@hey-api/openapi-ts 0.80.18 → 0.81.1

package/dist/clients/fetch/utils.ts

@@ -1,97 +1,14 @@
 import { getAuthToken } from '../core/auth';
-import type {
-  QuerySerializer,
-  QuerySerializerOptions,
-} from '../core/bodySerializer';
+import type { QuerySerializerOptions } from '../core/bodySerializer';
 import { jsonBodySerializer } from '../core/bodySerializer';
 import {
   serializeArrayParam,
   serializeObjectParam,
   serializePrimitiveParam,
 } from '../core/pathSerializer';
+import { getUrl } from '../core/utils';
 import type { Client, ClientOptions, Config, RequestOptions } from './types';
 
-interface PathSerializer {
-  path: Record<string, unknown>;
-  url: string;
-}
-
-const PATH_PARAM_RE = /\{[^{}]+\}/g;
-
-type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
-type MatrixStyle = 'label' | 'matrix' | 'simple';
-type ArraySeparatorStyle = ArrayStyle | MatrixStyle;
-
-const defaultPathSerializer = ({ path, url: _url }: PathSerializer) => {
-  let url = _url;
-  const matches = _url.match(PATH_PARAM_RE);
-  if (matches) {
-    for (const match of matches) {
-      let explode = false;
-      let name = match.substring(1, match.length - 1);
-      let style: ArraySeparatorStyle = 'simple';
-
-      if (name.endsWith('*')) {
-        explode = true;
-        name = name.substring(0, name.length - 1);
-      }
-
-      if (name.startsWith('.')) {
-        name = name.substring(1);
-        style = 'label';
-      } else if (name.startsWith(';')) {
-        name = name.substring(1);
-        style = 'matrix';
-      }
-
-      const value = path[name];
-
-      if (value === undefined || value === null) {
-        continue;
-      }
-
-      if (Array.isArray(value)) {
-        url = url.replace(
-          match,
-          serializeArrayParam({ explode, name, style, value }),
-        );
-        continue;
-      }
-
-      if (typeof value === 'object') {
-        url = url.replace(
-          match,
-          serializeObjectParam({
-            explode,
-            name,
-            style,
-            value: value as Record<string, unknown>,
-            valueOnly: true,
-          }),
-        );
-        continue;
-      }
-
-      if (style === 'matrix') {
-        url = url.replace(
-          match,
-          `;${serializePrimitiveParam({
-            name,
-            value: value as string,
-          })}`,
-        );
-        continue;
-      }
-
-      const replaceValue = encodeURIComponent(
-        style === 'label' ? `.${value as string}` : (value as string),
-      );
-      url = url.replace(match, replaceValue);
-    }
-  }
-  return url;
-};
-
 export const createQuerySerializer = <T = unknown>({
   allowReserved,
   array,
@@ -243,8 +160,8 @@ export const setAuthParams = async ({
   }
 };
 
-export const buildUrl: Client['buildUrl'] = (options) => {
-  const url = getUrl({
+export const buildUrl: Client['buildUrl'] = (options) =>
+  getUrl({
     baseUrl: options.baseUrl as string,
     path: options.path,
     query: options.query,
@@ -254,36 +171,6 @@ export const buildUrl: Client['buildUrl'] = (options) => {
         : createQuerySerializer(options.querySerializer),
     url: options.url,
   });
-  return url;
-};
-
-export const getUrl = ({
-  baseUrl,
-  path,
-  query,
-  querySerializer,
-  url: _url,
-}: {
-  baseUrl?: string;
-  path?: Record<string, unknown>;
-  query?: Record<string, unknown>;
-  querySerializer: QuerySerializer;
-  url: string;
-}) => {
-  const pathUrl = _url.startsWith('/') ? _url : `/${_url}`;
-  let url = (baseUrl ?? '') + pathUrl;
-  if (path) {
-    url = defaultPathSerializer({ path, url });
-  }
-  let search = query ? querySerializer(query) : '';
-  if (search.startsWith('?')) {
-    search = search.substring(1);
-  }
-  if (search) {
-    url += `?${search}`;
-  }
-  return url;
-};
 
 export const mergeConfigs = (a: Config, b: Config): Config => {
   const config = { ...a, ...b };

package/dist/clients/next/client.ts

@@ -1,4 +1,11 @@
-import type { Client, Config, ResolvedRequestOptions } from './types';
+import { createSseClient } from '../core/serverSentEvents';
+import type { HttpMethod } from '../core/types';
+import type {
+  Client,
+  Config,
+  RequestOptions,
+  ResolvedRequestOptions,
+} from './types';
 import {
   buildUrl,
   createConfig,
@@ -30,8 +37,7 @@ export const createClient = (config: Config = {}): Client => {
     ResolvedRequestOptions
   >();
 
-  // @ts-expect-error
-  const request: Client['request'] = async (options) => {
+  const beforeRequest = async (options: RequestOptions) => {
     const opts = {
       ..._config,
       ...options,
@@ -60,13 +66,22 @@ export const createClient = (config: Config = {}): Client => {
       opts.headers.delete('Content-Type');
     }
 
+    const url = buildUrl(opts);
+
+    return { opts, url };
+  };
+
+  // @ts-expect-error
+  const request: Client['request'] = async (options) => {
+    // @ts-expect-error
+    const { opts, url } = await beforeRequest(options);
+
     for (const fn of interceptors.request._fns) {
       if (fn) {
         await fn(opts);
       }
     }
 
-    const url = buildUrl(opts);
     // fetch must be assigned here, otherwise it would throw the error:
     // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
     const _fetch = opts.fetch!;
@@ -163,20 +178,47 @@ export const createClient = (config: Config = {}): Client => {
     };
   };
 
+  const makeMethodFn =
+    (method: Uppercase<HttpMethod>) => (options: RequestOptions) =>
+      request({ ...options, method });
+
+  const makeSseFn =
+    (method: Uppercase<HttpMethod>) => async (options: RequestOptions) => {
+      const { opts, url } = await beforeRequest(options);
+      return createSseClient({
+        ...opts,
+        body: opts.body as BodyInit | null | undefined,
+        headers: opts.headers as unknown as Record<string, string>,
+        method,
+        url,
+      });
+    };
+
   return {
     buildUrl,
-    connect: (options) => request({ ...options, method: 'CONNECT' }),
-    delete: (options) => request({ ...options, method: 'DELETE' }),
-    get: (options) => request({ ...options, method: 'GET' }),
+    connect: makeMethodFn('CONNECT'),
+    delete: makeMethodFn('DELETE'),
+    get: makeMethodFn('GET'),
     getConfig,
-    head: (options) => request({ ...options, method: 'HEAD' }),
+    head: makeMethodFn('HEAD'),
     interceptors,
-    options: (options) => request({ ...options, method: 'OPTIONS' }),
-    patch: (options) => request({ ...options, method: 'PATCH' }),
-    post: (options) => request({ ...options, method: 'POST' }),
-    put: (options) => request({ ...options, method: 'PUT' }),
+    options: makeMethodFn('OPTIONS'),
+    patch: makeMethodFn('PATCH'),
+    post: makeMethodFn('POST'),
+    put: makeMethodFn('PUT'),
     request,
     setConfig,
-    trace: (options) => request({ ...options, method: 'TRACE' }),
-  };
+    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;
 };

package/dist/clients/next/types.ts

@@ -1,4 +1,8 @@
 import type { Auth } from '../core/auth';
+import type {
+  ServerSentEventsOptions,
+  ServerSentEventsResult,
+} from '../core/serverSentEvents';
 import type {
   Client as CoreClient,
   Config as CoreConfig,
@@ -44,11 +48,20 @@ export interface Config<T extends ClientOptions = ClientOptions>
 }
 
 export interface RequestOptions<
+  TData = unknown,
   ThrowOnError extends boolean = boolean,
   Url extends string = string,
 > extends Config<{
-    throwOnError: ThrowOnError;
-  }> {
+      throwOnError: ThrowOnError;
+    }>,
+    Pick<
+      ServerSentEventsOptions<TData>,
+      | 'onSseError'
+      | 'onSseEvent'
+      | 'sseDefaultRetryDelay'
+      | 'sseMaxRetryAttempts'
+      | 'sseMaxRetryDelay'
+    > {
   /**
    * Any body that you want to add to your request.
    *
@@ -67,7 +80,7 @@ export interface RequestOptions<
 export interface ResolvedRequestOptions<
   ThrowOnError extends boolean = boolean,
   Url extends string = string,
-> extends RequestOptions<ThrowOnError, Url> {
+> extends RequestOptions<unknown, ThrowOnError, Url> {
   serializedBody?: string;
 }
 
@@ -109,16 +122,24 @@ type MethodFn = <
   TError = unknown,
   ThrowOnError extends boolean = false,
 >(
-  options: Omit<RequestOptions<ThrowOnError>, 'method'>,
+  options: Omit<RequestOptions<TData, ThrowOnError>, 'method'>,
 ) => RequestResult<TData, TError, ThrowOnError>;
 
+type SseFn = <
+  TData = unknown,
+  TError = unknown,
+  ThrowOnError extends boolean = false,
+>(
+  options: Omit<RequestOptions<TData, ThrowOnError>, 'method'>,
+) => Promise<ServerSentEventsResult<TData, TError>>;
+
 type RequestFn = <
   TData = unknown,
   TError = unknown,
   ThrowOnError extends boolean = false,
 >(
-  options: Omit<RequestOptions<ThrowOnError>, 'method'> &
-    Pick<Required<RequestOptions<ThrowOnError>>, 'method'>,
+  options: Omit<RequestOptions<TData, ThrowOnError>, 'method'> &
+    Pick<Required<RequestOptions<TData, ThrowOnError>>, 'method'>,
 ) => RequestResult<TData, TError, ThrowOnError>;
 
 type BuildUrlFn = <
@@ -132,7 +153,13 @@ type BuildUrlFn = <
   options: Pick<TData, 'url'> & Options<TData>,
 ) => string;
 
-export type Client = CoreClient<RequestFn, Config, MethodFn, BuildUrlFn> & {
+export type Client = CoreClient<
+  RequestFn,
+  Config,
+  MethodFn,
+  BuildUrlFn,
+  SseFn
+> & {
   interceptors: Middleware<Response, unknown, ResolvedRequestOptions>;
 };
 
@@ -161,7 +188,11 @@ type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
 export type Options<
   TData extends TDataShape = TDataShape,
   ThrowOnError extends boolean = boolean,
-> = OmitKeys<RequestOptions<ThrowOnError>, 'body' | 'path' | 'query' | 'url'> &
+  TResponse = unknown,
+> = OmitKeys<
+  RequestOptions<TResponse, ThrowOnError>,
+  'body' | 'path' | 'query' | 'url'
+> &
   Omit<TData, 'url'>;
 
 export type OptionsLegacyParser<
@@ -169,12 +200,16 @@ export type OptionsLegacyParser<
   ThrowOnError extends boolean = boolean,
 > = TData extends { body?: any }
   ? TData extends { headers?: any }
-    ? OmitKeys<RequestOptions<ThrowOnError>, 'body' | 'headers' | 'url'> & TData
-    : OmitKeys<RequestOptions<ThrowOnError>, 'body' | 'url'> &
+    ? OmitKeys<
+        RequestOptions<unknown, ThrowOnError>,
+        'body' | 'headers' | 'url'
+      > &
+        TData
+    : OmitKeys<RequestOptions<unknown, ThrowOnError>, 'body' | 'url'> &
         TData &
-        Pick<RequestOptions<ThrowOnError>, 'headers'>
+        Pick<RequestOptions<unknown, ThrowOnError>, 'headers'>
   : TData extends { headers?: any }
-    ? OmitKeys<RequestOptions<ThrowOnError>, 'headers' | 'url'> &
+    ? OmitKeys<RequestOptions<unknown, ThrowOnError>, 'headers' | 'url'> &
         TData &
-        Pick<RequestOptions<ThrowOnError>, 'body'>
-    : OmitKeys<RequestOptions<ThrowOnError>, 'url'> & TData;
+        Pick<RequestOptions<unknown, ThrowOnError>, 'body'>
+    : OmitKeys<RequestOptions<unknown, ThrowOnError>, 'url'> & TData;

package/dist/clients/nuxt/client.ts

@@ -6,7 +6,9 @@ import {
 } from 'nuxt/app';
 import { reactive, ref, watch } from 'vue';
 
-import type { Client, Config } from './types';
+import { createSseClient } from '../core/serverSentEvents';
+import type { HttpMethod } from '../core/types';
+import type { Client, Config, RequestOptions } from './types';
 import {
   buildUrl,
   createConfig,
@@ -16,6 +18,7 @@ import {
   mergeInterceptors,
   serializeBody,
   setAuthParams,
+  unwrapRefs,
 } from './utils';
 
 export const createClient = (config: Config = {}): Client => {
@@ -28,6 +31,32 @@ export const createClient = (config: Config = {}): Client => {
     return getConfig();
   };
 
+  const beforeRequest = async (options: RequestOptions) => {
+    const opts = {
+      ..._config,
+      ...options,
+      $fetch: options.$fetch ?? _config.$fetch ?? $fetch,
+      headers: mergeHeaders(_config.headers, options.headers),
+      onRequest: mergeInterceptors(_config.onRequest, options.onRequest),
+      onResponse: mergeInterceptors(_config.onResponse, options.onResponse),
+    };
+
+    if (opts.security) {
+      await setAuthParams({
+        ...opts,
+        security: opts.security,
+      });
+    }
+
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+
+    const url = buildUrl(opts);
+
+    return { opts, url };
+  };
+
   const request: Client['request'] = ({
     asyncDataOptions,
     composable,
@@ -107,7 +136,11 @@ export const createClient = (config: Config = {}): Client => {
     const fetchFn = opts.$fetch;
 
     if (composable === '$fetch') {
-      return executeFetchFn(opts, fetchFn);
+      return executeFetchFn(
+        // @ts-expect-error
+        opts,
+        fetchFn,
+      );
     }
 
     if (composable === 'useFetch' || composable === 'useLazyFetch') {
@@ -126,7 +159,12 @@ export const createClient = (config: Config = {}): Client => {
         : useFetch(() => buildUrl(opts), opts);
     }
 
-    const handler: any = () => executeFetchFn(opts, fetchFn);
+    const handler: any = () =>
+      executeFetchFn(
+        // @ts-expect-error
+        opts,
+        fetchFn,
+      );
 
     if (composable === 'useAsyncData') {
       return key
@@ -143,19 +181,46 @@ export const createClient = (config: Config = {}): Client => {
     return undefined as any;
   };
 
+  const makeMethodFn =
+    (method: Uppercase<HttpMethod>) => (options: RequestOptions) =>
+      request({ ...options, method });
+
+  const makeSseFn =
+    (method: Uppercase<HttpMethod>) => async (options: RequestOptions) => {
+      const { opts, url } = await beforeRequest(options);
+      return createSseClient({
+        ...unwrapRefs(opts),
+        body: opts.body as BodyInit | null | undefined,
+        method,
+        signal: unwrapRefs(opts.signal) as AbortSignal,
+        url,
+      });
+    };
+
   return {
     buildUrl,
-    connect: (options) => request({ ...options, method: 'CONNECT' }),
-    delete: (options) => request({ ...options, method: 'DELETE' }),
-    get: (options) => request({ ...options, method: 'GET' }),
+    connect: makeMethodFn('CONNECT'),
+    delete: makeMethodFn('DELETE'),
+    get: makeMethodFn('GET'),
     getConfig,
-    head: (options) => request({ ...options, method: 'HEAD' }),
-    options: (options) => request({ ...options, method: 'OPTIONS' }),
-    patch: (options) => request({ ...options, method: 'PATCH' }),
-    post: (options) => request({ ...options, method: 'POST' }),
-    put: (options) => request({ ...options, method: 'PUT' }),
+    head: makeMethodFn('HEAD'),
+    options: makeMethodFn('OPTIONS'),
+    patch: makeMethodFn('PATCH'),
+    post: makeMethodFn('POST'),
+    put: makeMethodFn('PUT'),
     request,
     setConfig,
-    trace: (options) => request({ ...options, method: 'TRACE' }),
-  };
+    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;
 };

package/dist/clients/nuxt/types.ts

@@ -10,6 +10,10 @@ import type { Ref } from 'vue';
 
 import type { Auth } from '../core/auth';
 import type { QuerySerializerOptions } from '../core/bodySerializer';
+import type {
+  ServerSentEventsOptions,
+  ServerSentEventsResult,
+} from '../core/serverSentEvents';
 import type {
   Client as CoreClient,
   Config as CoreConfig,
@@ -73,7 +77,15 @@ export interface RequestOptions<
       path?: FetchOptions<unknown>['query'];
       query?: FetchOptions<unknown>['query'];
       rawBody?: unknown;
-    }> {
+    }>,
+    Pick<
+      ServerSentEventsOptions<ResT>,
+      | 'onSseError'
+      | 'onSseEvent'
+      | 'sseDefaultRetryDelay'
+      | 'sseMaxRetryAttempts'
+      | 'sseMaxRetryDelay'
+    > {
   asyncDataOptions?: AsyncDataOptions<ResT, ResT, KeysOf<ResT>, DefaultT>;
   composable: TComposable;
   key?: string;
@@ -113,6 +125,15 @@ type MethodFn = <
   options: Omit<RequestOptions<TComposable, ResT, DefaultT>, 'method'>,
 ) => RequestResult<TComposable, ResT, TError>;
 
+type SseFn = <
+  TComposable extends Composable,
+  ResT = unknown,
+  TError = unknown,
+  DefaultT = undefined,
+>(
+  options: Omit<RequestOptions<TComposable, ResT, DefaultT>, 'method'>,
+) => Promise<ServerSentEventsResult<RequestResult<TComposable, ResT, TError>>>;
+
 type RequestFn = <
   TComposable extends Composable,
   ResT = unknown,
@@ -153,7 +174,7 @@ type BuildUrlFn = <TData extends Omit<TDataShape, 'headers'>>(
   options: BuildUrlOptions<TData>,
 ) => string;
 
-export type Client = CoreClient<RequestFn, Config, MethodFn, BuildUrlFn>;
+export type Client = CoreClient<RequestFn, Config, MethodFn, BuildUrlFn, SseFn>;
 
 type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
 

package/dist/clients/nuxt/utils.ts

@@ -334,7 +334,7 @@ type UnwrapRefs<T> =
         ? { [K in keyof T]: UnwrapRefs<T[K]> }
         : T;
 
-const unwrapRefs = <T>(value: T): UnwrapRefs<T> => {
+export const unwrapRefs = <T>(value: T): UnwrapRefs<T> => {
   if (value === null || typeof value !== 'object' || value instanceof Headers) {
     return (isRef(value) ? unref(value) : value) as UnwrapRefs<T>;
   }