### Install Borrow Node.js Package

Source: https://github.com/borrowdev/borrow/blob/main/apps/docs/src/app/limiter/quick-start/page.mdx

Installs the Borrow Node.js package using different package managers. This is the first step to integrate Borrow Limiter into your Node.js application.

```bash
npm install @borrowdev/node
```

```bash
pnpm add @borrowdev/node
```

```bash
yarn add @borrowdev/node
```

```bash
bun add @borrowdev/node
```

--------------------------------

### Example: Create Supabase Proxy Project using Borrow CLI

Source: https://github.com/borrowdev/borrow/blob/main/apps/README.md

An example demonstrating the usage of the `borrow start new` command to create a new project from the 'supabase-proxy' template, outputting it to a specified directory.

```bash
borrow start new -t supabase-proxy -o ~/my-awesome-project
```

--------------------------------

### Implement Sliding Window Rate Limiting with Borrow

Source: https://github.com/borrowdev/borrow/blob/main/apps/docs/src/app/limiter/quick-start/page.mdx

Demonstrates how to use the Borrow Limiter API with the sliding window algorithm to enforce rate limits. It includes examples in TypeScript, JavaScript, and a curl command for testing.

```TypeScript
import { borrow } from "@borrowdev/node";

const { success, timeLeft } = await borrow.limiter("my-limiter-id", "current-user-id", {
	limiters: [{
		maxRequests: 10,
		interval: "minute",
		type: "sliding",
	}]
});
if (!success) {
	return { message: "Rate limit exceeded." + timeLeft !== null ? ` You can try again in ${timeLeft} seconds.` : "" };
}
// ... Your expensive business logic
```

```JavaScript
import { borrow } from "@borrowdev/node";

const { success, timeLeft } = await borrow.limiter("my-limiter-id", "current-user-id", {
	limiters: [{
		maxRequests: 10,
		interval: "minute",
		type: "sliding",
	}]
});
if (!success) {
	return { message: "Rate limit exceeded." + timeLeft !== null ? ` You can try again in ${timeLeft} seconds.` : "" };
}
// ... Your expensive business logic
```

```curl
curl https://api.borrow.dev/v1/limiter \
  --request POST \
  --header 'Content-Type: application/json' \
  --data '{
  "userId": "current-user-id",
  "key": "login",
  "limiters": [
    {
      "type": "sliding",
      "maxRequests": 10,
      "interval": "minute"
    }
  ]
}'
```

--------------------------------

### Install Borrow and Redis Dependencies

Source: https://github.com/borrowdev/borrow/blob/main/apps/docs/src/app/limiter/self-hosting/page.mdx

Installs the necessary npm packages for the Borrow Limiter and Upstash Redis adapter. This command is essential for setting up the project environment.

```bash
npm install @borrowdev/node @upstash/redis
```

--------------------------------

### Borrow CLI Usage Examples

Source: https://github.com/borrowdev/borrow/blob/main/README.md

Provides examples of how to use the Borrow CLI to manage templates. This includes commands to download and install a new template from the Borrow registry or a local path, and to delete a cached template.

```bash
# Download and install a template
borrow start new -t <template> -o <output_dir>
# Delete a template from the cache
borrow start del -t <template>
```

```bash
borrow start new -t supabase-proxy -o ~/my-awesome-project
```

--------------------------------

### Rate Limiting with Borrow Algorithm

Source: https://github.com/borrowdev/borrow/blob/main/apps/docs/src/app/limiter/quick-start/page.mdx

This endpoint allows for rate limiting using the borrow algorithm, ensuring exclusive access to a resource for a limited time. It supports starting and ending a borrow action.

