@upstash/ratelimit 0.1.5 → 0.2.0-rc.0

package/README.md

@@ -6,9 +6,10 @@
 It is the only connectionless (HTTP based) rate limiting library and designed
 for:
 
-- Serverless functions (AWS Lambda ...)
+- Serverless functions (AWS Lambda, Vercel ...)
 - Cloudflare Workers
-- Fastly Compute@Edge (see
+- Vercel Edge
+- Fastly Compute@Edge
 - Next.js, Jamstack ...
 - Client side web/mobile applications
 - WebAssembly
@@ -25,7 +26,7 @@ for:
   - [Use it](#use-it)
   - [Block until ready](#block-until-ready)
   - [Ephemeral Cache](#ephemeral-cache)
-- [MultiRegion replicated ratelimiting](#multiregion-replicated-ratelimiting)
+  - [MultiRegion replicated ratelimiting](#multiregion-replicated-ratelimiting)
   - [Usage](#usage)
   - [Asynchronous synchronization between databases](#asynchronous-synchronization-between-databases)
   - [Example](#example)
@@ -243,7 +244,7 @@ const ratelimit = new MultiRegionRatelimit({
       /* auth */
     }),
   ],
-  limiter: Ratelimit.slidingWindow(10, "10 s"),
+  limiter: MultiRegionRatelimit.slidingWindow(10, "10 s"),
 });
 
 // Use a constant string to limit all requests with a single ratelimit

package/esm/_dnt.shims.js

@@ -0,0 +1,62 @@
+import { crypto } from "@deno/shim-crypto";
+export { crypto } from "@deno/shim-crypto";
+const dntGlobals = {
+    crypto,
+};
+export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+// deno-lint-ignore ban-types
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/esm/cache.js

@@ -25,4 +25,16 @@ export class Cache {
     blockUntil(identifier, reset) {
         this.cache.set(identifier, reset);
     }
+    set(key, value) {
+        this.cache.set(key, value);
+    }
+    get(key) {
+        return this.cache.get(key) || null;
+    }
+    incr(key) {
+        let value = this.cache.get(key) ?? 0;
+        value += 1;
+        this.cache.set(key, value);
+        return value;
+    }
 }

package/esm/multi.js

@@ -1,3 +1,4 @@
+import * as dntShim from "./_dnt.shims.js";
 import { ms } from "./duration.js";
 import { Ratelimit } from "./ratelimit.js";
 import { Cache } from "./cache.js";
@@ -24,6 +25,7 @@ export class MultiRegionRatelimit extends Ratelimit {
         super({
             prefix: config.prefix,
             limiter: config.limiter,
+            timeout: config.timeout,
             ctx: {
                 redis: config.redis,
                 cache: config.ephemeralCache
@@ -88,7 +90,7 @@ export class MultiRegionRatelimit extends Ratelimit {
                     };
                 }
             }
-            const requestID = crypto.randomUUID();
+            const requestID = dntShim.crypto.randomUUID();
             const bucket = Math.floor(Date.now() / windowDuration);
             const key = [identifier, bucket].join(":");
             const dbs = ctx.redis.map((redis) => ({
@@ -208,7 +210,7 @@ export class MultiRegionRatelimit extends Ratelimit {
                     };
                 }
             }
-            const requestID = crypto.randomUUID();
+            const requestID = dntShim.crypto.randomUUID();
             const now = Date.now();
             const currentWindow = Math.floor(now / windowSize);
             const currentKey = [identifier, currentWindow].join(":");

package/esm/ratelimit.js

@@ -1,4 +1,10 @@
 import { Cache } from "./cache.js";
+export class TimeoutError extends Error {
+    constructor() {
+        super("Timeout");
+        this.name = "TimeoutError";
+    }
+}
 /**
  * Ratelimiter using serverless redis from https://upstash.com/
  *
@@ -9,7 +15,7 @@ import { Cache } from "./cache.js";
  *    limiter: Ratelimit.slidingWindow(
  *      10,     // Allow 10 requests per window of 30 minutes
  *      "30 m", // interval of 30 minutes
- *    )
+ *    ),
  * })
  *
  * ```
@@ -34,6 +40,12 @@ export class Ratelimit {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "timeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         /**
          * Determine if a request should pass or be rejected based on the identifier and previously chosen ratelimit.
          *
@@ -59,7 +71,29 @@ export class Ratelimit {
             writable: true,
             value: async (identifier) => {
                 const key = [this.prefix, identifier].join(":");
-                return await this.limiter(this.ctx, key);
+                let timeoutId = null;
+                try {
+                    const arr = [this.limiter(this.ctx, key)];
+                    if (this.timeout) {
+                        arr.push(new Promise((resolve) => {
+                            timeoutId = setTimeout(() => {
+                                resolve({
+                                    success: true,
+                                    limit: 0,
+                                    remaining: 0,
+                                    reset: 0,
+                                    pending: Promise.resolve(),
+                                });
+                            }, this.timeout);
+                        }));
+                    }
+                    return await Promise.race(arr);
+                }
+                finally {
+                    if (timeoutId) {
+                        clearTimeout(timeoutId);
+                    }
+                }
             }
         });
         /**
@@ -125,6 +159,7 @@ export class Ratelimit {
         });
         this.ctx = config.ctx;
         this.limiter = config.limiter;
+        this.timeout = config.timeout;
         this.prefix = config.prefix ?? "@upstash/ratelimit";
         if (config.ephemeralCache instanceof Map) {
             this.ctx.cache = new Cache(config.ephemeralCache);

package/esm/single.js

@@ -23,6 +23,7 @@ export class RegionRatelimit extends Ratelimit {
         super({
             prefix: config.prefix,
             limiter: config.limiter,
+            timeout: config.timeout,
             ctx: {
                 redis: config.redis,
             },
@@ -288,4 +289,87 @@ export class RegionRatelimit extends Ratelimit {
             };
         };
     }
+    /**
+     * cachedFixedWindow first uses the local cache to decide if a request may pass and then updates
+     * it asynchronously.
+     * This is experimental and not yet recommended for production use.
+     *
+     * @experimental
+     *
+     * Each requests inside a fixed time increases a counter.
+     * Once the counter reaches a maxmimum allowed number, all further requests are
+     * rejected.
+     *
+     * **Pro:**
+     *
+     * - Newer requests are not starved by old ones.
+     * - Low storage cost.
+     *
+     * **Con:**
+     *
+     * A burst of requests near the boundary of a window can result in a very
+     * high request rate because two windows will be filled with requests quickly.
+     *
+     * @param tokens - How many requests a user can make in each time window.
+     * @param window - A fixed timeframe
+     */
+    static cachedFixedWindow(
+    /**
+     * How many requests are allowed per window.
+     */
+    tokens, 
+    /**
+     * The duration in which `tokens` requests are allowed.
+     */
+    window) {
+        const windowDuration = ms(window);
+        const script = `
+      local key     = KEYS[1]
+      local window  = ARGV[1]
+      
+      local r = redis.call("INCR", key)
+      if r == 1 then 
+      -- The first time this key is set, the value will be 1.
+      -- So we only need the expire command once
+      redis.call("PEXPIRE", key, window)
+      end
+      
+      return r
+      `;
+        return async function (ctx, identifier) {
+            if (!ctx.cache) {
+                throw new Error("This algorithm requires a cache");
+            }
+            const bucket = Math.floor(Date.now() / windowDuration);
+            const key = [identifier, bucket].join(":");
+            const reset = (bucket + 1) * windowDuration;
+            const hit = typeof ctx.cache.get(key) === "number";
+            if (hit) {
+                const cachedTokensAfterUpdate = ctx.cache.incr(key);
+                const success = cachedTokensAfterUpdate < tokens;
+                const pending = success
+                    ? ctx.redis.eval(script, [key], [windowDuration]).then((t) => {
+                        ctx.cache.set(key, t);
+                    })
+                    : Promise.resolve();
+                return {
+                    success,
+                    limit: tokens,
+                    remaining: tokens - cachedTokensAfterUpdate,
+                    reset: reset,
+                    pending,
+                };
+            }
+            const usedTokensAfterUpdate = (await ctx.redis.eval(script, [key], [windowDuration]));
+            ctx.cache.set(key, usedTokensAfterUpdate);
+            const remaining = tokens - usedTokensAfterUpdate;
+            return {
+                success: remaining >= 0,
+                limit: tokens,
+                remaining,
+                reset: reset,
+                pending: Promise.resolve(),
+            };
+        };
+    }
 }

package/package.json

@@ -3,7 +3,7 @@
   "main": "./script/mod.js",
   "types": "./types/mod.d.ts",
   "name": "@upstash/ratelimit",
-  "version": "v0.1.5",
+  "version": "v0.2.0-rc.0",
   "description": "A serverless ratelimiter built on top of Upstash REST API.",
   "repository": {
     "type": "git",
@@ -43,9 +43,17 @@
   ],
   "exports": {
     ".": {
-      "import": "./esm/mod.js",
-      "require": "./script/mod.js",
-      "types": "./types/mod.d.ts"
+      "import": {
+        "types": "./types/mod.d.ts",
+        "default": "./esm/mod.js"
+      },
+      "require": {
+        "types": "./types/mod.d.ts",
+        "default": "./script/mod.js"
+      }
     }
+  },
+  "dependencies": {
+    "@deno/shim-crypto": "~0.3.1"
   }
 }

package/script/_dnt.shims.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dntGlobalThis = exports.crypto = void 0;
+const shim_crypto_1 = require("@deno/shim-crypto");
+var shim_crypto_2 = require("@deno/shim-crypto");
+Object.defineProperty(exports, "crypto", { enumerable: true, get: function () { return shim_crypto_2.crypto; } });
+const dntGlobals = {
+    crypto: shim_crypto_1.crypto,
+};
+exports.dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+// deno-lint-ignore ban-types
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/script/cache.js

@@ -28,5 +28,17 @@ class Cache {
     blockUntil(identifier, reset) {
         this.cache.set(identifier, reset);
     }
+    set(key, value) {
+        this.cache.set(key, value);
+    }
+    get(key) {
+        return this.cache.get(key) || null;
+    }
+    incr(key) {
+        let value = this.cache.get(key) ?? 0;
+        value += 1;
+        this.cache.set(key, value);
+        return value;
+    }
 }
 exports.Cache = Cache;

package/script/multi.js

@@ -1,6 +1,30 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MultiRegionRatelimit = void 0;
+const dntShim = __importStar(require("./_dnt.shims.js"));
 const duration_js_1 = require("./duration.js");
 const ratelimit_js_1 = require("./ratelimit.js");
 const cache_js_1 = require("./cache.js");
@@ -27,6 +51,7 @@ class MultiRegionRatelimit extends ratelimit_js_1.Ratelimit {
         super({
             prefix: config.prefix,
             limiter: config.limiter,
+            timeout: config.timeout,
             ctx: {
                 redis: config.redis,
                 cache: config.ephemeralCache
@@ -91,7 +116,7 @@ class MultiRegionRatelimit extends ratelimit_js_1.Ratelimit {
                     };
                 }
             }
-            const requestID = crypto.randomUUID();
+            const requestID = dntShim.crypto.randomUUID();
             const bucket = Math.floor(Date.now() / windowDuration);
             const key = [identifier, bucket].join(":");
             const dbs = ctx.redis.map((redis) => ({
@@ -211,7 +236,7 @@ class MultiRegionRatelimit extends ratelimit_js_1.Ratelimit {
                     };
                 }
             }
-            const requestID = crypto.randomUUID();
+            const requestID = dntShim.crypto.randomUUID();
             const now = Date.now();
             const currentWindow = Math.floor(now / windowSize);
             const currentKey = [identifier, currentWindow].join(":");

package/script/ratelimit.js

@@ -1,7 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Ratelimit = void 0;
+exports.Ratelimit = exports.TimeoutError = void 0;
 const cache_js_1 = require("./cache.js");
+class TimeoutError extends Error {
+    constructor() {
+        super("Timeout");
+        this.name = "TimeoutError";
+    }
+}
+exports.TimeoutError = TimeoutError;
 /**
  * Ratelimiter using serverless redis from https://upstash.com/
  *
@@ -12,7 +19,7 @@ const cache_js_1 = require("./cache.js");
  *    limiter: Ratelimit.slidingWindow(
  *      10,     // Allow 10 requests per window of 30 minutes
  *      "30 m", // interval of 30 minutes
- *    )
+ *    ),
  * })
  *
  * ```
@@ -37,6 +44,12 @@ class Ratelimit {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "timeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         /**
          * Determine if a request should pass or be rejected based on the identifier and previously chosen ratelimit.
          *
@@ -62,7 +75,29 @@ class Ratelimit {
             writable: true,
             value: async (identifier) => {
                 const key = [this.prefix, identifier].join(":");
-                return await this.limiter(this.ctx, key);
+                let timeoutId = null;
+                try {
+                    const arr = [this.limiter(this.ctx, key)];
+                    if (this.timeout) {
+                        arr.push(new Promise((resolve) => {
+                            timeoutId = setTimeout(() => {
+                                resolve({
+                                    success: true,
+                                    limit: 0,
+                                    remaining: 0,
+                                    reset: 0,
+                                    pending: Promise.resolve(),
+                                });
+                            }, this.timeout);
+                        }));
+                    }
+                    return await Promise.race(arr);
+                }
+                finally {
+                    if (timeoutId) {
+                        clearTimeout(timeoutId);
+                    }
+                }
             }
         });
         /**
@@ -128,6 +163,7 @@ class Ratelimit {
         });
         this.ctx = config.ctx;
         this.limiter = config.limiter;
+        this.timeout = config.timeout;
         this.prefix = config.prefix ?? "@upstash/ratelimit";
         if (config.ephemeralCache instanceof Map) {
             this.ctx.cache = new cache_js_1.Cache(config.ephemeralCache);

package/script/single.js

@@ -26,6 +26,7 @@ class RegionRatelimit extends ratelimit_js_1.Ratelimit {
         super({
             prefix: config.prefix,
             limiter: config.limiter,
+            timeout: config.timeout,
             ctx: {
                 redis: config.redis,
             },
@@ -291,5 +292,88 @@ class RegionRatelimit extends ratelimit_js_1.Ratelimit {
             };
         };
     }
+    /**
+     * cachedFixedWindow first uses the local cache to decide if a request may pass and then updates
+     * it asynchronously.
+     * This is experimental and not yet recommended for production use.
+     *
+     * @experimental
+     *
+     * Each requests inside a fixed time increases a counter.
+     * Once the counter reaches a maxmimum allowed number, all further requests are
+     * rejected.
+     *
+     * **Pro:**
+     *
+     * - Newer requests are not starved by old ones.
+     * - Low storage cost.
+     *
+     * **Con:**
+     *
+     * A burst of requests near the boundary of a window can result in a very
+     * high request rate because two windows will be filled with requests quickly.
+     *
+     * @param tokens - How many requests a user can make in each time window.
+     * @param window - A fixed timeframe
+     */
+    static cachedFixedWindow(
+    /**
+     * How many requests are allowed per window.
+     */
+    tokens, 
+    /**
+     * The duration in which `tokens` requests are allowed.
+     */
+    window) {
+        const windowDuration = (0, duration_js_1.ms)(window);
+        const script = `
+      local key     = KEYS[1]
+      local window  = ARGV[1]
+      
+      local r = redis.call("INCR", key)
+      if r == 1 then 
+      -- The first time this key is set, the value will be 1.
+      -- So we only need the expire command once
+      redis.call("PEXPIRE", key, window)
+      end
+      
+      return r
+      `;
+        return async function (ctx, identifier) {
+            if (!ctx.cache) {
+                throw new Error("This algorithm requires a cache");
+            }
+            const bucket = Math.floor(Date.now() / windowDuration);
+            const key = [identifier, bucket].join(":");
+            const reset = (bucket + 1) * windowDuration;
+            const hit = typeof ctx.cache.get(key) === "number";
+            if (hit) {
+                const cachedTokensAfterUpdate = ctx.cache.incr(key);
+                const success = cachedTokensAfterUpdate < tokens;
+                const pending = success
+                    ? ctx.redis.eval(script, [key], [windowDuration]).then((t) => {
+                        ctx.cache.set(key, t);
+                    })
+                    : Promise.resolve();
+                return {
+                    success,
+                    limit: tokens,
+                    remaining: tokens - cachedTokensAfterUpdate,
+                    reset: reset,
+                    pending,
+                };
+            }
+            const usedTokensAfterUpdate = (await ctx.redis.eval(script, [key], [windowDuration]));
+            ctx.cache.set(key, usedTokensAfterUpdate);
+            const remaining = tokens - usedTokensAfterUpdate;
+            return {
+                success: remaining >= 0,
+                limit: tokens,
+                remaining,
+                reset: reset,
+                pending: Promise.resolve(),
+            };
+        };
+    }
 }
 exports.RegionRatelimit = RegionRatelimit;

package/types/_dnt.shims.d.ts

@@ -0,0 +1,5 @@
+export { crypto, type Crypto, type SubtleCrypto, type AlgorithmIdentifier, type Algorithm, type RsaOaepParams, type BufferSource, type AesCtrParams, type AesCbcParams, type AesGcmParams, type CryptoKey, type KeyAlgorithm, type KeyType, type KeyUsage, type EcdhKeyDeriveParams, type HkdfParams, type HashAlgorithmIdentifier, type Pbkdf2Params, type AesDerivedKeyParams, type HmacImportParams, type JsonWebKey, type RsaOtherPrimesInfo, type KeyFormat, type RsaHashedKeyGenParams, type RsaKeyGenParams, type BigInteger, type EcKeyGenParams, type NamedCurve, type CryptoKeyPair, type AesKeyGenParams, type HmacKeyGenParams, type RsaHashedImportParams, type EcKeyImportParams, type AesKeyAlgorithm, type RsaPssParams, type EcdsaParams } from "@deno/shim-crypto";
+export {} from "@types/node";
+export declare const dntGlobalThis: Omit<typeof globalThis, "crypto"> & {
+    crypto: import("@deno/shim-crypto").Crypto;
+};

package/types/cache.d.ts

@@ -10,4 +10,7 @@ export declare class Cache implements EphemeralCache {
         reset: number;
     };
     blockUntil(identifier: string, reset: number): void;
+    set(key: string, value: number): void;
+    get(key: string): number | null;
+    incr(key: string): number;
 }

package/types/duration.d.ts

@@ -1,5 +1,5 @@
-declare type Unit = "ms" | "s" | "m" | "h" | "d";
-export declare type Duration = `${number} ${Unit}`;
+type Unit = "ms" | "s" | "m" | "h" | "d";
+export type Duration = `${number} ${Unit}`;
 /**
  * Convert a human readable duration to milliseconds
  */

package/types/multi.d.ts

@@ -2,7 +2,7 @@ import type { Duration } from "./duration.js";
 import type { Algorithm, MultiRegionContext } from "./types.js";
 import { Ratelimit } from "./ratelimit.js";
 import type { Redis } from "./types.js";
-export declare type MultiRegionRatelimitConfig = {
+export type MultiRegionRatelimitConfig = {
     /**
      * Instances of `@upstash/redis`
      * @see https://github.com/upstash/upstash-redis#quick-start
@@ -39,6 +39,12 @@ export declare type MultiRegionRatelimitConfig = {
      * if the map or th ratelimit instance is created outside your serverless function handler.
      */
     ephemeralCache?: Map<string, number> | false;
+    /**
+     * If set, the ratelimiter will allow requests to pass after this many milliseconds.
+     *
+     * Use this if you want to allow requests in case of network problems
+     */
+    timeout?: number;
 };
 /**
  * Ratelimiter using serverless redis from https://upstash.com/

package/types/ratelimit.d.ts

@@ -1,5 +1,8 @@
 import type { Algorithm, Context, RatelimitResponse } from "./types.js";
-export declare type RatelimitConfig<TContext> = {
+export declare class TimeoutError extends Error {
+    constructor();
+}
+export type RatelimitConfig<TContext> = {
     /**
      * The ratelimiter function to use.
      *
@@ -35,6 +38,12 @@ export declare type RatelimitConfig<TContext> = {
      * if the map or the  ratelimit instance is created outside your serverless function handler.
      */
     ephemeralCache?: Map<string, number> | false;
+    /**
+     * If set, the ratelimiter will allow requests to pass after this many milliseconds.
+     *
+     * Use this if you want to allow requests in case of network problems
+     */
+    timeout?: number;
 };
 /**
  * Ratelimiter using serverless redis from https://upstash.com/
@@ -46,7 +55,7 @@ export declare type RatelimitConfig<TContext> = {
  *    limiter: Ratelimit.slidingWindow(
  *      10,     // Allow 10 requests per window of 30 minutes
  *      "30 m", // interval of 30 minutes
- *    )
+ *    ),
  * })
  *
  * ```
@@ -55,6 +64,7 @@ export declare abstract class Ratelimit<TContext extends Context> {
     protected readonly limiter: Algorithm<TContext>;
     protected readonly ctx: TContext;
     protected readonly prefix: string;
+    protected readonly timeout?: number;
     constructor(config: RatelimitConfig<TContext>);
     /**
      * Determine if a request should pass or be rejected based on the identifier and previously chosen ratelimit.

package/types/single.d.ts

@@ -2,7 +2,7 @@ import type { Duration } from "./duration.js";
 import type { Algorithm, RegionContext } from "./types.js";
 import type { Redis } from "./types.js";
 import { Ratelimit } from "./ratelimit.js";
-export declare type RegionRatelimitConfig = {
+export type RegionRatelimitConfig = {
     /**
      * Instance of `@upstash/redis`
      * @see https://github.com/upstash/upstash-redis#quick-start
@@ -42,6 +42,12 @@ export declare type RegionRatelimitConfig = {
      * if the map or the ratelimit instance is created outside your serverless function handler.
      */
     ephemeralCache?: Map<string, number> | false;
+    /**
+     * If set, the ratelimiter will allow requests to pass after this many milliseconds.
+     *
+     * Use this if you want to allow requests in case of network problems
+     */
+    timeout?: number;
 };
 /**
  * Ratelimiter using serverless redis from https://upstash.com/
@@ -145,4 +151,37 @@ export declare class RegionRatelimit extends Ratelimit<RegionContext> {
      * Useful to allow higher burst limits.
      */
     maxTokens: number): Algorithm<RegionContext>;
+    /**
+     * cachedFixedWindow first uses the local cache to decide if a request may pass and then updates
+     * it asynchronously.
+     * This is experimental and not yet recommended for production use.
+     *
+     * @experimental
+     *
+     * Each requests inside a fixed time increases a counter.
+     * Once the counter reaches a maxmimum allowed number, all further requests are
+     * rejected.
+     *
+     * **Pro:**
+     *
+     * - Newer requests are not starved by old ones.
+     * - Low storage cost.
+     *
+     * **Con:**
+     *
+     * A burst of requests near the boundary of a window can result in a very
+     * high request rate because two windows will be filled with requests quickly.
+     *
+     * @param tokens - How many requests a user can make in each time window.
+     * @param window - A fixed timeframe
+     */
+    static cachedFixedWindow(
+    /**
+     * How many requests are allowed per window.
+     */
+    tokens: number, 
+    /**
+     * The duration in which `tokens` requests are allowed.
+     */
+    window: Duration): Algorithm<RegionContext>;
 }

package/types/types.d.ts

@@ -11,17 +11,20 @@ export interface EphemeralCache {
         reset: number;
     };
     blockUntil: (identifier: string, reset: number) => void;
+    set: (key: string, value: number) => void;
+    get: (key: string) => number | null;
+    incr: (key: string) => number;
 }
-export declare type RegionContext = {
+export type RegionContext = {
     redis: Redis;
     cache?: EphemeralCache;
 };
-export declare type MultiRegionContext = {
+export type MultiRegionContext = {
     redis: Redis[];
     cache?: EphemeralCache;
 };
-export declare type Context = RegionContext | MultiRegionContext;
-export declare type RatelimitResponse = {
+export type Context = RegionContext | MultiRegionContext;
+export type RatelimitResponse = {
     /**
      * Whether the request may pass(true) or exceeded the limit(false)
      */
@@ -62,6 +65,6 @@ export declare type RatelimitResponse = {
      */
     pending: Promise<unknown>;
 };
-export declare type Algorithm<TContext> = (ctx: TContext, identifier: string, opts?: {
+export type Algorithm<TContext> = (ctx: TContext, identifier: string, opts?: {
     cache?: EphemeralCache;
 }) => Promise<RatelimitResponse>;