lesgo 1.0.0 → 2.1.0

package/dist/services/RDSAuroraMySQLProxyService/query.js

@@ -0,0 +1,63 @@
+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 getClient from './getMySQLProxyClient';
+const FILE = 'lesgo.services.RDSAuroraMySQLService.query';
+const query = (sql, preparedValues, connOptions, clientOpts) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const input = validateFields({ sql, preparedValues }, [
+      { key: 'sql', type: 'string', required: true },
+      { key: 'preparedValues', type: 'array', required: false },
+    ]);
+    const connection = yield getClient(connOptions, clientOpts);
+    try {
+      const resp = yield connection.execute(input.sql, input.preparedValues);
+      logger.debug(`${FILE}::RECEIVED_RESPONSE`, {
+        result: resp[0],
+        sql,
+        preparedValues,
+      });
+      return resp;
+    } catch (err) {
+      throw new LesgoException('Failed to query', `${FILE}::QUERY_ERROR`, 500, {
+        err,
+        sql,
+        preparedValues,
+        connOptions,
+        clientOpts,
+      });
+    }
+  });
+export default query;

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

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

package/dist/services/S3Service/getClient.js

@@ -0,0 +1,28 @@
+import { S3Client } from '@aws-sdk/client-s3';
+import { logger, isEmpty, validateFields } from '../../utils';
+import { s3 as s3Config } from '../../config';
+const FILE = 'lesgo.services.S3Service.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 || s3Config.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 S3Client({ region });
+  logger.debug(`${FILE}::NEW_CLIENT`, {
+    client,
+    region,
+  });
+  singleton[singletonConn] = client;
+  return client;
+};
+export default getClient;

package/dist/services/S3Service/getDownloadSignedUrl.d.ts

@@ -0,0 +1,7 @@
+import { ClientOptions } from '../../types/aws';
+import { GetObjectOptions } from './getObject';
+export interface GetSignedUrlOptions {
+    expiresIn?: number;
+}
+declare const getDownloadSignedUrl: (key: string, opts?: GetObjectOptions, signingOpts?: GetSignedUrlOptions, clientOpts?: ClientOptions) => Promise<string>;
+export default getDownloadSignedUrl;

package/dist/services/S3Service/getDownloadSignedUrl.js

@@ -0,0 +1,58 @@
+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 { GetObjectCommand } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import s3Config from '../../config/s3';
+import { validateFields } from '../../utils';
+import getClient from './getClient';
+const getDownloadSignedUrl = (key, opts, signingOpts, clientOpts) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const input = validateFields({ key }, [
+      { key: 'key', type: 'string', required: true },
+    ]);
+    const client = getClient(clientOpts);
+    const commandInput = Object.assign(
+      {
+        Bucket:
+          (opts === null || opts === void 0 ? void 0 : opts.Bucket) ||
+          s3Config.bucket,
+        Key: input.key,
+      },
+      opts
+    );
+    const command = new GetObjectCommand(commandInput);
+    signingOpts = Object.assign({ expiresIn: 3600 }, signingOpts);
+    return getSignedUrl(client, command, signingOpts);
+  });
+export default getDownloadSignedUrl;

package/dist/services/S3Service/getHeadObject.d.ts

@@ -0,0 +1,13 @@
+import { HeadObjectCommandInput } from '@aws-sdk/client-s3';
+import { ClientOptions } from '../../types/aws';
+export type HeadObjectOptions = Omit<HeadObjectCommandInput, 'Key'> & {
+    Key?: string;
+};
+declare const getHeadObject: (key: string, opts?: HeadObjectOptions, clientOpts?: ClientOptions) => Promise<{
+    LastModified: Date | undefined;
+    ContentLength: number | undefined;
+    ETag: string | undefined;
+    ContentType: string | undefined;
+    Metadata: Record<string, string> | undefined;
+}>;
+export default getHeadObject;

package/dist/services/S3Service/getHeadObject.js

