@zayne-labs/callapi 1.6.15 → 1.6.16

package/README.md

@@ -36,11 +36,11 @@ To do this, you first need to set your `script`'s type to `module`, then import
 
 ```html
 <script type="module">
- import { callApi } from "https://esm.run/@zayne-labs/callapi";
+	import { callApi } from "https://esm.run/@zayne-labs/callapi";
 </script>
 
 <!-- Locked to a specific version -->
 <script type="module">
- import { callApi } from "https://esm.run/@zayne-labs/callapi@0.3.2";
+	import { callApi } from "https://esm.run/@zayne-labs/callapi@0.3.2";
 </script>
 ```

package/dist/cjs/{error-MH9dJCiM.d.cts → error-BokQ-iQX.d.cts}

@@ -115,23 +115,75 @@ interface CallApiValidators<TData = unknown, TErrorData = unknown> {
 }
 type InferSchemaResult<TSchema, TData> = TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TSchema> : TData;
 
-type Params = UnmaskType<Record<string, boolean | number | string> | Array<boolean | number | string>>;
-type Query = UnmaskType<Record<string, boolean | number | string>>;
-type InitURL = UnmaskType<string | URL>;
-interface UrlOptions<TSchemas extends CallApiSchemas> {
+/**
+ * @description Makes a type required if TSchema type is undefined or if the output type of TSchema contains undefined, otherwise keeps it as is
+ */
+type MakeSchemaOptionRequired<TSchema extends StandardSchemaV1 | undefined, TObject> = undefined extends TSchema ? TObject : undefined extends InferSchemaResult<TSchema, NonNullable<unknown>> ? TObject : Required<TObject>;
+type JsonPrimitive = boolean | number | string | null | undefined;
+type SerializableObject = Record<keyof object, unknown>;
+type SerializableArray = Array<JsonPrimitive | SerializableArray | SerializableObject> | ReadonlyArray<JsonPrimitive | SerializableArray | SerializableObject>;
+type Body = UnmaskType<RequestInit["body"] | SerializableArray | SerializableObject>;
+type BodyOption<TSchemas extends CallApiSchemas> = MakeSchemaOptionRequired<TSchemas["body"], {
     /**
-     * URL to be used in the request.
+     * Body of the request, can be a object or any other supported body type.
      */
-    readonly initURL?: string;
+    body?: InferSchemaResult<TSchemas["body"], Body>;
+}>;
+type Method = UnmaskType<"CONNECT" | "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT" | "TRACE" | AnyString>;
+type MethodOption<TSchemas extends CallApiSchemas> = MakeSchemaOptionRequired<TSchemas["method"], {
     /**
-     * Parameters to be appended to the URL (i.e: /:id)
+     * HTTP method for the request.
+     * @default "GET"
      */
-    params?: InferSchemaResult<TSchemas["params"], Params>;
+    method?: InferSchemaResult<TSchemas["method"], Method>;
+}>;
+type Headers = UnmaskType<Record<"Authorization", CommonAuthorizationHeaders> | Record<"Content-Type", CommonContentTypes> | Record<CommonRequestHeaders, string | undefined> | Record<string, string | undefined> | RequestInit["headers"]>;
+type HeadersOption<TSchemas extends CallApiSchemas> = MakeSchemaOptionRequired<TSchemas["headers"], {
     /**
-     * Query parameters to append to the URL.
+     * Headers to be used in the request.
      */
-    query?: InferSchemaResult<TSchemas["query"], Query>;
+    headers?: InferSchemaResult<TSchemas["headers"], Headers>;
+}>;
+interface Register {
 }
+type GlobalMeta = Register extends {
+    meta?: infer TMeta extends Record<string, unknown>;
+} ? TMeta : never;
+type MetaOption<TSchemas extends CallApiSchemas> = {
+    /**
+     * - An optional field you can fill with additional information,
+     * to associate with the request, typically used for logging or tracing.
+     *
+     * - A good use case for this, would be to use the info to handle specific cases in any of the shared interceptors.
+     *
+     * @example
+     * ```ts
+     * const callMainApi = callApi.create({
+     * 	baseURL: "https://main-api.com",
+     * 	onResponseError: ({ response, options }) => {
+     * 		if (options.meta?.userId) {
+     * 			console.error(`User ${options.meta.userId} made an error`);
+     * 		}
+     * 	},
+     * });
+     *
+     * const response = await callMainApi({
+     * 	url: "https://example.com/api/data",
+     * 	meta: { userId: "123" },
+     * });
+     * ```
+     */
+    meta?: InferSchemaResult<TSchemas["meta"], GlobalMeta>;
+};
+type ResultModeOption<TErrorData, TResultMode extends ResultModeUnion> = TErrorData extends false ? {
+    resultMode: "onlySuccessWithException";
+} : TErrorData extends false | undefined ? {
+    resultMode?: "onlySuccessWithException";
+} : undefined extends TResultMode ? {
+    resultMode?: TResultMode;
+} : {
+    resultMode: TResultMode;
+};
 
 type RetryCondition<TErrorData> = (context: ErrorContext<TErrorData>) => boolean | Promise<boolean>;
 interface RetryOptions<TErrorData> {
@@ -201,6 +253,8 @@ type UnionToIntersection<TUnion> = (TUnion extends unknown ? (param: TUnion) =>
 type InferSchema<TResult> = TResult extends StandardSchemaV1 ? InferSchemaResult<TResult, NonNullable<unknown>> : TResult;
 type InferPluginOptions<TPluginArray extends CallApiPlugin[]> = UnionToIntersection<InferSchema<ReturnType<NonNullable<TPluginArray[number]["createExtraOptions"]>>>>;
 type PluginInitContext<TMoreOptions = DefaultMoreOptions> = WithMoreOptions<TMoreOptions> & {
+    baseConfig: BaseCallApiExtraOptions & CallApiRequestOptions;
+    config: CallApiExtraOptions & CallApiRequestOptions;
     initURL: InitURL | undefined;
     options: CombinedCallApiExtraOptions;
     request: CallApiRequestOptionsForHooks;
@@ -239,79 +293,12 @@ interface CallApiPlugin<TData = never, TErrorData = never> {
     version?: string;
 }
 declare const definePlugin: <TPlugin extends CallApiPlugin | AnyFunction<CallApiPlugin>>(plugin: TPlugin) => TPlugin;
-type Plugins<TPluginArray extends CallApiPlugin[]> = TPluginArray | ((context: PluginInitContext) => TPluginArray);
+type Plugins<TPluginArray extends CallApiPlugin[]> = TPluginArray;
 
 declare const fetchSpecificKeys: ("body" | "cache" | "credentials" | "headers" | "integrity" | "keepalive" | "method" | "mode" | "priority" | "redirect" | "referrer" | "referrerPolicy" | "signal" | "window")[];
 declare const defaultRetryMethods: ("GET" | "POST")[];
 declare const defaultRetryStatusCodes: Required<BaseCallApiExtraOptions>["retryStatusCodes"];
 
-/**
- * @description Makes a type required if TSchema type is undefined or if the output type of TSchema contains undefined, otherwise keeps it as is
- */
-type MakeSchemaOptionRequired<TSchema extends StandardSchemaV1 | undefined, TObject> = undefined extends TSchema ? TObject : undefined extends InferSchemaResult<TSchema, NonNullable<unknown>> ? TObject : Required<TObject>;
-type Body = UnmaskType<Record<string, unknown> | RequestInit["body"]>;
-type BodyOption<TSchemas extends CallApiSchemas> = MakeSchemaOptionRequired<TSchemas["body"], {
-    /**
-     * Body of the request, can be a object or any other supported body type.
-     */
-    body?: InferSchemaResult<TSchemas["body"], Body>;
-}>;
-type Method = UnmaskType<"CONNECT" | "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT" | "TRACE" | AnyString>;
-type MethodOption<TSchemas extends CallApiSchemas> = MakeSchemaOptionRequired<TSchemas["method"], {
-    /**
-     * HTTP method for the request.
-     * @default "GET"
-     */
-    method?: InferSchemaResult<TSchemas["method"], Method>;
-}>;
-type Headers = UnmaskType<Record<"Authorization", CommonAuthorizationHeaders> | Record<"Content-Type", CommonContentTypes> | Record<CommonRequestHeaders, string | undefined> | Record<string, string | undefined> | RequestInit["headers"]>;
-type HeadersOption<TSchemas extends CallApiSchemas> = MakeSchemaOptionRequired<TSchemas["headers"], {
-    /**
-     * Headers to be used in the request.
-     */
-    headers?: InferSchemaResult<TSchemas["headers"], Headers>;
-}>;
-interface Register {
-}
-type GlobalMeta = Register extends {
-    meta?: infer TMeta extends Record<string, unknown>;
-} ? TMeta : never;
-type MetaOption<TSchemas extends CallApiSchemas> = {
-    /**
-     * - An optional field you can fill with additional information,
-     * to associate with the request, typically used for logging or tracing.
-     *
-     * - A good use case for this, would be to use the info to handle specific cases in any of the shared interceptors.
-     *
-     * @example
-     * ```ts
-     * const callMainApi = callApi.create({
-     * 	baseURL: "https://main-api.com",
-     * 	onResponseError: ({ response, options }) => {
-     * 		if (options.meta?.userId) {
-     * 			console.error(`User ${options.meta.userId} made an error`);
-     * 		}
-     * 	},
-     * });
-     *
-     * const response = await callMainApi({
-     * 	url: "https://example.com/api/data",
-     * 	meta: { userId: "123" },
-     * });
-     * ```
-     */
-    meta?: InferSchemaResult<TSchemas["meta"], GlobalMeta>;
-};
-type ResultModeOption<TErrorData, TResultMode extends ResultModeUnion> = TErrorData extends false ? {
-    resultMode: "onlySuccessWithException";
-} : TErrorData extends false | undefined ? {
-    resultMode?: "onlySuccessWithException";
-} : undefined extends TResultMode ? {
-    resultMode?: TResultMode;
-} : {
-    resultMode: TResultMode;
-};
-
 type FetchSpecificKeysUnion = Exclude<(typeof fetchSpecificKeys)[number], "body" | "headers" | "method">;
 type CallApiRequestOptions<TSchemas extends CallApiSchemas = DefaultMoreOptions> = BodyOption<TSchemas> & HeadersOption<TSchemas> & MethodOption<TSchemas> & Pick<RequestInit, FetchSpecificKeysUnion>;
 type CallApiRequestOptionsForHooks<TSchemas extends CallApiSchemas = DefaultMoreOptions> = Omit<CallApiRequestOptions<TSchemas>, "headers"> & {
@@ -451,7 +438,7 @@ type ExtraOptions<TData = DefaultDataType, TErrorData = DefaultDataType, TResult
     validators?: CallApiValidators<TData, TErrorData>;
 } & InterceptorsOrInterceptorArray<TData, TErrorData> & Partial<InferPluginOptions<TPluginArray>> & MetaOption<TSchemas> & RetryOptions<TErrorData> & ResultModeOption<TErrorData, TResultMode> & UrlOptions<TSchemas>;
 declare const optionsEnumToExtendFromBase: ("plugins" | "schemas" | "validators")[];
-type CallApiExtraOptions<TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = DefaultThrowOnError, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TSchemas extends CallApiSchemas = DefaultMoreOptions> = CallApiRequestOptions<TSchemas> & ExtraOptions<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray, TSchemas> & {
+type CallApiExtraOptions<TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = DefaultThrowOnError, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TSchemas extends CallApiSchemas = DefaultMoreOptions> = ExtraOptions<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray, TSchemas> & {
     /**
      * Options that should extend the base options.
      */
@@ -460,9 +447,14 @@ type CallApiExtraOptions<TData = DefaultDataType, TErrorData = DefaultDataType,
 declare const optionsEnumToOmitFromBase: ("dedupeKey" | "extend")[];
 type BaseCallApiExtraOptions<TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends boolean = DefaultThrowOnError, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseSchemas extends CallApiSchemas = DefaultMoreOptions> = Omit<Partial<CallApiExtraOptions<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBasePluginArray, TBaseSchemas>>, (typeof optionsEnumToOmitFromBase)[number]>;
 type CombinedCallApiExtraOptions = BaseCallApiExtraOptions & CallApiExtraOptions;
+type BaseCallApiConfig<TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends boolean = DefaultThrowOnError, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseSchemas extends CallApiSchemas = DefaultMoreOptions> = (CallApiRequestOptions<TBaseSchemas> & BaseCallApiExtraOptions<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBasePluginArray, TBaseSchemas>) | ((context: {
+    initURL: string;
+    options: CallApiExtraOptions;
+    request: CallApiRequestOptions;
+}) => CallApiRequestOptions<TBaseSchemas> & BaseCallApiExtraOptions<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBasePluginArray, TBaseSchemas>);
 type CallApiParameters<TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = DefaultThrowOnError, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TSchemas extends CallApiSchemas = DefaultMoreOptions> = [
     initURL: InferSchemaResult<TSchemas["initURL"], InitURL>,
-    config?: CallApiExtraOptions<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray, TSchemas>
+    config?: CallApiRequestOptions<TSchemas> & CallApiExtraOptions<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray, TSchemas>
 ];
 type RequestContext = UnmaskType<{
     options: CombinedCallApiExtraOptions;
@@ -548,6 +540,24 @@ type ResultModeMap<TData = DefaultDataType, TErrorData = DefaultDataType, TRespo
 type ResultModeUnion = keyof ResultModeMap | undefined;
 type GetCallApiResult<TData, TErrorData, TResultMode extends ResultModeUnion, TThrowOnError extends boolean, TResponseType extends ResponseTypeUnion> = TErrorData extends false | undefined ? ResultModeMap<TData, TErrorData, TResponseType>["onlySuccessWithException"] : ResultModeUnion | undefined extends TResultMode ? TThrowOnError extends true ? ResultModeMap<TData, TErrorData, TResponseType>["allWithException"] : ResultModeMap<TData, TErrorData, TResponseType>["all"] : TResultMode extends NonNullable<ResultModeUnion> ? TResultMode extends "onlySuccess" ? ResultModeMap<TData, TErrorData, TResponseType>["onlySuccessWithException"] : TResultMode extends "onlyResponse" ? ResultModeMap<TData, TErrorData, TResponseType>["onlyResponseWithException"] : ResultModeMap<TData, TErrorData, TResponseType>[TResultMode] : never;
 
+type Params = UnmaskType<Record<string, boolean | number | string> | Array<boolean | number | string>>;
+type Query = UnmaskType<Record<string, boolean | number | string>>;
+type InitURL = UnmaskType<string | URL>;
+interface UrlOptions<TSchemas extends CallApiSchemas> {
+    /**
+     * URL to be used in the request.
+     */
+    readonly initURL?: string;
+    /**
+     * Parameters to be appended to the URL (i.e: /:id)
+     */
+    params?: InferSchemaResult<TSchemas["params"], Params>;
+    /**
+     * Query parameters to append to the URL.
+     */
+    query?: InferSchemaResult<TSchemas["query"], Query>;
+}
+
 type ErrorDetails<TErrorResponse> = {
     defaultErrorMessage: string;
     errorData: TErrorResponse;
@@ -564,4 +574,4 @@ declare class HTTPError<TErrorResponse = Record<string, unknown>> extends Error
     constructor(errorDetails: ErrorDetails<TErrorResponse>, errorOptions?: ErrorOptions);
 }
 
-export { type BaseCallApiExtraOptions as B, type CallApiPlugin as C, type DefaultPluginArray as D, type ErrorContext as E, type GetCallApiResult as G, HTTPError as H, type InferSchemaResult as I, type PluginInitContext as P, type ResultModeUnion as R, type SuccessContext as S, type ResponseTypeUnion as a, type CallApiSchemas as b, type CallApiExtraOptions as c, type DefaultDataType as d, type DefaultThrowOnError as e, type DefaultMoreOptions as f, type CallApiParameters as g, definePlugin as h, type PossibleJavaScriptError as i, type PossibleHTTPError as j, type CallApiRequestOptions as k, type CallApiRequestOptionsForHooks as l, type CallApiResultErrorVariant as m, type CallApiResultSuccessVariant as n, type CombinedCallApiExtraOptions as o, type Interceptors as p, type InterceptorsOrInterceptorArray as q, type PossibleJavascriptErrorNames as r, type Register as s, type RequestContext as t, type RequestErrorContext as u, type ResponseContext as v, type ResponseErrorContext as w, defaultRetryMethods as x, defaultRetryStatusCodes as y };
+export { type AnyString as A, type BaseCallApiConfig as B, type CallApiPlugin as C, type DefaultPluginArray as D, type ExtraOptions as E, type Interceptors as F, type GetCallApiResult as G, HTTPError as H, type InferSchemaResult as I, type PossibleJavascriptErrorNames as J, type Register as K, type RequestContext as L, type MetaOption as M, type RequestErrorContext as N, type ResponseContext as O, type PossibleJavaScriptError as P, type ResponseErrorContext as Q, type ResultModeUnion as R, type SerializableArray as S, type SuccessContext as T, type UrlOptions as U, defaultRetryMethods as V, defaultRetryStatusCodes as W, type ResponseTypeUnion as a, type CallApiSchemas as b, type SerializableObject as c, type CommonContentTypes as d, type CommonRequestHeaders as e, type Auth as f, type Awaitable as g, type CombinedCallApiExtraOptions as h, type CallApiRequestOptionsForHooks as i, type CallApiValidators as j, type InterceptorsOrInterceptorArray as k, type RetryOptions as l, type ResultModeOption as m, type DefaultDataType as n, type DefaultThrowOnError as o, type DefaultMoreOptions as p, type CallApiParameters as q, definePlugin as r, type PluginInitContext as s, type BaseCallApiExtraOptions as t, type CallApiExtraOptions as u, type PossibleHTTPError as v, type CallApiRequestOptions as w, type CallApiResultErrorVariant as x, type CallApiResultSuccessVariant as y, type ErrorContext as z };

package/dist/cjs/index.cjs

@@ -114,6 +114,20 @@ var isPlainObject = (value) => {
   }
   return true;
 };
+var isJsonString = (value) => {
+  if (!isString(value)) {
+    return false;
+  }
+  try {
+    JSON.parse(value);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var isSerializable = (value) => {
+  return isPlainObject(value) || isArray(value) || typeof value?.toJSON === "function";
+};
 var isFunction = (value) => typeof value === "function";
 var isQueryString = (value) => isString(value) && value.includes("=");
 var isString = (value) => typeof value === "string";
@@ -224,12 +238,6 @@ var splitConfig = (config) => [
   pickKeys(config, fetchSpecificKeys),
   omitKeys(config, fetchSpecificKeys)
 ];
-var objectifyHeaders = (headers) => {
-  if (!headers || isPlainObject(headers)) {
-    return headers;
-  }
-  return Object.fromEntries(headers);
-};
 var toQueryString = (params) => {
   if (!params) {
     console.error("toQueryString:", "No query params provided!");
@@ -237,6 +245,12 @@ var toQueryString = (params) => {
   }
   return new URLSearchParams(params).toString();
 };
+var objectifyHeaders = (headers) => {
+  if (!headers || isPlainObject(headers)) {
+    return headers;
+  }
+  return Object.fromEntries(headers);
+};
 var mergeAndResolveHeaders = (options) => {
   const { auth, baseHeaders, body, headers } = options;
   const shouldResolveHeaders = Boolean(baseHeaders || headers || body || auth);
@@ -250,7 +264,7 @@ var mergeAndResolveHeaders = (options) => {
     headersObject["Content-Type"] = "application/x-www-form-urlencoded";
     return headersObject;
   }
-  if (isPlainObject(body) || isString(body) && body.startsWith("{")) {
+  if (isSerializable(body) || isJsonString(body)) {
     headersObject["Content-Type"] = "application/json";
     headersObject.Accept = "application/json";
   }
@@ -354,14 +368,14 @@ var hooksEnum = {
   onRetry: /* @__PURE__ */ new Set(),
   onSuccess: /* @__PURE__ */ new Set()
 };
-var getPluginArray = (plugins, context) => {
+var getPluginArray = (plugins) => {
   if (!plugins) {
     return [];
   }
-  return isFunction(plugins) ? plugins(context) : plugins;
+  return plugins;
 };
 var initializePlugins = async (context) => {
-  const { initURL, options, request } = context;
+  const { baseConfig, config, initURL, options, request } = context;
   const hookRegistries = structuredClone(hooksEnum);
   const addMainHooks = () => {
     for (const key of Object.keys(hooksEnum)) {
@@ -379,15 +393,21 @@ var initializePlugins = async (context) => {
     addMainHooks();
   }
   const resolvedPlugins = [
-    ...getPluginArray(options.plugins, context),
-    ...getPluginArray(options.extend?.plugins, context)
+    ...getPluginArray(options.plugins),
+    ...getPluginArray(options.extend?.plugins)
   ];
   let resolvedUrl = initURL;
   let resolvedOptions = options;
   let resolvedRequestOptions = request;
   const executePluginInit = async (pluginInit) => {
     if (!pluginInit) return;
-    const initResult = await pluginInit({ initURL, options, request });
+    const initResult = await pluginInit({
+      baseConfig,
+      config,
+      initURL,
+      options,
+      request
+    });
     if (!isPlainObject(initResult)) return;
     if (isString(initResult.initURL)) {
       resolvedUrl = initResult.initURL;
@@ -570,12 +590,13 @@ var handleValidation = async (responseData, schema, validator) => {
 };
 
 // src/createFetchClient.ts
-var createFetchClient = (baseConfig) => {
-  const [baseFetchOptions, baseExtraOptions] = splitBaseConfig(baseConfig ?? {});
+var createFetchClient = (baseConfig = {}) => {
   const $RequestInfoCache = /* @__PURE__ */ new Map();
   const callApi2 = async (...parameters) => {
     const [initURL, config = {}] = parameters;
     const [fetchOptions, extraOptions] = splitConfig(config);
+    const resolvedBaseConfig = isFunction(baseConfig) ? baseConfig({ initURL: initURL.toString(), options: extraOptions, request: fetchOptions }) : baseConfig;
+    const [baseFetchOptions, baseExtraOptions] = splitBaseConfig(resolvedBaseConfig);
     const initCombinedHooks = {};
     for (const key of Object.keys(hooksEnum)) {
       const combinedHook = combineHooks(
@@ -603,20 +624,13 @@ var createFetchClient = (baseConfig) => {
       ...extraOptions,
       ...initCombinedHooks
     };
-    const body = fetchOptions.body ?? baseFetchOptions.body;
     const defaultRequestOptions = {
       ...baseFetchOptions,
-      ...fetchOptions,
-      body: isPlainObject(body) ? defaultExtraOptions.bodySerializer(body) : body,
-      headers: mergeAndResolveHeaders({
-        auth: defaultExtraOptions.auth,
-        baseHeaders: baseFetchOptions.headers,
-        body,
-        headers: fetchOptions.headers
-      }),
-      signal: fetchOptions.signal ?? baseFetchOptions.signal
+      ...fetchOptions
     };
     const { resolvedHooks, resolvedOptions, resolvedRequestOptions, url } = await initializePlugins({
+      baseConfig: resolvedBaseConfig,
+      config,
       initURL,
       options: defaultExtraOptions,
       request: defaultRequestOptions
@@ -637,6 +651,13 @@ var createFetchClient = (baseConfig) => {
     );
     const request = {
       ...resolvedRequestOptions,
+      body: isPlainObject(resolvedRequestOptions.body) ? options.bodySerializer(resolvedRequestOptions.body) : resolvedRequestOptions.body,
+      headers: mergeAndResolveHeaders({
+        auth: options.auth,
+        baseHeaders: baseFetchOptions.headers,
+        body: resolvedRequestOptions.body,
+        headers: fetchOptions.headers
+      }),
       signal: combinedSignal
     };
     const { handleRequestCancelStrategy, handleRequestDeferStrategy, removeDedupeKeyFromCache } = await createDedupeStrategy({ $RequestInfoCache, newFetchController, options, request });
@@ -646,12 +667,12 @@ var createFetchClient = (baseConfig) => {
       request.headers = mergeAndResolveHeaders({
         auth: options.auth,
         baseHeaders: baseFetchOptions.headers,
-        body,
+        body: request.body,
         headers: request.headers
       });
       const response = await handleRequestDeferStrategy();
-      const shouldCloneResponse = options.dedupeStrategy === "defer" || options.cloneResponse;
       const { schemas, validators } = createExtensibleSchemasAndValidators(options);
+      const shouldCloneResponse = options.dedupeStrategy === "defer" || options.cloneResponse;
       if (!response.ok) {
         const errorData = await resolveResponseData(
           shouldCloneResponse ? response.clone() : response,
@@ -753,7 +774,6 @@ var createFetchClient = (baseConfig) => {
       removeDedupeKeyFromCache();
     }
   };
-  callApi2.create = createFetchClient;
   return callApi2;
 };
 var callApi = createFetchClient();