@afoures/http-client 0.2.0 → 0.3.0

package/dist/lib/endpoint.d.mts

@@ -33,7 +33,7 @@ declare class Endpoint<http_method extends HTTPMethod.Any, pathname extends Path
     body: BodyInit | null;
     content_type?: string;
   } | SerializationError>;
-  parse_response(response: Response): Promise<HTTPFetch.ClientErrorResponse<Schema.infer_output<error_schema, string>> | HTTPFetch.ServerErrorResponse<Schema.infer_output<error_schema, string>> | HTTPFetch.SuccessfulResponse<Schema.infer_output<data_schema, void>> | HTTPFetch.RedirectMessage | ParseError>;
+  parse_response(raw_response: Response): Promise<HTTPFetch.ClientErrorResponse<Schema.infer_output<error_schema, string>> | HTTPFetch.ServerErrorResponse<Schema.infer_output<error_schema, string>> | HTTPFetch.SuccessfulResponse<Schema.infer_output<data_schema, void>> | HTTPFetch.RedirectMessage | ParseError>;
 }
 type AnyEndpoint = Endpoint<any, any, any, any, any, any, any>;
 //#endregion

package/dist/lib/endpoint.mjs

@@ -3,6 +3,77 @@ import "./types.mjs";
 import { RoutePattern } from "@remix-run/route-pattern";
 
 //#region src/lib/endpoint.ts
