@zayne-labs/callapi 1.12.4 → 1.12.6

package/dist/index.js

@@ -1,4 +1,4 @@
-import { A as getCurrentRouteSchemaKeyAndMainInitURL, B as isReadableStream, L as isArray, M as handleSchemaValidation, N as HTTPError, R as isBoolean, V as isString, a as getBody, c as getMethod, d as splitConfig, f as waitFor, h as isHTTPErrorInstance, i as createTimeoutSignal, j as handleConfigValidation, k as getFullAndNormalizedURL, l as getResolvedHeaders, o as getFetchImpl, r as createCombinedSignal, s as getHeaders, t as extraOptionDefaults, u as omitKeys, v as isValidationErrorInstance, z as isFunction } from "./defaults-WfRTxvn6.js";
+import { A as getCurrentRouteSchemaKeyAndMainInitURL, B as isString, L as isArray, M as handleSchemaValidation, N as HTTPError, R as isBoolean, a as getBody, c as getMethod, d as splitConfig, f as waitFor, h as isHTTPErrorInstance, i as createTimeoutSignal, j as handleConfigValidation, k as getFullAndNormalizedURL, l as getResolvedHeaders, o as getFetchImpl, r as createCombinedSignal, s as getHeaders, t as extraOptionDefaults, u as omitKeys, v as isValidationErrorInstance, z as isFunction } from "./defaults-IsBgvt90.js";
 //#region src/result.ts
 const getResponseType = (response, responseParser) => ({
 	arrayBuffer: () => response.arrayBuffer(),
@@ -143,7 +143,9 @@ const composeHooksFromArray = (hooksArray, hooksExecutionMode) => {
 	return composedHook;
 };
 const executeHooks = async (...hookResultsOrPromise) => {
-	await Promise.all(hookResultsOrPromise);
+	const validHooks = hookResultsOrPromise.filter(Boolean);
+	if (validHooks.length === 0) return;
+	await Promise.all(validHooks);
 };
 const executeHooksInCatchBlock = async (hookResultsOrPromise, hookInfo) => {
 	const { errorInfo, shouldThrowOnError } = hookInfo;
@@ -159,104 +161,128 @@ const executeHooksInCatchBlock = async (hookResultsOrPromise, hookInfo) => {
 //#endregion
 //#region src/stream.ts
 const createProgressEvent = (options) => {
-	const { chunk, totalBytes, transferredBytes } = options;
+	const { chunk, isDone, totalBytes, transferredBytes } = options;
+	let percentage = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
+	if (percentage >= 1) percentage = 1 - Number.EPSILON;
 	return {
 		chunk,
-		progress: Math.round(transferredBytes / totalBytes * 100) || 0,
+		progress: (isDone ? 1 : percentage) * 100,
 		totalBytes,
 		transferredBytes
 	};
 };
-const calculateTotalBytesFromBody = async (requestBody, existingTotalBytes) => {
-	let totalBytes = existingTotalBytes;
-	if (!requestBody) return totalBytes;
-	for await (const chunk of requestBody) totalBytes += chunk.byteLength;
-	return totalBytes;
+const textEncoder = new TextEncoder();
+const estimateBodySize = (body) => {
+	if (!body) return 0;
+	if (body instanceof ReadableStream) return 0;
+	if (body instanceof FormData) {
+		let size = 0;
+		for (const [key, value] of body) {
+			size += 40;
+			size += textEncoder.encode(`Content-Disposition: form-data; name="${key}"`).byteLength;
+			size += isString(value) ? textEncoder.encode(value).byteLength : value.size;
+		}
+		return size;
+	}
+	if (body instanceof Blob) return body.size;
+	if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) return body.byteLength;
+	if (isString(body) || body instanceof URLSearchParams) return textEncoder.encode(String(body)).byteLength;
+	return 0;
+};
+const createTrackedStream = (streamOptions) => {
+	const { initialTotalBytes, onStream, streamBody } = streamOptions;
+	let totalBytes = initialTotalBytes;
+	let transferredBytes = 0;
+	const reportProgress = async (progressOptions) => {
+		const { chunk, isDone } = progressOptions;
+		if (isDone) {
+			await onStream(createProgressEvent({
+				chunk: null,
+				isDone: true,
+				totalBytes,
+				transferredBytes
+			}));
+			return;
+		}
+		transferredBytes += chunk.byteLength;
+		totalBytes = Math.max(totalBytes, transferredBytes);
+		await onStream(createProgressEvent({
+			chunk,
+			totalBytes,
+			transferredBytes
+		}));
+	};
+	return streamBody.pipeThrough(new TransformStream({
+		flush: async () => {
+			await reportProgress({
+				chunk: null,
+				isDone: true
+			});
+		},
+		start: async () => {
+			await reportProgress({ chunk: new Uint8Array() });
+		},
+		transform: async (chunk, controller) => {
+			controller.enqueue(chunk);
+			await reportProgress({ chunk });
+		}
+	}));
 };
-const toStreamableRequest = async (context) => {
+const toStreamableRequest = (context) => {
 	const { baseConfig, config, options, request } = context;
-	if (!options.onRequestStream || !isReadableStream(request.body)) return request;
+	if (!options.onRequestStream || !request.body) return request;
 	const requestInstance = new Request(options.fullURL, {
 		...request,
 		duplex: "half"
 	});
 	const contentLength = requestInstance.headers.get("content-length");
-	let totalBytes = Number(contentLength ?? 0);
-	if (!contentLength && options.forcefullyCalculateRequestStreamSize) totalBytes = await calculateTotalBytesFromBody(requestInstance.clone().body, totalBytes);
-	let transferredBytes = 0;
-	const stream = new ReadableStream({ start: async (controller) => {
-		const body = requestInstance.body;
-		if (!body) return;
-		const requestStreamContext = {
-			baseConfig,
-			config,
-			event: createProgressEvent({
-				chunk: new Uint8Array(),
-				totalBytes,
-				transferredBytes
-			}),
-			options,
-			request,
-			requestInstance
-		};
-		await executeHooks(options.onRequestStream?.(requestStreamContext));
-		for await (const chunk of body) {
-			transferredBytes += chunk.byteLength;
-			totalBytes = Math.max(totalBytes, transferredBytes);
+	const initialTotalBytes = contentLength ? Math.max(0, Number(contentLength) || 0) : estimateBodySize(config.body ?? request.body);
+	const streamBody = requestInstance.body;
+	if (!streamBody) return requestInstance;
+	const requestStreamContext = {
+		baseConfig,
+		config,
+		options,
+		request,
+		requestInstance
+	};
+	const trackedStream = createTrackedStream({
+		initialTotalBytes,
+		onStream: async (event) => {
 			await executeHooks(options.onRequestStream?.({
 				...requestStreamContext,
-				event: createProgressEvent({
-					chunk,
-					totalBytes,
-					transferredBytes
-				})
+				event
 			}));
-			controller.enqueue(chunk);
-		}
-		controller.close();
-	} });
+		},
+		streamBody
+	});
 	return new Request(requestInstance, {
-		body: stream,
+		body: trackedStream,
 		duplex: "half"
 	});
 };
 const toStreamableResponse = (context) => {
 	const { baseConfig, config, options, request, response } = context;
-	if (!options.onResponseStream || !response.body) return response;
-	const contentLength = response.headers.get("content-length");
-	let totalBytes = Number(contentLength ?? 0);
-	let transferredBytes = 0;
-	const stream = new ReadableStream({ start: async (controller) => {
-		const body = response.body;
-		if (!body) return;
-		const responseStreamContext = {
-			baseConfig,
-			config,
-			event: createProgressEvent({
-				chunk: new Uint8Array(),
-				totalBytes,
-				transferredBytes
-			}),
-			options,
-			request,
-			response
-		};
-		await executeHooks(options.onResponseStream?.(responseStreamContext));
-		for await (const chunk of body) {
-			transferredBytes += chunk.byteLength;
-			totalBytes = Math.max(totalBytes, transferredBytes);
+	if (!options.onResponseStream || !response.body || response.status === 204) return response;
+	const initialTotalBytes = Math.max(0, Number(response.headers.get("content-length")) || 0);
+	const streamBody = response.body;
+	const responseStreamContext = {
+		baseConfig,
+		config,
+		options,
+		request,
+		response
+	};
+	const stream = createTrackedStream({
+		initialTotalBytes,
+		onStream: async (event) => {
 			await executeHooks(options.onResponseStream?.({
 				...responseStreamContext,
-				event: createProgressEvent({
-					chunk,
-					totalBytes,
-					transferredBytes
-				})
+				event
 			}));
-			controller.enqueue(chunk);
-		}
-		controller.close();
-	} });
+		},
+		streamBody
+	});
 	return new Response(stream, response);
 };
 //#endregion
@@ -265,21 +291,18 @@ const createDedupeStrategy = async (context) => {
 	const { $GlobalRequestInfoCache, $LocalRequestInfoCache, baseConfig, config, newFetchController, options: globalOptions } = context;
 	const dedupeStrategy = globalOptions.dedupeStrategy ?? extraOptionDefaults.dedupeStrategy;
 	const resolvedDedupeStrategy = isFunction(dedupeStrategy) ? dedupeStrategy(context) : dedupeStrategy;
+	const shouldDisableDedupe = resolvedDedupeStrategy === "none";
 	const getDedupeKey = () => {
-		if (!(resolvedDedupeStrategy === "cancel" || resolvedDedupeStrategy === "defer")) return null;
 		const dedupeKey = globalOptions.dedupeKey ?? extraOptionDefaults.dedupeKey;
 		return isFunction(dedupeKey) ? dedupeKey(context) : dedupeKey;
 	};
-	const getDedupeCacheScopeKey = () => {
-		const dedupeCacheScopeKey = globalOptions.dedupeCacheScopeKey ?? extraOptionDefaults.dedupeCacheScopeKey;
-		return isFunction(dedupeCacheScopeKey) ? dedupeCacheScopeKey(context) : dedupeCacheScopeKey;
-	};
-	const dedupeKey = getDedupeKey();
+	const dedupeKey = shouldDisableDedupe ? null : getDedupeKey();
 	const getRequestInfoCache = () => {
-		if (!dedupeKey) return;
+		if (dedupeKey == null) return;
 		const dedupeCacheScope = globalOptions.dedupeCacheScope ?? extraOptionDefaults.dedupeCacheScope;
-		const dedupeCacheScopeKey = getDedupeCacheScopeKey();
-		const $RequestInfoCache = dedupeCacheScope === "global" ? $GlobalRequestInfoCache.get(dedupeCacheScopeKey) ?? $GlobalRequestInfoCache.set(dedupeCacheScopeKey, /* @__PURE__ */ new Map()).get(dedupeCacheScopeKey) : $LocalRequestInfoCache;
+		const dedupeCacheScopeKey = globalOptions.dedupeCacheScopeKey ?? extraOptionDefaults.dedupeCacheScopeKey;
+		const resolvedDedupeCacheScopeKey = isFunction(dedupeCacheScopeKey) ? dedupeCacheScopeKey(context) : dedupeCacheScopeKey;
+		const $RequestInfoCache = dedupeCacheScope === "global" ? $GlobalRequestInfoCache.get(resolvedDedupeCacheScopeKey) ?? $GlobalRequestInfoCache.set(resolvedDedupeCacheScopeKey, /* @__PURE__ */ new Map()).get(resolvedDedupeCacheScopeKey) : $LocalRequestInfoCache;
 		return {
 			delete: () => $RequestInfoCache?.delete(dedupeKey),
 			get: () => $RequestInfoCache?.get(dedupeKey),
@@ -311,35 +334,34 @@ const createDedupeStrategy = async (context) => {
 	* simultaneously (same problem as microtasks). Any non-zero value (even 0.0000000001) forces
 	* proper sequential task queue scheduling, ensuring each request gets its own task slot.
 	*/
-	if (dedupeKey !== null) await waitFor(.01);
+	if (!shouldDisableDedupe) await waitFor(.01);
 	const prevRequestInfo = $RequestInfoCache?.get();
 	const getAbortErrorMessage = () => {
-		if (globalOptions.dedupeKey) return `Duplicate request detected - Aborted previous request with key '${dedupeKey}'`;
-		return `Duplicate request detected - Aborted previous request to '${globalOptions.fullURL}'`;
+		if (shouldDisableDedupe) return;
+		return globalOptions.dedupeKey != null ? `Duplicate request detected - Aborted previous request with key '${dedupeKey}'` : `Duplicate request detected - Aborted previous request to '${globalOptions.fullURL}'`;
 	};
 	const handleRequestCancelStrategy = () => {
-		if (!(prevRequestInfo && resolvedDedupeStrategy === "cancel")) return;
+		if (!(!shouldDisableDedupe && prevRequestInfo && resolvedDedupeStrategy === "cancel")) return;
 		const message = getAbortErrorMessage();
 		const reason = new DOMException(message, "AbortError");
-		prevRequestInfo.controller.abort(reason);
+		prevRequestInfo.controller?.abort(reason);
 	};
 	const handleRequestDeferStrategy = async (deferContext) => {
 		const { fetchApi, options: localOptions, request: localRequest } = deferContext;
-		const shouldUsePromiseFromCache = prevRequestInfo && resolvedDedupeStrategy === "defer";
-		const streamableContext = {
+		const shouldDeferPromise = !shouldDisableDedupe && prevRequestInfo && resolvedDedupeStrategy === "defer";
+		const streamContext = {
 			baseConfig,
 			config,
 			options: localOptions,
 			request: localRequest
 		};
-		const streamableRequest = await toStreamableRequest(streamableContext);
-		const responsePromise = shouldUsePromiseFromCache ? prevRequestInfo.responsePromise : fetchApi(localOptions.fullURL, streamableRequest);
+		const responsePromise = shouldDeferPromise ? prevRequestInfo.responsePromise : fetchApi(localOptions.fullURL, toStreamableRequest(streamContext));
 		$RequestInfoCache?.set({
 			controller: newFetchController,
 			responsePromise
 		});
 		return toStreamableResponse({
-			...streamableContext,
+			...streamContext,
 			response: await responsePromise
 		});
 	};
@@ -388,7 +410,7 @@ const getResolvedPlugins = (context) => {
 	const { baseConfig, options } = context;
 	return isFunction(options.plugins) ? options.plugins({ basePlugins: baseConfig.plugins ?? [] }) : options.plugins ?? [];
 };
-const initializePlugins = async (setupContext) => {
+const initializePluginsAndHooks = async (setupContext) => {
 	const { baseConfig, config, currentRouteSchemaKey, mainInitURL, options, request } = setupContext;
 	const { addMainHooks, addMainMiddlewares, addPluginHooks, addPluginMiddlewares, getResolvedHooks, getResolvedMiddlewares } = setupHooksAndMiddlewares({
 		baseConfig,
@@ -399,35 +421,37 @@ const initializePlugins = async (setupContext) => {
 	let resolvedInitURL = mainInitURL;
 	const resolvedOptions = options;
 	const resolvedRequest = request;
-	const executePluginSetupFn = async (pluginSetup) => {
-		if (!pluginSetup) return;
-		const initResult = await pluginSetup(setupContext);
-		if (!initResult) return;
-		const urlString = initResult.initURL?.toString();
-		if (isString(urlString)) {
-			const newURLResult = getCurrentRouteSchemaKeyAndMainInitURL({
-				baseExtraOptions: baseConfig,
-				extraOptions: config,
-				initURL: urlString
-			});
-			resolvedCurrentRouteSchemaKey = newURLResult.currentRouteSchemaKey;
-			resolvedInitURL = newURLResult.mainInitURL;
-		}
-		if (initResult.request) Object.assign(resolvedRequest, initResult.request, initResult.request.extraFetchOptions);
-		if (initResult.options) Object.assign(resolvedOptions, initResult.options);
-	};
 	const resolvedPlugins = getResolvedPlugins({
 		baseConfig,
 		options
 	});
-	for (const plugin of resolvedPlugins) {
-		const [, pluginHooks, pluginMiddlewares] = await Promise.all([
-			executePluginSetupFn(plugin.setup),
-			isFunction(plugin.hooks) ? plugin.hooks(setupContext) : plugin.hooks,
-			isFunction(plugin.middlewares) ? plugin.middlewares(setupContext) : plugin.middlewares
-		]);
-		pluginHooks && addPluginHooks(pluginHooks);
-		pluginMiddlewares && addPluginMiddlewares(pluginMiddlewares);
+	if (resolvedPlugins.length > 0) {
+		const executePluginSetupFn = async (pluginSetup) => {
+			if (!pluginSetup) return;
+			const initResult = await pluginSetup(setupContext);
+			if (!initResult) return;
+			const urlString = initResult.initURL?.toString();
+			if (isString(urlString)) {
+				const newURLResult = getCurrentRouteSchemaKeyAndMainInitURL({
+					baseExtraOptions: baseConfig,
+					extraOptions: config,
+					initURL: urlString
+				});
+				resolvedCurrentRouteSchemaKey = newURLResult.currentRouteSchemaKey;
+				resolvedInitURL = newURLResult.mainInitURL;
+			}
+			if (initResult.request) Object.assign(resolvedRequest, initResult.request, initResult.request.extraFetchOptions);
+			if (initResult.options) Object.assign(resolvedOptions, initResult.options);
+		};
+		for (const plugin of resolvedPlugins) {
+			const [, pluginHooks, pluginMiddlewares] = await Promise.all([
+				executePluginSetupFn(plugin.setup),
+				isFunction(plugin.hooks) ? plugin.hooks(setupContext) : plugin.hooks,
+				isFunction(plugin.middlewares) ? plugin.middlewares(setupContext) : plugin.middlewares
+			]);
+			pluginHooks && addPluginHooks(pluginHooks);
+			pluginMiddlewares && addPluginMiddlewares(pluginMiddlewares);
+		}
 	}
 	addMainHooks();
 	addMainMiddlewares();
@@ -478,17 +502,23 @@ const setupHooksAndMiddlewares = (context) => {
 	};
 	const getResolvedHooks = () => {
 		const resolvedHooks = {};
-		for (const [hookName, hookRegistry] of Object.entries(hookRegistries)) {
+		for (const hookName of hookRegistryKeys) {
+			const hookRegistry = hookRegistries[hookName];
 			if (hookRegistry.size === 0) continue;
 			const flattenedHookArray = [...hookRegistry].flat();
 			if (flattenedHookArray.length === 0) continue;
+			if (flattenedHookArray.length === 1) {
+				resolvedHooks[hookName] = flattenedHookArray[0];
+				continue;
+			}
 			resolvedHooks[hookName] = composeHooksFromArray(flattenedHookArray, options.hooksExecutionMode ?? extraOptionDefaults.hooksExecutionMode);
 		}
 		return resolvedHooks;
 	};
 	const getResolvedMiddlewares = () => {
 		const resolvedMiddlewares = {};
-		for (const [middlewareName, middlewareRegistry] of Object.entries(middlewareRegistries)) {
+		for (const middlewareName of middlewareRegistryKeys) {
+			const middlewareRegistry = middlewareRegistries[middlewareName];
 			if (middlewareRegistry.size === 0) continue;
 			const middlewareArray = [...middlewareRegistry];
 			if (middlewareArray.length === 0) continue;
@@ -592,8 +622,9 @@ const createFetchClientWithContext = () => {
 		const $LocalRequestInfoCache = /* @__PURE__ */ new Map();
 		const callApi = async (initURL, initConfig = {}) => {
 			const [fetchOptions, extraOptions] = splitConfig(initConfig);
+			const initURLString = initURL.toString();
 			const baseConfig = isFunction(initBaseConfig) ? initBaseConfig({
-				initURL: initURL.toString(),
+				initURL: initURLString,
 				options: extraOptions,
 				request: fetchOptions
 			}) : initBaseConfig;
@@ -614,9 +645,9 @@ const createFetchClientWithContext = () => {
 			const initURLResult = getCurrentRouteSchemaKeyAndMainInitURL({
 				baseExtraOptions: baseConfig,
 				extraOptions: config,
-				initURL: initURL.toString()
+				initURL: initURLString
 			});
-			const { resolvedCurrentRouteSchemaKey, resolvedHooks, resolvedInitURL, resolvedMiddlewares, resolvedOptions, resolvedRequest } = await initializePlugins({
+			const { resolvedCurrentRouteSchemaKey, resolvedHooks, resolvedInitURL, resolvedMiddlewares, resolvedOptions, resolvedRequest } = await initializePluginsAndHooks({
 				baseConfig,
 				config,
 				...initURLResult,
@@ -635,6 +666,7 @@ const createFetchClientWithContext = () => {
 			});
 			const { fullURL, normalizedInitURL } = getFullAndNormalizedURL({
 				baseURL: resolvedOptions.baseURL,
+				debugMode: resolvedOptions.debugMode,
 				initURL: resolvedInitURL,
 				params: resolvedOptions.params,
 				query: resolvedOptions.query
@@ -656,8 +688,8 @@ const createFetchClientWithContext = () => {
 				options
 			});
 			Object.assign(options, refetchFnResult);
-			const newFetchController = new AbortController();
-			const combinedSignal = createCombinedSignal(createTimeoutSignal(options.timeout), resolvedRequest.signal, newFetchController.signal);
+			const newFetchController = options.dedupeStrategy === "none" ? null : new AbortController();
+			const combinedSignal = createCombinedSignal(createTimeoutSignal(options.timeout), resolvedRequest.signal, newFetchController?.signal);
 			const request = {
 				...resolvedRequest,
 				signal: combinedSignal