@tahanabavi/typefetch 1.0.2 → 1.0.3

package/dist/index.mjs

@@ -0,0 +1,208 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __pow = Math.pow;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/client.ts
+var RichError = class extends Error {
+  constructor(error) {
+    super(error.message);
+    Object.assign(this, error);
+  }
+};
+var ApiClient = class {
+  constructor(config, contracts) {
+    this.config = config;
+    this.contracts = contracts;
+    this.middlewares = [];
+    this.responseTransform = (d) => d;
+  }
+  init() {
+    const modules = {};
+    for (const moduleName in this.contracts) {
+      const module = this.contracts[moduleName];
+      modules[moduleName] = {};
+      for (const endpointName in module) {
+        const endpoint = module[endpointName];
+        modules[moduleName][endpointName] = (input) => this.request(endpoint, input);
+      }
+    }
+    this._modules = modules;
+  }
+  get modules() {
+    return this._modules;
+  }
+  use(middleware, options) {
+    this.middlewares.push({ fn: middleware, options });
+  }
+  onError(handler) {
+    this.errorHandler = handler;
+  }
+  useResponseTransform(fn) {
+    this.responseTransform = fn;
+  }
+  request(endpoint, input) {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      endpoint.request.parse(input);
+      if (endpoint.auth && !this.config.token) {
+        const error = this.createError({
+          message: `Missing token for ${endpoint.path}`,
+          status: 401,
+          code: "NO_TOKEN"
+        });
+        (_a = this.errorHandler) == null ? void 0 : _a.call(this, error);
+        throw error;
+      }
+      const headers = { "Content-Type": "application/json" };
+      if (endpoint.auth && this.config.token)
+        headers["Authorization"] = `Bearer ${this.config.token}`;
+      const ctx = {
+        url: this.config.baseUrl + endpoint.path,
+        init: {
+          method: endpoint.method,
+          headers,
+          body: endpoint.method !== "GET" ? JSON.stringify(input) : void 0
+        }
+      };
+      const runner = this.middlewares.reduceRight(
+        (next, mw) => () => mw.fn(ctx, next, mw.options),
+        () => fetch(ctx.url, ctx.init)
+      );
+      try {
+        const res = yield runner();
+        if (!res.ok) {
+          const errorData = yield res.json().catch(() => ({}));
+          const error = this.createError({
+            message: errorData.message || res.statusText,
+            status: res.status,
+            code: errorData.code,
+            title: errorData.title,
+            detail: errorData.detail,
+            errors: errorData.errors
+          });
+          (_b = this.errorHandler) == null ? void 0 : _b.call(this, error);
+          throw error;
+        }
+        const json = yield res.json();
+        return this.responseTransform(endpoint.response.parse(json));
+      } catch (err) {
+        const error = this.normalizeError(err);
+        (_c = this.errorHandler) == null ? void 0 : _c.call(this, error);
+        throw error;
+      }
+    });
+  }
+  createError(error) {
+    return new RichError(error);
+  }
+  normalizeError(err) {
+    if (err instanceof RichError) return err;
+    return this.createError({ message: err.message || "Unknown error" });
+  }
+};
+
+// src/middlewares/logging.ts
+var loggingMiddleware = (ctx, next, options) => __async(null, null, function* () {
+  const { logRequest = true, logResponse = true, debug = true } = options || {};
+  if (debug && logRequest) console.log("\u27A1\uFE0F Request:", ctx.url, ctx.init);
+  const res = yield next();
+  if (debug && logResponse) console.log("\u2B05\uFE0F Response:", res.status);
+  return res;
+});
+
+// src/middlewares/retry.ts
+var retryMiddleware = (options) => {
+  const { maxRetries = 3, delay = 500 } = options || {};
+  const middleware = (ctx, next) => __async(null, null, function* () {
+    let attempt = 0;
+    while (true) {
+      try {
+        return yield next();
+      } catch (err) {
+        if (attempt >= maxRetries) throw err;
+        attempt++;
+        yield new Promise((r) => setTimeout(r, delay * __pow(2, attempt)));
+      }
+    }
+  });
+  return middleware;
+};
+
+// src/middlewares/auth.ts
+var authMiddleware = (ctx, next, options) => __async(null, null, function* () {
+  if (options == null ? void 0 : options.refreshToken) {
+    try {
+      const newToken = yield options.refreshToken();
+      ctx.init.headers = __spreadProps(__spreadValues({}, ctx.init.headers), {
+        Authorization: `Bearer ${newToken}`
+      });
+    } catch (e) {
+    }
+  }
+  return next();
+});
+
+// src/middlewares/cache.ts
+var cacheMiddleware = (options = {}) => {
+  const { ttl = 6e4 } = options;
+  const cache = /* @__PURE__ */ new Map();
+  return (ctx, next) => __async(null, null, function* () {
+    if (ctx.init.method === "GET") {
+      const cached = cache.get(ctx.url);
+      const now = Date.now();
+      if (cached && cached.expires > now)
+        return new Response(JSON.stringify(cached.data));
+      const res = yield next();
+      const data = yield res.clone().json().catch(() => null);
+      if (data) cache.set(ctx.url, { data, expires: now + ttl });
+      return res;
+    }
+    return next();
+  });
+};
+export {
+  ApiClient,
+  RichError,
+  authMiddleware,
+  cacheMiddleware,
+  loggingMiddleware,
+  retryMiddleware
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client.ts","../src/middlewares/logging.ts","../src/middlewares/retry.ts","../src/middlewares/auth.ts","../src/middlewares/cache.ts"],"sourcesContent":["import {\n  Contracts,\n  EndpointDef,\n  EndpointDefZ,\n  Middleware,\n  ErrorLike,\n  EndpointMethods,\n} from \"@/types\";\nimport { z } from \"zod\";\n\nexport class RichError extends Error implements ErrorLike {\n  status?: number;\n  code?: string;\n  title?: string;\n  detail?: string;\n  errors?: Record<string, string[]>;\n\n  constructor(error: Partial<ErrorLike> & { message: string }) {\n    super(error.message);\n    Object.assign(this, error);\n  }\n}\n\nexport class ApiClient<C extends Contracts, E extends ErrorLike = RichError> {\n  private middlewares: Array<{ fn: Middleware; options?: any }> = [];\n  private errorHandler?: (error: E) => void;\n  private responseTransform: (data: any) => any = (d) => d;\n\n  private _modules!: {\n    [M in keyof C]: EndpointMethods<C[M]>;\n  };\n\n  constructor(\n    private config: { baseUrl: string; token?: string },\n    private contracts: C\n  ) {}\n\n  init() {\n    const modules = {} as {\n      [M in keyof C]: EndpointMethods<C[M]>;\n    };\n\n    for (const moduleName in this.contracts) {\n      const module = this.contracts[moduleName];\n      (modules as any)[moduleName] = {} as EndpointMethods<typeof module>;\n\n      for (const endpointName in module) {\n        const endpoint = module[endpointName] as EndpointDefZ;\n\n        (modules as any)[moduleName][endpointName] = (\n          input: z.infer<(typeof endpoint)[\"request\"]>\n        ) => this.request(endpoint, input);\n      }\n    }\n\n    this._modules = modules;\n  }\n\n  get modules() {\n    return this._modules;\n  }\n\n  use<T>(middleware: Middleware<T>, options?: T) {\n    this.middlewares.push({ fn: middleware, options });\n  }\n\n  onError(handler: (error: E) => void) {\n    this.errorHandler = handler;\n  }\n\n  useResponseTransform(fn: (data: any) => any) {\n    this.responseTransform = fn;\n  }\n\n  private async request<TReq extends z.ZodTypeAny, TRes extends z.ZodTypeAny>(\n    endpoint: EndpointDef<TReq, TRes>,\n    input: z.infer<TReq>\n  ): Promise<z.infer<TRes>> {\n    endpoint.request.parse(input);\n\n    if (endpoint.auth && !this.config.token) {\n      const error = this.createError({\n        message: `Missing token for ${endpoint.path}`,\n        status: 401,\n        code: \"NO_TOKEN\",\n      });\n      this.errorHandler?.(error as unknown as E);\n      throw error;\n    }\n\n    const headers: HeadersInit = { \"Content-Type\": \"application/json\" };\n    if (endpoint.auth && this.config.token)\n      headers[\"Authorization\"] = `Bearer ${this.config.token}`;\n\n    const ctx = {\n      url: this.config.baseUrl + endpoint.path,\n      init: {\n        method: endpoint.method,\n        headers,\n        body: endpoint.method !== \"GET\" ? JSON.stringify(input) : undefined,\n      },\n    };\n\n    const runner = this.middlewares.reduceRight(\n      (next, mw) => () => mw.fn(ctx, next, mw.options),\n      () => fetch(ctx.url, ctx.init)\n    );\n\n    try {\n      const res = await runner();\n      if (!res.ok) {\n        const errorData = await res.json().catch(() => ({}));\n        const error = this.createError({\n          message: errorData.message || res.statusText,\n          status: res.status,\n          code: errorData.code,\n          title: errorData.title,\n          detail: errorData.detail,\n          errors: errorData.errors,\n        });\n        this.errorHandler?.(error as unknown as E);\n        throw error;\n      }\n\n      const json = await res.json();\n      return this.responseTransform(endpoint.response.parse(json));\n    } catch (err: any) {\n      const error = this.normalizeError(err);\n      this.errorHandler?.(error as unknown as E);\n      throw error;\n    }\n  }\n\n  private createError(error: Partial<RichError> & { message: string }) {\n    return new RichError(error);\n  }\n\n  private normalizeError(err: any) {\n    if (err instanceof RichError) return err;\n    return this.createError({ message: err.message || \"Unknown error\" });\n  }\n}\n","import { Middleware } from \"@/types\";\n\nexport type LoggingOptions = {\n  logRequest?: boolean;\n  logResponse?: boolean;\n  debug?: boolean;\n};\n\nexport const loggingMiddleware: Middleware<LoggingOptions> = async (\n  ctx,\n  next,\n  options\n) => {\n  const { logRequest = true, logResponse = true, debug = true } = options || {};\n\n  if (debug && logRequest) console.log(\"➡️ Request:\", ctx.url, ctx.init);\n\n  const res = await next();\n\n  if (debug && logResponse) console.log(\"⬅️ Response:\", res.status);\n\n  return res;\n};\n","import { Middleware } from \"@/types\";\n\n\nexport type RetryOptions = {\n  maxRetries?: number;\n  delay?: number; // ms\n};\n\nexport const retryMiddleware = (options?: RetryOptions): Middleware => {\n  const { maxRetries = 3, delay = 500 } = options || {};\n\n  const middleware: Middleware = async (ctx, next) => {\n    let attempt = 0;\n    while (true) {\n      try {\n        return await next();\n      } catch (err) {\n        if (attempt >= maxRetries) throw err;\n        attempt++;\n        await new Promise((r) => setTimeout(r, delay * 2 ** attempt));\n      }\n    }\n  };\n\n  return middleware;\n};\n","import { Middleware } from \"@/types\";\n\nexport type AuthOptions = {\n  refreshToken?: () => Promise<string>;\n};\n\nexport const authMiddleware: Middleware<AuthOptions> = async (\n  ctx,\n  next,\n  options\n) => {\n  if (options?.refreshToken) {\n    try {\n      const newToken = await options.refreshToken();\n      ctx.init.headers = {\n        ...ctx.init.headers,\n        Authorization: `Bearer ${newToken}`,\n      };\n    } catch {}\n  }\n\n  return next();\n};\n","import { MiddlewareContext, MiddlewareNext } from \"@/types\";\n\nexport type CacheOptions = { ttl?: number };\n\nexport const cacheMiddleware = (options: CacheOptions = {}) => {\n  const { ttl = 60000 } = options;\n  const cache = new Map<string, { data: any; expires: number }>();\n\n  return async (ctx: MiddlewareContext, next: MiddlewareNext) => {\n    if (ctx.init.method === \"GET\") {\n      const cached = cache.get(ctx.url);\n      const now = Date.now();\n      if (cached && cached.expires > now)\n        return new Response(JSON.stringify(cached.data));\n\n      const res = await next();\n      const data = await res\n        .clone()\n        .json()\n        .catch(() => null);\n      if (data) cache.set(ctx.url, { data, expires: now + ttl });\n      return res;\n    }\n    return next();\n  };\n};\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "@tahanabavi/typefetch",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "A fully type-safe, extensible API client for TypeScript projects, featuring global error handling, configurable middleware, automatic retries, auth refresh, response transforms, and seamless contract integration. Designed for large-scale applications and developer-friendly API interactions.",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "/dist"
+  ],
   "scripts": {
-    "build": "tsc",
+    "build": "tsup",
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage"
@@ -15,6 +19,7 @@
     "jest": "^30.1.3",
     "jest-fetch-mock": "^3.0.3",
     "ts-jest": "^29.4.1",
+    "tsup": "^8.5.0",
     "typescript": "^5.9.2",
     "zod": "^3.25.76"
   },

