lesgo 0.6.3 → 0.7.0

package/bin/lesgo-scripts.sh

@@ -1,5 +1,7 @@
 #!/usr/bin/env bash
 
+set -Eeuo pipefail
+
 ###############################################################################
 #                                                                             #
 # INITIALIZE EVERYTHING                                                       #

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lesgo",
-  "version": "0.6.3",
+  "version": "0.7.0",
   "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/__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/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;
   }
 
   /**
@@ -215,7 +219,8 @@ export default class Paginator {
   async executeQuery() {
     this.response = await this.dbProp.select(
       this.generatePaginationSqlSnippet(),
-      this.sqlParamsProp
+      this.sqlParamsProp,
+      this.connection
     );
 
     this.hasNext = this.response.length > this.perPage();
@@ -232,7 +237,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: {