lesgo 1.0.0 → 2.1.1

package/dist/services/DynamoDbService/query.js

@@ -0,0 +1,78 @@
+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 { QueryCommand } from '@aws-sdk/lib-dynamodb';
+import LesgoException from '../../exceptions/LesgoException';
+import { validateFields, logger } from '../../utils';
+import getClient from './getClient';
+import getTableName from './getTableName';
+const FILE = 'lesgo.services.DynamoDbService.query';
+const query = (
+  tableAlias,
+  keyConditionExpression,
+  expressionAttributeValues,
+  opts,
+  clientOpts
+) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const input = validateFields(
+      { tableAlias, keyConditionExpression, expressionAttributeValues },
+      [
+        { key: 'tableAlias', type: 'string', required: true },
+        { key: 'keyConditionExpression', type: 'string', required: true },
+        { key: 'expressionAttributeValues', type: 'object', required: true },
+      ]
+    );
+    const tableName = getTableName(input.tableAlias);
+    const client = getClient(clientOpts);
+    const commandInput = Object.assign(
+      {
+        TableName: tableName,
+        KeyConditionExpression: input.keyConditionExpression,
+        ExpressionAttributeValues: input.expressionAttributeValues,
+      },
+      opts
+    );
+    try {
+      const data = yield client.send(new QueryCommand(commandInput));
+      logger.debug(`${FILE}::RECEIVED_RESPONSE`, { data, commandInput });
+      return data;
+    } catch (error) {
+      throw new LesgoException('Failed to query', `${FILE}::ERROR`, 500, {
+        error,
+        commandInput,
+        opts,
+      });
+    }
+  });
+export default query;

package/dist/services/DynamoDbService/scan.d.ts

@@ -0,0 +1,7 @@
+import { ScanCommandInput } from '@aws-sdk/lib-dynamodb';
+import { ClientOptions } from '../../types/aws';
+export interface ScanOptions extends Partial<Omit<ScanCommandInput, 'TableName'>> {
+    TableName?: string;
+}
+declare const scan: (tableAlias: string, opts?: ScanOptions, clientOpts?: ClientOptions) => Promise<import("@aws-sdk/lib-dynamodb").ScanCommandOutput>;
+export default scan;

package/dist/services/DynamoDbService/scan.js

@@ -0,0 +1,60 @@
+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 { ScanCommand } from '@aws-sdk/lib-dynamodb';
+import LesgoException from '../../exceptions/LesgoException';
+import { validateFields, logger } from '../../utils';
+import getClient from './getClient';
+import getTableName from './getTableName';
+const FILE = 'lesgo.services.DynamoDbService.scan';
+const scan = (tableAlias, opts, clientOpts) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const input = validateFields(Object.assign({ tableAlias }, opts), [
+      { key: 'tableAlias', type: 'string', required: true },
+    ]);
+    const tableName = getTableName(input.tableAlias);
+    const client = getClient(clientOpts);
+    const commandInput = Object.assign({ TableName: tableName }, opts);
+    try {
+      const data = yield client.send(new ScanCommand(commandInput));
+      logger.debug(`${FILE}::RECEIVED_RESPONSE`, { data, commandInput });
+      return data;
+    } catch (error) {
+      throw new LesgoException('Failed to scan', `${FILE}::ERROR`, 500, {
+        error,
+        commandInput,
+        opts,
+      });
+    }
+  });
+export default scan;

package/dist/services/DynamoDbService/updateRecord.d.ts

@@ -0,0 +1,9 @@
+import { NativeAttributeValue, UpdateCommandInput } from '@aws-sdk/lib-dynamodb';
+import { ClientOptions } from '../../types/aws';
+export type Key = Record<string, NativeAttributeValue>;
+export type UpdateRecordOptions = Omit<UpdateCommandInput, 'TableName' | 'Key'> & {
+    TableName?: string;
+    Key?: Record<string, NativeAttributeValue> | undefined;
+};
+declare const updateRecord: (key: Record<string, string>, tableAlias: string, updateExpression: string, expressionAttributeValues: Record<string, NativeAttributeValue>, opts?: UpdateRecordOptions, clientOpts?: ClientOptions) => Promise<import("@aws-sdk/lib-dynamodb").UpdateCommandOutput>;
+export default updateRecord;

package/dist/services/DynamoDbService/updateRecord.js