+const RESPONSE = {
+	success(method, data, raw_response) {
+		const response = {
+			ok: true,
+			method,
+			url: raw_response.url,
+			status: raw_response.status,
+			data,
+			headers: raw_response.headers,
+			raw_response
+		};
+		Object.defineProperty(response, "raw_response", {
+			enumerable: false,
+			writable: false,
+			configurable: false
+		});
+		return response;
+	},
+	redirect(method, raw_response) {
+		const redirect_to = raw_response.headers.get("Location") || null;
+		const response = {
+			ok: false,
+			method,
+			url: raw_response.url,
+			status: raw_response.status,
+			redirect_to,
+			headers: raw_response.headers,
+			raw_response
+		};
+		Object.defineProperty(response, "raw_response", {
+			enumerable: false,
+			writable: false,
+			configurable: false
+		});
+		return response;
+	},
+	client_error(method, error, raw_response) {
+		const response = {
+			ok: false,
+			method,
+			url: raw_response.url,
+			status: raw_response.status,
+			error,
+			headers: raw_response.headers,
+			raw_response
+		};
+		Object.defineProperty(response, "raw_response", {
+			enumerable: false,
+			writable: false,
+			configurable: false
+		});
+		return response;
+	},
+	server_error(method, error, raw_response) {
+		const response = {
+			ok: false,
+			method,
+			url: raw_response.url,
+			status: raw_response.status,
+			error,
+			headers: raw_response.headers,
+			raw_response
+		};
+		Object.defineProperty(response, "raw_response", {
+			enumerable: false,
+			writable: false,
+			configurable: false
+		});
+		return response;
+	}
+};
 var Endpoint = class {
 	#method;
 	#pattern;
@@ -35,7 +106,8 @@ var Endpoint = class {
 			const result = await this.#serializers.params.schema["~standard"].validate(init.params);
 			if (result.issues !== void 0) return new SerializationError("Params serialization failed", {
 				operation: "generate_url",
-				cause: result.issues
+				cause: result.issues,
+				input: { params: init.params }
 			});
 			const transformed_params = result.value;
 			if (this.#serializers.params.serialize) pathname_params = this.#serializers.params.serialize(transformed_params);
@@ -47,7 +119,8 @@ var Endpoint = class {
 			const result = await this.#serializers.query.schema["~standard"].validate(init.query);
 			if (result.issues !== void 0) return new SerializationError("Query serialization failed", {
 				cause: result.issues,
-				operation: "generate_url"
+				operation: "generate_url",
+				input: { query: init.query }
 			});
 			const transformed_query = result.value;
 			if (typeof this.#serializers.query.serialize === "function") search_params = this.#serializers.query.serialize(transformed_query);
@@ -80,7 +153,8 @@ var Endpoint = class {
 		const result = await this.#serializers.body.schema["~standard"].validate(init.body);
 		if (result.issues !== void 0) return new SerializationError("Body serialization failed", {
 			operation: "serialize_body",
-			cause: result.issues
+			cause: result.issues,
+			input: { body: init.body }
 		});
 		const transformed_content = result.value;
 		if (typeof this.#serializers.body.serialize === "function") return this.#serializers.body.serialize(transformed_content);
@@ -89,74 +163,51 @@ var Endpoint = class {
 			content_type: "application/json"
 		};
 	}
-	async parse_response(response) {
-		const raw_response = response;
-		const cloned_response = response.clone();
-		const status = cloned_response.status;
-		const headers = cloned_response.headers;
-		if (status >= 300 && status < 400) return {
-			ok: false,
-			status,
-			redirect_to: headers.get("Location") || null,
-			headers,
-			raw_response
-		};
-		if (status >= 400 && status < 600) {
+	async parse_response(raw_response) {
+		const response = raw_response.clone();
+		if (raw_response.status >= 300 && raw_response.status < 400) return RESPONSE.redirect(this.#method, raw_response);
+		if (raw_response.status >= 400 && raw_response.status < 600) {
 			let error;
 			if (this.#parsers.error) {
 				const parser = this.#parsers.error;
 				let parsed;
-				if (typeof parser.parse === "function") parsed = await parser.parse(cloned_response.body);
-				else if (parser.parse === "json") parsed = await parse_as_json(cloned_response);
-				else if (parser.parse === "text") parsed = await cloned_response.text();
+				if (typeof parser.parse === "function") parsed = await parser.parse(response.body);
+				else if (parser.parse === "json") parsed = await parse_as_json(response);
+				else if (parser.parse === "text") parsed = await response.text();
 				const result = await parser.schema["~standard"].validate(parsed);
 				if (result.issues !== void 0) return new ParseError("Error parsing failed", {
 					cause: result.issues,
-					operation: "parse_response"
+					operation: "parse_response",
+					response: {
+						status: raw_response.status,
+						headers: raw_response.headers,
+						body: parsed
+					}
 				});
 				error = result.value;
-			} else error = await cloned_response.text();
-			return {
-				ok: false,
-				status,
-				error,
-				headers,
-				raw_response
-			};
+			} else error = await response.text();
+			return raw_response.status >= 400 && raw_response.status < 500 ? RESPONSE.client_error(this.#method, error, raw_response) : RESPONSE.server_error(this.#method, error, raw_response);
 		}
-		if (status >= 200 && status < 300) {
-			if (status === 204) return {
-				ok: true,
-				status: 204,
-				data: null,
-				headers,
-				raw_response
-			};
+		if (raw_response.status >= 200 && raw_response.status < 300) {
+			if (raw_response.status === 204) return RESPONSE.success(this.#method, null, raw_response);
 			if (this.#parsers.data) {
 				const parser = this.#parsers.data;
 				let parsed;
-				if (typeof parser.parse === "function") parsed = await parser.parse(cloned_response.body);
-				else if (parser.parse === "json") parsed = await parse_as_json(cloned_response);
-				else if (parser.parse === "text") parsed = await cloned_response.text();
+				if (typeof parser.parse === "function") parsed = await parser.parse(response.body);
+				else if (parser.parse === "json") parsed = await parse_as_json(response);
+				else if (parser.parse === "text") parsed = await response.text();
 				const result = await parser.schema["~standard"].validate(parsed);
 				if (result.issues !== void 0) return new ParseError("Response parsing failed", {
 					cause: result.issues,
-					operation: "parse_response"
+					operation: "parse_response",
+					response: {
+						status: raw_response.status,
+						headers: raw_response.headers,
+						body: parsed
+					}
 				});
-				return {
-					ok: true,
-					status,
-					data: result.value,
-					headers,
-					raw_response
-				};
-			} else return {
-				ok: true,
-				status,
-				data: null,
-				headers,
-				raw_response
-			};
+				return RESPONSE.success(this.#method, result.value, raw_response);
+			} else return RESPONSE.success(this.#method, null, raw_response);
 		}
 		throw new Error(`Unhandled status code: ${status}`);
 	}

package/dist/lib/errors.d.mts

@@ -1,54 +1,78 @@
 //#region src/lib/errors.d.ts
-type BaseContext = {
-  operation: string;
+type RequestContext = {
+  url: string;
+  method: string;
+  pathname?: string;
+  baseUrl?: string;
+  headers?: Headers;
+  timeout?: number;
+};
+type ResponseContext = {
+  status: number;
+  statusText?: string;
+  headers?: Headers;
+  body?: unknown;
+};
+type TimingContext = {
+  startTime?: number;
+  duration?: number;
+  attempt?: number;
+  maxAttempts?: number;
 };
-type ErrorCause = {
-  cause?: unknown;
+type InputContext = {
+  params?: unknown;
+  query?: unknown;
+  body?: unknown;
+};
+type ErrorContext = {
+  operation: string;
+  request?: RequestContext;
+  response?: ResponseContext;
+  timing?: TimingContext;
+  input?: InputContext;
 };
 declare class HttpClientError extends Error {
-  constructor(message: string, options: ErrorCause);
-}
-declare class TimeoutError extends HttpClientError {
-  readonly context: BaseContext;
+  readonly context: ErrorContext;
   constructor(message: string, {
     cause,
-    ...context
-  }: ErrorCause & BaseContext);
+    ...options
+  }: {
+    cause?: unknown;
+  } & Partial<ErrorContext>);
+}
+declare class TimeoutError extends HttpClientError {
+  constructor(message: string, options: {
+    cause?: unknown;
+  } & Partial<ErrorContext>);
 }
 declare class AbortedError extends HttpClientError {
-  readonly context: BaseContext;
-  constructor(message: string, {
-    cause,
-    ...context
-  }: ErrorCause & BaseContext);
+  constructor(message: string, options: {
+    cause?: unknown;
+  } & Partial<ErrorContext>);
 }
 declare class SerializationError extends HttpClientError {
-  readonly context: BaseContext;
-  constructor(message: string, {
-    cause,
-    ...context
-  }: ErrorCause & BaseContext);
+  constructor(message: string, options: {
+    cause?: unknown;
+  } & Partial<ErrorContext>);
 }
 declare class ParseError extends HttpClientError {
-  readonly context: BaseContext;
-  constructor(message: string, {
-    cause,
-    ...context
-  }: ErrorCause & BaseContext);
+  constructor(message: string, options: {
+    cause?: unknown;
+  } & Partial<ErrorContext>);
 }
 declare class NetworkError extends HttpClientError {
-  readonly context: BaseContext;
-  constructor(message: string, {
-    cause,
-    ...context
-  }: ErrorCause & BaseContext);
+  constructor(message: string, options: {
+    cause?: unknown;
+  } & Partial<ErrorContext>);
 }
 declare class UnexpectedError extends Error {
-  readonly context: BaseContext;
+  readonly context: ErrorContext;
   constructor(message: string, {
     cause,
-    ...context
-  }: ErrorCause & BaseContext);
+    ...options
+  }: {
+    cause?: unknown;
+  } & Partial<ErrorContext>);
 }
 //#endregion
 export { AbortedError, HttpClientError, NetworkError, ParseError, SerializationError, TimeoutError, UnexpectedError };

package/dist/lib/errors.mjs

@@ -1,56 +1,54 @@
 //#region src/lib/errors.ts
 var HttpClientError = class extends Error {
-	constructor(message, options) {
-		super(message, options);
+	context;
+	constructor(message, { cause, ...options }) {
+		super(message, { cause });
 		this.name = "HttpClientError";
+		this.context = {
+			...options,
+			operation: options.operation ?? "unknown"
+		};
 	}
 };
 var TimeoutError = class extends HttpClientError {
-	context;
-	constructor(message, { cause, ...context }) {
-		super(message, { cause });
+	constructor(message, options) {
+		super(message, options);
 		this.name = "TimeoutError";
-		this.context = context;
 	}
 };
 var AbortedError = class extends HttpClientError {
-	context;
-	constructor(message, { cause, ...context }) {
-		super(message, { cause });
+	constructor(message, options) {
+		super(message, options);
 		this.name = "AbortedError";
-		this.context = context;
 	}
 };
 var SerializationError = class extends HttpClientError {
-	context;
-	constructor(message, { cause, ...context }) {
-		super(message, { cause });
+	constructor(message, options) {
+		super(message, options);
 		this.name = "SerializationError";
-		this.context = context;
 	}
 };
 var ParseError = class extends HttpClientError {
-	context;
-	constructor(message, { cause, ...context }) {
-		super(message, { cause });
+	constructor(message, options) {
+		super(message, options);
 		this.name = "ParseError";
-		this.context = context;
 	}
 };
 var NetworkError = class extends HttpClientError {
-	context;
-	constructor(message, { cause, ...context }) {
-		super(message, { cause });
+	constructor(message, options) {
+		super(message, options);
 		this.name = "NetworkError";
-		this.context = context;
 	}
 };
 var UnexpectedError = class extends Error {
 	context;
-	constructor(message, { cause, ...context }) {
+	constructor(message, { cause, ...options }) {
 		super(message, { cause });
 		this.name = "UnexpectedError";
-		this.context = context;
+		this.context = {
+			...options,
+			operation: options.operation ?? "unknown"
+		};
 	}
 };
 

package/dist/lib/http-client.mjs

@@ -6,7 +6,16 @@ import { extract_args, merge_options, remove_custom_options, sleep } from "./uti
 //#region src/lib/http-client.ts
 function fetch_endpoint_factory({ base_url, endpoint, custom_fetch, get_default_options = () => ({}), hooks = {} }) {
 	async function fetch_endpoint(input) {
-		if (!URL.canParse(base_url)) return new UnexpectedError(`Invalid base_url: ${base_url}`, { operation: "base_url_validation" });
+		let start_time = Date.now();
+		if (!URL.canParse(base_url)) return new UnexpectedError(`Invalid base_url: ${base_url}`, {
+			operation: "base_url_validation",
+			request: {
+				url: base_url,
+				method: endpoint.method,
+				baseUrl: base_url
+			},
+			timing: { startTime: start_time }
+		});
 		const { args, options } = extract_args(input);
 		const { headers, ...merged_options } = merge_options(await get_default_options(), endpoint.options, options);
 		const url = await endpoint.generate_url({
@@ -15,12 +24,29 @@ function fetch_endpoint_factory({ base_url, endpoint, custom_fetch, get_default_
 			query: args.query
 		}).catch((error) => new UnexpectedError("Failed to generate URL", {
 			cause: error,
-			operation: "generate_url"
+			operation: "generate_url",
+			request: {
+				url: base_url,
+				method: endpoint.method,
+				baseUrl: base_url
+			},
+			input: {
+				params: args.params,
+				query: args.query
+			},
+			timing: { startTime: start_time }
 		}));
 		if (url instanceof Error) return url;
 		const serialized = await endpoint.serialize_body({ body: args.body }).catch((error) => new UnexpectedError("Failed to serialize body", {
 			cause: error,
-			operation: "serialize_body"
+			operation: "serialize_body",
+			request: {
+				url: url instanceof URL ? url.toString() : base_url,
+				method: endpoint.method,
+				baseUrl: base_url
+			},
+			input: { body: args.body },
+			timing: { startTime: start_time }
 		}));
 		if (serialized instanceof Error) return serialized;
 		headers.delete("Content-Type");
@@ -50,7 +76,18 @@ function fetch_endpoint_factory({ base_url, endpoint, custom_fetch, get_default_
 			} catch (local_error) {
 				error = new UnexpectedError("Failed to create request", {
 					cause: local_error,
-					operation: "create_request"
+					operation: "create_request",
+					request: {
+						url: url instanceof URL ? url.toString() : base_url,
+						method: endpoint.method,
+						headers,
+						timeout: options.timeout,
+						baseUrl: base_url
+					},
+					timing: {
+						startTime: start_time,
+						attempt: 1
+					}
 				});
 				break;
 			}
@@ -60,17 +97,48 @@ function fetch_endpoint_factory({ base_url, endpoint, custom_fetch, get_default_
 				response = await custom_fetch(request);
 				error = void 0;
 			} catch (local_error) {
+				const duration = Date.now() - start_time;
 				if (local_error instanceof Error && local_error.name === "TimeoutError") error = new TimeoutError(local_error.message, {
 					cause: local_error,
-					operation: "fetch"
+					operation: "fetch",
+					request: {
+						url: request.url,
+						method: request.method,
+						timeout: options.timeout
+					},
+					timing: {
+						startTime: start_time,
+						duration,
+						attempt
+					}
 				});
 				else if (local_error instanceof Error && local_error.name === "AbortError") error = new AbortedError(local_error.message, {
 					cause: local_error,
-					operation: "fetch"
+					operation: "fetch",
+					request: {
+						url: request.url,
+						method: request.method,
+						timeout: options.timeout
+					},
+					timing: {
+						startTime: start_time,
+						duration,
+						attempt
+					}
 				});
 				else error = new NetworkError("Network error", {
 					cause: local_error,
-					operation: "fetch"
+					operation: "fetch",
+					request: {
+						url: request.url,
+						method: request.method,
+						timeout: options.timeout
+					},
+					timing: {
+						startTime: start_time,
+						duration,
+						attempt
+					}
 				});
 			}
 			try {
@@ -91,25 +159,77 @@ function fetch_endpoint_factory({ base_url, endpoint, custom_fetch, get_default_
 			} catch (local_error) {
 				error = new UnexpectedError("Failed to check retry policy", {
 					cause: local_error,
-					operation: "retry_policy"
+					operation: "retry_policy",
+					request: {
+						url: url instanceof URL ? url.toString() : base_url,
+						method: endpoint.method,
+						timeout: options.timeout,
+						baseUrl: base_url
+					},
+					timing: {
+						startTime: start_time,
+						attempt,
+						maxAttempts: typeof retry_policy.attempts === "function" ? void 0 : retry_policy.attempts
+					}
 				});
 				break;
 			}
 		} while (true);
 		if (error) return error;
-		if (!response) return new UnexpectedError("", {
+		if (!response) return new UnexpectedError("No response received", {
 			cause: "No response received",
-			operation: "parse_response"
+			operation: "parse_response",
+			request: {
+				url: url instanceof URL ? url.toString() : base_url,
+				method: endpoint.method,
+				timeout: options.timeout,
+				baseUrl: base_url
+			},
+			timing: {
+				startTime: start_time,
+				attempt
+			}
 		});
 		hooks.on_response?.(response);
-		return await endpoint.parse_response(response).catch((error) => {
+		return await endpoint.parse_response(response).catch(async (error) => {
+			const response_body = await response.clone().text().catch(() => void 0);
 			if (error instanceof Error && error.name === "AbortError") return new AbortedError(error.message, {
 				cause: error,
-				operation: "parse_response"
+				operation: "parse_response",
+				request: {
+					url: response.url,
+					method: request?.method
+				},
+				response: {
+					status: response.status,
+					statusText: response.statusText,
+					headers: response.headers,
+					body: response_body
+				},
+				timing: {
+					startTime: start_time,
+					attempt
+				}
 			});
 			return new UnexpectedError("Failed to parse response", {
 				cause: error,
-				operation: "parse_response"
+				operation: "parse_response",
+				request: {
+					url: response.url,
+					method: request?.method,
+					timeout: options.timeout,
+					baseUrl: base_url
+				},
+				response: {
+					status: response.status,
+					statusText: response.statusText,
+					headers: response.headers,
+					body: response_body
+				},
+				timing: {
+					startTime: start_time,
+					attempt
+				}
 			});
 		});
 	}

package/dist/lib/types.d.mts

@@ -63,6 +63,8 @@ declare namespace RetryPolicy {
 }
 declare namespace HTTPFetch {
   type SharedResponseContent = {
+    method: HTTPMethod.Any;
+    url?: string;
     headers: Headers;
     raw_response: Response;
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@afoures/http-client",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "A typesafe and robust HTTP client",
   "homepage": "https://github.com/afoures/http-client#readme",
   "bugs": {
@@ -35,12 +35,12 @@
     "@standard-schema/spec": "^1.1.0"
   },
   "devDependencies": {
-    "@afoures/auto-release": "^0.4.1",
+    "@afoures/auto-release": "^0.5.0",
     "@arktype/attest": "^0.56.0",
-    "@types/node": "^24.12.0",
-    "msw": "^2.12.10",
+    "@types/node": "^24.12.2",
+    "msw": "^2.13.2",
     "oxfmt": "^0.36.0",
-    "oxlint": "^1.51.0",
+    "oxlint": "^1.59.0",
     "tsdown": "^0.21.0",
     "typescript": "^5.9.3",
     "zod": "^4.3.6"