```APIDOC
## POST /v1/limiter (Borrow Algorithm)

### Description
Applies rate limiting using the borrow algorithm to ensure exclusive access.

### Method
POST

### Endpoint
https://api.borrow.dev/v1/limiter

### Parameters
#### Query Parameters
None

#### Request Body
- **userId** (string) - Required - The ID of the user for whom the limiter is being applied.
- **key** (string) - Required - A unique identifier for the limiter.
- **limiters** (array) - Required - An array of limiter configurations.
  - **borrowAction** (string) - Required - The action to perform, either 'start' or 'end'.
  - **type** (string) - Required - The type of limiter, must be 'borrow'.
  - **timeout** (number) - Required - The duration in seconds for the borrow.

### Request Example (Start Borrow)
```json
{
  "userId": "current-user-id",
  "key": "my-limiter-id",
  "limiters": [
    {
      "borrowAction": "start",
      "type": "borrow",
      "timeout": 10
    }
  ]
}
```

### Request Example (End Borrow)
```json
{
  "userId": "current-user-id",
  "key": "my-limiter-id",
  "limiters": [
    {
      "type": "borrow",
      "borrowAction": "end",
      "timeout": 10
    }
  ]
}
```

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the request was successful (rate limit not exceeded or borrow action completed).
- **timeLeft** (number | null) - The time in seconds until the user can try again if the rate limit was exceeded, otherwise null.

#### Response Example
```json
{
  "success": true,
  "timeLeft": null
}
```
```

--------------------------------

### Implement Fixed Window Rate Limiting with Borrow

Source: https://github.com/borrowdev/borrow/blob/main/apps/docs/src/app/limiter/quick-start/page.mdx

Demonstrates how to use the Borrow Limiter API with the fixed window algorithm to enforce rate limits. It shows usage in TypeScript, JavaScript, and provides a curl command for testing.

```TypeScript
import { borrow } from "@borrowdev/node";

const { success, timeLeft } = await borrow.limiter("my-limiter-id", "current-user-id", {
	limiters: [{
		maxRequests: 10,
		interval: "minute",
		type: "fixed",
	}]
});
if (!success) {
	return { message: "Rate limit exceeded." + timeLeft !== null ? ` You can try again in ${timeLeft} seconds.` : "" };
}

// ... Your expensive business logic
```

```JavaScript
import { borrow } from "@borrowdev/node";

const { success, timeLeft } = await borrow.limiter("my-limiter-id", "current-user-id", {
	limiters: [{
		maxRequests: 10,
		interval: "minute",
		type: "fixed",
	}]
});
if (!success) {
	return { message: "Rate limit exceeded." + timeLeft !== null ? ` You can try again in ${timeLeft} seconds.` : "" };
}

// ... Your expensive business logic
```

```curl
curl https://api.borrow.dev/v1/limiter \
  --request POST \
  --header 'Content-Type: application/json' \
  --data '{
  "userId": "current-user-id",
  "key": "login",
  "limiters": [
    {
      "type": "fixed",
      "maxRequests": 10,
      "interval": "minute"
    }
  ]
}'
```

--------------------------------

### Rate Limiting with Token Bucket Algorithm

Source: https://github.com/borrowdev/borrow/blob/main/apps/docs/src/app/limiter/quick-start/page.mdx

This endpoint allows you to configure and apply rate limiting using the token bucket algorithm. You can set parameters like maximum tokens, tokens per replenish, and interval.

```APIDOC
## POST /v1/limiter (Token Bucket)

### Description
Applies rate limiting using the token bucket algorithm.

### Method
POST

### Endpoint
https://api.borrow.dev/v1/limiter

### Parameters
#### Query Parameters
None

#### Request Body
- **userId** (string) - Required - The ID of the user for whom the limiter is being applied.
- **key** (string) - Required - A unique identifier for the limiter.
- **limiters** (array) - Required - An array of limiter configurations.
  - **maxTokens** (number) - Required - The maximum number of tokens the bucket can hold.
  - **tokensCost** (number) - Required - The number of tokens consumed by a single request.
  - **tokensPerReplenish** (number) - Required - The number of tokens to replenish per interval.
  - **interval** (string) - Required - The time interval for token replenishment (e.g., 'minute', 'hour').
  - **type** (string) - Required - The type of limiter, must be 'token'.

### Request Example
```json
{
  "userId": "current-user-id",
  "key": "my-limiter-id",
  "limiters": [
    {
      "maxTokens": 20,
      "tokensCost": 5,
      "tokensPerReplenish": 10,
      "interval": "minute",
      "type": "token"
    }
  ]
}
```

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the request was successful (rate limit not exceeded).
- **timeLeft** (number | null) - The time in seconds until the user can try again if the rate limit was exceeded, otherwise null.

#### Response Example
```json
{
  "success": true,
  "timeLeft": null
}
```
```

