lesgo 0.6.2 → 0.7.2

package/src/services/AuroraDbService.js

@@ -4,6 +4,8 @@ import LesgoException from '../exceptions/LesgoException';
 import LengthAwarePaginator from './pagination/LengthAwarePaginator';
 import Paginator from './pagination/Paginator';
 
+const FILE = 'Lesgo/services/AuroraDbService';
+
 export default class AuroraDbService {
   constructor(opts = {}) {
     this.client = null;
@@ -11,20 +13,26 @@ export default class AuroraDbService {
   }
 
   connect(opts) {
-    const { secretArn, resourceArn, database } = opts;
+    const { secretArn, resourceArn, database, region } = opts;
 
-    this.client = dataApiClient({
+    const clientOpts = {
       secretArn,
       resourceArn,
       database,
-    });
+    };
+
+    if (region) {
+      clientOpts.region = region;
+    }
+
+    this.client = dataApiClient(clientOpts);
   }
 
   async query(sql, sqlParams) {
     try {
-      logger.info('QUERYING AURORA DB', { sql, sqlParams });
+      logger.debug(`${FILE}::QUERYING_DB`, { sql, sqlParams });
       const resp = await this.client.query(sql, sqlParams);
-      logger.info('AURORA DB RESPONSE', { resp });
+      logger.debug(`${FILE}::DB_RESPONSE`, { resp });
 
       return resp;
     } catch (err) {

package/src/services/DynamoDbService.js

@@ -2,6 +2,8 @@ import { DocumentClient } from 'aws-sdk/clients/dynamodb'; // eslint-disable-lin
 import LesgoException from '../exceptions/LesgoException';
 import logger from '../utils/logger';
 
+const FILE = 'Lesgo/services/DynamoDbService';
+
 export default class DynamoDb {
   constructor(opts = {}) {
     this.client = null;
@@ -35,11 +37,11 @@ export default class DynamoDb {
       projectionExpression
     );
 
-    logger.info('PREPARING TO QUERY DYNAMODB', { params });
+    logger.debug(`${FILE}::PREPARING_QUERY`, { params });
 
     try {
       const data = await this.client.query(params).promise();
-      logger.info('RECEIVED RESPONSE FROM DYNAMODB', { data });
+      logger.debug(`${FILE}::RECEIVED_QUERY_RESPONSE`, { data });
       return data.Items;
     } catch (err) {
       throw new LesgoException(
@@ -62,11 +64,11 @@ export default class DynamoDb {
       expressionAttributeValues
     );
 
-    logger.info('PREPARING TO QUERY COUNT DYNAMODB', { params });
+    logger.debug(`${FILE}::PREPARING_QUERY_COUNT`, { params });
 
     try {
       const data = await this.client.query(params).promise();
-      logger.info('RECEIVED RESPONSE FROM DYNAMODB', { data });
+      logger.debug(`${FILE}::RECEIVED_QUERY_COUNT_RESPONSE`, { data });
       return data.Count;
     } catch (err) {
       throw new LesgoException(
@@ -81,11 +83,11 @@ export default class DynamoDb {
   async put(tableName, item) {
     const params = this.preparePutPayload(tableName, item);
 
-    logger.info('PREPARING TO PUT ITEM TO DYNAMODB', { params });
+    logger.debug(`${FILE}::PREPARING_PUT`, { params });
 
     try {
       const data = await this.client.put(params).promise();
-      logger.info('RECEIVED RESPONSE FROM DYNAMODB', { data });
+      logger.debug(`${FILE}::RECEIVED_PUT_RESPONSE`, { data });
       return data;
     } catch (err) {
       throw new LesgoException(
@@ -105,11 +107,11 @@ export default class DynamoDb {
       expressionAttributeValues
     );
 
-    logger.info('PREPARING TO UPDATE ITEM ON DYNAMODB', { params });
+    logger.debug(`${FILE}::PREPARING_UPDATE`, { params });
 
     try {
       const data = await this.client.update(params).promise();
-      logger.info('RECEIVED RESPONSE FROM DYNAMODB', { data });
+      logger.debug(`${FILE}::RECEIVED_UPDATE_RESPONSE`, { data });
       return data;
     } catch (err) {
       throw new LesgoException(

package/src/services/FirebaseAdminService.js

@@ -3,6 +3,8 @@ import logger from '../utils/logger';
 import isEmpty from '../utils/isEmpty';
 import LesgoException from '../exceptions/LesgoException';
 
+const FILE = 'Lesgo/services/FirebaseAdminService';
+
 export default class FirebaseAdmin {
   constructor(opts = {}) {
     this.app = null;
@@ -30,13 +32,13 @@ export default class FirebaseAdmin {
     const max = !isEmpty(maxResults) ? maxResults : 25;
 
     try {
-      logger.info('FETCHING FIREBASE USERS', {
+      logger.debug(`${FILE}::FETCHING_USERS`, {
         max,
         maxResults,
         nextPageToken,
       });
       const users = await this.app.auth().listUsers(max, nextPageToken);
-      logger.info('FETCHED FIREBASE USERS', { users });
+      logger.debug(`${FILE}::USERS_FETCHED`, { users });
       return users.users;
     } catch (err) {
       throw new LesgoException(
@@ -58,9 +60,9 @@ export default class FirebaseAdmin {
         displayName: username,
       };
 
-      logger.info('CREATING USER ON FIREBASE', { userData, data });
+      logger.debug(`${FILE}::CREATING_USER`, { userData, data });
       const user = await this.app.auth().createUser(userData);
-      logger.info('USER CREATED ON FIREBASE', { user });
+      logger.debug(`${FILE}::USER_CREATED`, { user });
       return user;
     } catch (err) {
       throw new LesgoException(
@@ -74,9 +76,9 @@ export default class FirebaseAdmin {
 
   async deleteUser(uid) {
     try {
-      logger.info('DELETING FIREBASE USER');
+      logger.debug(`${FILE}::DELETING_USER`);
       const deleted = await this.app.auth().deleteUser(uid);
-      logger.info('DELETED FIREBASE USER', { deleted, uid });
+      logger.debug(`${FILE}::USER_DELETED`, { deleted, uid });
       return deleted;
     } catch (err) {
       throw new LesgoException(
@@ -90,8 +92,9 @@ export default class FirebaseAdmin {
 
   async delete() {
     try {
-      logger.info('DELETING FIREBASE APP');
+      logger.debug(`${FILE}::DELETING_APP`);
       const resp = await this.app.delete();
+      logger.debug(`${FILE}::APP_DELETED`, { resp });
       return resp;
     } catch (err) {
       throw new LesgoException(

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__/AuroraDbService.spec.js

@@ -23,6 +23,16 @@ describe('test AuroraDbService instantiate', () => {
     expect(dataApiClient).toHaveBeenCalledWith(auroraConfig);
     expect(db.client.mocked).toMatchObject(auroraConfig);
   });
+
+  it('should not throw exception with custom region', () => {
+    const db = new AuroraDbService({
+      ...auroraConfig,
+      region: 'ap-southeast-1',
+    });
+
+    expect(dataApiClient).toHaveBeenCalledWith(auroraConfig);
+    expect(db.client.mocked).toMatchObject(auroraConfig);
+  });
 });
 
 describe('test AuroraDbService connect', () => {

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/__tests__/validateFields.spec.js

@@ -11,6 +11,7 @@ const params = {
   listItem: ['apple', 'banana'],
   status: 'active',
   decimalCheck: 1.99,
+  totalRecord: 99,
 };
 
 const validFields = [
@@ -25,11 +26,8 @@ const validFields = [
     enumValues: ['active', 'inactive'],
     required: true,
   },
-  {
-    key: 'decimalCheck',
-    type: 'decimal',
-    required: true,
-  },
+  { key: 'decimalCheck', type: 'decimal', required: true },
+  { key: 'totalRecord', type: 'number', required: true },
 ];
 
 describe('test Utils/validateFields', () => {
@@ -93,6 +91,28 @@ describe('test Utils/validateFields', () => {
     );
   });
 
+  it('should throw required when array value is empty but required', () => {
+    const newParams = { ...params, listItem: [] };
+
+    expect(() => validateFields(newParams, validFields)).toThrow(
+      new LesgoException(
+        `Missing required 'listItem'`,
+        `${FILE}::MISSING_REQUIRED_LISTITEM`
+      )
+    );
+  });
+
+  it('should not throw invalid type when array value is empty and not required', () => {
+    const newParams = { ...params, listItem: [] };
+    const newValidFields = [
+      { key: 'listItem', type: 'array', required: false },
+    ];
+
+    expect(validateFields(newParams, newValidFields)).toMatchObject({
+      listItem: [],
+    });
+  });
+
   it('should throw invalid type when non-enum value check', async () => {
     const newParams = { ...params, status: 'private' };
 
@@ -123,5 +143,41 @@ describe('test Utils/validateFields', () => {
     expect(validated).toMatchObject(newParams);
     expect(validated.Id).toBeDefined();
     expect(validated.listItem).toBeUndefined();
+
+    validFields[4].required = true;
+  });
+
+  it('should return success with validated data for 0 number', () => {
+    const newParams = { ...params, totalRecord: 0 };
+    const validated = validateFields(newParams, validFields);
+
+    expect(validated).toMatchObject(newParams);
+    expect(validated.totalRecord).toBeDefined();
+    expect(validated.totalRecord).toEqual(0);
+  });
+
+  it('should return success with validated data for number without required', () => {
+    const newParams = { ...params };
+    validFields[7].required = false;
+
+    const validated = validateFields(newParams, validFields);
+
+    expect(validated).toMatchObject(newParams);
+    expect(validated.totalRecord).toBeDefined();
+    expect(validated.totalRecord).toEqual(99);
+
+    validFields[7].required = true;
+  });
+
+  it('should return error with missing required number', () => {
+    const newParams = { ...params };
+    delete newParams.totalRecord;
+
+    expect(() => validateFields(newParams, validFields)).toThrow(
+      new LesgoException(
+        `Missing required 'totalRecord'`,
+        `${FILE}::MISSING_REQUIRED_TOTALRECORD`
+      )
+    );
   });
 });