lesgo 0.7.8 → 2.1.0

package/dist/utils/crypto/decrypt.js

@@ -0,0 +1,59 @@
+import { createDecipheriv } from 'crypto';
+import cryptoConfig from '../../config/crypto';
+import {
+  validateEncryptionAlgorithm,
+  validateSecretKey,
+} from './validateEncryptionFields';
+import logger from '../logger';
+import validateFields from '../validateFields';
+const FILE = 'lesgo.utils.crypto.decrypt';
+/**
+ * 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
+ * ```
+ */
+const decrypt = (text, opts) => {
+  logger.debug(`${FILE}::DECRYPT`, { text });
+  const input = validateFields({ text }, [
+    { key: 'text', type: 'string', required: true },
+  ]);
+  const validAlgorithm =
+    (opts === null || opts === void 0 ? void 0 : opts.algorithm) ||
+    cryptoConfig.encryption.algorithm;
+  const validSecretKey =
+    (opts === null || opts === void 0 ? void 0 : opts.secretKey) ||
+    cryptoConfig.encryption.secretKey;
+  validateEncryptionAlgorithm(validAlgorithm);
+  validateSecretKey(validSecretKey, validAlgorithm);
+  const textParts = input.text.split(':');
+  const iv = Buffer.from(textParts.shift() || '', 'hex');
+  const encryptedText = Buffer.from(textParts.join(':'), 'hex');
+  const decipher = createDecipheriv(validAlgorithm, validSecretKey, iv);
+  let decrypted = decipher.update(encryptedText);
+  decrypted = Buffer.concat([decrypted, decipher.final()]);
+  const decryptedText = decrypted.toString();
+  logger.debug(`${FILE}::DECRYPTED_TEXT`, { decryptedText });
+  return decryptedText;
+};
+export default decrypt;

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

@@ -0,0 +1,31 @@
+import { EncryptionAlgorithm } from './validateEncryptionFields';
+export interface EncryptOptions {
+    algorithm?: EncryptionAlgorithm;
+    secretKey?: string;
+}
+/**
+ * Encrypts the given text using the specified options.
+ *
+ * @param text - The text to be encrypted.
+ * @param opts - Optional encryption options.
+ * @returns The encrypted text.
+ *
+ * @throws {LesgoException} If there is an error encrypting the text.
+ * @throws {LesgoException} If the text is not a string.
+ * @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.
+ *
+ * @example
+ * ```typescript
+ * import { encrypt } from 'lesgo/utils/crypto';
+ *
+ * const text = 'myText';
+ *
+ * const encryptedText = encrypt(text);
+ * console.log(encryptedText); // Encrypted text
+ * ```
+ */
+declare const encrypt: (text: string, opts?: EncryptOptions) => string;
+export default encrypt;

package/dist/utils/crypto/encrypt.js

@@ -0,0 +1,41 @@
+import { randomBytes, createCipheriv } from 'crypto';
+import validateEncryptionFields from './validateEncryptionFields';
+import logger from '../logger';
+const FILE = 'lesgo.utils.crypto.encrypt';
+/**
+ * Encrypts the given text using the specified options.
+ *
+ * @param text - The text to be encrypted.
+ * @param opts - Optional encryption options.
+ * @returns The encrypted text.
+ *
+ * @throws {LesgoException} If there is an error encrypting the text.
+ * @throws {LesgoException} If the text is not a string.
+ * @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.
+ *
+ * @example
+ * ```typescript
+ * import { encrypt } from 'lesgo/utils/crypto';
+ *
+ * const text = 'myText';
+ *
+ * const encryptedText = encrypt(text);
+ * console.log(encryptedText); // Encrypted text
+ * ```
+ */
+const encrypt = (text, opts) => {
+  logger.debug(`${FILE}::ENCRYPT`, { text });
+  const { validText, validAlgorithm, validIvLength, validSecretKey } =
+    validateEncryptionFields(text, opts);
+  const iv = randomBytes(validIvLength);
+  const cipher = createCipheriv(validAlgorithm, validSecretKey, iv);
+  let encrypted = cipher.update(validText);
+  encrypted = Buffer.concat([encrypted, cipher.final()]);
+  const encryptedText = `${iv.toString('hex')}:${encrypted.toString('hex')}`;
+  logger.debug(`${FILE}::ENCRYPTED_TEXT`, { encryptedText });
+  return encryptedText;
+};
+export default encrypt;

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

