@afoures/http-client 0.2.0 → 0.4.0

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { AbortedError, HttpClientError, NetworkError, ParseError, SerializationError, TimeoutError, UnexpectedError } from "./lib/errors.mjs";
 import { HTTPFetch, HTTPMethod, HTTPStatus, Parser, Pathname, Schema, Serializer } from "./lib/types.mjs";
 import { AnyEndpoint, Endpoint, EndpointDefinition } from "./lib/endpoint.mjs";
-import { EndpointMap, HttpClientOptions, http_client } from "./lib/http-client.mjs";
-export { AbortedError, type AnyEndpoint, Endpoint, type EndpointDefinition, type EndpointMap, type HTTPFetch, type HTTPMethod, type HTTPStatus, HttpClientError, type HttpClientOptions, NetworkError, ParseError, type Parser, type Pathname, type Schema, SerializationError, type Serializer, TimeoutError, UnexpectedError, http_client };
+import { $infer, EndpointMap, HttpClientOptions, http_client } from "./lib/http-client.mjs";
+export { type $infer, AbortedError, type AnyEndpoint, Endpoint, type EndpointDefinition, type EndpointMap, type HTTPFetch, type HTTPMethod, type HTTPStatus, HttpClientError, type HttpClientOptions, NetworkError, ParseError, type Parser, type Pathname, type Schema, SerializationError, type Serializer, TimeoutError, UnexpectedError, http_client };

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.d.mts

@@ -1,5 +1,5 @@
 import { AbortedError, NetworkError, ParseError, SerializationError, TimeoutError, UnexpectedError } from "./errors.mjs";
-import { HTTPFetch, HTTPMethod, HeadersInitWithReducer, MaybePromise, Schema } from "./types.mjs";
+import { HTTPFetch, HTTPMethod, HeadersInitWithReducer, MaybePromise, Pathname, Pretty, Schema } from "./types.mjs";
 import { AnyEndpoint, Endpoint } from "./endpoint.mjs";
 import * as _standard_schema_spec0 from "@standard-schema/spec";
 
@@ -8,6 +8,23 @@ interface EndpointMap {
   [name: string]: AnyEndpoint | EndpointMap;
 }
 type CustomFetch = (request: Request) => Promise<Response>;
