lesgo 0.7.8 → 2.1.0

package/dist/services/SQSService/dispatch.js

@@ -0,0 +1,71 @@
+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 { SendMessageCommand } 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.dispatch';
+const dispatch = (payload, queue, opts, clientOpts) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const queueUrl = getQueueUrl(queue);
+    const input = validateFields({ payload }, [
+      { key: 'payload', type: 'object', required: true },
+    ]);
+    const client = getClient(clientOpts);
+    const commandInput = Object.assign(
+      { MessageBody: JSON.stringify(input.payload), QueueUrl: queueUrl },
+      opts
+    );
+    try {
+      const data = yield client.send(new SendMessageCommand(commandInput));
+      logger.debug(`${FILE}::MESSAGE_SENT_TO_QUEUE`, {
+        data,
+        commandInput,
+      });
+      return data;
+    } catch (error) {
+      throw new LesgoException(
+        'Error occurred sending message to queue',
+        `${FILE}::SEND_MESSAGE_ERROR`,
+        500,
+        {
+          error,
+          commandInput,
+          opts,
+        }
+      );
+    }
+  });
+export default dispatch;

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

@@ -0,0 +1,4 @@
+import { SQSClient } from '@aws-sdk/client-sqs';
+import { ClientOptions } from '../../types/aws';
+declare const getClient: (clientOpts?: ClientOptions) => SQSClient;
+export default getClient;

package/dist/services/SQSService/getClient.js

@@ -0,0 +1,28 @@
+import { SQSClient } from '@aws-sdk/client-sqs';
+import { logger, isEmpty, validateFields } from '../../utils';
+import { sqs as sqsConfig } from '../../config';
+const FILE = 'lesgo.services.SQSService.getClient';
+const singleton = {};
+const getClient = (clientOpts = {}) => {
+  const options = validateFields(clientOpts, [
+    { key: 'region', type: 'string', required: false },
+    { key: 'singletonConn', type: 'string', required: false },
+  ]);
+  const region = options.region || sqsConfig.region;
+  const singletonConn = options.singletonConn || 'default';
+  if (!isEmpty(singleton[singletonConn])) {
+    logger.debug(`${FILE}::REUSE_CLIENT_SINGLETON`, {
+      client: singleton[singletonConn],
+      region,
+    });
+    return singleton[singletonConn];
+  }
+  const client = new SQSClient({ region });
+  logger.debug(`${FILE}::NEW_CLIENT`, {
+    client,
+    region,
+  });
+  singleton[singletonConn] = client;
+  return client;
+};
+export default getClient;

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

@@ -0,0 +1,7 @@
+export type Queue = {
+    alias: string;
+    name: string;
+    url: string;
+};
+declare const _default: (queue: string | Queue) => string;
+export default _default;

package/dist/services/SQSService/getQueueUrl.js

@@ -0,0 +1,25 @@
+import { LesgoException } from '../../exceptions';
+import sqsConfig from '../../config/sqs';
+const FILE = 'lesgo.services.SQSService.getQueueUrl';
+export default queue => {
+  if (
+    typeof queue !== 'string' &&
+    'alias' in queue &&
+    'name' in queue &&
+    'url' in queue
+  ) {
+    return queue.url;
+  }
+  const configQueue = sqsConfig.queues.find(q => q.alias === queue);
+  if (!configQueue) {
+    throw new LesgoException(
+      `Queue with alias ${queue} not found in config`,
+      `${FILE}::QUEUE_NOT_FOUND`,
+      404,
+      {
+        queue,
+      }
+    );
+  }
+  return configQueue.url;
+};

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

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

package/dist/services/SQSService/index.js

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

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

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

package/dist/services/SQSService/receiveMessages.js

@@ -0,0 +1,65 @@
+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 { ReceiveMessageCommand } 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.receiveMessages';
+const receiveMessages = (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 }, opts);
+    try {
+      const data = yield client.send(new ReceiveMessageCommand(commandInput));
+      logger.debug(`${FILE}::MESSAGES_RECEIVED_FROM_QUEUE`, {
+        data,
+        commandInput,
+      });
+      return data;
+    } catch (error) {
+      throw new LesgoException(
+        'Error occurred receiving messages from queue',
+        `${FILE}::RECEIVE_MESSAGES_ERROR`,
+        500,
+        {
+          error,
+          commandInput,
+          opts,
+        }
+      );
+    }
+  });
+export default receiveMessages;

