@tahanabavi/typefetch 1.0.2 → 1.1.0

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>;

package/dist/middlewares/cache.js

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

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

package/dist/middlewares/logging.js

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

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

package/dist/middlewares/retry.js

@@ -1,22 +0,0 @@
-"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 +0,0 @@
-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/src/__tests__/client.test.ts

@@ -1,137 +0,0 @@
-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"]);
-  });
-});