lesgo 2.1.4 → 2.1.6

package/dist/config/sqs.d.ts

@@ -1,9 +1,5 @@
 declare const _default: {
     region: string;
-    queues: {
-        alias: string;
-        name: string;
-        url: string;
-    }[];
+    queueAliases: string[];
 };
 export default _default;

package/dist/config/sqs.js

@@ -1,18 +1,9 @@
 var _a;
 import awsConfig from './aws';
-import appConfig from './app';
-const sqsQueueAliases =
-  ((_a = process.env.LESGO_AWS_SQS_QUEUE_ALIASES) === null || _a === void 0
-    ? void 0
-    : _a.split(',')) || [];
-const region = process.env.LESGO_AWS_SQS_REGION || awsConfig.region;
 export default {
   region: process.env.LESGO_AWS_SQS_REGION || awsConfig.region,
-  queues: sqsQueueAliases.map(q => ({
-    alias: q,
-    name: `${appConfig.stackName}-${q}`,
-    url: `https://sqs.${region}.amazonaws.com/${
-      awsConfig.accountId
-    }/${`${appConfig.stackName}-${q}`}`,
-  })),
+  queueAliases:
+    ((_a = process.env.LESGO_AWS_SQS_QUEUE_ALIASES) === null || _a === void 0
+      ? void 0
+      : _a.split(',')) || [],
 };

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.d.ts

@@ -1,4 +1,5 @@
-import { ConnectionOptions } from 'mysql2/promise';
+import { ConnectionOptions, FieldPacket, QueryResult } from 'mysql2/promise';
 import { RDSAuroraMySQLProxyClientOptions } from '../../types/aws';
-declare const query: (sql: string, preparedValues?: any[], connOptions?: ConnectionOptions, clientOpts?: RDSAuroraMySQLProxyClientOptions) => Promise<[import("mysql2/promise").QueryResult, import("mysql2/typings/mysql/lib/protocol/packets/FieldPacket").FieldPacket[]]>;
+type QueryReturn<T> = [T, FieldPacket[]];
+declare const query: <T = QueryResult>(sql: string, preparedValues?: any[], connOptions?: ConnectionOptions, clientOpts?: RDSAuroraMySQLProxyClientOptions) => Promise<QueryReturn<T>>;
 export default query;

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/services/SQSService/changeMessageVisibility.d.ts

@@ -0,0 +1,10 @@
+import { ChangeMessageVisibilityCommandInput } from '@aws-sdk/client-sqs';
+import { ClientOptions } from '../../types/aws';
+import { Queue } from './getQueueUrl';
+export interface changeMessageVisibilityOptions extends Partial<Omit<ChangeMessageVisibilityCommandInput, 'QueueUrl' | 'ReceiptHandle' | 'VisibilityTimeout'>> {
+    QueueUrl?: string;
+    ReceiptHandle?: string;
+    VisibilityTimeout?: number;
+}
+declare const changeMessageVisibility: (queue: string | Queue, receiptHandle: string, visibilityTimeout: number, opts?: changeMessageVisibilityOptions, clientOpts?: ClientOptions) => Promise<void>;
+export default changeMessageVisibility;

package/dist/services/SQSService/changeMessageVisibility.js

@@ -0,0 +1,80 @@
+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 { ChangeMessageVisibilityCommand } from '@aws-sdk/client-sqs';
+import LesgoException from '../../exceptions/LesgoException';
+import { logger, validateFields } from '../../utils';
+import getClient from './getClient';
+import getQueueUrl from './getQueueUrl';
+const FILE = 'lesgo.services.SQSService.changeMessageVisibility';
+const changeMessageVisibility = (
+  queue,
+  receiptHandle,
+  visibilityTimeout,
+  opts,
+  clientOpts
+) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const queueUrl = getQueueUrl(queue);
+    const input = validateFields({ receiptHandle, visibilityTimeout }, [
+      { key: 'receiptHandle', type: 'string', required: true },
+      { key: 'visibilityTimeout', type: 'number', required: true },
+    ]);
+    const client = getClient(clientOpts);
+    const commandInput = Object.assign(
+      {
+        QueueUrl: queueUrl,
+        ReceiptHandle: input.receiptHandle,
+        VisibilityTimeout: input.visibilityTimeout,
+      },
+      opts
+    );
+    try {
+      yield client.send(new ChangeMessageVisibilityCommand(commandInput));
+      logger.debug(`${FILE}::MESSAGE_VISIBILITY_UPDATED`, {
+        commandInput,
+      });
+    } catch (error) {
+      throw new LesgoException(
+        'Error occurred updating message visibility timeout',
+        `${FILE}::MESSAGE_VISIBILITY_TIMEOUT_UPDATED_ERROR`,
+        500,
+        {
+          error,
+          commandInput,
+          opts,
+        }
+      );
+    }
+  });
+export default changeMessageVisibility;

