lesgo 0.6.3 → 0.7.3

package/bin/lesgo-scripts.sh

@@ -1,12 +1,14 @@
 #!/usr/bin/env bash
 
+set -Eeuo pipefail
+
 ###############################################################################
 #                                                                             #
 # INITIALIZE EVERYTHING                                                       #
 #                                                                             #
 ###############################################################################
 
-usage="$(basename "$0") [-f] [-s] [-t] [-h] [-d] [-y] -- script to deploy serverless functions
+usage="$(basename "$0") [-f] [-s] [-t] [-h] [-d] [-c] [-y] -- script to deploy serverless functions
 
 where:
     -t      define the type of action to be taken (build, deploy, invoke, logs, destroy)
@@ -15,22 +17,24 @@ where:
     -h      show this help text
     -l      to invoke a local function
     -d      set data parameters for invoke function
+    -c      set config as per --config path-to-serverless-yml
     -y      no question/prompt for ci/cd"
 
 # arg options
-BUILD=0;        # serverless build without deploy
-DEPLOY=0;       # serverless deploy
-INVOKE=0;       # serverless invoke of specific function
-LOGS=0;         # serverless stream log of specific function
-DESTROY=0;      # serverless remove entire service
-FUNCTION='';    # specify function to involve
-STAGE='';       # deploy specific stage/environment
-INVOKE_LOCAL=0; # default to non local execution
-DATA=''         # set the data parameters for invoke function
-NO_QUESTION=0;  # default to prompt
+BUILD=0;                    # serverless build without deploy
+DEPLOY=0;                   # serverless deploy
+INVOKE=0;                   # serverless invoke of specific function
+LOGS=0;                     # serverless stream log of specific function
+DESTROY=0;                  # serverless remove entire service
+FUNCTION='';                # specify function to involve
+STAGE='';                   # deploy specific stage/environment
+INVOKE_LOCAL=0;             # default to non local execution
+DATA=''                     # set the data parameters for invoke function
+NO_QUESTION=0;              # default to prompt
+CONFIG='./serverless.yml';  # specify serverless config file to deploy, default to root
 
 # parse the options
-while getopts "lhs:f:t:d:y" OPT ; do
+while getopts "lhs:f:t:d:c:y" OPT ; do
   case ${OPT} in
     f) FUNCTION=${OPTARG} ;;
     s) STAGE=${OPTARG} ;;
@@ -51,6 +55,7 @@ while getopts "lhs:f:t:d:y" OPT ; do
         fi;;
     l) INVOKE_LOCAL=1 ;;
     d) DATA=${OPTARG} ;;
+    c) CONFIG=${OPTARG} ;;
     y) NO_QUESTION=1 ;;
     h)
         echo "${usage}"
@@ -100,8 +105,8 @@ function deploy_func_check ()
 
 function deploy_func ()
 {
-    echo -e "${YELLOW}Deploying ${FUNCTION} to ${STAGE}${NC}"
-    sls deploy -f ${FUNCTION} --stage ${STAGE} --env ${ENVFILE}
+    echo -e "${YELLOW}Deploying ${FUNCTION} to ${STAGE}${NC} using ${CONFIG}"
+    sls deploy -f ${FUNCTION} --stage ${STAGE} --env ${ENVFILE} --config ${CONFIG}
 }
 
 function prompt_confirmation_deploy_all ()
@@ -110,7 +115,7 @@ function prompt_confirmation_deploy_all ()
         deploy_full;
     else
         while true; do
-            read -p "Confirm deploy service to ${STAGE} with .env.${ENVFILE}? [Y|N] " yn
+            read -p "Confirm deploy service to ${STAGE} with .env.${ENVFILE} using ${CONFIG}? [Y|N] " yn
             case ${yn} in
                 [Yy] | yes | Yes | YES ) deploy_full; break;;
                 [Nn] | no | No | NO ) echo -e "${YELLOW}Cancelled deploying service to [${STAGE}]${NC}"; exit;;
@@ -123,7 +128,7 @@ function prompt_confirmation_deploy_all ()
 function prompt_confirmation_deploy_function ()
 {
     while true; do
-        read -p "Confirm deploy function ${FUNCTION} to ${STAGE} with .env.${ENVFILE}? [Y|N] " yn
+        read -p "Confirm deploy function ${FUNCTION} to ${STAGE} with .env.${ENVFILE} using ${CONFIG}? [Y|N] " yn
         case ${yn} in
             [Yy] | yes | Yes | YES ) deploy_func; break;;
             [Nn] | no | No | NO ) echo -e "${YELLOW}Cancelled deploying function ${FUNCTION} to [${STAGE}]${NC}"; exit;;
@@ -135,35 +140,35 @@ function prompt_confirmation_deploy_function ()
 function deploy_full ()
 {
     echo -e "${YELLOW}Deploying service to ${STAGE}${NC}"
-    sls deploy --stage ${STAGE} --env ${ENVFILE}
+    sls deploy --stage ${STAGE} --env ${ENVFILE} --config ${CONFIG}
 }
 
 function invoke_func ()
 {
-    echo -e "${YELLOW}Invoking function ${FUNCTION} on ${STAGE}${NC}"
+    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
+        sls invoke local -f ${FUNCTION} --stage ${STAGE} --env ${ENVFILE} -d ${DATA} -l --config ${CONFIG}
     else
-        sls invoke -f ${FUNCTION} --stage ${STAGE} --env ${ENVFILE} -d ${DATA} -l
+        sls invoke -f ${FUNCTION} --stage ${STAGE} --env ${ENVFILE} -d ${DATA} -l --config ${CONFIG}
     fi
 }
 
 function log_stream_func ()
 {
-    echo -e "${YELLOW}Log Streaming function ${FUNCTION} on ${STAGE}${NC}"
-    sls logs -f ${FUNCTION} --stage ${STAGE} --env ${ENVFILE} -t
+    echo -e "${YELLOW}Log Streaming function ${FUNCTION} on ${STAGE}${NC} using ${CONFIG}"
+    sls logs -f ${FUNCTION} --stage ${STAGE} --env ${ENVFILE} -t --config ${CONFIG}
 }
 
 function build ()
 {
-    echo -e "${YELLOW}Building bundle without deployment${NC}"
-    sls webpack --stage ${STAGE} --env ${ENVFILE}
+    echo -e "${YELLOW}Building bundle without deployment${NC} using ${CONFIG}"
+    sls webpack --stage ${STAGE} --env ${ENVFILE} --config ${CONFIG}
 }
 
 function prompt_confirmation_destroy_service ()
 {
     while true; do
-        read -p "Confirm destroy service to ${STAGE} with .env.${ENVFILE}? Note: This action will remove entire service from AWS. Ensure no other applications are using this service. [Y|N] " yn
+        read -p "Confirm destroy service to ${STAGE} with .env.${ENVFILE} using ${CONFIG}? Note: This action will remove entire service from AWS. Ensure no other applications are using this service. [Y|N] " yn
         case ${yn} in
             [Yy] | yes | Yes | YES ) destroy_service; break;;
             [Nn] | no | No | NO ) echo -e "${YELLOW}Cancelled destroying service to [${STAGE}]${NC}"; exit;;
