lesgo 0.6.2 → 0.7.2

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.2",
+  "version": "0.7.2",
   "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/middlewares/verifyJwtMiddleware.js

@@ -3,7 +3,9 @@ import JwtService from '../services/JwtService';
 import LesgoException from '../exceptions/LesgoException';
 
 export const token = headers => {
-  if (!headers.Authorization) {
+  const authorizationHeader = headers.Authorization || headers.authorization;
+
+  if (!authorizationHeader) {
     throw new LesgoException(
       'Authorization Header is required!',
       'JWT_MISSING_AUTHORIZATION_HEADER',
@@ -11,7 +13,7 @@ export const token = headers => {
     );
   }
 
-  const parsed = headers.Authorization.split(' ');
+  const parsed = authorizationHeader.split(' ');
 
   if (!parsed[1]) {
     throw new LesgoException(

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();
+  }
+}