@commandkit/ratelimit 0.0.0-dev.20260317060555

package/dist/storage/memory.d.ts

@@ -0,0 +1,146 @@
+/**
+ * In-memory storage.
+ *
+ * Used for tests and local development; implements TTL and sorted-set helpers.
+ * Not suitable for multi-process deployments.
+ */
+import type { FixedWindowConsumeResult, RateLimitStorage, SlidingWindowConsumeResult } from '../types';
+/**
+ * In-memory storage used for tests and local usage.
+ *
+ * @implements RateLimitStorage
+ */
+export declare class MemoryRateLimitStorage implements RateLimitStorage {
+    private readonly kv;
+    private readonly zsets;
+    private now;
+    private isExpired;
+    /**
+     * Clear expired entries so reads reflect current state.
+     *
+     * @param key - Storage key to clean.
+     */
+    private cleanupKey;
+    /**
+     * Read a value from the in-memory key/value store.
+     *
+     * @param key - Storage key to read.
+     * @returns Stored value or null when absent/expired.
+     */
+    get<T = unknown>(key: string): Promise<T | null>;
+    /**
+     * Store a value in memory with optional TTL.
+     *
+     * @param key - Storage key to write.
+     * @param value - Value to store.
+     * @param ttlMs - Optional TTL in milliseconds.
+     * @returns Resolves when the value is stored.
+     */
+    set<T = unknown>(key: string, value: T, ttlMs?: number): Promise<void>;
+    /**
+     * Delete a key from the in-memory store.
+     *
+     * @param key - Storage key to delete.
+     * @returns Resolves when the key is removed.
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Increment a fixed-window counter with TTL handling.
+     *
+     * @param key - Storage key to increment.
+     * @param ttlMs - TTL window in milliseconds.
+     * @returns Updated counter value and remaining TTL.
+     */
+    incr(key: string, ttlMs: number): Promise<FixedWindowConsumeResult>;
+    /**
+     * Read the TTL for a key when present.
+     *
+     * @param key - Storage key to inspect.
+     * @returns Remaining TTL in ms or null when no TTL is set.
+     */
+    ttl(key: string): Promise<number | null>;
+    /**
+     * Update the TTL for an existing key.
+     *
+     * @param key - Storage key to update.
+     * @param ttlMs - TTL in milliseconds.
+     * @returns Resolves after the TTL is updated.
+     */
+    expire(key: string, ttlMs: number): Promise<void>;
+    /**
+     * Add a member to a sorted set with the given score.
+     *
+     * @param key - Sorted-set key.
+     * @param score - Score to associate with the member.
+     * @param member - Member identifier.
+     * @returns Resolves when the member is added.
+     */
+    zAdd(key: string, score: number, member: string): Promise<void>;
+    /**
+     * Remove sorted-set members with scores in the given range.
+     *
+     * @param key - Sorted-set key.
+     * @param min - Minimum score (inclusive).
+     * @param max - Maximum score (inclusive).
+     * @returns Resolves when the range is removed.
+     */
+    zRemRangeByScore(key: string, min: number, max: number): Promise<void>;
+    /**
+     * Count members in a sorted set.
+     *
+     * @param key - Sorted-set key.
+     * @returns Number of members in the set.
+     */
+    zCard(key: string): Promise<number>;
+    /**
+     * Read sorted-set members in a score range.
+     *
+     * @param key - Sorted-set key.
+     * @param min - Minimum score (inclusive).
+     * @param max - Maximum score (inclusive).
+     * @returns Ordered members in the score range.
+     */
+    zRangeByScore(key: string, min: number, max: number): Promise<string[]>;
+    /**
+     * Atomically consume a fixed-window counter for the key.
+     *
+     * @param key - Storage key to consume.
+     * @param limit - Request limit for the window.
+     * @param windowMs - Window size in milliseconds.
+     * @param nowMs - Current timestamp in milliseconds.
+     * @returns Fixed-window consume result.
+     */
+    consumeFixedWindow(key: string, _limit: number, windowMs: number, _nowMs: number): Promise<FixedWindowConsumeResult>;
+    /**
+     * Atomically consume a sliding-window log for the key.
+     *
+     * @param key - Storage key to consume.
+     * @param limit - Request limit for the window.
+     * @param windowMs - Window size in milliseconds.
+     * @param nowMs - Current timestamp in milliseconds.
+     * @param member - Member identifier for this request.
+     * @returns Sliding-window consume result.
+     */
+    consumeSlidingWindowLog(key: string, limit: number, windowMs: number, nowMs: number, member: string): Promise<SlidingWindowConsumeResult>;
+    /**
+     * Delete keys with the given prefix.
+     *
+     * @param prefix - Prefix to match.
+     * @returns Resolves after matching keys are deleted.
+     */
+    deleteByPrefix(prefix: string): Promise<void>;
+    /**
+     * Delete keys matching a glob pattern.
+     *
+     * @param pattern - Glob pattern to match.
+     * @returns Resolves after matching keys are deleted.
+     */
+    deleteByPattern(pattern: string): Promise<void>;
+    /**
+     * List keys that match a prefix.
+     *
+     * @param prefix - Prefix to match.
+     * @returns Matching keys.
+     */
+    keysByPrefix(prefix: string): Promise<string[]>;
+}

