lesgo 0.7.8 → 2.1.0

package/dist/middlewares/httpResponseMiddleware.js

@@ -0,0 +1,128 @@
+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 } from '../utils';
+const FILE = 'lesgo.middlewares.httpResponseMiddleware';
+const defaultOptions = {
+  debugMode: false,
+  headers: {
+    'Access-Control-Allow-Origin': '*',
+    'Cache-Control': 'no-cache',
+    'Content-Type': 'application/json',
+  },
+  isBase64Encoded: false,
+};
+const httpResponseMiddleware = (opts = {}) => {
+  const options = Object.assign(
+    Object.assign(Object.assign({}, defaultOptions), opts),
+    {
+      headers: Object.assign(
+        Object.assign({}, defaultOptions.headers),
+        opts.headers
+      ),
+    }
+  );
+  const httpResponseMiddlewareAfter = request =>
+    __awaiter(void 0, void 0, void 0, function* () {
+      var _a;
+      let body;
+      if (options.headers['Content-Type'] !== 'application/json') {
+        body = request.response;
+      } else {
+        body = {
+          status: 'success',
+          data: request.response,
+          _meta: options.debugMode ? request.event : {},
+        };
+      }
+      const responseData = {
+        statusCode: 200,
+        headers: Object.assign(
+          Object.assign({}, options.headers),
+          (_a = request.response) === null || _a === void 0
+            ? void 0
+            : _a.headers
+        ),
+        body,
+        isBase64Encoded: options.isBase64Encoded,
+      };
+      logger.debug(`${FILE}::RESPONSE_DATA_SUCCESS`, responseData);
+      request.response = Object.assign(Object.assign({}, responseData), {
+        body:
+          options.headers['Content-Type'] === 'application/json'
+            ? JSON.stringify(responseData.body)
+            : responseData.body,
+      });
+    });
+  const httpResponseMiddlewareOnError = request =>
+    __awaiter(void 0, void 0, void 0, function* () {
+      var _b;
+      const error = request.error;
+      if (error.extra && error.extra.statusCode) {
+        delete error.extra.statusCode;
+      }
+      const responseData = {
+        statusCode: error.statusCode || 500,
+        headers: Object.assign(
+          Object.assign({}, options.headers),
+          (_b = request.response) === null || _b === void 0
+            ? void 0
+            : _b.headers
+        ),
+        body: {
+          status: 'error',
+          data: null,
+          error: {
+            code: error.code || 'UNHANDLED_ERROR',
+            message: error.message || 'Unhandled error occurred',
+            details: error.extra || {},
+          },
+          _meta: options.debugMode ? request.event : {},
+        },
+      };
+      logger.debug(`${FILE}::RESPONSE_DATA_ERROR`, responseData);
+      request.response = Object.assign(Object.assign({}, responseData), {
+        body: JSON.stringify(responseData.body),
+      });
+      if (isEmpty(error.statusCode) || error.statusCode >= 500) {
+        logger.error(error.message, error);
+      } else {
+        logger.warn(error.message, error);
+      }
+    });
+  return {
+    after: httpResponseMiddlewareAfter,
+    onError: httpResponseMiddlewareOnError,
+  };
+};
+export default httpResponseMiddleware;

package/dist/middlewares/index.d.ts

@@ -0,0 +1,7 @@
+export { default as disconnectMiddleware } from './disconnectMiddleware';
+export { default as httpMiddleware } from './httpMiddleware';
+export { default as httpResponseMiddleware } from './httpResponseMiddleware';
+export { default as invokeCommandMiddleware } from './invokeCommandMiddleware';
+export { default as sqsMiddleware } from './sqsMiddleware';
+export { default as verifyBasicAuthMiddleware } from './verifyBasicAuthMiddleware';
+export { default as verifyJwtMiddleware } from './verifyJwtMiddleware';

package/dist/middlewares/index.js

@@ -0,0 +1,7 @@
+export { default as disconnectMiddleware } from './disconnectMiddleware';
+export { default as httpMiddleware } from './httpMiddleware';
+export { default as httpResponseMiddleware } from './httpResponseMiddleware';
+export { default as invokeCommandMiddleware } from './invokeCommandMiddleware';
+export { default as sqsMiddleware } from './sqsMiddleware';
+export { default as verifyBasicAuthMiddleware } from './verifyBasicAuthMiddleware';
+export { default as verifyJwtMiddleware } from './verifyJwtMiddleware';

package/dist/middlewares/invokeCommandMiddleware.d.ts

