lesgo 2.1.6 → 2.1.7

package/dist/services/ElastiCacheRedisService/deleteRedisCache.d.ts

@@ -1,3 +1,3 @@
 import { ClientOptions } from '../../types/aws';
-declare const deleteRedisCache: (key: string, clientOpts?: ClientOptions) => Promise<number>;
+declare const deleteRedisCache: (keys: string | string[], clientOpts?: ClientOptions) => Promise<number>;
 export default deleteRedisCache;

package/dist/services/ElastiCacheRedisService/deleteRedisCache.js

@@ -31,20 +31,20 @@ var __awaiter =
       step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
   };
-import { logger, validateFields } from '../../utils';
+import { logger } from '../../utils';
 import { LesgoException } from '../../exceptions';
 import getElastiCacheRedisClient from './getElastiCacheRedisClient';
 const FILE = 'lesgo.services.ElastiCacheRedis.deleteRedisCache';
-const deleteRedisCache = (key, clientOpts) =>
+const deleteRedisCache = (keys, clientOpts) =>
   __awaiter(void 0, void 0, void 0, function* () {
-    const input = validateFields({ key }, [
-      { key: 'key', type: 'string', required: true },
-    ]);
     const client = yield getElastiCacheRedisClient(clientOpts);
     let resp;
+    if (!Array.isArray(keys)) {
+      keys = [keys];
+    }
     try {
-      resp = yield client.del(input.key);
-      logger.debug(`${FILE}::RECEIVED_RESPONSE`, { resp, input });
+      resp = yield client.del(...keys);
+      logger.debug(`${FILE}::RECEIVED_RESPONSE`, { resp, keys });
       return resp;
     } catch (err) {
       throw new LesgoException(
@@ -53,7 +53,7 @@ const deleteRedisCache = (key, clientOpts) =>
         500,
         {
           err,
-          input,
+          keys,
           clientOpts,
         }
       );

package/dist/services/ElastiCacheRedisService/index.d.ts

@@ -2,4 +2,5 @@ export { default as deleteRedisCache } from './deleteRedisCache';
 export { default as disconnectElastiCacheRedisClient } from './disconnectElastiCacheRedisClient';
 export { default as getElastiCacheRedisClient } from './getElastiCacheRedisClient';
 export { default as getRedisCache } from './getRedisCache';
+export { default as scanRedisCache } from './scanRedisCache';
 export { default as setRedisCache } from './setRedisCache';

package/dist/services/ElastiCacheRedisService/index.js

@@ -2,4 +2,5 @@ export { default as deleteRedisCache } from './deleteRedisCache';
 export { default as disconnectElastiCacheRedisClient } from './disconnectElastiCacheRedisClient';
 export { default as getElastiCacheRedisClient } from './getElastiCacheRedisClient';
 export { default as getRedisCache } from './getRedisCache';
+export { default as scanRedisCache } from './scanRedisCache';
 export { default as setRedisCache } from './setRedisCache';

package/dist/services/ElastiCacheRedisService/scanRedisCache.d.ts

@@ -0,0 +1,12 @@
+import { ClientOptions } from '../../types/aws';
+/**
+ * Scans the Redis cache for keys matching a given pattern.
+ *
+ * @param {string} pattern - The pattern to match keys against.
+ * @param {ClientOptions} [clientOpts] - Optional client options for connecting to the Redis instance.
+ * @returns {Promise<string[]>} - A promise that resolves to an array of keys matching the pattern.
+ *
+ * @throws {LesgoException} - Throws an exception if the scan operation fails.
+ */
+declare const scanRedisCache: (pattern: string, clientOpts?: ClientOptions) => Promise<string[]>;
+export default scanRedisCache;

package/dist/services/ElastiCacheRedisService/scanRedisCache.js

@@ -0,0 +1,83 @@
+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());
+    });
+  };
+import { logger, validateFields } from '../../utils';
+import { LesgoException } from '../../exceptions';
+import getElastiCacheRedisClient from './getElastiCacheRedisClient';
+const FILE = 'lesgo.services.ElastiCacheRedis.scanRedisCache';
+/**
+ * Scans the Redis cache for keys matching a given pattern.
+ *
+ * @param {string} pattern - The pattern to match keys against.
+ * @param {ClientOptions} [clientOpts] - Optional client options for connecting to the Redis instance.
+ * @returns {Promise<string[]>} - A promise that resolves to an array of keys matching the pattern.
+ *
+ * @throws {LesgoException} - Throws an exception if the scan operation fails.
+ */
+const scanRedisCache = (pattern, clientOpts) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const input = validateFields({ pattern }, [
+      { key: 'pattern', type: 'string', required: true },
+    ]);
+    const client = yield getElastiCacheRedisClient(clientOpts);
+    const keys = [];
+    try {
+      let cursor = '0'; // Start cursor
+      do {
+        // Perform SCAN operation
+        const [newCursor, matchedKeys] = yield client.scan(
+          cursor,
+          'MATCH',
+          pattern
+        );
+        cursor = newCursor;
+        if (matchedKeys.length > 0) {
+          keys.push(...matchedKeys);
+        }
+      } while (cursor !== '0'); // Continue until cursor is 0 (scan complete)
+      logger.debug(`${FILE}::RECEIVED_RESPONSE`, { keys, input });
+    } catch (err) {
+      throw new LesgoException(
+        'Failed to scan redis cache',
+        `${FILE}::SCAN_ERROR`,
+        500,
+        {
+          err,
+          input,
+          clientOpts,
+        }
+      );
+    }
+    return keys;
+  });
+export default scanRedisCache;