package/dist/services/SQSService/getQueueCount.d.ts

@@ -0,0 +1,8 @@
+import { GetQueueAttributesCommandInput } from '@aws-sdk/client-sqs';
+import { ClientOptions } from '../../types/aws';
+import { Queue } from './getQueueUrl';
+export interface GetQueueCountOptions extends Partial<Omit<GetQueueAttributesCommandInput, 'QueueUrl'>> {
+    QueueUrl?: string;
+}
+declare const getQueueCount: (queue: string | Queue, opts?: GetQueueCountOptions, clientOpts?: ClientOptions) => Promise<import("@aws-sdk/client-sqs").GetQueueAttributesCommandOutput>;
+export default getQueueCount;

package/dist/services/SQSService/getQueueCount.js

@@ -0,0 +1,76 @@
+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 { GetQueueAttributesCommand } from '@aws-sdk/client-sqs';
+import LesgoException from '../../exceptions/LesgoException';
+import { logger } from '../../utils';
+import getClient from './getClient';
+import getQueueUrl from './getQueueUrl';
+const FILE = 'lesgo.services.SQSService.getQueueCount';
+const getQueueCount = (queue, opts, clientOpts) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const queueUrl = getQueueUrl(queue);
+    const client = getClient(clientOpts);
+    const commandInput = Object.assign(
+      {
+        QueueUrl: queueUrl,
+        AttributeNames: [
+          'ApproximateNumberOfMessages',
+          'ApproximateNumberOfMessagesNotVisible',
+        ],
+      },
+      opts
+    );
+    try {
+      const data = yield client.send(
+        new GetQueueAttributesCommand(commandInput)
+      );
+      logger.debug(`${FILE}::QUEUE_COUNT`, {
+        data,
+        commandInput,
+      });
+      return data;
+    } catch (error) {
+      throw new LesgoException(
+        'Error occurred getting count from queue',
+        `${FILE}::QUEUE_COUNT_ERROR`,
+        500,
+        {
+          error,
+          commandInput,
+          opts,
+        }
+      );
+    }
+  });
+export default getQueueCount;

package/dist/services/SQSService/getQueueUrl.js

@@ -1,5 +1,6 @@
 import { LesgoException } from '../../exceptions';
 import sqsConfig from '../../config/sqs';
