lesgo 2.1.5 → 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/services/RDSAuroraMySQLProxyService/getMySQLProxyClient.d.ts

@@ -1,8 +1,8 @@
-import { Connection, ConnectionOptions } from 'mysql2/promise';
+import { Pool, ConnectionOptions } from 'mysql2/promise';
 import { RDSAuroraMySQLProxyClientOptions } from '../../types/aws';
 export interface Singleton {
-    [key: string]: Connection;
+    [key: string]: Pool;
 }
 export declare const singleton: Singleton;
-declare const getMySQLProxyClient: (connOptions?: ConnectionOptions, clientOpts?: RDSAuroraMySQLProxyClientOptions) => Promise<Connection>;
+declare const getMySQLProxyClient: (connOptions?: ConnectionOptions, clientOpts?: RDSAuroraMySQLProxyClientOptions) => Promise<Pool>;
 export default getMySQLProxyClient;

package/dist/services/RDSAuroraMySQLProxyService/getMySQLProxyClient.js

@@ -31,7 +31,7 @@ var __awaiter =
       step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
   };
-import { createConnection } from 'mysql2/promise';
+import { createPool } from 'mysql2/promise';
 import { logger, isEmpty, validateFields } from '../../utils';
 import { rds as rdsConfig } from '../../config';
 import { getSecretValue } from '../../utils/secretsmanager';
@@ -53,10 +53,7 @@ const getMySQLProxyClient = (connOptions, clientOpts) =>
     const databaseName =
       options.databaseName || rdsConfig.aurora.mysql.databaseName;
     if (!isEmpty(singleton[singletonConn])) {
-      logger.debug(`${FILE}::REUSE_RDS_CONNECTION`, {
-        client: singleton[singletonConn],
-        region,
-      });
+      logger.debug(`${FILE}::REUSE_RDS_CONNECTION`);
       return singleton[singletonConn];
     }
     const dbCredentials = yield getSecretValue(
@@ -80,17 +77,18 @@ const getMySQLProxyClient = (connOptions, clientOpts) =>
       connOptions
     );
     logger.debug(`${FILE}::CONN_OPTS`, { connOpts });
-    const conn = yield createConnection(
+    const dbPool = createPool(
       Object.assign(
         {
           user: validatedDbCredentials.username,
           password: validatedDbCredentials.password,
+          connectionLimit: 20,
         },
         connOpts
       )
     );
-    singleton[singletonConn] = conn;
+    singleton[singletonConn] = dbPool;
     logger.debug(`${FILE}::NEW_RDS_CONNECTION`);
-    return conn;
+    return dbPool;
   });
 export default getMySQLProxyClient;

package/dist/services/RDSAuroraMySQLProxyService/query.js

@@ -41,9 +41,9 @@ const query = (sql, preparedValues, connOptions, clientOpts) =>
       { key: 'sql', type: 'string', required: true },
       { key: 'preparedValues', type: 'array', required: false },
     ]);
-    const connection = yield getClient(connOptions, clientOpts);
+    const pool = yield getClient(connOptions, clientOpts);
     try {
-      const resp = yield connection.execute(input.sql, input.preparedValues);
+      const resp = yield pool.execute(input.sql, input.preparedValues);
       logger.debug(`${FILE}::RECEIVED_RESPONSE`, {
         result: resp[0],
         sql,

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/dist/utils/db/mysql/proxy/getClient.d.ts

@@ -1,4 +1,4 @@
 import { ConnectionOptions } from 'mysql2/promise';
 import { RDSAuroraMySQLProxyClientOptions } from '../../../../types/aws';
-declare const getClient: (connOptions?: ConnectionOptions, clientOpts?: RDSAuroraMySQLProxyClientOptions) => Promise<import("mysql2/promise").Connection>;
+declare const getClient: (connOptions?: ConnectionOptions, clientOpts?: RDSAuroraMySQLProxyClientOptions) => Promise<import("mysql2/promise").Pool>;
 export default getClient;

package/dist/utils/secretsmanager/getSecretValue.d.ts

@@ -1,4 +1,7 @@
 import { GetSecretValueOptions } from '../../services/SecretsManagerService/getSecretValue';
 import { ClientOptions } from '../../types/aws';
+export interface Secrets {
+    [key: string]: string | object;
+}
 declare const getSecretValue: (secretId: string, opts?: GetSecretValueOptions, clientOpts?: ClientOptions) => Promise<any>;
 export default getSecretValue;

package/dist/utils/secretsmanager/getSecretValue.js

@@ -31,12 +31,18 @@ var __awaiter =
       step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
   };
+import { logger } from '../../utils';
 import { LesgoException } from '../../exceptions';
 import getSecretValueService from '../../services/SecretsManagerService/getSecretValue';
 import isEmpty from '../isEmpty';
+const secret = {};
 const FILE = 'lesgo.utils.secretsmanager.getSecretValue';
 const getSecretValue = (secretId, opts, clientOpts) =>
   __awaiter(void 0, void 0, void 0, function* () {
+    if (secret[secretId]) {
+      logger.debug(`${FILE}::CACHED_SECRET_VALUE`, { secretId });
+      return secret[secretId];
+    }
     let secretString;
     try {
       const { SecretString } = yield getSecretValueService(
@@ -60,8 +66,13 @@ const getSecretValue = (secretId, opts, clientOpts) =>
       );
     }
     try {
-      return JSON.parse(secretString);
+      const secretObj = JSON.parse(secretString);
+      secret[secretId] = secretObj;
+      logger.debug(`${FILE}::SECRET_VALUE`, { secretId });
+      return secretObj;
     } catch (error) {
+      secret[secretId] = secretString || '';
+      logger.debug(`${FILE}::SECRET_VALUE`, { secretId });
       return secretString;
     }
   });

package/package.json

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