redis-abstraction 0.0.2 → 1.0.5

package/README.md

@@ -4,7 +4,7 @@ A Redis client pool with abstraction to different Redis libraries.
 This package helps to create redis connections in a connection pool fashion, ideally redis is single threaded so multiple connection or a connection pool for simple commands may not make sense, but there are some conditions in which connection pool makes sense like blocking commands, pub-sub commands etc apart form these cases there are also some fringe cases where if you have a simple command with a lot of data to be serialized on wire/network here multiple connections make sense as redis execution is single threaded but its I/O stack is multi so another command which has relatively small data to be serialized on wire gets stuck behind this big network transfer command ahead of it, It can take advantage of another connection where there is not que before-hand and get executed first in such a case connection pools make sense. This package also supports cluster mode connections.
 
 Working of this package is simple it exposes an interface [i-redis-client-pool](https://github.com/LRagji/redis-abstraction/blob/main/source/i-redis-client-pool.ts) which has following methods 
-1. `acquire(token: string): Promise<void>` : Responsibile to acquire a connection to redis server in-reference to the unique token provided.
+1. `acquire(token: string): Promise<void>` : Responsible to acquire a connection to redis server in-reference to the unique token provided.
 2. `run(token: string, commandArgs: string[]): Promise<any>` : Responsible to run a redis command in-reference to the unique token acquired before.
 3. `release(token: string): Promise<void>` : Responsible to release the acquired connection back into connection pool in-reference to the unique token acquired before.
 
@@ -31,10 +31,19 @@ Currently this package only supports ioredis as underneath client library, but i
 ### Non Cluster Initialization
 
 ```javascript
+//Function which can decompose the connection string into different components like hostname,password etc.
+function parseRedisConnectionString(connectionString) {
+    //Used to parse the connection string and return components of the same 
+    //Refer:ioredis/built/utils/index.js parseURL function for more details
+    //This is just a mock implementation, you can enhance it as per your needs.
+    return {
+        password: ""
+    };
+}
 //Define the redis connection string
 const singleNodeRedisConnectionString = 'rediss://redis.my-service.com';
 //Create a injector function for creating redis connection instance.
-const connectionInjector = () => IORedisClientPool.IORedisClientClusterFactory([singleNodeRedisConnectionString]);
+const connectionInjector = () => IORedisClientPool.IORedisClientClusterFactory([singleNodeRedisConnectionString], Redis, Cluster, parseRedisConnectionString);
 //Initialize the pool
 const pool = new IORedisClientPool(connectionInjector);
 
@@ -52,7 +61,8 @@ main(pool)
 const clusteredRedisConnectionStringPrimary = 'rediss://redis.my-service.com';
 const clusteredRedisConnectionStringSecondary = 'rediss://redis.my-service.com' || clusteredRedisConnectionStringPrimary; //Secondary is optional if not present pass in primary connection.
 //Create a injector function for creating redis connection instance.
-const connectionInjector = () => IORedisClientPool.IORedisClientClusterFactory([clusteredRedisConnectionStringPrimary,clusteredRedisConnectionStringSecondary]);//Passing more than one connection string indicates its a cluster setup.
+//Passing more than one connection string indicates its a cluster setup.
+const connectionInjector = () => IORedisClientPool.IORedisClientClusterFactory([clusteredRedisConnectionStringPrimary,clusteredRedisConnectionStringSecondary], Redis, Cluster, parseRedisConnectionString);
 //Initialize the pool
 const pool = new IORedisClientPool(connectionInjector);
 
@@ -93,4 +103,4 @@ main(pool)
 
 ## License
 
-This project is contrubution to public domain and completely free for use, view [LICENSE.md](/license.md) file for details.
+This project is contribution to public domain and completely free for use, view [LICENSE.md](/license.md) file for details.

package/index.d.ts

@@ -1,2 +1,5 @@
 export { IRedisClientPool } from './i-redis-client-pool';
 export { IORedisClientPool } from './ioredis-client-pool';
+export { TIORedisCommonCommands } from './t-ioredis-common-commands';
+export { RedisClientPool } from './redis-client-pool';
+export { TRedisCommonCommands } from './t-redis-common-commands';

package/index.js

@@ -1,5 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IORedisClientPool = void 0;
+exports.RedisClientPool = exports.IORedisClientPool = void 0;
+//Implemented Class for IORedis
 var ioredis_client_pool_1 = require("./ioredis-client-pool");
 Object.defineProperty(exports, "IORedisClientPool", { enumerable: true, get: function () { return ioredis_client_pool_1.IORedisClientPool; } });
+//Implemented Class for NodeRedis
+var redis_client_pool_1 = require("./redis-client-pool");
+Object.defineProperty(exports, "RedisClientPool", { enumerable: true, get: function () { return redis_client_pool_1.RedisClientPool; } });

package/ioredis-client-pool.d.ts

@@ -1,11 +1,12 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { IRedisClientPool } from "./i-redis-client-pool";
 import crypto from 'node:crypto';
 import fs from 'node:fs';
-import Redis, { Cluster } from 'ioredis';
-export declare type RedisConnection = Cluster | Redis;
-export declare class IORedisClientPool implements IRedisClientPool {
+import { IRedisClientPool } from "./i-redis-client-pool";
+import { TIORedisCommonCommands } from "./t-ioredis-common-commands";
+/**
+ * A Redis Client Pool implementation using ioredis library
+ * @template redisConnectionType Type of the ioredis connection (Redis or Cluster)
+ */
+export declare class IORedisClientPool<redisConnectionType extends TIORedisCommonCommands> implements IRedisClientPool {
     private readonly nodeFSModule;
     private readonly nodeCryptoModule;
     private poolRedisClients;
@@ -14,13 +15,13 @@ export declare class IORedisClientPool implements IRedisClientPool {
     private redisConnectionCreator;
     private idlePoolSize;
     private totalConnectionCounter;
-    constructor(redisConnectionCreator: () => RedisConnection, idlePoolSize?: number, nodeFSModule?: typeof fs, nodeCryptoModule?: typeof crypto);
+    constructor(redisConnectionCreator: () => redisConnectionType, idlePoolSize?: number, nodeFSModule?: typeof fs, nodeCryptoModule?: typeof crypto);
     generateUniqueToken(prefix: string): string;
     shutdown(): Promise<void>;
     acquire(token: string): Promise<void>;
     release(token: string): Promise<void>;
-    run(token: string, commandArgs: any): Promise<unknown>;
-    pipeline(token: string, commands: string[][], transaction?: boolean): Promise<unknown[] | undefined>;
+    run(token: string, commandArgs: any): Promise<any>;
+    pipeline(token: string, commands: string[][], transaction?: boolean): Promise<any[]>;
     script(token: string, filePath: string, keys: string[], args: any[]): Promise<any>;
     info(): {
         "Idle Size": number;
@@ -29,5 +30,5 @@ export declare class IORedisClientPool implements IRedisClientPool {
         "Peak Connections": number;
     };
     private MD5Hash;
-    static IORedisClientClusterFactory(connectionDetails: string[], instanceInjection?: <T>(c: new (...args: any) => T, args: any[]) => T): RedisConnection;
+    static IORedisClientClusterFactory(connectionDetails: string[], redisClass: new (...args: any) => TIORedisCommonCommands, clusterClass: new (...args: any) => TIORedisCommonCommands, parseURLFunction: (url: string) => Record<string, any>, instanceInjection?: <T>(c: new (...args: any) => T, args: any[]) => T): TIORedisCommonCommands;
 }

package/ioredis-client-pool.js

@@ -1,27 +1,4 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -38,9 +15,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IORedisClientPool = void 0;
 const node_crypto_1 = __importDefault(require("node:crypto"));
 const node_fs_1 = __importDefault(require("node:fs"));
-const ioredis_1 = __importStar(require("ioredis"));
-const utils_1 = require("ioredis/built/utils");
 function createInstance(c, args = []) { return new c(...args); }
+/**
+ * A Redis Client Pool implementation using ioredis library
+ * @template redisConnectionType Type of the ioredis connection (Redis or Cluster)
+ */
 class IORedisClientPool {
     constructor(redisConnectionCreator, idlePoolSize = 6, nodeFSModule = node_fs_1.default, nodeCryptoModule = node_crypto_1.default) {
         this.nodeFSModule = nodeFSModule;
@@ -99,14 +78,15 @@ class IORedisClientPool {
             return yield redisClient.call(commandArgs.shift(), ...commandArgs);
         });
     }
-    pipeline(token, commands, transaction = true) {
-        return __awaiter(this, void 0, void 0, function* () {
+    pipeline(token_1, commands_1) {
+        return __awaiter(this, arguments, void 0, function* (token, commands, transaction = true) {
+            var _a;
             const redisClient = this.activeRedisClients.get(token);
             if (redisClient == undefined) {
                 throw new Error("Please acquire a client with proper token");
             }
-            const result = transaction === true ? yield redisClient.multi(commands).exec() : yield redisClient.pipeline(commands).exec();
-            return result === null || result === void 0 ? void 0 : result.map(r => {
+            const result = (_a = (transaction === true ? yield redisClient.multi(commands).exec() : yield redisClient.pipeline(commands).exec())) !== null && _a !== void 0 ? _a : [];
+            return result.map(r => {
                 let err = r[0];
                 if (err != null) {
                     throw err;
@@ -122,14 +102,12 @@ class IORedisClientPool {
                 throw new Error("Please acquire a client with proper token");
             }
             let command = this.filenameToCommand.get(filePath);
-            // @ts-ignore
             if (command == null || redisClient[command] == null) {
                 const contents = yield this.nodeFSModule.promises.readFile(filePath, { encoding: "utf-8" });
                 command = this.MD5Hash(contents);
                 redisClient.defineCommand(command, { lua: contents });
                 this.filenameToCommand.set(filePath, command);
             }
-            // @ts-ignore
             return yield redisClient[command](keys.length, keys, args);
         });
     }
@@ -146,13 +124,13 @@ class IORedisClientPool {
     MD5Hash(value) {
         return this.nodeCryptoModule.createHash('md5').update(value).digest('hex');
     }
-    static IORedisClientClusterFactory(connectionDetails, instanceInjection = createInstance) {
+    static IORedisClientClusterFactory(connectionDetails, redisClass, clusterClass, parseURLFunction, instanceInjection = createInstance) {
         const distinctConnections = new Set(connectionDetails);
         if (distinctConnections.size === 0) {
-            throw new Error("Inncorrect or Invalid Connection details, cannot be empty");
+            throw new Error("Incorrect or Invalid Connection details, cannot be empty");
         }
         if (connectionDetails.length > distinctConnections.size || distinctConnections.size > 1) {
-            const parsedRedisURl = (0, utils_1.parseURL)(connectionDetails[0]); //Assuming all have same password(they should have finally its a cluster)
+            const parsedRedisURl = parseURLFunction(connectionDetails[0]); //Assuming all have same password(they should have finally its a cluster)
             const awsElasticCacheOptions = {
                 dnsLookup: (address, callback) => callback(null, address),
                 redisOptions: {
@@ -161,10 +139,10 @@ class IORedisClientPool {
                     maxRedirections: 32
                 },
             };
-            return instanceInjection(ioredis_1.Cluster, [Array.from(distinctConnections.values()), awsElasticCacheOptions]);
+            return instanceInjection(clusterClass, [Array.from(distinctConnections.values()), awsElasticCacheOptions]);
         }
         else {
-            return instanceInjection(ioredis_1.default, [connectionDetails[0]]);
+            return instanceInjection(redisClass, [connectionDetails[0]]);
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redis-abstraction",
-  "version": "0.0.2",
+  "version": "1.0.5",
   "description": "A Redis client pool with abstraction to different Redis libraries.",
   "main": "index.js",
   "scripts": {
@@ -39,18 +39,15 @@
     "Laukik"
   ],
   "devDependencies": {
-    "@types/mocha": "^9.1.1",
-    "@types/sinon": "^10.0.15",
-    "cross-env": "^7.0.3",
-    "mocha": "^9.2.2",
-    "nyc": "^15.1.0",
+    "@types/mocha": "^10.0.10",
+    "@types/sinon": "^21.0.0",
+    "cross-env": "^10.1.0",
+    "mocha": "^11.3.0",
+    "nyc": "^17.1.0",
     "run-script-os": "^1.1.6",
-    "sinon": "^15.2.0",
-    "ts-node": "^10.7.0",
-    "typedoc": "^0.22.14",
-    "typescript": "^4.6.3"
-  },
-  "dependencies": {
-    "ioredis": "^5.3.2"
+    "sinon": "^21.0.1",
+    "ts-node": "^10.9.2",
+    "typedoc": "^0.28.16",
+    "typescript": "^5.9.3"
   }
 }

package/redis-client-pool.d.ts

@@ -0,0 +1,22 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import { IRedisClientPool } from "./i-redis-client-pool";
+import { TRedisCommonCommands } from './t-redis-common-commands';
+export declare class RedisClientPool<redisConnectionType extends TRedisCommonCommands> implements IRedisClientPool {
+    private readonly redisConnectionCreator;
+    private idlePoolSize;
+    private readonly nodeFSModule;
+    private readonly nodeCryptoModule;
+    private totalConnectionCounter;
+    private poolRedisClients;
+    private activeRedisClients;
+    constructor(redisConnectionCreator: () => redisConnectionType, idlePoolSize?: number, nodeFSModule?: typeof fs, nodeCryptoModule?: typeof crypto);
+    initialize(): Promise<void>;
+    acquire(token: string): Promise<void>;
+    release(token: string): Promise<void>;
+    shutdown(): Promise<void>;
+    run(token: string, commandArgs: string[]): Promise<any>;
+    pipeline(token: string, commands: string[][], transaction: boolean): Promise<any>;
+    script(token: string, filePath: string, keys: string[], args: string[]): Promise<any>;
+    generateUniqueToken(prefix: string): string;
+}

package/redis-client-pool.js

@@ -0,0 +1,101 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisClientPool = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+class RedisClientPool {
+    constructor(redisConnectionCreator, idlePoolSize = 6, nodeFSModule = node_fs_1.default, nodeCryptoModule = node_crypto_1.default) {
+        this.redisConnectionCreator = redisConnectionCreator;
+        this.idlePoolSize = idlePoolSize;
+        this.nodeFSModule = nodeFSModule;
+        this.nodeCryptoModule = nodeCryptoModule;
+        this.totalConnectionCounter = 0;
+        this.poolRedisClients = Array.from({ length: idlePoolSize }, (_) => redisConnectionCreator());
+        this.totalConnectionCounter += idlePoolSize;
+        this.activeRedisClients = new Map();
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const initHandles = this.poolRedisClients.map((_) => __awaiter(this, void 0, void 0, function* () { yield _.connect(); }));
+            yield Promise.allSettled(initHandles);
+        });
+    }
+    acquire(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.activeRedisClients.has(token)) {
+                const availableClient = this.poolRedisClients.pop() || (() => { this.totalConnectionCounter += 1; return this.redisConnectionCreator(); })();
+                this.activeRedisClients.set(token, availableClient);
+            }
+        });
+    }
+    release(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const releasedClient = this.activeRedisClients.get(token);
+            if (releasedClient == undefined) {
+                return;
+            }
+            this.activeRedisClients.delete(token);
+            if (this.poolRedisClients.length < this.idlePoolSize) {
+                this.poolRedisClients.push(releasedClient);
+            }
+            else {
+                yield releasedClient.close();
+                releasedClient.destroy();
+            }
+        });
+    }
+    shutdown() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const waitHandles = [...this.poolRedisClients, ...Array.from(this.activeRedisClients.values())]
+                .map((_) => __awaiter(this, void 0, void 0, function* () { yield _.close(); _.destroy(); }));
+            yield Promise.allSettled(waitHandles);
+            this.poolRedisClients = [];
+            this.activeRedisClients.clear();
+            this.totalConnectionCounter = 0;
+        });
+    }
+    run(token, commandArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const redisClient = this.activeRedisClients.get(token);
+            if (redisClient == undefined) {
+                throw new Error("Please acquire a client with proper token");
+            }
+            return yield redisClient.sendCommand(commandArgs);
+        });
+    }
+    pipeline(token, commands, transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const redisClient = this.activeRedisClients.get(token);
+            if (redisClient == undefined) {
+                throw new Error("Please acquire a client with proper token");
+            }
+            const transactionContext = redisClient.multi();
+            for (const cmd of commands) {
+                const commandName = ((_a = cmd.shift()) !== null && _a !== void 0 ? _a : "").toLowerCase();
+                // @ts-ignore
+                transactionContext[commandName](...cmd);
+            }
+            return transaction === true ? yield transactionContext.exec() : yield transactionContext.execAsPipeline();
+        });
+    }
+    script(token, filePath, keys, args) {
+        throw new Error("Method not implemented.");
+    }
+    generateUniqueToken(prefix) {
+        return `${prefix}-${this.nodeCryptoModule.randomUUID()}`;
+    }
+}
+exports.RedisClientPool = RedisClientPool;

package/t-ioredis-common-commands.d.ts

@@ -0,0 +1,20 @@
+interface IIORedisRequiredCommands {
+    quit(): Promise<void>;
+    disconnect(): void;
+    multi(commands: string[][]): this;
+    pipeline(commands: string[][]): this;
+    exec(): Promise<(Error | null | any)[] | null>;
+    defineCommand(commandName: string, definition: {
+        lua: string;
+    }): void;
+    call(commandName: string, ...args: any[]): Promise<any>;
+}
+type TExclusion<T> = {
+    [key in Exclude<string, keyof T>]: (argsLength: number, ...args: any[]) => Promise<any>;
+};
+/**
+ * Type representing common commands for ioredis clients
+ * This interface abstracts the common methods used in both Redis and Cluster clients.
+ */
+export type TIORedisCommonCommands = TExclusion<IIORedisRequiredCommands> & IIORedisRequiredCommands;
+export {};

package/t-ioredis-common-commands.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/t-redis-common-commands.d.ts

@@ -0,0 +1,18 @@
+interface IRedisRequiredCommands {
+    close(): Promise<void>;
+    connect(): Promise<void>;
+    destroy(): void;
+    multi(): this;
+    exec(): Promise<(Error | null | any)[] | null>;
+    execAsPipeline(): Promise<(Error | null | any)[] | null>;
+    sendCommand(args: any[]): Promise<any>;
+}
+type TExclusion<T> = {
+    [key in Exclude<string, keyof T>]: (argsLength: number, ...args: any[]) => Promise<any>;
+};
+/**
+ * Type representing common commands for node-redis clients
+ * This interface abstracts the common methods used in both Redis and Cluster clients.
+ */
+export type TRedisCommonCommands = TExclusion<IRedisRequiredCommands> & IRedisRequiredCommands;
+export {};

package/t-redis-common-commands.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });