lesgo 0.7.8 → 2.1.0

package/README.md

@@ -5,13 +5,13 @@
 
 Bootstrap your next microservice with a lightweight node.js serverless framework.
 
-> Note: This repository contains the core code of the Lesgo! framework. If you want to build an application using Lesgo!, visit the main Lesgo! repository.
+> Note: This repository contains the core code of the Lesgo! framework. If you want to build an application using Lesgo!, visit the [docs](https://reflex-media.github.io/lesgo-docs).
 
 ## Unit Test
 
 This framework uses Jest test framework for unit testing.
 
-All test files exist in the respective `src/__tests__/` directory.
+All test files exist in the respective `src/**/__tests__/*.test.ts` directory.
 
 **Install dependencies**
 
@@ -35,8 +35,9 @@ View the generated html report in `coverage/index.html`.
 
 ### Testing environment
 
-Declare testing environment configurations in `tests/config` directory.
+Declare testing environment configurations in `jest.setup.ts` directory.
 
 ## Contributing
 
-You may contribute to the core framework by submitting a PR to the `develop` branch. Refer to the official [Docs](https://reflex-media.github.io/lesgo-docs/contributing/) for more information.
+You may contribute to the core framework by submitting a PR to the `develop` branch. Refer to the official [Docs](https://reflex-media.github.io/lesgo-docs/stable/prologue/contribution-guide/) for more information.
+

package/bin/lesgo-scripts.sh

@@ -93,6 +93,21 @@ NC='\033[0m';
 # FUNCTION DECLARATIONS                                                       #
 #                                                                             #
 ###############################################################################
+LOCAL_SERVERLESS_VERSION=`npm ls --depth=0 serverless | grep -o "serverless@.*" || true`
+GLOBAL_SERVERLESS_VERSION=`npm ls -g --depth=0 serverless | grep -o "serverless@.*" || true`
+LATEST_SERVERLESS_VERSION_NUMBER=3
+
+if [ -z "$LOCAL_SERVERLESS_VERSION" ]
+then
+    CURRENT_SERVERLESS_VERSION=$GLOBAL_SERVERLESS_VERSION
+else
+    CURRENT_SERVERLESS_VERSION=$LOCAL_SERVERLESS_VERSION
+fi
+SERVERLESS_VERSION=${CURRENT_SERVERLESS_VERSION#*@}
+SERVERLESS_VERSION_NUMBER=${SERVERLESS_VERSION%%.*}
+
+echo -e "Running Serverless version:\n${CURRENT_SERVERLESS_VERSION}\n"
+echo -e "Current Serverless version: ${SERVERLESS_VERSION_NUMBER}\n"
 
 function deploy_func_check ()
 {
@@ -106,7 +121,12 @@ function deploy_func_check ()
 function deploy_func ()
 {
     echo -e "${YELLOW}Deploying ${FUNCTION} to ${STAGE}${NC} using ${CONFIG}"
-    sls deploy -f ${FUNCTION} --stage ${STAGE} --env ${ENVFILE} --config ${CONFIG}
+
+    if [ ${SERVERLESS_VERSION_NUMBER} -ge ${LATEST_SERVERLESS_VERSION_NUMBER} ]; then
+        sls deploy function -f ${FUNCTION} --stage ${STAGE} --param="env=${ENVFILE}" --config ${CONFIG}
+    else
+        sls deploy -f ${FUNCTION} --stage ${STAGE} --env ${ENVFILE} --config ${CONFIG}
+    fi
 }
 
 function prompt_confirmation_deploy_all ()
@@ -140,29 +160,50 @@ function prompt_confirmation_deploy_function ()
 function deploy_full ()
 {
     echo -e "${YELLOW}Deploying service to ${STAGE}${NC}"
-    sls deploy --stage ${STAGE} --env ${ENVFILE} --config ${CONFIG}
+    if [ ${SERVERLESS_VERSION_NUMBER} -ge ${LATEST_SERVERLESS_VERSION_NUMBER} ]; then
+        sls deploy --stage ${STAGE} --param="env=${ENVFILE}" --config ${CONFIG}
+    else
+        sls deploy --stage ${STAGE} --env ${ENVFILE} --config ${CONFIG}
+    fi
 }
 
 function invoke_func ()
 {
     echo -e "${YELLOW}Invoking function ${FUNCTION} on ${STAGE}${NC} using ${CONFIG}"
     if [ ${INVOKE_LOCAL} == 1 ]; then
-        sls invoke local -f ${FUNCTION} --stage ${STAGE} --env ${ENVFILE} -d ${DATA} -l --config ${CONFIG}
+        if [ ${SERVERLESS_VERSION_NUMBER} -ge ${LATEST_SERVERLESS_VERSION_NUMBER} ]; then
+            sls invoke local -f ${FUNCTION} --stage ${STAGE} --param="env=${ENVFILE}" -d ${DATA} -l --config ${CONFIG}
+        else
+            sls invoke local -f ${FUNCTION} --stage ${STAGE} --env ${ENVFILE} -d ${DATA} -l --config ${CONFIG}
+        fi
+
     else
-        sls invoke -f ${FUNCTION} --stage ${STAGE} --env ${ENVFILE} -d ${DATA} -l --config ${CONFIG}
+        if [ ${SERVERLESS_VERSION_NUMBER} -ge ${LATEST_SERVERLESS_VERSION_NUMBER} ]; then
+            sls invoke -f ${FUNCTION} --stage ${STAGE} --param="env=${ENVFILE}" -d ${DATA} -l --config ${CONFIG}
+        else
+            sls invoke -f ${FUNCTION} --stage ${STAGE} --env ${ENVFILE} -d ${DATA} -l --config ${CONFIG}
+        fi
     fi
 }
 
 function log_stream_func ()
 {
     echo -e "${YELLOW}Log Streaming function ${FUNCTION} on ${STAGE}${NC} using ${CONFIG}"
-    sls logs -f ${FUNCTION} --stage ${STAGE} --env ${ENVFILE} -t --config ${CONFIG}
+    if [ ${SERVERLESS_VERSION_NUMBER} -ge ${LATEST_SERVERLESS_VERSION_NUMBER} ]; then
+        sls logs -f ${FUNCTION} --stage ${STAGE} --param="env=${ENVFILE}" -t --config ${CONFIG}
+    else
+        sls logs -f ${FUNCTION} --stage ${STAGE} --env ${ENVFILE} -t --config ${CONFIG}
+    fi
 }
 
 function build ()
 {
     echo -e "${YELLOW}Building bundle without deployment${NC} using ${CONFIG}"
-    sls webpack --stage ${STAGE} --env ${ENVFILE} --config ${CONFIG}
+    if [ ${SERVERLESS_VERSION_NUMBER} -ge ${LATEST_SERVERLESS_VERSION_NUMBER} ]; then
+        sls webpack --stage ${STAGE} --param="env=${ENVFILE}" --config ${CONFIG}
+    else
+        sls webpack --stage ${STAGE} --env ${ENVFILE} --config ${CONFIG}
+    fi
 }
 
 function prompt_confirmation_destroy_service ()
@@ -180,7 +221,11 @@ function prompt_confirmation_destroy_service ()
 function destroy_service ()
 {
     echo -e "${YELLOW}Removing service to ${STAGE}${NC}"
-    sls remove --stage ${STAGE} --env ${ENVFILE} --config ${CONFIG}
+    if [ ${SERVERLESS_VERSION_NUMBER} -ge ${LATEST_SERVERLESS_VERSION_NUMBER} ]; then
+        sls remove --stage ${STAGE} --param="env=${ENVFILE}" --config ${CONFIG}
+    else
+        sls remove --stage ${STAGE} --env ${ENVFILE} --config ${CONFIG}
+    fi
 }
 
 ###############################################################################

package/dist/config/app.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    name: string;
+    stackName: string;
+    env: string;
+    debug: boolean;
+};
+export default _default;

package/dist/config/app.js

@@ -0,0 +1,9 @@
+const appName = process.env.APP_NAME || 'lesgo';
+const env = process.env.APP_ENV || 'dev';
+const stackName = `${appName}-${env}`;
+export default {
+  name: appName,
+  stackName,
+  env,
+  debug: process.env.APP_DEBUG === 'true',
+};

package/dist/config/aws.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    accountId: string | undefined;
+    region: string;
+};
+export default _default;

package/dist/config/aws.js

@@ -0,0 +1,4 @@
+export default {
+  accountId: process.env.AWS_ACCOUNT_ID,
+  region: process.env.AWS_REGION || 'ap-southeast-1',
+};

package/dist/config/basicAuth.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    authorizedList: {
+        username: string;
+        password: string;
+    }[];
+};
+export default _default;

package/dist/config/basicAuth.js

@@ -0,0 +1,8 @@
+const basicAuthList = process.env.LESGO_BASIC_AUTH_LIST || '';
+const authorizedList = basicAuthList.split(',').map(key => {
+  const [username, password] = key.split(':');
+  return { username, password };
+});
+export default {
+  authorizedList,
+};

package/dist/config/crypto.d.ts

@@ -0,0 +1,10 @@
+declare const _default: {
+    hash: {
+        algorithm: string;
+    };
+    encryption: {
+        algorithm: string;
+        secretKey: string | undefined;
+    };
+};
+export default _default;

package/dist/config/crypto.js

@@ -0,0 +1,9 @@
+export default {
+  hash: {
+    algorithm: process.env.LESGO_CRYPTO_HASH_ALG || 'sha256',
+  },
+  encryption: {
+    algorithm: process.env.LESGO_CRYPTO_ENCRYPTION_ALG || 'aes-256-cbc',
+    secretKey: process.env.LESGO_CRYPTO_ENCRYPTION_SEC,
+  },
+};

package/dist/config/dynamodb.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    region: string;
+    tables: {
+        alias: string;
+        name: string;
+    }[];
+};
+export default _default;

package/dist/config/dynamodb.js

@@ -0,0 +1,14 @@
+var _a;
+import appConfig from './app';
+import awsConfig from './aws';
+const dynamodbTableAliases =
+  ((_a = process.env.LESGO_AWS_DYNAMODB_TABLE_ALIASES) === null || _a === void 0
+    ? void 0
+    : _a.split(',')) || [];
+export default {
+  region: process.env.LESGO_AWS_DYNAMODB_REGION || awsConfig.region,
+  tables: dynamodbTableAliases.map(t => ({
+    alias: t,
+    name: `${appConfig.stackName}-${t}`,
+  })),
+};

package/dist/config/elasticache.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    redis: {
+        endpoint: string | undefined;
+        port: number;
+    };
+};
+export default _default;