+import { convertQueueAliasToObject } from '../../utils/sqs';
 const FILE = 'lesgo.services.SQSService.getQueueUrl';
 export default queue => {
   if (
@@ -10,7 +11,8 @@ export default queue => {
   ) {
     return queue.url;
   }
-  const configQueue = sqsConfig.queues.find(q => q.alias === queue);
+  const queues = convertQueueAliasToObject(sqsConfig.queueAliases);
+  const configQueue = queues.find(q => q.alias === queue);
   if (!configQueue) {
     throw new LesgoException(
       `Queue with alias ${queue} not found in config`,

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

@@ -1,3 +1,4 @@
+export { default as changeMessageVisibility } from './changeMessageVisibility';
 export { default as deleteMessage } from './deleteMessage';
 export { default as dispatch } from './dispatch';
 export { default as getClient } from './getClient';

package/dist/services/SQSService/index.js

@@ -1,3 +1,4 @@
+export { default as changeMessageVisibility } from './changeMessageVisibility';
 export { default as deleteMessage } from './deleteMessage';
 export { default as dispatch } from './dispatch';
 export { default as getClient } from './getClient';

package/dist/utils/crypto/validateEncryptionFields.d.ts

@@ -11,7 +11,7 @@ interface ValidateEncryptionFieldsOptions {
 export declare const validateEncryptionAlgorithm: (algorithm: EncryptionAlgorithm) => void;
 export declare const validateSecretKey: (secretKey?: string, algorithm?: EncryptionAlgorithm) => void;
 declare const validateEncryptionFields: (text: string, opts?: ValidateEncryptionFieldsOptions) => {
-    validText: any;
+    validText: string;
     validAlgorithm: EncryptionAlgorithm;
     validSecretKey: string;
     validIvLength: number;

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/db/mysql/proxy/query.d.ts

@@ -1,4 +1,4 @@
 import { ConnectionOptions } from 'mysql2/promise';
 import { RDSAuroraMySQLProxyClientOptions } from '../../../../types/aws';
-declare const query: (sql: string, preparedValues?: any[], connOptions?: ConnectionOptions, clientOpts?: RDSAuroraMySQLProxyClientOptions) => Promise<import("mysql2/promise").QueryResult>;
+declare const query: <T>(sql: string, preparedValues?: any[], connOptions?: ConnectionOptions, clientOpts?: RDSAuroraMySQLProxyClientOptions) => Promise<T>;
 export default query;

package/dist/utils/index.d.ts

@@ -7,3 +7,4 @@ export { default as isEmail } from './isEmail';
 export { default as isEmpty } from './isEmpty';
 export { default as logger } from './logger';
 export { default as validateFields } from './validateFields';
+export { default as safePromise } from './safePromise';

package/dist/utils/index.js

@@ -7,3 +7,4 @@ export { default as isEmail } from './isEmail';
 export { default as isEmpty } from './isEmpty';
 export { default as logger } from './logger';
 export { default as validateFields } from './validateFields';
+export { default as safePromise } from './safePromise';

package/dist/utils/safePromise.d.ts

@@ -0,0 +1,20 @@
+/**
+ *
+ * @param promise
+ * @returns [err, res]
+ * @reference https://github.com/arthurfiorette/proposal-safe-assignment-operator
+ *
+ * @example
+ * ```typescript
+ * import { safePromise } from 'lesgo/utils';
+ *
+ * const [err, res] = await safePromise(fetch('https://example.com/'));
+ * if (err) {
+ *   console.error(err);
+ * } else {
+ *   console.log(res);
+ * }
+ * ```
+ */
+declare const safePromise: <T>(promise: Promise<T>) => Promise<[unknown, T | null]>;
+export default safePromise;

package/dist/utils/safePromise.js

@@ -0,0 +1,61 @@
+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());
+    });
+  };
+/**
+ *
+ * @param promise
+ * @returns [err, res]
+ * @reference https://github.com/arthurfiorette/proposal-safe-assignment-operator
+ *
+ * @example
+ * ```typescript
+ * import { safePromise } from 'lesgo/utils';
+ *
+ * const [err, res] = await safePromise(fetch('https://example.com/'));
+ * if (err) {
+ *   console.error(err);
+ * } else {
+ *   console.log(res);
+ * }
+ * ```
+ */
+const safePromise = promise =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    try {
+      const res = yield promise;
+      return [null, res];
+    } catch (err) {
+      return [err, null];
+    }
+  });
+export default safePromise;

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/dist/utils/sqs/changeMessageVisibility.d.ts

@@ -0,0 +1,5 @@
+import { Queue } from '../../services/SQSService/getQueueUrl';
+import { ClientOptions } from '../../types/aws';
+import { changeMessageVisibilityOptions } from '../../services/SQSService/changeMessageVisibility';
+export declare const changeMessageVisibility: (queue: string | Queue, receiptHandle: string, visibilityTimeout: number, opts?: changeMessageVisibilityOptions, clientOpts?: ClientOptions) => Promise<void>;
+export default changeMessageVisibility;

package/dist/utils/sqs/changeMessageVisibility.js

@@ -0,0 +1,51 @@
+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 changeMessageVisibilityService from '../../services/SQSService/changeMessageVisibility';
+export const changeMessageVisibility = (
+  queue,
+  receiptHandle,
+  visibilityTimeout,
+  opts,
+  clientOpts
+) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    return changeMessageVisibilityService(
+      queue,
+      receiptHandle,
+      visibilityTimeout,
+      opts,
+      clientOpts
+    );
+  });
+export default changeMessageVisibility;

package/dist/utils/sqs/convertQueueAliasToObject.d.ts

@@ -0,0 +1,3 @@
+import { Queue } from '../../services/SQSService/getQueueUrl';
+export declare const convertQueueAliasToObject: (queueAlias: string | string[]) => Queue | Queue[];
+export default convertQueueAliasToObject;

package/dist/utils/sqs/convertQueueAliasToObject.js

@@ -0,0 +1,16 @@
+import appConfig from '../../config/app';
+import awsConfig from '../../config/aws';
+const convert = queueAlias => ({
+  alias: queueAlias,
+  name: `${appConfig.stackName}-${queueAlias}`,
+  url: `https://sqs.${awsConfig.region}.amazonaws.com/${
+    awsConfig.accountId
+  }/${`${appConfig.stackName}-${queueAlias}`}`,
+});
+export const convertQueueAliasToObject = queueAlias => {
+  if (Array.isArray(queueAlias)) {
+    return queueAlias.map(q => convert(q));
+  }
+  return convert(queueAlias);
+};
+export default convertQueueAliasToObject;

package/dist/utils/sqs/getQueueCount.d.ts