--------------------------------

### Borrow Algorithm Rate Limiting with Borrow (TypeScript, JavaScript, curl)

Source: https://github.com/borrowdev/borrow/blob/main/apps/docs/src/app/limiter/quick-start/page.mdx

Limits requests to one at a time using the Borrow algorithm. It requires starting and ending the 'borrow' action. If the limit is exceeded, it returns a message and the time until the next attempt is possible. Requires the '@borrowdev/node' library for TS/JS.

```TypeScript
import { borrow } from "@borrowdev/node";

const { success, timeLeft } = await borrow.limiter("my-limiter-id", "current-user-id", {
	limiters: [{
		borrowAction: "start",
		type: "borrow",
		timeout: 10,
	}]
});
if (!success) {
	return { message: "Rate limit exceeded." + timeLeft !== null ? ` You can try again in ${timeLeft} seconds.` : "" };
}
// ... Your expensive business logic
const { success: endSuccess } = await borrow.limiter("my-limiter-id", "current-user-id", {
	limiters: [{
		borrowAction: "end",
		type: "borrow",
		timeout: 10,
	}]
});
if (!endSuccess) {
	return { message: "Failed to end borrow." };
}
```

```JavaScript
import { borrow } from "@borrowdev/node";

const { success, timeLeft } = await borrow.limiter("my-limiter-id", "current-user-id", {
	limiters: [{
		borrowAction: "start",
		type: "borrow",
		timeout: 10,
	}]
});
if (!success) {
	return { message: "Rate limit exceeded." + timeLeft !== null ? ` You can try again in ${timeLeft} seconds.` : "" };
}
// ... Your expensive business logic
const { success: endSuccess } = await borrow.limiter("my-limiter-id", "current-user-id", {
	limiters: [{
		borrowAction: "end",
		type: "borrow",
		timeout: 10,
	}]
});
if (!endSuccess) {
	return { message: "Failed to end borrow." };
}
```

```curl
# Start the borrow
curl https://api.borrow.dev/v1/limiter \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'x-borrow-api-key: YOUR_API_KEY' \
  --data '{ \
  "userId": "current-user-id", \
  "key": "my-limiter-id", \
  "limiters": [ \
    { \
	  "borrowAction": "start", \
      "type": "borrow", \
	  "timeout": 10 \
    } \
  ] \
}'

# End the borrow when finished
curl https://api.borrow.dev/v1/limiter \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'x-borrow-api-key: YOUR_API_KEY' \
  --data '{ \
  "userId": "current-user-id", \
  "key": "my-limiter-id", \
  "limiters": [ \
    { \
      "type": "borrow", \
      "borrowAction": "end", \
	  "timeout": 10 \
    } \
  ] \
}'
```

--------------------------------

### Token Bucket Rate Limiting with Borrow (TypeScript, JavaScript, curl)

Source: https://github.com/borrowdev/borrow/blob/main/apps/docs/src/app/limiter/quick-start/page.mdx

Implements rate limiting using the Token Bucket algorithm, allowing a maximum of 20 tokens with a replenish rate of 10 tokens per minute. Handles success and provides remaining time if limits are exceeded. Requires the '@borrowdev/node' library.