package/dist/config/elasticache.js

@@ -0,0 +1,6 @@
+export default {
+  redis: {
+    endpoint: process.env.LESGO_AWS_ELASTICACHE_REDIS_ENDPOINT,
+    port: Number(process.env.LESGO_AWS_ELASTICACHE_REDIS_PORT || 6379),
+  },
+};

package/dist/config/index.d.ts

@@ -0,0 +1,11 @@
+export { default as app } from './app';
+export { default as aws } from './aws';
+export { default as basicAuth } from './basicAuth';
+export { default as crypto } from './crypto';
+export { default as dynamodb } from './dynamodb';
+export { default as elasticache } from './elasticache';
+export { default as jwt } from './jwt';
+export { default as rds } from './rds';
+export { default as s3 } from './s3';
+export { default as secretsmanager } from './secretsmanager';
+export { default as sqs } from './sqs';

package/dist/config/index.js

@@ -0,0 +1,11 @@
+export { default as app } from './app';
+export { default as aws } from './aws';
+export { default as basicAuth } from './basicAuth';
+export { default as crypto } from './crypto';
+export { default as dynamodb } from './dynamodb';
+export { default as elasticache } from './elasticache';
+export { default as jwt } from './jwt';
+export { default as rds } from './rds';
+export { default as s3 } from './s3';
+export { default as secretsmanager } from './secretsmanager';
+export { default as sqs } from './sqs';

