@tahanabavi/typefetch 1.0.0 → 1.0.1

package/dist/client.js

@@ -0,0 +1,98 @@
+"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/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./types";
+export * from "./client";
+export * from "./middlewares/logging";
+export * from "./middlewares/retry";
+export * from "./middlewares/auth";
+export * from "./middlewares/cache";

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./client"), exports);
+__exportStar(require("./middlewares/logging"), exports);
+__exportStar(require("./middlewares/retry"), exports);
+__exportStar(require("./middlewares/auth"), exports);
+__exportStar(require("./middlewares/cache"), exports);

package/dist/middlewares/auth.d.ts

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

package/dist/middlewares/auth.js

@@ -0,0 +1,17 @@
+"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

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

package/dist/middlewares/cache.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheMiddleware = void 0;
+const cacheMiddleware = (options = {}) => {
+    const { ttl = 60000 } = options;
+    const cache = new Map();
+    return async (ctx, next) => {
+        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 = await next();
+            const data = await res
+                .clone()
+                .json()
+                .catch(() => null);
+            if (data)
+                cache.set(ctx.url, { data, expires: now + ttl });
+            return res;
+        }
+        return next();
+    };
+};
+exports.cacheMiddleware = cacheMiddleware;

package/dist/middlewares/logging.d.ts

@@ -0,0 +1,7 @@
+import { Middleware } from "../types";
+export type LoggingOptions = {
+    logRequest?: boolean;
+    logResponse?: boolean;
+    debug?: boolean;
+};
+export declare const loggingMiddleware: Middleware<LoggingOptions>;

package/dist/middlewares/logging.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loggingMiddleware = void 0;
+const loggingMiddleware = async (ctx, next, options) => {
+    const { logRequest = true, logResponse = true, debug = true } = options || {};
+    if (debug && logRequest)
+        console.log("➡️ Request:", ctx.url, ctx.init);
+    const res = await next();
+    if (debug && logResponse)
+        console.log("⬅️ Response:", res.status);
+    return res;
+};
+exports.loggingMiddleware = loggingMiddleware;

package/dist/middlewares/retry.d.ts

@@ -0,0 +1,6 @@
+import { Middleware } from "../types";
+export type RetryOptions = {
+    maxRetries?: number;
+    delay?: number;
+};
+export declare const retryMiddleware: (options?: RetryOptions) => Middleware;

package/dist/middlewares/retry.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryMiddleware = void 0;
+const retryMiddleware = (options) => {
+    const { maxRetries = 3, delay = 500 } = options || {};
+    const middleware = async (ctx, next) => {
+        let attempt = 0;
+        while (true) {
+            try {
+                return await next();
+            }
+            catch (err) {
+                if (attempt >= maxRetries)
+                    throw err;
+                attempt++;
+                await new Promise(r => setTimeout(r, delay * 2 ** attempt));
+            }
+        }
+    };
+    return middleware;
+};
+exports.retryMiddleware = retryMiddleware;

package/jest.config.ts

@@ -1,18 +1,18 @@
-import type { Config } from "jest";
-
-const config: Config = {
-  preset: "ts-jest",
-  testEnvironment: "node",
-  roots: ["<rootDir>/src"],
-  moduleFileExtensions: ["ts", "tsx", "js", "jsx", "json", "node"],
-  transform: {
-    "^.+\\.(ts|tsx)$": "ts-jest",
-  },
-  testMatch: ["**/*.test.ts", "**/*.test.tsx"],
-  collectCoverage: true,
-  collectCoverageFrom: ["src/**/*.{ts,tsx}", "!src/**/*.d.ts"],
-  coverageDirectory: "coverage",
-  clearMocks: true,
-};
-
-export default config;
+import type { Config } from "jest";
+
+const config: Config = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+  roots: ["<rootDir>/src"],
+  moduleFileExtensions: ["ts", "tsx", "js", "jsx", "json", "node"],
+  transform: {
+    "^.+\\.(ts|tsx)$": "ts-jest",
+  },
+  testMatch: ["**/*.test.ts", "**/*.test.tsx"],
+  collectCoverage: true,
+  collectCoverageFrom: ["src/**/*.{ts,tsx}", "!src/**/*.d.ts"],
+  coverageDirectory: "coverage",
+  clearMocks: true,
+};
+
+export default config;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tahanabavi/typefetch",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "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",