package/.github/workflows/publish.yml

@@ -1,36 +0,0 @@
-name: Publish Package
-
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - 'package.json'
-      - 'src/**'
-      - 'README.md'
-      - '.github/workflows/publish.yml'
-
-jobs:
-  build-and-publish:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v3
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: 20
-          registry-url: https://registry.npmjs.org/
-
-      - name: Install dependencies
-        run: npm install
-
-      - name: Build package
-        run: npm run build
-
-      - name: Publish to npm
-        run: npm publish --access public
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/dist/__tests__/client.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/client.test.js

@@ -1,108 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const zod_1 = require("zod");
-const client_1 = require("../client");
-// Mock fetch globally
-global.fetch = jest.fn();
-const contracts = {
-    user: {
-        getUser: {
-            method: "GET",
-            path: "/user",
-            request: zod_1.z.object({ id: zod_1.z.string() }),
-            response: zod_1.z.object({ id: zod_1.z.string(), name: zod_1.z.string() }),
-        },
-        createUser: {
-            method: "POST",
-            path: "/user",
-            auth: true,
-            request: zod_1.z.object({ name: zod_1.z.string() }),
-            response: zod_1.z.object({ id: zod_1.z.string(), name: zod_1.z.string() }),
-        },
-    },
-};
-describe("ApiClient", () => {
-    let client;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        client = new client_1.ApiClient({ baseUrl: "https://api.test.com" }, contracts);
-        client.init();
-    });
-    it("should initialize modules correctly", () => {
-        expect(client.modules.user).toBeDefined();
-        expect(typeof client.modules.user.getUser).toBe("function");
-    });
-    it("should call fetch with correct URL and headers", async () => {
-        fetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({ id: "1", name: "John" }),
-        });
-        const res = await client.modules.user.getUser({ id: "1" });
-        expect(fetch).toHaveBeenCalledWith("https://api.test.com/user", {
-            method: "GET",
-            headers: { "Content-Type": "application/json" },
-            body: undefined,
-        });
-        expect(res).toEqual({ id: "1", name: "John" });
-    });
-    it("should throw validation error if input is invalid", async () => {
-        await expect(client.modules.user.getUser({}))
-            .rejects.toBeInstanceOf(zod_1.ZodError);
-    });
-    it("should handle auth header when token is provided", async () => {
-        const authedClient = new client_1.ApiClient({ baseUrl: "https://api.test.com", token: "mytoken" }, contracts);
-        authedClient.init();
-        fetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({ id: "2", name: "Alice" }),
-        });
-        await authedClient.modules.user.createUser({ name: "Alice" });
-        expect(fetch).toHaveBeenCalledWith("https://api.test.com/user", {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: "Bearer mytoken",
-            },
-            body: JSON.stringify({ name: "Alice" }),
-        });
-    });
-    it("should throw error if auth required and no token provided", async () => {
-        await expect(client.modules.user.createUser({ name: "Alice" })).rejects.toThrow(client_1.RichError);
-    });
-    it("should call errorHandler when error occurs", async () => {
-        const handler = jest.fn();
-        client.onError(handler);
-        fetch.mockResolvedValueOnce({
-            ok: false,
-            status: 400,
-            statusText: "Bad Request",
-            json: async () => ({ message: "Invalid input" }),
-        });
-        await expect(client.modules.user.getUser({ id: "bad" })).rejects.toThrow();
-        expect(handler).toHaveBeenCalled();
-    });
-    it("should apply responseTransform", async () => {
-        client.useResponseTransform((data) => ({ ...data, transformed: true }));
-        fetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({ id: "1", name: "John" }),
-        });
-        const res = await client.modules.user.getUser({ id: "1" });
-        expect(res).toEqual({ id: "1", name: "John", transformed: true });
-    });
-    it("should execute middleware in order", async () => {
-        const logs = [];
-        client.use(async (ctx, next) => {
-            logs.push("before");
-            const res = await next();
-            logs.push("after");
-            return res;
-        });
-        fetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({ id: "1", name: "John" }),
-        });
-        await client.modules.user.getUser({ id: "1" });
-        expect(logs).toEqual(["before", "after"]);
-    });
-});