package/dist/config/jwt.d.ts

@@ -0,0 +1,12 @@
+declare const _default: {
+    algorithm: string;
+    secrets: {
+        keyid: string;
+        secret: string;
+    }[];
+    expiresIn: string;
+    issuer: string | undefined;
+    audience: string | undefined;
+    validateClaims: boolean;
+};
+export default _default;

package/dist/config/jwt.js

@@ -0,0 +1,16 @@
+const secretKeys = process.env.LESGO_JWT_SECRET_KEYS || '';
+const secrets = secretKeys.split(',').map(key => {
+  if (!key.includes(':')) {
+    return { keyid: '0', secret: key };
+  }
+  const [keyid, secret] = key.split(':');
+  return { keyid, secret };
+});
+export default {
+  algorithm: process.env.LESGO_JWT_ALGORITHM || 'HS256',
+  secrets,
+  expiresIn: process.env.LESGO_JWT_EXPIRES_IN || '1h',
+  issuer: process.env.LESGO_JWT_ISSUER,
+  audience: process.env.LESGO_JWT_AUDIENCE,
+  validateClaims: process.env.LESGO_JWT_VALIDATE_CLAIMS !== 'false',
+};

package/dist/config/rds.d.ts

@@ -0,0 +1,12 @@
+declare const _default: {
+    aurora: {
+        mysql: {
+            region: string;
+            databaseName: string | undefined;
+            proxy: {
+                dbCredentialsSecretId: string | undefined;
+            };
+        };
+    };
+};
+export default _default;