```TypeScript
import { borrow } from "@borrowdev/node";

const { success, timeLeft } = await borrow.limiter("my-limiter-id", "current-user-id", {
	limiters: [{
		maxTokens: 20,
		tokensCost: 5,
		tokensPerReplenish: 10,
		interval: "minute",
		type: "token",
	}]
});
if (!success) {
	return { message: "Rate limit exceeded." + timeLeft !== null ? ` You can try again in ${timeLeft} seconds.` : "" };
}
// ... Your expensive business logic
```

```JavaScript
import { borrow } from "@borrowdev/node";

const { success, timeLeft } = await borrow.limiter("my-limiter-id", "current-user-id", {
	limiters: [{
		maxTokens: 20,
		tokensCost: 5,
		tokensPerReplenish: 10,
		interval: "minute",
		type: "token",
	}]
});
if (!success) {
	return { message: "Rate limit exceeded." + timeLeft !== null ? ` You can try again in ${timeLeft} seconds.` : "" };
}
// ... Your expensive business logic
```

```curl
curl https://api.borrow.dev/v1/limiter \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'x-borrow-api-key: YOUR_API_KEY' \
  --data '{ \
  "userId": "current-user-id", \
  "key": "my-limiter-id", \
  "limiters": [ \
    { \
      "maxTokens": 20, \
      "tokensCost": 5, \
      "tokensPerReplenish": 10, \
      "interval": "minute", \
	  "type": "token" \
    } \
  ] \
}'
```

--------------------------------

### Scaffold Projects with Borrow CLI Templates

Source: https://context7.com/borrowdev/borrow/llms.txt

Quickly scaffold new projects using pre-configured templates from the Borrow registry or local sources with the Borrow CLI. Commands are provided for installing the CLI, creating new projects from registry or local templates, and removing cached templates. This requires the Rust toolchain to build and install the 'borrow-dev' binary.

```bash
# Install Borrow CLI
cargo install borrow-dev

# Create new project from template
borrow start new -t supabase-proxy -o ~/my-awesome-project

# Use local template
borrow start new -t local:my-custom-template -o ~/project

# Remove cached template
borrow start del -t supabase-proxy
```

--------------------------------

### Call Borrow Limiter API with TypeScript Client

Source: https://github.com/borrowdev/borrow/blob/main/apps/docs/src/app/limiter/self-hosting/page.mdx

Example of how to use the Borrow client library in TypeScript to check rate limits before executing expensive business logic. It shows configuration options like fail behavior and API key.

```typescript
import { borrow } from "@borrowdev/node";
 
const { success, timeLeft } = await borrow.limiter("my-limiter-id", "current-user-id", {
  limiters: [{
    maxTokens: 20,
    tokensCost: 5,
    tokensPerReplenish: 10,
    interval: "minute",
    type: "token",
  }],
  options: {
    // Use for testing or if you want to fail closed.
    failBehavior: "fail",
    apiKey: "random-secure-string",
    endpoint: {
      baseUrl: "http://localhost:8787",
    }
  }
});
if (!success) {
  return { message: "Rate limit exceeded." + (timeLeft !== null ? ` You can try again in ${timeLeft} seconds.` : "") };
}
// ... Your expensive business logic

```

--------------------------------

### Install Borrow CLI using Cargo

Source: https://github.com/borrowdev/borrow/blob/main/apps/README.md

Installs the Borrow CLI developer toolkit using the Cargo package manager. This is the initial step required to use any of the Borrow CLI commands.

```bash
cargo install borrow-dev
```

--------------------------------

### Install Borrow Node.js SDK using Package Managers

Source: https://github.com/borrowdev/borrow/blob/main/packages/javascript/node/README.md

This snippet shows how to install the Borrow Node.js SDK using various package managers like npm, pnpm, yarn, and bun. It's a prerequisite for using the SDK in your Node.js project.

```bash
# npm
npm install @borrowdev/node

# pnpm
pnpm add @borrowdev/node

# yarn
yarn add @borrowdev/node

# bun
bun add @borrowdev/node
```

--------------------------------