@@ -0,0 +1,31 @@
+export type HashAlgorithm = 'md5' | 'sha256' | 'sha512';
+export interface HashOptions {
+    algorithm?: HashAlgorithm;
+}
+/**
+ * Calculates the hash value of the given data using the specified algorithm.
+ *
+ * @param data - The data to be hashed.
+ * @param opts - Optional configuration for the hash algorithm.
+ * @returns The hashed value as a string.
+ *
+ * @throws {LesgoException} if an invalid hash algorithm is supplied.
+ * @throws {LesgoException} if the data is not a string.
+ * @throws {LesgoException} if the data is not provided.
+ * @throws {LesgoException} if the algorithm is not provided.
+ * @throws {LesgoException} if the algorithm is not valid.
+ * @throws {LesgoException} if the algorithm is not a string.
+ * @throws {LesgoException} if the algorithm is not a valid hash algorithm.
+ *
+ * @example
+ * ```typescript
+ * import { hash } from 'lesgo/utils/crypto';
+ *
+ * const data = 'myData';
+ *
+ * const hashedValue = hash(data);
+ * console.log(hashedValue); // Hashed value
+ * ```
+ */
+declare const hash: (data: string, opts?: HashOptions) => string;
+export default hash;

package/dist/utils/crypto/hash.js

@@ -0,0 +1,56 @@
+import { createHash } from 'crypto';
+import { crypto as cryptoConfig } from '../../config';
+import validateFields from '../validateFields';
+import { LesgoException } from '../../exceptions';
+const FILE = 'lesgo.utils.crypto.hash';
+const isHashAlgorithm = algorithm => {
+  return ['md5', 'sha256', 'sha512'].includes(algorithm);
+};
+/**
+ * Calculates the hash value of the given data using the specified algorithm.
+ *
+ * @param data - The data to be hashed.
+ * @param opts - Optional configuration for the hash algorithm.
+ * @returns The hashed value as a string.
+ *
+ * @throws {LesgoException} if an invalid hash algorithm is supplied.
+ * @throws {LesgoException} if the data is not a string.
+ * @throws {LesgoException} if the data is not provided.
+ * @throws {LesgoException} if the algorithm is not provided.
+ * @throws {LesgoException} if the algorithm is not valid.
+ * @throws {LesgoException} if the algorithm is not a string.
+ * @throws {LesgoException} if the algorithm is not a valid hash algorithm.
+ *
+ * @example
+ * ```typescript
+ * import { hash } from 'lesgo/utils/crypto';
+ *
+ * const data = 'myData';
+ *
+ * const hashedValue = hash(data);
+ * console.log(hashedValue); // Hashed value
+ * ```
+ */
+const hash = (data, opts) => {
+  const input = validateFields({ data }, [
+    { key: 'data', type: 'string', required: true },
+  ]);
+  const algorithmSupplied =
+    (opts === null || opts === void 0 ? void 0 : opts.algorithm) ||
+    cryptoConfig.hash.algorithm;
+  if (!isHashAlgorithm(algorithmSupplied)) {
+    throw new LesgoException(
+      'Invalid hash algorithm supplied',
+      `${FILE}::ERROR_INVALID_HASH_ALGORITHM`,
+      500,
+      {
+        algorithmSupplied,
+      }
+    );
+  }
+  const hashedValue = createHash(algorithmSupplied)
+    .update(input.data)
+    .digest('hex');
+  return hashedValue;
+};
+export default hash;

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

@@ -0,0 +1,3 @@
+export { default as decrypt } from './decrypt';
+export { default as encrypt } from './encrypt';
+export { default as hash } from './hash';

package/dist/utils/crypto/index.js

@@ -0,0 +1,3 @@
+export { default as decrypt } from './decrypt';
+export { default as encrypt } from './encrypt';
+export { default as hash } from './hash';

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

@@ -0,0 +1,19 @@
+export declare enum EncryptionAlgorithm {
+    AES128 = "aes-128-cbc",
+    AES192 = "aes-192-cbc",
+    AES256 = "aes-256-cbc",
+    AES512 = "aes-512-cbc"
+}
+interface ValidateEncryptionFieldsOptions {
+    algorithm?: EncryptionAlgorithm;
+    secretKey?: string;
+}
+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;
+    validAlgorithm: EncryptionAlgorithm;
+    validSecretKey: string;
+    validIvLength: number;
+};
+export default validateEncryptionFields;

package/dist/utils/crypto/validateEncryptionFields.js