package/dist/config/rds.js

@@ -0,0 +1,13 @@
+import awsConfig from './aws';
+export default {
+  aurora: {
+    mysql: {
+      region: process.env.LESGO_AWS_RDS_AURORA_MYSQL_REGION || awsConfig.region,
+      databaseName: process.env.LESGO_AWS_RDS_AURORA_MYSQL_DB_NAME,
+      proxy: {
+        dbCredentialsSecretId:
+          process.env.LESGO_AWS_RDS_AURORA_MYSQL_PROXY_DB_CREDENTIALS_SECRET_ID,
+      },
+    },
+  },
+};

package/dist/config/s3.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    region: string;
+    bucket: string;
+};
+export default _default;

package/dist/config/s3.js

@@ -0,0 +1,5 @@
+import awsConfig from './aws';
+export default {
+  region: process.env.LESGO_AWS_S3_REGION || awsConfig.region,
+  bucket: process.env.LESGO_AWS_S3_BUCKET || 'lesgo-dev',
+};

package/dist/config/secretsManager.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    region: string;
+};
+export default _default;

package/dist/config/secretsManager.js

@@ -0,0 +1,4 @@
+import awsConfig from './aws';
+export default {
+  region: process.env.LESGO_AWS_SECRETS_MANAGER_REGION || awsConfig.region,
+};

package/dist/config/sqs.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    region: string;
+    queues: {
+        alias: string;
+        name: string;
+        url: string;
+    }[];
+};
+export default _default;

package/dist/config/sqs.js

@@ -0,0 +1,18 @@
+var _a;
+import awsConfig from './aws';
+import appConfig from './app';
+const sqsQueueAliases =
+  ((_a = process.env.LESGO_AWS_SQS_QUEUE_ALIASES) === null || _a === void 0
+    ? void 0
+    : _a.split(',')) || [];
+const region = process.env.LESGO_AWS_SQS_REGION || awsConfig.region;
+export default {
+  region: process.env.LESGO_AWS_SQS_REGION || awsConfig.region,
+  queues: sqsQueueAliases.map(q => ({
+    alias: q,
+    name: `${appConfig.stackName}-${q}`,
+    url: `https://sqs.${region}.amazonaws.com/${
+      awsConfig.accountId
+    }/${`${appConfig.stackName}-${q}`}`,
+  })),
+};

package/dist/exceptions/LesgoException.d.ts

@@ -0,0 +1,6 @@
+export default class LesgoException extends Error {
+    statusCode: number;
+    code: string;
+    extra: any;
+    constructor(message: string, errorCode?: string, httpStatusCode?: number, extra?: any);
+}

package/{src → dist}/exceptions/LesgoException.js