@@ -175,7 +180,7 @@ function prompt_confirmation_destroy_service ()
 function destroy_service ()
 {
     echo -e "${YELLOW}Removing service to ${STAGE}${NC}"
-    sls remove --stage ${STAGE} --env ${ENVFILE}
+    sls remove --stage ${STAGE} --env ${ENVFILE} --config ${CONFIG}
 }
 
 ###############################################################################

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lesgo",
-  "version": "0.6.3",
+  "version": "0.7.3",
   "description": "Core framework for lesgo node.js serverless framework.",
   "main": "./src/index.js",
   "author": "Sufiyan Rahmat",
@@ -57,6 +57,7 @@
     "firebase-admin": "^9.3.0",
     "jsonwebtoken": "^8.5.1",
     "memcached-elasticache": "^1.1.1",
+    "mysql2": "^2.2.5",
     "nanoid": "^3.1.16"
   },
   "husky": {

package/src/middlewares/__tests__/errorHttpResponseMiddleware.spec.js

@@ -5,8 +5,8 @@ import {
 import ValidationErrorException from '../__mocks__/ValidationErrorException';
 
 describe('MiddlewareGroup: test errorHandler middleware', () => {
-  it('test with thrown Error', () => {
-    const data = errorHttpResponseHandler({
+  it('test with thrown Error', async () => {
+    const data = await errorHttpResponseHandler({
       error: new Error('Test validation error'),
     });
 
@@ -29,8 +29,8 @@ describe('MiddlewareGroup: test errorHandler middleware', () => {
     expect(dataBody).toHaveProperty('error.details', '');
   });
 
-  it('test with thrown custom Error with default parameters', () => {
-    const data = errorHttpResponseHandler({
+  it('test with thrown custom Error with default parameters', async () => {
+    const data = await errorHttpResponseHandler({
       error: new ValidationErrorException('Test validation error'),
     });
     const dataBody = JSON.parse(data.body);
@@ -45,8 +45,8 @@ describe('MiddlewareGroup: test errorHandler middleware', () => {
     expect(dataBody).toHaveProperty('error.details', '');
   });
 
-  it('test with thrown custom Error with given parameters', () => {
-    const data = errorHttpResponseHandler({
+  it('test with thrown custom Error with given parameters', async () => {
+    const data = await errorHttpResponseHandler({
       error: new ValidationErrorException(
         'Test validation error',
         'VALIDATION_ERROR_SAMPLE',
@@ -70,8 +70,10 @@ describe('MiddlewareGroup: test errorHandler middleware', () => {
     });
   });
 
-  it('test with error message', () => {
-    const data = errorHttpResponseHandler({ error: 'Test error message' });
+  it('test with error message', async () => {
+    const data = await errorHttpResponseHandler({
+      error: 'Test error message',
+    });
     const dataBody = JSON.parse(data.body);
 
     expect(data.statusCode).toBe(500);
@@ -81,8 +83,8 @@ describe('MiddlewareGroup: test errorHandler middleware', () => {
     expect(dataBody).toHaveProperty('error.details', '');
   });
 
-  it('test with error message with event', () => {
-    const data = errorHttpResponseHandler({
+  it('test with error message with event', async () => {
+    const data = await errorHttpResponseHandler({
       error: 'Test error message',
       event: {
         someEventKey: 'someEventValue',
@@ -97,8 +99,8 @@ describe('MiddlewareGroup: test errorHandler middleware', () => {
     });
   });
 
-  it('test with error message with event in non-debug mode', () => {
-    const data = errorHttpResponseHandler({
+  it('test with error message with event in non-debug mode', async () => {
+    const data = await errorHttpResponseHandler({
       error: 'Test error message',
       event: {
         someEventKey: 'someEventValue',
@@ -110,8 +112,8 @@ describe('MiddlewareGroup: test errorHandler middleware', () => {
     expect(dataBody).toHaveProperty('_meta', {});
   });
 
-  it('test with undefined opts', () => {
-    const data = errorHttpResponseHandler();
+  it('test with undefined opts', async () => {
+    const data = await errorHttpResponseHandler();
 
     expect(data.headers['Access-Control-Allow-Origin']).toBe('*');
     expect(data.headers['Cache-Control']).toBe('no-cache');
@@ -128,16 +130,31 @@ describe('MiddlewareGroup: test errorHandler middleware', () => {
     expect(dataBody).toHaveProperty('error.message', '');
     expect(dataBody).toHaveProperty('error.details', '');
   });
+
+  it('should call db.end() whenever a db options is set', async () => {
+    const end = jest.fn().mockResolvedValue();
+    await errorHttpResponseHandler({
+      error: 'Test error message',
+      event: {
+        someEventKey: 'someEventValue',
+      },
+      db: {
+        end,
+      },
+    });
+
+    expect(end).toHaveBeenCalledTimes(1);
+  });
 });
 
 describe('MiddlewareGroup: test errorHttpResponseAfterHandler', () => {
-  it('test with default parameters', () => {
+  it('test with default parameters', async () => {
     const handler = {
       error: {},
       event: {},
     };
 
-    errorHttpResponseAfterHandler(handler, () => {});
+    await errorHttpResponseAfterHandler(handler, () => {});
     expect(handler.response).toHaveProperty('statusCode', 500);
   });
 });

package/src/middlewares/__tests__/normalizeHttpRequestMiddleware.spec.js

@@ -1,7 +1,9 @@
+import app from 'Config/app'; // eslint-disable-line import/no-unresolved
 import {
   normalizeRequest,
   normalizeHttpRequestBeforeHandler,
 } from '../normalizeHttpRequestMiddleware';
+import logger from '../../utils/logger';
 
 describe('MiddlewareGroup: test normalizeRequest', () => {
   it('test with default parameters', () => {
@@ -116,4 +118,26 @@ describe('MiddlewareGroup: test normalizeHttpRequestBeforeHandler', () => {
     normalizeHttpRequestBeforeHandler(handler, () => {});
     expect(handler.event.auth.sub).toBe('f2b5349d-f5e3-44f5-9c08-ae6b01e95434');
   });
+
+  it('should not set meta on debug', () => {
+    app.debug = true;
+    const handler = {
+      event: {
+        headers: {},
+        auth: '1',
+        queryStringParameters: {
+          foo: 'bar',
+        },
+        body: {
+          test: 'body',
+        },
+      },
+    };
+    normalizeHttpRequestBeforeHandler(handler, () => {});
+    expect(logger.meta.auth).toBe(handler.event.auth);
+    expect(logger.meta.queryStringParameters).toStrictEqual(
+      handler.event.queryStringParameters
+    );
+    expect(logger.meta.body).toStrictEqual(handler.event.body);
+  });
 });

package/src/middlewares/__tests__/successHttpResponseMiddleware.spec.js

@@ -4,8 +4,8 @@ import {
 } from '../successHttpResponseMiddleware';
 
 describe('MiddlewareGroup: test successHttpResponseHandler middleware', () => {
-  it('test default without parameters', () => {
-    const data = successHttpResponseHandler();
+  it('test default without parameters', async () => {
+    const data = await successHttpResponseHandler();
 
     expect(data.headers['Access-Control-Allow-Origin']).toBe('*');
     expect(data.headers['Cache-Control']).toBe('no-cache');
@@ -20,8 +20,8 @@ describe('MiddlewareGroup: test successHttpResponseHandler middleware', () => {
     expect(dataBody).toHaveProperty('_meta', {});
   });
 
-  it('test default', () => {
-    const data = successHttpResponseHandler({ response: 'Some message' });
+  it('test default', async () => {
+    const data = await successHttpResponseHandler({ response: 'Some message' });
 
     expect(data.headers['Access-Control-Allow-Origin']).toBe('*');
     expect(data.headers['Cache-Control']).toBe('no-cache');
@@ -36,8 +36,8 @@ describe('MiddlewareGroup: test successHttpResponseHandler middleware', () => {
     expect(dataBody).toHaveProperty('_meta', {});
   });
 
-  it('test with status code and event', () => {
-    const data = successHttpResponseHandler({
+  it('test with status code and event', async () => {
+    const data = await successHttpResponseHandler({
       response: 'Some message',
       statusCode: 201,
       event: {
@@ -53,8 +53,8 @@ describe('MiddlewareGroup: test successHttpResponseHandler middleware', () => {
     expect(dataBody).toHaveProperty('_meta', {});
   });
 
-  it('test with status code and event in debug mode', () => {
-    const data = successHttpResponseHandler({
+  it('test with status code and event in debug mode', async () => {
+    const data = await successHttpResponseHandler({
       response: 'Some message',
       statusCode: 201,
       event: {
@@ -73,8 +73,8 @@ describe('MiddlewareGroup: test successHttpResponseHandler middleware', () => {
     });
   });
 
-  it('test with configurable header', () => {
-    const data = successHttpResponseHandler({
+  it('test with configurable header', async () => {
+    const data = await successHttpResponseHandler({
       response: 'Some message',
       headers: {
         'Access-Control-Allow-Credentials': false,
@@ -96,16 +96,32 @@ describe('MiddlewareGroup: test successHttpResponseHandler middleware', () => {
     expect(dataBody).toHaveProperty('data', 'Some message');
     expect(dataBody).toHaveProperty('_meta', {});
   });
+
+  it('should call db.end() whenever a db options is set', async () => {
+    const end = jest.fn().mockResolvedValue();
+    await successHttpResponseHandler({
+      response: 'Some message',
+      headers: {
+        'Access-Control-Allow-Credentials': false,
+        'X-Token-Id': 'token',
+      },
+      db: {
+        end,
+      },
+    });
+
+    expect(end).toHaveBeenCalledTimes(1);
+  });
 });
 
 describe('MiddlewareGroup: test successHttpResponseAfterHandler', () => {
-  it('test with default parameters', () => {
+  it('test with default parameters', async () => {
     const handler = {
       response: {},
       event: {},
     };
 
-    successHttpResponseAfterHandler(handler, () => {});
+    await successHttpResponseAfterHandler(handler, () => {});
     expect(handler.response).toHaveProperty('statusCode', 200);
   });
 });

package/src/middlewares/errorHttpResponseMiddleware.js

@@ -1,6 +1,7 @@
 import logger from '../utils/logger';
+import isEmpty from '../utils/isEmpty';
 
-export const errorHttpResponseHandler = opts => {
+export const errorHttpResponseHandler = async opts => {
   const defaults = {
     response: '',
     statusCode: 500,
@@ -47,6 +48,12 @@ export const errorHttpResponseHandler = opts => {
     logger.warn(options.error);
   }
 
+  try {
+    if (!isEmpty(opts.db)) await opts.db.end();
+  } catch (err) {
+    // do nothing
+  }
+
   return {
     headers: options.headers,
     statusCode,
@@ -54,7 +61,7 @@ export const errorHttpResponseHandler = opts => {
   };
 };
 
-export const errorHttpResponseAfterHandler = (handler, next, opts) => {
+export const errorHttpResponseAfterHandler = async (handler, next, opts) => {
   const defaults = {
     error: handler.error,
     event: handler.event,
@@ -64,7 +71,7 @@ export const errorHttpResponseAfterHandler = (handler, next, opts) => {
   const options = { ...defaults, ...opts };
 
   // eslint-disable-next-line no-param-reassign
-  handler.response = errorHttpResponseHandler(options);
+  handler.response = await errorHttpResponseHandler(options);
   /* istanbul ignore next */
   next();
 };

package/src/middlewares/gzipHttpResponse.js

@@ -31,7 +31,7 @@ export const gzip = async response => {
  * Determine request origin
  */
 export const determineRequestOrigin = handler => {
-  const { requestContext } = handler.event;
+  const { requestContext = {} } = handler.event;
   let requestFrom = 'APIGATEWAY';
 
   if (requestContext.elb) {

package/src/middlewares/successHttpResponseMiddleware.js

@@ -1,6 +1,7 @@
 import gzipHttpResponse from './gzipHttpResponse';
+import isEmpty from '../utils/isEmpty';
 
-export const successHttpResponseHandler = opts => {
+export const successHttpResponseHandler = async opts => {
   const defaults = {
     response: '',
     statusCode: 200,
@@ -23,6 +24,12 @@ export const successHttpResponseHandler = opts => {
 
   const options = { ...defaults, ...optionsHeadersMerged };
 
+  try {
+    if (!isEmpty(opts.db)) await opts.db.end();
+  } catch (err) {
+    // do nothing
+  }
+
   return {
     headers: options.headers,
     statusCode: options.statusCode,
@@ -43,7 +50,7 @@ export const successHttpResponseAfterHandler = async (handler, next, opts) => {
   const options = { ...defaults, ...opts };
 
   // eslint-disable-next-line no-param-reassign
-  handler.response = successHttpResponseHandler(options);
+  handler.response = await successHttpResponseHandler(options);
 
   // eslint-disable-next-line no-param-reassign
   handler.response = await gzipHttpResponse(handler, opts);

package/src/services/AuroraDbRDSProxyService.js

@@ -0,0 +1,183 @@
+import mysql from 'mysql2/promise';
+import logger from '../utils/logger';
+import isEmpty from '../utils/isEmpty';
+import LesgoException from '../exceptions/LesgoException';
+import LengthAwarePaginator from './pagination/LengthAwarePaginator';
+import Paginator from './pagination/Paginator';
+
+const FILE = 'Lesgo/services/AuroraDbRDSProxyService';
+
+/**
+ * Service to connect to AWS Aurora Provisioned MySQL Database via RDS Proxy.
+ * Use Services/AuroraDbServerlessService for the Serverless type via Data API.
+ */
+export default class AuroraDbRDSProxyService {
+  constructor(opts = {}) {
+    const { host, user, password, database, persists } = opts;
+
+    this.clientOpts = {
+      host,
+      user,
+      password,
+      database,
+      persists,
+    };
+
+    this.conn = {};
+  }
+
+  /**
+   * Persists the database connection for later use
+   *
+   * @param {*} connectionOpts
+   * @returns
+   */
+  async pConnect(connectionOpts = {}) {
+    await this.connect({ ...connectionOpts, persists: true });
+  }
+
+  async connect(connectionOpts = {}) {
+    const clientOpts = {
+      host: connectionOpts.host ? connectionOpts.host : this.clientOpts.host,
+      user: connectionOpts.user ? connectionOpts.user : this.clientOpts.user,
+      password: connectionOpts.password
+        ? connectionOpts.password
+        : this.clientOpts.password,
+      database: connectionOpts.database
+        ? connectionOpts.database
+        : this.clientOpts.database,
+    };
+
+    const persistentConn = connectionOpts.persists || this.clientOpts.persists;
+
+    logger.debug(`${FILE}::PREPARING DB CONNECTION`, {
+      clientOpts,
+      persistentConn,
+    });
+
+    const conn = await mysql.createConnection(clientOpts);
+    conn.config.namedPlaceholders = true;
+    logger.debug(`${FILE}::DB CONNECTED`);
+
+    if (persistentConn) {
+      this.conn = conn;
+    }
+
+    return conn;
+  }
+
+  /* eslint-disable-next-line class-methods-use-this */
+  async end(conn = {}) {
+    logger.debug(`${FILE}::ENDING DB CONNECTION`);
+    if (!isEmpty(conn)) {
+      await conn.end();
+      logger.debug(`${FILE}::DB DISCONNECTED`);
+    } else {
+      await this.conn.end();
+      logger.debug(`${FILE}::PERSISTED DB DISCONNECTED`);
+    }
+  }
+
+  async query(sql, sqlParams, connectionOpts = {}) {
+    let conn = {};
+    if (!isEmpty(connectionOpts)) {
+      conn = await this.connect(connectionOpts);
+    } else if (isEmpty(this.conn)) {
+      conn = await this.connect();
+    } else {
+      conn = this.conn;
+    }
+
+    try {
+      logger.debug(`${FILE}::QUERYING_DB`, { sql, sqlParams });
+      const [results, fields] = await conn.execute(sql, sqlParams);
+      logger.debug(`${FILE}::DB_RESPONSE`, { results, fields });
+
+      return { results, fields };
+    } catch (err) {
+      throw new LesgoException(
+        'Exception caught executing SQL Statement',
+        `${FILE}::QUERY_EXECUTION_EXCEPTION`,
+        500,
+        { err }
+      );
+    } finally {
+      if (isEmpty(this.conn) || !isEmpty(connectionOpts)) await this.end(conn);
+    }
+  }
+
+  async select(sql, sqlParams, connectionOpts = {}) {
+    const resp = await this.query(sql, sqlParams, connectionOpts);
+    return resp.results;
+  }
+
+  async selectFirst(sql, sqlParams, connectionOpts = {}) {
+    const resp = await this.query(sql, sqlParams, connectionOpts);
+    return resp.results[0];
+  }
+
+  async selectPaginate(
+    sql,
+    sqlParams,
+    perPage = 10,
+    currentPage = 1,
+    total = null,
+    connectionOpts = {}
+  ) {
+    let paginator;
+    if (typeof total === 'number') {
+      paginator = new LengthAwarePaginator(
+        this,
+        sql,
+        sqlParams,
+        {
+          perPage,
+          currentPage,
+          total,
+        },
+        connectionOpts
+      );
+    } else {
+      paginator = new Paginator(
+        this,
+        sql,
+        sqlParams,
+        {
+          perPage,
+          currentPage,
+        },
+        connectionOpts
+      );
+    }
+
+    return (await paginator).toObject();
+  }
+
+  async insert(sql, sqlParams, connectionOpts = {}) {
+    const resp = await this.query(sql, sqlParams, connectionOpts);
+
+    if (resp.results.affectedRows <= 0) {
+      throw new LesgoException(
+        'No records inserted from INSERT query',
+        `${FILE}::NO_RECORDS_INSERTED`,
+        400,
+        { resp, sql, sqlParams }
+      );
+    }
+
+    return resp.results.insertId;
+  }
+
+  async update(sql, sqlParams, connectionOpts = {}) {
+    const resp = await this.query(sql, sqlParams, connectionOpts);
+
+    if (resp.results.changedRows <= 0) {
+      logger.warn(`${FILE}::No records updated from UPDATE query`, {
+        sql,
+        sqlParams,
+      });
+    }
+
+    return Promise.resolve();
+  }
+}

package/src/services/ElasticsearchService.js

@@ -39,22 +39,17 @@ class ElasticsearchService {
   }
 
   search(body) {
-    return new Promise((resolve, reject) => {
-      const param = {
-        index: this.index,
-        type: this.type,
-        body,
-      };
-      this.client.search(param, (err, response) => {
-        /* istanbul ignore next */
-        if (err) {
-          reject(err);
-        }
-
-        this.result = response;
-
-        resolve(response);
-      });
+    const param = {
+      index: this.index,
+      type: this.type,
+      body,
+    };
+
+    return this.client.search(param, (err, response) => {
+      if (err) return Promise.reject(err);
+
+      this.result = response;
+      return Promise.resolve(response);
     });
   }
 
@@ -75,11 +70,9 @@ class ElasticsearchService {
       body: settings,
     };
 
-    return new Promise((resolve, reject) => {
-      this.client.indices.create(params, (err, response) => {
-        // eslint-disable-next-line no-unused-expressions
-        err ? /* istanbul ignore next */ reject(err) : resolve(response);
-      });
+    return this.client.indices.create(params, (err, response) => {
+      if (err) return Promise.reject(err);
+      return Promise.resolve(response);
     });
   }
 
@@ -89,31 +82,27 @@ class ElasticsearchService {
       ...options,
     };
 
-    return new Promise((resolve, reject) => {
-      this.client.indices.delete(params, (err, response) => {
-        // eslint-disable-next-line no-unused-expressions
-        err ? /* istanbul ignore next */ reject(err) : resolve(response);
-      });
+    return this.client.indices.delete(params, (err, response) => {
+      if (err) return Promise.reject(err);
+      return Promise.resolve(response);
     });
   }
 
   existIndices(index, options = {}) {
     const params = { index, ...options };
-    return new Promise((resolve, reject) => {
-      this.client.indices.exists(params, (err, response) => {
-        // eslint-disable-next-line no-unused-expressions
-        err ? /* istanbul ignore next */ reject(err) : resolve(response.body);
-      });
+
+    return this.client.indices.exists(params, (err, response) => {
+      if (err) return Promise.reject(err);
+      return Promise.resolve(response.body);
     });
   }
 
   putMapping(index, type, body) {
     const params = { index, type, body: { properties: body } };
-    return new Promise((resolve, reject) => {
-      this.client.indices.putMapping(params, (err, response) => {
-        // eslint-disable-next-line no-unused-expressions
-        err ? /* istanbul ignore next */ reject(err) : resolve(response);
-      });
+
+    return this.client.indices.putMapping(params, (err, response) => {
+      if (err) return Promise.reject(err);
+      return Promise.resolve(response);
     });
   }
 
@@ -124,11 +113,9 @@ class ElasticsearchService {
       id,
     };
 
-    return new Promise((resolve, reject) => {
-      this.client.get(params, (err, response) => {
-        // eslint-disable-next-line no-unused-expressions
-        err ? /* istanbul ignore next */ reject(err) : resolve(response);
-      });
+    return this.client.get(params, (err, response) => {
+      if (err) return Promise.reject(err);
+      return Promise.resolve(response);
     });
   }
 
@@ -141,24 +128,20 @@ class ElasticsearchService {
       refresh,
     };
 
-    return new Promise((resolve, reject) => {
-      this.client.index(params, (err, response) => {
-        // eslint-disable-next-line no-unused-expressions
-        err ? /* istanbul ignore next */ reject(err) : resolve(response);
-      });
+    return this.client.index(params, (err, response) => {
+      if (err) return Promise.reject(err);
+      return Promise.resolve(response);
     });
   }
 
   bulkIndex(bodies) {
-    return new Promise((resolve, reject) => {
-      this.client.bulk(
-        { body: this.constructBulkIndex(bodies) },
-        (err, response) => {
-          // eslint-disable-next-line no-unused-expressions
-          err ? /* istanbul ignore next */ reject(err) : resolve(response);
-        }
-      );
-    });
+    return this.client.bulk(
+      { body: this.constructBulkIndex(bodies) },
+      (err, response) => {
+        if (err) return Promise.reject(err);
+        return Promise.resolve(response);
+      }
+    );
   }
 
   create(id, body) {
@@ -169,11 +152,9 @@ class ElasticsearchService {
       body,
     };
 
-    return new Promise((resolve, reject) => {
-      this.client.index(params, (err, response) => {
-        // eslint-disable-next-line no-unused-expressions
-        err ? /* istanbul ignore next */ reject(err) : resolve(response);
-      });
+    return this.client.index(params, (err, response) => {
+      if (err) return Promise.reject(err);
+      return Promise.resolve(response);
     });
   }
 
@@ -184,11 +165,9 @@ class ElasticsearchService {
       id,
     };
 
-    return new Promise((resolve, reject) => {
-      this.client.get(params, (err, response) => {
-        // eslint-disable-next-line no-unused-expressions
-        err ? /* istanbul ignore next */ reject(err) : resolve(response);
-      });
+    return this.client.get(params, (err, response) => {
+      if (err) return Promise.reject(err);
+      return Promise.resolve(response);
     });
   }
 

package/src/services/__tests__/AuroraDbRDSProxyService.spec.js

@@ -0,0 +1,278 @@
+import mysql from 'mysql2/promise';
+import AuroraDbRDSProxyService from '../AuroraDbRDSProxyService';
+import LesgoException from '../../exceptions/LesgoException';
+
+const auroraConfig = {
+  host: 'some-fake-host',
+  user: 'fakeUsername',
+  password: 'fakePassword',
+  database: 'fakeDbName',
+};
+
+const customConfig = {
+  host: 'some-fake-host-2',
+  user: 'fakeUsername2',
+  password: 'fakePassword2',
+  database: 'fakeDbName2',
+};
+
+describe('test AuroraDbRDSProxyService instantiate', () => {
+  it('should not throw exception when instantiating', () => {
+    const db = new AuroraDbRDSProxyService(auroraConfig);
+    expect(db.clientOpts).toMatchObject(auroraConfig);
+  });
+
+  it('should allow for empty config', () => {
+    const db = new AuroraDbRDSProxyService();
+    expect(db.clientOpts).toMatchObject({});
+  });
+});
+
+describe('test AuroraDbRDSProxyService connect', () => {
+  it('should be able to connect without custom config', async () => {
+    const db = new AuroraDbRDSProxyService(auroraConfig);
+    const conn = await db.connect();
+
+    expect(conn.mocked).toMatchObject(auroraConfig);
+  });
+
+  it('should be able to connect with custom config', async () => {
+    const db = new AuroraDbRDSProxyService(auroraConfig);
+    const conn = await db.connect(customConfig);
+
+    expect(conn.mocked).toMatchObject(customConfig);
+  });
+});
+
+describe('test AuroraDbRDSProxyService query', () => {
+  it('should return results object when calling query function', async () => {
+    const db = new AuroraDbRDSProxyService(auroraConfig);
+    const resp = await db.query('SELECT_QUERY', {});
+
+    expect(resp).toMatchObject({
+      results: [
+        {
+          id: 1,
+          uid: 'some-uid-1',
+        },
+        {
+          id: 2,
+          uid: 'some-uid-2',
+        },
+      ],
+    });
+
+    expect(mysql.createConnection).toHaveBeenCalled();
+  });
+
+  it('should return results object when calling querying with connection options passed', async () => {
+    const db = new AuroraDbRDSProxyService(auroraConfig);
+    const resp = await db.query('SELECT_QUERY', {}, auroraConfig);
+
+    expect(resp).toMatchObject({
+      results: [
+        {
+          id: 1,
+          uid: 'some-uid-1',
+        },
+        {
+          id: 2,
+          uid: 'some-uid-2',
+        },
+      ],
+    });
+
+    expect(mysql.createConnection).toHaveBeenCalled();
+  });
+
+  it('should return results object when calling querying with no connection options passed and persistent conn', async () => {
+    const db = new AuroraDbRDSProxyService(auroraConfig);
+    await db.pConnect();
+    const resp = await db.query('SELECT_QUERY', {});
+
+    expect(resp).toMatchObject({
+      results: [
+        {
+          id: 1,
+          uid: 'some-uid-1',
+        },
+        {
+          id: 2,
+          uid: 'some-uid-2',
+        },
+      ],
+    });
+
+    expect(mysql.createConnection).toHaveBeenCalled();
+  });
+});
+
+describe('test AuroraDbRDSProxyService select', () => {
+  it('should return array results when calling select function', async () => {
+    const db = new AuroraDbRDSProxyService(auroraConfig);
+    return expect(db.select('SELECT_QUERY', {})).resolves.toMatchObject([
+      {
+        id: 1,
+        uid: 'some-uid-1',
+      },
+      {
+        id: 2,
+        uid: 'some-uid-2',
+      },
+    ]);
+  });
+
+  it('should throw an exception when writing with invalid query', async () => {
+    const error = new LesgoException(
+      'Exception caught executing SQL Statement',
+      'AURORADBSERVICE_QUERY_EXCEPTION',
+      500,
+      {
+        err: {
+          code: 'BadRequestException',
+        },
+      }
+    );
+
+    const db = new AuroraDbRDSProxyService(auroraConfig);
+    return expect(db.select('INVALID_QUERY', {})).rejects.toMatchObject(error);
+  });
+
+  it('should throw an exception when calling select with invalid query parameters', async () => {
+    const error = new LesgoException(
+      'Exception caught executing SQL Statement',
+      'AURORADBSERVICE_QUERY_EXCEPTION',
+      500,
+      {
+        err: {
+          code: 'BadRequestException',
+        },
+      }
+    );
+
+    const db = new AuroraDbRDSProxyService(auroraConfig);
+    return expect(
+      db.select('RANDOM_QUERY', 'INVALID_QUERY_PARAMETERS')
+    ).rejects.toMatchObject(error);
+  });
+});
+
+describe('test AuroraDbRDSProxyService selectPaginate', () => {
+  it('should return paginated results when calling selectPaginate function', async () => {
+    const db = new AuroraDbRDSProxyService(auroraConfig);
+    return expect(db.selectPaginate('SELECT_QUERY', {})).resolves.toMatchObject(
+      {
+        count: 2,
+        previous_page: false,
+        current_page: 1,
+        next_page: false,
+        per_page: 10,
+        items: [
+          {
+            id: 1,
+            uid: 'some-uid-1',
+          },
+          {
+            id: 2,
+            uid: 'some-uid-2',
+          },
+        ],
+      }
+    );
+  });
+
+  it('should return paginated results when calling selectPaginate with defined total', async () => {
+    const db = new AuroraDbRDSProxyService(auroraConfig);
+    return expect(
+      db.selectPaginate('SELECT_QUERY', {}, 1, 2, 1)
+    ).resolves.toMatchObject({
+      count: 1,
+      previous_page: 1,
+      current_page: 2,
+      next_page: 3,
+      per_page: 1,
+      items: [
+        {
+          id: 1,
+          uid: 'some-uid-1',
+        },
+      ],
+    });
+  });
+});
+
+describe('test AuroraDbRDSProxyService selectFirst', () => {
+  it('should only return the first record when calling selectFirst', async () => {
+    const db = new AuroraDbRDSProxyService(auroraConfig);
+    return expect(db.selectFirst('SELECT_QUERY', {})).resolves.toMatchObject({
+      id: 1,
+      uid: 'some-uid-1',
+    });
+  });
+});
+
+describe('test AuroraDbRDSProxyService insert', () => {
+  it('should return recordId when inserting record', async () => {
+    const db = new AuroraDbRDSProxyService(auroraConfig);
+    return expect(db.insert('INSERT_QUERY', {})).resolves.toEqual(20);
+  });
+
+  it('should throw exception when calling insert with invalid query', async () => {
+    const error = new LesgoException(
+      'No records inserted from INSERT query',
+      'AURORADBSERVICE_NO_RECORDS_INSERTED',
+      400
+    );
+
+    const db = new AuroraDbRDSProxyService(auroraConfig);
+    return expect(db.insert('INVALID_INSERT_QUERY', {})).rejects.toMatchObject(
+      error
+    );
+  });
+});
+
+describe('test AuroraDbRDSProxyService update', () => {
+  it('should return success when making update query', async () => {
+    const db = new AuroraDbRDSProxyService(auroraConfig);
+    return expect(db.update('UPDATE_QUERY', {})).resolves.not.toThrow();
+  });
+
+  it('should throw not exception when caliing update with invalid query', async () => {
+    const db = new AuroraDbRDSProxyService(auroraConfig);
+    return expect(db.update('INVALID_UPDATE_QUERY', {})).resolves.not.toThrow();
+  });
+});
+
+describe('test AuroraDbRDSProxyService pConnect', () => {
+  it('should be able to connect without custom config', async () => {
+    const db = new AuroraDbRDSProxyService(auroraConfig);
+    await db.pConnect();
+
+    expect(db.conn.mocked).toMatchObject(auroraConfig);
+  });
+
+  it('should be able to connect with custom config', async () => {
+    const db = new AuroraDbRDSProxyService(auroraConfig);
+    await db.pConnect(customConfig);
+
+    expect(db.conn.mocked).toMatchObject(customConfig);
+  });
+});
+
+describe('test AuroraDbRDSProxyService end', () => {
+  it('should end the connection when passed', async () => {
+    const db = new AuroraDbRDSProxyService(auroraConfig);
+    const conn = await db.connect();
+    await db.end(conn);
+
+    expect(conn.end).toHaveBeenCalledTimes(1);
+  });
+
+  it('should end the persisted connection when none is passed', async () => {
+    const db = new AuroraDbRDSProxyService(auroraConfig);
+    await db.pConnect();
+    await db.end();
+
+    expect(db.conn.end).toHaveBeenCalledTimes(1);
+  });
+});

package/src/services/__tests__/LengthAwarePaginator.spec.js

@@ -32,6 +32,8 @@ describe('test LengthAwarePaginator instantiate', () => {
     expect(await paginator.lastItem()).toMatchObject(mockDataLastItem);
     expect(paginator.perPage()).toEqual(5);
     expect(await paginator.total()).toEqual(30);
+
+    expect(db.select).toHaveBeenCalled();
   });
   it('should not throw exception when instantiating with current page', async () => {
     const paginator = new LengthAwarePaginator(
@@ -51,6 +53,8 @@ describe('test LengthAwarePaginator instantiate', () => {
     expect(await paginator.lastItem()).toMatchObject(mockDataLastItem);
     expect(paginator.perPage()).toEqual(5);
     expect(await paginator.total()).toEqual(30);
+
+    expect(db.select).toHaveBeenCalled();
   });
   it('should default perPage to 10 when instantiating without perPage', async () => {
     const paginator = new LengthAwarePaginator(
@@ -66,6 +70,8 @@ describe('test LengthAwarePaginator instantiate', () => {
     expect(paginator.currentPage()).toEqual(1);
     expect(paginator.perPage()).toEqual(10);
     expect(await paginator.total()).toEqual(30);
+
+    expect(db.select).toHaveBeenCalled();
   });
   it('should throw exception if total is not a number', async () => {
     try {
@@ -116,6 +122,43 @@ describe('test LengthAwarePaginator instantiate', () => {
         { ...mockDataLastItem },
       ],
     });
+
+    expect(db.select).toHaveBeenCalled();
+  });
+
+  it('should simply return an empty paginator object if total is explicitly zero', async () => {
+    const paginator = new LengthAwarePaginator(
+      db,
+      'SELECT * FROM tests',
+      {},
+      {
+        perPage: 5,
+        currentPage: 1,
+        total: 0,
+      }
+    );
+
+    expect(await paginator.count()).toEqual(0);
+    expect(await paginator.previousPage()).toEqual(false);
+    expect(paginator.currentPage()).toEqual(1);
+    expect(await paginator.nextPage()).toEqual(false);
+    expect(await paginator.firstItem()).toBe(undefined);
+    expect(await paginator.lastItem()).toBe(undefined);
+    expect(paginator.perPage()).toEqual(5);
+    expect(await paginator.total()).toEqual(0);
+
+    expect(await paginator.toObject()).toMatchObject({
+      count: 0,
+      previous_page: false,
+      current_page: 1,
+      next_page: false,
+      per_page: 5,
+      last_page: 0,
+      total: 0,
+      items: [],
+    });
+
+    expect(db.select).not.toHaveBeenCalled();
   });
 });
 
@@ -138,7 +181,7 @@ describe('test total() usage', () => {
 });
 
 describe('test lastPage() usage', () => {
-  it('should get the last page using supplied paramater as total data', async () => {
+  it('should get the last page using supplied parameter as total data', async () => {
     const paginator1 = new LengthAwarePaginator(
       db,
       'SELECT * FROM total_tests',

package/src/services/pagination/LengthAwarePaginator.js

@@ -12,8 +12,9 @@ export default class LengthAwarePaginator extends Paginator {
    * @param sql
    * @param sqlParams
    * @param options
+   * @param connection
    */
-  constructor(db, sql, sqlParams, options) {
+  constructor(db, sql, sqlParams, options, connection = {}) {
     const validFields = [{ key: 'total', type: 'number', required: true }];
 
     let validated = {};
@@ -33,7 +34,7 @@ export default class LengthAwarePaginator extends Paginator {
 
     const { total } = validated;
 
-    super(db, sql, sqlParams, options);
+    super(db, sql, sqlParams, options, connection);
     this.totalProp = total;
   }
 

package/src/services/pagination/Paginator.js

@@ -12,13 +12,14 @@ export default class Paginator {
    * @param sqlParams
    * @param options
    */
-  constructor(db, sql, sqlParams, options = {}) {
+  constructor(db, sql, sqlParams, options = {}, connection = {}) {
     const validFields = [
       { key: 'db', type: 'object', required: true },
       { key: 'sql', type: 'string', required: true },
       { key: 'sqlParams', type: 'object', required: true },
       { key: 'perPage', type: 'number', required: false },
       { key: 'currentPage', type: 'number', required: false },
+      { key: 'connection', type: 'object', required: false },
     ];
 
     let validated = {};
@@ -29,6 +30,7 @@ export default class Paginator {
           sql,
           sqlParams,
           ...options,
+          connection,
         },
         validFields
       );
@@ -56,6 +58,8 @@ export default class Paginator {
 
     this.response = [];
     this.totalProp = false;
+
+    this.connection = connection;
   }
 
   /**
@@ -213,10 +217,17 @@ export default class Paginator {
   }
 
   async executeQuery() {
-    this.response = await this.dbProp.select(
-      this.generatePaginationSqlSnippet(),
-      this.sqlParamsProp
-    );
+    const total = this.totalProp;
+    if (
+      (typeof total === 'number' && total > 0) ||
+      (typeof total !== 'number' && !total)
+    ) {
+      this.response = await this.dbProp.select(
+        this.generatePaginationSqlSnippet(),
+        this.sqlParamsProp,
+        this.connection
+      );
+    }
 
     this.hasNext = this.response.length > this.perPage();
     if (this.hasNext) {
@@ -232,7 +243,11 @@ export default class Paginator {
    * @returns {Promise<number>}
    */
   async countTotalItems() {
-    const resp = await this.dbProp.select(this.sqlProp, this.sqlParamsProp);
+    const resp = await this.dbProp.select(
+      this.sqlProp,
+      this.sqlParamsProp,
+      this.connection
+    );
     this.totalProp = Object.keys(resp).length;
 
     return this.totalProp;

package/src/utils/__tests__/db.spec.js

@@ -1,5 +1,12 @@
 import config from 'Config/db'; // eslint-disable-line import/no-unresolved
-import db from '../db';
+
+let db;
+
+beforeEach(() => {
+  jest.isolateModules(() => {
+    db = require('../db').default; // eslint-disable-line global-require
+  });
+});
 
 describe('test db utils instantiate', () => {
   it('should not throw error on instantiating AuroraDbService', () => {
@@ -29,4 +36,36 @@ describe('test db utils instantiate', () => {
       },
     });
   });
+
+  it('should update AuroraDb credentials on connect based on dataApi config', () => {
+    config.default = 'dataApi';
+    let thisDb;
+    jest.isolateModules(() => {
+      thisDb = require('../db').default; // eslint-disable-line global-require
+    });
+
+    return expect(thisDb.client).toMatchObject({
+      mocked: {
+        database: config.connections.dataApi.database,
+        resourceArn: config.connections.dataApi.resourceArn,
+        secretArn: config.connections.dataApi.secretArn,
+      },
+    });
+  });
+
+  it('should update AuroraDb credentials on connect based on rdsProxy config', () => {
+    config.default = 'rdsProxy';
+    let thisDb;
+    jest.isolateModules(() => {
+      thisDb = require('../db').default; // eslint-disable-line global-require
+    });
+
+    return expect(thisDb.clientOpts).toMatchObject({
+      database: config.connections.rdsProxy.database,
+      host: config.connections.rdsProxy.host,
+      user: config.connections.rdsProxy.user,
+      password: config.connections.rdsProxy.password,
+      persists: config.connections.rdsProxy.persists,
+    });
+  });
 });

package/src/utils/db.js

@@ -1,6 +1,17 @@
-import config from 'Config/db'; // eslint-disable-line import/no-unresolved
+import dbConfig from 'Config/db'; // eslint-disable-line import/no-unresolved
+import AuroraDbRDSProxyService from '../services/AuroraDbRDSProxyService';
 import AuroraDbService from '../services/AuroraDbService';
 
-const db = new AuroraDbService(config);
+/* eslint-disable-next-line import/no-mutable-exports */
+let db;
+
+if (dbConfig.default === 'rdsProxy' || dbConfig.default === 'rdsProxyRead') {
+  db = new AuroraDbRDSProxyService(dbConfig.connections[dbConfig.default]);
+} else if (dbConfig.default === 'dataApi') {
+  db = new AuroraDbService(dbConfig.connections[dbConfig.default]);
+} else {
+  // @deprecated
+  db = new AuroraDbService(dbConfig);
+}
 
 export default db;

package/src/utils/logger.js

@@ -4,7 +4,7 @@ import LoggerService from '../services/LoggerService';
 const transports = [
   {
     logType: 'console',
-    level: app.debug ? 'debug' : 'info',
+    level: /* istanbul ignore next */ app.debug ? 'debug' : 'info',
     config: {
       getCreatedAt: true,
       tags: {