@@ -0,0 +1,12 @@
+import middy from '@middy/core';
+import { DisconnectMiddlewareOptions } from './disconnectMiddleware';
+export interface InvokeCommandMiddlewareOptions extends DisconnectMiddlewareOptions {
+    debugMode?: boolean;
+    [key: string]: any;
+}
+declare const invokeCommandMiddleware: (opts?: InvokeCommandMiddlewareOptions) => {
+    before: (handler: middy.Request) => Promise<void>;
+    after: (handler: middy.Request) => Promise<void>;
+    onError: (handler: middy.Request) => Promise<void>;
+};
+export default invokeCommandMiddleware;

package/dist/middlewares/invokeCommandMiddleware.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 eventNormalizer from '@middy/event-normalizer';
+import doNotWaitForEmptyEventLoop from '@middy/do-not-wait-for-empty-event-loop';
+import disconnectMiddleware from './disconnectMiddleware';
+const invokeCommandMiddleware = (opts = {}) => {
+  const middlewarePackages = [
+    doNotWaitForEmptyEventLoop(),
+    eventNormalizer(),
+    disconnectMiddleware(opts),
+  ];
+  return {
+    before: handler =>
+      __awaiter(void 0, void 0, void 0, function* () {
+        for (const middleware of middlewarePackages) {
+          if (middleware.before) {
+            yield middleware.before(handler);
+          }
+        }
+      }),
+    after: handler =>
+      __awaiter(void 0, void 0, void 0, function* () {
+        for (const middleware of middlewarePackages) {
+          if (middleware.after) {
+            yield middleware.after(handler);
+          }
+        }
+      }),
+    onError: handler =>
+      __awaiter(void 0, void 0, void 0, function* () {
+        for (const middleware of middlewarePackages) {
+          if (middleware.onError) {
+            yield middleware.onError(handler);
+          }
+        }
+      }),
+  };
+};
+export default invokeCommandMiddleware;

package/dist/middlewares/sqsMiddleware.d.ts

@@ -0,0 +1,10 @@
+import middy from '@middy/core';
+export interface HttpMiddlewareOptions {
+    debugMode?: boolean;
+}
+declare const httpMiddleware: () => {
+    before: (handler: middy.Request) => Promise<void>;
+    after: (handler: middy.Request) => Promise<void>;
+    onError: (handler: middy.Request) => Promise<void>;
+};
+export default httpMiddleware;

package/dist/middlewares/sqsMiddleware.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 eventNormalizer from '@middy/event-normalizer';
+import doNotWaitForEmptyEventLoop from '@middy/do-not-wait-for-empty-event-loop';
+import disconnectMiddleware from './disconnectMiddleware';
+const httpMiddleware = () => {
+  const middlewarePackages = [
+    doNotWaitForEmptyEventLoop(),
+    eventNormalizer(),
+    disconnectMiddleware(),
+  ];
+  return {
+    before: handler =>
+      __awaiter(void 0, void 0, void 0, function* () {
+        for (const middleware of middlewarePackages) {
+          if (middleware.before) {
+            yield middleware.before(handler);
+          }
+        }
+      }),
+    after: handler =>
+      __awaiter(void 0, void 0, void 0, function* () {
+        for (const middleware of middlewarePackages) {
+          if (middleware.after) {
+            yield middleware.after(handler);
+          }
+        }
+      }),
+    onError: handler =>
+      __awaiter(void 0, void 0, void 0, function* () {
+        for (const middleware of middlewarePackages) {
+          if (middleware.onError) {
+            yield middleware.onError(handler);
+          }
+        }
+      }),
+  };
+};
+export default httpMiddleware;

package/dist/middlewares/verifyBasicAuthMiddleware.d.ts

@@ -0,0 +1,8 @@
+import middy from '@middy/core';
+export interface VerifyBasicAuthMiddlewareOptions {
+    debugMode?: boolean;
+}
+declare const verifyBasicAuthMiddleware: (options?: VerifyBasicAuthMiddlewareOptions) => {
+    before: (request: middy.Request) => void;
+};
+export default verifyBasicAuthMiddleware;

package/dist/middlewares/verifyBasicAuthMiddleware.js

