limitly 1.0.2 → 2.0.0

package/README.md

@@ -1,6 +1,6 @@
 # limitly
 
-Distributed, Redis-powered rate limiting for Express and Fastify.
+Distributed, Redis-powered rate limiting for Express, Fastify, Hono, Koa, Bun, and NestJS.
 
 > Express-rate-limit, but distributed, Redis-powered, and production ready.
 
@@ -8,6 +8,22 @@ Distributed, Redis-powered rate limiting for Express and Fastify.
 
 ```bash
 npm install limitly ioredis
+
+# Memcached backend
+npm install limitly memcached
+
+# NestJS
+npm install limitly ioredis @nestjs/common @nestjs/core
+```
+
+Framework-specific subpath imports are available for tree-shaking:
+
+```typescript
+import { createExpressMiddleware } from "limitly/express";
+import { createFastifyPlugin } from "limitly/fastify";
+import { createHonoMiddleware } from "limitly/hono";
+import { createKoaMiddleware } from "limitly/koa";
+import { createBunMiddleware } from "limitly/bun";
 ```
 
 ## Quick Start
@@ -51,11 +67,185 @@ await fastify.register(limiter.fastifyPlugin, {
 });
 ```
 
+### Hono
+
+```typescript
+import { Hono } from "hono";
+import Redis from "ioredis";
+import { createLimiter } from "limitly";
+
+const app = new Hono();
+const limiter = createLimiter({ redis: new Redis() });
+
+app.use(
+  "*",
+  limiter.honoMiddleware({
+    algorithm: "sliding-window",
+    limit: 100,
+    window: 60,
+    key: (c) => c.req.header("x-api-key"),
+  })
+);
+```
+
+### Koa
+
+```typescript
+import Koa from "koa";
+import Redis from "ioredis";
+import { createLimiter } from "limitly";
+
+const app = new Koa();
+const limiter = createLimiter({ redis: new Redis() });
+
+app.use(
+  limiter.koaMiddleware({
+    algorithm: "sliding-window",
+    limit: 100,
+    window: 60,
+    key: (ctx) => ctx.ip,
+  })
+);
+```
+
+### Bun
+
+```typescript
+import Redis from "ioredis";
+import { composeBunHandler, createLimiter } from "limitly";
+
+const limiter = createLimiter({ redis: new Redis() });
+
+const rateLimit = limiter.bunMiddleware({
+  algorithm: "sliding-window",
+  limit: 100,
+  window: 60,
+  key: (req) => req.headers.get("x-api-key"),
+});
+
+const fetch = composeBunHandler(
+  [rateLimit],
+  () => Response.json({ message: "Hello Bun!" })
+);
+
+Bun.serve({ port: 3000, fetch });
+```
+
+### NestJS
+
+```typescript
+import { Module } from "@nestjs/common";
+import { APP_GUARD } from "@nestjs/core";
+import Redis from "ioredis";
+import { createLimiter } from "limitly";
+import { RateLimit } from "limitly/nest";
+
+const limiter = createLimiter({ redis: new Redis() });
+const NestGuard = limiter.nestGuard({
+  algorithm: "sliding-window",
+  limit: 100,
+  window: 60,
+  key: (req) => req.ip,
+});
+
+@Module({
+  providers: [{ provide: APP_GUARD, useClass: NestGuard }],
+})
+export class AppModule {}
+```
+
+Per-route limits with `@RateLimit()`:
+
+```typescript
+import { Controller, Get } from "@nestjs/common";
+import { RateLimit } from "limitly/nest";
+
+@Controller("api")
+export class ApiController {
+  @Get()
+  @RateLimit({ algorithm: "sliding-window", limit: 10, window: 60 })
+  findAll() {
+    return { ok: true };
+  }
+}
+```
+
+Module helper (like `redisLimitPlugin` for Fastify):
+
+```typescript
+import { limitlyNestModule } from "limitly/nest";
+
+@Module({
+  imports: [
+    limitlyNestModule({
+      limiter,
+      algorithm: "token-bucket",
+      capacity: 50,
+      refillRate: 10,
+      global: true,
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+## Default Algorithm
+
+If you omit algorithm options, limitly uses **sliding-window** with `limit: 100` and `window: 60`:
+
+```typescript
+const limiter = createLimiter({ redis: new Redis() });
+
+app.use(limiter.middleware({ key: (req) => req.ip }));
+
+// equivalent to:
+app.use(
+  limiter.middleware({
+    algorithm: "sliding-window",
+    limit: 100,
+    window: 60,
+    key: (req) => req.ip,
+  })
+);
+```
+
+Set limiter-wide defaults:
+
+```typescript
+const limiter = createLimiter({
+  redis: new Redis(),
+  default: { limit: 50, window: 30 },
+});
+
+app.use(limiter.middleware({ key: (req) => req.ip }));
+```
+
+## Programmatic Checks
+
+Use `limiter.check()` outside middleware — useful for login guards, background jobs, or custom response handling:
+
+```typescript
+const result = await limiter.check(req.ip ?? "unknown", {
+  algorithm: "sliding-window",
+  limit: 5,
+  window: 10,
+});
+
+if (!result.allowed) {
+  return res.status(429).json({
+    error: "Too many attempts",
+    retryAfter: result.retryAfter,
+  });
+}
+```
+
+`check()` respects limiter-wide defaults, `failOpen`, and global `onMetrics` hooks.
+
 ## Algorithms
 
 ### Sliding Window
 
-Uses Redis Sorted Sets for precise rate limiting over a rolling time window.
+Uses Redis Sorted Sets (or Memcached counters) for rate limiting over a rolling time window.
 
 ```typescript
 limiter.middleware({
@@ -77,30 +267,56 @@ limiter.middleware({
 });
 ```
 
-## Redis Connection
+## Storage Backends
+
+limitly supports Redis, Valkey, DragonflyDB (Redis-compatible), and Memcached.
+
+### Redis / Valkey / DragonflyDB
 
-Supports multiple connection modes:
+Redis-compatible backends use atomic Lua scripts (sorted sets + hashes). Connect with `ioredis`:
 
 ```typescript
-// Existing Redis instance
+import Redis from "ioredis";
+
+// Redis
 createLimiter({ redis: new Redis() });
 
-// Connection URL
-createLimiter({ redis: "redis://localhost:6379" });
+// Valkey
+createLimiter({ store: "valkey", redis: "redis://localhost:6379" });
 
-// Options object
-createLimiter({ redis: { host: "localhost", port: 6379 } });
+// DragonflyDB
+createLimiter({ store: "dragonfly", redis: { host: "localhost", port: 6379 } });
 
 // Cluster
 createLimiter({
-  redis: {
-    nodes: [{ host: "127.0.0.1", port: 7000 }],
-  },
+  store: "redis",
+  redis: { nodes: [{ host: "127.0.0.1", port: 7000 }] },
+});
+```
+
+### Memcached
+
+Memcached uses counter-based sliding window and CAS token bucket (no Lua required):
+
+```typescript
+import Memcached from "memcached";
+
+createLimiter({
+  store: "memcached",
+  memcached: "localhost:11211",
 });
+
+// Or pass an existing client
+createLimiter({ memcached: new Memcached(["localhost:11211"]) });
 ```
 
+> Memcached sliding window uses a weighted two-window counter (high accuracy, no sorted sets).
+> Token bucket uses `gets`/`cas` for atomic updates.
+
 ## Key Extraction
 
+The `key` option identifies **who** is being rate limited (per request):
+
 ```typescript
 // IP-based
 key: (req) => req.ip;
@@ -112,6 +328,29 @@ key: (req) => req.headers["x-api-key"];
 key: (req) => req.user.id;
 ```
 
+## Storage Key Prefix
+
+The `keyPrefix` option controls **where** counters are stored in Redis/Memcached.
+Default is `limitly`:
+
+```typescript
+createLimiter({ redis: new Redis() });
+// stores keys like: limitly:sw:203.0.113.1
+
+createLimiter({
+  redis: new Redis(),
+  keyPrefix: "myapp:prod",
+});
+// stores keys like: myapp:prod:sw:203.0.113.1
+```
+
+Key format:
+
+```
+{keyPrefix}:sw:{id}   — sliding window
+{keyPrefix}:tb:{id}   — token bucket
+```
+
 ## Response Headers
 
 Standard rate limit headers are set by default:
@@ -138,6 +377,46 @@ limiter.middleware({
 });
 ```
 
+## Metrics
+
+Emit observability events via the `onMetrics` hook. Set it globally on the limiter or per middleware/route:
+
+```typescript
+const limiter = createLimiter({
+  redis: new Redis(),
+  onMetrics: (event) => {
+    console.log(event.type, event.key, `${event.durationMs.toFixed(2)}ms`);
+  },
+});
+
+// Per-route override
+limiter.middleware({
+  algorithm: "sliding-window",
+  limit: 100,
+  window: 60,
+  onMetrics: (event) => metrics.increment(`ratelimit.${event.type}`),
+});
+```
+
+Event types:
+
+| Type | When |
+|------|------|
+| `allowed` | Request passed the rate limit check |
+| `blocked` | Request exceeded the limit |
+| `error` | Store operation failed |
+| `fail_open` | Store failed but `failOpen: true` allowed traffic through |
+
+Each event includes `key`, `algorithm`, `durationMs`, and optionally `store`, `context` (the request object), and `result` or `error` depending on type.
+
+Multiple hooks are supported:
+
+```typescript
+onMetrics: [logToConsole, sendToDatadog]
+```
+
+`limiter.check()` and all framework middleware use the same metrics pipeline.
+
 ## Fail Open / Closed
 
 When Redis is unavailable:

package/dist/algorithms/factory.d.ts

@@ -1,3 +1,4 @@
-import type { AlgorithmConfig, RateLimitStrategy, RedisClient } from "../types";
-export declare function createStrategy(redis: RedisClient, config: AlgorithmConfig, keyPrefix?: string): RateLimitStrategy;
+import type { AlgorithmConfig, RateLimitStrategy } from "../types";
+import type { RateLimitStore } from "../stores/types";
+export declare function createStrategy(store: RateLimitStore, config: AlgorithmConfig): RateLimitStrategy;
 //# sourceMappingURL=factory.d.ts.map

package/dist/algorithms/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/algorithms/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EACjB,WAAW,EACZ,MAAM,UAAU,CAAC;AAIlB,wBAAgB,cAAc,CAC5B,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,eAAe,EACvB,SAAS,CAAC,EAAE,MAAM,GACjB,iBAAiB,CAanB"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/algorithms/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAItD,wBAAgB,cAAc,CAC5B,KAAK,EAAE,cAAc,EACrB,MAAM,EAAE,eAAe,GACtB,iBAAiB,CAanB"}

package/dist/algorithms/factory.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStrategy = createStrategy;
 const sliding_window_1 = require("./sliding-window");
 const token_bucket_1 = require("./token-bucket");
-function createStrategy(redis, config, keyPrefix) {
+function createStrategy(store, config) {
     switch (config.algorithm) {
         case "sliding-window":
-            return new sliding_window_1.SlidingWindowStrategy(redis, config, keyPrefix);
+            return new sliding_window_1.SlidingWindowStrategy(store, config);
         case "token-bucket":
-            return new token_bucket_1.TokenBucketStrategy(redis, config, keyPrefix);
+            return new token_bucket_1.TokenBucketStrategy(store, config);
         default: {
             const exhaustive = config;
             throw new Error(`Unknown algorithm: ${exhaustive.algorithm}`);

package/dist/algorithms/factory.js.map

@@ -1 +1 @@
-{"version":3,"file":"factory.js","sourceRoot":"","sources":["../../src/algorithms/factory.ts"],"names":[],"mappings":";;AAQA,wCAiBC;AApBD,qDAAyD;AACzD,iDAAqD;AAErD,SAAgB,cAAc,CAC5B,KAAkB,EAClB,MAAuB,EACvB,SAAkB;IAElB,QAAQ,MAAM,CAAC,SAAS,EAAE,CAAC;QACzB,KAAK,gBAAgB;YACnB,OAAO,IAAI,sCAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;QAC7D,KAAK,cAAc;YACjB,OAAO,IAAI,kCAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;QAC3D,OAAO,CAAC,CAAC,CAAC;YACR,MAAM,UAAU,GAAU,MAAM,CAAC;YACjC,MAAM,IAAI,KAAK,CACb,sBAAuB,UAA8B,CAAC,SAAS,EAAE,CAClE,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC"}
+{"version":3,"file":"factory.js","sourceRoot":"","sources":["../../src/algorithms/factory.ts"],"names":[],"mappings":";;AAKA,wCAgBC;AAnBD,qDAAyD;AACzD,iDAAqD;AAErD,SAAgB,cAAc,CAC5B,KAAqB,EACrB,MAAuB;IAEvB,QAAQ,MAAM,CAAC,SAAS,EAAE,CAAC;QACzB,KAAK,gBAAgB;YACnB,OAAO,IAAI,sCAAqB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QAClD,KAAK,cAAc;YACjB,OAAO,IAAI,kCAAmB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QAChD,OAAO,CAAC,CAAC,CAAC;YACR,MAAM,UAAU,GAAU,MAAM,CAAC;YACjC,MAAM,IAAI,KAAK,CACb,sBAAuB,UAA8B,CAAC,SAAS,EAAE,CAClE,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/algorithms/sliding-window.d.ts

@@ -1,10 +1,10 @@
-import type { RateLimitResult, RateLimitStrategy, RedisClient, SlidingWindowConfig } from "../types";
+import type { RateLimitResult, RateLimitStrategy, SlidingWindowConfig } from "../types";
+import type { RateLimitStore } from "../stores/types";
 export declare class SlidingWindowStrategy implements RateLimitStrategy {
-    private readonly redis;
+    private readonly store;
     private readonly limit;
     private readonly window;
-    private readonly keyPrefix;
-    constructor(redis: RedisClient, config: SlidingWindowConfig, keyPrefix?: string);
+    constructor(store: RateLimitStore, config: SlidingWindowConfig);
     consume(key: string): Promise<RateLimitResult>;
 }
 //# sourceMappingURL=sliding-window.d.ts.map

package/dist/algorithms/sliding-window.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sliding-window.d.ts","sourceRoot":"","sources":["../../src/algorithms/sliding-window.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,mBAAmB,EACpB,MAAM,UAAU,CAAC;AAIlB,qBAAa,qBAAsB,YAAW,iBAAiB;IAC7D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAc;IACpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAGjC,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,mBAAmB,EAC3B,SAAS,SAAe;IAQpB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;CAsBrD"}
+{"version":3,"file":"sliding-window.d.ts","sourceRoot":"","sources":["../../src/algorithms/sliding-window.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD,qBAAa,qBAAsB,YAAW,iBAAiB;IAC7D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiB;IACvC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAEpB,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,mBAAmB;IAMxD,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;CAGrD"}

package/dist/algorithms/sliding-window.js

@@ -1,34 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SlidingWindowStrategy = void 0;
-const crypto_1 = require("crypto");
-const redis_1 = require("../utils/redis");
-const scripts_1 = require("../utils/scripts");
 class SlidingWindowStrategy {
-    constructor(redis, config, keyPrefix = "redislimit") {
-        this.redis = redis;
+    constructor(store, config) {
+        this.store = store;
         this.limit = config.limit;
         this.window = config.window;
-        this.keyPrefix = keyPrefix;
     }
     async consume(key) {
-        const redisKey = (0, redis_1.buildKey)(this.keyPrefix, `sw:${key}`);
-        const now = Date.now();
-        const requestId = (0, crypto_1.randomUUID)();
-        const result = await (0, scripts_1.evalScript)(this.redis, "sliding", [redisKey], [
-            this.limit,
-            this.window,
-            now,
-            requestId,
-        ]);
-        const parsed = (0, scripts_1.parseScriptResult)(result);
-        return {
-            allowed: parsed.allowed,
-            limit: parsed.limit,
-            remaining: parsed.remaining,
-            reset: parsed.reset,
-            retryAfter: parsed.retryAfter || undefined,
-        };
+        return this.store.slidingWindow(key, this.limit, this.window);
     }
 }
 exports.SlidingWindowStrategy = SlidingWindowStrategy;

package/dist/algorithms/sliding-window.js.map

@@ -1 +1 @@
-{"version":3,"file":"sliding-window.js","sourceRoot":"","sources":["../../src/algorithms/sliding-window.ts"],"names":[],"mappings":";;;AAAA,mCAAoC;AAOpC,0CAA0C;AAC1C,8CAAiE;AAEjE,MAAa,qBAAqB;IAMhC,YACE,KAAkB,EAClB,MAA2B,EAC3B,SAAS,GAAG,YAAY;QAExB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;QAC1B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,GAAW;QACvB,MAAM,QAAQ,GAAG,IAAA,gBAAQ,EAAC,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,EAAE,CAAC,CAAC;QACvD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,MAAM,SAAS,GAAG,IAAA,mBAAU,GAAE,CAAC;QAE/B,MAAM,MAAM,GAAG,MAAM,IAAA,oBAAU,EAAC,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC,QAAQ,CAAC,EAAE;YACjE,IAAI,CAAC,KAAK;YACV,IAAI,CAAC,MAAM;YACX,GAAG;YACH,SAAS;SACV,CAAC,CAAC;QAEH,MAAM,MAAM,GAAG,IAAA,2BAAiB,EAAC,MAAM,CAAC,CAAC;QAEzC,OAAO;YACL,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,KAAK,EAAE,MAAM,CAAC,KAAK;YACnB,SAAS,EAAE,MAAM,CAAC,SAAS;YAC3B,KAAK,EAAE,MAAM,CAAC,KAAK;YACnB,UAAU,EAAE,MAAM,CAAC,UAAU,IAAI,SAAS;SAC3C,CAAC;IACJ,CAAC;CACF;AAvCD,sDAuCC"}
+{"version":3,"file":"sliding-window.js","sourceRoot":"","sources":["../../src/algorithms/sliding-window.ts"],"names":[],"mappings":";;;AAOA,MAAa,qBAAqB;IAKhC,YAAY,KAAqB,EAAE,MAA2B;QAC5D,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;QAC1B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IAC9B,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,GAAW;QACvB,OAAO,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,GAAG,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAChE,CAAC;CACF;AAdD,sDAcC"}

package/dist/algorithms/token-bucket.d.ts

@@ -1,10 +1,10 @@
-import type { RateLimitResult, RateLimitStrategy, RedisClient, TokenBucketConfig } from "../types";
+import type { RateLimitResult, RateLimitStrategy, TokenBucketConfig } from "../types";
+import type { RateLimitStore } from "../stores/types";
 export declare class TokenBucketStrategy implements RateLimitStrategy {
-    private readonly redis;
+    private readonly store;
     private readonly capacity;
     private readonly refillRate;
-    private readonly keyPrefix;
-    constructor(redis: RedisClient, config: TokenBucketConfig, keyPrefix?: string);
+    constructor(store: RateLimitStore, config: TokenBucketConfig);
     consume(key: string): Promise<RateLimitResult>;
 }
 //# sourceMappingURL=token-bucket.d.ts.map

package/dist/algorithms/token-bucket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"token-bucket.d.ts","sourceRoot":"","sources":["../../src/algorithms/token-bucket.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAIlB,qBAAa,mBAAoB,YAAW,iBAAiB;IAC3D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAc;IACpC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAGjC,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,iBAAiB,EACzB,SAAS,SAAe;IAQpB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;CAoBrD"}
+{"version":3,"file":"token-bucket.d.ts","sourceRoot":"","sources":["../../src/algorithms/token-bucket.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD,qBAAa,mBAAoB,YAAW,iBAAiB;IAC3D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiB;IACvC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;gBAExB,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,iBAAiB;IAMtD,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;CAGrD"}

package/dist/algorithms/token-bucket.js

@@ -1,31 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TokenBucketStrategy = void 0;
-const redis_1 = require("../utils/redis");
-const scripts_1 = require("../utils/scripts");
 class TokenBucketStrategy {
-    constructor(redis, config, keyPrefix = "redislimit") {
-        this.redis = redis;
+    constructor(store, config) {
+        this.store = store;
         this.capacity = config.capacity;
         this.refillRate = config.refillRate;
-        this.keyPrefix = keyPrefix;
     }
     async consume(key) {
-        const redisKey = (0, redis_1.buildKey)(this.keyPrefix, `tb:${key}`);
-        const now = Date.now();
-        const result = await (0, scripts_1.evalScript)(this.redis, "token", [redisKey], [
-            this.capacity,
-            this.refillRate,
-            now,
-        ]);
-        const parsed = (0, scripts_1.parseScriptResult)(result);
-        return {
-            allowed: parsed.allowed,
-            limit: parsed.limit,
-            remaining: parsed.remaining,
-            reset: parsed.reset,
-            retryAfter: parsed.retryAfter || undefined,
-        };
+        return this.store.tokenBucket(key, this.capacity, this.refillRate);
     }
 }
 exports.TokenBucketStrategy = TokenBucketStrategy;

package/dist/algorithms/token-bucket.js.map

@@ -1 +1 @@
-{"version":3,"file":"token-bucket.js","sourceRoot":"","sources":["../../src/algorithms/token-bucket.ts"],"names":[],"mappings":";;;AAMA,0CAA0C;AAC1C,8CAAiE;AAEjE,MAAa,mBAAmB;IAM9B,YACE,KAAkB,EAClB,MAAyB,EACzB,SAAS,GAAG,YAAY;QAExB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;QAChC,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC;QACpC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,GAAW;QACvB,MAAM,QAAQ,GAAG,IAAA,gBAAQ,EAAC,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,EAAE,CAAC,CAAC;QACvD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAEvB,MAAM,MAAM,GAAG,MAAM,IAAA,oBAAU,EAAC,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,QAAQ,CAAC,EAAE;YAC/D,IAAI,CAAC,QAAQ;YACb,IAAI,CAAC,UAAU;YACf,GAAG;SACJ,CAAC,CAAC;QAEH,MAAM,MAAM,GAAG,IAAA,2BAAiB,EAAC,MAAM,CAAC,CAAC;QAEzC,OAAO;YACL,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,KAAK,EAAE,MAAM,CAAC,KAAK;YACnB,SAAS,EAAE,MAAM,CAAC,SAAS;YAC3B,KAAK,EAAE,MAAM,CAAC,KAAK;YACnB,UAAU,EAAE,MAAM,CAAC,UAAU,IAAI,SAAS;SAC3C,CAAC;IACJ,CAAC;CACF;AArCD,kDAqCC"}
+{"version":3,"file":"token-bucket.js","sourceRoot":"","sources":["../../src/algorithms/token-bucket.ts"],"names":[],"mappings":";;;AAOA,MAAa,mBAAmB;IAK9B,YAAY,KAAqB,EAAE,MAAyB;QAC1D,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;QAChC,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC;IACtC,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,GAAW;QACvB,OAAO,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IACrE,CAAC;CACF;AAdD,kDAcC"}

package/dist/index.d.ts

@@ -1,8 +1,22 @@
 export { RedisLimit, createLimiter } from "./limiter";
 export { createExpressMiddleware } from "./middleware/express";
 export { createFastifyPlugin, redisLimitPlugin } from "./middleware/fastify";
+export { createHonoMiddleware } from "./middleware/hono";
+export { createKoaMiddleware } from "./middleware/koa";
+export { applyRateLimitHeaders, composeBunHandler, createBunMiddleware, jsonResponse, } from "./middleware/bun";
+export type { BunMiddleware, BunNext } from "./middleware/bun";
+export { createNestGuard, limitlyNestModule, LimitlyModule, RateLimit, RATE_LIMIT_KEY, } from "./middleware/nest";
+export type { NestRateLimitOptions } from "./middleware/nest";
 export { SlidingWindowStrategy } from "./algorithms/sliding-window";
 export { TokenBucketStrategy } from "./algorithms/token-bucket";
 export type { RateLimitStrategy } from "./algorithms/strategy";
-export type { AlgorithmConfig, BaseMiddlewareOptions, MiddlewareOptions, RateLimitHeaders, RateLimitResult, RedisClient, RedisConfig, RedisLimitOptions, SlidingWindowConfig, TokenBucketConfig, } from "./types";
+export { DEFAULT_KEY_PREFIX } from "./utils/redis";
+export { DEFAULT_SLIDING_WINDOW, DEFAULT_TOKEN_BUCKET, resolveAlgorithmConfig, resolveMiddlewareOptions, } from "./utils/defaults";
+export { consumeRateLimit } from "./utils/metrics";
+export type { RateLimitCheckOutcome } from "./utils/metrics";
+export { createStore, resolveStoreType } from "./stores/factory";
+export { RedisStore } from "./stores/redis-store";
+export { MemcachedStore } from "./stores/memcached-store";
+export type { RateLimitStore, StoreType } from "./stores/types";
+export type { AlgorithmConfig, BaseMiddlewareOptions, MemcachedClient, MemcachedConfig, MemcachedOptions, MiddlewareOptions, MiddlewareOptionsInput, RateLimitHeaders, RateLimitMetricsEvent, RateLimitMetricsHook, RateLimitResult, RedisClient, RedisConfig, RedisLimitOptions, SlidingWindowConfig, TokenBucketConfig, } from "./types";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AACtD,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7E,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAChE,YAAY,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,YAAY,EACV,eAAe,EACf,qBAAqB,EACrB,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,EACf,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AACtD,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7E,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EACL,qBAAqB,EACrB,iBAAiB,EACjB,mBAAmB,EACnB,YAAY,GACb,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,SAAS,EACT,cAAc,GACf,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAChE,YAAY,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACpB,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,YAAY,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACjE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,YAAY,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChE,YAAY,EACV,eAAe,EACf,qBAAqB,EACrB,eAAe,EACf,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,sBAAsB,EACtB,gBAAgB,EAChB,qBAAqB,EACrB,oBAAoB,EACpB,eAAe,EACf,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TokenBucketStrategy = exports.SlidingWindowStrategy = exports.redisLimitPlugin = exports.createFastifyPlugin = exports.createExpressMiddleware = exports.createLimiter = exports.RedisLimit = void 0;
+exports.MemcachedStore = exports.RedisStore = exports.resolveStoreType = exports.createStore = exports.consumeRateLimit = exports.resolveMiddlewareOptions = exports.resolveAlgorithmConfig = exports.DEFAULT_TOKEN_BUCKET = exports.DEFAULT_SLIDING_WINDOW = exports.DEFAULT_KEY_PREFIX = exports.TokenBucketStrategy = exports.SlidingWindowStrategy = exports.RATE_LIMIT_KEY = exports.RateLimit = exports.LimitlyModule = exports.limitlyNestModule = exports.createNestGuard = exports.jsonResponse = exports.createBunMiddleware = exports.composeBunHandler = exports.applyRateLimitHeaders = exports.createKoaMiddleware = exports.createHonoMiddleware = exports.redisLimitPlugin = exports.createFastifyPlugin = exports.createExpressMiddleware = exports.createLimiter = exports.RedisLimit = void 0;
 var limiter_1 = require("./limiter");
 Object.defineProperty(exports, "RedisLimit", { enumerable: true, get: function () { return limiter_1.RedisLimit; } });
 Object.defineProperty(exports, "createLimiter", { enumerable: true, get: function () { return limiter_1.createLimiter; } });
@@ -9,8 +9,39 @@ Object.defineProperty(exports, "createExpressMiddleware", { enumerable: true, ge
 var fastify_1 = require("./middleware/fastify");
 Object.defineProperty(exports, "createFastifyPlugin", { enumerable: true, get: function () { return fastify_1.createFastifyPlugin; } });
 Object.defineProperty(exports, "redisLimitPlugin", { enumerable: true, get: function () { return fastify_1.redisLimitPlugin; } });
+var hono_1 = require("./middleware/hono");
+Object.defineProperty(exports, "createHonoMiddleware", { enumerable: true, get: function () { return hono_1.createHonoMiddleware; } });
+var koa_1 = require("./middleware/koa");
+Object.defineProperty(exports, "createKoaMiddleware", { enumerable: true, get: function () { return koa_1.createKoaMiddleware; } });
+var bun_1 = require("./middleware/bun");
+Object.defineProperty(exports, "applyRateLimitHeaders", { enumerable: true, get: function () { return bun_1.applyRateLimitHeaders; } });
+Object.defineProperty(exports, "composeBunHandler", { enumerable: true, get: function () { return bun_1.composeBunHandler; } });
+Object.defineProperty(exports, "createBunMiddleware", { enumerable: true, get: function () { return bun_1.createBunMiddleware; } });
+Object.defineProperty(exports, "jsonResponse", { enumerable: true, get: function () { return bun_1.jsonResponse; } });
+var nest_1 = require("./middleware/nest");
+Object.defineProperty(exports, "createNestGuard", { enumerable: true, get: function () { return nest_1.createNestGuard; } });
+Object.defineProperty(exports, "limitlyNestModule", { enumerable: true, get: function () { return nest_1.limitlyNestModule; } });
+Object.defineProperty(exports, "LimitlyModule", { enumerable: true, get: function () { return nest_1.LimitlyModule; } });
+Object.defineProperty(exports, "RateLimit", { enumerable: true, get: function () { return nest_1.RateLimit; } });
+Object.defineProperty(exports, "RATE_LIMIT_KEY", { enumerable: true, get: function () { return nest_1.RATE_LIMIT_KEY; } });
 var sliding_window_1 = require("./algorithms/sliding-window");
 Object.defineProperty(exports, "SlidingWindowStrategy", { enumerable: true, get: function () { return sliding_window_1.SlidingWindowStrategy; } });
 var token_bucket_1 = require("./algorithms/token-bucket");
 Object.defineProperty(exports, "TokenBucketStrategy", { enumerable: true, get: function () { return token_bucket_1.TokenBucketStrategy; } });
+var redis_1 = require("./utils/redis");
+Object.defineProperty(exports, "DEFAULT_KEY_PREFIX", { enumerable: true, get: function () { return redis_1.DEFAULT_KEY_PREFIX; } });
+var defaults_1 = require("./utils/defaults");
+Object.defineProperty(exports, "DEFAULT_SLIDING_WINDOW", { enumerable: true, get: function () { return defaults_1.DEFAULT_SLIDING_WINDOW; } });
+Object.defineProperty(exports, "DEFAULT_TOKEN_BUCKET", { enumerable: true, get: function () { return defaults_1.DEFAULT_TOKEN_BUCKET; } });
+Object.defineProperty(exports, "resolveAlgorithmConfig", { enumerable: true, get: function () { return defaults_1.resolveAlgorithmConfig; } });
+Object.defineProperty(exports, "resolveMiddlewareOptions", { enumerable: true, get: function () { return defaults_1.resolveMiddlewareOptions; } });
+var metrics_1 = require("./utils/metrics");
+Object.defineProperty(exports, "consumeRateLimit", { enumerable: true, get: function () { return metrics_1.consumeRateLimit; } });
+var factory_1 = require("./stores/factory");
+Object.defineProperty(exports, "createStore", { enumerable: true, get: function () { return factory_1.createStore; } });
+Object.defineProperty(exports, "resolveStoreType", { enumerable: true, get: function () { return factory_1.resolveStoreType; } });
+var redis_store_1 = require("./stores/redis-store");
+Object.defineProperty(exports, "RedisStore", { enumerable: true, get: function () { return redis_store_1.RedisStore; } });
+var memcached_store_1 = require("./stores/memcached-store");
+Object.defineProperty(exports, "MemcachedStore", { enumerable: true, get: function () { return memcached_store_1.MemcachedStore; } });
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,qCAAsD;AAA7C,qGAAA,UAAU,OAAA;AAAE,wGAAA,aAAa,OAAA;AAClC,gDAA+D;AAAtD,kHAAA,uBAAuB,OAAA;AAChC,gDAA6E;AAApE,8GAAA,mBAAmB,OAAA;AAAE,2GAAA,gBAAgB,OAAA;AAC9C,8DAAoE;AAA3D,uHAAA,qBAAqB,OAAA;AAC9B,0DAAgE;AAAvD,mHAAA,mBAAmB,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,qCAAsD;AAA7C,qGAAA,UAAU,OAAA;AAAE,wGAAA,aAAa,OAAA;AAClC,gDAA+D;AAAtD,kHAAA,uBAAuB,OAAA;AAChC,gDAA6E;AAApE,8GAAA,mBAAmB,OAAA;AAAE,2GAAA,gBAAgB,OAAA;AAC9C,0CAAyD;AAAhD,4GAAA,oBAAoB,OAAA;AAC7B,wCAAuD;AAA9C,0GAAA,mBAAmB,OAAA;AAC5B,wCAK0B;AAJxB,4GAAA,qBAAqB,OAAA;AACrB,wGAAA,iBAAiB,OAAA;AACjB,0GAAA,mBAAmB,OAAA;AACnB,mGAAA,YAAY,OAAA;AAGd,0CAM2B;AALzB,uGAAA,eAAe,OAAA;AACf,yGAAA,iBAAiB,OAAA;AACjB,qGAAA,aAAa,OAAA;AACb,iGAAA,SAAS,OAAA;AACT,sGAAA,cAAc,OAAA;AAGhB,8DAAoE;AAA3D,uHAAA,qBAAqB,OAAA;AAC9B,0DAAgE;AAAvD,mHAAA,mBAAmB,OAAA;AAE5B,uCAAmD;AAA1C,2GAAA,kBAAkB,OAAA;AAC3B,6CAK0B;AAJxB,kHAAA,sBAAsB,OAAA;AACtB,gHAAA,oBAAoB,OAAA;AACpB,kHAAA,sBAAsB,OAAA;AACtB,oHAAA,wBAAwB,OAAA;AAE1B,2CAAmD;AAA1C,2GAAA,gBAAgB,OAAA;AAEzB,4CAAiE;AAAxD,sGAAA,WAAW,OAAA;AAAE,2GAAA,gBAAgB,OAAA;AACtC,oDAAkD;AAAzC,yGAAA,UAAU,OAAA;AACnB,4DAA0D;AAAjD,iHAAA,cAAc,OAAA"}

package/dist/limiter.d.ts

@@ -1,19 +1,31 @@
+import type { RateLimitStore } from "./stores/types";
 import type { FastifyPluginAsync } from "fastify";
-import type { AlgorithmConfig, MiddlewareOptions, RateLimitResult, RateLimitStrategy, RedisClient, RedisLimitOptions } from "./types";
+import type { CanActivate, Type } from "@nestjs/common";
+import type { AlgorithmConfig, MemcachedClient, MiddlewareOptions, MiddlewareOptionsInput, RateLimitResult, RateLimitStrategy, RedisClient, RedisLimitOptions } from "./types";
 export declare class RedisLimit {
-    private readonly redis;
+    private readonly store;
     private readonly failOpen;
-    private readonly keyPrefix;
+    private readonly defaultOptions;
     constructor(options: RedisLimitOptions);
+    getStore(): RateLimitStore;
+    getStoreType(): RateLimitStore["type"];
+    getDefaultOptions(): MiddlewareOptionsInput;
+    resolveOptions(options?: MiddlewareOptionsInput): MiddlewareOptions;
     getRedis(): RedisClient;
+    getMemcached(): MemcachedClient;
     createStrategy(config: AlgorithmConfig): RateLimitStrategy;
-    check(key: string, config: AlgorithmConfig, options?: {
+    createStrategyFromOptions(options?: MiddlewareOptionsInput): RateLimitStrategy;
+    check(key: string, config?: MiddlewareOptionsInput, options?: {
         failOpen?: boolean;
     }): Promise<RateLimitResult>;
-    middleware(options: MiddlewareOptions): (req: import("express").Request, res: import("express").Response, next: import("express").NextFunction) => Promise<void>;
-    get fastifyPlugin(): FastifyPluginAsync<MiddlewareOptions>;
+    middleware(options?: MiddlewareOptionsInput): (req: import("express").Request, res: import("express").Response, next: import("express").NextFunction) => Promise<void>;
+    honoMiddleware(options?: MiddlewareOptionsInput): (c: import("hono").Context, next: import("hono").Next) => Promise<Response | void>;
+    koaMiddleware(options?: MiddlewareOptionsInput): (ctx: import("koa").Context, next: import("koa").Next) => Promise<void>;
+    bunMiddleware(options?: MiddlewareOptionsInput): import("./middleware/bun").BunMiddleware;
+    get fastifyPlugin(): FastifyPluginAsync<MiddlewareOptionsInput>;
+    nestGuard(defaultOptions?: MiddlewareOptionsInput): Type<CanActivate>;
     private createFailOpenResult;
 }
 export declare function createLimiter(options: RedisLimitOptions): RedisLimit;
-export type { MiddlewareOptions };
+export type { MiddlewareOptions, MiddlewareOptionsInput };
 //# sourceMappingURL=limiter.d.ts.map