@@ -0,0 +1,71 @@
+import { LesgoException } from '../../exceptions';
+import cryptoConfig from '../../config/crypto';
+import validateFields from '../validateFields';
+export var EncryptionAlgorithm;
+(function (EncryptionAlgorithm) {
+  EncryptionAlgorithm['AES128'] = 'aes-128-cbc';
+  EncryptionAlgorithm['AES192'] = 'aes-192-cbc';
+  EncryptionAlgorithm['AES256'] = 'aes-256-cbc';
+  EncryptionAlgorithm['AES512'] = 'aes-512-cbc';
+})(EncryptionAlgorithm || (EncryptionAlgorithm = {}));
+const FILE = 'lesgo.utils.crypto.validateEncryptionFields';
+export const validateEncryptionAlgorithm = algorithm => {
+  const input = validateFields({ algorithm }, [
+    { key: 'algorithm', type: 'string', required: true },
+  ]);
+  if (!Object.values(EncryptionAlgorithm).includes(input.algorithm)) {
+    throw new LesgoException(
+      'Invalid encryption algorithm supplied',
+      `${FILE}::ERROR_INVALID_ENCRYPTION_ALGORITHM`,
+      500,
+      {
+        algorithm,
+        allowedAlgorithms: Object.values(EncryptionAlgorithm),
+      }
+    );
+  }
+};
+export const validateSecretKey = (secretKey, algorithm) => {
+  const keyLengths = {
+    'aes-128-cbc': 16,
+    'aes-192-cbc': 24,
+    'aes-256-cbc': 32,
+    'aes-512-cbc': 64,
+  };
+  const input = validateFields({ secretKey, algorithm }, [
+    { key: 'algorithm', type: 'string', required: true },
+    { key: 'secretKey', type: 'string', required: true },
+  ]);
+  const keyLength = keyLengths[input.algorithm];
+  if (!keyLength) {
+    throw new LesgoException(
+      `Invalid secret key length for ${input.algorithm}`,
+      `${FILE}::ERROR_INVALID_SECRET_KEY_LENGTH`,
+      500,
+      {
+        secretKey,
+        keyLength,
+      }
+    );
+  }
+};
+const validateEncryptionFields = (text, opts) => {
+  const input = validateFields({ text }, [
+    { key: 'text', type: 'string', required: true },
+  ]);
+  const algorithmSupplied =
+    (opts === null || opts === void 0 ? void 0 : opts.algorithm) ||
+    cryptoConfig.encryption.algorithm;
+  const secretKeySupplied =
+    (opts === null || opts === void 0 ? void 0 : opts.secretKey) ||
+    cryptoConfig.encryption.secretKey;
+  validateEncryptionAlgorithm(algorithmSupplied);
+  validateSecretKey(secretKeySupplied, algorithmSupplied);
+  return {
+    validText: input.text,
+    validAlgorithm: algorithmSupplied,
+    validSecretKey: secretKeySupplied,
+    validIvLength: 16,
+  };
+};
+export default validateEncryptionFields;

package/dist/utils/db/mysql/proxy/disconnect.d.ts

@@ -0,0 +1,2 @@
+declare const disconnect: () => Promise<void>;
+export default disconnect;

package/dist/utils/db/mysql/proxy/disconnect.js

@@ -0,0 +1,5 @@
+import { disconnectMySQLProxyClient } from '../../../../services/RDSAuroraMySQLProxyService';
+const disconnect = () => {
+  return disconnectMySQLProxyClient();
+};
+export default disconnect;

package/dist/utils/db/mysql/proxy/disconnectDb.d.ts

@@ -0,0 +1,2 @@
+declare const disconnectDb: () => Promise<void>;
+export default disconnectDb;

package/dist/utils/db/mysql/proxy/disconnectDb.js

@@ -0,0 +1,5 @@
+import { disconnectMySQLProxyClient } from '../../../../services/RDSAuroraMySQLProxyService';
+const disconnectDb = () => {
+  return disconnectMySQLProxyClient();
+};
+export default disconnectDb;

package/dist/utils/db/mysql/proxy/getClient.d.ts

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

package/dist/utils/db/mysql/proxy/getClient.js

@@ -0,0 +1,5 @@
+import getClientService from '../../../../services/RDSAuroraMySQLProxyService/getMySQLProxyClient';
+const getClient = (connOptions, clientOpts) => {
+  return getClientService(connOptions, clientOpts);
+};
+export default getClient;

package/dist/utils/db/mysql/proxy/index.d.ts

@@ -0,0 +1,3 @@
+export { default as disconnectDb } from './disconnectDb';
+export { default as getClient } from './getClient';
+export { default as query } from './query';

package/dist/utils/db/mysql/proxy/index.js

@@ -0,0 +1,3 @@
+export { default as disconnectDb } from './disconnectDb';
+export { default as getClient } from './getClient';
+export { default as query } from './query';

package/dist/utils/db/mysql/proxy/query.d.ts

@@ -0,0 +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>;
+export default query;

package/dist/utils/db/mysql/proxy/query.js

@@ -0,0 +1,45 @@
+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 queryService from '../../../../services/RDSAuroraMySQLProxyService/query';
+const query = (sql, preparedValues, connOptions, clientOpts) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const [res] = yield queryService(
+      sql,
+      preparedValues,
+      connOptions,
+      clientOpts
+    );
+    return res;
+  });
+export default query;