### Implement Custom Storage Adapter for BorrowDev

Source: https://github.com/borrowdev/borrow/blob/main/apps/docs/src/app/limiter/self-hosting/page.mdx

Extend the StorageAdapter class to create a custom database adapter for BorrowDev. This allows integration with different storage solutions beyond Upstash Redis. The adapter requires implementing methods for getting, setting, and performing relative updates on stored values, with an optional method for generating storage keys.

```TypeScript
import { StorageAdapter } from "@borrowdev/node/limiter/host";

class MyCustomAdapter extends StorageAdapter {
  private db: DbType;

  constructor(db: DbType) {
    super();
    this.db = db;
  }

  override get = (key: string) => {
    // Implement your logic to get a value using the given input. Must not throw.
  }

  override set = async (key: string, value: any) => {
    // Implement your logic to set a value using the given inputs. May throw.
  }

  override relative = async (key: string, field: string, amount: number) => {
    // Implement your logic to increment/decrement an integer using the given inputs. May throw.
  }

  // (optional)
  override getStorageKey = (
    params: {
      limiterType: LimiterType;
      userId: string | null;
      key: string | null;
    }
  ) => {
    // Implement your logic to generate a storage key using the given parameters. May throw.
  }
}
```

```JavaScript
import { StorageAdapter } from "@borrowdev/node/limiter/host";

class MyCustomAdapter extends StorageAdapter {
  constructor(db) {
    super();
    this.db = db;
  }

  get(key) {
    // Implement your logic to get a value using the given input. Must not throw.
  }

  async set(key, value) {
    // Implement your logic to set a value using the given inputs. May throw.
  }

  async relative(key, field, amount) {
    // Implement your logic to increment/decrement an integer using the given inputs. May throw.
  }

  // (optional)
  getStorageKey(params) {
    // Implement your logic to generate a storage key using the given parameters. May throw.
  }
}
```

--------------------------------

### Configure Environment Secrets (`.dev.vars`)

Source: https://github.com/borrowdev/borrow/blob/main/apps/docs/src/app/limiter/self-hosting/page.mdx

Sets up environment variables for local development, including the Borrow Limiter invoke secret and Upstash Redis credentials. This file should not be committed to version control.

```dotenv
BORROW_LIMITER_INVOKE_SECRET="random-secure-string"
UPSTASH_REDIS_REST_TOKEN="your-upstash-redis-token"
UPSTASH_REDIS_REST_URL="https://your-upstash-redis-url"
```

--------------------------------

### Call Borrow Limiter API with `curl`

Source: https://github.com/borrowdev/borrow/blob/main/apps/docs/src/app/limiter/self-hosting/page.mdx

Demonstrates how to make an HTTP POST request to the Borrow Limiter API using `curl`. This includes setting the necessary headers like `Content-Type` and `x-borrow-api-key`, and providing the request body in JSON format.

```bash
curl http://localhost:8787 \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'x-borrow-api-key: YOUR_INVOKE_SECRET' \
  --data '{ \
  "action": "check", \
  "userId": "current-user-id", \
  "key": "my-limiter-id", \
  "limiters": [ \
    { \
      "maxTokens": 20, \
      "tokensCost": 5, \
      "tokensPerReplenish": 10, \
      "interval": "minute", \
      "type": "token" \
    } \
  ]
}'

```

--------------------------------

### Configure Cloudflare Worker (`wrangler.jsonc`)

Source: https://github.com/borrowdev/borrow/blob/main/apps/docs/src/app/limiter/self-hosting/page.mdx

Configures the Cloudflare Worker using `wrangler.jsonc`. It sets the worker name, compatibility date, main entry point, and environment variables, including the Upstash Redis URL.

```json
{
  "$schema": "node_modules/wrangler/config-schema.json",
  "name": "borrow-limiter",
  "compatibility_date": "2025-04-25",
  "main": "src/index.ts",
  "vars": {
    "UPSTASH_REDIS_REST_URL": "https://your-upstash-redis-url"
  }
}
```

