@hey-api/openapi-ts 0.80.17 → 0.81.0

package/dist/clients/next/client.ts

@@ -1,4 +1,10 @@
-import type { Client, Config, ResolvedRequestOptions } from './types';
+import { createSseClient } from '../core/serverSentEvents';
+import type {
+  Client,
+  Config,
+  RequestOptions,
+  ResolvedRequestOptions,
+} from './types';
 import {
   buildUrl,
   createConfig,
@@ -30,8 +36,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 +65,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 +177,35 @@ export const createClient = (config: Config = {}): Client => {
     };
   };
 
+  const makeMethod = (method: Required<Config>['method']) => {
+    const fn = (options: RequestOptions) => request({ ...options, method });
+    fn.sse = 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 fn;
+  };
+
   return {
     buildUrl,
-    connect: (options) => request({ ...options, method: 'CONNECT' }),
-    delete: (options) => request({ ...options, method: 'DELETE' }),
-    get: (options) => request({ ...options, method: 'GET' }),
+    connect: makeMethod('CONNECT'),
+    delete: makeMethod('DELETE'),
+    get: makeMethod('GET'),
     getConfig,
-    head: (options) => request({ ...options, method: 'HEAD' }),
+    head: makeMethod('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: makeMethod('OPTIONS'),
+    patch: makeMethod('PATCH'),
+    post: makeMethod('POST'),
+    put: makeMethod('PUT'),
     request,
     setConfig,
-    trace: (options) => request({ ...options, method: 'TRACE' }),
-  };
+    trace: makeMethod('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;
 }
 
@@ -104,21 +117,33 @@ export interface ClientOptions {
   throwOnError?: boolean;
 }
 
-type MethodFn = <
+type MethodFnBase = <
   TData = unknown,
   TError = unknown,
   ThrowOnError extends boolean = false,
 >(
-  options: Omit<RequestOptions<ThrowOnError>, 'method'>,
+  options: Omit<RequestOptions<TData, ThrowOnError>, 'method'>,
 ) => RequestResult<TData, TError, ThrowOnError>;
 
+type MethodFnServerSentEvents = <
+  TData = unknown,
+  TError = unknown,
+  ThrowOnError extends boolean = false,
+>(
+  options: Omit<RequestOptions<TData, ThrowOnError>, 'method'>,
+) => Promise<ServerSentEventsResult<TData, TError>>;
+
+type MethodFn = MethodFnBase & {
+  sse: MethodFnServerSentEvents;
+};
+
 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 = <
@@ -161,7 +186,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 +198,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,8 @@ import {
 } from 'nuxt/app';
 import { reactive, ref, watch } from 'vue';
 
-import type { Client, Config } from './types';
+import { createSseClient } from '../core/serverSentEvents';
+import type { Client, Config, RequestOptions } from './types';
 import {
   buildUrl,
   createConfig,
@@ -16,6 +17,7 @@ import {
   mergeInterceptors,
   serializeBody,
   setAuthParams,
+  unwrapRefs,
 } from './utils';
 
 export const createClient = (config: Config = {}): Client => {
@@ -28,6 +30,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 +135,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 +158,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 +180,34 @@ export const createClient = (config: Config = {}): Client => {
     return undefined as any;
   };
 
+  const makeMethod = (method: Required<Config>['method']) => {
+    const fn = (options: RequestOptions) => request({ ...options, method });
+    fn.sse = 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 fn;
+  };
+
   return {
     buildUrl,
-    connect: (options) => request({ ...options, method: 'CONNECT' }),
-    delete: (options) => request({ ...options, method: 'DELETE' }),
-    get: (options) => request({ ...options, method: 'GET' }),
+    connect: makeMethod('CONNECT'),
+    delete: makeMethod('DELETE'),
+    get: makeMethod('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: makeMethod('HEAD'),
+    options: makeMethod('OPTIONS'),
+    patch: makeMethod('PATCH'),
+    post: makeMethod('POST'),
+    put: makeMethod('PUT'),
     request,
     setConfig,
-    trace: (options) => request({ ...options, method: 'TRACE' }),
-  };
+    trace: makeMethod('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;
@@ -104,7 +116,7 @@ export interface ClientOptions {
   baseURL?: string;
 }
 
-type MethodFn = <
+type MethodFnBase = <
   TComposable extends Composable,
   ResT = unknown,
   TError = unknown,
@@ -113,6 +125,19 @@ type MethodFn = <
   options: Omit<RequestOptions<TComposable, ResT, DefaultT>, 'method'>,
 ) => RequestResult<TComposable, ResT, TError>;
 
+type MethodFnServerSentEvents = <
+  TComposable extends Composable,
+  ResT = unknown,
+  TError = unknown,
+  DefaultT = undefined,
+>(
+  options: Omit<RequestOptions<TComposable, ResT, DefaultT>, 'method'>,
+) => Promise<ServerSentEventsResult<RequestResult<TComposable, ResT, TError>>>;
+
+type MethodFn = MethodFnBase & {
+  sse: MethodFnServerSentEvents;
+};
+
 type RequestFn = <
   TComposable extends Composable,
   ResT = unknown,

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>;
   }