feat(ofetch): init core client func & config

Author: brolnickij

packages/openapi-ts/src/plugins/@hey-api/client-ofetch/api.ts

@@ -0,0 +1,25 @@
+import type { ICodegenSymbolSelector } from '@hey-api/codegen-core';
+
+import type { Plugin } from '../../types';
+
+type SelectorType = 'client';
+
+export type IApi = {
+  /**
+   * @param type Selector type.
+   * @param value Depends on `type`:
+   *  - `client`: never
+   * @returns Selector array
+   */
+  getSelector: (type: SelectorType, value?: string) => ICodegenSymbolSelector;
+};
+
+export class Api implements IApi {
+  constructor(public meta: Plugin.Name<'@hey-api/client-ofetch'>) {}
+
+  getSelector(
+    ...args: ReadonlyArray<string | undefined>
+  ): ICodegenSymbolSelector {
+    return [this.meta.name, ...(args as ICodegenSymbolSelector)];
+  }
+}

packages/openapi-ts/src/plugins/@hey-api/client-ofetch/bundle/client.ts

@@ -0,0 +1,273 @@
+import { ofetch, type ResponseType as OfetchResponseType } from 'ofetch';
+
+import { createSseClient } from '../../client-core/bundle/serverSentEvents';
+import type { HttpMethod } from '../../client-core/bundle/types';
+import { getValidRequestBody } from '../../client-core/bundle/utils';
+import type {
+  Client,
+  Config,
+  RequestOptions,
+  ResolvedRequestOptions,
+} from './types';
+import {
+  buildOfetchOptions,
+  buildUrl,
+  createConfig,
+  createInterceptors,
+  isRepeatableBody,
+  mapParseAsToResponseType,
+  mergeConfigs,
+  mergeHeaders,
+  parseError,
+  parseSuccess,
+  setAuthParams,
+  wrapDataReturn,
+  wrapErrorReturn,
+} from './utils';
+
+type ReqInit = Omit<RequestInit, 'body' | 'headers'> & {
+  body?: BodyInit | null | undefined;
+  headers: ReturnType<typeof mergeHeaders>;
+};
+
+export const createClient = (config: Config = {}): Client => {
+  let _config = mergeConfigs(createConfig(), config);
+
+  const getConfig = (): Config => ({ ..._config });
+
+  const setConfig = (config: Config): Config => {
+    _config = mergeConfigs(_config, config);
+    return getConfig();
+  };
+
+  const interceptors = createInterceptors<
+    Request,
+    Response,
+    unknown,
+    ResolvedRequestOptions
+  >();
+
+  // Resolve final options, serialized body, network body and URL
+  const resolveOptions = async (options: RequestOptions) => {
+    const opts = {
+      ..._config,
+      ...options,
+      headers: mergeHeaders(_config.headers, options.headers),
+      serializedBody: undefined,
+    };
+
+    if (opts.security) {
+      await setAuthParams({
+        ...opts,
+        security: opts.security,
+      });
+    }
+
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+
+    if (opts.body !== undefined && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body);
+    }
+
+    // remove Content-Type header if body is empty to avoid sending invalid requests
+    if (opts.body === undefined || opts.serializedBody === '') {
+      opts.headers.delete('Content-Type');
+    }
+
+    // If user provides a raw body (no serializer), adjust Content-Type sensibly.
+    // Avoid overriding explicit user-defined headers; only correct the default JSON header.
+    if (
+      opts.body !== undefined &&
+      opts.bodySerializer === null &&
+      (opts.headers.get('Content-Type') || '').toLowerCase() ===
+        'application/json'
+    ) {
+      const b: unknown = opts.body;
+      if (typeof FormData !== 'undefined' && b instanceof FormData) {
+        // Let the runtime set proper boundary
+        opts.headers.delete('Content-Type');
+      } else if (
+        typeof URLSearchParams !== 'undefined' &&
+        b instanceof URLSearchParams
+      ) {
+        // Set standard urlencoded content type with charset
+        opts.headers.set(
+          'Content-Type',
+          'application/x-www-form-urlencoded;charset=UTF-8',
+        );
+      } else if (typeof Blob !== 'undefined' && b instanceof Blob) {
+        const t = b.type?.trim();
+        if (t) {
+          opts.headers.set('Content-Type', t);
+        } else {
+          // No known type for the blob: avoid sending misleading JSON header
+          opts.headers.delete('Content-Type');
+        }
+      }
+    }
+
+    // Precompute network body for retries and consistent handling
+    const networkBody = getValidRequestBody(opts) as
+      | RequestInit['body']
+      | null
+      | undefined;
+
+    const url = buildUrl(opts);
+
+    return { networkBody, opts, url };
+  };
+
+  // Apply request interceptors to a Request and reflect header/method/signal
+  const applyRequestInterceptors = async (
+    request: Request,
+    opts: ResolvedRequestOptions,
+  ) => {
+    for (const fn of interceptors.request.fns) {
+      if (fn) {
+        request = await fn(request, opts);
+      }
+    }
+    // Reflect any interceptor changes into opts used for network and downstream
+    opts.headers = request.headers;
+    opts.method = request.method as Uppercase<HttpMethod>;
+    // Note: we intentionally ignore request.body changes from interceptors to
+    // avoid turning serialized bodies into streams. Body is sourced solely
+    // from getValidRequestBody(options) for consistency.
+    // Attempt to reflect possible signal changes
+    opts.signal = (request as any).signal as AbortSignal | undefined;
+    return request;
+  };
+
+  // Build ofetch options with stable retry logic based on body repeatability
+  const buildNetworkOptions = (
+    opts: ResolvedRequestOptions,
+    body: BodyInit | null | undefined,
+    responseType: OfetchResponseType | undefined,
+  ) => {
+    const effectiveRetry = isRepeatableBody(body)
+      ? (opts.retry as any)
+      : (0 as any);
+    return buildOfetchOptions(opts, body, responseType, effectiveRetry);
+  };
+
+  const request: Client['request'] = async (options) => {
+    const {
+      networkBody: initialNetworkBody,
+      opts,
+      url,
+    } = await resolveOptions(options as any);
+    // Compute response type mapping once
+    const ofetchResponseType: OfetchResponseType | undefined =
+      mapParseAsToResponseType(opts.parseAs, opts.responseType);
+
+    const $ofetch = opts.ofetch ?? ofetch;
+
+    // Always create Request pre-network (align with client-fetch)
+    const networkBody = initialNetworkBody;
+    const requestInit: ReqInit = {
+      body: networkBody,
+      headers: opts.headers as Headers,
+      method: opts.method,
+      redirect: 'follow',
+      signal: opts.signal,
+    };
+    let request = new Request(url, requestInit);
+
+    request = await applyRequestInterceptors(request, opts);
+    const finalUrl = request.url;
+
+    // Build ofetch options and perform the request
+    const responseOptions = buildNetworkOptions(
+      opts as ResolvedRequestOptions,
+      networkBody,
+      ofetchResponseType,
+    );
+
+    let response = await $ofetch.raw(finalUrl, responseOptions);
+
+    for (const fn of interceptors.response.fns) {
+      if (fn) {
+        response = await fn(response, request, opts);
+      }
+    }
+
+    const result = { request, response };
+
+    if (response.ok) {
+      const data = await parseSuccess(response, opts, ofetchResponseType);
+      return wrapDataReturn(data, result, opts.responseStyle);
+    }
+
+    let finalError = await parseError(response);
+
+    for (const fn of interceptors.error.fns) {
+      if (fn) {
+        finalError = await fn(finalError, response, request, opts);
+      }
+    }
+
+    // Ensure error is never undefined after interceptors
+    finalError = (finalError as any) || ({} as string);
+
+    if (opts.throwOnError) {
+      throw finalError;
+    }
+
+    return wrapErrorReturn(finalError, result, opts.responseStyle) as any;
+  };
+
+  const makeMethodFn =
+    (method: Uppercase<HttpMethod>) => (options: RequestOptions) =>
+      request({ ...options, method } as any);
+
+  const makeSseFn =
+    (method: Uppercase<HttpMethod>) => async (options: RequestOptions) => {
+      const { networkBody, opts, url } = await resolveOptions(options);
+      const optsForSse: any = { ...opts };
+      delete optsForSse.body;
+      return createSseClient({
+        ...optsForSse,
+        fetch: opts.fetch,
+        headers: opts.headers as Headers,
+        method,
+        onRequest: async (url, init) => {
+          let request = new Request(url, init);
+          request = await applyRequestInterceptors(request, opts);
+          return request;
+        },
+        serializedBody: networkBody as BodyInit | null | undefined,
+        signal: opts.signal,
+        url,
+      });
+    };
+
+  return {
+    buildUrl,
+    connect: makeMethodFn('CONNECT'),
+    delete: makeMethodFn('DELETE'),
+    get: makeMethodFn('GET'),
+    getConfig,
+    head: makeMethodFn('HEAD'),
+    interceptors,
+    options: makeMethodFn('OPTIONS'),
+    patch: makeMethodFn('PATCH'),
+    post: makeMethodFn('POST'),
+    put: makeMethodFn('PUT'),
+    request,
+    setConfig,
+    sse: {
+      connect: makeSseFn('CONNECT'),
+      delete: makeSseFn('DELETE'),
+      get: makeSseFn('GET'),
+      head: makeSseFn('HEAD'),
+      options: makeSseFn('OPTIONS'),
+      patch: makeSseFn('PATCH'),
+      post: makeSseFn('POST'),
+      put: makeSseFn('PUT'),
+      trace: makeSseFn('TRACE'),
+    },
+    trace: makeMethodFn('TRACE'),
+  } as Client;
+};

packages/openapi-ts/src/plugins/@hey-api/client-ofetch/bundle/index.ts

@@ -0,0 +1,23 @@
+export type { Auth } from '../../client-core/bundle/auth';
+export type { QuerySerializerOptions } from '../../client-core/bundle/bodySerializer';
+export {
+  formDataBodySerializer,
+  jsonBodySerializer,
+  urlSearchParamsBodySerializer,
+} from '../../client-core/bundle/bodySerializer';
+export { buildClientParams } from '../../client-core/bundle/params';
+export { createClient } from './client';
+export type {
+  Client,
+  ClientOptions,
+  Config,
+  CreateClientConfig,
+  Options,
+  OptionsLegacyParser,
+  RequestOptions,
+  RequestResult,
+  ResolvedRequestOptions,
+  ResponseStyle,
+  TDataShape,
+} from './types';
+export { createConfig, mergeHeaders } from './utils';