@tahanabavi/typefetch 1.0.0 → 1.0.1

package/src/__tests__/middlewares.test.ts

@@ -1,108 +1,108 @@
-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
-  });
-});
+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 +1,142 @@
-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" });
-  }
-}
+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 +1,6 @@
-export * from "./types";
-export * from "./client";
-export * from "./middlewares/logging";
-export * from "./middlewares/retry";
-export * from "./middlewares/auth";
-export * from "./middlewares/cache";
+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 +1,19 @@
-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();
-};
+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 +1,26 @@
-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();
-  };
-};
+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 +1,19 @@
-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;
-};
+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;
+};