@@ -0,0 +1,5 @@
+import { GetQueueCountOptions } from '../../services/SQSService/getQueueCount';
+import { Queue } from '../../services/SQSService/getQueueUrl';
+import { ClientOptions } from '../../types/aws';
+export declare const getQueueCount: (queue: string | Queue, opts?: GetQueueCountOptions, clientOpts?: ClientOptions) => Promise<import("@aws-sdk/client-sqs").GetQueueAttributesCommandOutput>;
+export default getQueueCount;

package/dist/utils/sqs/getQueueCount.js

@@ -0,0 +1,39 @@
+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 getQueueCountService from '../../services/SQSService/getQueueCount';
+export const getQueueCount = (queue, opts, clientOpts) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    return getQueueCountService(queue, opts, clientOpts);
+  });
+export default getQueueCount;

package/dist/utils/sqs/index.d.ts

@@ -1,4 +1,7 @@
+export { default as changeMessageVisibility } from './changeMessageVisibility';
+export { default as convertQueueAliasToObject } from './convertQueueAliasToObject';
 export { default as deleteMessage } from './deleteMessage';
 export { default as dispatch } from './dispatch';
 export { default as getClient } from './getClient';
+export { default as getQueueCount } from './getQueueCount';
 export { default as receiveMessages } from './receiveMessages';

package/dist/utils/sqs/index.js

@@ -1,4 +1,7 @@
+export { default as changeMessageVisibility } from './changeMessageVisibility';
+export { default as convertQueueAliasToObject } from './convertQueueAliasToObject';
 export { default as deleteMessage } from './deleteMessage';
 export { default as dispatch } from './dispatch';
 export { default as getClient } from './getClient';
+export { default as getQueueCount } from './getQueueCount';
 export { default as receiveMessages } from './receiveMessages';

package/dist/utils/validateFields.d.ts

@@ -1,6 +1,4 @@
-export type Params = {
-    [key: string]: any;
-};
+export type Params = Record<PropertyKey, any>;
 export type Field = {
     key: string;
     type: string;
@@ -16,7 +14,5 @@ export type Field = {
  * @returns An object containing the validated fields.
  * @throws {LesgoException} If a required field is missing or if a field has an invalid type.
  */
-declare const validateFields: (params: Params, validFields: Field[]) => {
-    [key: string]: any;
-};
+declare const validateFields: <T extends Params>(params: T, validFields: Field[]) => T;
 export default validateFields;

package/dist/utils/validateFields.js

@@ -25,9 +25,10 @@ const validateFields = (params, validFields) => {
   const validated = {};
   validFields.forEach(field => {
     const { required, type, key, isCollection, enumValues = [] } = field;
+    const value = params[key];
     if (required) {
-      if (typeof params[key] === 'object') {
-        if (Array.isArray(params[key]) && params[key].length === 0) {
+      if (typeof value === 'object') {
+        if (Array.isArray(value) && value.length === 0) {
           throw new LesgoException(
             `Missing required '${key}'`,
             `${FILE}::MISSING_REQUIRED_${key.toUpperCase()}`,
@@ -36,8 +37,8 @@ const validateFields = (params, validFields) => {
           );
         }
       }
-      if (!params[key]) {
-        if (typeof params[key] !== 'number') {
+      if (!value) {
+        if (typeof value !== 'number') {
           throw new LesgoException(
             `Missing required '${key}'`,
             `${FILE}::MISSING_REQUIRED_${key.toUpperCase()}`,
@@ -49,19 +50,18 @@ const validateFields = (params, validFields) => {
     }
     if (isCollection) {
       try {
-        validateFields({ [key]: params[key] }, [
-          { key, required, type: 'array' },
-        ]);
+        validateFields({ [key]: value }, [{ key, required, type: 'array' }]);
       } catch (_) {
         throw new LesgoException(
           `Invalid type for '${key}', expecting collection of '${type}'`,
           `${FILE}::INVALID_TYPE_${key.toUpperCase()}`,
           500,
-          { field, value: params[key] }
+          { field, value }
         );
       }
     }
-    (isCollection ? params[key] || [] : [params[key]]).forEach(paramsItem => {
+    const paramsItems = isCollection ? value || [] : [value];
+    paramsItems.forEach(paramsItem => {
       if (
         (type === 'string' &&
           typeof paramsItem !== 'undefined' &&
@@ -101,8 +101,8 @@ const validateFields = (params, validFields) => {
         );
       }
     });
-    if (typeof params[key] !== 'undefined') {
-      validated[key] = params[key];
+    if (typeof value !== 'undefined') {
+      validated[key] = value;
     }
   });
   return validated;

package/package.json

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