package/dist/utils/cache/redis/deleteCache.d.ts

@@ -2,7 +2,7 @@ import { ClientOptions } from '../../../types/aws';
 /**
  * Deletes the cache value from the Redis cache.
  *
- * @param {string} key - The key of the cache value to delete.
+ * @param {string | string[]} keys - The key(s) of the cache value to delete.
  * @param {ClientOptions} clientOpts - Optional client options for Redis connection.
  * @returns A promise that resolves to the deleted cache value.
  * @throws {LesgoException} If there is an error deleting the cache.
@@ -11,9 +11,10 @@ import { ClientOptions } from '../../../types/aws';
  * ```typescript
  * import { deleteCache } from 'lesgo/utils/cache/redis';
  *
- * const key = 'myKey';
+ * const keys = 'myKey';
+ * // const keys = ['key1', 'key2'];
  *
- * await deleteCache(key);
+ * await deleteCache(keys);
  */
-declare const getCache: (key: string, clientOpts?: ClientOptions) => Promise<number>;
-export default getCache;
+declare const deleteCache: (keys: string | string[], clientOpts?: ClientOptions) => Promise<number>;
+export default deleteCache;

package/dist/utils/cache/redis/deleteCache.js

@@ -2,7 +2,7 @@ import { deleteRedisCache } from '../../../services/ElastiCacheRedisService';
 /**
  * Deletes the cache value from the Redis cache.
  *
- * @param {string} key - The key of the cache value to delete.
+ * @param {string | string[]} keys - The key(s) of the cache value to delete.
  * @param {ClientOptions} clientOpts - Optional client options for Redis connection.
  * @returns A promise that resolves to the deleted cache value.
  * @throws {LesgoException} If there is an error deleting the cache.
@@ -11,11 +11,12 @@ import { deleteRedisCache } from '../../../services/ElastiCacheRedisService';
  * ```typescript
  * import { deleteCache } from 'lesgo/utils/cache/redis';
  *
- * const key = 'myKey';
+ * const keys = 'myKey';
+ * // const keys = ['key1', 'key2'];
  *
- * await deleteCache(key);
+ * await deleteCache(keys);
  */
-const getCache = (key, clientOpts) => {
-  return deleteRedisCache(key, clientOpts);
+const deleteCache = (keys, clientOpts) => {
+  return deleteRedisCache(keys, clientOpts);
 };
-export default getCache;
+export default deleteCache;

package/dist/utils/cache/redis/index.d.ts

@@ -2,4 +2,5 @@ export { default as disconnectCache } from './disconnectCache';
 export { default as deleteCache } from './deleteCache';
 export { default as getCache } from './getCache';
 export { default as getClient } from './getClient';
+export { default as scanCache } from './scanCache';
 export { default as setCache } from './setCache';

package/dist/utils/cache/redis/index.js

@@ -2,4 +2,5 @@ export { default as disconnectCache } from './disconnectCache';
 export { default as deleteCache } from './deleteCache';
 export { default as getCache } from './getCache';
 export { default as getClient } from './getClient';
+export { default as scanCache } from './scanCache';
 export { default as setCache } from './setCache';

package/dist/utils/cache/redis/scanCache.d.ts

@@ -0,0 +1,23 @@
+import { ClientOptions } from '../../../types/aws';
+/**
+ * Scans the Redis cache for keys matching a given pattern.
+ *
+ * @param {string} pattern - The pattern to match keys against.
+ * @param {ClientOptions} clientOpts - Optional client options for the cache client.
+ * @returns A promise that resolves when the value is retrieved from the cache.
+ *
+ * @throws {LesgoException} If there is an error retrieving the cache.
+ *
+ * @example
+ * ```typescript
+ * import { scanCache } from 'lesgo/utils/cache/redis';
+ *
+ * const pattern = 'getUser:byId:*';
+ * // const pattern = 'getUser:*';
+ *
+ * const keys = await scanCache(pattern);
+ * console.log(keys); // Array of cache keys returned from the scan operation
+ * ```
+ */
+declare const scanCache: (pattern: string, clientOpts?: ClientOptions) => Promise<string[]>;
+export default scanCache;

package/dist/utils/cache/redis/scanCache.js

@@ -0,0 +1,25 @@
+import { scanRedisCache } from '../../../services/ElastiCacheRedisService';
+/**
+ * Scans the Redis cache for keys matching a given pattern.
+ *
+ * @param {string} pattern - The pattern to match keys against.
+ * @param {ClientOptions} clientOpts - Optional client options for the cache client.
+ * @returns A promise that resolves when the value is retrieved from the cache.
+ *
+ * @throws {LesgoException} If there is an error retrieving the cache.
+ *
+ * @example
+ * ```typescript
+ * import { scanCache } from 'lesgo/utils/cache/redis';
+ *
+ * const pattern = 'getUser:byId:*';
+ * // const pattern = 'getUser:*';
+ *
+ * const keys = await scanCache(pattern);
+ * console.log(keys); // Array of cache keys returned from the scan operation
+ * ```
+ */
+const scanCache = (pattern, clientOpts) => {
+  return scanRedisCache(pattern, clientOpts);
+};
+export default scanCache;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lesgo",
-  "version": "2.1.6",
+  "version": "2.1.7",
   "description": "Core framework for lesgo node.js serverless framework.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",