package/dist/__tests__/middlewares.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/middlewares.test.js

@@ -1,85 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const auth_1 = require("../middlewares/auth");
-const cache_1 = require("../middlewares/cache");
-const logging_1 = require("../middlewares/logging");
-const retry_1 = require("../middlewares/retry");
-describe("middlewares", () => {
-    const mockCtx = (url = "/test", method = "GET") => ({
-        url,
-        init: { method, headers: {} },
-    });
-    const mockNext = (response = { ok: true, status: 200 }) => jest.fn().mockResolvedValue(new Response(JSON.stringify(response)));
-    // ---------------- AUTH ----------------
-    it("authMiddleware should add refreshed token", async () => {
-        const ctx = mockCtx();
-        const next = mockNext();
-        await (0, auth_1.authMiddleware)(ctx, next, {
-            refreshToken: async () => "NEW_TOKEN",
-        });
-        expect(ctx.init.headers["Authorization"]).toBe("Bearer NEW_TOKEN");
-        expect(next).toHaveBeenCalled();
-    });
-    it("authMiddleware should skip if no refreshToken provided", async () => {
-        const ctx = mockCtx();
-        const next = mockNext();
-        await (0, auth_1.authMiddleware)(ctx, next, {});
-        expect(ctx.init.headers["Authorization"]).toBeUndefined();
-        expect(next).toHaveBeenCalled();
-    });
-    // ---------------- CACHE ----------------
-    it("cacheMiddleware should cache GET responses", async () => {
-        const ctx = mockCtx("/users", "GET");
-        const next = mockNext({ users: [1, 2, 3] });
-        const middleware = (0, cache_1.cacheMiddleware)({ ttl: 1000 });
-        const res1 = await middleware(ctx, next);
-        const res2 = await middleware(ctx, next);
-        expect(next).toHaveBeenCalledTimes(1); // only first time
-        const data2 = await res2.json();
-        expect(data2.users).toEqual([1, 2, 3]);
-    });
-    it("cacheMiddleware should bypass cache for non-GET requests", async () => {
-        const ctx = mockCtx("/users", "POST");
-        const next = mockNext({ ok: true });
-        const middleware = (0, cache_1.cacheMiddleware)();
-        await middleware(ctx, next);
-        expect(next).toHaveBeenCalledTimes(1);
-    });
-    // ---------------- LOGGING ----------------
-    it("loggingMiddleware should log request and response", async () => {
-        const ctx = mockCtx();
-        const next = mockNext();
-        const logSpy = jest.spyOn(console, "log").mockImplementation(() => { });
-        await (0, logging_1.loggingMiddleware)(ctx, next, {
-            logRequest: true,
-            logResponse: true,
-            debug: true,
-        });
-        expect(logSpy).toHaveBeenCalledWith("➡️ Request:", ctx.url, ctx.init);
-        expect(logSpy).toHaveBeenCalledWith("⬅️ Response:", 200);
-        logSpy.mockRestore();
-    });
-    // ---------------- RETRY ----------------
-    it("retryMiddleware should retry failed requests", async () => {
-        const ctx = mockCtx();
-        let attempt = 0;
-        const next = jest.fn().mockImplementation(() => {
-            attempt++;
-            if (attempt < 2)
-                throw new Error("fail");
-            return Promise.resolve(new Response(JSON.stringify({ ok: true })));
-        });
-        const middleware = (0, retry_1.retryMiddleware)({ maxRetries: 3, delay: 10 });
-        const res = await middleware(ctx, next);
-        const json = await res.json();
-        expect(json.ok).toBe(true);
-        expect(next).toHaveBeenCalledTimes(2);
-    });
-    it("retryMiddleware should throw after exceeding maxRetries", async () => {
-        const ctx = mockCtx();
-        const next = jest.fn().mockRejectedValue(new Error("fail always"));
-        const middleware = (0, retry_1.retryMiddleware)({ maxRetries: 2, delay: 10 });
-        await expect(middleware(ctx, next)).rejects.toThrow("fail always");
-        expect(next).toHaveBeenCalledTimes(3); // initial + 2 retries
-    });
-});