package/dist/storage/memory.js

@@ -0,0 +1,304 @@
+"use strict";
+/**
+ * In-memory storage.
+ *
+ * Used for tests and local development; implements TTL and sorted-set helpers.
+ * Not suitable for multi-process deployments.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryRateLimitStorage = void 0;
+/**
+ * In-memory storage used for tests and local usage.
+ *
+ * @implements RateLimitStorage
+ */
+class MemoryRateLimitStorage {
+    constructor() {
+        this.kv = new Map();
+        this.zsets = new Map();
+    }
+    now() {
+        return Date.now();
+    }
+    isExpired(expiresAt) {
+        return expiresAt != null && expiresAt <= this.now();
+    }
+    /**
+     * Clear expired entries so reads reflect current state.
+     *
+     * @param key - Storage key to clean.
+     */
+    cleanupKey(key) {
+        const kvEntry = this.kv.get(key);
+        if (kvEntry && this.isExpired(kvEntry.expiresAt)) {
+            this.kv.delete(key);
+        }
+        const zEntry = this.zsets.get(key);
+        if (zEntry && this.isExpired(zEntry.expiresAt)) {
+            this.zsets.delete(key);
+        }
+    }
+    /**
+     * Read a value from the in-memory key/value store.
+     *
+     * @param key - Storage key to read.
+     * @returns Stored value or null when absent/expired.
+     */
+    async get(key) {
+        this.cleanupKey(key);
+        const entry = this.kv.get(key);
+        if (!entry)
+            return null;
+        return entry.value;
+    }
+    /**
+     * Store a value in memory with optional TTL.
+     *
+     * @param key - Storage key to write.
+     * @param value - Value to store.
+     * @param ttlMs - Optional TTL in milliseconds.
+     * @returns Resolves when the value is stored.
+     */
+    async set(key, value, ttlMs) {
+        const expiresAt = typeof ttlMs === 'number' ? this.now() + ttlMs : null;
+        this.kv.set(key, { value, expiresAt });
+    }
+    /**
+     * Delete a key from the in-memory store.
+     *
+     * @param key - Storage key to delete.
+     * @returns Resolves when the key is removed.
+     */
+    async delete(key) {
+        this.kv.delete(key);
+        this.zsets.delete(key);
+    }
+    /**
+     * Increment a fixed-window counter with TTL handling.
+     *
+     * @param key - Storage key to increment.
+     * @param ttlMs - TTL window in milliseconds.
+     * @returns Updated counter value and remaining TTL.
+     */
+    async incr(key, ttlMs) {
+        this.cleanupKey(key);
+        const entry = this.kv.get(key);
+        if (!entry || typeof entry.value !== 'number') {
+            const expiresAt = this.now() + ttlMs;
+            this.kv.set(key, { value: 1, expiresAt });
+            return { count: 1, ttlMs };
+        }
+        const count = entry.value + 1;
+        entry.value = count;
+        if (!entry.expiresAt) {
+            entry.expiresAt = this.now() + ttlMs;
+        }
+        const remainingTtl = Math.max(0, (entry.expiresAt ?? this.now()) - this.now());
+        return { count, ttlMs: remainingTtl };
+    }
+    /**
+     * Read the TTL for a key when present.
+     *
+     * @param key - Storage key to inspect.
+     * @returns Remaining TTL in ms or null when no TTL is set.
+     */
+    async ttl(key) {
+        this.cleanupKey(key);
+        const entry = this.kv.get(key) ?? this.zsets.get(key);
+        if (!entry)
+            return null;
+        if (entry.expiresAt == null)
+            return null;
+        return Math.max(0, entry.expiresAt - this.now());
+    }
+    /**
+     * Update the TTL for an existing key.
+     *
+     * @param key - Storage key to update.
+     * @param ttlMs - TTL in milliseconds.
+     * @returns Resolves after the TTL is updated.
+     */
+    async expire(key, ttlMs) {
+        const expiresAt = this.now() + ttlMs;
+        const kvEntry = this.kv.get(key);
+        if (kvEntry)
+            kvEntry.expiresAt = expiresAt;
+        const zEntry = this.zsets.get(key);
+        if (zEntry)
+            zEntry.expiresAt = expiresAt;
+    }
+    /**
+     * Add a member to a sorted set with the given score.
+     *
+     * @param key - Sorted-set key.
+     * @param score - Score to associate with the member.
+     * @param member - Member identifier.
+     * @returns Resolves when the member is added.
+     */
+    async zAdd(key, score, member) {
+        this.cleanupKey(key);
+        const entry = this.zsets.get(key) ?? { items: [], expiresAt: null };
+        const existingIndex = entry.items.findIndex((item) => item.member === member);
+        if (existingIndex >= 0) {
+            entry.items[existingIndex] = { score, member };
+        }
+        else {
+            entry.items.push({ score, member });
+        }
+        entry.items.sort((a, b) => a.score - b.score);
+        this.zsets.set(key, entry);
+    }
+    /**
+     * Remove sorted-set members with scores in the given range.
+     *
+     * @param key - Sorted-set key.
+     * @param min - Minimum score (inclusive).
+     * @param max - Maximum score (inclusive).
+     * @returns Resolves when the range is removed.
+     */
+    async zRemRangeByScore(key, min, max) {
+        this.cleanupKey(key);
+        const entry = this.zsets.get(key);
+        if (!entry)
+            return;
+        entry.items = entry.items.filter((item) => item.score < min || item.score > max);
+    }
+    /**
+     * Count members in a sorted set.
+     *
+     * @param key - Sorted-set key.
+     * @returns Number of members in the set.
+     */
+    async zCard(key) {
+        this.cleanupKey(key);
+        const entry = this.zsets.get(key);
+        return entry ? entry.items.length : 0;
+    }
+    /**
+     * Read sorted-set members in a score range.
+     *
+     * @param key - Sorted-set key.
+     * @param min - Minimum score (inclusive).
+     * @param max - Maximum score (inclusive).
+     * @returns Ordered members in the score range.
+     */
+    async zRangeByScore(key, min, max) {
+        this.cleanupKey(key);
+        const entry = this.zsets.get(key);
+        if (!entry)
+            return [];
+        return entry.items
+            .filter((item) => item.score >= min && item.score <= max)
+            .map((item) => item.member);
+    }
+    /**
+     * Atomically consume a fixed-window counter for the key.
+     *
+     * @param key - Storage key to consume.
+     * @param limit - Request limit for the window.
+     * @param windowMs - Window size in milliseconds.
+     * @param nowMs - Current timestamp in milliseconds.
+     * @returns Fixed-window consume result.
+     */
+    async consumeFixedWindow(key, _limit, windowMs, _nowMs) {
+        return this.incr(key, windowMs);
+    }
+    /**
+     * Atomically consume a sliding-window log for the key.
+     *
+     * @param key - Storage key to consume.
+     * @param limit - Request limit for the window.
+     * @param windowMs - Window size in milliseconds.
+     * @param nowMs - Current timestamp in milliseconds.
+     * @param member - Member identifier for this request.
+     * @returns Sliding-window consume result.
+     */
+    async consumeSlidingWindowLog(key, limit, windowMs, nowMs, member) {
+        await this.zRemRangeByScore(key, 0, nowMs - windowMs);
+        const count = await this.zCard(key);
+        if (count >= limit) {
+            const oldest = await this.zRangeByScore(key, Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY);
+            const oldestMember = oldest[0];
+            const oldestTs = parseMemberTimestamp(oldestMember, nowMs);
+            return { allowed: false, count, resetAt: oldestTs + windowMs };
+        }
+        await this.zAdd(key, nowMs, member);
+        await this.expire(key, windowMs);
+        const newCount = count + 1;
+        const oldest = await this.zRangeByScore(key, Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY);
+        const oldestMember = oldest[0];
+        const oldestTs = parseMemberTimestamp(oldestMember, nowMs);
+        return { allowed: true, count: newCount, resetAt: oldestTs + windowMs };
+    }
+    /**
+     * Delete keys with the given prefix.
+     *
+     * @param prefix - Prefix to match.
+     * @returns Resolves after matching keys are deleted.
+     */
+    async deleteByPrefix(prefix) {
+        for (const key of Array.from(this.kv.keys())) {
+            if (key.startsWith(prefix))
+                this.kv.delete(key);
+        }
+        for (const key of Array.from(this.zsets.keys())) {
+            if (key.startsWith(prefix))
+                this.zsets.delete(key);
+        }
+    }
+    /**
+     * Delete keys matching a glob pattern.
+     *
+     * @param pattern - Glob pattern to match.
+     * @returns Resolves after matching keys are deleted.
+     */
+    async deleteByPattern(pattern) {
+        const regex = globToRegex(pattern);
+        for (const key of Array.from(this.kv.keys())) {
+            if (regex.test(key))
+                this.kv.delete(key);
+        }
+        for (const key of Array.from(this.zsets.keys())) {
+            if (regex.test(key))
+                this.zsets.delete(key);
+        }
+    }
+    /**
+     * List keys that match a prefix.
+     *
+     * @param prefix - Prefix to match.
+     * @returns Matching keys.
+     */
+    async keysByPrefix(prefix) {
+        const keys = new Set();
+        const kvKeys = Array.from(this.kv.keys());
+        for (const key of kvKeys) {
+            this.cleanupKey(key);
+            if (this.kv.has(key) && key.startsWith(prefix)) {
+                keys.add(key);
+            }
+        }
+        const zsetKeys = Array.from(this.zsets.keys());
+        for (const key of zsetKeys) {
+            this.cleanupKey(key);
+            if (this.zsets.has(key) && key.startsWith(prefix)) {
+                keys.add(key);
+            }
+        }
+        return Array.from(keys);
+    }
+}
+exports.MemoryRateLimitStorage = MemoryRateLimitStorage;
+function globToRegex(glob) {
+    const escaped = glob.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+    const regex = `^${escaped.replace(/\*/g, '.*')}$`;
+    return new RegExp(regex);
+}
+function parseMemberTimestamp(member, fallback) {
+    if (!member)
+        return fallback;
+    const prefix = member.split('-')[0];
+    const parsed = Number(prefix);
+    return Number.isFinite(parsed) ? parsed : fallback;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"memory.js","sourceRoot":"","sources":["../../src/storage/memory.ts"],"names":[],"mappings":"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"}

