lesgo 0.6.1 → 0.7.1

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

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,10 +4,7 @@ import LoggerService from '../services/LoggerService';
 const transports = [
   {
     logType: 'console',
-    level:
-      app.env === 'local' && /* istanbul ignore next */ app.debug
-        ? /* istanbul ignore next */ 'debug'
-        : 'info',
+    level: /* istanbul ignore next */ app.debug ? 'debug' : 'info',
     config: {
       getCreatedAt: true,
       tags: {

package/src/utils/validateFields.js

@@ -8,13 +8,31 @@ export default (params, validFields) => {
   const validated = {};
 
   validFields.forEach(field => {
-    if (field.required && !params[field.key]) {
-      throw new LesgoException(
-        `Missing required '${field.key}'`,
-        `${FILE}::MISSING_REQUIRED_${field.key.toUpperCase()}`,
-        500,
-        { field }
-      );
+    if (field.required) {
+      if (typeof params[field.key] === 'object') {
+        if (
+          Array.isArray(params[field.key]) &&
+          params[field.key].length === 0
+        ) {
+          throw new LesgoException(
+            `Missing required '${field.key}'`,
+            `${FILE}::MISSING_REQUIRED_${field.key.toUpperCase()}`,
+            500,
+            { field }
+          );
+        }
+      }
+
+      if (!params[field.key]) {
+        if (typeof params[field.key] !== 'number') {
+          throw new LesgoException(
+            `Missing required '${field.key}'`,
+            `${FILE}::MISSING_REQUIRED_${field.key.toUpperCase()}`,
+            500,
+            { field }
+          );
+        }
+      }
     }
 
     if (
@@ -35,7 +53,7 @@ export default (params, validFields) => {
         !isEmail(params[field.key])) ||
       (field.type === 'array' &&
         typeof params[field.key] !== 'undefined' &&
-        (!Array.isArray(params[field.key]) || !params[field.key].length)) ||
+        !Array.isArray(params[field.key])) ||
       (field.type === 'enum' &&
         typeof params[field.key] !== 'undefined' &&
         !field.enumValues.includes(params[field.key]))