@commandkit/redis 0.1.1 → 1.2.0-rc.1

package/README.md

@@ -31,4 +31,143 @@ async function getCachedData() {
 
   return data;
 }
+```
+
+## Manual configuration
+
+If you want to configure the Redis client manually, you can do so by not registering this plugin and instead updating the cache provider at runtime:
+
+```ts
+import { setCacheProvider } from '@commandkit/cache';
+import { RedisCacheProvider } from '@commandkit/redis';
+import { Redis } from 'ioredis';
+
+// configure the redis client as needed
+const redis = new Redis();
+const redisProvider = new RedisCacheProvider(redis);
+
+setCacheProvider(redisProvider)
+```
+
+## Redis Mutex Storage
+
+This package also provides a Redis-based mutex storage implementation for distributed locking:
+
+```ts
+import { createMutex } from 'commandkit/mutex';
+import { RedisMutexStorage } from '@commandkit/redis';
+import { Redis } from 'ioredis';
+
+// Create Redis client
+const redis = new Redis();
+
+// Create Redis-based mutex storage
+const redisMutexStorage = new RedisMutexStorage(redis);
+
+// Create mutex with Redis storage
+const mutex = createMutex({
+  timeout: 30000,
+  storage: redisMutexStorage,
+});
+
+// Use the mutex for distributed locking
+const result = await mutex.withLock('shared-resource', async () => {
+  // This code runs with exclusive access across all instances
+  return await updateSharedResource();
+});
+```
+
+### Redis Mutex Features
+
+- **Distributed Locking**: Works across multiple application instances
+- **Automatic Expiration**: Locks automatically expire to prevent deadlocks
+- **Abort Signal Support**: Can be cancelled using AbortSignal
+- **Atomic Operations**: Uses Lua scripts for atomic lock operations
+- **Lock Extension**: Extend lock timeouts if needed
+- **Force Release**: Emergency release of locks (use with caution)
+
+### Advanced Mutex Usage
+
+```ts
+import { RedisMutexStorage } from '@commandkit/redis';
+
+const redisStorage = new RedisMutexStorage(redis);
+
+// Get detailed lock information
+const lockInfo = await redisStorage.getLockInfo('my-resource');
+console.log(`Locked: ${lockInfo.locked}, TTL: ${lockInfo.ttl}ms`);
+
+// Extend a lock
+const extended = await redisStorage.extendLock('my-resource', 60000);
+if (extended) {
+  console.log('Lock extended by 60 seconds');
+}
+
+// Force release a lock (emergency use only)
+await redisStorage.forceRelease('my-resource');
+```
+
+## Redis Semaphore Storage
+
+This package also provides a Redis-based semaphore storage implementation for distributed concurrency control:
+
+```ts
+import { createSemaphore } from 'commandkit/semaphore';
+import { RedisSemaphoreStorage } from '@commandkit/redis';
+import { Redis } from 'ioredis';
+
+// Create Redis client
+const redis = new Redis();
+
+// Create Redis-based semaphore storage
+const redisSemaphoreStorage = new RedisSemaphoreStorage(redis);
+
+// Create semaphore with Redis storage
+const semaphore = createSemaphore({
+  permits: 5,
+  timeout: 30000,
+  storage: redisSemaphoreStorage,
+});
+
+// Use the semaphore for distributed concurrency control
+const result = await semaphore.withPermit('database-connection', async () => {
+  // This code runs with limited concurrency across all instances
+  return await executeDatabaseQuery();
+});
+```
+
+### Redis Semaphore Features
+
+- **Distributed Concurrency Control**: Works across multiple application instances
+- **Automatic Initialization**: Semaphores are automatically initialized when first used
+- **Abort Signal Support**: Can be cancelled using AbortSignal
+- **Atomic Operations**: Uses Lua scripts for atomic permit operations
+- **Dynamic Permit Management**: Increase or decrease permits at runtime
+- **Semaphore Information**: Get detailed information about permit usage
+
+### Advanced Semaphore Usage
+
+```ts
+import { RedisSemaphoreStorage } from '@commandkit/redis';
+
+const redisStorage = new RedisSemaphoreStorage(redis);
+
+// Get detailed semaphore information
+const info = await redisStorage.getSemaphoreInfo('database');
+console.log(`Total: ${info.total}, Available: ${info.available}, Acquired: ${info.acquired}`);
+
+// Initialize a semaphore with specific permits
+await redisStorage.initialize('api-endpoint', 10);
+
+// Increase permits dynamically
+await redisStorage.increasePermits('database', 5);
+
+// Decrease permits dynamically
+await redisStorage.decreasePermits('api-endpoint', 2);
+
+// Reset semaphore to initial state
+await redisStorage.reset('database');
+
+// Clear semaphore completely
+await redisStorage.clear('old-semaphore');
 ```

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { Redis, type RedisOptions } from 'ioredis';
-import { CacheProvider, CommandKitPluginRuntime, RuntimePlugin } from 'commandkit';
+import { CommandKitPluginRuntime, RuntimePlugin } from 'commandkit';
+import { CacheProvider, CacheEntry } from '@commandkit/cache';
 export type Awaitable<T> = T | Promise<T>;
 export type SerializeFunction = (value: any) => Awaitable<string>;
 export type DeserializeFunction = (value: string) => Awaitable<any>;
@@ -12,7 +13,7 @@ export type DeserializeFunction = (value: string) => Awaitable<any>;
  * });
  */
 export declare class RedisCache extends CacheProvider {
-    protected redis: Redis;
+    redis: Redis;
     /**
      * Serialize function used to serialize values before storing them in the cache.
      * By default, it uses `JSON.stringify`.
@@ -42,7 +43,7 @@ export declare class RedisCache extends CacheProvider {
      * @param key The key to retrieve the value for.
      * @returns The value stored in the cache, or `undefined` if it does not exist.
      */
-    get<T>(key: string): Promise<T | undefined>;
+    get<T>(key: string): Promise<CacheEntry<T> | undefined>;
     /**
      * Store a value in the cache.
      * @param key The key to store the value under.
@@ -76,4 +77,13 @@ export declare class RedisPlugin extends RuntimePlugin<RedisOptions> {
     readonly name = "RedisPlugin";
     activate(ctx: CommandKitPluginRuntime): Promise<void>;
 }
+/**
+ * Create a new Redis plugin instance.
+ * @param options The options to configure the Redis client.
+ * @returns The created Redis plugin instance.
+ */
 export declare function redis(options?: RedisOptions): RedisPlugin;
+export * from './ratelimit-storage';
+export * from './mutex-storage';
+export * from './semaphore-storage';
+export { RedisCache as RedisCacheProvider };

package/dist/index.js

@@ -1,9 +1,24 @@
 "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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisPlugin = exports.RedisCache = void 0;
+exports.RedisCacheProvider = exports.RedisPlugin = exports.RedisCache = void 0;
 exports.redis = redis;
 const ioredis_1 = require("ioredis");
 const commandkit_1 = require("commandkit");
+const cache_1 = require("@commandkit/cache");
 /**
  * A cache provider that uses Redis as the cache store.
  * @example const redisCache = new RedisCache();
@@ -12,7 +27,7 @@ const commandkit_1 = require("commandkit");
  *  cacheProvider: redisCache,
  * });
  */
-class RedisCache extends commandkit_1.CacheProvider {
+class RedisCache extends cache_1.CacheProvider {
     constructor(redis) {
         super();
         if (redis instanceof ioredis_1.Redis) {
@@ -34,7 +49,12 @@ class RedisCache extends commandkit_1.CacheProvider {
         if (value === null) {
             return undefined;
         }
-        return JSON.parse(value);
+        const entry = this.deserialize(value);
+        if (entry.ttl && Date.now() > entry.ttl) {
+            await this.delete(key);
+            return undefined;
+        }
+        return entry;
     }
     /**
      * Store a value in the cache.
@@ -43,12 +63,17 @@ class RedisCache extends commandkit_1.CacheProvider {
      * @param ttl The time-to-live for the cache entry in milliseconds.
      */
     async set(key, value, ttl) {
-        const serialized = await this.serialize(value);
+        const entry = {
+            value,
+            ttl: ttl != null ? Date.now() + ttl : undefined,
+        };
+        const serialized = this.serialize(entry);
+        const finalValue = serialized instanceof Promise ? await serialized : serialized;
         if (typeof ttl === 'number') {
-            await this.redis.set(key, serialized, 'PX', ttl);
+            await this.redis.set(key, finalValue, 'PX', ttl);
         }
         else {
-            await this.redis.set(key, serialized);
+            await this.redis.set(key, finalValue);
         }
     }
     /**
@@ -82,17 +107,26 @@ class RedisCache extends commandkit_1.CacheProvider {
     }
 }
 exports.RedisCache = RedisCache;
+exports.RedisCacheProvider = RedisCache;
 class RedisPlugin extends commandkit_1.RuntimePlugin {
     constructor() {
         super(...arguments);
         this.name = 'RedisPlugin';
     }
     async activate(ctx) {
-        ctx.commandkit.setCacheProvider(new RedisCache(this.options));
+        (0, cache_1.setCacheProvider)(new RedisCache(this.options));
     }
 }
 exports.RedisPlugin = RedisPlugin;
+/**
+ * Create a new Redis plugin instance.
+ * @param options The options to configure the Redis client.
+ * @returns The created Redis plugin instance.
+ */
 function redis(options) {
     return new RedisPlugin(options ?? {});
 }
-//# sourceMappingURL=data:application/json;base64,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
+__exportStar(require("./ratelimit-storage"), exports);
+__exportStar(require("./mutex-storage"), exports);
+__exportStar(require("./semaphore-storage"), exports);
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mutex-storage.d.ts

@@ -0,0 +1,35 @@
+import type { MutexStorage } from 'commandkit/mutex';
+import Redis from 'ioredis';
+export declare class RedisMutexStorage implements MutexStorage {
+    private readonly redis;
+    private readonly lockPrefix;
+    private readonly defaultTimeout;
+    constructor(redis: Redis);
+    acquire(key: string, timeout?: number, signal?: AbortSignal): Promise<boolean>;
+    release(key: string): Promise<void>;
+    isLocked(key: string): Promise<boolean>;
+    /**
+     * Gets information about a lock including its TTL
+     * @param key - The lock key
+     * @returns Object containing lock information
+     */
+    getLockInfo(key: string): Promise<{
+        locked: boolean;
+        ttl: number;
+        value?: string;
+    }>;
+    /**
+     * Force releases a lock (use with caution)
+     * @param key - The lock key
+     */
+    forceRelease(key: string): Promise<void>;
+    /**
+     * Extends the lock timeout
+     * @param key - The lock key
+     * @param additionalTime - Additional time in milliseconds
+     * @returns True if lock was extended, false if lock doesn't exist
+     */
+    extendLock(key: string, additionalTime: number): Promise<boolean>;
+    private generateLockValue;
+    private delay;
+}

package/dist/mutex-storage.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisMutexStorage = void 0;
+class RedisMutexStorage {
+    constructor(redis) {
+        this.redis = redis;
+        this.lockPrefix = 'mutex:';
+        this.defaultTimeout = 30000; // 30 seconds
+    }
+    async acquire(key, timeout = this.defaultTimeout, signal) {
+        const lockKey = this.lockPrefix + key;
+        const lockValue = this.generateLockValue();
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            // Check if aborted
+            if (signal?.aborted) {
+                throw new Error('Lock acquisition was aborted');
+            }
+            // Try to acquire the lock using SET with NX (only if not exists) and EX (expiration)
+            const result = await this.redis.set(lockKey, lockValue, 'EX', Math.ceil(timeout / 1000), // Convert to seconds
+            'NX');
+            if (result === 'OK') {
+                return true;
+            }
+            // Wait a bit before trying again
+            await this.delay(10);
+        }
+        return false;
+    }
+    async release(key) {
+        const lockKey = this.lockPrefix + key;
+        // Simple delete - in a real scenario, you might want to check ownership
+        // but for simplicity, we'll just delete the key
+        await this.redis.del(lockKey);
+    }
+    async isLocked(key) {
+        const lockKey = this.lockPrefix + key;
+        const exists = await this.redis.exists(lockKey);
+        return exists === 1;
+    }
+    /**
+     * Gets information about a lock including its TTL
+     * @param key - The lock key
+     * @returns Object containing lock information
+     */
+    async getLockInfo(key) {
+        const lockKey = this.lockPrefix + key;
+        const exists = await this.redis.exists(lockKey);
+        if (exists === 0) {
+            return { locked: false, ttl: 0 };
+        }
+        const ttl = await this.redis.ttl(lockKey);
+        const value = await this.redis.get(lockKey);
+        return {
+            locked: true,
+            ttl: ttl > 0 ? ttl * 1000 : 0, // Convert to milliseconds
+            value: value || undefined,
+        };
+    }
+    /**
+     * Force releases a lock (use with caution)
+     * @param key - The lock key
+     */
+    async forceRelease(key) {
+        const lockKey = this.lockPrefix + key;
+        await this.redis.del(lockKey);
+    }
+    /**
+     * Extends the lock timeout
+     * @param key - The lock key
+     * @param additionalTime - Additional time in milliseconds
+     * @returns True if lock was extended, false if lock doesn't exist
+     */
+    async extendLock(key, additionalTime) {
+        const lockKey = this.lockPrefix + key;
+        const exists = await this.redis.exists(lockKey);
+        if (exists === 0) {
+            return false;
+        }
+        const result = await this.redis.expire(lockKey, Math.ceil(additionalTime / 1000));
+        return result === 1;
+    }
+    generateLockValue() {
+        return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+exports.RedisMutexStorage = RedisMutexStorage;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ratelimit-storage.d.ts

@@ -0,0 +1,9 @@
+import type { RateLimitStorage } from 'commandkit/ratelimit';
+import Redis from 'ioredis';
+export declare class RedisRateLimitStorage implements RateLimitStorage {
+    private readonly redis;
+    constructor(redis: Redis);
+    get(key: string): Promise<number>;
+    set(key: string, value: number): Promise<void>;
+    delete(key: string): Promise<void>;
+}

package/dist/ratelimit-storage.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisRateLimitStorage = void 0;
+class RedisRateLimitStorage {
+    constructor(redis) {
+        this.redis = redis;
+    }
+    async get(key) {
+        return Number(await this.redis.get(key)) || 0;
+    }
+    async set(key, value) {
+        await this.redis.set(key, value);
+    }
+    async delete(key) {
+        await this.redis.del(key);
+    }
+}
+exports.RedisRateLimitStorage = RedisRateLimitStorage;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmF0ZWxpbWl0LXN0b3JhZ2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvcmF0ZWxpbWl0LXN0b3JhZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBR0EsTUFBYSxxQkFBcUI7SUFDaEMsWUFBb0MsS0FBWTtRQUFaLFVBQUssR0FBTCxLQUFLLENBQU87SUFBRyxDQUFDO0lBRTdDLEtBQUssQ0FBQyxHQUFHLENBQUMsR0FBVztRQUMxQixPQUFPLE1BQU0sQ0FBQyxNQUFNLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ2hELENBQUM7SUFFTSxLQUFLLENBQUMsR0FBRyxDQUFDLEdBQVcsRUFBRSxLQUFhO1FBQ3pDLE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxDQUFDO0lBQ25DLENBQUM7SUFFTSxLQUFLLENBQUMsTUFBTSxDQUFDLEdBQVc7UUFDN0IsTUFBTSxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUM1QixDQUFDO0NBQ0Y7QUFkRCxzREFjQyJ9

package/dist/semaphore-storage.d.ts

@@ -0,0 +1,53 @@
+import type { SemaphoreStorage } from 'commandkit/semaphore';
+import Redis from 'ioredis';
+export declare class RedisSemaphoreStorage implements SemaphoreStorage {
+    private readonly redis;
+    private readonly semaphorePrefix;
+    private readonly defaultTimeout;
+    constructor(redis: Redis);
+    acquire(key: string, timeout?: number, signal?: AbortSignal): Promise<boolean>;
+    release(key: string): Promise<void>;
+    getAvailablePermits(key: string): Promise<number>;
+    getTotalPermits(key: string): Promise<number>;
+    /**
+     * Initializes a semaphore with the specified number of permits
+     * @param key - The semaphore key
+     * @param permits - The total number of permits to allocate
+     */
+    initialize(key: string, permits: number): Promise<void>;
+    /**
+     * Gets detailed information about a semaphore
+     * @param key - The semaphore key
+     * @returns Object containing semaphore information
+     */
+    getSemaphoreInfo(key: string): Promise<{
+        total: number;
+        available: number;
+        acquired: number;
+        initialized: boolean;
+    }>;
+    /**
+     * Resets a semaphore to its initial state
+     * @param key - The semaphore key
+     * @param permits - The number of permits to reset to (optional, uses current total if not provided)
+     */
+    reset(key: string, permits?: number): Promise<void>;
+    /**
+     * Increases the total number of permits for a semaphore
+     * @param key - The semaphore key
+     * @param additionalPermits - The number of additional permits to add
+     */
+    increasePermits(key: string, additionalPermits: number): Promise<void>;
+    /**
+     * Decreases the total number of permits for a semaphore
+     * @param key - The semaphore key
+     * @param permitsToRemove - The number of permits to remove
+     */
+    decreasePermits(key: string, permitsToRemove: number): Promise<void>;
+    /**
+     * Clears a semaphore completely
+     * @param key - The semaphore key
+     */
+    clear(key: string): Promise<void>;
+    private delay;
+}

package/dist/semaphore-storage.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisSemaphoreStorage = void 0;
+class RedisSemaphoreStorage {
+    constructor(redis) {
+        this.redis = redis;
+        this.semaphorePrefix = 'semaphore:';
+        this.defaultTimeout = 30000; // 30 seconds
+    }
+    async acquire(key, timeout = this.defaultTimeout, signal) {
+        const semaphoreKey = this.semaphorePrefix + key;
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            // Check if aborted
+            if (signal?.aborted) {
+                throw new Error('Permit acquisition was aborted');
+            }
+            // Check if semaphore exists, if not initialize it
+            const total = await this.redis.get(semaphoreKey + ':total');
+            if (!total) {
+                await this.initialize(key, 10); // Default 10 permits
+            }
+            // Try to decrement available permits
+            const available = await this.redis.get(semaphoreKey + ':available');
+            const availableCount = Number(available) || 0;
+            if (availableCount > 0) {
+                // Use DECR to atomically decrease the count
+                const newCount = await this.redis.decr(semaphoreKey + ':available');
+                if (newCount >= 0) {
+                    return true;
+                }
+                else {
+                    // If we went negative, increment back
+                    await this.redis.incr(semaphoreKey + ':available');
+                }
+            }
+            // Wait a bit before trying again
+            await this.delay(10);
+        }
+        return false;
+    }
+    async release(key) {
+        const semaphoreKey = this.semaphorePrefix + key;
+        // Get current values
+        const total = await this.redis.get(semaphoreKey + ':total');
+        const available = await this.redis.get(semaphoreKey + ':available');
+        const totalPermits = Number(total) || 0;
+        const availablePermits = Number(available) || 0;
+        // Only increment if we haven't reached the total
+        if (availablePermits < totalPermits) {
+            await this.redis.incr(semaphoreKey + ':available');
+        }
+    }
+    async getAvailablePermits(key) {
+        const semaphoreKey = this.semaphorePrefix + key;
+        const available = await this.redis.get(semaphoreKey + ':available');
+        return Number(available) || 0;
+    }
+    async getTotalPermits(key) {
+        const semaphoreKey = this.semaphorePrefix + key;
+        const total = await this.redis.get(semaphoreKey + ':total');
+        return Number(total) || 0;
+    }
+    /**
+     * Initializes a semaphore with the specified number of permits
+     * @param key - The semaphore key
+     * @param permits - The total number of permits to allocate
+     */
+    async initialize(key, permits) {
+        const semaphoreKey = this.semaphorePrefix + key;
+        await this.redis.set(semaphoreKey + ':total', permits);
+        await this.redis.set(semaphoreKey + ':available', permits);
+    }
+    /**
+     * Gets detailed information about a semaphore
+     * @param key - The semaphore key
+     * @returns Object containing semaphore information
+     */
+    async getSemaphoreInfo(key) {
+        const semaphoreKey = this.semaphorePrefix + key;
+        const total = await this.redis.get(semaphoreKey + ':total');
+        const available = await this.redis.get(semaphoreKey + ':available');
+        const totalPermits = Number(total) || 0;
+        const availablePermits = Number(available) || 0;
+        return {
+            total: totalPermits,
+            available: availablePermits,
+            acquired: totalPermits - availablePermits,
+            initialized: totalPermits > 0,
+        };
+    }
+    /**
+     * Resets a semaphore to its initial state
+     * @param key - The semaphore key
+     * @param permits - The number of permits to reset to (optional, uses current total if not provided)
+     */
+    async reset(key, permits) {
+        const semaphoreKey = this.semaphorePrefix + key;
+        if (permits !== undefined) {
+            await this.initialize(key, permits);
+        }
+        else {
+            const total = await this.getTotalPermits(key);
+            if (total > 0) {
+                await this.redis.set(semaphoreKey + ':available', total);
+            }
+        }
+    }
+    /**
+     * Increases the total number of permits for a semaphore
+     * @param key - The semaphore key
+     * @param additionalPermits - The number of additional permits to add
+     */
+    async increasePermits(key, additionalPermits) {
+        const semaphoreKey = this.semaphorePrefix + key;
+        const total = await this.redis.get(semaphoreKey + ':total');
+        const available = await this.redis.get(semaphoreKey + ':available');
+        const totalPermits = Number(total) || 0;
+        const availablePermits = Number(available) || 0;
+        const newTotal = totalPermits + additionalPermits;
+        const newAvailable = availablePermits + additionalPermits;
+        await this.redis.set(semaphoreKey + ':total', newTotal);
+        await this.redis.set(semaphoreKey + ':available', newAvailable);
+    }
+    /**
+     * Decreases the total number of permits for a semaphore
+     * @param key - The semaphore key
+     * @param permitsToRemove - The number of permits to remove
+     */
+    async decreasePermits(key, permitsToRemove) {
+        const semaphoreKey = this.semaphorePrefix + key;
+        const total = await this.redis.get(semaphoreKey + ':total');
+        const available = await this.redis.get(semaphoreKey + ':available');
+        const totalPermits = Number(total) || 0;
+        const availablePermits = Number(available) || 0;
+        const newTotal = Math.max(0, totalPermits - permitsToRemove);
+        const newAvailable = Math.max(0, availablePermits - permitsToRemove);
+        await this.redis.set(semaphoreKey + ':total', newTotal);
+        await this.redis.set(semaphoreKey + ':available', newAvailable);
+    }
+    /**
+     * Clears a semaphore completely
+     * @param key - The semaphore key
+     */
+    async clear(key) {
+        const semaphoreKey = this.semaphorePrefix + key;
+        await this.redis.del(semaphoreKey + ':total', semaphoreKey + ':available');
+    }
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+exports.RedisSemaphoreStorage = RedisSemaphoreStorage;
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@commandkit/redis",
-  "version": "0.1.1",
+  "version": "1.2.0-rc.1",
   "description": "Redis cache provider for CommandKit",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,7 +16,10 @@
     "redis",
     "cache"
   ],
-  "author": "twilight <hello@twlite.dev>",
+  "contributors": [
+    "Twilight <hello@twlite.dev>",
+    "Avraj <avraj@underctrl.io>"
+  ],
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/underctrl-io/commandkit/issues"
@@ -27,11 +30,12 @@
   },
   "devDependencies": {
     "typescript": "^5.7.3",
-    "tsconfig": "0.0.0",
-    "commandkit": "0.1.11"
+    "@commandkit/cache": "1.2.0-rc.1",
+    "commandkit": "1.2.0-rc.1",
+    "tsconfig": "0.0.0-rc.1"
   },
   "scripts": {
-    "lint": "tsc --noEmit",
+    "check-types": "tsc --noEmit",
     "build": "tsc"
   }
 }