zlient 2.1.10 → 3.0.0

package/dist/index.js

@@ -1,5 +1,3 @@
-import { z } from "zod";
-
 //#region lib/auth.ts
 /**
 * No-op authentication provider (no authentication applied).
@@ -73,7 +71,6 @@ var BearerTokenAuth = class {
 		};
 	}
 };
-
 //#endregion
 //#region lib/types.ts
 const HTTPMethod = {
@@ -162,23 +159,20 @@ const HTTPStatusCode = {
 * ```
 */
 var ApiError = class ApiError extends Error {
-	status;
-	details;
-	zodError;
 	constructor(message, options) {
 		super(message);
 		this.name = "ApiError";
 		this.status = options?.status;
 		this.details = options?.details;
 		this.cause = options?.cause;
-		this.zodError = options?.zodError;
+		this.validationIssues = options?.validationIssues;
 		if (Error.captureStackTrace) Error.captureStackTrace(this, ApiError);
 	}
 	/**
-	* Check if this is a validation error (has zodError)
+	* Check if this is a validation error (has validationIssues)
 	*/
 	isValidationError() {
-		return !!this.zodError;
+		return !!this.validationIssues && this.validationIssues.length > 0;
 	}
 	/**
 	* Check if this is a client error (4xx status)
@@ -201,7 +195,7 @@ var ApiError = class ApiError extends Error {
 			message: this.message,
 			status: this.status,
 			details: this.details,
-			zodError: this.zodError?.issues,
+			validationIssues: this.validationIssues,
 			stack: this.stack
 		};
 	}
@@ -219,15 +213,6 @@ var SchemaDefinitionError = class SchemaDefinitionError extends Error {
 	}
 };
 /**
-* Schema for paginated responses
-*/
-const PaginationSchema = z.object({
-	items: z.array(z.unknown()),
-	total: z.number().int().nonnegative(),
-	page: z.number().int().nonnegative(),
-	pageSize: z.number().int().positive()
-});
-/**
 * Converts query parameters to a URL query string.
 * Filters out undefined values automatically.
 *
@@ -243,8 +228,8 @@ const PaginationSchema = z.object({
 function toQueryString(q) {
 	if (!q) return "";
 	if (q instanceof URLSearchParams) {
-		const s$1 = q.toString();
-		return s$1 ? `?${s$1}` : "";
+		const s = q.toString();
+		return s ? `?${s}` : "";
 	}
 	const params = new URLSearchParams();
 	Object.entries(q).forEach(([k, v]) => {
@@ -253,36 +238,88 @@ function toQueryString(q) {
 	const s = params.toString();
 	return s ? `?${s}` : "";
 }
-
 //#endregion
 //#region lib/validation.ts
 /**
-* Parse data with a Zod schema, throwing an ApiError on validation failure.
+* Safely parse/validate data with any Standard Schema-compatible library (Zod, Valibot, ArkType, etc.).
+* Returns a result object with success status and data or issues.
+*
+* @param schema - A Standard Schema-compatible validator
+* @param data - Data to validate
+* @returns Result object with success flag and data/issues
+*
+* @example
+* ```ts
+* // Works with Zod
+* import { z } from 'zod';
+* const result = await safeParse(z.object({ name: z.string() }), userData);
+*
+* // Works with Valibot
+* import * as v from 'valibot';
+* const result = await safeParse(v.object({ name: v.string() }), userData);
+*
+* // Works with ArkType
+* import { type } from 'arktype';
+* const result = await safeParse(type({ name: 'string' }), userData);
+*
+* if (result.success) {
+*   console.log(result.data);
+* } else {
+*   console.error(result.issues);
+* }
+* ```
+*/
+async function safeParse(schema, data) {
+	const result = await schema["~standard"].validate(data);
+	if (result.issues) return {
+		success: false,
+		issues: result.issues
+	};
+	return {
+		success: true,
+		data: result.value
+	};
+}
+/**
+* Parse/validate data with any Standard Schema-compatible library, throwing an ApiError on failure.
 * Use this when you want to fail fast on invalid data.
 *
-* @param schema - Zod schema to validate against
+* @param schema - A Standard Schema-compatible validator
 * @param data - Data to validate
 * @returns Validated and typed data
-* @throws {ApiError} If validation fails
+* @throws {ApiError} If validation fails (with validationIssues property)
 *
 * @example
 * ```ts
+* // Works with any Standard Schema-compatible library
 * try {
-*   const user = parseOrThrow(UserSchema, userData);
+*   const user = await parseOrThrow(UserSchema, userData);
 *   console.log(user);
 * } catch (error) {
-*   if (error instanceof ApiError && error.zodError) {
-*     console.error('Validation failed:', error.zodError.issues);
+*   if (error instanceof ApiError && error.isValidationError()) {
+*     console.error('Validation failed:', error.validationIssues);
 *   }
 * }
 * ```
 */
-function parseOrThrow(schema, data) {
-	const res = schema.safeParse(data);
-	if (!res.success) throw new ApiError("Response validation failed", { zodError: res.error });
-	return res.data;
+async function parseOrThrow(schema, data) {
+	const result = await schema["~standard"].validate(data);
+	if (result.issues) throw new ApiError(`Validation failed: ${result.issues.map((issue) => issue.message).join(", ")}`, { validationIssues: result.issues });
+	return result.value;
+}
+/**
+* Type guard to check if a value is a Standard Schema-compatible validator.
+* Handles both object-based schemas (Zod, Valibot) and function-based schemas (ArkType).
+*
+* @param value - Value to check
+* @returns True if the value implements Standard Schema v1
+*/
+function isStandardSchema(value) {
+	if (value === null || value === void 0) return false;
+	if (typeof value !== "object" && typeof value !== "function") return false;
+	const schema = value;
+	return "~standard" in schema && typeof schema["~standard"] === "object" && schema["~standard"] !== null && schema["~standard"].version === 1 && typeof schema["~standard"].validate === "function";
 }
-
 //#endregion
 //#region lib/endpoint/base-endpoint.ts
 var EndpointImpl = class {
@@ -291,21 +328,17 @@ var EndpointImpl = class {
 		this.config = config;
 	}
 	async call(params) {
-		const { data, query, pathParams, headers, signal } = params;
+		const { data, query, pathParams, signal } = params;
+		const headers = "headers" in params ? params.headers : void 0;
 		const skipRequestValidation = this.config.advanced?.skipRequestValidation ?? false;
 		const skipResponseValidation = this.config.advanced?.skipResponseValidation ?? false;
-		if (!skipRequestValidation && this.config.request && data !== void 0) {
-			const parsed = this.config.request.safeParse(data);
-			if (!parsed.success) throw parsed.error;
-		}
-		if (!skipRequestValidation && this.config.query && query !== void 0) {
-			const parsed = this.config.query.safeParse(query);
-			if (!parsed.success) throw parsed.error;
-		}
-		if (!skipRequestValidation && this.config.pathParams && pathParams !== void 0) {
-			const parsed = this.config.pathParams.safeParse(pathParams);
-			if (!parsed.success) throw parsed.error;
+		if (this.config.mustHeaderKeys && this.config.mustHeaderKeys.length > 0) {
+			const missingHeaders = this.config.mustHeaderKeys.filter((key) => !headers || !(key in headers));
+			if (missingHeaders.length > 0) throw new Error(`Missing required header(s): ${missingHeaders.join(", ")}`);
 		}
+		if (!skipRequestValidation && this.config.request && data !== void 0) await parseOrThrow(this.config.request, data);
+		if (!skipRequestValidation && this.config.query && query !== void 0) await parseOrThrow(this.config.query, query);
+		if (!skipRequestValidation && this.config.pathParams && pathParams !== void 0) await parseOrThrow(this.config.pathParams, pathParams);
 		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;
@@ -323,24 +356,23 @@ var EndpointImpl = class {
 		});
 		const schema = this.config.response;
 		if (skipResponseValidation) return responseData;
-		if (schema instanceof z.ZodType) return parseOrThrow(schema, responseData);
+		if (isStandardSchema(schema)) return await parseOrThrow(schema, responseData);
 		const specificSchema = schema[status];
 		if (!specificSchema) throw new SchemaDefinitionError(status);
-		return parseOrThrow(specificSchema, responseData);
+		return await parseOrThrow(specificSchema, responseData);
 	}
 };
-
 //#endregion
 //#region lib/logger.ts
 /**
 * Log levels for structured logging.
 */
-let LogLevel = /* @__PURE__ */ function(LogLevel$1) {
-	LogLevel$1["DEBUG"] = "debug";
-	LogLevel$1["INFO"] = "info";
-	LogLevel$1["WARN"] = "warn";
-	LogLevel$1["ERROR"] = "error";
-	return LogLevel$1;
+let LogLevel = /* @__PURE__ */ function(LogLevel) {
+	LogLevel["DEBUG"] = "debug";
+	LogLevel["INFO"] = "info";
+	LogLevel["WARN"] = "warn";
+	LogLevel["ERROR"] = "error";
+	return LogLevel;
 }({});
 /**
 * Default console logger implementation.
@@ -357,9 +389,7 @@ var ConsoleLogger = class {
 			LogLevel.WARN,
 			LogLevel.ERROR
 		];
-		const entryLevelIndex = levels.indexOf(entry.level);
-		const minLevelIndex = levels.indexOf(this.minLevel);
-		if (entryLevelIndex < minLevelIndex) return;
+		if (levels.indexOf(entry.level) < levels.indexOf(this.minLevel)) return;
 		const output = {
 			...entry,
 			error: entry.error ? {
@@ -402,7 +432,7 @@ var LoggerUtil = class {
 		this.logger.log({
 			level: LogLevel.DEBUG,
 			message,
-			timestamp: new Date().toISOString(),
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
 			context
 		});
 	}
@@ -410,7 +440,7 @@ var LoggerUtil = class {
 		this.logger.log({
 			level: LogLevel.INFO,
 			message,
-			timestamp: new Date().toISOString(),
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
 			context
 		});
 	}
@@ -418,7 +448,7 @@ var LoggerUtil = class {
 		this.logger.log({
 			level: LogLevel.WARN,
 			message,
-			timestamp: new Date().toISOString(),
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
 			context
 		});
 	}
@@ -426,13 +456,12 @@ var LoggerUtil = class {
 		this.logger.log({
 			level: LogLevel.ERROR,
 			message,
-			timestamp: new Date().toISOString(),
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
 			context,
 			error
 		});
 	}
 };
-
 //#endregion
 //#region lib/metrics.ts
 /**
@@ -446,9 +475,8 @@ var NoOpMetricsCollector = class {
 * Stores metrics in memory with configurable retention.
 */
 var InMemoryMetricsCollector = class {
-	metrics = [];
-	maxEntries;
 	constructor(maxEntries = 1e3) {
+		this.metrics = [];
 		this.maxEntries = maxEntries;
 	}
 	collect(metrics) {
@@ -507,7 +535,6 @@ var ConsoleMetricsCollector = class {
 		console.log("[METRICS]", JSON.stringify(metrics));
 	}
 };
-
 //#endregion
 //#region lib/http/http-client.ts
 /**
@@ -527,16 +554,6 @@ var ConsoleMetricsCollector = class {
 * ```
 */
 var HttpClient = class {
-	fetchImpl;
-	baseUrls;
-	headers;
-	interceptors;
-	retry;
-	timeoutMs;
-	auth;
-	logger;
-	metrics;
-	onUnauthenticated;
 	/**
 	* Creates a new HTTP client instance.
 	*
@@ -677,8 +694,7 @@ var HttpClient = class {
 	*/
 	async request(method, path, body, options) {
 		const startTime = Date.now();
-		const base = this.resolveBaseUrl(options?.baseUrlKey);
-		let url = `${base}${path}${toQueryString(options?.query)}`;
+		let url = `${this.resolveBaseUrl(options?.baseUrlKey)}${path}${toQueryString(options?.query)}`;
 		this.logger.debug("HTTP request initiated", {
 			method,
 			path,
@@ -716,7 +732,7 @@ var HttpClient = class {
 			while (true) {
 				let timeoutId;
 				if (this.timeoutMs && !options?.signal) timeoutId = setTimeout(() => {
-					const timeoutError = new Error("Request timeout");
+					const timeoutError = /* @__PURE__ */ new Error("Request timeout");
 					timeoutError.name = "TimeoutError";
 					controller.abort(timeoutError);
 				}, this.timeoutMs);
@@ -733,8 +749,7 @@ var HttpClient = class {
 					const req = new Request(url, init);
 					const res = await this.fetchImpl(req);
 					if (res.status === 401 && this.onUnauthenticated && !refreshAttempted) {
-						const shouldRetry = await this.onUnauthenticated(res.clone());
-						if (shouldRetry) {
+						if (await this.onUnauthenticated(res.clone())) {
 							refreshAttempted = true;
 							if (timeoutId) clearTimeout(timeoutId);
 							continue;
@@ -759,7 +774,7 @@ var HttpClient = class {
 						path,
 						status: res.status,
 						durationMs: duration,
-						timestamp: new Date().toISOString(),
+						timestamp: (/* @__PURE__ */ new Date()).toISOString(),
 						success: true
 					});
 					return {
@@ -778,7 +793,7 @@ var HttpClient = class {
 						path,
 						status: error instanceof ApiError ? error.status : void 0,
 						durationMs: duration,
-						timestamp: new Date().toISOString(),
+						timestamp: (/* @__PURE__ */ new Date()).toISOString(),
 						success: false,
 						error: error instanceof Error ? error.message : String(error)
 					});
@@ -794,8 +809,7 @@ var HttpClient = class {
 				if (errorName === "AbortError" || errorName === "TimeoutError") return false;
 			}
 			if (error instanceof ApiError && error.status) {
-				const retryCodes = this.retry.retryStatusCodes;
-				if (retryCodes?.some((codeKey) => HTTPStatusCode[codeKey] === error.status)) return true;
+				if (this.retry.retryStatusCodes?.some((codeKey) => HTTPStatusCode[codeKey] === error.status)) return true;
 			}
 			return false;
 		};
@@ -859,98 +873,38 @@ var HttpClient = class {
 	}
 	/**
 	* Create a strongly-typed endpoint builder.
+	* Works with any Standard Schema-compatible library (Zod, Valibot, ArkType, etc.)
+	*
+	* @param config - Endpoint configuration with schemas
+	* @returns Endpoint call function
+	*
+	* @example
+	* ```ts
+	* // With Zod
+	* import { z } from 'zod';
+	* const getUser = client.createEndpoint({
+	*   method: 'GET',
+	*   path: '/users/:id',
+	*   response: z.object({ id: z.string(), name: z.string() }),
+	*   pathParams: z.object({ id: z.string() }),
+	* });
 	*
-	* @param config - Endpoint configuration
-	* @returns Endpoint instance
+	* // With Valibot
+	* import * as v from 'valibot';
+	* const getUser = client.createEndpoint({
+	*   method: 'GET',
+	*   path: '/users/:id',
+	*   response: v.object({ id: v.string(), name: v.string() }),
+	*   pathParams: v.object({ id: v.string() }),
+	* });
+	* ```
 	*/
 	createEndpoint(config) {
 		const endpoint = new EndpointImpl(this, config);
 		return (params) => endpoint.call(params);
 	}
 };
-
 //#endregion
-//#region lib/schemas/common.ts
-/**
-* Common ID type that supports strings, numbers, or UUIDs.
-* Use this for entity identifiers in your schemas.
-*
-* @example
-* ```ts
-* const UserSchema = z.object({ id: Id, name: z.string() });
-* ```
-*/
-const Id = z.union([
-	z.string().min(1),
-	z.number(),
-	z.uuid({ version: "v4" })
-]);
-/**
-* Common timestamp fields for entities.
-* Use this for database models with creation/update tracking.
-*
-* @example
-* ```ts
-* const UserSchema = z.object({
-*   id: Id,
-*   name: z.string(),
-*   ...Timestamps.shape
-* });
-* ```
-*/
-const Timestamps = z.object({
-	createdAt: z.iso.datetime(),
-	updatedAt: z.iso.datetime()
-});
-/**
-* Metadata information typically included in API responses.
-* Contains request tracking and debugging information.
-*/
-const Meta = z.object({ timestamp: z.iso.datetime().optional() });
-/**
-* Detailed error information for a specific field or path.
-*/
-const ErrorDetail = z.object({
-	path: z.string().optional(),
-	message: z.string()
-});
-/**
-* Standard API error response schema.
-* Use this for consistent error handling across your API.
-*/
-const ApiErrorSchema = z.object({
-	code: z.string(),
-	message: z.string(),
-	details: z.array(ErrorDetail).optional()
-});
-/**
-* Generic envelope wrapper for API responses.
-* Provides consistent structure with success flag, data, error, and metadata.
-*
-* @param inner - Zod schema for the response data
-* @returns Envelope schema wrapping the inner schema
-*
-* @example
-* ```ts
-* const UserResponseSchema = Envelope(z.object({ id: Id, name: z.string() }));
-*
-* // Response structure:
-* // {
-* //   success: true,
-* //   data: { id: 1, name: 'John' },
-* //   meta: { timestamp: '...' }
-* // }
-* ```
-*/
-const Envelope = (inner, meta) => {
-	return z.object({
-		success: z.boolean(),
-		data: inner.optional().nullable(),
-		error: ApiErrorSchema.optional(),
-		meta: meta !== void 0 ? meta : Meta.optional()
-	});
-};
+export { ApiError, ApiKeyAuth, BearerTokenAuth, ConsoleLogger, ConsoleMetricsCollector, EndpointImpl, HTTPMethod, HTTPStatusCode, HttpClient, InMemoryMetricsCollector, LogLevel, LoggerUtil, NoAuth, NoOpLogger, NoOpMetricsCollector, SchemaDefinitionError, isStandardSchema, parseOrThrow, safeParse, toQueryString };
 
-//#endregion
-export { ApiError, ApiErrorSchema, ApiKeyAuth, BearerTokenAuth, ConsoleLogger, ConsoleMetricsCollector, EndpointImpl, Envelope, ErrorDetail, HTTPMethod, HTTPStatusCode, HttpClient, Id, InMemoryMetricsCollector, LogLevel, LoggerUtil, Meta, NoAuth, NoOpLogger, NoOpMetricsCollector, PaginationSchema, SchemaDefinitionError, Timestamps, toQueryString };
 //# sourceMappingURL=index.js.map