unfee 0.1.2 → 1.0.1

package/README.md

@@ -0,0 +1 @@
+# unfee

package/dist/index.d.ts

@@ -8,30 +8,41 @@ declare class HTTPError extends Error {
   constructor(response: Response, request: Request, options: FetchOptions);
 }
 //#endregion
+//#region src/parse-error.d.ts
+declare class ParseError extends Error {
+  readonly response: Response;
+  readonly request: Request;
+  readonly options: FetchOptions;
+  constructor(response: Response, request: Request, options: FetchOptions, cause?: unknown);
+}
+//#endregion
 //#region src/types.d.ts
 type Input = string | URL;
 interface Fetch {
   <T = any>(input: Input, options?: FetchOptions): Promise<FetchResponse<T>>;
   extend: (options: ExtendOptions) => Fetch;
 }
-interface FetchResponse<T> {
-  headers: Headers;
-  data: T;
-  status: number;
-  statusText: string;
-}
+type FetchResponse<T> = [error: null, data: T, response: Response | null] | [error: HTTPError | ParseError | Error, data: null, response: Response | null];
 interface ExtendOptions {
   baseUrl?: string;
   headers?: HeadersInit;
   query?: Record<string, any>;
   hooks?: Hooks;
+  signal?: AbortSignal;
+  timeout?: number;
+  retry?: Retry;
 }
 interface FetchOptions {
   method?: RequestHttpVerbs;
   query?: Record<string, any>;
   headers?: HeadersInit;
   data?: string | FormData | URLSearchParams | object;
+  responseType?: keyof typeof ResponseType;
   hooks?: Hooks;
+  signal?: AbortSignal;
+  timeout?: number;
+  native?: Omit<RequestInit, "method" | "headers" | "body" | "signal">;
+  retry?: Retry;
 }
 interface Hooks {
   beforeRequest?: (options: Omit<FetchOptions, "hooks">) => void;
@@ -39,29 +50,43 @@ interface Hooks {
   onRequestError?: (error: unknown, request: Request, options: Readonly<FetchOptions>) => void;
   onResponseError?: (error: HTTPError, response: Response, request: Request, options: Readonly<FetchOptions>) => void;
   onResponseParseError?: (error: unknown, response: Response, request: Request, options: Readonly<FetchOptions>) => void;
+  onRequestRetry?: (retryCount: number, response: Response, request: Request, options: Readonly<FetchOptions>) => void;
+}
+interface Retry {
+  times?: number;
+  delay?: number;
+  statusCode?: Set<number>;
 }
 interface Context {
-  method: string;
+  method: RequestHttpVerbs;
   url: string;
   headers: HeadersInit;
   query: URLSearchParams;
   data: BodyInit | undefined;
   options: FetchOptions;
+  responseType?: ResponseType;
+  signal?: AbortSignal;
+  timeout?: number;
   hooks: {
     beforeRequest: Hooks["beforeRequest"][];
     afterResponse: Hooks["afterResponse"][];
     onRequestError: Hooks["onRequestError"][];
     onResponseError: Hooks["onResponseError"][];
     onResponseParseError: Hooks["onResponseParseError"][];
+    onRequestRetry: Hooks["onRequestRetry"][];
   };
+  retry: Required<Retry>;
 }
 type RequestHttpVerbs = "get" | "post" | "put" | "patch" | "head" | "delete" | "options" | "trace";
 declare enum ResponseType {
   text = 0,
-  json = 1
+  json = 1,
+  formdata = 2,
+  arraybuffer = 3,
+  blob = 4
 }
 //#endregion
 //#region src/index.d.ts
-declare const bfetch: Fetch;
+declare const unfee: Fetch;
 //#endregion
-export { Context, ExtendOptions, Fetch, FetchOptions, FetchResponse, Hooks, Input, RequestHttpVerbs, ResponseType, bfetch };
+export { Context, ExtendOptions, Fetch, FetchOptions, FetchResponse, Hooks, Input, RequestHttpVerbs, ResponseType, Retry, unfee };

package/dist/index.js

@@ -13,11 +13,40 @@ var HTTPError = class extends Error {
 	}
 };
 
