zlient 1.0.11 → 2.0.1

package/dist/index.js

@@ -1,5 +1,80 @@
 import { z } from "zod";
 
+//#region lib/auth.ts
+/**
+* No-op authentication provider (no authentication applied).
+* Use this when you don't need authentication.
+*/
+var NoAuth = class {
+	async apply() {}
+};
+/**
+* API Key authentication provider.
+* Supports both header-based and query parameter-based authentication.
+*
+* @example
+* ```ts
+* // Header-based
+* const auth = new ApiKeyAuth({ header: 'X-API-Key', value: 'secret' });
+*
+* // Query parameter-based
+* const auth = new ApiKeyAuth({ query: 'apiKey', value: 'secret' });
+* ```
+*/
+var ApiKeyAuth = class {
+	constructor(opts) {
+		this.opts = opts;
+		if (!opts.header && !opts.query) throw new Error("ApiKeyAuth requires either \"header\" or \"query\" option");
+		if (opts.header && opts.query) throw new Error("ApiKeyAuth cannot use both \"header\" and \"query\" options");
+	}
+	apply({ url, init }) {
+		const value = this.opts.value;
+		if (this.opts.header) if (init.headers instanceof Headers) init.headers.set(this.opts.header, value);
+		else if (Array.isArray(init.headers)) init.headers.push([this.opts.header, value]);
+		else init.headers = {
+			...init.headers,
+			[this.opts.header]: value
+		};
+		else if (this.opts.query) {
+			const u = new URL(url);
+			u.searchParams.set(this.opts.query, value);
+			init.__urlOverride = u.toString();
+		}
+	}
+};
+/**
+* Bearer token authentication provider.
+* Supports both static tokens and dynamic token fetching (e.g., for OAuth2 refresh).
+*
+* @example
+* ```ts
+* // Static token
+* const auth = new BearerTokenAuth(() => 'my-token');
+*
+* // Dynamic token with refresh
+* const auth = new BearerTokenAuth(async () => {
+*   return await refreshAccessToken();
+* });
+* ```
+*/
+var BearerTokenAuth = class {
+	constructor(getToken) {
+		this.getToken = getToken;
+	}
+	async apply({ init }) {
+		const token = await this.getToken();
+		if (!token) throw new Error("BearerTokenAuth: token is empty or undefined");
+		const authHeader = `Bearer ${token}`;
+		if (init.headers instanceof Headers) init.headers.set("Authorization", authHeader);
+		else if (Array.isArray(init.headers)) init.headers.push(["Authorization", authHeader]);
+		else init.headers = {
+			...init.headers,
+			Authorization: authHeader
+		};
+	}
+};
+
+//#endregion
 //#region lib/types.ts
 const HTTPMethod = {
 	GET: "GET",
@@ -10,6 +85,70 @@ const HTTPMethod = {
 	HEAD: "HEAD",
 	OPTIONS: "OPTIONS"
 };
+const HTTPStatusCode = {
+	CONTINUE: 100,
+	SWITCHING_PROTOCOLS: 101,
+	PROCESSING: 102,
+	EARLY_HINTS: 103,
+	OK: 200,
+	CREATED: 201,
+	ACCEPTED: 202,
+	NON_AUTHORITATIVE_INFORMATION: 203,
+	NO_CONTENT: 204,
+	RESET_CONTENT: 205,
+	PARTIAL_CONTENT: 206,
+	MULTI_STATUS: 207,
+	ALREADY_REPORTED: 208,
+	IM_USED: 226,
+	MULTIPLE_CHOICES: 300,
+	MOVED_PERMANENTLY: 301,
+	FOUND: 302,
+	SEE_OTHER: 303,
+	NOT_MODIFIED: 304,
+	USE_PROXY: 305,
+	TEMPORARY_REDIRECT: 307,
+	PERMANENT_REDIRECT: 308,
+	BAD_REQUEST: 400,
+	UNAUTHORIZED: 401,
+	PAYMENT_REQUIRED: 402,
+	FORBIDDEN: 403,
+	NOT_FOUND: 404,
+	METHOD_NOT_ALLOWED: 405,
+	NOT_ACCEPTABLE: 406,
+	PROXY_AUTHENTICATION_REQUIRED: 407,
+	REQUEST_TIMEOUT: 408,
+	CONFLICT: 409,
+	GONE: 410,
+	LENGTH_REQUIRED: 411,
+	PRECONDITION_FAILED: 412,
+	PAYLOAD_TOO_LARGE: 413,
+	URI_TOO_LONG: 414,
+	UNSUPPORTED_MEDIA_TYPE: 415,
+	RANGE_NOT_SATISFIABLE: 416,
+	EXPECTATION_FAILED: 417,
+	IM_A_TEAPOT: 418,
+	MISDIRECTED_REQUEST: 421,
+	UNPROCESSABLE_ENTITY: 422,
+	LOCKED: 423,
+	FAILED_DEPENDENCY: 424,
+	TOO_EARLY: 425,
+	UPGRADE_REQUIRED: 426,
+	PRECONDITION_REQUIRED: 428,
+	TOO_MANY_REQUESTS: 429,
+	REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
+	UNAVAILABLE_FOR_LEGAL_REASONS: 451,
+	INTERNAL_SERVER_ERROR: 500,
+	NOT_IMPLEMENTED: 501,
+	BAD_GATEWAY: 502,
+	SERVICE_UNAVAILABLE: 503,
+	GATEWAY_TIMEOUT: 504,
+	HTTP_VERSION_NOT_SUPPORTED: 505,
+	VARIANT_ALSO_NEGOTIATES: 506,
+	INSUFFICIENT_STORAGE: 507,
+	LOOP_DETECTED: 508,
+	NOT_EXTENDED: 510,
+	NETWORK_AUTHENTICATION_REQUIRED: 511
+};
 /**
 * Custom error class for API-related errors.
 * Includes HTTP status codes, response details, and validation errors.
@@ -68,6 +207,18 @@ var ApiError = class ApiError extends Error {
 	}
 };
 /**
+* Error thrown when an endpoint receives a response with a status code
+* that has no defined schema in the endpoint configuration.
+*/
+var SchemaDefinitionError = class SchemaDefinitionError extends Error {
+	constructor(status) {
+		super(`No schema defined for status code ${status}`);
+		this.status = status;
+		this.name = "SchemaDefinitionError";
+		if (Error.captureStackTrace) Error.captureStackTrace(this, SchemaDefinitionError);
+	}
+};
+/**
 * Schema for paginated responses
 */
 const PaginationSchema = z.object({
@@ -103,107 +254,9 @@ function toQueryString(q) {
 	return s ? `?${s}` : "";
 }
 
-//#endregion
-//#region lib/auth.ts
-/**
-* No-op authentication provider (no authentication applied).
-* Use this when you don't need authentication.
-*/
-var NoAuth = class {
-	async apply() {}
-};
-/**
-* API Key authentication provider.
-* Supports both header-based and query parameter-based authentication.
-*
-* @example
-* ```ts
-* // Header-based
-* const auth = new ApiKeyAuth({ header: 'X-API-Key', value: 'secret' });
-*
-* // Query parameter-based
-* const auth = new ApiKeyAuth({ query: 'apiKey', value: 'secret' });
-* ```
-*/
-var ApiKeyAuth = class {
-	constructor(opts) {
-		this.opts = opts;
-		if (!opts.header && !opts.query) throw new Error("ApiKeyAuth requires either \"header\" or \"query\" option");
-		if (opts.header && opts.query) throw new Error("ApiKeyAuth cannot use both \"header\" and \"query\" options");
-	}
-	apply({ url, init }) {
-		if (this.opts.header) init.headers = {
-			...init.headers,
-			[this.opts.header]: this.opts.value
-		};
-		else if (this.opts.query) {
-			const u = new URL(url);
-			u.searchParams.set(this.opts.query, this.opts.value);
-			init.__urlOverride = u.toString();
-		}
-	}
-};
-/**
-* Bearer token authentication provider.
-* Supports both static tokens and dynamic token fetching (e.g., for OAuth2 refresh).
-*
-* @example
-* ```ts
-* // Static token
-* const auth = new BearerTokenAuth(() => 'my-token');
-*
-* // Dynamic token with refresh
-* const auth = new BearerTokenAuth(async () => {
-*   return await refreshAccessToken();
-* });
-* ```
-*/
-var BearerTokenAuth = class {
-	constructor(getToken) {
-		this.getToken = getToken;
-	}
-	async apply({ init }) {
-		const token = await this.getToken();
-		if (!token) throw new Error("BearerTokenAuth: token is empty or undefined");
-		init.headers = {
-			...init.headers,
-			Authorization: `Bearer ${token}`
-		};
-	}
-};
-
 //#endregion
 //#region lib/validation.ts
 /**
-* Safely parse data with a Zod schema without throwing.
-* Returns a result object with success status and data or error.
-*
-* @param schema - Zod schema to validate against
-* @param data - Data to validate
-* @returns Result object with success flag and data/error
-*
-* @example
-* ```ts
-* const result = safeParse(UserSchema, userData);
-* if (result.success) {
-*   console.log(result.data);
-* } else {
-*   console.error(result.error);
-* }
-* ```
-*/
-function safeParse(schema, data) {
-	const res = schema.safeParse(data);
-	if (res.success) return {
-		success: true,
-		data: res.data
-	};
-	return {
-		success: false,
-		error: res.error
-	};
-}
-/**
 * Parse data with a Zod schema, throwing an ApiError on validation failure.
 * Use this when you want to fail fast on invalid data.
 *
@@ -230,6 +283,48 @@ function parseOrThrow(schema, data) {
 	return res.data;
 }
 
+//#endregion
+//#region lib/endpoint/base-endpoint.ts
+var Endpoint = class {
+	constructor(client, config) {
+		this.client = client;
+		this.config = config;
+	}
+	async call(params) {
+		const { data, query, pathParams, headers, signal } = params;
+		if (this.config.request && data !== void 0) {
+			const parsed = this.config.request.safeParse(data);
+			if (!parsed.success) throw parsed.error;
+		}
+		if (this.config.query && query !== void 0) {
+			const parsed = this.config.query.safeParse(query);
+			if (!parsed.success) throw parsed.error;
+		}
+		if (this.config.pathParams && pathParams !== void 0) {
+			const parsed = this.config.pathParams.safeParse(pathParams);
+			if (!parsed.success) throw parsed.error;
+		}
+		if (this.config.request && data === void 0) throw new Error("Missing required request body (data)");
+		if (this.config.pathParams && pathParams === void 0) throw new Error("Missing required path parameters (pathParams)");
+		let pathStr;
+		if (typeof this.config.path === "function") {
+			if (!pathParams) throw new Error("Path function requires pathParams");
+			pathStr = this.config.path(pathParams);
+		} else pathStr = this.config.path;
+		const { data: responseData, status } = await this.client.request(this.config.method, pathStr, data, {
+			query,
+			headers,
+			baseUrlKey: this.config.baseUrlKey,
+			signal
+		});
+		const schema = this.config.response;
+		if (schema instanceof z.ZodType) return parseOrThrow(schema, responseData);
+		const specificSchema = schema[status];
+		if (!specificSchema) throw new SchemaDefinitionError(status);
+		return parseOrThrow(specificSchema, responseData);
+	}
+};
+
 //#endregion
 //#region lib/logger.ts
 /**
@@ -257,7 +352,9 @@ var ConsoleLogger = class {
 			LogLevel.WARN,
 			LogLevel.ERROR
 		];
-		if (levels.indexOf(entry.level) < levels.indexOf(this.minLevel)) return;
+		const entryLevelIndex = levels.indexOf(entry.level);
+		const minLevelIndex = levels.indexOf(this.minLevel);
+		if (entryLevelIndex < minLevelIndex) return;
 		const output = {
 			...entry,
 			error: entry.error ? {
@@ -300,7 +397,7 @@ var LoggerUtil = class {
 		this.logger.log({
 			level: LogLevel.DEBUG,
 			message,
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			timestamp: new Date().toISOString(),
 			context
 		});
 	}
@@ -308,7 +405,7 @@ var LoggerUtil = class {
 		this.logger.log({
 			level: LogLevel.INFO,
 			message,
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			timestamp: new Date().toISOString(),
 			context
 		});
 	}
@@ -316,7 +413,7 @@ var LoggerUtil = class {
 		this.logger.log({
 			level: LogLevel.WARN,
 			message,
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			timestamp: new Date().toISOString(),
 			context
 		});
 	}
@@ -324,7 +421,7 @@ var LoggerUtil = class {
 		this.logger.log({
 			level: LogLevel.ERROR,
 			message,
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			timestamp: new Date().toISOString(),
 			context,
 			error
 		});
@@ -372,15 +469,22 @@ var InMemoryMetricsCollector = class {
 			maxDurationMs: 0
 		};
 		const successful = this.metrics.filter((m) => m.success).length;
-		const durations = this.metrics.map((m) => m.durationMs);
-		const sum = durations.reduce((a, b) => a + b, 0);
+		let sum = 0;
+		let min = Infinity;
+		let max = -Infinity;
+		for (const m of this.metrics) {
+			const d = m.durationMs;
+			sum += d;
+			if (d < min) min = d;
+			if (d > max) max = d;
+		}
 		return {
 			total: this.metrics.length,
 			successful,
 			failed: this.metrics.length - successful,
 			avgDurationMs: sum / this.metrics.length,
-			minDurationMs: Math.min(...durations),
-			maxDurationMs: Math.max(...durations)
+			minDurationMs: min === Infinity ? 0 : min,
+			maxDurationMs: max === -Infinity ? 0 : max
 		};
 	}
 	/**
@@ -447,6 +551,10 @@ var HttpClient = class {
 			jitter: .2,
 			retryMethods: ["GET", "HEAD"]
 		};
+		if (!this.retry.retryStatusCodes) this.retry.retryStatusCodes = Object.keys(HTTPStatusCode).filter((key) => {
+			const code = HTTPStatusCode[key];
+			return typeof code === "number" && code >= 500;
+		});
 		if (this.retry.maxRetries < 0) throw new Error("retry.maxRetries must be non-negative");
 		if (this.retry.baseDelayMs < 0) throw new Error("retry.baseDelayMs must be non-negative");
 		if (this.retry.jitter !== void 0 && (this.retry.jitter < 0 || this.retry.jitter > 1)) throw new Error("retry.jitter must be between 0 and 1");
@@ -562,7 +670,8 @@ var HttpClient = class {
 	*/
 	async request(method, path, body, options) {
 		const startTime = Date.now();
-		let url = `${this.resolveBaseUrl(options?.baseUrlKey)}${path}${toQueryString(options?.query)}`;
+		const base = this.resolveBaseUrl(options?.baseUrlKey);
+		let url = `${base}${path}${toQueryString(options?.query)}`;
 		this.logger.debug("HTTP request initiated", {
 			method,
 			path,
@@ -591,26 +700,16 @@ var HttpClient = class {
 		const doFetch = async () => {
 			let timeoutId;
 			if (this.timeoutMs && !options?.signal) timeoutId = setTimeout(() => {
-				const timeoutError = /* @__PURE__ */ new Error("Request timeout");
+				const timeoutError = new Error("Request timeout");
 				timeoutError.name = "TimeoutError";
 				controller.abort(timeoutError);
 			}, this.timeoutMs);
 			try {
 				const req = new Request(url, init);
 				const res = await this.fetchImpl(req);
-				if (!res.ok) {
-					let text = "";
-					try {
-						text = await res.text();
-					} catch (readError) {
-						text = `Failed to read response: ${readError instanceof Error ? readError.message : String(readError)}`;
-					}
-					throw new ApiError(`HTTP ${res.status}: ${res.statusText}`, {
-						status: res.status,
-						details: text
-					});
-				}
-				const data = (res.headers.get("content-type") || "").includes("json") ? await res.json() : await res.text();
+				const status = res.status;
+				const contentType = res.headers.get("content-type") || "";
+				const data = contentType.includes("json") ? await res.json() : await res.text();
 				await this.runAfterHooks(new Request(url, init), res, data);
 				const duration = Date.now() - startTime;
 				this.logger.info("HTTP request successful", {
@@ -624,12 +723,12 @@ var HttpClient = class {
 					path,
 					status: res.status,
 					durationMs: duration,
-					timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+					timestamp: new Date().toISOString(),
 					success: true
 				});
 				return {
 					data,
-					response: res
+					status
 				};
 			} catch (error) {
 				const duration = Date.now() - startTime;
@@ -643,7 +742,7 @@ var HttpClient = class {
 					path,
 					status: error instanceof ApiError ? error.status : void 0,
 					durationMs: duration,
-					timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+					timestamp: new Date().toISOString(),
 					success: false,
 					error: error instanceof Error ? error.message : String(error)
 				});
@@ -652,13 +751,15 @@ var HttpClient = class {
 				if (timeoutId) clearTimeout(timeoutId);
 			}
 		};
-		const canRetry = ({ response, error }) => {
+		const canRetry = ({ error }) => {
 			if (error && typeof error === "object" && "name" in error) {
 				const errorName = error.name;
 				if (errorName === "AbortError" || errorName === "TimeoutError") return false;
 			}
-			if (error instanceof ApiError && error.status && error.status >= 500) return true;
-			if (error && !response) return true;
+			if (error instanceof ApiError && error.status) {
+				const retryCodes = this.retry.retryStatusCodes;
+				if (retryCodes?.some((codeKey) => HTTPStatusCode[codeKey] === error.status)) return true;
+			}
 			return false;
 		};
 		if (!this.retry.retryMethods?.includes(method)) return doFetch();
@@ -719,109 +820,14 @@ var HttpClient = class {
 	async delete(path, options) {
 		return this.request("DELETE", path, void 0, options);
 	}
-};
-
-//#endregion
-//#region lib/endpoint/base-endpoint.ts
-/**
-* Generic, strongly-typed endpoint with Zod schemas for request and response validation.
-* Extend this class to create type-safe API endpoints.
-*
-* @template ReqSchema - Zod schema for request validation
-* @template ResSchema - Zod schema for response validation
-* @template PathParams - Type for path parameters (optional)
-* @template QueryParams - Type for query parameters (optional)
-*
-* @example
-* ```ts
-* const UserSchema = z.object({ id: z.number(), name: z.string() });
-* const CreateUserSchema = z.object({ name: z.string() });
-*
-* type UserPathParams = { id: string };
-* type UserQueryParams = { include?: string; limit?: number };
-*
-* class GetUser extends BaseEndpoint<
-*   typeof CreateUserSchema,
-*   typeof UserSchema,
-*   UserPathParams,
-*   UserQueryParams
-* > {
-*   protected method = 'GET' as const;
-*   protected path = (params: UserPathParams) => `/users/${params.id}`;
-*
-*   constructor(client: HttpClient) {
-*     super(client, {
-*       requestSchema: CreateUserSchema,
-*       responseSchema: UserSchema
-*     });
-*   }
-* }
-*
-* // Usage:
-* const user = await endpoint.call({
-*   pathParams: { id: '123' },
-*   query: { include: 'posts', limit: 10 }
-* });
-* ```
-*/
-var BaseEndpoint = class {
-	/** Additional options for the request */
-	options;
-	/** Optional request schema for validation */
-	requestSchema;
-	/** Response schema for validation */
-	responseSchema;
-	/**
-	* @param client - HttpClient instance
-	* @param cfg - Configuration with request and response schemas
-	*/
-	constructor(client, cfg) {
-		this.client = client;
-		this.requestSchema = cfg.requestSchema;
-		this.responseSchema = cfg.responseSchema;
-	}
 	/**
-	* Call the endpoint with strong typing derived from schemas.
-	* Validates request data before sending and response data after receiving.
-	*
-	* @param config - Request configuration object containing all parameters
-	* @returns Promise resolving to validated response data (typed by ResSchema)
-	* @throws {ZodError} If request validation fails
-	* @throws {ApiError} If response validation fails or request fails
+	* Create a strongly-typed endpoint builder.
 	*
-	* @example
-	* ```ts
-	* const endpoint = new GetUser(client);
-	* const user = await endpoint.call({
-	*   pathParams: { id: '123' },
-	*   query: { include: 'posts' }
-	* });
-	* // With additional options:
-	* const user = await endpoint.call({
-	*   data: { name: 'John' },
-	*   pathParams: { id: '123' },
-	*   headers: { 'X-Custom': 'value' },
-	*   query: { include: 'posts' }
-	* });
-	* ```
+	* @param config - Endpoint configuration
+	* @returns Endpoint instance
 	*/
-	async call(config = {}) {
-		const { data, query, headers, baseUrlKey, signal, pathParams } = config;
-		if (this.requestSchema && data !== void 0) {
-			const parsed = this.requestSchema.safeParse(data);
-			if (!parsed.success) throw parsed.error;
-		}
-		const pathArgs = pathParams ?? data;
-		const path = typeof this.path === "function" ? this.path(pathArgs) : this.path;
-		const body = this.method !== "GET" && this.method !== "HEAD" ? data : void 0;
-		const queryForRequest = query;
-		const { data: responseData } = await this.client.request(this.method, path, body, {
-			query: queryForRequest,
-			headers,
-			baseUrlKey: baseUrlKey ?? this.options?.baseUrlKey,
-			signal
-		});
-		return parseOrThrow(this.responseSchema, responseData);
+	createEndpoint(config) {
+		return new Endpoint(this, config);
 	}
 };
 
@@ -910,5 +916,5 @@ const Envelope = (inner) => z.object({
 });
 
 //#endregion
-export { ApiError, ApiErrorSchema, ApiKeyAuth, BaseEndpoint, BearerTokenAuth, ConsoleLogger, ConsoleMetricsCollector, Envelope, ErrorDetail, HTTPMethod, HttpClient, Id, InMemoryMetricsCollector, LogLevel, LoggerUtil, Meta, NoAuth, NoOpLogger, NoOpMetricsCollector, PaginationSchema, Timestamps, parseOrThrow, safeParse, toQueryString };
+export { ApiError, ApiErrorSchema, ApiKeyAuth, BearerTokenAuth, ConsoleLogger, ConsoleMetricsCollector, Endpoint, Envelope, ErrorDetail, HTTPMethod, HTTPStatusCode, HttpClient, Id, InMemoryMetricsCollector, LogLevel, LoggerUtil, Meta, NoAuth, NoOpLogger, NoOpMetricsCollector, PaginationSchema, SchemaDefinitionError, Timestamps, toQueryString };
 //# sourceMappingURL=index.js.map