@@ -0,0 +1,83 @@
+var __awaiter =
+  (this && this.__awaiter) ||
+  function (thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P
+        ? value
+        : new P(function (resolve) {
+            resolve(value);
+          });
+    }
+    return new (P || (P = Promise))(function (resolve, reject) {
+      function fulfilled(value) {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function rejected(value) {
+        try {
+          step(generator['throw'](value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function step(result) {
+        result.done
+          ? resolve(result.value)
+          : adopt(result.value).then(fulfilled, rejected);
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  };
+import { HeadObjectCommand } from '@aws-sdk/client-s3';
+import s3Config from '../../config/s3';
+import LesgoException from '../../exceptions/LesgoException';
+import { logger, validateFields } from '../../utils';
+import getClient from './getClient';
+const FILE = 'lesgo.services.S3Service.getHeadObject';
+const getHeadObject = (key, opts, clientOpts) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const input = validateFields({ key }, [
+      { key: 'key', type: 'string', required: true },
+    ]);
+    const client = getClient(clientOpts);
+    const commandInput = Object.assign(
+      {
+        Bucket:
+          (opts === null || opts === void 0 ? void 0 : opts.Bucket) ||
+          s3Config.bucket,
+        Key: input.key,
+      },
+      opts
+    );
+    try {
+      const response = yield client.send(new HeadObjectCommand(commandInput));
+      const { LastModified, ContentLength, ETag, ContentType, Metadata } =
+        response;
+      logger.debug(`${FILE}::RESPONSE`, {
+        LastModified,
+        ContentLength,
+        ETag,
+        ContentType,
+        Metadata,
+        response,
+        commandInput,
+      });
+      return { LastModified, ContentLength, ETag, ContentType, Metadata };
+    } catch (error) {
+      throw new LesgoException(
+        'Error occurred getting object metadata from S3 bucket',
+        `${FILE}::ERROR`,
+        500,
+        {
+          error,
+          commandInput,
+          opts,
+          clientOpts,
+        }
+      );
+    }
+  });
+export default getHeadObject;

package/dist/services/S3Service/getObject.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { GetObjectCommandInput } from '@aws-sdk/client-s3';
+import { ClientOptions } from '../../types/aws';
+export interface GetObjectOptions extends Partial<Omit<GetObjectCommandInput, 'Key' | 'Bucket'>> {
+    Key?: string;
+    Bucket?: string;
+}
+export declare const streamToBuffer: (stream?: any) => Promise<Buffer>;
+declare const getObject: (key: string, opts?: GetObjectOptions, clientOpts?: ClientOptions) => Promise<import("@aws-sdk/client-s3").GetObjectCommandOutput>;
+export default getObject;

package/dist/services/S3Service/getObject.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 { GetObjectCommand } from '@aws-sdk/client-s3';
+import { Readable } from 'stream';
+import LesgoException from '../../exceptions/LesgoException';
+import s3Config from '../../config/s3';
+import { logger, validateFields } from '../../utils';
+import getClient from './getClient';
+const FILE = 'lesgo.services.S3Service.getObject';
+export const streamToBuffer = stream =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    if (!stream || !(stream instanceof Readable)) {
+      throw new LesgoException(
+        'Data is not a readable stream',
+        `${FILE}::ERROR_NOT_READABLE_STREAM`
+      );
+    }
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      stream.on('data', chunk => chunks.push(chunk));
+      stream.on('error', reject);
+      stream.on('end', () => resolve(Buffer.concat(chunks)));
+    });
+  });
+const getObject = (key, opts, clientOpts) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const input = validateFields({ key }, [
+      { key: 'key', type: 'string', required: true },
+    ]);
+    const client = getClient(clientOpts);
+    const commandInput = Object.assign(
+      {
+        Bucket:
+          (opts === null || opts === void 0 ? void 0 : opts.Bucket) ||
+          s3Config.bucket,
+        Key: input.key,
+      },
+      opts
+    );
+    try {
+      const resp = yield client.send(new GetObjectCommand(commandInput));
+      logger.debug(`${FILE}::RESPONSE`, { commandInput });
+      return resp;
+    } catch (error) {
+      throw new LesgoException(
+        'Error occurred getting object from S3 bucket',
+        `${FILE}::ERROR`,
+        500,
+        {
+          error,
+          commandInput,
+          opts,
+          clientOpts,
+        }
+      );
+    }
+  });
+export default getObject;

package/dist/services/S3Service/getUploadSignedUrl.d.ts

@@ -0,0 +1,7 @@
+import { ClientOptions } from '../../types/aws';
+import { PutObjectOptions } from './putObject';
+export interface GetSignedUrlOptions {
+    expiresIn?: number;
+}
+declare const getUploadSignedUrl: (key: string, opts?: PutObjectOptions, signingOpts?: GetSignedUrlOptions, clientOpts?: ClientOptions) => Promise<string>;
+export default getUploadSignedUrl;

package/dist/services/S3Service/getUploadSignedUrl.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());
+    });
+  };
+import { PutObjectCommand } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { logger, validateFields } from '../../utils';
+import s3Config from '../../config/s3';
+import getClient from './getClient';
+const FILE = 'lesgo.services.S3Service.getUploadSignedUrl';
+const getUploadSignedUrl = (key, opts, signingOpts, clientOpts) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const input = validateFields({ key }, [
+      { key: 'key', type: 'string', required: true },
+    ]);
+    const client = getClient(clientOpts);
+    const commandInput = Object.assign(
+      {
+        Bucket:
+          (opts === null || opts === void 0 ? void 0 : opts.Bucket) ||
+          s3Config.bucket,
+        Key: input.key,
+      },
+      opts
+    );
+    const command = new PutObjectCommand(commandInput);
+    signingOpts = Object.assign({ expiresIn: 3600 }, signingOpts);
+    const resp = yield getSignedUrl(client, command, signingOpts);
+    logger.debug(`${FILE}::RESPONSE`, { resp, commandInput, signingOpts });
+    return resp;
+  });
+export default getUploadSignedUrl;

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

