lesgo 0.6.0 → 0.7.0

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

@@ -0,0 +1,183 @@
+import LesgoException from '../../exceptions/LesgoException';
+import validateFields from '../validateFields';
+
+const FILE = 'Utils/validateFields';
+
+const params = {
+  Id: 99,
+  name: 'name',
+  email: 'email@mail.com',
+  roles: { admin: 'admin' },
+  listItem: ['apple', 'banana'],
+  status: 'active',
+  decimalCheck: 1.99,
+  totalRecord: 99,
+};
+
+const validFields = [
+  { key: 'Id', type: 'number', required: true },
+  { key: 'name', type: 'string', required: true },
+  { key: 'email', type: 'email', required: true },
+  { key: 'roles', type: 'object', required: true },
+  { key: 'listItem', type: 'array', required: true },
+  {
+    key: 'status',
+    type: 'enum',
+    enumValues: ['active', 'inactive'],
+    required: true,
+  },
+  { key: 'decimalCheck', type: 'decimal', required: true },
+  { key: 'totalRecord', type: 'number', required: true },
+];
+
+describe('test Utils/validateFields', () => {
+  it('should return validated fields', () => {
+    expect(validateFields(params, validFields)).toMatchObject(params);
+  });
+
+  it('should throw missing required field when not present', () => {
+    const newParams = { ...params };
+    delete newParams.email;
+
+    expect(() => validateFields(newParams, validFields)).toThrow(
+      new LesgoException(
+        "Missing required 'email'",
+        `${FILE}::MISSING_REQUIRED_EMAIL}`
+      )
+    );
+  });
+
+  it('should throw invalid type when non-string value check', () => {
+    const newParams = { ...params, name: 123 };
+
+    expect(() => validateFields(newParams, validFields)).toThrow(
+      new LesgoException(
+        `Invalid type for 'name', expecting 'string'`,
+        `${FILE}::INVALID_TYPE_NAME`
+      )
+    );
+  });
+
+  it('should throw invalid type when non-object value check', () => {
+    const newParams = { ...params, roles: 1597929335 };
+
+    expect(() => validateFields(newParams, validFields)).toThrow(
+      new LesgoException(
+        `Invalid type for 'roles', expecting 'object'`,
+        `${FILE}::INVALID_TYPE_ROLES`
+      )
+    );
+  });
+
+  it('should throw invalid type when non-number value check', () => {
+    const newParams = { ...params, Id: '123' };
+
+    expect(() => validateFields(newParams, validFields)).toThrow(
+      new LesgoException(
+        `Invalid type for 'Id', expecting 'number'`,
+        `${FILE}::INVALID_TYPE_ID`
+      )
+    );
+  });
+
+  it('should throw invalid type when non-array value check', () => {
+    const newParams = { ...params, listItem: { created_at: 1597929335 } };
+
+    expect(() => validateFields(newParams, validFields)).toThrow(
+      new LesgoException(
+        `Invalid type for 'listItem', expecting 'array'`,
+        `${FILE}::INVALID_TYPE_LISTITEM`
+      )
+    );
+  });
+
+  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' };
+
+    expect(() => validateFields(newParams, validFields)).toThrow(
+      new LesgoException(
+        `Invalid type for 'status', expecting 'enum'`,
+        `${FILE}::INVALID_TYPE_STATUS`
+      )
+    );
+  });
+
+  it('should return only valid and allowed fields when other fields are received', () => {
+    const newParams = { ...params, someOtherKey: 'someOtherValue' };
+    const validated = validateFields(newParams, validFields);
+
+    expect(validated).toMatchObject(params);
+    expect(validated.Id).toBeDefined();
+    expect(validated.someOtherKey).toBeUndefined();
+  });
+
+  it('should return success with validated data for non-required fields', () => {
+    const newParams = { ...params };
+    delete newParams.listItem;
+
+    validFields[4].required = false;
+    const validated = validateFields(newParams, validFields);
+
+    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/getJwtSubFromAuthHeader.js

@@ -0,0 +1,18 @@
+import isEmpty from './isEmpty';
+
+export const getTokenData = authHeader => {
+  try {
+    return JSON.parse(Buffer.from(authHeader.split('.')[1], 'base64'));
+  } catch (err) {
+    return {};
+  }
+};
+
+export default authHeader => {
+  if (isEmpty(authHeader)) {
+    return null;
+  }
+
+  const data = getTokenData(authHeader);
+  return data.sub || null;
+};

package/src/utils/index.js

@@ -4,6 +4,7 @@ import logger from './logger';
 import { getObject } from './objectStore';
 import { dispatch } from './queue';
 import isEmpty from './isEmpty';
+import isDecimal from './isDecimal';
 import crypto from './crypto';
 import generateUid from './generateUid';
 import db from './db';
@@ -17,6 +18,7 @@ export {
   getObject,
   logger,
   isEmpty,
+  isDecimal,
   crypto,
   generateUid,
   db,

package/src/utils/isDecimal.js

@@ -0,0 +1,2 @@
+export default number =>
+  typeof number !== 'string' && number.toString().indexOf('.') !== -1;

package/src/utils/isEmail.js

@@ -0,0 +1,15 @@
+import isEmpty from './isEmpty';
+import LesgoException from '../exceptions/LesgoException';
+
+export default email => {
+  const pattern = /^[\w\-\.\+]+\@[a-zA-Z0-9\.\-]+\.[a-zA-z0-9]{2,5}$/; // eslint-disable-line no-useless-escape
+
+  if (isEmpty(email)) {
+    throw new LesgoException(
+      'Empty parameter supplied',
+      'IS_EMAIL_EMPTY_PARAMETER'
+    );
+  }
+
+  return pattern.test(email);
+};

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/prepSQLInsertParams.js

@@ -0,0 +1,21 @@
+export default (params, columns) => {
+  const insertFields = {};
+  const insertColumns = [];
+  const insertValues = [];
+
+  columns.forEach(column => {
+    const { key } = column;
+
+    if (typeof params[key] !== 'undefined') {
+      insertColumns.push(key);
+      insertValues.push([`:${key}`]);
+      insertFields[key] = params[key];
+    }
+  });
+
+  return {
+    insertColumns: insertColumns.join(','),
+    insertValues: insertValues.join(','),
+    insertFields,
+  };
+};

package/src/utils/prepSQLUpdateParams.js

@@ -0,0 +1,25 @@
+export default (params, columns) => {
+  const updateFields = {};
+  const updateColumnValues = [];
+  let wherePrimaryKey = '';
+
+  columns.forEach(column => {
+    const { key } = column;
+
+    if (typeof params[key] !== 'undefined') {
+      if (key === 'id') {
+        wherePrimaryKey = `${key}=:${key}`;
+        updateFields[key] = params[key];
+      } else {
+        updateColumnValues.push([`${key}=:${key}`]);
+        updateFields[key] = params[key];
+      }
+    }
+  });
+
+  return {
+    updateColumnValues: updateColumnValues.join(','),
+    wherePrimaryKey,
+    updateFields,
+  };
+};

package/src/utils/validateFields.js

@@ -0,0 +1,75 @@
+import LesgoException from '../exceptions/LesgoException';
+import isEmail from './isEmail';
+import isDecimal from './isDecimal';
+
+const FILE = 'Utils/validateFields';
+
+export default (params, validFields) => {
+  const validated = {};
+
+  validFields.forEach(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 (
+      (field.type === 'string' &&
+        typeof params[field.key] !== 'undefined' &&
+        typeof params[field.key] !== 'string') ||
+      (field.type === 'object' &&
+        typeof params[field.key] !== 'undefined' &&
+        typeof params[field.key] !== 'object') ||
+      (field.type === 'number' &&
+        typeof params[field.key] !== 'undefined' &&
+        typeof params[field.key] !== 'number') ||
+      (field.type === 'decimal' &&
+        typeof params[field.key] !== 'undefined' &&
+        !isDecimal(params[field.key])) ||
+      (field.type === 'email' &&
+        typeof params[field.key] !== 'undefined' &&
+        !isEmail(params[field.key])) ||
+      (field.type === 'array' &&
+        typeof params[field.key] !== 'undefined' &&
+        !Array.isArray(params[field.key])) ||
+      (field.type === 'enum' &&
+        typeof params[field.key] !== 'undefined' &&
+        !field.enumValues.includes(params[field.key]))
+    ) {
+      throw new LesgoException(
+        `Invalid type for '${field.key}', expecting '${field.type}'`,
+        `${FILE}::INVALID_TYPE_${field.key.toUpperCase()}`,
+        500,
+        { field, value: params[field.key] }
+      );
+    }
+
+    if (typeof params[field.key] !== 'undefined') {
+      validated[field.key] = params[field.key];
+    }
+  });
+
+  return validated;
+};