@@ -0,0 +1,59 @@
+import logger from '../utils/logger';
+import { LesgoException } from '../exceptions';
+import { validateFields } from '../utils';
+import { basicAuth as basicAuthConfig } from '../config';
+const FILE = 'lesgo.middlewares.verifyBasicAuthMiddleware';
+const verifyBasicAuthMiddleware = (options = {}) => {
+  let decoded;
+  let input;
+  const verifyBasicAuth = basicAuth => {
+    if (basicAuth.includes('Basic')) {
+      basicAuth = basicAuth.replace('Basic ', '');
+    }
+    decoded = Buffer.from(basicAuth, 'base64').toString('utf8');
+    const [username, password] = decoded.split(':');
+    logger.debug(`${FILE}::BASIC_AUTH_DECODED`, { username, password });
+    try {
+      input = validateFields({ username, password }, [
+        { key: 'username', type: 'string', required: true },
+        { key: 'password', type: 'string', required: true },
+      ]);
+    } catch (error) {
+      throw new LesgoException(
+        'Invalid basic auth due to missing fields',
+        `${FILE}::INVALID_BASIC_AUTH_MISSING_FIELDS`,
+        401,
+        error
+      );
+    }
+    const matchFound = basicAuthConfig.authorizedList.find(
+      a => a.username === username && a.password === password
+    );
+    if (!matchFound) {
+      throw new LesgoException(
+        'Invalid basic auth due to no match found',
+        `${FILE}::INVALID_BASIC_AUTH_NO_MATCH`,
+        401
+      );
+    }
+    return { username: input.username };
+  };
+  const verifyBasicAuthMiddlewareBefore = request => {
+    logger.debug(`${FILE}::BASIC_AUTH_TO_VERIFY`, { request, options });
+    const basicAuth = request.event.headers.authorization;
+    if (!basicAuth) {
+      throw new LesgoException(
+        'No basic auth provided',
+        `${FILE}::NO_BASIC_AUTH_PROVIDED`,
+        401
+      );
+    }
+    const decoded = verifyBasicAuth(basicAuth);
+    logger.debug(`${FILE}::BASIC_AUTH_VERIFIED`);
+    request.event.basicAuth = decoded;
+  };
+  return {
+    before: verifyBasicAuthMiddlewareBefore,
+  };
+};
+export default verifyBasicAuthMiddleware;

package/dist/middlewares/verifyJwtMiddleware.d.ts

@@ -0,0 +1,6 @@
+import middy from '@middy/core';
+import { VerifyInputOptions } from '../services/JWTService/verify';
+declare const verifyJwtMiddleware: (secret?: string, options?: VerifyInputOptions) => {
+    before: (request: middy.Request) => void;
+};
+export default verifyJwtMiddleware;

package/dist/middlewares/verifyJwtMiddleware.js

@@ -0,0 +1,37 @@
+import { verify } from '../utils/jwt';
+import logger from '../utils/logger';
+import { LesgoException } from '../exceptions';
+const FILE = 'lesgo.middlewares.verifyJwtMiddleware';
+const verifyJwtMiddleware = (secret, options) => {
+  const verifyJwt = (token, secret, opts) => {
+    try {
+      const decoded = verify(token, secret, opts);
+      return decoded;
+    } catch (error) {
+      throw new LesgoException(
+        'Error verifying JWT',
+        `${FILE}::ERROR_VERIFYING_JWT`,
+        401,
+        error
+      );
+    }
+  };
+  const verifyJwtMiddlewareBefore = request => {
+    logger.debug(`${FILE}::JWT_TO_VERIFY`, { request, options });
+    const token = request.event.headers.authorization;
+    if (!token) {
+      throw new LesgoException(
+        'No token provided',
+        `${FILE}::NO_TOKEN_PROVIDED`,
+        401
+      );
+    }
+    const decoded = verifyJwt(token, secret, options);
+    logger.debug(`${FILE}::JWT_VERIFIED`, { decoded });
+    request.event.jwt = decoded;
+  };
+  return {
+    before: verifyJwtMiddlewareBefore,
+  };
+};
+export default verifyJwtMiddleware;

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

@@ -0,0 +1,8 @@
+import { DeleteCommandInput, NativeAttributeValue } from '@aws-sdk/lib-dynamodb';
+import { ClientOptions } from '../../types/aws';
+export type Key = Record<string, NativeAttributeValue>;
+export interface DeleteRecordOptions extends Partial<Omit<DeleteCommandInput, 'TableName'>> {
+    TableName?: string;
+}
+declare const deleteRecord: (key: Key, tableAlias: string, opts?: DeleteRecordOptions, clientOpts?: ClientOptions) => Promise<import("@aws-sdk/lib-dynamodb").DeleteCommandOutput>;
+export default deleteRecord;