package/dist/storage/redis.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Redis storage.
+ *
+ * Uses Lua scripts for atomic fixed/sliding window operations.
+ */
+import Redis, { type RedisOptions } from 'ioredis';
+import type { FixedWindowConsumeResult, RateLimitStorage, SlidingWindowConsumeResult } from '../types';
+/**
+ * Redis-backed storage with Lua scripts for atomic window operations.
+ *
+ * @implements RateLimitStorage
+ */
+export declare class RedisRateLimitStorage implements RateLimitStorage {
+    readonly redis: Redis;
+    constructor(redis?: Redis | RedisOptions);
+    /**
+     * Read a value from Redis and JSON-decode it.
+     *
+     * @param key - Storage key to read.
+     * @returns Parsed value or null when absent.
+     */
+    get<T = unknown>(key: string): Promise<T | null>;
+    /**
+     * Store a value in Redis with optional TTL.
+     *
+     * @param key - Storage key to write.
+     * @param value - Value to serialize and store.
+     * @param ttlMs - Optional TTL in milliseconds.
+     * @returns Resolves when the value is stored.
+     */
+    set<T = unknown>(key: string, value: T, ttlMs?: number): Promise<void>;
+    /**
+     * Delete a key from Redis.
+     *
+     * @param key - Storage key to delete.
+     * @returns Resolves when the key is removed.
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Read the TTL for a key when present.
+     *
+     * @param key - Storage key to inspect.
+     * @returns Remaining TTL in ms or null when no TTL is set.
+     */
+    ttl(key: string): Promise<number | null>;
+    /**
+     * Update the TTL for an existing key.
+     *
+     * @param key - Storage key to update.
+     * @param ttlMs - TTL in milliseconds.
+     * @returns Resolves after the TTL is updated.
+     */
+    expire(key: string, ttlMs: number): Promise<void>;
+    /**
+     * Add a member to a sorted set with the given score.
+     *
+     * @param key - Sorted-set key.
+     * @param score - Score to associate with the member.
+     * @param member - Member identifier.
+     * @returns Resolves when the member is added.
+     */
+    zAdd(key: string, score: number, member: string): Promise<void>;
+    /**
+     * Remove sorted-set members with scores in the given range.
+     *
+     * @param key - Sorted-set key.
+     * @param min - Minimum score (inclusive).
+     * @param max - Maximum score (inclusive).
+     * @returns Resolves when the range is removed.
+     */
+    zRemRangeByScore(key: string, min: number, max: number): Promise<void>;
+    /**
+     * Count members in a sorted set.
+     *
+     * @param key - Sorted-set key.
+     * @returns Number of members in the set.
+     */
+    zCard(key: string): Promise<number>;
+    /**
+     * Read sorted-set members in a score range.
+     *
+     * @param key - Sorted-set key.
+     * @param min - Minimum score (inclusive).
+     * @param max - Maximum score (inclusive).
+     * @returns Ordered members in the score range.
+     */
+    zRangeByScore(key: string, min: number, max: number): Promise<string[]>;
+    /**
+     * Atomically consume a fixed-window counter via Lua.
+     *
+     * @param key - Storage key to consume.
+     * @param _limit - Limit (unused by the script).
+     * @param windowMs - Window size in milliseconds.
+     * @param _nowMs - Current time (unused by the script).
+     * @returns Fixed-window consume result.
+     */
+    consumeFixedWindow(key: string, _limit: number, windowMs: number, _nowMs: number): Promise<FixedWindowConsumeResult>;
+    /**
+     * Atomically consume a sliding-window log via Lua.
+     *
+     * @param key - Storage key to consume.
+     * @param limit - Request limit for the window.
+     * @param windowMs - Window size in milliseconds.
+     * @param nowMs - Current timestamp in milliseconds.
+     * @param member - Member identifier for this request.
+     * @returns Sliding-window consume result.
+     */
+    consumeSlidingWindowLog(key: string, limit: number, windowMs: number, nowMs: number, member: string): Promise<SlidingWindowConsumeResult>;
+    /**
+     * Delete keys with the given prefix.
+     *
+     * @param prefix - Prefix to match.
+     * @returns Resolves after matching keys are deleted.
+     */
+    deleteByPrefix(prefix: string): Promise<void>;
+    /**
+     * Delete keys matching a glob pattern using SCAN to avoid blocking Redis.
+     *
+     * @param pattern - Glob pattern to match keys against.
+     * @returns Resolves after matching keys are deleted.
+     */
+    deleteByPattern(pattern: string): Promise<void>;
+    /**
+     * List keys that match a prefix using SCAN.
+     *
+     * @param prefix - Prefix to match.
+     * @returns Matching keys.
+     */
+    keysByPrefix(prefix: string): Promise<string[]>;
+}