zlient 1.0.0

package/README.md

@@ -0,0 +1,292 @@
+# zlient
+
+A type-safe HTTP client framework with Zod validation for building robust API clients.
+
+## Features
+
+- 🔒 **Type-safe**: Full TypeScript support with automatic type inference
+- ✅ **Runtime validation**: Zod schemas for request/response validation
+- 🔄 **Retry logic**: Built-in configurable retry strategies
+- 🎯 **Authentication**: Multiple auth providers (API Key, Bearer Token, Custom)
+- 🪝 **Interceptors**: Before request and after response hooks
+- ⏱️ **Timeouts**: Configurable request timeouts
+- 📦 **Multiple endpoints**: Easy service separation with base URL mapping
+
+## Installation
+
+```bash
+npm install zlient zod
+# or
+yarn add zlient zod
+# or
+pnpm add zlient zod
+# or
+bun add zlient zod
+```
+
+## Quick Start
+
+```typescript
+import { HttpClient, BaseEndpoint, BearerTokenAuth } from 'zlient';
+import { z } from 'zod';
+
+// Define your schemas
+const UserSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  email: z.string().email(),
+});
+
+// Create a client
+const client = new HttpClient({
+  baseUrls: {
+    default: 'https://api.example.com',
+  },
+  auth: new BearerTokenAuth(() => 'your-token'),
+});
+
+// Define an endpoint
+class GetUserEndpoint extends BaseEndpoint<typeof z.undefined, typeof UserSchema> {
+  protected method = 'GET' as const;
+  protected path = (params: { id: number }) => `/users/${params.id}`;
+  
+  constructor(client: HttpClient) {
+    super(client, { responseSchema: UserSchema });
+  }
+}
+
+// Use the endpoint
+const getUserEndpoint = new GetUserEndpoint(client);
+const user = await getUserEndpoint.call({ id: 1 });
+console.log(user); // Fully typed!
+```
+
+## Core Concepts
+
+### HttpClient
+
+The main HTTP client that handles requests, retries, authentication, and interceptors.
+
+```typescript
+import { HttpClient, NoAuth } from 'zlient';
+
+const client = new HttpClient({
+  baseUrls: {
+    default: 'https://api.example.com',
+    v2: 'https://api-v2.example.com',
+  },
+  headers: {
+    'Content-Type': 'application/json',
+  },
+  retry: {
+    maxRetries: 3,
+    baseDelayMs: 1000,
+    jitter: 0.2,
+  },
+  timeout: {
+    requestTimeoutMs: 30000,
+  },
+  auth: new NoAuth(),
+});
+```
+
+### Authentication
+
+#### Bearer Token
+
+```typescript
+import { BearerTokenAuth } from 'zlient';
+
+const auth = new BearerTokenAuth(async () => {
+  // Fetch token from your auth service
+  return await getAccessToken();
+});
+
+client.setAuth(auth);
+```
+
+#### API Key
+
+```typescript
+import { ApiKeyAuth } from 'zlient';
+
+// Header-based
+const auth = new ApiKeyAuth({
+  header: 'X-API-Key',
+  value: 'your-api-key',
+});
+
+// Query parameter-based
+const auth = new ApiKeyAuth({
+  query: 'apiKey',
+  value: 'your-api-key',
+});
+```
+
+#### Custom Auth
+
+```typescript
+import { AuthProvider } from 'zlient';
+
+class CustomAuth implements AuthProvider {
+  async apply({ init }) {
+    init.headers = {
+      ...init.headers,
+      'X-Custom-Auth': 'custom-value',
+    };
+  }
+}
+```
+
+### BaseEndpoint
+
+Create type-safe endpoints with automatic validation:
+
+```typescript
+import { BaseEndpoint, HttpClient } from 'zlient';
+import { z } from 'zod';
+
+const CreateUserSchema = z.object({
+  name: z.string(),
+  email: z.string().email(),
+});
+
+const UserResponseSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  email: z.string().email(),
+  createdAt: z.string().datetime(),
+});
+
+class CreateUserEndpoint extends BaseEndpoint<
+  typeof CreateUserSchema,
+  typeof UserResponseSchema
+> {
+  protected method = 'POST' as const;
+  protected path = '/users';
+  
+  constructor(client: HttpClient) {
+    super(client, {
+      requestSchema: CreateUserSchema,
+      responseSchema: UserResponseSchema,
+    });
+  }
+}
+
+// Usage
+const endpoint = new CreateUserEndpoint(client);
+const user = await endpoint.call({
+  name: 'John Doe',
+  email: 'john@example.com',
+});
+```
+
+### Interceptors
+
+Add hooks to inspect or modify requests and responses:
+
+```typescript
+const client = new HttpClient({
+  baseUrls: { default: 'https://api.example.com' },
+  interceptors: {
+    beforeRequest: [
+      async ({ url, init }) => {
+        console.log('Making request to:', url);
+      },
+    ],
+    afterResponse: [
+      async ({ request, response, parsed }) => {
+        console.log('Response received:', response.status);
+      },
+    ],
+  },
+});
+```
+
+### Common Schemas
+
+The package includes common reusable schemas:
+
+```typescript
+import { Id, Timestamps, Meta, ApiErrorSchema, Envelope } from 'zlient';
+
+// Use in your schemas
+const MyEntitySchema = z.object({
+  id: Id,
+  name: z.string(),
+  ...Timestamps.shape,
+});
+
+// Wrap responses in an envelope
+const MyResponseSchema = Envelope(MyEntitySchema);
+```
+
+## Advanced Usage
+
+### Multiple Base URLs
+
+```typescript
+const client = new HttpClient({
+  baseUrls: {
+    default: 'https://api.example.com',
+    auth: 'https://auth.example.com',
+    cdn: 'https://cdn.example.com',
+  },
+});
+
+// Use specific base URL for a request
+await endpoint.call(data, { baseUrlKey: 'auth' });
+```
+
+### Request Options
+
+```typescript
+await endpoint.call(data, {
+  headers: { 'X-Custom-Header': 'value' },
+  baseUrlKey: 'v2',
+  signal: abortController.signal,
+  query: { filter: 'active', page: 1 },
+});
+```
+
+### Error Handling
+
+```typescript
+import { ApiError } from 'zlient';
+
+try {
+  await endpoint.call(data);
+} catch (error) {
+  if (error instanceof ApiError) {
+    console.error('API Error:', error.message);
+    console.error('Status:', error.status);
+    console.error('Details:', error.details);
+    
+    if (error.zodError) {
+      console.error('Validation errors:', error.zodError.errors);
+    }
+  }
+}
+```
+
+## Building from Source
+
+```bash
+# Clone the repository
+git clone <your-repo-url>
+cd zlient
+
+# Install dependencies
+bun install
+
+# Build the package
+bun run build
+```
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.