@@ -1,18 +1,19 @@
+import isEmpty from '../utils/isEmpty';
 export default class LesgoException extends Error {
   constructor(
     message,
     errorCode = 'LESGO_EXCEPTION',
     httpStatusCode = 500,
-    extra
+    extra = {}
   ) {
     super();
     this.name = 'LesgoException';
     this.message = message;
     this.statusCode = httpStatusCode;
     this.code = errorCode;
-
     Error.captureStackTrace(this, this.constructor);
-
-    if (extra) this.extra = extra;
+    if (!isEmpty(extra)) {
+      this.extra = extra;
+    }
   }
 }

package/dist/exceptions/index.d.ts

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

package/dist/exceptions/index.js

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

package/dist/middlewares/disconnectMiddleware.d.ts

@@ -0,0 +1,8 @@
+export interface DisconnectMiddlewareOptions {
+    clients?: any[];
+}
+declare const disconnectMiddleware: (opts?: DisconnectMiddlewareOptions) => {
+    after: () => Promise<void>;
+    onError: () => Promise<void>;
+};
+export default disconnectMiddleware;

package/dist/middlewares/disconnectMiddleware.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 logger from '../utils/logger';
+const FILE = 'lesgo.middlewares.disconnectMiddleware';
+const disconnectMiddleware = opts => {
+  const disconnect = () =>
+    __awaiter(void 0, void 0, void 0, function* () {
+      var _a;
+      logger.debug(`${FILE}::PREPARING_TO_DISCONNECT`);
+      const disconnect = [];
+      if (
+        (opts === null || opts === void 0 ? void 0 : opts.clients) &&
+        ((_a = opts === null || opts === void 0 ? void 0 : opts.clients) ===
+          null || _a === void 0
+          ? void 0
+          : _a.length) > 0
+      ) {
+        opts.clients.forEach(client => {
+          disconnect.push(client());
+        });
+      }
+      if (disconnect.length > 0) {
+        const results = yield Promise.allSettled(disconnect);
+        results.forEach(result => {
+          if (result.status === 'fulfilled') {
+            logger.debug(`${FILE}::DISCONNECT_SUCCESS`, { result });
+          } else if (result.status === 'rejected') {
+            logger.error(`${FILE}::DISCONNECT_ERROR`, { result });
+          }
+        });
+        logger.debug(`${FILE}::DISCONNECT_COMPLETED`, opts);
+      }
+    });
+  const disconnectMiddlewareAfter = () =>
+    __awaiter(void 0, void 0, void 0, function* () {
+      yield disconnect();
+    });
+  const disconnectMiddlewareOnError = () =>
+    __awaiter(void 0, void 0, void 0, function* () {
+      yield disconnect();
+    });
+  return {
+    after: disconnectMiddlewareAfter,
+    onError: disconnectMiddlewareOnError,
+  };
+};
+export default disconnectMiddleware;

package/dist/middlewares/httpMiddleware.d.ts

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

package/dist/middlewares/httpMiddleware.js

@@ -0,0 +1,74 @@
+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 jsonBodyParser from '@middy/http-json-body-parser';
+import eventNormalizer from '@middy/http-event-normalizer';
+import doNotWaitForEmptyEventLoop from '@middy/do-not-wait-for-empty-event-loop';
+import httpHeaderNormalizer from '@middy/http-header-normalizer';
+import httpResponseMiddleware from './httpResponseMiddleware';
+const httpMiddleware = (opts = {}) => {
+  const middlewarePackages = [
+    doNotWaitForEmptyEventLoop(),
+    eventNormalizer(),
+    httpHeaderNormalizer(),
+    jsonBodyParser({ disableContentTypeError: true }),
+    httpResponseMiddleware(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 httpMiddleware;

package/dist/middlewares/httpResponseMiddleware.d.ts

@@ -0,0 +1,7 @@
+import middy from '@middy/core';
+import { HttpMiddlewareOptions } from './httpMiddleware';
+declare const httpResponseMiddleware: (opts?: HttpMiddlewareOptions) => {
+    after: (request: middy.Request) => Promise<void>;
+    onError: (request: middy.Request) => Promise<void>;
+};
+export default httpResponseMiddleware;