More progress

Author: ejsmith

readme.md

@@ -3,12 +3,18 @@
 
 FetchClient is a library that makes it easier to use the fetch API for JSON APIs. It provides the following features:
 
-* [Makes fetch easier to use for JSON APIs](#typed-response)
-* [Automatic model validation](#model-validator)
-* [Caching](#caching)
-* [Middleware](#middleware)
-* [Problem Details](https://www.rfc-editor.org/rfc/rfc9457.html) support
-* Option to parse dates in responses
+- [FetchClient   ](#fetchclient---)
+  - [Install](#install)
+  - [Docs](#docs)
+  - [Usage](#usage)
+    - [Typed Response](#typed-response)
+    - [Typed Response Using a Function](#typed-response-using-a-function)
+    - [Model Validator](#model-validator)
+    - [Caching](#caching)
+    - [Middleware](#middleware)
+    - [Rate Limiting](#rate-limiting)
+  - [Contributing](#contributing)
+  - [License](#license)
 
 ## Install
 
@@ -130,6 +136,23 @@ const response = await client.getJSON<Products>(
 );
 ```
 
+### Rate Limiting
+
+```ts
+import { FetchClient, useRateLimit } from '@exceptionless/fetchclient';
+
+// Enable rate limiting globally with 100 requests per minute
+useRateLimit({
+  maxRequests: 100,
+  windowSeconds: 60,
+});
+
+const client = new FetchClient();
+const response = await client.getJSON(
+  `https://api.example.com/data`,
+);
+```
+
 Also, take a look at the tests:
 
 [FetchClient Tests](src/FetchClient.test.ts)

src/DefaultHelpers.ts

@@ -7,6 +7,7 @@ import {
 } from "./FetchClientProvider.ts";
 import type { FetchClientResponse } from "./FetchClientResponse.ts";
 import type { ProblemDetails } from "./ProblemDetails.ts";
+import type { RateLimitMiddlewareOptions } from "./RateLimitMiddleware.ts";
 import type { GetRequestOptions, RequestOptions } from "./RequestOptions.ts";
 
 let getCurrentProviderFunc: () => FetchClientProvider | null = () => null;
@@ -164,3 +165,23 @@ export function useMiddleware(middleware: FetchClientMiddleware) {
 export function setRequestOptions(options: RequestOptions) {
   getCurrentProvider().applyOptions({ defaultRequestOptions: options });
 }
+
+/**
+ * Enables rate limiting for any FetchClient instances created by the current provider.
+ * @param options - The rate limiting configuration options.
+ */
+export function useRateLimit(
+  options: RateLimitMiddlewareOptions,
+) {
+  getCurrentProvider().useRateLimit(options);
+}
+
+/**
+ * Enables per-domain rate limiting for any FetchClient instances created by the current provider.
+ * @param options - The rate limiting configuration options.
+ */
+export function usePerDomainRateLimit(
+  options: Omit<RateLimitMiddlewareOptions, "getGroupFunc">,
+) {
+  getCurrentProvider().usePerDomainRateLimit(options);
+}

src/FetchClient.test.ts

@@ -16,6 +16,7 @@ import {
 } from "../mod.ts";
 import { FetchClientProvider } from "./FetchClientProvider.ts";
 import { z, type ZodTypeAny } from "zod";
+import { buildRateLimitHeader } from "./RateLimiter.ts";
 
 export const TodoSchema = z.object({
   userId: z.number(),
@@ -970,6 +971,123 @@ Deno.test("handles 400 response with non-JSON text", async () => {
   );
 });
 
+Deno.test("can use per-domain rate limiting with auto-update from headers", async () => {
+  const provider = new FetchClientProvider();
+
+  const groupTracker = new Map<string, number>();
+
+  const startTime = Date.now();
+
+  groupTracker.set("api.example.com", 100);
+  groupTracker.set("slow-api.example.com", 5);
+
+  provider.usePerDomainRateLimit({
+    maxRequests: 50, // Default limit
+    windowSeconds: 60, // 1 minute default window
+    autoUpdateFromHeaders: true,
+    groups: {
+      "api.example.com": {
+        maxRequests: 100,
+        windowSeconds: 60,
+      },
+      "slow-api.example.com": {
+        maxRequests: 5,
+        windowSeconds: 30,
+      },
+    },
+  });
+
+  provider.fetch = (
+    input: RequestInfo | URL,
+    _init?: RequestInit,
+  ): Promise<Response> => {
+    let url: URL;
+    if (input instanceof Request) {
+      url = new URL(input.url);
+    } else {
+      url = new URL(input.toString());
+    }
+
+    const headers = new Headers({
+      "Content-Type": "application/json",
+    });
+
+    // Simulate different rate limits for different domains
+    if (url.hostname === "api.example.com") {
+      headers.set("X-RateLimit-Limit", "100");
+      let remaining = groupTracker.get("api.example.com") ?? 0;
+      remaining = remaining > 0 ? remaining - 1 : 0;
+      groupTracker.set("api.example.com", remaining);
+      headers.set("X-RateLimit-Remaining", String(remaining));
+    } else if (url.hostname === "slow-api.example.com") {
+      let remaining = groupTracker.get("slow-api.example.com") ?? 0;
+      remaining = remaining > 0 ? remaining - 1 : 0;
+      groupTracker.set("slow-api.example.com", remaining);
+
+      headers.set(
+        "RateLimit-Policy",
+        buildRateLimitHeader({
+          policy: "slow-api.example.com",
+          remaining: remaining,
+          resetSeconds: 30 - ((Date.now() - startTime) / 1000),
+        }),
+      );
+      headers.set(
+        "RateLimit",
+        buildRateLimitHeader({
+          policy: "slow-api.example.com",
+          remaining: remaining,
+          resetSeconds: 30 - ((Date.now() - startTime) / 1000),
+        }),
+      );
+    }
+    // other-api.example.com gets no rate limit headers
+
+    return Promise.resolve(
+      new Response(JSON.stringify({ success: true }), {
+        status: 200,
+        statusText: "OK",
+        headers,
+      }),
+    );
+  };
+
+  const client = provider.getFetchClient();
+
+  const response1 = await client.getJSON(
+    "https://api.example.com/data",
+  );
+  assertEquals(response1.status, 200);
+
+  const response2 = await client.getJSON(
+    "https://slow-api.example.com/data",
+  );
+  assertEquals(response2.status, 200);
+
+  const response3 = await client.getJSON(
+    "https://other-api.example.com/data",
+  );
+  assertEquals(response3.status, 200);
+
+  assert(provider.rateLimiter);
+
+  const apiOptions = provider.rateLimiter.getGroupOptions("api.example.com");
+  assertEquals(apiOptions.maxRequests, 100);
+  assertEquals(apiOptions.windowSeconds, 60);
+
+  const slowApiOptions = provider.rateLimiter.getGroupOptions(
+    "slow-api.example.com",
+  );
+  assertEquals(slowApiOptions.maxRequests, 5);
+  assertEquals(slowApiOptions.windowSeconds, 30);
+
+  const otherOptions = provider.rateLimiter.getGroupOptions(
+    "other-api.example.com",
+  );
+  assertEquals(otherOptions.maxRequests, undefined);
+  assertEquals(otherOptions.windowSeconds, undefined);
+});
+
 function delay(time: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, time));
 }