package/dist/auth.d.ts

@@ -0,0 +1,36 @@
+import type { RequestOptions as ReqOpts } from "./types";
+export interface AuthProvider {
+    /**
+     * Apply authentication to the outgoing request.
+     * Called after SDK headers are assembled, but before request is sent.
+     */
+    apply(req: {
+        url: string;
+        init: RequestInit;
+        options?: ReqOpts;
+    }): Promise<void> | void;
+}
+export declare class NoAuth implements AuthProvider {
+    apply(): Promise<void>;
+}
+export declare class ApiKeyAuth implements AuthProvider {
+    private opts;
+    constructor(opts: {
+        header?: string;
+        query?: string;
+        value: string;
+    });
+    apply({ url, init }: {
+        url: string;
+        init: RequestInit;
+    }): void;
+}
+export declare class BearerTokenAuth implements AuthProvider {
+    private getToken;
+    constructor(getToken: () => Promise<string> | string);
+    apply({ init }: {
+        url: string;
+        init: RequestInit;
+    }): Promise<void>;
+}
+//# sourceMappingURL=auth.d.ts.map

package/dist/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../src/api/auth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,IAAI,OAAO,EAAE,MAAM,SAAS,CAAC;AAEzD,MAAM,WAAW,YAAY;IACzB;;;OAGG;IACH,KAAK,CAAC,GAAG,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,WAAW,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAC3F;AAED,qBAAa,MAAO,YAAW,YAAY;IACjC,KAAK;CACd;AAED,qBAAa,UAAW,YAAW,YAAY;IAC/B,OAAO,CAAC,IAAI;gBAAJ,IAAI,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE;IAC5E,KAAK,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,WAAW,CAAA;KAAE;CAS1D;AAED,qBAAa,eAAgB,YAAW,YAAY;IACpC,OAAO,CAAC,QAAQ;gBAAR,QAAQ,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM;IACtD,KAAK,CAAC,EAAE,IAAI,EAAE,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,WAAW,CAAA;KAAE;CAI3D"}

package/dist/endpoint/BaseEndpoint.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { HttpClient } from "../http/HttpClient";
+import { HTTPMethod, RequestOptions } from "../types";
+/**
+ * Generic, strongly-typed endpoint with Zod schemas for request and response.
+ */
+export declare abstract class BaseEndpoint<ReqSchema extends z.ZodTypeAny, ResSchema extends z.ZodTypeAny> {
+    protected client: HttpClient;
+    protected abstract readonly method: keyof typeof HTTPMethod;
+    protected abstract readonly path: string | ((params: any) => string);
+    protected readonly requestSchema?: ReqSchema;
+    protected readonly responseSchema: ResSchema;
+    constructor(client: HttpClient, cfg: {
+        requestSchema?: ReqSchema;
+        responseSchema: ResSchema;
+    });
+    /**
+     * Call the endpoint with strong typing derived from schemas.
+     */
+    call(args: z.infer<ReqSchema>, options?: RequestOptions): Promise<z.infer<ResSchema>>;
+}
+//# sourceMappingURL=BaseEndpoint.d.ts.map

