@fsilva3/rate-limiter-redis 0.0.2 → 0.0.4

package/README.md

@@ -20,7 +20,7 @@ This library is useful for controlling the rate of requests from your applicatio
 To install the library, use npm:
 
 ```bash
-npm i --save rate-limiter-redis
+npm i -P @fsilva3/rate-limiter-redis
 ```
 
 ## Usage
@@ -35,25 +35,19 @@ const second = 1000
 // 60 tokens (requests) per minute
 const tbSettings: TokenBucketSettings = {
     capacity: 60,
-    interval: (60*second)
+    interval: (60*second),
+    key: 'my-rate-limiter-bucket' // optional key param to identify the bucket, otherwise it will use the default key
 }
 
 // Create a new token bucket instance
-const bucket = await TokenBucket.create(tbSettings); 
+const bucket = await TokenBucket.create(tbSettings);
 ```
 
 2. Take Method
 ```javascript
-// Takes the first token created in the bucket, if exists! Otherwise the token.value will return null
+// Takes the first token created in the bucket, if exists! Otherwise the token will be null
 const token = await bucket.take();
-
-const { 
-    value, // value is a hash string if a token is available, null otherwise
-    timestamp, // timestamp when the token was created
-    remaning // remaining is the number of tokens
-} = token;
-
-if (!value) {
+if (!token) {
     // re-queue the message, throw exception or return error
 }
 
@@ -71,9 +65,9 @@ const controler = new AbortController()
 const token = await bucket.delay(controler.signal);
 
 const { 
-    value,
-    timestamp,
-    remaning
+    value, // value is a hash string if a token is available, null otherwise
+    timestamp, // timestamp when the token was created
+    remaning // remaining is the number of tokens
 } = token;
 
 ...
@@ -89,6 +83,7 @@ REDIS_HOST=localhost
 REDIS_PORT=6379
 REDIS_USER=default
 REDIS_PASSWORD=mysecretpassword
+REDIS_DATABASE=0
 ```
 
 <br>

package/dist/bucket.d.ts

@@ -2,10 +2,12 @@ import { RedisClientType } from 'redis';
 export default class Bucket {
     private host;
     private port;
+    private database;
     protected client: RedisClientType;
     private maxConnectionRetries;
     private retryConnectionCount;
     constructor();
+    private validateEnvVariables;
     protected connect(): Promise<void>;
     protected quit(): Promise<void>;
     private onConnect;

package/dist/bucket.js

@@ -19,9 +19,19 @@ class Bucket {
     constructor() {
         this.host = '';
         this.port = 6379;
+        this.database = 0;
         this.maxConnectionRetries = 5;
         this.retryConnectionCount = 0;
-        const { REDIS_HOST, REDIS_USER, REDIS_PASSWORD, REDIS_PORT, } = process.env;
+        this.validateEnvVariables();
+        const { REDIS_HOST, REDIS_USER, REDIS_PASSWORD } = process.env;
+        this.host = REDIS_HOST;
+        const redisURL = `redis://${REDIS_USER}:${REDIS_PASSWORD}@${this.host}:${this.port}/${this.database}`;
+        this.client = redis_1.default.createClient({ url: redisURL, socket: { connectTimeout: 5000 } });
+        this.client.on('error', this.onError);
+        this.client.on('connect', this.onConnect);
+    }
+    validateEnvVariables() {
+        const { REDIS_HOST, REDIS_USER, REDIS_PASSWORD, REDIS_PORT, REDIS_DATABASE } = process.env;
         if (!REDIS_HOST) {
             throw new exception_1.RateLimiterException('REDIS_HOST environment is required');
         }
@@ -31,14 +41,20 @@ class Bucket {
         if (!REDIS_PASSWORD) {
             throw new exception_1.RateLimiterException('REDIS_PASSWORD environment is required');
         }
-        this.host = REDIS_HOST;
         if (REDIS_PORT && parseInt(REDIS_PORT) !== 6379) {
+            const port = parseInt(REDIS_PORT);
+            if (Number.isNaN(port)) {
+                throw new exception_1.RateLimiterException('REDIS_PORT wrongly set, please use a correct number');
+            }
             this.port = parseInt(REDIS_PORT);
         }
-        const redisURL = `redis://${REDIS_USER}:${REDIS_PASSWORD}@${this.host}:${this.port}`;
-        this.client = redis_1.default.createClient({ url: redisURL, socket: { connectTimeout: 5000 } });
-        this.client.on('error', this.onError);
-        this.client.on('connect', this.onConnect);
+        if (REDIS_DATABASE && parseInt(REDIS_DATABASE) !== 0) {
+            const database = parseInt(REDIS_DATABASE);
+            if (Number.isNaN(database)) {
+                throw new exception_1.RateLimiterException('REDIS_DATABASE wrongly set, please use a correct number');
+            }
+            this.database = parseInt(REDIS_DATABASE);
+        }
     }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {

package/dist/token-bucket.d.ts

@@ -1,8 +1,8 @@
 import { Token, TokenBucketSettings } from './types';
 import Bucket from './bucket';
 export default class TokenBucket extends Bucket {
-    private static readonly BUCKET_NAME;
     private readonly maxDelayRetryCount;
+    private bucketName;
     private capacity;
     private interval;
     private delayRetryCount;
@@ -11,7 +11,6 @@ export default class TokenBucket extends Bucket {
     constructor(settings: TokenBucketSettings);
     private generateToken;
     private getNextExecutionInMilliseconds;
-    private abortHandler;
     /**
      * Static method to create a new TokenBucket instance to ensure the bucket is refilled
      * @param {TokenBucketSettings} settings - The constructor settings for the Bucket
@@ -54,6 +53,7 @@ export default class TokenBucket extends Bucket {
      * @return {Promise<void>}
      */
     close(): Promise<void>;
+    isReady(): boolean;
     /**
      * Get the current total of tokens in the bucket
      * @return {Promise<number>}

package/dist/token-bucket.js

@@ -25,6 +25,7 @@ class TokenBucket extends bucket_1.default {
     constructor(settings) {
         super();
         this.maxDelayRetryCount = 5;
+        this.bucketName = 'rate-limiter-tokens';
         this.capacity = 0;
         this.interval = 0;
         this.delayRetryCount = 0;
@@ -32,6 +33,9 @@ class TokenBucket extends bucket_1.default {
         this.startTime = 0;
         this.capacity = settings.capacity;
         this.interval = settings.interval;
+        if (settings.key) {
+            this.bucketName = settings.key;
+        }
         this.startTime = Date.now();
         this.timer = setInterval(this.refill.bind(this), this.interval);
     }
@@ -43,11 +47,6 @@ class TokenBucket extends bucket_1.default {
         const nextExecution = this.interval - Math.ceil(elapsedTime % this.interval);
         return nextExecution;
     }
-    abortHandler() {
-        if (this.aborted) {
-            throw new Error('Operation aborted');
-        }
-    }
     /**
      * Static method to create a new TokenBucket instance to ensure the bucket is refilled
      * @param {TokenBucketSettings} settings - The constructor settings for the Bucket
@@ -84,17 +83,29 @@ class TokenBucket extends bucket_1.default {
                 if (context === null || context === void 0 ? void 0 : context.aborted) {
                     throw new Error('Operation aborted');
                 }
-                context === null || context === void 0 ? void 0 : context.addEventListener('abort', this.abortHandler);
-                const response = yield this.client.RPOP(TokenBucket.BUCKET_NAME);
-                if (!response) {
+                const timeoutAbortSignal = new Promise((_, reject) => {
+                    if (context) {
+                        context.addEventListener('abort', () => reject(new Error('Operation aborted')));
+                    }
+                });
+                const promises = Promise.all([
+                    this.client.RPOP(this.bucketName),
+                    this.getTotalTokens()
+                ]);
+                const responses = yield Promise.race([promises, timeoutAbortSignal]);
+                const responsesArray = responses;
+                const tokenResponse = responsesArray[0];
+                if (!tokenResponse) {
                     return null;
                 }
-                const token = JSON.parse(response);
-                token.remaining = yield this.getTotalTokens();
-                context === null || context === void 0 ? void 0 : context.removeEventListener('abort', this.abortHandler);
+                const token = JSON.parse(tokenResponse);
+                token.remaining = responsesArray[1];
                 return token;
             }
             catch (error) {
+                if (error instanceof Error && error.message === 'Operation aborted') {
+                    throw error;
+                }
                 throw new exception_1.RateLimiterException(`Error taking token from bucket | ${error}`);
             }
         });
@@ -137,7 +148,7 @@ class TokenBucket extends bucket_1.default {
                 if (!this.client.isReady) {
                     throw new exception_1.RateLimiterException('Redis client is not ready');
                 }
-                const countTokens = yield this.client.LLEN(TokenBucket.BUCKET_NAME);
+                const countTokens = yield this.client.LLEN(this.bucketName);
                 if (countTokens >= this.capacity) {
                     return;
                 }
@@ -149,7 +160,7 @@ class TokenBucket extends bucket_1.default {
                         timestamp: Date.now()
                     });
                 });
-                yield this.client.LPUSH(TokenBucket.BUCKET_NAME, tokens);
+                yield this.client.LPUSH(this.bucketName, tokens);
             }
             catch (error) {
                 throw new exception_1.RateLimiterException(`Error filling token bucket | ${error}`);
@@ -170,13 +181,16 @@ class TokenBucket extends bucket_1.default {
             console.log('Closed Token Bucket instance!');
         });
     }
+    isReady() {
+        return this.client.isReady;
+    }
     /**
      * Get the current total of tokens in the bucket
      * @return {Promise<number>}
      */
     getTotalTokens() {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.client.LLEN(TokenBucket.BUCKET_NAME);
+            return this.client.LLEN(this.bucketName);
         });
     }
     /**
@@ -185,9 +199,8 @@ class TokenBucket extends bucket_1.default {
      */
     clearTokens() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.client.LTRIM(TokenBucket.BUCKET_NAME, 1, 0);
+            yield this.client.LTRIM(this.bucketName, 1, 0);
         });
     }
 }
-TokenBucket.BUCKET_NAME = 'rate-limiter-tokens';
 exports.default = TokenBucket;

package/dist/types.d.ts

@@ -1,6 +1,13 @@
+/**
+ * @typedef {Object} TokenBucketSettings - creates a new type named 'TokenBucketSettings'
+ * @property {number} capacity - the total tokesn to be refilled in the bucket
+ * @property {number} interval - the time interval when it should refill the tokens in milliseconds
+ * @property {string?} key - an optional parameter to define a different bucket name key on redis list
+ */
 export type TokenBucketSettings = {
     capacity: number;
     interval: number;
+    key?: string;
 };
 export type Token = {
     value: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fsilva3/rate-limiter-redis",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "license": "MIT",
   "description": "A javascript library to rate limiter requests using different algorithms using Redis as shared state where you can sync the tokens between multiple services instances",
   "main": "./dist/index.js",