package/dist/services/DynamoDbService/deleteRecord.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 { DeleteCommand } 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.deleteRecord';
+const deleteRecord = (key, tableAlias, opts, clientOpts) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const input = validateFields({ key, tableAlias }, [
+      { key: 'key', type: 'object', required: true },
+      { key: 'tableAlias', type: 'string', required: true },
+    ]);
+    const tableName = getTableName(input.tableAlias);
+    const client = getClient(clientOpts);
+    const commandInput = Object.assign(
+      { TableName: tableName, Key: input.key },
+      opts
+    );
+    try {
+      const data = yield client.send(new DeleteCommand(commandInput));
+      logger.debug(`${FILE}::RECEIVED_RESPONSE`, { data, commandInput });
+      return data;
+    } catch (error) {
+      throw new LesgoException(
+        'Failed to delete record',
+        `${FILE}::ERROR`,
+        500,
+        {
+          error,
+          commandInput,
+          clientOpts,
+        }
+      );
+    }
+  });
+export default deleteRecord;

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

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

package/dist/services/DynamoDbService/getClient.js

@@ -0,0 +1,30 @@
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
+import { isEmpty, logger, validateFields } from '../../utils';
+import { dynamodb as dynamodbConfig } from '../../config';
+const FILE = 'lesgo.services.DynamoDbService.getClient';
+const singleton = {};
+const getClient = (opts = {}) => {
+  const options = validateFields(opts, [
+    { key: 'region', type: 'string', required: false },
+    { key: 'singletonConn', type: 'string', required: false },
+  ]);
+  const region = options.region || dynamodbConfig.region;
+  const singletonConn = options.singletonConn || 'default';
+  if (!isEmpty(singleton[singletonConn])) {
+    logger.debug(`${FILE}::REUSE_CLIENT_SINGLETON`, {
+      client: singleton[singletonConn],
+      region,
+    });
+    return singleton[singletonConn];
+  }
+  const ddbClient = new DynamoDBClient({ region });
+  const client = DynamoDBDocumentClient.from(ddbClient);
+  logger.debug(`${FILE}::NEW_CLIENT_SINGLETON`, {
+    client,
+    region,
+  });
+  singleton[singletonConn] = client;
+  return client;
+};
+export default getClient;

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

@@ -0,0 +1,2 @@
+declare const _default: (tableAlias: string) => string;
+export default _default;

package/dist/services/DynamoDbService/getTableName.js

@@ -0,0 +1,15 @@
+import { LesgoException } from '../../exceptions';
+import dynamodbConfig from '../../config/dynamodb';
+const FILE = 'lesgo.services.DynamoDbService.getTableName';
+export default tableAlias => {
+  const table = dynamodbConfig.tables.find(t => t.alias === tableAlias);
+  if (!table) {
+    throw new LesgoException(
+      'Table not found',
+      `${FILE}::TABLE_NOT_FOUND`,
+      404,
+      { tableAlias }
+    );
+  }
+  return table.name;
+};

package/dist/services/DynamoDbService/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/services/DynamoDbService/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/services/DynamoDbService/putRecord.d.ts

@@ -0,0 +1,8 @@
+import { NativeAttributeValue, PutCommandInput } from '@aws-sdk/lib-dynamodb';
+import { ClientOptions } from '../../types/aws';
+export interface PutRecordOptions extends Partial<Omit<PutCommandInput, 'TableName'>> {
+    TableName?: string;
+}
+export type Item = Record<string, NativeAttributeValue>;
+declare const putRecord: (item: Item, tableAlias: string, opts?: PutRecordOptions, clientOpts?: ClientOptions) => Promise<import("@aws-sdk/lib-dynamodb").PutCommandOutput>;
+export default putRecord;

package/dist/services/DynamoDbService/putRecord.js

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

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

@@ -0,0 +1,7 @@
+import { NativeAttributeValue, QueryCommandInput } from '@aws-sdk/lib-dynamodb';
+import { ClientOptions } from '../../types/aws';
+export interface QueryOptions extends Partial<Omit<QueryCommandInput, 'TableName'>> {
+    TableName?: string;
+}
+declare const query: (tableAlias: string, keyConditionExpression: string, expressionAttributeValues: Record<string, NativeAttributeValue>, opts?: QueryOptions, clientOpts?: ClientOptions) => Promise<import("@aws-sdk/lib-dynamodb").QueryCommandOutput>;
+export default query;