ky-http-client.ejs

<%
const { apiConfig, generateResponses, config } = it;
%>

import type { KyInstance, Options as KyOptions, SearchParamsOption } from "ky";
import ky from "ky";

type KyResponse<Data> = Response & {
  json<T extends Data = Data>(): Promise<T>;
}

export type ResponsePromise<Data> = {
    arrayBuffer: () => Promise<ArrayBuffer>;
    blob: () => Promise<Blob>;
    formData: () => Promise<FormData>;
    json<T extends Data = Data>(): Promise<T>;
    text: () => Promise<string>;
} & Promise<KyResponse<Data>>;

export type ResponseFormat = keyof Omit<Body, "body" | "bodyUsed">;

export interface FullRequestParams extends Omit<KyOptions, "json" | "body" | "searchParams"> {
  /** request path */
  path: string;
  /** content type of request body */
  type?: ContentType;
  /** query params */
  query?: SearchParamsOption;
  /** format of response (i.e. response.json() -> format: "json") */
  format?: ResponseFormat;
  /** request body */
  body?: unknown;
}

export type RequestParams = Omit<FullRequestParams, "body" | "method" | "query" | "path">;

export interface ApiConfig<SecurityDataType = unknown> extends Omit<KyOptions, "data" | "cancelToken"> {
  format?: ResponseType;
}

export enum ContentType {
  Json = "application/json",
  FormData = "multipart/form-data",
  UrlEncoded = "application/x-www-form-urlencoded",
  Text = "text/plain",
}

export class HttpClient<SecurityDataType = unknown> {
    public ky: KyInstance;
    private format?: ResponseType;

    constructor({ format, ...options }: ApiConfig<SecurityDataType> = {}) {
        this.ky = ky.create({ ...options, prefixUrl: options.prefixUrl || "<%~ apiConfig.baseUrl %>" })
        this.format = format;
    }

    protected stringifyFormItem(formItem: unknown) {
      if (typeof formItem === "object" && formItem !== null) {
        return JSON.stringify(formItem);
      } else {
        return `${formItem}`;
      }
    }

    protected createFormData(input: Record<string, unknown>): FormData {
      return Object.keys(input || {}).reduce((formData, key) => {
        const property = input[key];
        const propertyContent: any[] = (property instanceof Array) ? property : [property]

        for (const formItem of propertyContent) {
          const isFileType = formItem instanceof Blob || formItem instanceof File;
          formData.append(
            key,
            isFileType ? formItem : this.stringifyFormItem(formItem)
            );
        }

        return formData;
      }, new FormData());
    }

    public request = <T = any, _E = any>({
        path,
        type,
        query,
        format,
        body,
        ...options
<% if (config.unwrapResponseData) { %>
    }: FullRequestParams): Promise<T> => {
<% } else { %>
    }: FullRequestParams): ResponsePromise<T> => {
<% } %>
        if (body) {
          if (type === ContentType.FormData) {
            body = typeof body === "object" ? this.createFormData(body as Record<string, unknown>) : body;
          } else if (type === ContentType.Text) {
            body = typeof body !== "string" ? JSON.stringify(body) : body;
          }
        }

        let headers: Headers | Record<string, string | undefined> | undefined;
        if (options.headers instanceof Headers) {
          headers = new Headers(options.headers);
          if (type && type !== ContentType.FormData) {
            headers.set('Content-Type', type);
          }
        } else {
          headers = { ...options.headers } as Record<string, string | undefined>;
          if (type && type !== ContentType.FormData) {
            headers['Content-Type'] = type;
          }
        }

        const request = this.ky(path, {
          ...options,
          headers,
          searchParams: query,
          body: body as any,
        });

<% if (config.unwrapResponseData) { %>
        const responseFormat = (format || this.format) || undefined;
        return responseFormat === "json"
          ? request.json()
          : responseFormat === "arrayBuffer"
          ? request.arrayBuffer()
          : responseFormat === "blob"
          ? request.blob()
          : responseFormat === "formData"
          ? request.formData()
          : request.text();
<% } else { %>
        return request;
<% } %>
    };
}