Mini Api Builder

ApiBuilder.ts

type URLSearchParamsInit = ConstructorParameters<typeof URLSearchParams>[0];
type ApiFormatMap = {
  arrayBuffer: ArrayBuffer;
  text: string;
  json: object;
  formData: FormData;
  blob: Blob;
  stream: ReadableStream<Uint8Array>;
  response: Response;
};
type ApiFormat = keyof ApiFormatMap;
type ApiResponseType<T extends ApiFormat> = {
  responseType?: T;
};
type ApiQuery = {
  query?: URLSearchParamsInit;
};
type ApiDefaults<T extends ApiFormat> = RequestInit & ApiResponseType<T> & ApiQuery;
type ApiCallOptions<T extends ApiFormat> = RequestInit & ApiResponseType<T> & ApiQuery;

type ApiBuilder<T extends ApiFormat> = {
  [key: string]: ApiBuilder<T>;
  (firstArg: string | number, ...extraPaths: (string | number)[]): ApiBuilder<T>;
  (): Promise<ApiFormatMap[T]>;
  <O extends ApiFormat = T>(callOptions: ApiCallOptions<O>): Promise<ApiFormatMap[O]>;
};

export function createApi<T extends ApiFormat = 'response'>(
  url: string,
  defaults?: ApiDefaults<T>,
): ApiBuilder<T> {
  const internalTarget = (() => {}) as unknown as ApiBuilder<T>;
  const responseModifier = (callOptions?: ApiCallOptions<ApiFormat>) => {
    const responseType: ApiFormat | undefined = callOptions?.responseType ?? defaults?.responseType;
    switch (responseType) {
      case 'json':
        return (res: Response) => res.json();
      case 'text':
        return (res: Response) => res.text();
      case 'arrayBuffer':
        return (res: Response) => res.arrayBuffer();
      case 'formData':
        return (res: Response) => res.formData();
      case 'blob':
        return (res: Response) => res.blob();
      case 'stream':
        return (res: Response) => res.body;
      case 'response':
      default:
        return (res: Response) => res;
    }
  };
  const parseUrl = (callOptions?: ApiCallOptions<ApiFormat>): string => {
    const parsedUrl: URL = new URL(url);

    if (!!defaults?.query) {
      new URLSearchParams(defaults.query).forEach((value, key) =>
        parsedUrl.searchParams.set(key, value),
      );
    }
    if (!!callOptions?.query) {
      new URLSearchParams(callOptions.query).forEach((value, key) =>
        parsedUrl.searchParams.set(key, value),
      );
    }
    return parsedUrl.toString();
  };
  const parseHeadersInit = (callHeaders?: HeadersInit): Headers | HeadersInit | undefined => {
    if (!defaults?.headers) {
      return callHeaders;
    }
    if (!callHeaders) {
      return defaults.headers;
    }
    const headers = new Headers(defaults.headers);
    for (const [name, value] of new Headers(callHeaders)) {
      headers.set(name, value);
    }
    return headers;
  };
  const parseRequestInit = (callOptions?: ApiCallOptions<ApiFormat>): RequestInit | undefined => {
    if (!defaults) {
      if (!callOptions) return;
      const { query: _1, responseType: _2, ...requestInit } = callOptions;
      return requestInit;
    }
    if (!callOptions) {
      const { query: _1, responseType: _2, ...requestInit } = defaults;
      return requestInit;
    }
    const { query: _1, responseType: _2, ...requestInitOptions } = callOptions;
    const { query: _3, responseType: _4, ...requestInitDefaults } = defaults;
    const headers = parseHeadersInit(callOptions.headers);

    return {
      ...requestInitDefaults,
      ...requestInitOptions,
      headers,
    };
  };
  const p = (url: string): ApiBuilder<T> =>
    new Proxy(internalTarget, {
      get(_target, key: string) {
        return p(`${url}/${key}`);
      },
      apply(_target, _thisArg, args: (string | number | ApiCallOptions<ApiFormat>)[]) {
        // () => Promise<T>
        if (args.length === 0) {
          const modifier = responseModifier();
          return fetch(parseUrl(), parseRequestInit()).then(modifier);
        }

        // (callOptions) => Promise<T or O>
        if (typeof args[0] === 'object' && args[0] !== null) {
          const options: ApiCallOptions<ApiFormat> = args[0];
          const modifier = responseModifier(options);
          return fetch(parseUrl(options), parseRequestInit(options)).then(modifier);
        }

        // (...paths) => ApiBuilder<T>
        return p(`${url}/${args.join('/')}`);
      },
    });
  return p(url);
}