+type Hooks = {
+  on_request?: (request: Request) => void;
+  on_response?: (response: Response) => void;
+};
+declare function fetch_endpoint_factory<http_method extends HTTPMethod.Any, pathname extends Pathname.Relative, params_schema extends Schema._, query_schema extends Schema._, body_schema extends Schema._, data_schema extends Schema._, error_schema extends Schema._>({
+  base_url,
+  endpoint,
+  custom_fetch,
+  get_default_options,
+  hooks
+}: {
+  base_url: string;
+  endpoint: Endpoint<http_method, pathname, params_schema, query_schema, body_schema, data_schema, error_schema>;
+  custom_fetch: CustomFetch;
+  get_default_options?: () => MaybePromise<HTTPFetch.OptionalRequestInit & HTTPFetch.DefaultRequestInit>;
+  hooks?: Hooks;
+}): (input: Pretty<HTTPFetch.TypedParamsInit<pathname, params_schema> & HTTPFetch.TypedQueryInit<query_schema> & HTTPFetch.TypedBodyInit<body_schema> & HTTPFetch.OptionalRequestInit & HTTPFetch.DefaultRequestInit>) => Promise<TimeoutError | AbortedError | SerializationError | ParseError | NetworkError | UnexpectedError | HTTPFetch.RedirectMessage | HTTPFetch.ClientErrorResponse<[error_schema] extends [never] ? string : _standard_schema_spec0.StandardSchemaV1.InferOutput<error_schema>> | HTTPFetch.ServerErrorResponse<[error_schema] extends [never] ? string : _standard_schema_spec0.StandardSchemaV1.InferOutput<error_schema>> | HTTPFetch.SuccessfulResponse<[data_schema] extends [never] ? void : _standard_schema_spec0.StandardSchemaV1.InferOutput<data_schema>>>;
 type HttpClientOptions<endpoints extends EndpointMap> = {
   base_url: string;
   endpoints: endpoints;
@@ -60,5 +77,19 @@ declare function http_client<const endpoints extends EndpointMap>({
 } & Omit<RequestInit, "body" | "method" | "headers"> extends infer T_16 ? { [K_10 in keyof T_16]: T_16[K_10] } : never) => Promise<TimeoutError | AbortedError | SerializationError | ParseError | NetworkError | UnexpectedError | HTTPFetch.RedirectMessage | HTTPFetch.ClientErrorResponse<[error_schema] extends [never] ? string : _standard_schema_spec0.StandardSchemaV1.InferOutput<error_schema>> | HTTPFetch.ServerErrorResponse<[error_schema] extends [never] ? string : _standard_schema_spec0.StandardSchemaV1.InferOutput<error_schema>> | HTTPFetch.SuccessfulResponse<[data_schema] extends [never] ? void : _standard_schema_spec0.StandardSchemaV1.InferOutput<data_schema>>> : T_15[name_9] extends EndpointMap ? (T_15[name_9] extends infer T_17 extends EndpointMap ? { -readonly [name_10 in keyof T_17]: T_17[name_10] extends Endpoint<infer http_method extends HTTPMethod.Any, infer pathname extends `/${string}`, infer params_schema extends Schema._<unknown, unknown>, infer query_schema extends Schema._<unknown, unknown>, infer body_schema extends Schema._<unknown, unknown>, infer data_schema extends Schema._<unknown, unknown>, infer error_schema extends Schema._<unknown, unknown>> ? (input: HTTPFetch.TypedParamsInit<pathname, params_schema> & HTTPFetch.TypedQueryInit<query_schema> & HTTPFetch.TypedBodyInit<body_schema> & HTTPFetch.OptionalRequestInit & {
   headers?: HeadersInitWithReducer;
 } & Omit<RequestInit, "body" | "method" | "headers"> extends infer T_18 ? { [K_11 in keyof T_18]: T_18[K_11] } : never) => Promise<TimeoutError | AbortedError | SerializationError | ParseError | NetworkError | UnexpectedError | HTTPFetch.RedirectMessage | HTTPFetch.ClientErrorResponse<[error_schema] extends [never] ? string : _standard_schema_spec0.StandardSchemaV1.InferOutput<error_schema>> | HTTPFetch.ServerErrorResponse<[error_schema] extends [never] ? string : _standard_schema_spec0.StandardSchemaV1.InferOutput<error_schema>> | HTTPFetch.SuccessfulResponse<[data_schema] extends [never] ? void : _standard_schema_spec0.StandardSchemaV1.InferOutput<data_schema>>> : T_17[name_10] extends EndpointMap ? (T_17[name_10] extends infer T_19 extends EndpointMap ? { -readonly [name_11 in keyof T_19]: T_19[name_11] extends Endpoint<infer http_method extends HTTPMethod.Any, infer pathname extends `/${string}`, infer params_schema extends Schema._<unknown, unknown>, infer query_schema extends Schema._<unknown, unknown>, infer body_schema extends Schema._<unknown, unknown>, infer data_schema extends Schema._<unknown, unknown>, infer error_schema extends Schema._<unknown, unknown>> ? (input: /*elided*/any) => Promise<TimeoutError | AbortedError | SerializationError | ParseError | NetworkError | UnexpectedError | HTTPFetch.RedirectMessage | HTTPFetch.ClientErrorResponse<[error_schema] extends [never] ? string : _standard_schema_spec0.StandardSchemaV1.InferOutput<error_schema>> | HTTPFetch.ServerErrorResponse<[error_schema] extends [never] ? string : _standard_schema_spec0.StandardSchemaV1.InferOutput<error_schema>> | HTTPFetch.SuccessfulResponse<[data_schema] extends [never] ? void : _standard_schema_spec0.StandardSchemaV1.InferOutput<data_schema>>> : T_19[name_11] extends EndpointMap ? /*elided*/any : never } : never) extends infer T_18 ? { [K_11 in keyof T_18]: T_18[K_11] } : never : never } : never) extends infer T_16 ? { [K_10 in keyof T_16]: T_16[K_10] } : never : never } : never) extends infer T_14 ? { [K_9 in keyof T_14]: T_14[K_9] } : never : never } : never) extends infer T_12 ? { [K_8 in keyof T_12]: T_12[K_8] } : never : never } : never) extends infer T_10 ? { [K_7 in keyof T_10]: T_10[K_7] } : never : never } : never) extends infer T_8 ? { [K_6 in keyof T_8]: T_8[K_6] } : never : never } : never) extends infer T_6 ? { [K_5 in keyof T_6]: T_6[K_5] } : never : never } : never) extends infer T_4 ? { [K_4 in keyof T_4]: T_4[K_4] } : never : never } : never) extends infer T_2 ? { [K_3 in keyof T_2]: T_2[K_3] } : never : never } : never) extends infer T ? { [K_2 in keyof T]: T[K_2] } : never : never }[K] };
