@tahanabavi/typefetch 1.0.2 → 1.0.3

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"]);
-  });
-});

package/src/__tests__/middlewares.test.ts

@@ -1,108 +0,0 @@
-import { authMiddleware } from "../middlewares/auth";
-import { cacheMiddleware } from "../middlewares/cache";
-import { loggingMiddleware } from "../middlewares/logging";
-import { retryMiddleware } from "../middlewares/retry";
-
-describe("middlewares", () => {
-  const mockCtx = (url = "/test", method = "GET") => ({
-    url,
-    init: { method, headers: {} as Record<string, string> },
-  });
-
-  const mockNext = (response: any = { 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 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 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 = 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 = 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 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 = 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 = retryMiddleware({ maxRetries: 2, delay: 10 });
-
-    await expect(middleware(ctx, next)).rejects.toThrow("fail always");
-    expect(next).toHaveBeenCalledTimes(3); // initial + 2 retries
-  });
-});

package/src/client.ts

@@ -1,142 +0,0 @@
-import {
-  Contracts,
-  EndpointDef,
-  EndpointDefZ,
-  Middleware,
-  ErrorLike,
-  EndpointMethods,
-} from "./types";
-import { z } from "zod";
-
-export class RichError extends Error implements ErrorLike {
-  status?: number;
-  code?: string;
-  title?: string;
-  detail?: string;
-  errors?: Record<string, string[]>;
-
-  constructor(error: Partial<ErrorLike> & { message: string }) {
-    super(error.message);
-    Object.assign(this, error);
-  }
-}
-
-export class ApiClient<C extends Contracts, E extends ErrorLike = RichError> {
-  private middlewares: Array<{ fn: Middleware; options?: any }> = [];
-  private errorHandler?: (error: E) => void;
-  private responseTransform: (data: any) => any = (d) => d;
-
-  private _modules!: {
-    [M in keyof C]: EndpointMethods<C[M]>;
-  };
-
-  constructor(
-    private config: { baseUrl: string; token?: string },
-    private contracts: C
-  ) {}
-
-  init() {
-    const modules = {} as {
-      [M in keyof C]: EndpointMethods<C[M]>;
-    };
-
-    for (const moduleName in this.contracts) {
-      const module = this.contracts[moduleName];
-      (modules as any)[moduleName] = {} as EndpointMethods<typeof module>;
-
-      for (const endpointName in module) {
-        const endpoint = module[endpointName] as EndpointDefZ;
-
-        (modules as any)[moduleName][endpointName] = (
-          input: z.infer<(typeof endpoint)["request"]>
-        ) => this.request(endpoint, input);
-      }
-    }
-
-    this._modules = modules;
-  }
-
-  get modules() {
-    return this._modules;
-  }
-
-  use<T>(middleware: Middleware<T>, options?: T) {
-    this.middlewares.push({ fn: middleware, options });
-  }
-
-  onError(handler: (error: E) => void) {
-    this.errorHandler = handler;
-  }
-
-  useResponseTransform(fn: (data: any) => any) {
-    this.responseTransform = fn;
-  }
-
-  private async request<TReq extends z.ZodTypeAny, TRes extends z.ZodTypeAny>(
-    endpoint: EndpointDef<TReq, TRes>,
-    input: z.infer<TReq>
-  ): Promise<z.infer<TRes>> {
-    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 as unknown as E);
-      throw error;
-    }
-
-    const headers: HeadersInit = { "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 as unknown as E);
-        throw error;
-      }
-
-      const json = await res.json();
-      return this.responseTransform(endpoint.response.parse(json));
-    } catch (err: any) {
-      const error = this.normalizeError(err);
-      this.errorHandler?.(error as unknown as E);
-      throw error;
-    }
-  }
-
-  private createError(error: Partial<RichError> & { message: string }) {
-    return new RichError(error);
-  }
-
-  private normalizeError(err: any) {
-    if (err instanceof RichError) return err;
-    return this.createError({ message: err.message || "Unknown error" });
-  }
-}

package/src/index.ts

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

package/src/middlewares/auth.ts

@@ -1,19 +0,0 @@
-import { Middleware } from "../types";
-
-export type AuthOptions = {
-  refreshToken?: () => Promise<string>;
-};
-
-export const authMiddleware: Middleware<AuthOptions> = 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();
-};

package/src/middlewares/cache.ts

@@ -1,26 +0,0 @@
-import { MiddlewareContext, MiddlewareNext } from "../types";
-
-export type CacheOptions = { ttl?: number };
-
-export const cacheMiddleware = (options: CacheOptions = {}) => {
-  const { ttl = 60000 } = options;
-  const cache = new Map<string, { data: any; expires: number }>();
-
-  return async (ctx: MiddlewareContext, next: MiddlewareNext) => {
-    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();
-  };
-};

package/src/middlewares/logging.ts

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

package/src/middlewares/retry.ts

@@ -1,25 +0,0 @@
-import { Middleware } from "../types";
-
-export type RetryOptions = {
-  maxRetries?: number;
-  delay?: number; // ms
-};
-
-export const retryMiddleware = (options?: RetryOptions): Middleware => {
-  const { maxRetries = 3, delay = 500 } = options || {};
-
-  const middleware: 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;
-};

package/src/types.d.ts

@@ -1,46 +0,0 @@
-import { z } from "zod";
-
-export type EndpointDef<
-  TReq extends z.ZodTypeAny,
-  TRes extends z.ZodTypeAny
-> = {
-  method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
-  path: string;
-  auth?: boolean;
-  request: TReq;
-  response: TRes;
-};
-
-export type Contracts = {
-  [ModuleName: string]: {
-    [EndpointName: string]: EndpointDef<z.ZodTypeAny, z.ZodTypeAny>;
-  };
-};
-
-export interface MiddlewareContext {
-  url: string;
-  init: RequestInit;
-}
-
-export type MiddlewareNext = () => Promise<Response>;
-
-export type Middleware<Options = any> = (
-  ctx: MiddlewareContext,
-  next: MiddlewareNext,
-  options?: Options
-) => Promise<Response>;
-
-export type ErrorLike = {
-  message: string;
-  status?: number;
-  code?: string;
-  [key: string]: any;
-};
-
-export type EndpointDefZ = EndpointDef<z.ZodTypeAny, z.ZodTypeAny>;
-
-export type EndpointMethods<M extends Record<string, EndpointDefZ>> = {
-  [K in keyof M]: (
-    input: z.infer<M[K]["request"]>
-  ) => Promise<z.infer<M[K]["response"]>>;
-};

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "declaration": true,
-    "outDir": "dist",
-    "strict": true,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true
-  },
-  "include": ["src", "__test__"]
-}