--------------------------------

### Implement Cloudflare Worker (`src/index.ts`)

Source: https://github.com/borrowdev/borrow/blob/main/apps/docs/src/app/limiter/self-hosting/page.mdx

The main Cloudflare Worker script that handles incoming requests. It initializes the Redis adapter, processes requests using the Borrow limiter function, and returns the rate limiting status.

```typescript
import { limiter, UpstashRedisAdapter } from "@borrowdev/node/limiter/host";
import { Redis } from "@upstash/redis/cloudflare";

export default {
  async fetch(request, env, ctx) {
    const redis = Redis.fromEnv(env);
    const adapters = { storage: new UpstashRedisAdapter(redis) };
    const req = await request.json();

    // Execute the limiter function, passing:
    // - invokeSecret from env for authentication
    // - the Redis-backed storage adapter
    // - ctx.waitUntil for background updates (or false if you want to execute synchronously)
    const response = await limiter({
      env,
      req: {
        ...req || {},
        invokeSecret: request.headers.get("X-Borrow-Api-Key") || "",
      } as any,
      adapters,
      backgroundExecute: ctx.waitUntil.bind(ctx),
      hooks: {
        beforeResponse: async (r) => console.log("Limiter result: ", r),
      },
    });

    if (response.error) {
      console.error("Limiter error: ", response.message);
    }

    // Return JSON result
    return new Response(
      JSON.stringify({
        result: response.result,
        timeLeft: response.timeLeft,
        tokensLeft: response.tokensLeft,
      }),
      {
        status: response.status,
        headers: { "Content-Type": "application/json" },
      },
    );
  },
} satisfies ExportedHandler<any>;

```

--------------------------------

### Delete Template from Cache using Borrow CLI

Source: https://github.com/borrowdev/borrow/blob/main/apps/README.md

Removes a specified template from the local cache managed by the Borrow CLI. This is useful for freeing up space or managing installed templates.

```bash
borrow start del -t <template>
```

--------------------------------

### Rate Limiting with Fixed Window Algorithm in Node.js

Source: https://context7.com/borrowdev/borrow/llms.txt

Demonstrates how to implement fixed window rate limiting using the Borrow Node.js SDK. This method limits requests within a defined time interval, resetting at the start of each interval. It requires the '@borrowdev/node' package.

```javascript
import { borrow } from "@borrowdev/node";

// Limit login endpoint to 10 requests per minute
const result = await borrow.limiter("login-endpoint", "user-123", {
  limiters: [{
    type: "fixed",
    maxRequests: 10,
    interval: "minute"
  }]
});

if (!result.success) {
  throw new Error(`Rate limited. Try again in ${result.timeLeft} seconds.`);
}

// Proceed with login logic
console.log("Login attempt allowed");
```

--------------------------------

### Supabase Edge Function Integration with Borrow in Node.js

Source: https://context7.com/borrowdev/borrow/llms.txt

Shows how to integrate Borrow's rate limiting within a Supabase Edge Function using Node.js. This example automatically identifies the user and uses the request URL for endpoint scoping, simplifying rate limiting for serverless functions.

```javascript
import { borrow } from "@borrowdev/node";

// In Supabase Edge Function
export default async function handler(req) {
  // Automatically extracts user ID and uses request URL as limiter ID
  const result = await borrow.limiter(req, {
    limiters: [{
      type: "fixed",
      maxRequests: 20,
      interval: "minute"
    }]
  });

  if (!result.success) {
    return new Response(
      JSON.stringify({ error: "Rate limit exceeded" }),
      { status: 429 }
    );
  }

  // Process request
  return new Response(JSON.stringify({ status: "ok" }));
}
```

--------------------------------

### Create New Project from Template using Borrow CLI

Source: https://github.com/borrowdev/borrow/blob/main/apps/README.md

Initializes a new project by downloading and applying a specified template from the Borrow registry or a local path. Requires a template name and an output directory for the new project.