@@ -0,0 +1,6 @@
+export { default as getClient } from './getClient';
+export { default as getDownloadSignedUrl } from './getDownloadSignedUrl';
+export { default as getHeadObject } from './getHeadObject';
+export { default as getObject } from './getObject';
+export { default as getUploadSignedUrl } from './getUploadSignedUrl';
+export { default as putObject } from './putObject';

package/dist/services/S3Service/index.js

@@ -0,0 +1,6 @@
+export { default as getClient } from './getClient';
+export { default as getDownloadSignedUrl } from './getDownloadSignedUrl';
+export { default as getHeadObject } from './getHeadObject';
+export { default as getObject } from './getObject';
+export { default as getUploadSignedUrl } from './getUploadSignedUrl';
+export { default as putObject } from './putObject';

package/dist/services/S3Service/putObject.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { PutObjectCommandInput } from '@aws-sdk/client-s3';
+import { ClientOptions } from '../../types/aws';
+export interface PutObjectOptions extends Partial<Omit<PutObjectCommandInput, 'Key' | 'Bucket'>> {
+    Key?: string;
+    Bucket?: string;
+}
+declare const putObject: (key: string, file: Buffer | Uint8Array | Blob | string, opts?: PutObjectOptions, clientOpts?: ClientOptions) => Promise<import("@aws-sdk/client-s3").PutObjectCommandOutput>;
+export default putObject;

package/dist/services/S3Service/putObject.js

@@ -0,0 +1,77 @@
+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 { PutObjectCommand } from '@aws-sdk/client-s3';
+import LesgoException from '../../exceptions/LesgoException';
+import s3Config from '../../config/s3';
+import { logger, validateFields } from '../../utils';
+import getClient from './getClient';
+const FILE = 'lesgo.services.S3Service.putObject';
+const putObject = (key, file, opts, clientOpts) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const input = validateFields({ key }, [
+      { key: 'key', type: 'string', required: true },
+    ]);
+    const client = getClient(clientOpts);
+    const commandInput = Object.assign(
+      {
+        Bucket:
+          (opts === null || opts === void 0 ? void 0 : opts.Bucket) ||
+          s3Config.bucket,
+        Key: input.key,
+        Body: file,
+        StorageClass:
+          (opts === null || opts === void 0 ? void 0 : opts.StorageClass) ||
+          'STANDARD',
+      },
+      opts
+    );
+    try {
+      const response = yield client.send(new PutObjectCommand(commandInput));
+      logger.debug(`${FILE}::RESPONSE`, { response, commandInput });
+      return response;
+    } catch (error) {
+      throw new LesgoException(
+        'Error occurred putting object to S3 bucket',
+        `${FILE}::ERROR`,
+        500,
+        {
+          error,
+          commandInput,
+          opts,
+          clientOpts,
+        }
+      );
+    }
+  });
+export default putObject;

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

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

package/dist/services/SQSService/deleteMessage.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 { DeleteMessageCommand } 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.deleteMessage';
+const deleteMessage = (queue, receiptHandle, opts, clientOpts) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const queueUrl = getQueueUrl(queue);
+    const input = validateFields({ receiptHandle }, [
+      { key: 'receiptHandle', type: 'string', required: true },
+    ]);
+    const client = getClient(clientOpts);
+    const commandInput = Object.assign(
+      { QueueUrl: queueUrl, ReceiptHandle: input.receiptHandle },
+      opts
+    );
+    try {
+      yield client.send(new DeleteMessageCommand(commandInput));
+      logger.debug(`${FILE}::MESSAGE_DELETED_FROM_QUEUE`, {
+        commandInput,
+      });
+    } catch (error) {
+      throw new LesgoException(
+        'Error occurred deleting message from queue',
+        `${FILE}::DELETE_MESSAGE_ERROR`,
+        500,
+        {
+          error,
+          commandInput,
+          opts,
+        }
+      );
+    }
+  });
+export default deleteMessage;

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

@@ -0,0 +1,9 @@
+import { SendMessageCommandInput } from '@aws-sdk/client-sqs';
+import { ClientOptions } from '../../types/aws';
+import { Queue } from './getQueueUrl';
+export interface DispatchOptions extends Partial<Omit<SendMessageCommandInput, 'QueueUrl' | 'MessageBody'>> {
+    QueueUrl?: string;
+    MessageBody?: string;
+}
+declare const dispatch: (payload: Record<any, any>, queue: string | Queue, opts?: DispatchOptions, clientOpts?: ClientOptions) => Promise<import("@aws-sdk/client-sqs").SendMessageCommandOutput>;
+export default dispatch;