limitly 1.0.2 → 3.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,28 @@ Distributed, Redis-powered rate limiting for Express and Fastify.
 
 ```bash
 npm install limitly ioredis
+
+# Memcached backend
+npm install limitly memcached
+
+# OpenTelemetry
+npm install limitly ioredis @opentelemetry/api
+
+# Prometheus
+npm install limitly ioredis prom-client
+
+# 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
@@ -23,14 +45,7 @@ const app = express();
 const redis = new Redis();
 const limiter = createLimiter({ redis });
 
-app.use(
-  limiter.middleware({
-    algorithm: "sliding-window",
-    limit: 100,
-    window: 60,
-    key: (req) => req.ip,
-  }),
-);
+app.use(limiter.middleware({ key: (req) => req.ip }));
 ```
 
 ### Fastify
@@ -51,11 +66,179 @@ 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({ 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({ 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({
+  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({
+  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({ 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 **GCRA** 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: "gcra",
+    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", {
+  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
 
+### GCRA (default)
+
+Generic Cell Rate Algorithm — smooth rate limiting with controlled bursts. Uses a single TAT (theoretical arrival time) per key, so it's memory-efficient compared to sliding window:
+
+```typescript
+limiter.middleware({
+  limit: 100,
+  window: 60, // seconds — algorithm defaults to gcra
+  key: (req) => req.ip,
+});
+```
+
+GCRA enforces an average rate of `limit / window` while allowing short bursts up to `limit`. Ideal when you want token-bucket-like behavior with predictable storage costs.
+
 ### 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 +260,117 @@ limiter.middleware({
 });
 ```
 
-## Redis Connection
+### Concurrency
+
+Limits simultaneous in-flight requests per key. Slots are acquired on entry and released when the response finishes (middleware handles this automatically):
+
+```typescript
+limiter.middleware({
+  algorithm: "concurrency",
+  limit: 10, // max concurrent requests
+  ttl: 300, // lease TTL in seconds for stale slot cleanup
+  key: (req) => req.ip,
+});
+```
+
+For manual acquire/release outside middleware:
+
+```typescript
+const acquired = await limiter.acquire("job-42", {
+  algorithm: "concurrency",
+  limit: 5,
+  ttl: 120,
+});
+
+if (!acquired.allowed) {
+  throw new Error("Too many concurrent jobs");
+}
+
+try {
+  await runJob();
+} finally {
+  await limiter.release("job-42", acquired.slotId!, {
+    algorithm: "concurrency",
+    limit: 5,
+    ttl: 120,
+  });
+}
+```
+
+Storage keys use the `cc:` prefix: `{keyPrefix}:cc:{id}`.
+
+## Storage Backends
+
+limitly supports Redis, Valkey, DragonflyDB (Redis-compatible), and Memcached.
 
-Supports multiple connection modes:
+### Redis / Valkey / DragonflyDB
+
+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
+// Cluster (auto-pipelining, script warmup, master reads)
 createLimiter({
+  store: "redis",
   redis: {
-    nodes: [{ host: "127.0.0.1", port: 7000 }],
+    nodes: [
+      { host: "127.0.0.1", port: 7000 },
+      { host: "127.0.0.1", port: 7001 },
+    ],
+    options: {
+      redisOptions: { password: "secret" },
+    },
   },
 });
+
+// Optional: pin all keys to one slot (use only when you need co-location)
+createLimiter({
+  redis: { nodes: [{ host: "127.0.0.1", port: 7000 }] },
+  hashTag: "limitly",
+});
 ```
 
+Cluster optimizations built into limitly:
+
+- **ioredis `defineCommand`** — Lua scripts are registered cluster-aware, avoiding per-node `NOSCRIPT` fallbacks
+- **Script warmup** — scripts are preloaded on all master nodes at startup (disable with `warmupScripts: false`)
+- **Auto-pipelining** — enabled by default for higher throughput under concurrent load
+- **Hash tags** — optional `hashTag` for slot pinning; leave unset to spread keys across slots (recommended)
+- **Master reads** — `scaleReads: "master"` by default so checks always hit the authoritative node
+
+### 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 +382,31 @@ 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
+{keyPrefix}:gcra:{id} — GCRA
+{keyPrefix}:cc:{id}   — concurrency
+```
+
 ## Response Headers
 
 Standard rate limit headers are set by default:
@@ -129,15 +424,166 @@ Disable with `headers: false`.
 
 ```typescript
 limiter.middleware({
-  algorithm: "sliding-window",
-  limit: 100,
-  window: 60,
   onLimitReached(req, res) {
     res.status(429).json({ code: "RATE_LIMITED" });
   },
 });
 ```
 
+## 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({
+  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.
+
+## OpenTelemetry
+
+Use the `limitly/otel` helpers to emit OTEL metrics and traces. Only `@opentelemetry/api` is required — bring your own SDK/exporter:
+
+```typescript
+import Redis from "ioredis";
+import { createLimiter } from "limitly";
+import { createOpenTelemetryInstrumentation } from "limitly/otel";
+
+const otel = createOpenTelemetryInstrumentation();
+
+const limiter = createLimiter({
+  redis: new Redis(),
+  tracer: otel.tracer,
+  onMetrics: otel.onMetrics,
+});
+
+app.use(limiter.middleware({ key: (req) => req.ip }));
+```
+
+`createOpenTelemetryInstrumentation()` returns:
+
+- **`tracer`** — creates `limitly.check` spans with `limitly.algorithm`, `limitly.store`, `limitly.outcome`, `limitly.limit`, and `limitly.remaining` attributes
+- **`onMetrics`** — records `limitly.check.total` (counter) and `limitly.check.duration` (histogram, ms)
+
+Use the pieces independently when needed:
+
+```typescript
+import {
+  createOpenTelemetryMetricsHook,
+  createOpenTelemetryTracer,
+} from "limitly/otel";
+
+const limiter = createLimiter({
+  redis: new Redis(),
+  tracer: createOpenTelemetryTracer(),
+  onMetrics: createOpenTelemetryMetricsHook({ includeKey: false }),
+});
+```
+
+Combine with custom hooks:
+
+```typescript
+onMetrics: [otel.onMetrics, customHook]
+```
+
+## Prometheus
+
+Use `limitly/prometheus` to expose rate limit metrics for scraping:
+
+```typescript
+import express from "express";
+import Redis from "ioredis";
+import { createLimiter } from "limitly";
+import {
+  createPrometheusExporter,
+  createPrometheusHandler,
+} from "limitly/prometheus";
+
+const app = express();
+const prometheus = createPrometheusExporter();
+
+const limiter = createLimiter({
+  redis: new Redis(),
+  onMetrics: prometheus.onMetrics,
+});
+
+app.use(limiter.middleware({ key: (req) => req.ip }));
+app.get("/metrics", createPrometheusHandler(prometheus));
+```
+
+Metrics exposed:
+
+| Metric | Type | Labels |
+|--------|------|--------|
+| `limitly_check_total` | Counter | `algorithm`, `outcome`, `store` |
+| `limitly_check_duration_seconds` | Histogram | `algorithm`, `outcome`, `store` |
+
+`outcome` is one of `allowed`, `blocked`, `error`, or `fail_open`.
+
+Options:
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `register` | new `Registry` | Prometheus registry |
+| `prefix` | `"limitly"` | Metric name prefix |
+| `includeKey` | `false` | Add rate limit key as a label (high cardinality) |
+| `durationBuckets` | `[0.001, 0.005, 0.01, …, 1]` | Histogram buckets (seconds) |
+
+Use a shared registry with your existing metrics:
+
+```typescript
+import { Registry } from "prom-client";
+
+const register = new Registry();
+const prometheus = createPrometheusExporter({ register });
+
+onMetrics: [prometheus.onMetrics, otherHook];
+```
+
+Scrape manually without HTTP middleware:
+
+```typescript
+const body = await prometheus.getMetrics();
+```
+
+Use `createPrometheusMetricsHook` when you only need the `onMetrics` hook without the HTTP handler:
+
+```typescript
+import { createPrometheusMetricsHook } from "limitly/prometheus";
+
+const limiter = createLimiter({
+  redis: new Redis(),
+  onMetrics: createPrometheusMetricsHook({ prefix: "api" }),
+});
+```
+
 ## Fail Open / Closed
 
 When Redis is unavailable:
@@ -157,9 +603,12 @@ Implement custom algorithms with the `RateLimitStrategy` interface:
 ```typescript
 interface RateLimitStrategy {
   consume(key: string): Promise<RateLimitResult>;
+  release?(key: string, slotId: string): Promise<void>;
 }
 ```
 
+`release` is optional — only needed for concurrency-style strategies that hold a slot until the response finishes.
+
 ## Performance
 
 - Atomic operations via Lua scripts (`EVALSHA`)

package/dist/algorithms/concurrency.d.ts

@@ -0,0 +1,11 @@
+import type { ConcurrencyConfig, RateLimitResult, RateLimitStrategy } from "../types";
+import type { RateLimitStore } from "../stores/types";
+export declare class ConcurrencyStrategy implements RateLimitStrategy {
+    private readonly store;
+    private readonly limit;
+    private readonly ttl;
+    constructor(store: RateLimitStore, config: ConcurrencyConfig);
+    consume(key: string): Promise<RateLimitResult>;
+    release(key: string, slotId: string): Promise<void>;
+}
+//# sourceMappingURL=concurrency.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"concurrency.d.ts","sourceRoot":"","sources":["../../src/algorithms/concurrency.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,eAAe,EACf,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGtD,qBAAa,mBAAoB,YAAW,iBAAiB;IAC3D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiB;IACvC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;gBAEjB,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,iBAAiB;IAMtD,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAI9C,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAG1D"}

package/dist/algorithms/concurrency.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConcurrencyStrategy = void 0;
+const defaults_1 = require("../utils/defaults");
+class ConcurrencyStrategy {
+    constructor(store, config) {
+        this.store = store;
+        this.limit = config.limit;
+        this.ttl = config.ttl ?? defaults_1.DEFAULT_CONCURRENCY.ttl;
+    }
+    async consume(key) {
+        return this.store.concurrencyAcquire(key, this.limit, this.ttl);
+    }
+    async release(key, slotId) {
+        await this.store.concurrencyRelease(key, slotId);
+    }
+}
+exports.ConcurrencyStrategy = ConcurrencyStrategy;
+//# sourceMappingURL=concurrency.js.map

package/dist/algorithms/concurrency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"concurrency.js","sourceRoot":"","sources":["../../src/algorithms/concurrency.ts"],"names":[],"mappings":";;;AAMA,gDAAwD;AAExD,MAAa,mBAAmB;IAK9B,YAAY,KAAqB,EAAE,MAAyB;QAC1D,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;QAC1B,IAAI,CAAC,GAAG,GAAG,MAAM,CAAC,GAAG,IAAI,8BAAmB,CAAC,GAAI,CAAC;IACpD,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,GAAW;QACvB,OAAO,IAAI,CAAC,KAAK,CAAC,kBAAkB,CAAC,GAAG,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;IAClE,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,GAAW,EAAE,MAAc;QACvC,MAAM,IAAI,CAAC,KAAK,CAAC,kBAAkB,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IACnD,CAAC;CACF;AAlBD,kDAkBC"}

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;AAMtD,wBAAgB,cAAc,CAC5B,KAAK,EAAE,cAAc,EACrB,MAAM,EAAE,eAAe,GACtB,iBAAiB,CAiBnB"}

package/dist/algorithms/factory.js

@@ -1,14 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStrategy = createStrategy;
+const concurrency_1 = require("./concurrency");
+const gcra_1 = require("./gcra");
 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);
+        case "concurrency":
+            return new concurrency_1.ConcurrencyStrategy(store, config);
+        case "gcra":
+            return new gcra_1.GcraStrategy(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":";;AAOA,wCAoBC;AAzBD,+CAAoD;AACpD,iCAAsC;AACtC,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,KAAK,aAAa;YAChB,OAAO,IAAI,iCAAmB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QAChD,KAAK,MAAM;YACT,OAAO,IAAI,mBAAY,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QACzC,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/gcra.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"gcra.d.ts","sourceRoot":"","sources":["../../src/algorithms/gcra.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC/E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD,qBAAa,YAAa,YAAW,iBAAiB;IACpD,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,UAAU;IAM/C,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;CAGrD"}

package/dist/algorithms/gcra.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GcraStrategy = void 0;
+class GcraStrategy {
+    constructor(store, config) {
+        this.store = store;
+        this.limit = config.limit;
+        this.window = config.window;
+    }
+    async consume(key) {
+        return this.store.gcra(key, this.limit, this.window);
+    }
+}
+exports.GcraStrategy = GcraStrategy;
+//# sourceMappingURL=gcra.js.map

package/dist/algorithms/gcra.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gcra.js","sourceRoot":"","sources":["../../src/algorithms/gcra.ts"],"names":[],"mappings":";;;AAGA,MAAa,YAAY;IAKvB,YAAY,KAAqB,EAAE,MAAkB;QACnD,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,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACvD,CAAC;CACF;AAdD,oCAcC"}