@@ -0,0 +1,89 @@
+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 { UpdateCommand } from '@aws-sdk/lib-dynamodb';
+import LesgoException from '../../exceptions/LesgoException';
+import { logger, validateFields } from '../../utils';
+import getClient from './getClient';
+import getTableName from './getTableName';
+const FILE = 'lesgo.services.DynamoDbService.updateRecord';
+const updateRecord = (
+  key,
+  tableAlias,
+  updateExpression,
+  expressionAttributeValues,
+  opts,
+  clientOpts
+) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const input = validateFields(
+      Object.assign(
+        { key, tableAlias, updateExpression, expressionAttributeValues },
+        opts
+      ),
+      [
+        { key: 'key', type: 'object', required: true },
+        { key: 'tableAlias', type: 'string', required: true },
+        { key: 'updateExpression', type: 'string', required: true },
+        { key: 'expressionAttributeValues', type: 'object', required: true },
+      ]
+    );
+    const tableName = getTableName(input.tableAlias);
+    const client = getClient(clientOpts);
+    const commandInput = Object.assign(
+      {
+        TableName: tableName,
+        Key: input.key,
+        UpdateExpression: input.updateExpression,
+        ExpressionAttributeValues: input.expressionAttributeValues,
+      },
+      opts
+    );
+    try {
+      const data = yield client.send(new UpdateCommand(commandInput));
+      logger.debug(`${FILE}::RECEIVED_RESPONSE`, { data, commandInput });
+      return data;
+    } catch (error) {
+      throw new LesgoException(
+        'Failed to update record',
+        `${FILE}::ERROR`,
+        500,
+        {
+          error,
+          commandInput,
+          opts,
+        }
+      );
+    }
+  });
+export default updateRecord;

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

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

package/dist/services/ElastiCacheRedisService/deleteRedisCache.js

@@ -0,0 +1,62 @@
+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.deleteRedisCache';
+const deleteRedisCache = (key, 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;
+    try {
+      resp = yield client.del(input.key);
+      logger.debug(`${FILE}::RECEIVED_RESPONSE`, { resp, input });
+      return resp;
+    } catch (err) {
+      throw new LesgoException(
+        'Failed to delete redis cache',
+        `${FILE}::DELETE_ERROR`,
+        500,
+        {
+          err,
+          input,
+          clientOpts,
+        }
+      );
+    }
+  });
+export default deleteRedisCache;

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

@@ -0,0 +1,11 @@
+/**
+ * Disconnects the ElastiCache Redis client.
+ *
+ * It is important to disconnect the ElastiCache Redis client
+ * when it is no longer needed to prevent memory leaks and to free up resources,
+ * especially for serverless applications on Lambda function.
+ *
+ * @returns {Promise<void>} A promise that resolves when the disconnection is completed.
+ */
+declare const disconnectElastiCacheRedisClient: () => Promise<void>;
+export default disconnectElastiCacheRedisClient;

package/dist/services/ElastiCacheRedisService/disconnectElastiCacheRedisClient.js

@@ -0,0 +1,69 @@
+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 } from '../../utils';
+import { singleton } from '../ElastiCacheRedisService/getElastiCacheRedisClient';
+const FILE =
+  'lesgo.services.ElastiCacheRedisService.disconnectElastiCacheRedisClient';
+/**
+ * Disconnects the ElastiCache Redis client.
+ *
+ * It is important to disconnect the ElastiCache Redis client
+ * when it is no longer needed to prevent memory leaks and to free up resources,
+ * especially for serverless applications on Lambda function.
+ *
+ * @returns {Promise<void>} A promise that resolves when the disconnection is completed.
+ */
+const disconnectElastiCacheRedisClient = () =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const singletonConns = Object.keys(singleton);
+    if (singletonConns.length === 0) {
+      logger.debug(`${FILE}::NO_CONNECTIONS_TO_DISCONNECT`);
+      return;
+    }
+    logger.debug(`${FILE}::PREPARING_TO_DISCONNECT`, {
+      singletonConns,
+    });
+    singletonConns.forEach(singletonConn =>
+      __awaiter(void 0, void 0, void 0, function* () {
+        try {
+          yield singleton[singletonConn].quit();
+          delete singleton[singletonConn];
+          logger.debug(`${FILE}::COMPLETED`, { singletonConn });
+        } catch (err) {
+          logger.error(`${FILE}::ERROR`, { singletonConn, err });
+        }
+      })
+    );
+  });
+export default disconnectElastiCacheRedisClient;

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

@@ -0,0 +1,12 @@
+import { Cluster } from 'ioredis';
+import { ClientOptions } from '../../types/aws';
+export interface Singleton {
+    [key: string]: Cluster;
+}
+export declare const singleton: Singleton;
+export interface ElastiCacheRedisClientOptions extends ClientOptions {
+    endpoint?: string;
+    port?: number;
+}
+declare const getElastiCacheRedisClient: (clientOpts?: ElastiCacheRedisClientOptions) => Promise<Cluster>;
+export default getElastiCacheRedisClient;

package/dist/services/ElastiCacheRedisService/getElastiCacheRedisClient.js