package/src/__tests__/client.test.ts

@@ -1,137 +1,137 @@
-import { z, ZodError } from "zod";
-import { ApiClient, RichError } from "../client";
-import { Contracts } from "../types";
-
-// Mock fetch globally
-global.fetch = jest.fn();
-
-const contracts: Contracts = {
-  user: {
-    getUser: {
-      method: "GET",
-      path: "/user",
-      request: z.object({ id: z.string() }),
-      response: z.object({ id: z.string(), name: z.string() }),
-    },
-    createUser: {
-      method: "POST",
-      path: "/user",
-      auth: true,
-      request: z.object({ name: z.string() }),
-      response: z.object({ id: z.string(), name: z.string() }),
-    },
-  },
-};
-
-describe("ApiClient", () => {
-  let client: ApiClient<typeof contracts>;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    client = new 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 as jest.Mock).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({} as any))
-    .rejects.toBeInstanceOf(ZodError);
-});
-
-  it("should handle auth header when token is provided", async () => {
-    const authedClient = new ApiClient(
-      { baseUrl: "https://api.test.com", token: "mytoken" },
-      contracts
-    );
-    authedClient.init();
-
-    (fetch as jest.Mock).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(RichError);
-  });
-
-  it("should call errorHandler when error occurs", async () => {
-    const handler = jest.fn();
-    client.onError(handler);
-
-    (fetch as jest.Mock).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 as jest.Mock).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: string[] = [];
-
-    client.use(async (ctx, next) => {
-      logs.push("before");
-      const res = await next();
-      logs.push("after");
-      return res;
-    });
-
-    (fetch as jest.Mock).mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({ id: "1", name: "John" }),
-    });
-
-    await client.modules.user.getUser({ id: "1" });
-
-    expect(logs).toEqual(["before", "after"]);
-  });
-});
+import { z, ZodError } from "zod";
+import { ApiClient, RichError } from "../client";
+import { Contracts } from "../types";
+
+// Mock fetch globally
+global.fetch = jest.fn();
+
+const contracts: Contracts = {
+  user: {
+    getUser: {
+      method: "GET",
+      path: "/user",
+      request: z.object({ id: z.string() }),
+      response: z.object({ id: z.string(), name: z.string() }),
+    },
+    createUser: {
+      method: "POST",
+      path: "/user",
+      auth: true,
+      request: z.object({ name: z.string() }),
+      response: z.object({ id: z.string(), name: z.string() }),
+    },
+  },
+};
+
+describe("ApiClient", () => {
+  let client: ApiClient<typeof contracts>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    client = new 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 as jest.Mock).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({} as any))
+    .rejects.toBeInstanceOf(ZodError);
+});
+
+  it("should handle auth header when token is provided", async () => {
+    const authedClient = new ApiClient(
+      { baseUrl: "https://api.test.com", token: "mytoken" },
+      contracts
+    );
+    authedClient.init();
+
+    (fetch as jest.Mock).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(RichError);
+  });
+
+  it("should call errorHandler when error occurs", async () => {
+    const handler = jest.fn();
+    client.onError(handler);
+
+    (fetch as jest.Mock).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 as jest.Mock).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: string[] = [];
+
+    client.use(async (ctx, next) => {
+      logs.push("before");
+      const res = await next();
+      logs.push("after");
+      return res;
+    });
+
+    (fetch as jest.Mock).mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ id: "1", name: "John" }),
+    });
+
+    await client.modules.user.getUser({ id: "1" });
+
+    expect(logs).toEqual(["before", "after"]);
+  });
+});