OpenAPI TypeScript Client Generator

/**
 * Generated from an OpenAPI document. No runtime dependencies — uses fetch.
 *
 * Anything the generator could not resolve is typed `unknown` rather than
 * `any`, so the compiler still makes you handle it.
 */

export type RequestOptions = {
  /** Base URL, without a trailing slash. */
  baseUrl?: string;
  headers?: Record<string, string>;
  signal?: AbortSignal;
};

export class ApiError extends Error {
  constructor(
    readonly status: number,
    readonly statusText: string,
    readonly body: unknown,
  ) {
    super(`${status} ${statusText}`);
    this.name = "ApiError";
  }
}

function buildQuery(params: Record<string, unknown>): string {
  const search = new URLSearchParams();
  for (const [key, value] of Object.entries(params)) {
    if (value === undefined || value === null) continue;
    if (Array.isArray(value)) {
      for (const item of value) search.append(key, String(item));
    } else {
      search.set(key, String(value));
    }
  }
  const query = search.toString();
  return query ? `?${query}` : "";
}

async function request<T>(
  method: string,
  url: string,
  options: RequestOptions,
  body?: unknown,
): Promise<T> {
  const response = await fetch(`${options.baseUrl ?? ""}${url}`, {
    method,
    headers: {
      ...(body === undefined ? {} : { "Content-Type": "application/json" }),
      ...options.headers,
    },
    body: body === undefined ? undefined : JSON.stringify(body),
    signal: options.signal,
  });

  // fetch resolves for 4xx and 5xx, so this check is the one thing every
  // hand-written client forgets.
  if (!response.ok) {
    const text = await response.text();
    let parsed: unknown = text;
    try {
      parsed = text ? JSON.parse(text) : undefined;
    } catch {
      /* keep the raw text */
    }
    throw new ApiError(response.status, response.statusText, parsed);
  }

  if (response.status === 204) return undefined as T;
  const text = await response.text();
  return (text ? JSON.parse(text) : undefined) as T;
}

// ------------------------------ schemas ------------------------------

export type Pet = {
  id: number;
  name: string;
  tag?: string;
  status?: "available" | "pending" | "sold";
};

export type NewPet = {
  name: string;
  tag?: string;
};

// ----------------------------- operations -----------------------------

/**
 * List all pets
 *
 * GET /pets
 */
export async function listPets(query: { limit?: number; status: "available" | "pending" | "sold" }, options: RequestOptions = {}): Promise<Pet[]> {
  return request<Pet[]>("GET", `/pets${buildQuery(query)}`, options);
}

/**
 * Add a pet
 *
 * POST /pets
 */
export async function createPet(body: NewPet, options: RequestOptions = {}): Promise<Pet> {
  return request<Pet>("POST", `/pets`, options, body);
}

export async function getPet(petId: string, options: RequestOptions = {}): Promise<Pet> {
  return request<Pet>("GET", `/pets/${encodeURIComponent(String(petId))}`, options);
}

export async function deletePet(petId: string, options: RequestOptions = {}): Promise<void> {
  return request<void>("DELETE", `/pets/${encodeURIComponent(String(petId))}`, options);
}