package/dist/client.d.ts

@@ -1,31 +0,0 @@
-import { Contracts, Middleware, ErrorLike, EndpointMethods } from "./types";
-export declare class RichError extends Error implements ErrorLike {
-    status?: number;
-    code?: string;
-    title?: string;
-    detail?: string;
-    errors?: Record<string, string[]>;
-    constructor(error: Partial<ErrorLike> & {
-        message: string;
-    });
-}
-export declare class ApiClient<C extends Contracts, E extends ErrorLike = RichError> {
-    private config;
-    private contracts;
-    private middlewares;
-    private errorHandler?;
-    private responseTransform;
-    private _modules;
-    constructor(config: {
-        baseUrl: string;
-        token?: string;
-    }, contracts: C);
-    init(): void;
-    get modules(): { [M in keyof C]: EndpointMethods<C[M]>; };
-    use<T>(middleware: Middleware<T>, options?: T): void;
-    onError(handler: (error: E) => void): void;
-    useResponseTransform(fn: (data: any) => any): void;
-    private request;
-    private createError;
-    private normalizeError;
-}

package/dist/client.js

@@ -1,98 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiClient = exports.RichError = void 0;
-class RichError extends Error {
-    constructor(error) {
-        super(error.message);
-        Object.assign(this, error);
-    }
-}
-exports.RichError = RichError;
-class ApiClient {
-    constructor(config, contracts) {
-        this.config = config;
-        this.contracts = contracts;
-        this.middlewares = [];
-        this.responseTransform = (d) => d;
-    }
-    init() {
-        const modules = {};
-        for (const moduleName in this.contracts) {
-            const module = this.contracts[moduleName];
-            modules[moduleName] = {};
-            for (const endpointName in module) {
-                const endpoint = module[endpointName];
-                modules[moduleName][endpointName] = (input) => this.request(endpoint, input);
-            }
-        }
-        this._modules = modules;
-    }
-    get modules() {
-        return this._modules;
-    }
-    use(middleware, options) {
-        this.middlewares.push({ fn: middleware, options });
-    }
-    onError(handler) {
-        this.errorHandler = handler;
-    }
-    useResponseTransform(fn) {
-        this.responseTransform = fn;
-    }
-    async request(endpoint, input) {
-        endpoint.request.parse(input);
-        if (endpoint.auth && !this.config.token) {
-            const error = this.createError({
-                message: `Missing token for ${endpoint.path}`,
-                status: 401,
-                code: "NO_TOKEN",
-            });
-            this.errorHandler?.(error);
-            throw error;
-        }
-        const headers = { "Content-Type": "application/json" };
-        if (endpoint.auth && this.config.token)
-            headers["Authorization"] = `Bearer ${this.config.token}`;
-        const ctx = {
-            url: this.config.baseUrl + endpoint.path,
-            init: {
-                method: endpoint.method,
-                headers,
-                body: endpoint.method !== "GET" ? JSON.stringify(input) : undefined,
-            },
-        };
-        const runner = this.middlewares.reduceRight((next, mw) => () => mw.fn(ctx, next, mw.options), () => fetch(ctx.url, ctx.init));
-        try {
-            const res = await runner();
-            if (!res.ok) {
-                const errorData = await res.json().catch(() => ({}));
-                const error = this.createError({
-                    message: errorData.message || res.statusText,
-                    status: res.status,
-                    code: errorData.code,
-                    title: errorData.title,
-                    detail: errorData.detail,
-                    errors: errorData.errors,
-                });
-                this.errorHandler?.(error);
-                throw error;
-            }
-            const json = await res.json();
-            return this.responseTransform(endpoint.response.parse(json));
-        }
-        catch (err) {
-            const error = this.normalizeError(err);
-            this.errorHandler?.(error);
-            throw error;
-        }
-    }
-    createError(error) {
-        return new RichError(error);
-    }
-    normalizeError(err) {
-        if (err instanceof RichError)
-            return err;
-        return this.createError({ message: err.message || "Unknown error" });
-    }
-}
-exports.ApiClient = ApiClient;

package/dist/middlewares/auth.d.ts

@@ -1,5 +0,0 @@
-import { Middleware } from "../types";
-export type AuthOptions = {
-    refreshToken?: () => Promise<string>;
-};
-export declare const authMiddleware: Middleware<AuthOptions>;

package/dist/middlewares/auth.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.authMiddleware = void 0;
-const authMiddleware = async (ctx, next, options) => {
-    if (options?.refreshToken) {
-        try {
-            const newToken = await options.refreshToken();
-            ctx.init.headers = {
-                ...ctx.init.headers,
-                Authorization: `Bearer ${newToken}`
-            };
-        }
-        catch { }
-    }
-    return next();
-};
-exports.authMiddleware = authMiddleware;

package/dist/middlewares/cache.d.ts

@@ -1,5 +0,0 @@
-import { MiddlewareContext, MiddlewareNext } from "../types";
-export type CacheOptions = {
-    ttl?: number;
-};
-export declare const cacheMiddleware: (options?: CacheOptions) => (ctx: MiddlewareContext, next: MiddlewareNext) => Promise<Response>;