@creator.co/wapi 1.5.3 → 1.5.5

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@creator.co/wapi",
-    "version": "1.5.3",
+    "version": "1.5.5",
     "description": "",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",

package/dist/src/Cache/Redis.d.ts

@@ -1,4 +1,4 @@
-import { RedisClientType } from 'redis';
+import { RedisClientType, RedisClusterType } from 'redis';
 import { CacheConfig } from './types';
 /**
  * Represents a Redis cache connection class.
@@ -10,7 +10,13 @@ export default class Redis {
      * This property is used to create client.
      */
     private static ClientFactory;
-    static connection(config: CacheConfig<'redis'>): Promise<RedisClientType>;
+    /**
+     * A private static property that references the createCluster function.
+     * This property can be used to create clusters within the class.
+     */
+    private static ClusterFactory;
+    static connection(config: CacheConfig<'redis'>): Promise<RedisClientType | RedisClusterType>;
+    private static connectionFactory;
     /**
      * Establishes a connection to a Redis client based on the provided configuration
      * and holds it for reusability. If connection is detected closed, new connection is
@@ -18,5 +24,6 @@ export default class Redis {
      * @param {CacheConfig<'redis'>} config - The configuration object for connecting to the Redis client.
      * @returns {Promise<RedisClientType>} A promise that resolves to the Redis client connection.
      */
-    private static redisConnection;
+    private static redisClientConnection;
+    private static redisClusterConnection;
 }

package/dist/src/Cache/Redis.js