package/dist/endpoint/BaseEndpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseEndpoint.d.ts","sourceRoot":"","sources":["../../src/api/endpoint/BaseEndpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAGtD;;GAEG;AACH,8BAAsB,YAAY,CAAC,SAAS,SAAS,CAAC,CAAC,UAAU,EAAE,SAAS,SAAS,CAAC,CAAC,UAAU;IAMjF,SAAS,CAAC,MAAM,EAAE,UAAU;IALxC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,OAAO,UAAU,CAAC;IAC5D,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,CAAC,MAAM,EAAE,GAAG,KAAK,MAAM,CAAC,CAAC;IACrE,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,CAAC;IAC7C,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAE,SAAS,CAAC;gBAEvB,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE;QAAE,aAAa,CAAC,EAAE,SAAS,CAAC;QAAC,cAAc,EAAE,SAAS,CAAA;KAAE;IAKvG;;OAEG;IACG,IAAI,CACN,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,EACxB,OAAO,CAAC,EAAE,cAAc,GACzB,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;CAkBjC"}

package/dist/http/HttpClient.d.ts

@@ -0,0 +1,25 @@
+import { ClientOptions, HTTPMethod, RequestOptions } from "../types";
+import type { AuthProvider } from "../auth";
+export declare class HttpClient {
+    private fetchImpl;
+    private baseUrls;
+    private headers;
+    private interceptors;
+    private retry;
+    private timeoutMs?;
+    private auth;
+    constructor(opts: ClientOptions & {
+        auth?: AuthProvider;
+    });
+    setAuth(auth: AuthProvider): void;
+    private resolveBaseUrl;
+    private sleep;
+    private withRetry;
+    private runBeforeHooks;
+    private runAfterHooks;
+    request<T = unknown>(method: keyof typeof HTTPMethod, path: string, body?: unknown, options?: RequestOptions): Promise<{
+        data: T;
+        response: Response;
+    }>;
+}
+//# sourceMappingURL=HttpClient.d.ts.map

package/dist/http/HttpClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpClient.d.ts","sourceRoot":"","sources":["../../src/api/http/HttpClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,aAAa,EAAa,UAAU,EAAgB,cAAc,EAAgC,MAAM,UAAU,CAAC;AACtI,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C,qBAAa,UAAU;IACnB,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,QAAQ,CAA4B;IAC5C,OAAO,CAAC,OAAO,CAAyB;IACxC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,SAAS,CAAC,CAAS;IAC3B,OAAO,CAAC,IAAI,CAAe;gBAEf,IAAI,EAAE,aAAa,GAAG;QAAE,IAAI,CAAC,EAAE,YAAY,CAAA;KAAE;IAgBzD,OAAO,CAAC,IAAI,EAAE,YAAY;IAE1B,OAAO,CAAC,cAAc;IAOtB,OAAO,CAAC,KAAK;YAEC,SAAS;YAiBT,cAAc;YAMd,aAAa;IAMrB,OAAO,CAAC,CAAC,GAAG,OAAO,EACrB,MAAM,EAAE,MAAM,OAAO,UAAU,EAC/B,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,cAAc,GACzB,OAAO,CAAC;QAAE,IAAI,EAAE,CAAC,CAAC;QAAC,QAAQ,EAAE,QAAQ,CAAA;KAAE,CAAC;CA2D9C"}

package/dist/index.cjs

