+25

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

··· 1 1 + import type { ICodegenSymbolSelector } from '@hey-api/codegen-core'; 2 2 + 3 3 + import type { Plugin } from '../../types'; 4 4 + 5 5 + type SelectorType = 'client'; 6 6 + 7 7 + export type IApi = { 8 8 + /** 9 9 + * @param type Selector type. 10 10 + * @param value Depends on `type`: 11 11 + * - `client`: never 12 12 + * @returns Selector array 13 13 + */ 14 14 + getSelector: (type: SelectorType, value?: string) => ICodegenSymbolSelector; 15 15 + }; 16 16 + 17 17 + export class Api implements IApi { 18 18 + constructor(public meta: Plugin.Name<'@hey-api/client-ofetch'>) {} 19 19 + 20 20 + getSelector( 21 21 + ...args: ReadonlyArray<string | undefined> 22 22 + ): ICodegenSymbolSelector { 23 23 + return [this.meta.name, ...(args as ICodegenSymbolSelector)]; 24 24 + } 25 25 + }

+273

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

··· 1 1 + import { ofetch, type ResponseType as OfetchResponseType } from 'ofetch'; 2 2 + 3 3 + import { createSseClient } from '../../client-core/bundle/serverSentEvents'; 4 4 + import type { HttpMethod } from '../../client-core/bundle/types'; 5 5 + import { getValidRequestBody } from '../../client-core/bundle/utils'; 6 6 + import type { 7 7 + Client, 8 8 + Config, 9 9 + RequestOptions, 10 10 + ResolvedRequestOptions, 11 11 + } from './types'; 12 12 + import { 13 13 + buildOfetchOptions, 14 14 + buildUrl, 15 15 + createConfig, 16 16 + createInterceptors, 17 17 + isRepeatableBody, 18 18 + mapParseAsToResponseType, 19 19 + mergeConfigs, 20 20 + mergeHeaders, 21 21 + parseError, 22 22 + parseSuccess, 23 23 + setAuthParams, 24 24 + wrapDataReturn, 25 25 + wrapErrorReturn, 26 26 + } from './utils'; 27 27 + 28 28 + type ReqInit = Omit<RequestInit, 'body' | 'headers'> & { 29 29 + body?: BodyInit | null | undefined; 30 30 + headers: ReturnType<typeof mergeHeaders>; 31 31 + }; 32 32 + 33 33 + export const createClient = (config: Config = {}): Client => { 34 34 + let _config = mergeConfigs(createConfig(), config); 35 35 + 36 36 + const getConfig = (): Config => ({ ..._config }); 37 37 + 38 38 + const setConfig = (config: Config): Config => { 39 39 + _config = mergeConfigs(_config, config); 40 40 + return getConfig(); 41 41 + }; 42 42 + 43 43 + const interceptors = createInterceptors< 44 44 + Request, 45 45 + Response, 46 46 + unknown, 47 47 + ResolvedRequestOptions 48 48 + >(); 49 49 + 50 50 + // Resolve final options, serialized body, network body and URL 51 51 + const resolveOptions = async (options: RequestOptions) => { 52 52 + const opts = { 53 53 + ..._config, 54 54 + ...options, 55 55 + headers: mergeHeaders(_config.headers, options.headers), 56 56 + serializedBody: undefined, 57 57 + }; 58 58 + 59 59 + if (opts.security) { 60 60 + await setAuthParams({ 61 61 + ...opts, 62 62 + security: opts.security, 63 63 + }); 64 64 + } 65 65 + 66 66 + if (opts.requestValidator) { 67 67 + await opts.requestValidator(opts); 68 68 + } 69 69 + 70 70 + if (opts.body !== undefined && opts.bodySerializer) { 71 71 + opts.serializedBody = opts.bodySerializer(opts.body); 72 72 + } 73 73 + 74 74 + // remove Content-Type header if body is empty to avoid sending invalid requests 75 75 + if (opts.body === undefined || opts.serializedBody === '') { 76 76 + opts.headers.delete('Content-Type'); 77 77 + } 78 78 + 79 79 + // If user provides a raw body (no serializer), adjust Content-Type sensibly. 80 80 + // Avoid overriding explicit user-defined headers; only correct the default JSON header. 81 81 + if ( 82 82 + opts.body !== undefined && 83 83 + opts.bodySerializer === null && 84 84 + (opts.headers.get('Content-Type') || '').toLowerCase() === 85 85 + 'application/json' 86 86 + ) { 87 87 + const b: unknown = opts.body; 88 88 + if (typeof FormData !== 'undefined' && b instanceof FormData) { 89 89 + // Let the runtime set proper boundary 90 90 + opts.headers.delete('Content-Type'); 91 91 + } else if ( 92 92 + typeof URLSearchParams !== 'undefined' && 93 93 + b instanceof URLSearchParams 94 94 + ) { 95 95 + // Set standard urlencoded content type with charset 96 96 + opts.headers.set( 97 97 + 'Content-Type', 98 98 + 'application/x-www-form-urlencoded;charset=UTF-8', 99 99 + ); 100 100 + } else if (typeof Blob !== 'undefined' && b instanceof Blob) { 101 101 + const t = b.type?.trim(); 102 102 + if (t) { 103 103 + opts.headers.set('Content-Type', t); 104 104 + } else { 105 105 + // No known type for the blob: avoid sending misleading JSON header 106 106 + opts.headers.delete('Content-Type'); 107 107 + } 108 108 + } 109 109 + } 110 110 + 111 111 + // Precompute network body for retries and consistent handling 112 112 + const networkBody = getValidRequestBody(opts) as 113 113 + | RequestInit['body'] 114 114 + | null 115 115 + | undefined; 116 116 + 117 117 + const url = buildUrl(opts); 118 118 + 119 119 + return { networkBody, opts, url }; 120 120 + }; 121 121 + 122 122 + // Apply request interceptors to a Request and reflect header/method/signal 123 123 + const applyRequestInterceptors = async ( 124 124 + request: Request, 125 125 + opts: ResolvedRequestOptions, 126 126 + ) => { 127 127 + for (const fn of interceptors.request.fns) { 128 128 + if (fn) { 129 129 + request = await fn(request, opts); 130 130 + } 131 131 + } 132 132 + // Reflect any interceptor changes into opts used for network and downstream 133 133 + opts.headers = request.headers; 134 134 + opts.method = request.method as Uppercase<HttpMethod>; 135 135 + // Note: we intentionally ignore request.body changes from interceptors to 136 136 + // avoid turning serialized bodies into streams. Body is sourced solely 137 137 + // from getValidRequestBody(options) for consistency. 138 138 + // Attempt to reflect possible signal changes 139 139 + opts.signal = (request as any).signal as AbortSignal | undefined; 140 140 + return request; 141 141 + }; 142 142 + 143 143 + // Build ofetch options with stable retry logic based on body repeatability 144 144 + const buildNetworkOptions = ( 145 145 + opts: ResolvedRequestOptions, 146 146 + body: BodyInit | null | undefined, 147 147 + responseType: OfetchResponseType | undefined, 148 148 + ) => { 149 149 + const effectiveRetry = isRepeatableBody(body) 150 150 + ? (opts.retry as any) 151 151 + : (0 as any); 152 152 + return buildOfetchOptions(opts, body, responseType, effectiveRetry); 153 153 + }; 154 154 + 155 155 + const request: Client['request'] = async (options) => { 156 156 + const { 157 157 + networkBody: initialNetworkBody, 158 158 + opts, 159 159 + url, 160 160 + } = await resolveOptions(options as any); 161 161 + // Compute response type mapping once 162 162 + const ofetchResponseType: OfetchResponseType | undefined = 163 163 + mapParseAsToResponseType(opts.parseAs, opts.responseType); 164 164 + 165 165 + const $ofetch = opts.ofetch ?? ofetch; 166 166 + 167 167 + // Always create Request pre-network (align with client-fetch) 168 168 + const networkBody = initialNetworkBody; 169 169 + const requestInit: ReqInit = { 170 170 + body: networkBody, 171 171 + headers: opts.headers as Headers, 172 172 + method: opts.method, 173 173 + redirect: 'follow', 174 174 + signal: opts.signal, 175 175 + }; 176 176 + let request = new Request(url, requestInit); 177 177 + 178 178 + request = await applyRequestInterceptors(request, opts); 179 179 + const finalUrl = request.url; 180 180 + 181 181 + // Build ofetch options and perform the request 182 182 + const responseOptions = buildNetworkOptions( 183 183 + opts as ResolvedRequestOptions, 184 184 + networkBody, 185 185 + ofetchResponseType, 186 186 + ); 187 187 + 188 188 + let response = await $ofetch.raw(finalUrl, responseOptions); 189 189 + 190 190 + for (const fn of interceptors.response.fns) { 191 191 + if (fn) { 192 192 + response = await fn(response, request, opts); 193 193 + } 194 194 + } 195 195 + 196 196 + const result = { request, response }; 197 197 + 198 198 + if (response.ok) { 199 199 + const data = await parseSuccess(response, opts, ofetchResponseType); 200 200 + return wrapDataReturn(data, result, opts.responseStyle); 201 201 + } 202 202 + 203 203 + let finalError = await parseError(response); 204 204 + 205 205 + for (const fn of interceptors.error.fns) { 206 206 + if (fn) { 207 207 + finalError = await fn(finalError, response, request, opts); 208 208 + } 209 209 + } 210 210 + 211 211 + // Ensure error is never undefined after interceptors 212 212 + finalError = (finalError as any) || ({} as string); 213 213 + 214 214 + if (opts.throwOnError) { 215 215 + throw finalError; 216 216 + } 217 217 + 218 218 + return wrapErrorReturn(finalError, result, opts.responseStyle) as any; 219 219 + }; 220 220 + 221 221 + const makeMethodFn = 222 222 + (method: Uppercase<HttpMethod>) => (options: RequestOptions) => 223 223 + request({ ...options, method } as any); 224 224 + 225 225 + const makeSseFn = 226 226 + (method: Uppercase<HttpMethod>) => async (options: RequestOptions) => { 227 227 + const { networkBody, opts, url } = await resolveOptions(options); 228 228 + const optsForSse: any = { ...opts }; 229 229 + delete optsForSse.body; 230 230 + return createSseClient({ 231 231 + ...optsForSse, 232 232 + fetch: opts.fetch, 233 233 + headers: opts.headers as Headers, 234 234 + method, 235 235 + onRequest: async (url, init) => { 236 236 + let request = new Request(url, init); 237 237 + request = await applyRequestInterceptors(request, opts); 238 238 + return request; 239 239 + }, 240 240 + serializedBody: networkBody as BodyInit | null | undefined, 241 241 + signal: opts.signal, 242 242 + url, 243 243 + }); 244 244 + }; 245 245 + 246 246 + return { 247 247 + buildUrl, 248 248 + connect: makeMethodFn('CONNECT'), 249 249 + delete: makeMethodFn('DELETE'), 250 250 + get: makeMethodFn('GET'), 251 251 + getConfig, 252 252 + head: makeMethodFn('HEAD'), 253 253 + interceptors, 254 254 + options: makeMethodFn('OPTIONS'), 255 255 + patch: makeMethodFn('PATCH'), 256 256 + post: makeMethodFn('POST'), 257 257 + put: makeMethodFn('PUT'), 258 258 + request, 259 259 + setConfig, 260 260 + sse: { 261 261 + connect: makeSseFn('CONNECT'), 262 262 + delete: makeSseFn('DELETE'), 263 263 + get: makeSseFn('GET'), 264 264 + head: makeSseFn('HEAD'), 265 265 + options: makeSseFn('OPTIONS'), 266 266 + patch: makeSseFn('PATCH'), 267 267 + post: makeSseFn('POST'), 268 268 + put: makeSseFn('PUT'), 269 269 + trace: makeSseFn('TRACE'), 270 270 + }, 271 271 + trace: makeMethodFn('TRACE'), 272 272 + } as Client; 273 273 + };

+23

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

··· 1 1 + export type { Auth } from '../../client-core/bundle/auth'; 2 2 + export type { QuerySerializerOptions } from '../../client-core/bundle/bodySerializer'; 3 3 + export { 4 4 + formDataBodySerializer, 5 5 + jsonBodySerializer, 6 6 + urlSearchParamsBodySerializer, 7 7 + } from '../../client-core/bundle/bodySerializer'; 8 8 + export { buildClientParams } from '../../client-core/bundle/params'; 9 9 + export { createClient } from './client'; 10 10 + export type { 11 11 + Client, 12 12 + ClientOptions, 13 13 + Config, 14 14 + CreateClientConfig, 15 15 + Options, 16 16 + OptionsLegacyParser, 17 17 + RequestOptions, 18 18 + RequestResult, 19 19 + ResolvedRequestOptions, 20 20 + ResponseStyle, 21 21 + TDataShape, 22 22 + } from './types'; 23 23 + export { createConfig, mergeHeaders } from './utils';

+298

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

··· 1 1 + import type { 2 2 + FetchOptions as OfetchOptions, 3 3 + ResponseType as OfetchResponseType, 4 4 + } from 'ofetch'; 5 5 + import type { ofetch } from 'ofetch'; 6 6 + 7 7 + import type { Auth } from '../../client-core/bundle/auth'; 8 8 + import type { 9 9 + ServerSentEventsOptions, 10 10 + ServerSentEventsResult, 11 11 + } from '../../client-core/bundle/serverSentEvents'; 12 12 + import type { 13 13 + Client as CoreClient, 14 14 + Config as CoreConfig, 15 15 + } from '../../client-core/bundle/types'; 16 16 + import type { Middleware } from './utils'; 17 17 + 18 18 + export type ResponseStyle = 'data' | 'fields'; 19 19 + 20 20 + export interface Config<T extends ClientOptions = ClientOptions> 21 21 + extends Omit<RequestInit, 'body' | 'headers' | 'method'>, 22 22 + CoreConfig { 23 23 + agent?: OfetchOptions['agent']; 24 24 + /** 25 25 + * Base URL for all requests made by this client. 26 26 + */ 27 27 + baseUrl?: T['baseUrl']; 28 28 + /** Node-only proxy/agent options */ 29 29 + dispatcher?: OfetchOptions['dispatcher']; 30 30 + /** Optional fetch instance used for SSE streaming */ 31 31 + fetch?: typeof fetch; 32 32 + // No custom fetch option: provide custom instance via `ofetch` instead 33 33 + /** 34 34 + * Please don't use the Fetch client for Next.js applications. The `next` 35 35 + * options won't have any effect. 36 36 + * 37 37 + * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead. 38 38 + */ 39 39 + next?: never; 40 40 + /** 41 41 + * Custom ofetch instance created via `ofetch.create()`. If provided, it will 42 42 + * be used for requests instead of the default `ofetch` export. 43 43 + */ 44 44 + ofetch?: typeof ofetch; 45 45 + /** ofetch interceptors and runtime options */ 46 46 + onRequest?: OfetchOptions['onRequest']; 47 47 + onRequestError?: OfetchOptions['onRequestError']; 48 48 + onResponse?: OfetchOptions['onResponse']; 49 49 + onResponseError?: OfetchOptions['onResponseError']; 50 50 + /** 51 51 + * Return the response data parsed in a specified format. By default, `auto` 52 52 + * will infer the appropriate method from the `Content-Type` response header. 53 53 + * You can override this behavior with any of the {@link Body} methods. 54 54 + * Select `stream` if you don't want to parse response data at all. 55 55 + * 56 56 + * @default 'auto' 57 57 + */ 58 58 + parseAs?: 59 59 + | 'arrayBuffer' 60 60 + | 'auto' 61 61 + | 'blob' 62 62 + | 'formData' 63 63 + | 'json' 64 64 + | 'stream' 65 65 + | 'text'; 66 66 + /** Custom response parser (ofetch). */ 67 67 + parseResponse?: OfetchOptions['parseResponse']; 68 68 + /** 69 69 + * Should we return only data or multiple fields (data, error, response, etc.)? 70 70 + * 71 71 + * @default 'fields' 72 72 + */ 73 73 + responseStyle?: ResponseStyle; 74 74 + /** 75 75 + * ofetch responseType override. If provided, it will be passed directly to 76 76 + * ofetch and take precedence over `parseAs`. 77 77 + */ 78 78 + responseType?: OfetchResponseType; 79 79 + /** 80 80 + * Automatically retry failed requests. 81 81 + */ 82 82 + retry?: OfetchOptions['retry']; 83 83 + retryDelay?: OfetchOptions['retryDelay']; 84 84 + retryStatusCodes?: OfetchOptions['retryStatusCodes']; 85 85 + /** 86 86 + * Throw an error instead of returning it in the response? 87 87 + * 88 88 + * @default false 89 89 + */ 90 90 + throwOnError?: T['throwOnError']; 91 91 + /** 92 92 + * Abort the request after the given milliseconds. 93 93 + */ 94 94 + timeout?: number; 95 95 + } 96 96 + 97 97 + export interface RequestOptions< 98 98 + TData = unknown, 99 99 + TResponseStyle extends ResponseStyle = 'fields', 100 100 + ThrowOnError extends boolean = boolean, 101 101 + Url extends string = string, 102 102 + > extends Config<{ 103 103 + responseStyle: TResponseStyle; 104 104 + throwOnError: ThrowOnError; 105 105 + }>, 106 106 + Pick< 107 107 + ServerSentEventsOptions<TData>, 108 108 + | 'onSseError' 109 109 + | 'onSseEvent' 110 110 + | 'sseDefaultRetryDelay' 111 111 + | 'sseMaxRetryAttempts' 112 112 + | 'sseMaxRetryDelay' 113 113 + > { 114 114 + /** 115 115 + * Any body that you want to add to your request. 116 116 + * 117 117 + * {@link https://developer.mozilla.org/docs/Web/API/fetch#body} 118 118 + */ 119 119 + body?: unknown; 120 120 + path?: Record<string, unknown>; 121 121 + query?: Record<string, unknown>; 122 122 + /** 123 123 + * Security mechanism(s) to use for the request. 124 124 + */ 125 125 + security?: ReadonlyArray<Auth>; 126 126 + url: Url; 127 127 + } 128 128 + 129 129 + export interface ResolvedRequestOptions< 130 130 + TResponseStyle extends ResponseStyle = 'fields', 131 131 + ThrowOnError extends boolean = boolean, 132 132 + Url extends string = string, 133 133 + > extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> { 134 134 + serializedBody?: string; 135 135 + } 136 136 + 137 137 + export type RequestResult< 138 138 + TData = unknown, 139 139 + TError = unknown, 140 140 + ThrowOnError extends boolean = boolean, 141 141 + TResponseStyle extends ResponseStyle = 'fields', 142 142 + > = ThrowOnError extends true 143 143 + ? Promise< 144 144 + TResponseStyle extends 'data' 145 145 + ? TData extends Record<string, unknown> 146 146 + ? TData[keyof TData] 147 147 + : TData 148 148 + : { 149 149 + data: TData extends Record<string, unknown> 150 150 + ? TData[keyof TData] 151 151 + : TData; 152 152 + request: Request; 153 153 + response: Response; 154 154 + } 155 155 + > 156 156 + : Promise< 157 157 + TResponseStyle extends 'data' 158 158 + ? 159 159 + | (TData extends Record<string, unknown> 160 160 + ? TData[keyof TData] 161 161 + : TData) 162 162 + | undefined 163 163 + : ( 164 164 + | { 165 165 + data: TData extends Record<string, unknown> 166 166 + ? TData[keyof TData] 167 167 + : TData; 168 168 + error: undefined; 169 169 + } 170 170 + | { 171 171 + data: undefined; 172 172 + error: TError extends Record<string, unknown> 173 173 + ? TError[keyof TError] 174 174 + : TError; 175 175 + } 176 176 + ) & { 177 177 + request: Request; 178 178 + response: Response; 179 179 + } 180 180 + >; 181 181 + 182 182 + export interface ClientOptions { 183 183 + baseUrl?: string; 184 184 + responseStyle?: ResponseStyle; 185 185 + throwOnError?: boolean; 186 186 + } 187 187 + 188 188 + type MethodFn = < 189 189 + TData = unknown, 190 190 + TError = unknown, 191 191 + ThrowOnError extends boolean = false, 192 192 + TResponseStyle extends ResponseStyle = 'fields', 193 193 + >( 194 194 + options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>, 195 195 + ) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>; 196 196 + 197 197 + type SseFn = < 198 198 + TData = unknown, 199 199 + TError = unknown, 200 200 + ThrowOnError extends boolean = false, 201 201 + TResponseStyle extends ResponseStyle = 'fields', 202 202 + >( 203 203 + options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>, 204 204 + ) => Promise<ServerSentEventsResult<TData, TError>>; 205 205 + 206 206 + type RequestFn = < 207 207 + TData = unknown, 208 208 + TError = unknown, 209 209 + ThrowOnError extends boolean = false, 210 210 + TResponseStyle extends ResponseStyle = 'fields', 211 211 + >( 212 212 + options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & 213 213 + Pick< 214 214 + Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 215 215 + 'method' 216 216 + >, 217 217 + ) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>; 218 218 + 219 219 + type BuildUrlFn = < 220 220 + TData extends { 221 221 + body?: unknown; 222 222 + path?: Record<string, unknown>; 223 223 + query?: Record<string, unknown>; 224 224 + url: string; 225 225 + }, 226 226 + >( 227 227 + options: Pick<TData, 'url'> & Options<TData>, 228 228 + ) => string; 229 229 + 230 230 + export type Client = CoreClient< 231 231 + RequestFn, 232 232 + Config, 233 233 + MethodFn, 234 234 + BuildUrlFn, 235 235 + SseFn 236 236 + > & { 237 237 + interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>; 238 238 + }; 239 239 + 240 240 + /** 241 241 + * The `createClientConfig()` function will be called on client initialization 242 242 + * and the returned object will become the client's initial configuration. 243 243 + * 244 244 + * You may want to initialize your client this way instead of calling 245 245 + * `setConfig()`. This is useful for example if you're using Next.js 246 246 + * to ensure your client always has the correct values. 247 247 + */ 248 248 + export type CreateClientConfig<T extends ClientOptions = ClientOptions> = ( 249 249 + override?: Config<ClientOptions & T>, 250 250 + ) => Config<Required<ClientOptions> & T>; 251 251 + 252 252 + export interface TDataShape { 253 253 + body?: unknown; 254 254 + headers?: unknown; 255 255 + path?: unknown; 256 256 + query?: unknown; 257 257 + url: string; 258 258 + } 259 259 + 260 260 + type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>; 261 261 + 262 262 + export type Options< 263 263 + TData extends TDataShape = TDataShape, 264 264 + ThrowOnError extends boolean = boolean, 265 265 + TResponse = unknown, 266 266 + TResponseStyle extends ResponseStyle = 'fields', 267 267 + > = OmitKeys< 268 268 + RequestOptions<TResponse, TResponseStyle, ThrowOnError>, 269 269 + 'body' | 'path' | 'query' | 'url' 270 270 + > & 271 271 + Omit<TData, 'url'>; 272 272 + 273 273 + export type OptionsLegacyParser< 274 274 + TData = unknown, 275 275 + ThrowOnError extends boolean = boolean, 276 276 + TResponseStyle extends ResponseStyle = 'fields', 277 277 + > = TData extends { body?: any } 278 278 + ? TData extends { headers?: any } 279 279 + ? OmitKeys< 280 280 + RequestOptions<unknown, TResponseStyle, ThrowOnError>, 281 281 + 'body' | 'headers' | 'url' 282 282 + > & 283 283 + TData 284 284 + : OmitKeys< 285 285 + RequestOptions<unknown, TResponseStyle, ThrowOnError>, 286 286 + 'body' | 'url' 287 287 + > & 288 288 + TData & 289 289 + Pick<RequestOptions<unknown, TResponseStyle, ThrowOnError>, 'headers'> 290 290 + : TData extends { headers?: any } 291 291 + ? OmitKeys< 292 292 + RequestOptions<unknown, TResponseStyle, ThrowOnError>, 293 293 + 'headers' | 'url' 294 294 + > & 295 295 + TData & 296 296 + Pick<RequestOptions<unknown, TResponseStyle, ThrowOnError>, 'body'> 297 297 + : OmitKeys<RequestOptions<unknown, TResponseStyle, ThrowOnError>, 'url'> & 298 298 + TData;

+536

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

··· 1 1 + import type { 2 2 + FetchOptions as OfetchOptions, 3 3 + ResponseType as OfetchResponseType, 4 4 + } from 'ofetch'; 5 5 + 6 6 + import { getAuthToken } from '../../client-core/bundle/auth'; 7 7 + import type { QuerySerializerOptions } from '../../client-core/bundle/bodySerializer'; 8 8 + import { jsonBodySerializer } from '../../client-core/bundle/bodySerializer'; 9 9 + import { 10 10 + serializeArrayParam, 11 11 + serializeObjectParam, 12 12 + serializePrimitiveParam, 13 13 + } from '../../client-core/bundle/pathSerializer'; 14 14 + import { getUrl } from '../../client-core/bundle/utils'; 15 15 + import type { 16 16 + Client, 17 17 + ClientOptions, 18 18 + Config, 19 19 + RequestOptions, 20 20 + ResolvedRequestOptions, 21 21 + ResponseStyle, 22 22 + } from './types'; 23 23 + 24 24 + export const createQuerySerializer = <T = unknown>({ 25 25 + allowReserved, 26 26 + array, 27 27 + object, 28 28 + }: QuerySerializerOptions = {}) => { 29 29 + const querySerializer = (queryParams: T) => { 30 30 + const search: string[] = []; 31 31 + if (queryParams && typeof queryParams === 'object') { 32 32 + for (const name in queryParams) { 33 33 + const value = queryParams[name]; 34 34 + 35 35 + if (value === undefined || value === null) { 36 36 + continue; 37 37 + } 38 38 + 39 39 + if (Array.isArray(value)) { 40 40 + const serializedArray = serializeArrayParam({ 41 41 + allowReserved, 42 42 + explode: true, 43 43 + name, 44 44 + style: 'form', 45 45 + value, 46 46 + ...array, 47 47 + }); 48 48 + if (serializedArray) search.push(serializedArray); 49 49 + } else if (typeof value === 'object') { 50 50 + const serializedObject = serializeObjectParam({ 51 51 + allowReserved, 52 52 + explode: true, 53 53 + name, 54 54 + style: 'deepObject', 55 55 + value: value as Record<string, unknown>, 56 56 + ...object, 57 57 + }); 58 58 + if (serializedObject) search.push(serializedObject); 59 59 + } else { 60 60 + const serializedPrimitive = serializePrimitiveParam({ 61 61 + allowReserved, 62 62 + name, 63 63 + value: value as string, 64 64 + }); 65 65 + if (serializedPrimitive) search.push(serializedPrimitive); 66 66 + } 67 67 + } 68 68 + } 69 69 + return search.join('&'); 70 70 + }; 71 71 + return querySerializer; 72 72 + }; 73 73 + 74 74 + /** 75 75 + * Infers parseAs value from provided Content-Type header. 76 76 + */ 77 77 + export const getParseAs = ( 78 78 + contentType: string | null, 79 79 + ): Exclude<Config['parseAs'], 'auto'> => { 80 80 + if (!contentType) { 81 81 + // If no Content-Type header is provided, the best we can do is return the raw response body, 82 82 + // which is effectively the same as the 'stream' option. 83 83 + return 'stream'; 84 84 + } 85 85 + 86 86 + const cleanContent = contentType.split(';')[0]?.trim(); 87 87 + 88 88 + if (!cleanContent) { 89 89 + return; 90 90 + } 91 91 + 92 92 + if ( 93 93 + cleanContent.startsWith('application/json') || 94 94 + cleanContent.endsWith('+json') 95 95 + ) { 96 96 + return 'json'; 97 97 + } 98 98 + 99 99 + if (cleanContent === 'multipart/form-data') { 100 100 + return 'formData'; 101 101 + } 102 102 + 103 103 + if ( 104 104 + ['application/', 'audio/', 'image/', 'video/'].some((type) => 105 105 + cleanContent.startsWith(type), 106 106 + ) 107 107 + ) { 108 108 + return 'blob'; 109 109 + } 110 110 + 111 111 + if (cleanContent.startsWith('text/')) { 112 112 + return 'text'; 113 113 + } 114 114 + 115 115 + return; 116 116 + }; 117 117 + 118 118 + /** 119 119 + * Map our parseAs value to ofetch responseType when not explicitly provided. 120 120 + */ 121 121 + export const mapParseAsToResponseType = ( 122 122 + parseAs: Config['parseAs'] | undefined, 123 123 + explicit?: OfetchResponseType, 124 124 + ): OfetchResponseType | undefined => { 125 125 + if (explicit) return explicit; 126 126 + switch (parseAs) { 127 127 + case 'arrayBuffer': 128 128 + case 'blob': 129 129 + case 'json': 130 130 + case 'text': 131 131 + case 'stream': 132 132 + return parseAs; 133 133 + case 'formData': 134 134 + case 'auto': 135 135 + default: 136 136 + return undefined; // let ofetch auto-detect 137 137 + } 138 138 + }; 139 139 + 140 140 + const checkForExistence = ( 141 141 + options: Pick<RequestOptions, 'auth' | 'query'> & { 142 142 + headers: Headers; 143 143 + }, 144 144 + name?: string, 145 145 + ): boolean => { 146 146 + if (!name) { 147 147 + return false; 148 148 + } 149 149 + if ( 150 150 + options.headers.has(name) || 151 151 + options.query?.[name] || 152 152 + options.headers.get('Cookie')?.includes(`${name}=`) 153 153 + ) { 154 154 + return true; 155 155 + } 156 156 + return false; 157 157 + }; 158 158 + 159 159 + export const setAuthParams = async ({ 160 160 + security, 161 161 + ...options 162 162 + }: Pick<Required<RequestOptions>, 'security'> & 163 163 + Pick<RequestOptions, 'auth' | 'query'> & { 164 164 + headers: Headers; 165 165 + }) => { 166 166 + for (const auth of security) { 167 167 + if (checkForExistence(options, auth.name)) { 168 168 + continue; 169 169 + } 170 170 + 171 171 + const token = await getAuthToken(auth, options.auth); 172 172 + 173 173 + if (!token) { 174 174 + continue; 175 175 + } 176 176 + 177 177 + const name = auth.name ?? 'Authorization'; 178 178 + 179 179 + switch (auth.in) { 180 180 + case 'query': 181 181 + if (!options.query) { 182 182 + options.query = {}; 183 183 + } 184 184 + options.query[name] = token; 185 185 + break; 186 186 + case 'cookie': 187 187 + options.headers.append('Cookie', `${name}=${token}`); 188 188 + break; 189 189 + case 'header': 190 190 + default: 191 191 + options.headers.set(name, token); 192 192 + break; 193 193 + } 194 194 + } 195 195 + }; 196 196 + 197 197 + export const buildUrl: Client['buildUrl'] = (options) => 198 198 + getUrl({ 199 199 + baseUrl: options.baseUrl as string, 200 200 + path: options.path, 201 201 + query: options.query, 202 202 + querySerializer: 203 203 + typeof options.querySerializer === 'function' 204 204 + ? options.querySerializer 205 205 + : createQuerySerializer(options.querySerializer), 206 206 + url: options.url, 207 207 + }); 208 208 + 209 209 + export const mergeConfigs = (a: Config, b: Config): Config => { 210 210 + const config = { ...a, ...b }; 211 211 + if (config.baseUrl?.endsWith('/')) { 212 212 + config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1); 213 213 + } 214 214 + config.headers = mergeHeaders(a.headers, b.headers); 215 215 + return config; 216 216 + }; 217 217 + 218 218 + const headersEntries = (headers: Headers): Array<[string, string]> => { 219 219 + const entries: Array<[string, string]> = []; 220 220 + headers.forEach((value, key) => { 221 221 + entries.push([key, value]); 222 222 + }); 223 223 + return entries; 224 224 + }; 225 225 + 226 226 + export const mergeHeaders = ( 227 227 + ...headers: Array<Required<Config>['headers'] | undefined> 228 228 + ): Headers => { 229 229 + const mergedHeaders = new Headers(); 230 230 + for (const header of headers) { 231 231 + if (!header) { 232 232 + continue; 233 233 + } 234 234 + 235 235 + const iterator = 236 236 + header instanceof Headers 237 237 + ? headersEntries(header) 238 238 + : Object.entries(header); 239 239 + 240 240 + for (const [key, value] of iterator) { 241 241 + if (value === null) { 242 242 + mergedHeaders.delete(key); 243 243 + } else if (Array.isArray(value)) { 244 244 + for (const v of value) { 245 245 + mergedHeaders.append(key, v as string); 246 246 + } 247 247 + } else if (value !== undefined) { 248 248 + // assume object headers are meant to be JSON stringified, i.e. their 249 249 + // content value in OpenAPI specification is 'application/json' 250 250 + mergedHeaders.set( 251 251 + key, 252 252 + typeof value === 'object' ? JSON.stringify(value) : (value as string), 253 253 + ); 254 254 + } 255 255 + } 256 256 + } 257 257 + return mergedHeaders; 258 258 + }; 259 259 + 260 260 + /** 261 261 + * Heuristic to detect whether a request body can be safely retried. 262 262 + */ 263 263 + export const isRepeatableBody = (body: unknown): boolean => { 264 264 + if (body == null) return true; // undefined/null treated as no-body 265 265 + if (typeof body === 'string') return true; 266 266 + if (typeof URLSearchParams !== 'undefined' && body instanceof URLSearchParams) 267 267 + return true; 268 268 + if (typeof Uint8Array !== 'undefined' && body instanceof Uint8Array) 269 269 + return true; 270 270 + if (typeof ArrayBuffer !== 'undefined' && body instanceof ArrayBuffer) 271 271 + return true; 272 272 + if (typeof Blob !== 'undefined' && body instanceof Blob) return true; 273 273 + if (typeof FormData !== 'undefined' && body instanceof FormData) return true; 274 274 + // Streams are not repeatable 275 275 + if (typeof ReadableStream !== 'undefined' && body instanceof ReadableStream) 276 276 + return false; 277 277 + // Default: assume non-repeatable for unknown structured bodies 278 278 + return false; 279 279 + }; 280 280 + 281 281 + /** 282 282 + * Small helper to unify data vs fields return style. 283 283 + */ 284 284 + export const wrapDataReturn = <T>( 285 285 + data: T, 286 286 + result: { request: Request; response: Response }, 287 287 + responseStyle: ResponseStyle | undefined, 288 288 + ): 289 289 + | T 290 290 + | ((T extends Record<string, unknown> ? { data: T } : { data: T }) & 291 291 + typeof result) => 292 292 + (responseStyle ?? 'fields') === 'data' 293 293 + ? (data as any) 294 294 + : ({ data, ...result } as any); 295 295 + 296 296 + /** 297 297 + * Small helper to unify error vs fields return style. 298 298 + */ 299 299 + export const wrapErrorReturn = <E>( 300 300 + error: E, 301 301 + result: { request: Request; response: Response }, 302 302 + responseStyle: ResponseStyle | undefined, 303 303 + ): 304 304 + | undefined 305 305 + | ((E extends Record<string, unknown> ? { error: E } : { error: E }) & 306 306 + typeof result) => 307 307 + (responseStyle ?? 'fields') === 'data' 308 308 + ? undefined 309 309 + : ({ error, ...result } as any); 310 310 + 311 311 + /** 312 312 + * Build options for $ofetch.raw from our resolved opts and body. 313 313 + */ 314 314 + export const buildOfetchOptions = ( 315 315 + opts: ResolvedRequestOptions, 316 316 + body: BodyInit | null | undefined, 317 317 + responseType: OfetchResponseType | undefined, 318 318 + retryOverride?: OfetchOptions['retry'], 319 319 + ): OfetchOptions => 320 320 + ({ 321 321 + agent: opts.agent as OfetchOptions['agent'], 322 322 + body, 323 323 + dispatcher: opts.dispatcher as OfetchOptions['dispatcher'], 324 324 + headers: opts.headers as Headers, 325 325 + method: opts.method, 326 326 + onRequest: opts.onRequest as OfetchOptions['onRequest'], 327 327 + onRequestError: opts.onRequestError as OfetchOptions['onRequestError'], 328 328 + onResponse: opts.onResponse as OfetchOptions['onResponse'], 329 329 + onResponseError: opts.onResponseError as OfetchOptions['onResponseError'], 330 330 + parseResponse: opts.parseResponse as OfetchOptions['parseResponse'], 331 331 + // URL already includes query 332 332 + query: undefined, 333 333 + responseType, 334 334 + retry: retryOverride ?? (opts.retry as OfetchOptions['retry']), 335 335 + retryDelay: opts.retryDelay as OfetchOptions['retryDelay'], 336 336 + retryStatusCodes: 337 337 + opts.retryStatusCodes as OfetchOptions['retryStatusCodes'], 338 338 + signal: opts.signal, 339 339 + timeout: opts.timeout as number | undefined, 340 340 + }) as OfetchOptions; 341 341 + 342 342 + /** 343 343 + * Parse a successful response, handling empty bodies and stream cases. 344 344 + */ 345 345 + export const parseSuccess = async ( 346 346 + response: Response, 347 347 + opts: ResolvedRequestOptions, 348 348 + ofetchResponseType?: OfetchResponseType, 349 349 + ): Promise<unknown> => { 350 350 + // Stream requested: return stream body 351 351 + if (ofetchResponseType === 'stream') { 352 352 + return response.body; 353 353 + } 354 354 + 355 355 + const inferredParseAs = 356 356 + (opts.parseAs === 'auto' 357 357 + ? getParseAs(response.headers.get('Content-Type')) 358 358 + : opts.parseAs) ?? 'json'; 359 359 + 360 360 + // Handle empty responses 361 361 + if ( 362 362 + response.status === 204 || 363 363 + response.headers.get('Content-Length') === '0' 364 364 + ) { 365 365 + switch (inferredParseAs) { 366 366 + case 'arrayBuffer': 367 367 + case 'blob': 368 368 + case 'text': 369 369 + return await (response as any)[inferredParseAs](); 370 370 + case 'formData': 371 371 + return new FormData(); 372 372 + case 'stream': 373 373 + return response.body; 374 374 + default: 375 375 + return {}; 376 376 + } 377 377 + } 378 378 + 379 379 + // Prefer ofetch-populated data 380 380 + let data: unknown = (response as any)._data; 381 381 + if (typeof data === 'undefined') { 382 382 + switch (inferredParseAs) { 383 383 + case 'arrayBuffer': 384 384 + case 'blob': 385 385 + case 'formData': 386 386 + case 'text': 387 387 + data = await (response as any)[inferredParseAs](); 388 388 + break; 389 389 + case 'json': { 390 390 + // Some servers return 200 with no Content-Length and empty body. 391 391 + // response.json() would throw; detect empty via clone().text() first. 392 392 + const txt = await response.clone().text(); 393 393 + if (!txt) { 394 394 + data = {}; 395 395 + } else { 396 396 + data = await (response as any).json(); 397 397 + } 398 398 + break; 399 399 + } 400 400 + case 'stream': 401 401 + return response.body; 402 402 + } 403 403 + } 404 404 + 405 405 + if (inferredParseAs === 'json') { 406 406 + if (opts.responseValidator) { 407 407 + await opts.responseValidator(data); 408 408 + } 409 409 + if (opts.responseTransformer) { 410 410 + data = await opts.responseTransformer(data); 411 411 + } 412 412 + } 413 413 + 414 414 + return data; 415 415 + }; 416 416 + 417 417 + /** 418 418 + * Parse an error response payload. 419 419 + */ 420 420 + export const parseError = async (response: Response): Promise<unknown> => { 421 421 + let error: unknown = (response as any)._data; 422 422 + if (typeof error === 'undefined') { 423 423 + const textError = await response.text(); 424 424 + try { 425 425 + error = JSON.parse(textError); 426 426 + } catch { 427 427 + error = textError; 428 428 + } 429 429 + } 430 430 + return error ?? ({} as string); 431 431 + }; 432 432 + 433 433 + type ErrInterceptor<Err, Res, Req, Options> = ( 434 434 + error: Err, 435 435 + response: Res, 436 436 + request: Req, 437 437 + options: Options, 438 438 + ) => Err | Promise<Err>; 439 439 + 440 440 + type ReqInterceptor<Req, Options> = ( 441 441 + request: Req, 442 442 + options: Options, 443 443 + ) => Req | Promise<Req>; 444 444 + 445 445 + type ResInterceptor<Res, Req, Options> = ( 446 446 + response: Res, 447 447 + request: Req, 448 448 + options: Options, 449 449 + ) => Res | Promise<Res>; 450 450 + 451 451 + class Interceptors<Interceptor> { 452 452 + fns: Array<Interceptor | null> = []; 453 453 + 454 454 + clear(): void { 455 455 + this.fns = []; 456 456 + } 457 457 + 458 458 + eject(id: number | Interceptor): void { 459 459 + const index = this.getInterceptorIndex(id); 460 460 + if (this.fns[index]) { 461 461 + this.fns[index] = null; 462 462 + } 463 463 + } 464 464 + 465 465 + exists(id: number | Interceptor): boolean { 466 466 + const index = this.getInterceptorIndex(id); 467 467 + return Boolean(this.fns[index]); 468 468 + } 469 469 + 470 470 + getInterceptorIndex(id: number | Interceptor): number { 471 471 + if (typeof id === 'number') { 472 472 + return this.fns[id] ? id : -1; 473 473 + } 474 474 + return this.fns.indexOf(id); 475 475 + } 476 476 + 477 477 + update( 478 478 + id: number | Interceptor, 479 479 + fn: Interceptor, 480 480 + ): number | Interceptor | false { 481 481 + const index = this.getInterceptorIndex(id); 482 482 + if (this.fns[index]) { 483 483 + this.fns[index] = fn; 484 484 + return id; 485 485 + } 486 486 + return false; 487 487 + } 488 488 + 489 489 + use(fn: Interceptor): number { 490 490 + this.fns.push(fn); 491 491 + return this.fns.length - 1; 492 492 + } 493 493 + } 494 494 + 495 495 + export interface Middleware<Req, Res, Err, Options> { 496 496 + error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>; 497 497 + request: Interceptors<ReqInterceptor<Req, Options>>; 498 498 + response: Interceptors<ResInterceptor<Res, Req, Options>>; 499 499 + } 500 500 + 501 501 + export const createInterceptors = <Req, Res, Err, Options>(): Middleware< 502 502 + Req, 503 503 + Res, 504 504 + Err, 505 505 + Options 506 506 + > => ({ 507 507 + error: new Interceptors<ErrInterceptor<Err, Res, Req, Options>>(), 508 508 + request: new Interceptors<ReqInterceptor<Req, Options>>(), 509 509 + response: new Interceptors<ResInterceptor<Res, Req, Options>>(), 510 510 + }); 511 511 + 512 512 + const defaultQuerySerializer = createQuerySerializer({ 513 513 + allowReserved: false, 514 514 + array: { 515 515 + explode: true, 516 516 + style: 'form', 517 517 + }, 518 518 + object: { 519 519 + explode: true, 520 520 + style: 'deepObject', 521 521 + }, 522 522 + }); 523 523 + 524 524 + const defaultHeaders = { 525 525 + 'Content-Type': 'application/json', 526 526 + }; 527 527 + 528 528 + export const createConfig = <T extends ClientOptions = ClientOptions>( 529 529 + override: Config<Omit<ClientOptions, keyof T> & T> = {}, 530 530 + ): Config<Omit<ClientOptions, keyof T> & T> => ({ 531 531 + ...jsonBodySerializer, 532 532 + headers: defaultHeaders, 533 533 + parseAs: 'auto', 534 534 + querySerializer: defaultQuerySerializer, 535 535 + ...override, 536 536 + });

+23

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

··· 1 1 + import { definePluginConfig } from '../../shared/utils/config'; 2 2 + import { clientDefaultConfig, clientDefaultMeta } from '../client-core/config'; 3 3 + import { clientPluginHandler } from '../client-core/plugin'; 4 4 + import { Api } from './api'; 5 5 + import type { HeyApiClientOfetchPlugin } from './types'; 6 6 + 7 7 + export const defaultConfig: HeyApiClientOfetchPlugin['Config'] = { 8 8 + ...clientDefaultMeta, 9 9 + api: new Api({ 10 10 + name: '@hey-api/client-ofetch', 11 11 + }), 12 12 + config: { 13 13 + ...clientDefaultConfig, 14 14 + throwOnError: false, 15 15 + }, 16 16 + handler: clientPluginHandler, 17 17 + name: '@hey-api/client-ofetch', 18 18 + }; 19 19 + 20 20 + /** 21 21 + * Type helper for `@hey-api/client-ofetch` plugin, returns {@link Plugin.Config} object 22 22 + */ 23 23 + export const defineConfig = definePluginConfig(defaultConfig);

+3

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

··· 1 1 + export type { Client as OfetchClient } from './bundle/types'; 2 2 + export { defaultConfig, defineConfig } from './config'; 3 3 + export type { HeyApiClientOfetchPlugin } from './types';

+19

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

··· 1 1 + import type { DefinePlugin, Plugin } from '../../types'; 2 2 + import type { Client } from '../client-core/types'; 3 3 + import type { IApi } from './api'; 4 4 + 5 5 + export type UserConfig = Plugin.Name<'@hey-api/client-ofetch'> & 6 6 + Client.Config & { 7 7 + /** 8 8 + * Throw an error instead of returning it in the response? 9 9 + * 10 10 + * @default false 11 11 + */ 12 12 + throwOnError?: boolean; 13 13 + }; 14 14 + 15 15 + export type HeyApiClientOfetchPlugin = DefinePlugin< 16 16 + UserConfig, 17 17 + UserConfig, 18 18 + IApi 19 19 + >;