```bash
# Download and install a template
borrow start new -t <template> -o <output_dir>
```

--------------------------------

### Combining Multiple Limiter Configurations in Node.js

Source: https://context7.com/borrowdev/borrow/llms.txt

Demonstrates how to configure multiple rate limiters simultaneously using the Borrow Node.js SDK. This allows for complex rate limiting strategies by layering different algorithms. Up to four limiters can be combined.

```javascript
import { borrow } from "@borrowdev/node";

// Protect file download with multiple limits
const result = await borrow.limiter("file-download", "user-101", {
  limiters: [
    {
      type: "fixed",
      maxRequests: 5,
      interval: "minute"
    },
    {
      type: "token",
      maxTokens: 1000,
      tokensPerReplenish: 200,
      tokensCost: 100,
      interval: "hour"
    }
  ]
});

if (!result.success) {
  console.log("Rate limit hit:", result.message);
  throw new Error(`Rate limited: ${result.timeLeft}s remaining`);
}

// All limiters passed, proceed with download
```

--------------------------------

### Implement Self-Hosted Limiter with Upstash Redis Adapter in Node.js

Source: https://context7.com/borrowdev/borrow/llms.txt

Implement a self-hosted rate limiter service using the Borrow SDK with a custom Upstash Redis storage adapter. This provides complete infrastructure control. Dependencies include '@borrowdev/node/limiter/host' and an Upstash Redis client. The code handles incoming rate limit check requests and returns a response.

```javascript
import { limiter, UpstashRedisAdapter } from "@borrowdev/node/limiter/host";

// Initialize Redis storage adapter
const storage = new UpstashRedisAdapter({
  url: process.env.UPSTASH_REDIS_URL,
  token: process.env.UPSTASH_REDIS_TOKEN
});

// Handle incoming rate limit check
async function handleRequest(req) {
  const body = await req.json();

  const result = await limiter({
    req: {
      action: "check",
      key: body.key,
      userId: body.userId,
      limiters: body.limiters
    },
    adapters: {
      storage
    },
    // Use platform-specific background execution
    backgroundExecute: (promise) => ctx.waitUntil(promise),
    hooks: {
      beforeResponse: async (response) => {
        // Log or track rate limit events
        console.log("Rate limit check:", response);
      }
    }
  });

  return new Response(JSON.stringify(result), {
    status: result.status,
    headers: { "Content-Type": "application/json" }
  });
}
```

--------------------------------

### Rate Limit Login Endpoint with Borrow Node.js SDK (JavaScript)

Source: https://github.com/borrowdev/borrow/blob/main/packages/javascript/node/README.md

This JavaScript code snippet demonstrates how to use the Borrow Node.js SDK to implement rate limiting for a login endpoint using the fixed window algorithm. It allows a maximum of 10 requests per minute per user. If the limit is exceeded, it returns a message indicating the rate limit has been hit and provides the time until the next allowed request.

```javascript
import { borrow } from "@borrowdev/node";

const { success, timeLeft } = await borrow.limiter("my-limiter-id", "current-user-id", {
	limiters: [{
		maxRequests: 10,
		interval: "minute",
		type: "fixed",
	}]
});
if (!success) {
	return { message: "Rate limit exceeded." + timeLeft !== null ? ` You can try again in ${timeLeft} seconds.` : "" };
}
```

--------------------------------

### Configure Custom Borrow Limiter with Options in Node.js

Source: https://context7.com/borrowdev/borrow/llms.txt

Configure custom Borrow limiter instances with specific limiters, self-hosted endpoints, custom API keys, and fail behaviors using the Node.js SDK. This is useful for development scenarios and self-hosted deployments. Dependencies include the '@borrowdev/node' package.