@@ -58,6 +58,17 @@ var Redis = /** @class */ (function () {
     Redis.connection = function (config) {
         return _a.singleton.instance(config);
     };
+    Redis.connectionFactory = function (config) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                if (config.clusterMode)
+                    return [2 /*return*/, _a.redisClusterConnection(config)];
+                else
+                    return [2 /*return*/, _a.redisClientConnection(config)];
+                return [2 /*return*/];
+            });
+        });
+    };
     /**
      * Establishes a connection to a Redis client based on the provided configuration
      * and holds it for reusability. If connection is detected closed, new connection is
@@ -65,14 +76,45 @@ var Redis = /** @class */ (function () {
      * @param {CacheConfig<'redis'>} config - The configuration object for connecting to the Redis client.
      * @returns {Promise<RedisClientType>} A promise that resolves to the Redis client connection.
      */
-    Redis.redisConnection = function (config) {
+    Redis.redisClientConnection = function (config) {
+        return __awaiter(this, void 0, void 0, function () {
+            var connection;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        console.debug('Starting remote client cache connection');
+                        connection = _a.ClientFactory(__assign(__assign({ username: config.username }, (config.password ? { password: config.password } : {})), { disableOfflineQueue: true, socket: {
+                                host: config.hostname,
+                                tls: config.enableTLS,
+                                connectTimeout: 10000,
+                            } }));
+                        return [4 /*yield*/, connection.connect()];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/, connection];
+                }
+            });
+        });
+    };
+    Redis.redisClusterConnection = function (config) {
         return __awaiter(this, void 0, void 0, function () {
             var connection;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
-                        console.debug('Starting remote cache connection');
-                        connection = _a.ClientFactory(__assign(__assign({ username: config.username }, (config.password ? { password: config.password } : {})), { disableOfflineQueue: true, socket: __assign(__assign({ host: config.hostname }, (config.enableTLS ? { tls: true } : {})), { connectTimeout: 10000 }) }));
+                        console.debug('Starting remote cluster cache connection');
+                        connection = _a.ClusterFactory({
+                            defaults: __assign(__assign({ username: config.username }, (config.password ? { password: config.password } : {})), { socket: {
+                                    tls: config.enableTLS,
+                                    connectTimeout: 10000,
+                                } }),
+                            rootNodes: [
+                                {
+                                    url: "redis://".concat(config.username, ":").concat(config.username, "@").concat(config.hostname, ":6379"),
+                                    disableOfflineQueue: true,
+                                },
+                            ],
+                        });
                         return [4 /*yield*/, connection.connect()];
                     case 1:
                         _b.sent();
@@ -83,7 +125,7 @@ var Redis = /** @class */ (function () {
     };
     var _a;
     _a = Redis;
-    Redis.singleton = new AsyncSingleton_1.default(_a.redisConnection, function (c) { return __awaiter(void 0, void 0, void 0, function () { return __generator(_a, function (_b) {
+    Redis.singleton = new AsyncSingleton_1.default(_a.connectionFactory, function (c) { return __awaiter(void 0, void 0, void 0, function () { return __generator(_a, function (_b) {
         return [2 /*return*/, c.isOpen];
     }); }); });
     /**
@@ -91,6 +133,11 @@ var Redis = /** @class */ (function () {
      * This property is used to create client.
      */
     Redis.ClientFactory = redis_1.createClient;
+    /**
+     * A private static property that references the createCluster function.
+     * This property can be used to create clusters within the class.
+     */
+    Redis.ClusterFactory = redis_1.createCluster;
     return Redis;
 }());
 exports.default = Redis;

package/dist/src/Cache/Redis.js.map

@@ -1 +1 @@
-{"version":3,"file":"Redis.js","sourceRoot":"","sources":["../../../src/Cache/Redis.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+BAAqD;AAGrD,yDAAmD;AACnD;;GAEG;AACH;IAAA;IAuCA,CAAC;IA3Be,gBAAU,GAAxB,UAAyB,MAA4B;QACnD,OAAO,EAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAA;IACzC,CAAC;IAED;;;;;;OAMG;IACkB,qBAAe,GAApC,UAAqC,MAA4B;;;;;;wBAC/D,OAAO,CAAC,KAAK,CAAC,kCAAkC,CAAC,CAAA;wBAC3C,UAAU,GAAG,EAAK,CAAC,aAAa,qBACpC,QAAQ,EAAE,MAAM,CAAC,QAAQ,IACtB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,KACzD,mBAAmB,EAAE,IAAI,EACzB,MAAM,sBACJ,IAAI,EAAE,MAAM,CAAC,QAAQ,IAClB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,KAC1C,cAAc,EAAE,KAAK,OAEvB,CAAA;wBACF,qBAAM,UAAU,CAAC,OAAO,EAAE,EAAA;;wBAA1B,SAA0B,CAAA;wBAE1B,sBAAO,UAAiB,EAAA;;;;KACzB;;;IArCc,eAAS,GAAG,IAAI,wBAAc,CAC3C,EAAK,CAAC,eAAe,EACrB,UAAM,CAAC;QAAI,sBAAA,CAAC,CAAC,MAAM,EAAA;aAAA,CACpB,AAHuB,CAGvB;IAED;;;OAGG;IACY,mBAAa,GAAG,oBAAY,AAAf,CAAe;IA6B7C,YAAC;CAAA,AAvCD,IAuCC;kBAvCoB,KAAK"}
+{"version":3,"file":"Redis.js","sourceRoot":"","sources":["../../../src/Cache/Redis.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+BAAsF;AAGtF,yDAAmD;AACnD;;GAEG;AACH;IAAA;IAgFA,CAAC;IA9De,gBAAU,GAAxB,UACE,MAA4B;QAE5B,OAAO,EAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAA;IACzC,CAAC;IAEoB,uBAAiB,GAAtC,UACE,MAA4B;;;gBAE5B,IAAI,MAAM,CAAC,WAAW;oBAAE,sBAAO,EAAK,CAAC,sBAAsB,CAAC,MAAM,CAAC,EAAA;;oBAC9D,sBAAO,EAAK,CAAC,qBAAqB,CAAC,MAAM,CAAC,EAAA;;;;KAChD;IACD;;;;;;OAMG;IACkB,2BAAqB,GAA1C,UACE,MAA4B;;;;;;wBAE5B,OAAO,CAAC,KAAK,CAAC,yCAAyC,CAAC,CAAA;wBAClD,UAAU,GAAG,EAAK,CAAC,aAAa,qBACpC,QAAQ,EAAE,MAAM,CAAC,QAAQ,IACtB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,KACzD,mBAAmB,EAAE,IAAI,EACzB,MAAM,EAAE;gCACN,IAAI,EAAE,MAAM,CAAC,QAAQ;gCACrB,GAAG,EAAE,MAAM,CAAC,SAAS;gCACrB,cAAc,EAAE,KAAK;6BACtB,IACD,CAAA;wBACF,qBAAM,UAAU,CAAC,OAAO,EAAE,EAAA;;wBAA1B,SAA0B,CAAA;wBAE1B,sBAAO,UAAiB,EAAA;;;;KACzB;IAEoB,4BAAsB,GAA3C,UACE,MAA4B;;;;;;wBAE5B,OAAO,CAAC,KAAK,CAAC,0CAA0C,CAAC,CAAA;wBACnD,UAAU,GAAG,EAAK,CAAC,cAAc,CAAC;4BACtC,QAAQ,sBACN,QAAQ,EAAE,MAAM,CAAC,QAAQ,IACtB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,KACzD,MAAM,EAAE;oCACN,GAAG,EAAE,MAAM,CAAC,SAAS;oCACrB,cAAc,EAAE,KAAK;iCACtB,GACF;4BACD,SAAS,EAAE;gCACT;oCACE,GAAG,EAAE,kBAAW,MAAM,CAAC,QAAQ,cAAI,MAAM,CAAC,QAAQ,cAAI,MAAM,CAAC,QAAQ,UAAO;oCAC5E,mBAAmB,EAAE,IAAI;iCAC1B;6BACF;yBACF,CAAC,CAAA;wBACF,qBAAM,UAAU,CAAC,OAAO,EAAE,EAAA;;wBAA1B,SAA0B,CAAA;wBAE1B,sBAAO,UAAiB,EAAA;;;;KACzB;;;IA9Ec,eAAS,GAAG,IAAI,wBAAc,CAG3C,EAAK,CAAC,iBAAiB,EAAE,UAAM,CAAC;QAAI,sBAAA,CAAC,CAAC,MAAM,EAAA;aAAA,CAAC,AAHvB,CAGuB;IAE/C;;;OAGG;IACY,mBAAa,GAAG,oBAAY,AAAf,CAAe;IAE3C;;;OAGG;IACY,oBAAc,GAAG,qBAAa,AAAhB,CAAgB;IAgE/C,YAAC;CAAA,AAhFD,IAgFC;kBAhFoB,KAAK"}

package/dist/src/Cache/types.d.ts

@@ -18,6 +18,7 @@ export type CacheBaseConfig = {
     username: string;
     password?: string;
     enableTLS: boolean;
+    clusterMode?: boolean;
 };
 /**
  * Defines a CacheConfig type that extends CacheBaseConfig and includes a specific cache type.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@creator.co/wapi",
-  "version": "1.5.3",
+  "version": "1.5.5",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/Cache/Redis.ts

@@ -1,4 +1,4 @@
-import { RedisClientType, createClient } from 'redis'
+import { RedisClientType, RedisClusterType, createCluster, createClient } from 'redis'
 
 import { CacheConfig } from './types'
 import AsyncSingleton from '../Util/AsyncSingleton'
@@ -6,10 +6,10 @@ import AsyncSingleton from '../Util/AsyncSingleton'
  * Represents a Redis cache connection class.
  */
 export default class Redis {
-  private static singleton = new AsyncSingleton<RedisClientType, CacheConfig<'redis'>>(
-    Redis.redisConnection,
-    async c => c.isOpen
-  )
+  private static singleton = new AsyncSingleton<
+    RedisClientType | RedisClusterType,
+    CacheConfig<'redis'>
+  >(Redis.connectionFactory, async c => c.isOpen)
 
   /**
    * A private static property that holds a reference to the redis.createClient function.
@@ -17,10 +17,24 @@ export default class Redis {
    */
   private static ClientFactory = createClient
 
-  public static connection(config: CacheConfig<'redis'>): Promise<RedisClientType> {
+  /**
+   * A private static property that references the createCluster function.
+   * This property can be used to create clusters within the class.
+   */
+  private static ClusterFactory = createCluster
+
+  public static connection(
+    config: CacheConfig<'redis'>
+  ): Promise<RedisClientType | RedisClusterType> {
     return Redis.singleton.instance(config)
   }
 
+  private static async connectionFactory(
+    config: CacheConfig<'redis'>
+  ): Promise<RedisClientType | RedisClusterType> {
+    if (config.clusterMode) return Redis.redisClusterConnection(config)
+    else return Redis.redisClientConnection(config)
+  }
   /**
    * Establishes a connection to a Redis client based on the provided configuration
    * and holds it for reusability. If connection is detected closed, new connection is
@@ -28,15 +42,17 @@ export default class Redis {
    * @param {CacheConfig<'redis'>} config - The configuration object for connecting to the Redis client.
    * @returns {Promise<RedisClientType>} A promise that resolves to the Redis client connection.
    */
-  private static async redisConnection(config: CacheConfig<'redis'>): Promise<RedisClientType> {
-    console.debug('Starting remote cache connection')
+  private static async redisClientConnection(
+    config: CacheConfig<'redis'>
+  ): Promise<RedisClientType> {
+    console.debug('Starting remote client cache connection')
     const connection = Redis.ClientFactory({
       username: config.username,
       ...(config.password ? { password: config.password } : {}),
       disableOfflineQueue: true,
       socket: {
         host: config.hostname,
-        ...(config.enableTLS ? { tls: true } : {}),
+        tls: config.enableTLS,
         connectTimeout: 10000,
       },
     })
@@ -44,4 +60,29 @@ export default class Redis {
 
     return connection as any
   }
+
+  private static async redisClusterConnection(
+    config: CacheConfig<'redis'>
+  ): Promise<RedisClusterType> {
+    console.debug('Starting remote cluster cache connection')
+    const connection = Redis.ClusterFactory({
+      defaults: {
+        username: config.username,
+        ...(config.password ? { password: config.password } : {}),
+        socket: {
+          tls: config.enableTLS,
+          connectTimeout: 10000,
+        },
+      },
+      rootNodes: [
+        {
+          url: `redis://${config.username}:${config.username}@${config.hostname}:6379`,
+          disableOfflineQueue: true,
+        },
+      ],
+    })
+    await connection.connect()
+
+    return connection as any
+  }
 }

package/src/Cache/types.ts

@@ -21,6 +21,7 @@ export type CacheBaseConfig = {
   username: string
   password?: string
   enableTLS: boolean
+  clusterMode?: boolean
 }
 
 /**

package/tests/Cache/{Redis.test.ts → Redis-client.test.ts}

@@ -33,7 +33,7 @@ async function simpleRedisTest(config: any, concurrent?: boolean) {
     disableOfflineQueue: true,
     socket: {
       host: config.hostname,
-      ...(config.enableTLS ? { tls: true } : {}),
+      tls: config.enableTLS,
       connectTimeout: 10000,
     },
   })
@@ -43,7 +43,7 @@ async function simpleRedisTest(config: any, concurrent?: boolean) {
   expect(provider2.connect).toHaveBeenCalledTimes(1)
 }
 
-describe('Redis', () => {
+describe('Redis (client)', () => {
   beforeEach(async () => {
     // hack to close singleton connection
     if (Redis['singleton'].getValue()) Redis['singleton'].clear()

package/tests/Cache/Redis-cluster.test.ts

@@ -0,0 +1,98 @@
+import Redis from '../../src/Cache/Redis'
+
+let _connectionId = 1
+
+async function simpleRedisTest(config: any, concurrent?: boolean) {
+  const RedisMock = jest.fn(() => {
+    let opened = false
+    const connectionId = _connectionId++
+    return {
+      connectionId,
+      isOpen: () => opened,
+      close: () => (opened = false),
+      connect: jest.fn(() => {
+        opened = true
+        return {
+          mget: jest.fn(() => {
+            return true
+          }),
+        }
+      }),
+    } as any
+  })
+  Redis['ClusterFactory'] = RedisMock
+  // Double call is intentional
+  const [provider, provider2] = concurrent
+    ? await Promise.all([Redis.connection(config), Redis.connection(config)])
+    : [await Redis.connection(config), await Redis.connection(config)]
+
+  // client checks
+  expect(RedisMock).toHaveBeenNthCalledWith(1, {
+    defaults: {
+      username: config.username,
+      ...(config.password ? { password: config.password } : {}),
+      socket: {
+        tls: config.enableTLS,
+        connectTimeout: 10000,
+      },
+    },
+    rootNodes: [
+      {
+        url: `redis://${config.username}:${config.username}@${config.hostname}:6379`,
+        disableOfflineQueue: true,
+      },
+    ],
+  })
+  // Does not have double connection
+  expect(provider['connectionId']).toEqual(provider2['connectionId'])
+  expect(provider.connect).toHaveBeenCalledTimes(1)
+  expect(provider2.connect).toHaveBeenCalledTimes(1)
+}
+
+describe('Redis (cluster)', () => {
+  beforeEach(async () => {
+    // hack to close singleton connection
+    if (Redis['singleton'].getValue()) Redis['singleton'].clear()
+  })
+  test('Simple redis - do not connect twice', async () => {
+    await simpleRedisTest({
+      hostname: 'redis://localhost',
+      username: 'gabe',
+      password: 'mypassword',
+      enableTLS: true,
+      clusterMode: true,
+      type: 'redis',
+    })
+  })
+  test('Simple redis (no SSL) - do not connect twice', async () => {
+    await simpleRedisTest({
+      hostname: 'redis://localhost',
+      username: 'gabe',
+      password: 'mypassword',
+      enableTLS: false,
+      clusterMode: true,
+      type: 'redis',
+    })
+  })
+  test('Simple redis (passwordless) - do not connect twice', async () => {
+    await simpleRedisTest({
+      hostname: 'redis://localhost',
+      username: 'gabe',
+      enableTLS: false,
+      clusterMode: true,
+      type: 'redis',
+    })
+  })
+  test('Concurrent redis - do not connect twice', async () => {
+    await simpleRedisTest(
+      {
+        hostname: 'redis://localhost',
+        username: 'gabe',
+        enableTLS: false,
+        clusterMode: true,
+        type: 'redis',
+      },
+      true
+    )
+  })
+})