package/dist/services/SecretsManagerService/getClient.d.ts

@@ -0,0 +1,7 @@
+import { SecretsManagerClient } from '@aws-sdk/client-secrets-manager';
+import { ClientOptions } from '../../types/aws';
+export interface Singleton {
+    [key: string]: SecretsManagerClient;
+}
+declare const getClient: (clientOpts?: ClientOptions) => SecretsManagerClient;
+export default getClient;

package/dist/services/SecretsManagerService/getClient.js

@@ -0,0 +1,28 @@
+import { SecretsManagerClient } from '@aws-sdk/client-secrets-manager';
+import { logger, isEmpty, validateFields } from '../../utils';
+import { secretsmanager as secretsmanagerConfig } from '../../config';
+const FILE = 'lesgo.services.SecretsManager.getClient';
+const singleton = {};
+const getClient = (clientOpts = {}) => {
+  const options = validateFields(clientOpts, [
+    { key: 'region', type: 'string', required: false },
+    { key: 'singletonConn', type: 'string', required: false },
+  ]);
+  const region = options.region || secretsmanagerConfig.region;
+  const singletonConn = options.singletonConn || 'default';
+  if (!isEmpty(singleton[singletonConn])) {
+    logger.debug(`${FILE}::REUSE_CLIENT_SINGLETON`, {
+      singletonConn,
+      region,
+    });
+    return singleton[singletonConn];
+  }
+  const client = new SecretsManagerClient({ region });
+  logger.debug(`${FILE}::NEW_CLIENT`, {
+    singletonConn,
+    region,
+  });
+  singleton[singletonConn] = client;
+  return client;
+};
+export default getClient;

package/dist/services/SecretsManagerService/getSecretValue.d.ts

@@ -0,0 +1,7 @@
+import { GetSecretValueCommandInput } from '@aws-sdk/client-secrets-manager';
+import { ClientOptions } from '../../types/aws';
+export type GetSecretValueOptions = Omit<GetSecretValueCommandInput, 'SecretId'> & {
+    SecretId?: string;
+};
+declare const getSecretValue: (secretId: string, opts?: GetSecretValueOptions, clientOpts?: ClientOptions) => Promise<import("@aws-sdk/client-secrets-manager").GetSecretValueCommandOutput>;
+export default getSecretValue;

package/dist/services/SecretsManagerService/getSecretValue.js

@@ -0,0 +1,65 @@
+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 { GetSecretValueCommand } from '@aws-sdk/client-secrets-manager';
+import LesgoException from '../../exceptions/LesgoException';
+import { logger, validateFields } from '../../utils';
+import getClient from './getClient';
+const FILE = 'lesgo.services.SecretsManager.getSecretValue';
+const getSecretValue = (secretId, opts, clientOpts) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const input = validateFields({ secretId }, [
+      { key: 'secretId', type: 'string', required: true },
+    ]);
+    const client = getClient(clientOpts);
+    const command = new GetSecretValueCommand(
+      Object.assign({ SecretId: input.secretId }, opts)
+    );
+    try {
+      const resp = yield client.send(command);
+      logger.debug(`${FILE}::RESPONSE`, { resp: '<REDACTED>', command });
+      return resp;
+    } catch (error) {
+      throw new LesgoException(
+        'Error occurred getting secret value from Secrets Manager',
+        `${FILE}::ERROR`,
+        500,
+        {
+          error,
+          command,
+          opts,
+        }
+      );
+    }
+  });
+export default getSecretValue;

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

@@ -0,0 +1,2 @@
+export { default as getClient } from './getClient';
+export { default as getSecretValue } from './getSecretValue';

package/dist/services/SecretsManagerService/index.js

@@ -0,0 +1,2 @@
+export { default as getClient } from './getClient';
+export { default as getSecretValue } from './getSecretValue';

package/dist/services/index.d.ts

@@ -0,0 +1 @@
+export { default as LoggerService } from './LoggerService';

package/dist/services/index.js

@@ -0,0 +1 @@
+export { default as LoggerService } from './LoggerService';