```javascript
import { borrow } from "@borrowdev/node";

const result = await borrow.limiter("custom-endpoint", "user-999", {
  limiters: [{
    type: "fixed",
    maxRequests: 50,
    interval: 3600 // Custom interval in seconds
  }],
  options: {
    // Self-hosted endpoint
    endpoint: {
      baseUrl: "https://my-limiter.example.com/v1",
      path: "/limiter"
    },
    // Custom API key
    apiKey: "my-custom-key",
    // Fail on errors instead of bypassing (default: "bypass")
    failBehavior: "fail",
    // Enable debug logging
    debug: true
  }
});
```

--------------------------------

### Refill Tokens for Users and Limiters with Borrow Node.js SDK

Source: https://context7.com/borrowdev/borrow/llms.txt

Manually refill tokens for specific users and limiters using the Borrow Node.js SDK. This is useful for premium features or administrative actions. It supports refilling for individual users/limiters, globally, or for multiple keys simultaneously. Dependencies include the '@borrowdev/node' package.

```javascript
import { borrow } from "@borrowdev/node";

// Refill tokens for a specific user and limiter
const result = await borrow.limiter.tokens.refill(
  { key: "api-endpoint", userId: "user-premium-001" },
  {
    apiKey: process.env.BORROW_API_KEY,
    debug: true
  }
);

if (result.success) {
  console.log("Tokens refilled successfully");
}

// Refill tokens globally for all users
await borrow.limiter.tokens.refill(true);

// Refill for multiple keys at once
await borrow.limiter.tokens.refill([
  { key: "limiter-1", userId: "user-123" },
  { key: "limiter-2", userId: "user-456" }
]);
```

--------------------------------

### Rate Limiting with Sliding Window Algorithm in Node.js

Source: https://context7.com/borrowdev/borrow/llms.txt

Shows how to apply sliding window rate limiting with the Borrow Node.js SDK. This algorithm provides a fairer distribution by allowing the time window to slide with each request. It's suitable for scenarios requiring consistent request throughput.

```javascript
import { borrow } from "@borrowdev/node";

// Limit API calls to 100 requests per hour using sliding window
const result = await borrow.limiter("api-endpoint", "user-456", {
  limiters: [{
    type: "sliding",
    maxRequests: 100,
    interval: "hour"
  }]
});

if (!result.success) {
  return {
    status: 429,
    body: {
      error: "Too many requests",
      retryAfter: result.timeLeft
    }
  };
}

// Process API request
```

--------------------------------

### Rate Limiting with Token Bucket Algorithm in Node.js

Source: https://context7.com/borrowdev/borrow/llms.txt

Illustrates the implementation of token bucket rate limiting using the Borrow Node.js SDK. This approach uses a bucket of tokens that replenish over time, allowing for flexible request costs and dynamic throttling. Useful for APIs with variable resource consumption.

```javascript
import { borrow } from "@borrowdev/node";

// Token bucket for AI API: 1000 tokens max, refill 100 every minute
// This request costs 50 tokens
const result = await borrow.limiter("ai-api", "user-789", {
  limiters: [{
    type: "token",
    maxTokens: 1000,
    tokensPerReplenish: 100,
    tokensCost: 50,
    interval: "minute"
  }]
});

if (!result.success) {
  return {
    error: "Insufficient tokens",
    tokensLeft: result.tokensLeft,
    timeLeft: result.timeLeft
  };
}

console.log(`Request allowed. Tokens remaining: ${result.tokensLeft}`);
```

--------------------------------

### Rate Limit Request with Supabase - TypeScript

Source: https://github.com/borrowdev/borrow/blob/main/apps/docs/src/app/limiter/integrations/supabase/page.mdx

Demonstrates how to use the borrow.limiter function with a Supabase request object in TypeScript. It sets up rate limiting rules and returns success status and time left. This simplifies endpoint protection.

```typescript
import { borrow } from "@borrowdev/node";
// ... Your Supabase Edge Function handler

const { success, timeLeft } = await borrow.limiter(req, {
	limiters: [{
		interval: 20,
		maxRequests: 10,
		type: "fixed",
	}]
});

// ... Your expensive business logic
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.