Add rate limiting support

Author: ejsmith

deno.json

@@ -9,10 +9,10 @@
     "test": "deno test --allow-net"
   },
   "imports": {
-    "@deno/dnt": "jsr:@deno/dnt@^0.41.3",
-    "@std/assert": "jsr:@std/assert@^1.0.10",
-    "@std/path": "jsr:@std/path@^1.0.8",
-    "zod": "npm:zod@^3.24.1"
+    "@deno/dnt": "jsr:@deno/dnt@^0.42.1",
+    "@std/assert": "jsr:@std/assert@^1.0.13",
+    "@std/path": "jsr:@std/path@^1.1.1",
+    "zod": "npm:zod@^4.0.5"
   },
   "exclude": ["npm"]
 }

deno.lock

@@ -11,3 +11,4 @@ export {
   FetchClientProvider,
 } from "./src/FetchClientProvider.ts";
 export * from "./src/DefaultHelpers.ts";
+export { type RateLimitConfig, RateLimiter } from "./src/RateLimiter.ts";

mod.ts

@@ -7,6 +7,7 @@ FetchClient is a library that makes it easier to use the fetch API for JSON APIs
 * [Automatic model validation](#model-validator)
 * [Caching](#caching)
 * [Middleware](#middleware)
+* [Rate limiting](#rate-limiting)
 * [Problem Details](https://www.rfc-editor.org/rfc/rfc9457.html) support
 * Option to parse dates in responses
 
@@ -130,6 +131,32 @@ const response = await client.getJSON<Products>(
 );
 ```
 
+### Rate Limiting
+
+```ts
+import { FetchClientProvider } from '@exceptionless/fetchclient';
+
+const provider = new FetchClientProvider();
+
+// Enable rate limiting: max 100 requests per hour
+provider.enableRateLimit({
+  maxRequests: 100,
+  windowMs: 60 * 60 * 1000, // 1 hour
+});
+
+const client = provider.getFetchClient();
+
+// Requests exceeding the limit will receive HTTP 429 responses
+const response = await client.getJSON('https://api.example.com/data', {
+  expectedStatusCodes: [200, 429] // Handle 429 without throwing
+});
+
+if (response.status === 429) {
+  const retryAfter = response.headers.get('Retry-After');
+  console.log(`Rate limited. Retry after ${retryAfter} seconds`);
+}
+```
+
 Also, take a look at the tests:
 
 [FetchClient Tests](src/FetchClient.test.ts)

readme.md

@@ -8,6 +8,7 @@ import {
 import type { FetchClientResponse } from "./FetchClientResponse.ts";
 import type { ProblemDetails } from "./ProblemDetails.ts";
 import type { GetRequestOptions, RequestOptions } from "./RequestOptions.ts";
+import type { RateLimitConfig } from "./RateLimiter.ts";
 
 let getCurrentProviderFunc: () => FetchClientProvider | null = () => null;
 
@@ -164,3 +165,11 @@ export function useMiddleware(middleware: FetchClientMiddleware) {
 export function setRequestOptions(options: RequestOptions) {
   getCurrentProvider().applyOptions({ defaultRequestOptions: options });
 }
+
+/**
+ * Enables rate limiting for the current provider.
+ * @param config - The rate limit configuration.
+ */
+export function enableRateLimit(config: RateLimitConfig) {
+  getCurrentProvider().enableRateLimit(config);
+}

src/DefaultHelpers.ts

@@ -8,14 +8,14 @@ import {
   useFetchClient,
 } from "../mod.ts";
 import { FetchClientProvider } from "./FetchClientProvider.ts";
-import { z, type ZodTypeAny } from "zod";
+import * as z from "zod/mini";
 
 export const TodoSchema = z.object({
   userId: z.number(),
   id: z.number(),
   title: z.string(),
   completed: z.boolean(),
-  completedTime: z.coerce.date().optional(),
+  completedTime: z.optional(z.coerce.date()),
 });
 
 type Todo = z.infer<typeof TodoSchema>;
@@ -614,7 +614,7 @@ Deno.test("can getJSON with zod schema", async () => {
     await next();
 
     if (ctx.options.schema) {
-      const schema = ctx.options.schema as ZodTypeAny;
+      const schema = ctx.options.schema as z.ZodMiniType;
       const parsed = schema.safeParse(ctx.response!.data);
 
       if (parsed.success) {

src/FetchClient.test.ts

@@ -5,6 +5,11 @@ import type { ProblemDetails } from "./ProblemDetails.ts";
 import { FetchClientCache } from "./FetchClientCache.ts";
 import type { FetchClientOptions } from "./FetchClientOptions.ts";
 import { type IObjectEvent, ObjectEvent } from "./ObjectEvent.ts";
+import {
+  createRateLimitMiddleware,
+  type RateLimitConfig,
+  RateLimiter,
+} from "./RateLimiter.ts";
 
 type Fetch = typeof globalThis.fetch;
 
@@ -17,6 +22,7 @@ export class FetchClientProvider {
   #cache: FetchClientCache;
   #counter = new Counter();
   #onLoading = new ObjectEvent<boolean>();
+  #rateLimiter?: RateLimiter;
 
   /**
    * Creates a new instance of FetchClientProvider.
@@ -187,6 +193,22 @@ export class FetchClientProvider {
       ],
     };
   }
+
+  /**
+   * Enables rate limiting for all FetchClient instances created by this provider.
+   * @param config - The rate limit configuration.
+   */
+  public enableRateLimit(config: RateLimitConfig) {
+    this.#rateLimiter = new RateLimiter(config);
+    this.useMiddleware(createRateLimitMiddleware(this.#rateLimiter));
+  }
+
+  /**
+   * Gets the current rate limiter instance, if rate limiting is enabled.
+   */
+  public get rateLimiter(): RateLimiter | undefined {
+    return this.#rateLimiter;
+  }
 }
 
 const provider = new FetchClientProvider();