package/dist/types/aws.d.ts

@@ -0,0 +1,8 @@
+export interface ClientOptions {
+    region?: string;
+    singletonConn?: string;
+}
+export interface RDSAuroraMySQLProxyClientOptions extends ClientOptions {
+    dbCredentialsSecretId?: string;
+    databaseName?: string;
+}

package/dist/types/aws.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,19 @@
+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 {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.
+ *
+ * @example
+ * ```typescript
+ * import { deleteCache } from 'lesgo/utils/cache/redis';
+ *
+ * const key = 'myKey';
+ *
+ * await deleteCache(key);
+ */
+declare const getCache: (key: string, clientOpts?: ClientOptions) => Promise<number>;
+export default getCache;

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

@@ -0,0 +1,21 @@
+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 {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.
+ *
+ * @example
+ * ```typescript
+ * import { deleteCache } from 'lesgo/utils/cache/redis';
+ *
+ * const key = 'myKey';
+ *
+ * await deleteCache(key);
+ */
+const getCache = (key, clientOpts) => {
+  return deleteRedisCache(key, clientOpts);
+};
+export default getCache;

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

@@ -0,0 +1,22 @@
+import { ClientOptions } from '../../../types/aws';
+/**
+ * Retrieves the value from the cache based on the provided key.
+ *
+ * @param {string} key - The key used to identify the value in the cache.
+ * @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 { getCache } from 'lesgo/utils/cache/redis';
+ *
+ * const key = 'myKey';
+ *
+ * const value = await getCache(key);
+ * console.log(value); // Value retrieved from the cache
+ * ```
+ */
+declare const getCache: (key: string, clientOpts?: ClientOptions) => Promise<any>;
+export default getCache;

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

@@ -0,0 +1,24 @@
+import { getRedisCache } from '../../../services/ElastiCacheRedisService';
+/**
+ * Retrieves the value from the cache based on the provided key.
+ *
+ * @param {string} key - The key used to identify the value in the cache.
+ * @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 { getCache } from 'lesgo/utils/cache/redis';
+ *
+ * const key = 'myKey';
+ *
+ * const value = await getCache(key);
+ * console.log(value); // Value retrieved from the cache
+ * ```
+ */
+const getCache = (key, clientOpts) => {
+  return getRedisCache(key, clientOpts);
+};
+export default getCache;

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

@@ -0,0 +1,30 @@
+import { ClientOptions } from '../../../types/aws';
+/**
+ * Retrieves a Redis client.
+ *
+ * This function will return a Redis client that is connected to the ElastiCache Redis cluster.
+ * A new client will be created if one does not already exist. The client will be reused if it is already connected.
+ * This is useful if you need to use the Redis Client functions directly.
+ *
+ * This function is not intended to be used directly.
+ * Use the available `getCache`, `setCache`, and `deleteCache` functions instead.
+ *
+ * @param {ClientOptions} clientOpts - Optional client options.
+ * @returns A promise of with Redis client.
+ *
+ * @throws {LesgoException} If there is an error creating the client.
+ *
+ * @example
+ * ```typescript
+ * import { getClient } from 'lesgo/utils/cache/redis';
+ *
+ * const client = await getClient();
+ *
+ * const key = 'myKey';
+ * const value = 'myValue';
+ *
+ * await client.set(key, value);
+ * ```
+ */
+declare const getClient: (clientOpts?: ClientOptions) => Promise<import("ioredis/built/cluster").default>;
+export default getClient;

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

@@ -0,0 +1,32 @@
+import { getElastiCacheRedisClient } from '../../../services/ElastiCacheRedisService';
+/**
+ * Retrieves a Redis client.
+ *
+ * This function will return a Redis client that is connected to the ElastiCache Redis cluster.
+ * A new client will be created if one does not already exist. The client will be reused if it is already connected.
+ * This is useful if you need to use the Redis Client functions directly.
+ *
+ * This function is not intended to be used directly.
+ * Use the available `getCache`, `setCache`, and `deleteCache` functions instead.
+ *
+ * @param {ClientOptions} clientOpts - Optional client options.
+ * @returns A promise of with Redis client.
+ *
+ * @throws {LesgoException} If there is an error creating the client.
+ *
+ * @example
+ * ```typescript
+ * import { getClient } from 'lesgo/utils/cache/redis';
+ *
+ * const client = await getClient();
+ *
+ * const key = 'myKey';
+ * const value = 'myValue';
+ *
+ * await client.set(key, value);
+ * ```
+ */
+const getClient = clientOpts => {
+  return getElastiCacheRedisClient(clientOpts);
+};
+export default getClient;

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

@@ -0,0 +1,4 @@
+export { default as deleteCache } from './deleteCache';
+export { default as getCache } from './getCache';
+export { default as getClient } from './getClient';
+export { default as setCache } from './setCache';

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

@@ -0,0 +1,4 @@
+export { default as deleteCache } from './deleteCache';
+export { default as getCache } from './getCache';
+export { default as getClient } from './getClient';
+export { default as setCache } from './setCache';

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

@@ -0,0 +1,25 @@
+import { ClientOptions } from '../../../types/aws';
+import { SetRedisCacheOptions } from '../../../services/ElastiCacheRedisService/setRedisCache';
+/**
+ * Sets a value in the Redis cache.
+ *
+ * @param {string} key - The key to set in the cache.
+ * @param {any} value - The value to set in the cache.
+ * @param {SetRedisCacheOptions} opts - Optional settings for setting the cache.
+ * @param {ClientOptions} clientOpts - Optional client options for connecting to Redis.
+ * @returns A promise that resolves when the value is successfully set in the cache.
+ *
+ * @throws {LesgoException} If there is an error setting the cache.
+ *
+ * @example
+ * ```typescript
+ * import { setCache } from 'lesgo/utils/cache/redis';
+ *
+ * const key = 'myKey';
+ * const value = 'myValue';
+ *
+ * await setCache(key, value);
+ * ```
+ */
+declare const setCache: (key: string, value: any, opts?: SetRedisCacheOptions, clientOpts?: ClientOptions) => Promise<"OK">;
+export default setCache;

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

@@ -0,0 +1,26 @@
+import { setRedisCache } from '../../../services/ElastiCacheRedisService';
+/**
+ * Sets a value in the Redis cache.
+ *
+ * @param {string} key - The key to set in the cache.
+ * @param {any} value - The value to set in the cache.
+ * @param {SetRedisCacheOptions} opts - Optional settings for setting the cache.
+ * @param {ClientOptions} clientOpts - Optional client options for connecting to Redis.
+ * @returns A promise that resolves when the value is successfully set in the cache.
+ *
+ * @throws {LesgoException} If there is an error setting the cache.
+ *
+ * @example
+ * ```typescript
+ * import { setCache } from 'lesgo/utils/cache/redis';
+ *
+ * const key = 'myKey';
+ * const value = 'myValue';
+ *
+ * await setCache(key, value);
+ * ```
+ */
+const setCache = (key, value, opts, clientOpts) => {
+  return setRedisCache(key, value, opts, clientOpts);
+};
+export default setCache;

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

@@ -0,0 +1,33 @@
+import { EncryptionAlgorithm } from './validateEncryptionFields';
+export interface DecryptOptions {
+    algorithm?: EncryptionAlgorithm;
+    secretKey?: string;
+}
+/**
+ * Decrypts the given encrypted text.
+ *
+ * @param text - The encrypted text to be decrypted.
+ * @param opts - Optional decryption options.
+ * @returns The decrypted text.
+ *
+ * @throws {LesgoException} If there is an error decrypting the text.
+ * @throws {LesgoException} If the text is not a string.
+ * @throws {LesgoException} If the text is not encrypted.
+ * @throws {LesgoException} If the algorithm is not valid.
+ * @throws {LesgoException} If the secret key is not valid.
+ * @throws {LesgoException} If the secret key is not provided.
+ * @throws {LesgoException} If the algorithm is not provided.
+ * @throws {LesgoException} If the text is not provided.
+ *
+ * @example
+ * ```typescript
+ * import { decrypt } from 'lesgo/utils/crypto';
+ *
+ * const encryptedText = 'encryptedText';
+ *
+ * const decryptedText = decrypt(encryptedText);
+ * console.log(decryptedText); // Decrypted text
+ * ```
+ */
+declare const decrypt: (text: string, opts?: DecryptOptions) => string;
+export default decrypt;