@afoures/http-client 0.1.1 → 0.3.0

package/README.md

@@ -29,7 +29,7 @@ import { Endpoint, http_client } from '@afoures/http-client'
 import { z } from 'zod'
 
 const api = http_client({
-  origin: 'https://api.example.com',
+  base_url: 'https://api.example.com',
   endpoints: {
     users: {
       list: new Endpoint({
@@ -43,6 +43,7 @@ const api = http_client({
         },
         data: {
           schema: z.array(z.object({ id: z.string(), name: z.string() })),
+          parse: 'json',
         },
       }),
       get: new Endpoint({
@@ -50,6 +51,7 @@ const api = http_client({
         pathname: '/users/(:id)',
         data: {
           schema: z.object({ id: z.string(), name: z.string() }),
+          parse: 'json',
         },
       }),
       create: new Endpoint({
@@ -57,9 +59,11 @@ const api = http_client({
         pathname: '/users',
         body: {
           schema: z.object({ name: z.string(), email: z.string().email() }),
+          serialize: 'json',
         },
         data: {
           schema: z.object({ id: z.string(), name: z.string() }),
+          parse: 'json',
         },
       }),
     },

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { AbortedError, DeserializationError, HttpClientError, NetworkError, SerializationError, TimeoutError, UnexpectedError } from "./lib/errors.mjs";
+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, DeserializationError, Endpoint, type EndpointDefinition, type EndpointMap, type HTTPFetch, type HTTPMethod, type HTTPStatus, HttpClientError, type HttpClientOptions, NetworkError, type Parser, type Pathname, type Schema, SerializationError, type Serializer, TimeoutError, UnexpectedError, http_client };
+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 };

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { AbortedError, DeserializationError, HttpClientError, NetworkError, SerializationError, TimeoutError, UnexpectedError } from "./lib/errors.mjs";
+import { AbortedError, HttpClientError, NetworkError, ParseError, SerializationError, TimeoutError, UnexpectedError } from "./lib/errors.mjs";
 import { Endpoint } from "./lib/endpoint.mjs";
 import { http_client } from "./lib/http-client.mjs";
 
-export { AbortedError, DeserializationError, Endpoint, HttpClientError, NetworkError, SerializationError, TimeoutError, UnexpectedError, http_client };
+export { AbortedError, Endpoint, HttpClientError, NetworkError, ParseError, SerializationError, TimeoutError, UnexpectedError, http_client };

package/dist/lib/endpoint.d.mts

@@ -1,4 +1,4 @@
-import { DeserializationError, SerializationError } from "./errors.mjs";
+import { ParseError, SerializationError } from "./errors.mjs";
 import { ErrorMessage, HTTPFetch, HTTPMethod, Parser, Pathname, Pretty, Schema, Serializer } from "./types.mjs";
 
 //#region src/lib/endpoint.d.ts
@@ -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 | DeserializationError>;
+  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

@@ -1,8 +1,79 @@
-import { DeserializationError, SerializationError } from "./errors.mjs";
+import { ParseError, SerializationError } from "./errors.mjs";
 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,10 +106,11 @@ 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.serialization) pathname_params = this.#serializers.params.serialization(transformed_params);
+			if (this.#serializers.params.serialize) pathname_params = this.#serializers.params.serialize(transformed_params);
 			else pathname_params = Object.fromEntries(Object.entries(transformed_params).map(([key, value]) => [key, String(value)]));
 		} else pathname_params = Object.fromEntries(Object.entries(init.params).map(([key, value]) => [key, String(value)]));
 		const pathname = this.#pattern.href(pathname_params);
@@ -47,11 +119,12 @@ 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.serialization === "function") search_params = this.#serializers.query.serialization(transformed_query);
-			else if (this.#serializers.query.serialization === "urlencoded") {
+			if (typeof this.#serializers.query.serialize === "function") search_params = this.#serializers.query.serialize(transformed_query);
+			else if (this.#serializers.query.serialize === "urlencoded") {
 				if (Array.isArray(transformed_query)) transformed_query.forEach((tuple, index) => {
 					if (Array.isArray(tuple)) tuple.forEach((value, tupleIndex) => {
 						search_params.append(`${index}[${tupleIndex}]`, String(value));
@@ -80,83 +153,61 @@ 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.serialization === "function") return this.#serializers.body.serialization(transformed_content);
+		if (typeof this.#serializers.body.serialize === "function") return this.#serializers.body.serialize(transformed_content);
 		else return {
 			body: JSON.stringify(transformed_content),
 			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.deserialization === "function") parsed = await parser.deserialization(cloned_response.body);
-				else if (parser.deserialization === "json") parsed = await parse_as_json(cloned_response);
-				else if (parser.deserialization === "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 DeserializationError("Error deserialization failed", {
+				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.deserialization === "function") parsed = await parser.deserialization(cloned_response.body);
-				else if (parser.deserialization === "json") parsed = await parse_as_json(cloned_response);
-				else if (parser.deserialization === "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 DeserializationError("Response deserialization failed", {
+				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}`);
 	}
@@ -170,19 +221,19 @@ async function parse_as_json(response) {
 		throw new Error(`Failed to parse response as JSON: ${e instanceof Error ? e.message : String(e)}`);
 	}
 }
-function as_serializer(serializer, default_serialization) {
+function as_serializer(serializer, default_serialize) {
 	if (!serializer || typeof serializer !== "object" || !("schema" in serializer)) return null;
-	if (default_serialization === void 0 || "serialization" in serializer && typeof serializer.serialization !== "undefined") return serializer;
+	if (default_serialize === void 0 || "serialize" in serializer && typeof serializer.serialize !== "undefined") return serializer;
 	return {
-		serialization: default_serialization,
+		serialize: default_serialize,
 		...serializer
 	};
 }
-function as_parser(parser, default_deserialization) {
+function as_parser(parser, default_parse) {
 	if (!parser || typeof parser !== "object" || !("schema" in parser)) return null;
-	if (default_deserialization === void 0 || "deserialization" in parser && typeof parser.deserialization !== "undefined") return parser;
+	if (default_parse === void 0 || "parse" in parser && typeof parser.parse !== "undefined") return parser;
 	return {
-		deserialization: default_deserialization,
+		parse: default_parse,
 		...parser
 	};
 }

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 DeserializationError extends HttpClientError {
-  readonly context: BaseContext;
-  constructor(message: string, {
-    cause,
-    ...context
-  }: ErrorCause & BaseContext);
+declare class ParseError extends HttpClientError {
+  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, DeserializationError, HttpClientError, NetworkError, SerializationError, TimeoutError, UnexpectedError };
+export { AbortedError, HttpClientError, NetworkError, ParseError, SerializationError, TimeoutError, UnexpectedError };

package/dist/lib/errors.mjs

@@ -1,58 +1,56 @@
 //#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 DeserializationError = class extends HttpClientError {
-	context;
-	constructor(message, { cause, ...context }) {
-		super(message, { cause });
-		this.name = "DeserializationError";
-		this.context = context;
+var ParseError = class extends HttpClientError {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "ParseError";
 	}
 };
 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"
+		};
 	}
 };
 
 //#endregion
-export { AbortedError, DeserializationError, HttpClientError, NetworkError, SerializationError, TimeoutError, UnexpectedError };
+export { AbortedError, HttpClientError, NetworkError, ParseError, SerializationError, TimeoutError, UnexpectedError };