+type AnyFetchEndpointFunction = ReturnType<typeof fetch_endpoint_factory<any, any, any, any, any, any, any>>;
+declare namespace $infer {
+  type Query<fetch_endpoint extends AnyFetchEndpointFunction> = Parameters<fetch_endpoint>[0] extends {
+    query: infer query;
+  } ? query : never;
+  type Params<fetch_endpoint extends AnyFetchEndpointFunction> = Parameters<fetch_endpoint>[0] extends {
+    params: infer params;
+  } ? params : never;
+  type Body<fetch_endpoint extends AnyFetchEndpointFunction> = Parameters<fetch_endpoint>[0] extends {
+    body: infer body;
+  } ? body : never;
+  type Data<fetch_endpoint extends AnyFetchEndpointFunction> = ReturnType<fetch_endpoint> extends HTTPFetch.SuccessfulResponse<infer data> ? data : never;
+  type Error<fetch_endpoint extends AnyFetchEndpointFunction> = ReturnType<fetch_endpoint> extends HTTPFetch.ClientErrorResponse<infer error> ? error : ReturnType<fetch_endpoint> extends HTTPFetch.ServerErrorResponse<infer error> ? error : never;
+}
 //#endregion
-export { EndpointMap, HttpClientOptions, http_client };
+export { $infer, EndpointMap, HttpClientOptions, http_client };

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/docs/http-client.md

@@ -145,3 +145,46 @@ if (result.ok) {
   console.log(result.error)
 }
 ```
+
+## Type Inference
+
+The `$infer` namespace provides helpers to extract types from endpoint functions:
+
+```typescript
+import { $infer, http_client, Endpoint } from '@afoures/http-client'
+import { z } from 'zod'
+
+const api = http_client({
+  base_url: 'https://api.example.com',
+  endpoints: {
+    users: {
+      list: new Endpoint({
+        method: 'GET',
+        pathname: '/users',
+        data: { schema: z.array(z.object({ id: z.string(), name: z.string() })), parse: 'json' },
+      }),
+      create: new Endpoint({
+        method: 'POST',
+        pathname: '/users',
+        body: { schema: z.object({ name: z.string() }) },
+        data: { schema: z.object({ id: z.string(), name: z.string() }), parse: 'json' },
+      }),
+    },
+  },
+})
+
+type UsersListQuery = $infer.Query<typeof api.users.list>
+type UsersListData = $infer.Data<typeof api.users.list>
+type UsersListParams = $infer.Params<typeof api.users.list>
+type UsersListError = $infer.Error<typeof api.users.list>
+
+type UsersCreateBody = $infer.Body<typeof api.users.create>
+type UsersCreateData = $infer.Data<typeof api.users.create>
+```
+
+Available type helpers:
+- `$infer.Query` - Extracts the query parameter type
+- `$infer.Params` - Extracts the URL params type
+- `$infer.Body` - Extracts the request body type
+- `$infer.Data` - Extracts the successful response data type
+- `$infer.Error` - Extracts the error response type (client or server errors)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@afoures/http-client",
-  "version": "0.2.0",
+  "version": "0.4.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"