@@ -0,0 +1,114 @@
+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 { Cluster } from 'ioredis';
+import { elasticache as elasticacheConfig } from '../../config';
+import { logger, isEmpty, validateFields } from '../../utils';
+import { LesgoException } from '../../exceptions';
+const FILE = 'lesgo.services.ElastiCacheRedisService.getClient';
+export const singleton = {};
+const getElastiCacheRedisClient = clientOpts =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const options = validateFields(clientOpts || {}, [
+      { key: 'singletonConn', type: 'string', required: false },
+      { key: 'endpoint', type: 'string', required: false },
+      { key: 'port', type: 'number', required: false },
+    ]);
+    const singletonConn = options.singletonConn || 'default';
+    if (!isEmpty(singleton[singletonConn])) {
+      logger.debug(`${FILE}::REUSE_ELASTICACHE_REDIS_CONNECTION`);
+      return singleton[singletonConn];
+    }
+    const clusterEndpoint =
+      options.endpoint || elasticacheConfig.redis.endpoint;
+    const clusterPort = options.port || elasticacheConfig.redis.port || 6379;
+    if (!clusterEndpoint) {
+      throw new LesgoException(
+        'Missing ElastiCache Redis endpoint',
+        `${FILE}::MISSING_ENDPOINT`,
+        500,
+        { options, elasticacheConfig }
+      );
+    }
+    const redisClient = new Cluster(
+      [
+        {
+          host: clusterEndpoint,
+          port: clusterPort,
+        },
+      ],
+      {
+        dnsLookup: (address, callback) => callback(null, address),
+        redisOptions: {
+          tls: {},
+        },
+      }
+    );
+    redisClient.on('error', err => {
+      logger.error(`${FILE}::REDIS_CLIENT_NOT_CONNECTED_ERROR`, { err });
+    });
+    redisClient.on('connect', () => {
+      logger.debug(`${FILE}::REDIS_CLIENT_CONNECTED`);
+    });
+    try {
+      yield redisClient.connect();
+    } catch (error) {
+      // Not ideal to base on error message but ioredis doesn't have a better way to check if it's already connected
+      if (error.message === 'Redis is already connecting/connected') {
+        logger.debug(`${FILE}::REDIS_ALREADY_CONNECTED`, {
+          error,
+          errorMessage:
+            error === null || error === void 0 ? void 0 : error.message,
+          clusterEndpoint,
+          clusterPort,
+        });
+      } else {
+        throw new LesgoException(
+          'Failed to connect to ElastiCache Redis',
+          `${FILE}::REDIS_CONNECT_ERROR`,
+          500,
+          {
+            error,
+            errorMessage:
+              error === null || error === void 0 ? void 0 : error.message,
+            clusterEndpoint,
+            clusterPort,
+          }
+        );
+      }
+    }
+    singleton[singletonConn] = redisClient;
+    logger.debug(`${FILE}::NEW_ELASTICACHE_REDIS_CONNECTION`);
+    return redisClient;
+  });
+export default getElastiCacheRedisClient;

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

@@ -0,0 +1,3 @@
+import { ClientOptions } from '../../types/aws';
+declare const getRedisCache: (key: string, clientOpts?: ClientOptions) => Promise<any>;
+export default getRedisCache;

package/dist/services/ElastiCacheRedisService/getRedisCache.js

@@ -0,0 +1,70 @@
+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 { isEmpty, logger, validateFields } from '../../utils';
+import { LesgoException } from '../../exceptions';
+import getElastiCacheRedisClient from './getElastiCacheRedisClient';
+const FILE = 'lesgo.services.ElastiCacheRedis.getRedisCache';
+const getRedisCache = (key, 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;
+    try {
+      resp = yield client.get(input.key);
+      logger.debug(`${FILE}::RECEIVED_RESPONSE`, { resp, input });
+    } catch (err) {
+      throw new LesgoException(
+        'Failed to get redis cache',
+        `${FILE}::GET_ERROR`,
+        500,
+        {
+          err,
+          input,
+          clientOpts,
+        }
+      );
+    }
+    try {
+      if (isEmpty(resp) || !resp) return resp;
+      const data = JSON.parse(resp);
+      logger.debug(`${FILE}::DATA_IS_JSON`, { data });
+      return data;
+    } catch (e) {
+      logger.debug(`${FILE}::DATA_NOT_JSON`, { resp });
+      return resp;
+    }
+  });
+export default getRedisCache;

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

@@ -0,0 +1,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 setRedisCache } from './setRedisCache';

package/dist/services/ElastiCacheRedisService/index.js

@@ -0,0 +1,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 setRedisCache } from './setRedisCache';

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

@@ -0,0 +1,6 @@
+import { ClientOptions } from '../../types/aws';
+export interface SetRedisCacheOptions {
+    EX?: number;
+}
+declare const setRedisCache: (key: string, value: any, opts?: SetRedisCacheOptions, clientOpts?: ClientOptions) => Promise<"OK">;
+export default setRedisCache;