+//#endregion
+//#region src/constants.ts
+const RETRY_STATUS_CODES = new Set([
+	408,
+	409,
+	425,
+	429,
+	500,
+	502,
+	503,
+	504
+]);
+const PAYLOAD_METHODS = new Set([
+	"post",
+	"put",
+	"patch",
+	"delete"
+]);
+const TEXT_TYPES = new Set([
+	"image/svg",
+	"application/xml",
+	"application/xhtml",
+	"application/html"
+]);
+const JSON_RESPONSE = /^application\/(?:[\w!#$%&*.^`~-]*\+)?json(?:;.+)?$/i;
+
 //#endregion
 //#region src/types.ts
 let ResponseType = /* @__PURE__ */ function(ResponseType) {
 	ResponseType[ResponseType["text"] = 0] = "text";
 	ResponseType[ResponseType["json"] = 1] = "json";
+	ResponseType[ResponseType["formdata"] = 2] = "formdata";
+	ResponseType[ResponseType["arraybuffer"] = 3] = "arraybuffer";
+	ResponseType[ResponseType["blob"] = 4] = "blob";
 	return ResponseType;
 }({});
 
@@ -28,14 +57,18 @@ function constructRequest(ctx) {
 	return new Request(ctx.url + (query ? `?${query}` : ""), {
 		method: ctx.method,
 		headers: ctx.headers,
-		body: ctx.data
+		signal: ctx.signal,
+		body: ctx.data,
+		...ctx.options.native
 	});
 }
 function detectResponseType(responseTypeHeader) {
-	const JSON_RESPONSE = /^application\/(?:[\w!#$%&*.^`~-]*\+)?json(?:;.+)?$/i;
 	responseTypeHeader = responseTypeHeader.split(";").shift() || "";
 	if (JSON_RESPONSE.test(responseTypeHeader)) return ResponseType.json;
-	return ResponseType.text;
+	if (TEXT_TYPES.has(responseTypeHeader) || responseTypeHeader.startsWith("text/")) return ResponseType.text;
+	if (responseTypeHeader.includes("application/octet-stream")) return ResponseType.arraybuffer;
+	if (responseTypeHeader.includes("multipart/form-data")) return ResponseType.formdata;
+	return ResponseType.blob;
 }
 
 //#endregion
@@ -62,6 +95,27 @@ function mergeParams(...params) {
 	});
 	return result;
 }
+function mergeRetry(...params) {
+	const result = {
+		times: 1,
+		delay: 0,
+		statusCode: RETRY_STATUS_CODES
+	};
+	for (const param of params) {
+		if (param.times !== void 0) result.times = param.times;
+		if (param.delay !== void 0) result.delay = param.delay;
+		if (param.statusCode !== void 0) result.statusCode = param.statusCode;
+	}
+	return result;
+}
+function mergeSignals(...signals) {
+	const controller = new AbortController();
+	signals.forEach((signal) => {
+		if (signal) if (signal.aborted) controller.abort();
+		else signal.addEventListener("abort", () => controller.abort());
+	});
+	return controller.signal;
+}
 
 //#endregion
 //#region src/parse-error.ts
@@ -75,13 +129,18 @@ var ParseError = class extends Error {
 	}
 };
 
+//#endregion
+//#region src/utils.ts
+function isIdempotentRequest(method) {
+	return !PAYLOAD_METHODS.has(method);
+}
+
 //#endregion
 //#region src/fetch.ts
-function createContext(input, options, extendOption) {
-	let method = "get";
+function createContext(input, options, extendOption, timeoutSignal) {
+	const method = options.method ?? "get";
 	let data;
 	let headers = { Accept: "application/json, text/plain, */*" };
-	if (options.method) method = options.method;
 	if (options.data instanceof URLSearchParams) {
 		headers["Content-Type"] = "application/x-www-form-urlencoded";
 		data = options.data.toString();
@@ -98,70 +157,93 @@ function createContext(input, options, extendOption) {
 		...options.headers ?? {}
 	};
 	return {
-		method: method.toUpperCase(),
+		method,
 		url: mergeURL(input, extendOption.baseUrl),
 		query: mergeParams(extendOption.query ?? {}, options.query ?? {}),
+		retry: mergeRetry(extendOption.retry ?? {}, options.retry ?? {}),
+		responseType: options.responseType ? ResponseType[options.responseType] : void 0,
 		headers,
 		data,
 		options,
+		timeout: options.timeout ?? extendOption.timeout,
+		signal: mergeSignals(extendOption.signal, options.signal, timeoutSignal),
 		hooks: {
 			onRequestError: [extendOption.hooks?.onRequestError, options.hooks?.onRequestError],
 			onResponseError: [extendOption.hooks?.onResponseError, options.hooks?.onResponseError],
 			beforeRequest: [extendOption.hooks?.beforeRequest, options.hooks?.beforeRequest],
 			afterResponse: [extendOption.hooks?.afterResponse, options.hooks?.afterResponse],
-			onResponseParseError: [extendOption.hooks?.onResponseParseError, options.hooks?.onResponseParseError]
+			onResponseParseError: [extendOption.hooks?.onResponseParseError, options.hooks?.onResponseParseError],
+			onRequestRetry: [extendOption.hooks?.onRequestRetry, options.hooks?.onRequestRetry]
 		}
 	};
 }
 async function createFetchResponse(response, request, ctx) {
-	const contentType = detectResponseType(response.headers.get("content-type") ?? "application/json");
+	ctx.hooks.afterResponse[0]?.(request, response, ctx.options);
+	ctx.hooks.afterResponse[1]?.(request, response, ctx.options);
+	const contentType = ctx.responseType ?? detectResponseType(response.headers.get("content-type") ?? "application/json");
 	let data;
 	try {
 		if (contentType === ResponseType.json) data = await response.json();
+		else if (contentType === ResponseType.formdata) data = await response.formData();
+		else if (contentType === ResponseType.arraybuffer) data = await response.arrayBuffer();
+		else if (contentType === ResponseType.blob) data = await response.blob();
 		else data = await response.text();
 	} catch (error) {
 		throw new ParseError(response, request, ctx.options, error);
 	}
-	return {
-		data,
-		status: response.status,
-		headers: response.headers,
-		statusText: response.statusText
-	};
+	return data;
+}
+async function handleFetchError(response, request, ctx, error, retryCount) {
+	if (error instanceof ParseError) {
+		ctx.hooks.onResponseParseError[0]?.(error, response, request, ctx.options);
+		ctx.hooks.onResponseParseError[1]?.(error, response, request, ctx.options);
+	} else if (error instanceof HTTPError) {
+		ctx.hooks.onResponseError[0]?.(error, response, request, ctx.options);
+		ctx.hooks.onResponseError[1]?.(error, response, request, ctx.options);
+		if (isIdempotentRequest(ctx.method) && ctx.retry.statusCode.has(response.status) && retryCount < ctx.retry.times) {
+			ctx.hooks.onRequestRetry[0]?.(retryCount, response, request, ctx.options);
+			ctx.hooks.onRequestRetry[1]?.(retryCount, response, request, ctx.options);
+			if (ctx.retry.delay > 0) await new Promise((resolve) => setTimeout(resolve, ctx.retry.delay));
+		}
+	} else {
+		ctx.hooks.onRequestError[0]?.(error, request, ctx.options);
+		ctx.hooks.onRequestError[1]?.(error, request, ctx.options);
+	}
 }
 function createFetch(extendOptions) {
 	const $fetch = async function(input, options = {}) {
-		extendOptions.hooks?.beforeRequest?.(options);
-		options.hooks?.beforeRequest?.(options);
-		const context = createContext(input, options, extendOptions);
-		const request = constructRequest(context);
-		let inflight;
-		try {
-			inflight = await fetch(request);
-			if (!inflight.ok) throw new HTTPError(inflight, request, context.options);
-			context.hooks.afterResponse[0]?.(request, inflight, options);
-			context.hooks.afterResponse[1]?.(request, inflight, options);
-			return await createFetchResponse(inflight, request, context);
-		} catch (error) {
-			if (error instanceof ParseError) {
-				context.hooks.onResponseParseError[0]?.(error, inflight, request, options);
-				context.hooks.onResponseParseError[1]?.(error, inflight, request, options);
-			} else if (error instanceof HTTPError) {
-				context.hooks.onResponseError[0]?.(error, inflight, request, options);
-				context.hooks.onResponseError[1]?.(error, inflight, request, options);
-			} else {
-				context.hooks.onRequestError[0]?.(error, request, options);
-				context.hooks.onRequestError[1]?.(error, request, options);
+		let context = null;
+		let maxRetries = 0;
+		for (let retryCount = 0; retryCount <= maxRetries; retryCount++) {
+			extendOptions.hooks?.beforeRequest?.(options);
+			options.hooks?.beforeRequest?.(options);
+			const timeoutController = new AbortController();
+			let timer;
+			context = createContext(input, options, extendOptions, timeoutController.signal);
+			if (context.timeout) timer = setTimeout(() => {
+				timeoutController.abort();
+			}, context.timeout);
+			maxRetries = context.retry.times;
+			const request = constructRequest(context);
+			let inflight;
+			try {
+				inflight = await fetch(request);
+				if (!inflight.ok) throw new HTTPError(inflight, request, context.options);
+				return await createFetchResponse(inflight, request, context);
+			} catch (error) {
+				await handleFetchError(inflight, request, context, error, retryCount);
+			} finally {
+				clearTimeout(timer);
 			}
-			throw error;
 		}
+		throw new Error("Failed to fetch after retries");
 	};
 	return Object.assign($fetch, { extend: createFetch });
 }
 
 //#endregion
 //#region src/index.ts
-const bfetch = createFetch({});
+const unfee = createFetch({});
 
 //#endregion
-export { ResponseType, bfetch };
+export { ResponseType, unfee };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "unfee",
   "type": "module",
-  "version": "0.1.2",
+  "version": "1.0.1",
   "description": "Fetch API with sensible defaults",
   "license": "MIT",
   "repository": "ayb-cha/unfee",