reatomFetch

index.ts

export type UrlSearchParamsInit = ConstructorParameters<
  typeof URLSearchParams
>[0];

export interface FetchRequestInit<
  Result = unknown,
  Params = unknown,
  Body = unknown
> extends RequestInit {
  url?: string | URL;
  origin?: string;
  transport?: typeof globalThis.fetch;
  getResult?: (response: Response) => Result | Promise<Result>;
  getParams?: (params: Params) => UrlSearchParamsInit;
  getBody?: (body: Body) => BodyInit;
}

export class FetchRequest<
  Result = unknown,
  Params = void,
  Body = void
> extends Request {
  static defaults = {
    origin: globalThis.location?.toString(),
    transport: globalThis.fetch,
    method: "get",
    headers: { Accept: "application/json" },
    getResult(response) {
      if (Math.floor(response.status / 100) - 2) {
        throw new Error(
          `HTTP Error: ${response.statusText ?? response.status}`
        );
      }
      const ct = response.headers.get("Content-Type");

      if (ct !== "application/json") {
        throw new Error(
          `Expected Content-Type to be "application/json", got "${ct}"`
        );
      }
      return response.json();
    },
    getParams: (x) => x as UrlSearchParamsInit,
    getBody: (body) =>
      body &&
      typeof body === "object" &&
      Reflect.getPrototypeOf(body) &&
      !Array.isArray(body)
        ? (body as BodyInit)
        : JSON.stringify(body),
  } satisfies FetchRequestInit;

  init: Required<FetchRequestInit<Result, Params, Body>>;

  constructor(init: FetchRequestInit<Result, Params, Body>) {
    Object.assign(init, FetchRequest.defaults, init);
    const url = new URL(init.origin!, init.origin);
    super(url, init);
    // FIXME prefill the init
    this.init = init;
  }

  clone(): FetchRequest<Result, Params, Body> {
    return new FetchRequest(this.init);
  }

  fetch(options: Params & Body): Promise<Response> {
    const { transport, getParams, getBody, getResult, ...init } = this.init;

    const url = new URL(init.url);

    for (const [key, value] of new URLSearchParams(getParams(options))) {
      url.searchParams.set(key, value);
    }

    init.body ??= getBody(options);

    return transport(url, init).then(getResult);
  }
}

fetch('', {signal})