@@ -0,0 +1,352 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function() {
+	return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (all) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+//#endregion
+let zod = require("zod");
+zod = __toESM(zod);
+
+//#region src/api/types.ts
+const HTTPMethod = {
+	GET: "GET",
+	POST: "POST",
+	PUT: "PUT",
+	PATCH: "PATCH",
+	DELETE: "DELETE",
+	HEAD: "HEAD",
+	OPTIONS: "OPTIONS"
+};
+var ApiError = class 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;
+	}
+};
+const PaginationSchema = zod.z.object({
+	items: zod.z.array(zod.z.unknown()),
+	total: zod.z.number().int().nonnegative(),
+	page: zod.z.number().int().nonnegative(),
+	pageSize: zod.z.number().int().positive()
+});
+function toQueryString(q) {
+	if (!q) return "";
+	if (q instanceof URLSearchParams) {
+		const s$1 = q.toString();
+		return s$1 ? `?${s$1}` : "";
+	}
+	const params = new URLSearchParams();
+	Object.entries(q).forEach(([k, v]) => {
+		if (v !== void 0) params.append(k, String(v));
+	});
+	const s = params.toString();
+	return s ? `?${s}` : "";
+}
+
+//#endregion
+//#region src/api/auth.ts
+var auth_exports = /* @__PURE__ */ __export({
+	ApiKeyAuth: () => ApiKeyAuth,
+	BearerTokenAuth: () => BearerTokenAuth,
+	NoAuth: () => NoAuth
+});
+var NoAuth, ApiKeyAuth, BearerTokenAuth;
+var init_auth = __esm({ "src/api/auth.ts": (() => {
+	NoAuth = class {
+		async apply() {}
+	};
+	ApiKeyAuth = class {
+		constructor(opts) {
+			this.opts = opts;
+		}
+		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();
+			}
+		}
+	};
+	BearerTokenAuth = class {
+		constructor(getToken) {
+			this.getToken = getToken;
+		}
+		async apply({ init }) {
+			const token = await this.getToken();
+			init.headers = {
+				...init.headers,
+				Authorization: `Bearer ${token}`
+			};
+		}
+	};
+}) });
+
+//#endregion
+//#region src/api/validation.ts
+function safeParse(schema, data) {
+	const res = schema.safeParse(data);
+	if (res.success) return {
+		success: true,
+		data: res.data
+	};
+	return {
+		success: false,
+		error: res.error
+	};
+}
+function parseOrThrow(schema, data) {
+	const res = schema.safeParse(data);
+	if (!res.success) throw new ApiError("Response validation failed", { zodError: res.error });
+	return res.data;
+}
+
+//#endregion
+//#region src/api/http/HttpClient.ts
+var HttpClient = class {
+	fetchImpl;
+	baseUrls;
+	headers;
+	interceptors;
+	retry;
+	timeoutMs;
+	auth;
+	constructor(opts) {
+		this.fetchImpl = opts.fetch ?? globalThis.fetch?.bind(globalThis);
+		if (!this.fetchImpl) throw new Error("No fetch implementation found. Pass one via options.fetch.");
+		this.baseUrls = opts.baseUrls;
+		this.headers = opts.headers ?? { "Content-Type": "application/json" };
+		this.interceptors = opts.interceptors ?? {};
+		this.retry = opts.retry ?? {
+			maxRetries: 2,
+			baseDelayMs: 250,
+			jitter: .2,
+			retryMethods: ["GET", "HEAD"]
+		};
+		this.timeoutMs = opts.timeout?.requestTimeoutMs;
+		this.auth = opts["auth"] ?? new (init_auth(), __toCommonJS(auth_exports)).NoAuth();
+	}
+	setAuth(auth) {
+		this.auth = auth;
+	}
+	resolveBaseUrl(key) {
+		const k = key || "default";
+		const url = this.baseUrls[k];
+		if (!url) throw new Error(`Unknown baseUrl key: ${k}`);
+		return url.replace(/\/$/, "");
+	}
+	sleep(ms) {
+		return new Promise((res) => setTimeout(res, ms));
+	}
+	async withRetry(fn, canRetry) {
+		let attempt = 0;
+		const { maxRetries, baseDelayMs, jitter = .2 } = this.retry;
+		while (true) try {
+			return await fn();
+		} catch (err) {
+			if (attempt >= maxRetries || !canRetry({
+				attempt,
+				error: err
+			})) throw err;
+			const backoff = baseDelayMs * 2 ** attempt;
+			const j = 1 + (Math.random() * 2 - 1) * jitter;
+			await this.sleep(backoff * j);
+			attempt++;
+		}
+	}
+	async runBeforeHooks(url, init) {
+		for (const h of this.interceptors.beforeRequest ?? []) await h({
+			url,
+			init
+		});
+	}
+	async runAfterHooks(req, res, parsed) {
+		for (const h of this.interceptors.afterResponse ?? []) await h({
+			request: req,
+			response: res,
+			parsed
+		});
+	}
+	async request(method, path, body, options) {
+		let url = `${this.resolveBaseUrl(options?.baseUrlKey)}${path}${toQueryString(options?.query)}`;
+		const headers = {
+			...this.headers,
+			...options?.headers ?? {}
+		};
+		const controller = new AbortController();
+		const signal = options?.signal ?? controller.signal;
+		const init = {
+			method,
+			headers,
+			body: body != null ? headers["Content-Type"]?.includes("json") ? JSON.stringify(body) : body : void 0,
+			signal
+		};
+		await this.auth.apply({
+			url,
+			init,
+			options
+		});
+		if (init.__urlOverride) url = init.__urlOverride;
+		await this.runBeforeHooks(url, init);
+		const doFetch = async () => {
+			let timeoutId;
+			if (this.timeoutMs && !options?.signal) timeoutId = setTimeout(() => controller.abort(new ApiError("Request timeout", { status: 0 })), this.timeoutMs);
+			try {
+				const req = new Request(url, init);
+				console.log("HTTP Request:", req.method, req.url, req);
+				const res = await this.fetchImpl(req);
+				if (!res.ok) {
+					let text = "";
+					try {
+						text = await res.text();
+					} catch {}
+					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();
+				await this.runAfterHooks(new Request(url, init), res, data);
+				return {
+					data,
+					response: res
+				};
+			} finally {
+				if (timeoutId) clearTimeout(timeoutId);
+			}
+		};
+		const canRetry = ({ response, error }) => {
+			if (error instanceof ApiError && error.status && error.status >= 500) return true;
+			if (error?.name === "AbortError") return false;
+			if (!error?.status && !response) return true;
+			return false;
+		};
+		if (!this.retry.retryMethods?.includes(method)) return doFetch();
+		return this.withRetry(doFetch, canRetry);
+	}
+};
+
+//#endregion
+//#region src/api/endpoint/BaseEndpoint.ts
+/**
+* Generic, strongly-typed endpoint with Zod schemas for request and response.
+*/
+var BaseEndpoint = class {
+	requestSchema;
+	responseSchema;
+	constructor(client, cfg) {
+		this.client = client;
+		this.requestSchema = cfg.requestSchema;
+		this.responseSchema = cfg.responseSchema;
+	}
+	/**
+	* Call the endpoint with strong typing derived from schemas.
+	*/
+	async call(args, options) {
+		if (this.requestSchema) {
+			const parsed = this.requestSchema.safeParse(args);
+			if (!parsed.success) throw parsed.error;
+		}
+		const path = typeof this.path === "function" ? this.path(args) : this.path;
+		const body = this.method === "GET" || this.method === "HEAD" ? void 0 : args;
+		const { data } = await this.client.request(this.method, path, body, {
+			...options,
+			query: (this.method === "GET" ? args?.query : void 0) ?? options?.query
+		});
+		return parseOrThrow(this.responseSchema, data);
+	}
+};
+
+//#endregion
+//#region src/api/schemas/common.ts
+const Id = zod.z.union([
+	zod.z.string().min(1),
+	zod.z.number(),
+	zod.z.uuid({ version: "v4" })
+]);
+const Timestamps = zod.z.object({
+	createdAt: zod.z.iso.datetime(),
+	updatedAt: zod.z.iso.datetime()
+});
+const Meta = zod.z.object({
+	requestId: zod.z.string().optional(),
+	timestamp: zod.z.iso.datetime().optional(),
+	traceId: zod.z.string().optional()
+});
+const ErrorDetail = zod.z.object({
+	path: zod.z.string().optional(),
+	message: zod.z.string()
+});
+const ApiErrorSchema = zod.z.object({
+	code: zod.z.string(),
+	message: zod.z.string(),
+	details: zod.z.array(ErrorDetail).optional()
+});
+const Envelope = (inner) => zod.z.object({
+	success: zod.z.boolean(),
+	data: inner.optional(),
+	error: ApiErrorSchema.optional(),
+	meta: Meta.optional()
+});
+
+//#endregion
+//#region src/api/index.ts
+init_auth();
+
+//#endregion
+exports.ApiError = ApiError;
+exports.ApiErrorSchema = ApiErrorSchema;
+exports.ApiKeyAuth = ApiKeyAuth;
+exports.BaseEndpoint = BaseEndpoint;
+exports.BearerTokenAuth = BearerTokenAuth;
+exports.Envelope = Envelope;
+exports.ErrorDetail = ErrorDetail;
+exports.HTTPMethod = HTTPMethod;
+exports.HttpClient = HttpClient;
+exports.Id = Id;
+exports.Meta = Meta;
+exports.NoAuth = NoAuth;
+exports.PaginationSchema = PaginationSchema;
+exports.Timestamps = Timestamps;
+exports.parseOrThrow = parseOrThrow;
+exports.safeParse = safeParse;
+exports.toQueryString = toQueryString;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./types";
+export * from "./auth";
+export * from "./validation";
+export { HttpClient } from "./http/HttpClient";
+export { BaseEndpoint } from "./endpoint/BaseEndpoint";
+export * from "./schemas/common";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/api/index.ts"],"names":[],"mappings":"AACA,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,cAAc,CAAC;AAG7B,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAGvD,cAAc,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,329 @@
+import { z } from "zod";
+
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function() {
+	return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (all) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+//#endregion
+//#region src/api/types.ts
+const HTTPMethod = {
+	GET: "GET",
+	POST: "POST",
+	PUT: "PUT",
+	PATCH: "PATCH",
+	DELETE: "DELETE",
+	HEAD: "HEAD",
+	OPTIONS: "OPTIONS"
+};
+var ApiError = class 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;
+	}
+};
+const PaginationSchema = z.object({
+	items: z.array(z.unknown()),
+	total: z.number().int().nonnegative(),
+	page: z.number().int().nonnegative(),
+	pageSize: z.number().int().positive()
+});
+function toQueryString(q) {
+	if (!q) return "";
+	if (q instanceof URLSearchParams) {
+		const s$1 = q.toString();
+		return s$1 ? `?${s$1}` : "";
+	}
+	const params = new URLSearchParams();
+	Object.entries(q).forEach(([k, v]) => {
+		if (v !== void 0) params.append(k, String(v));
+	});
+	const s = params.toString();
+	return s ? `?${s}` : "";
+}
+
+//#endregion
+//#region src/api/auth.ts
+var auth_exports = /* @__PURE__ */ __export({
+	ApiKeyAuth: () => ApiKeyAuth,
+	BearerTokenAuth: () => BearerTokenAuth,
+	NoAuth: () => NoAuth
+});
+var NoAuth, ApiKeyAuth, BearerTokenAuth;
+var init_auth = __esm({ "src/api/auth.ts": (() => {
+	NoAuth = class {
+		async apply() {}
+	};
+	ApiKeyAuth = class {
+		constructor(opts) {
+			this.opts = opts;
+		}
+		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();
+			}
+		}
+	};
+	BearerTokenAuth = class {
+		constructor(getToken) {
+			this.getToken = getToken;
+		}
+		async apply({ init }) {
+			const token = await this.getToken();
+			init.headers = {
+				...init.headers,
+				Authorization: `Bearer ${token}`
+			};
+		}
+	};
+}) });
+
+//#endregion
+//#region src/api/validation.ts
+function safeParse(schema, data) {
+	const res = schema.safeParse(data);
+	if (res.success) return {
+		success: true,
+		data: res.data
+	};
+	return {
+		success: false,
+		error: res.error
+	};
+}
+function parseOrThrow(schema, data) {
+	const res = schema.safeParse(data);
+	if (!res.success) throw new ApiError("Response validation failed", { zodError: res.error });
+	return res.data;
+}
+
+//#endregion
+//#region src/api/http/HttpClient.ts
+var HttpClient = class {
+	fetchImpl;
+	baseUrls;
+	headers;
+	interceptors;
+	retry;
+	timeoutMs;
+	auth;
+	constructor(opts) {
+		this.fetchImpl = opts.fetch ?? globalThis.fetch?.bind(globalThis);
+		if (!this.fetchImpl) throw new Error("No fetch implementation found. Pass one via options.fetch.");
+		this.baseUrls = opts.baseUrls;
+		this.headers = opts.headers ?? { "Content-Type": "application/json" };
+		this.interceptors = opts.interceptors ?? {};
+		this.retry = opts.retry ?? {
+			maxRetries: 2,
+			baseDelayMs: 250,
+			jitter: .2,
+			retryMethods: ["GET", "HEAD"]
+		};
+		this.timeoutMs = opts.timeout?.requestTimeoutMs;
+		this.auth = opts["auth"] ?? new (init_auth(), __toCommonJS(auth_exports)).NoAuth();
+	}
+	setAuth(auth) {
+		this.auth = auth;
+	}
+	resolveBaseUrl(key) {
+		const k = key || "default";
+		const url = this.baseUrls[k];
+		if (!url) throw new Error(`Unknown baseUrl key: ${k}`);
+		return url.replace(/\/$/, "");
+	}
+	sleep(ms) {
+		return new Promise((res) => setTimeout(res, ms));
+	}
+	async withRetry(fn, canRetry) {
+		let attempt = 0;
+		const { maxRetries, baseDelayMs, jitter = .2 } = this.retry;
+		while (true) try {
+			return await fn();
+		} catch (err) {
+			if (attempt >= maxRetries || !canRetry({
+				attempt,
+				error: err
+			})) throw err;
+			const backoff = baseDelayMs * 2 ** attempt;
+			const j = 1 + (Math.random() * 2 - 1) * jitter;
+			await this.sleep(backoff * j);
+			attempt++;
+		}
+	}
+	async runBeforeHooks(url, init) {
+		for (const h of this.interceptors.beforeRequest ?? []) await h({
+			url,
+			init
+		});
+	}
+	async runAfterHooks(req, res, parsed) {
+		for (const h of this.interceptors.afterResponse ?? []) await h({
+			request: req,
+			response: res,
+			parsed
+		});
+	}
+	async request(method, path, body, options) {
+		let url = `${this.resolveBaseUrl(options?.baseUrlKey)}${path}${toQueryString(options?.query)}`;
+		const headers = {
+			...this.headers,
+			...options?.headers ?? {}
+		};
+		const controller = new AbortController();
+		const signal = options?.signal ?? controller.signal;
+		const init = {
+			method,
+			headers,
+			body: body != null ? headers["Content-Type"]?.includes("json") ? JSON.stringify(body) : body : void 0,
+			signal
+		};
+		await this.auth.apply({
+			url,
+			init,
+			options
+		});
+		if (init.__urlOverride) url = init.__urlOverride;
+		await this.runBeforeHooks(url, init);
+		const doFetch = async () => {
+			let timeoutId;
+			if (this.timeoutMs && !options?.signal) timeoutId = setTimeout(() => controller.abort(new ApiError("Request timeout", { status: 0 })), this.timeoutMs);
+			try {
+				const req = new Request(url, init);
+				console.log("HTTP Request:", req.method, req.url, req);
+				const res = await this.fetchImpl(req);
+				if (!res.ok) {
+					let text = "";
+					try {
+						text = await res.text();
+					} catch {}
+					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();
+				await this.runAfterHooks(new Request(url, init), res, data);
+				return {
+					data,
+					response: res
+				};
+			} finally {
+				if (timeoutId) clearTimeout(timeoutId);
+			}
+		};
+		const canRetry = ({ response, error }) => {
+			if (error instanceof ApiError && error.status && error.status >= 500) return true;
+			if (error?.name === "AbortError") return false;
+			if (!error?.status && !response) return true;
+			return false;
+		};
+		if (!this.retry.retryMethods?.includes(method)) return doFetch();
+		return this.withRetry(doFetch, canRetry);
+	}
+};
+
+//#endregion
+//#region src/api/endpoint/BaseEndpoint.ts
+/**
+* Generic, strongly-typed endpoint with Zod schemas for request and response.
+*/
+var BaseEndpoint = class {
+	requestSchema;
+	responseSchema;
+	constructor(client, cfg) {
+		this.client = client;
+		this.requestSchema = cfg.requestSchema;
+		this.responseSchema = cfg.responseSchema;
+	}
+	/**
+	* Call the endpoint with strong typing derived from schemas.
+	*/
+	async call(args, options) {
+		if (this.requestSchema) {
+			const parsed = this.requestSchema.safeParse(args);
+			if (!parsed.success) throw parsed.error;
+		}
+		const path = typeof this.path === "function" ? this.path(args) : this.path;
+		const body = this.method === "GET" || this.method === "HEAD" ? void 0 : args;
+		const { data } = await this.client.request(this.method, path, body, {
+			...options,
+			query: (this.method === "GET" ? args?.query : void 0) ?? options?.query
+		});
+		return parseOrThrow(this.responseSchema, data);
+	}
+};
+
+//#endregion
+//#region src/api/schemas/common.ts
+const Id = z.union([
+	z.string().min(1),
+	z.number(),
+	z.uuid({ version: "v4" })
+]);
+const Timestamps = z.object({
+	createdAt: z.iso.datetime(),
+	updatedAt: z.iso.datetime()
+});
+const Meta = z.object({
+	requestId: z.string().optional(),
+	timestamp: z.iso.datetime().optional(),
+	traceId: z.string().optional()
+});
+const ErrorDetail = z.object({
+	path: z.string().optional(),
+	message: z.string()
+});
+const ApiErrorSchema = z.object({
+	code: z.string(),
+	message: z.string(),
+	details: z.array(ErrorDetail).optional()
+});
+const Envelope = (inner) => z.object({
+	success: z.boolean(),
+	data: inner.optional(),
+	error: ApiErrorSchema.optional(),
+	meta: Meta.optional()
+});
+
+//#endregion
+//#region src/api/index.ts
+init_auth();
+
+//#endregion
+export { ApiError, ApiErrorSchema, ApiKeyAuth, BaseEndpoint, BearerTokenAuth, Envelope, ErrorDetail, HTTPMethod, HttpClient, Id, Meta, NoAuth, PaginationSchema, Timestamps, parseOrThrow, safeParse, toQueryString };

package/dist/schemas/common.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+export declare const Id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodUUID]>;
+export type Id = z.infer<typeof Id>;
+export declare const Timestamps: z.ZodObject<{
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export declare const Meta: z.ZodObject<{
+    requestId: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodOptional<z.ZodISODateTime>;
+    traceId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ErrorDetail: z.ZodObject<{
+    path: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+}, z.core.$strip>;
+export declare const ApiErrorSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    details: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodOptional<z.ZodString>;
+        message: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const Envelope: <T extends z.ZodTypeAny>(inner: T) => z.ZodObject<{
+    success: z.ZodBoolean;
+    data: z.ZodOptional<T>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodOptional<z.ZodString>;
+            message: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    meta: z.ZodOptional<z.ZodObject<{
+        requestId: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodOptional<z.ZodISODateTime>;
+        traceId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+//# sourceMappingURL=common.d.ts.map

package/dist/schemas/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/api/schemas/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,EAAE,4DAEX,CAAC;AACL,MAAM,MAAM,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;AAGpC,eAAO,MAAM,UAAU;;;iBAGrB,CAAC;AAGH,eAAO,MAAM,IAAI;;;;iBAIf,CAAC;AAGH,eAAO,MAAM,WAAW;;;iBAGtB,CAAC;AAGH,eAAO,MAAM,cAAc;;;;;;;iBAIzB,CAAC;AAGH,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;iBAMnD,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,99 @@
+import { z, ZodError } from "zod";
+export type Dictionary<T = unknown> = Record<string, T>;
+export type FetchLike = (input: string | Request | URL, init?: RequestInit) => Promise<Response>;
+export type BaseUrlMap = {
+    default: string;
+    [service: string]: string;
+};
+export type RetryStrategy = {
+    maxRetries: number;
+    /** milliseconds */
+    baseDelayMs: number;
+    /** Jitter factor 0..1 */
+    jitter?: number;
+    /** HTTP methods eligible for retry */
+    retryMethods?: (keyof typeof HTTPMethod)[];
+    /** Which status codes are retriable */
+    shouldRetry?: (ctx: {
+        attempt: number;
+        error?: unknown;
+        response?: Response;
+    }) => boolean;
+};
+export declare const HTTPMethod: {
+    readonly GET: "GET";
+    readonly POST: "POST";
+    readonly PUT: "PUT";
+    readonly PATCH: "PATCH";
+    readonly DELETE: "DELETE";
+    readonly HEAD: "HEAD";
+    readonly OPTIONS: "OPTIONS";
+};
+export type HttpMethod = keyof typeof HTTPMethod;
+export type AfterResponseHook = (ctx: {
+    request: Request;
+    response: Response;
+    parsed?: unknown;
+}) => Promise<void> | void;
+export type BeforeRequestHook = (ctx: {
+    url: string;
+    init: RequestInit;
+}) => Promise<void> | void;
+export interface Interceptors {
+    beforeRequest?: BeforeRequestHook[];
+    afterResponse?: AfterResponseHook[];
+}
+export interface TimeoutOptions {
+    /** ms */
+    requestTimeoutMs?: number;
+}
+export interface ClientOptions {
+    baseUrls: BaseUrlMap;
+    fetch?: FetchLike;
+    headers?: Record<string, string>;
+    retry?: RetryStrategy;
+    interceptors?: Interceptors;
+    timeout?: TimeoutOptions;
+}
+export type SafeParseResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: ZodError;
+};
+export declare class ApiError extends Error {
+    status?: number;
+    details?: unknown;
+    zodError?: ZodError;
+    constructor(message: string, options?: {
+        status?: number;
+        cause?: unknown;
+        details?: unknown;
+        zodError?: ZodError;
+    });
+}
+export type Paginated<T> = {
+    items: T[];
+    total: number;
+    page: number;
+    pageSize: number;
+};
+export declare const PaginationSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodUnknown>;
+    total: z.ZodNumber;
+    page: z.ZodNumber;
+    pageSize: z.ZodNumber;
+}, z.core.$strip>;
+export type RequestOptions = {
+    /** Override base URL for a single call */
+    baseUrlKey?: keyof BaseUrlMap;
+    /** Additional headers for this call only */
+    headers?: Record<string, string>;
+    /** Abort controller */
+    signal?: AbortSignal;
+    /** Custom query params */
+    query?: URLSearchParams | Record<string, string | number | boolean | undefined>;
+};
+export declare function toQueryString(q?: RequestOptions["query"]): string;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/api/types.ts"],"names":[],"mappings":"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"}

package/dist/validation.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+import { SafeParseResult } from "./types";
+export declare function safeParse<T>(schema: z.ZodTypeAny, data: unknown): SafeParseResult<T>;
+export declare function parseOrThrow<T>(schema: z.ZodTypeAny, data: unknown): T;
+//# sourceMappingURL=validation.d.ts.map

package/dist/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/api/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAY,eAAe,EAAE,MAAM,SAAS,CAAC;AAEpD,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,UAAU,EAAE,IAAI,EAAE,OAAO,GAAG,eAAe,CAAC,CAAC,CAAC,CAIpF;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,UAAU,EAAE,IAAI,EAAE,OAAO,GAAG,CAAC,CAMtE"}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "zlient",
+  "version": "1.0.0",
+  "description": "A type-safe HTTP client framework with Zod validation",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rolldown -c && tsc --emitDeclarationOnly --outDir dist",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "http-client",
+    "api-client",
+    "zod",
+    "validation",
+    "typescript"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/bun": "latest",
+    "rolldown": "^1.0.0-beta.44",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "zod": "^3.0.0 || ^4.0.0"
+  },
+  "dependencies": {
+    "zod": "^4.1.12"
+  }
+}