package/dist/utils/dynamodb/deleteRecord.d.ts

@@ -0,0 +1,5 @@
+import { ClientOptions } from '../../types/aws';
+import { Key } from '../../services/DynamoDbService/deleteRecord';
+import { DeleteCommandInput } from '@aws-sdk/lib-dynamodb';
+declare const deleteRecord: (key: Key, tableAlias: string, opts?: DeleteCommandInput, clientOpts?: ClientOptions) => Promise<import("@aws-sdk/lib-dynamodb").DeleteCommandOutput>;
+export default deleteRecord;

package/dist/utils/dynamodb/deleteRecord.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 deleteRecordService from '../../services/DynamoDbService/deleteRecord';
+const deleteRecord = (key, tableAlias, opts, clientOpts) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    return deleteRecordService(key, tableAlias, opts, clientOpts);
+  });
+export default deleteRecord;

package/dist/utils/dynamodb/getClient.d.ts

@@ -0,0 +1,3 @@
+import { ClientOptions } from '../../types/aws';
+declare const getClient: (opts?: ClientOptions) => import("@aws-sdk/lib-dynamodb").DynamoDBDocumentClient;
+export default getClient;

package/dist/utils/dynamodb/getClient.js

@@ -0,0 +1,5 @@
+import getClientService from '../../services/DynamoDbService/getClient';
+const getClient = opts => {
+  return getClientService(opts);
+};
+export default getClient;

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

@@ -0,0 +1,6 @@
+export { default as deleteRecord } from './deleteRecord';
+export { default as getClient } from './getClient';
+export { default as putRecord } from './putRecord';
+export { default as query } from './query';
+export { default as scan } from './scan';
+export { default as updateRecord } from './updateRecord';

package/dist/utils/dynamodb/index.js

@@ -0,0 +1,6 @@
+export { default as deleteRecord } from './deleteRecord';
+export { default as getClient } from './getClient';
+export { default as putRecord } from './putRecord';
+export { default as query } from './query';
+export { default as scan } from './scan';
+export { default as updateRecord } from './updateRecord';

package/dist/utils/dynamodb/putRecord.d.ts

@@ -0,0 +1,4 @@
+import { ClientOptions } from '../../types/aws';
+import { Item, PutRecordOptions } from '../../services/DynamoDbService/putRecord';
+declare const putRecord: (item: Item, tableAlias: string, opts?: PutRecordOptions, clientOpts?: ClientOptions) => Promise<import("@aws-sdk/lib-dynamodb").PutCommandOutput>;
+export default putRecord;

package/dist/utils/dynamodb/putRecord.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 putRecordService from '../../services/DynamoDbService/putRecord';
+const putRecord = (item, tableAlias, opts, clientOpts) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    return putRecordService(item, tableAlias, opts, clientOpts);
+  });
+export default putRecord;

package/dist/utils/dynamodb/query.d.ts

@@ -0,0 +1,5 @@
+import { ClientOptions } from '../../types/aws';
+import { QueryOptions } from '../../services/DynamoDbService/query';
+import { NativeAttributeValue } from '@aws-sdk/lib-dynamodb';
+export declare const query: (tableAlias: string, keyConditionExpression: string, expressionAttributeValues: Record<string, NativeAttributeValue>, opts?: QueryOptions, clientOpts?: ClientOptions) => Promise<Record<string, any>[]>;
+export default query;

package/dist/utils/dynamodb/query.js

@@ -0,0 +1,52 @@
+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 queryService from '../../services/DynamoDbService/query';
+export const query = (
+  tableAlias,
+  keyConditionExpression,
+  expressionAttributeValues,
+  opts,
+  clientOpts
+) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const data = yield queryService(
+      tableAlias,
+      keyConditionExpression,
+      expressionAttributeValues,
+      opts,
+      clientOpts
+    );
+    return (data === null || data === void 0 ? void 0 : data.Items) || [];
+  });
+export default query;

package/dist/utils/dynamodb/scan.d.ts

@@ -0,0 +1,4 @@
+import { ClientOptions } from '../../types/aws';
+import { ScanOptions } from '../../services/DynamoDbService/scan';
+export declare const scan: (tableAlias: string, opts?: ScanOptions, clientOpts?: ClientOptions) => Promise<Record<string, any>[]>;
+export default scan;

package/dist/utils/dynamodb/scan.js

@@ -0,0 +1,40 @@
+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 scanService from '../../services/DynamoDbService/scan';
+export const scan = (tableAlias, opts, clientOpts) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const data = yield scanService(tableAlias, opts, clientOpts);
+    return (data === null || data === void 0 ? void 0 : data.Items) || [];
+  });
+export default scan;

package/dist/utils/dynamodb/updateRecord.d.ts

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