lesgo 1.0.0 → 2.1.1

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

@@ -1,54 +0,0 @@
-import aws from 'Config/aws'; // eslint-disable-line import/no-unresolved
-import queue, { dispatch } from '../queue';
-import LesgoException from '../../exceptions/LesgoException';
-
-describe('UtilsGroup: test queue utils', () => {
-  it('test queue.dispatch', () => {
-    return expect(
-      // eslint-disable-next-line import/no-named-as-default-member
-      queue.dispatch({ someData: 'someValue' }, 'pingQueue')
-    ).resolves.toMatchObject({
-      MessageId: 'MessageId',
-      mocked: {
-        opts: {},
-        params: {
-          MessageBody: '{"someData":"someValue"}',
-          QueueUrl: `${aws.sqs.queues.pingQueue.url}`,
-        },
-      },
-    });
-  });
-
-  it('test queue dispatch', () => {
-    return expect(
-      dispatch({ someData: 'someValue' }, 'pingQueue')
-    ).resolves.toMatchObject({
-      MessageId: 'MessageId',
-      mocked: {
-        opts: {},
-        params: {
-          MessageBody: '{"someData":"someValue"}',
-          QueueUrl: `${aws.sqs.queues.pingQueue.url}`,
-        },
-      },
-    });
-  });
-
-  it('test queue dispatch with empty payload', () => {
-    return expect(() => dispatch()).toThrow(
-      new LesgoException(
-        'payload is undefined in dispatch()',
-        'SQSSERVICE_DISPATCH_PAYLOAD_UNDEFINED'
-      )
-    );
-  });
-
-  it('test queue dispatch with empty queueName', () => {
-    return expect(() => dispatch({ someData: 'someValue' })).toThrow(
-      new LesgoException(
-        'queueName is undefined in dispatch()',
-        'SQSSERVICE_DISPATCH_QUEUENAME_UNDEFINED'
-      )
-    );
-  });
-});

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

@@ -1,374 +0,0 @@
-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,
-  functionCheck: () => {},
-  jsonCheck: JSON.stringify({
-    test: 'json value',
-    testArray: ['withvalues', 'here'],
-    testNum: 1,
-  }),
-  statusCollection: ['active', 'inactive', 'active'],
-};
-
-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 },
-  {
-    key: 'functionCheck',
-    type: 'function',
-    required: true,
-  },
-  {
-    key: 'jsonCheck',
-    type: 'json',
-    required: true,
-  },
-  {
-    key: 'statusCollection',
-    type: 'enum',
-    enumValues: ['active', 'inactive'],
-    required: true,
-    isCollection: 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;
-
-    try {
-      const validated = validateFields(newParams, validFields);
-
-      expect(validated).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual("Missing required 'email'");
-      expect(e.code).toEqual(`${FILE}::MISSING_REQUIRED_EMAIL`);
-      expect(e.extra).toStrictEqual({
-        field: validFields[2],
-      });
-    }
-  });
-
-  it('should throw invalid type when non-string value check', () => {
-    const newParams = { ...params, name: 123 };
-
-    try {
-      const validated = validateFields(newParams, validFields);
-
-      expect(validated).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual(`Invalid type for 'name', expecting 'string'`);
-      expect(e.code).toEqual(`${FILE}::INVALID_TYPE_NAME`);
-      expect(e.extra).toStrictEqual({
-        field: validFields[1],
-        value: 123,
-      });
-    }
-  });
-
-  it('should throw invalid type when non-object value check', () => {
-    const newParams = { ...params, roles: 1597929335 };
-
-    try {
-      const validated = validateFields(newParams, validFields);
-
-      expect(validated).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual(`Invalid type for 'roles', expecting 'object'`);
-      expect(e.code).toEqual(`${FILE}::INVALID_TYPE_ROLES`);
-      expect(e.extra).toStrictEqual({
-        field: validFields[3],
-        value: 1597929335,
-      });
-    }
-  });
-
-  it('should throw invalid type when non-number value check', () => {
-    const newParams = { ...params, Id: '123' };
-
-    try {
-      const validated = validateFields(newParams, validFields);
-
-      expect(validated).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual(`Invalid type for 'Id', expecting 'number'`);
-      expect(e.code).toEqual(`${FILE}::INVALID_TYPE_ID`);
-      expect(e.extra).toStrictEqual({
-        field: validFields[0],
-        value: '123',
-      });
-    }
-  });
-
-  it('should throw invalid type when non-array value check', () => {
-    const newParams = { ...params, listItem: { created_at: 1597929335 } };
-
-    try {
-      const validated = validateFields(newParams, validFields);
-
-      expect(validated).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual(
-        `Invalid type for 'listItem', expecting 'array'`
-      );
-      expect(e.code).toEqual(`${FILE}::INVALID_TYPE_LISTITEM`);
-      expect(e.extra).toStrictEqual({
-        field: validFields[4],
-        value: { created_at: 1597929335 },
-      });
-    }
-  });
-
-  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'`,
-        `Invalid type for 'status', expecting 'enum'`
-      )
-    );
-
-    try {
-      const validated = validateFields(newParams, validFields);
-
-      expect(validated).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual(`Invalid type for 'status', expecting 'enum'`);
-      expect(e.code).toEqual(`${FILE}::INVALID_TYPE_STATUS`);
-      expect(e.extra).toStrictEqual({
-        field: validFields[5],
-        value: 'private',
-      });
-    }
-  });
-
-  it('should throw invalid type when non-function value check', async () => {
-    const newParams = {
-      ...params,
-      functionCheck: { not: 'function' },
-    };
-
-    try {
-      const validated = validateFields(newParams, validFields);
-
-      expect(validated).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual(
-        `Invalid type for 'functionCheck', expecting 'function'`
-      );
-      expect(e.code).toEqual(`${FILE}::INVALID_TYPE_FUNCTIONCHECK`);
-      expect(e.extra).toStrictEqual({
-        field: validFields[8],
-        value: { not: 'function' },
-      });
-    }
-  });
-
-  it.each`
-    value
-    ${'not a json'}
-    ${3}
-    ${'"invalid'}
-    ${{ not: 'json' }}
-    ${'{"missing":"bracket"}}'}
-  `(
-    'should throw invalid type when non-json $value check',
-    async ({ value }) => {
-      const newParams = {
-        ...params,
-        jsonCheck: value,
-      };
-
-      try {
-        const validated = validateFields(newParams, validFields);
-
-        expect(validated).toThrow();
-      } catch (e) {
-        expect(e.name).toEqual('LesgoException');
-        expect(e.message).toEqual(
-          `Invalid type for 'jsonCheck', expecting 'json'`
-        );
-        expect(e.code).toEqual(`${FILE}::INVALID_TYPE_JSONCHECK`);
-        expect(e.extra).toStrictEqual({
-          field: validFields[9],
-          value,
-        });
-      }
-    }
-  );
-
-  it('should throw invalid type when non-collection value check', async () => {
-    const newParams = {
-      ...params,
-      statusCollection: 'active',
-    };
-
-    try {
-      const validated = validateFields(newParams, validFields);
-
-      expect(validated).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual(
-        `Invalid type for 'statusCollection', expecting collection of 'enum'`
-      );
-      expect(e.code).toEqual(`${FILE}::INVALID_TYPE_STATUSCOLLECTION`);
-      expect(e.extra).toStrictEqual({
-        field: validFields[10],
-        value: 'active',
-      });
-    }
-  });
-
-  it('should ignore type when collection value check is non-required', async () => {
-    const newParams = { ...params };
-    const newValidFields = [...validFields];
-    delete newParams.statusCollection;
-    newValidFields[10].required = false;
-
-    const validated = validateFields(newParams, newValidFields);
-
-    expect(validated).toStrictEqual(newParams);
-  });
-
-  it('should throw invalid type when non-enum collection value check', async () => {
-    const newParams = {
-      ...params,
-      statusCollection: ['archive'],
-    };
-
-    try {
-      const validated = validateFields(newParams, validFields);
-
-      expect(validated).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual(
-        `Invalid type for 'statusCollection', expecting collection of 'enum'`
-      );
-      expect(e.code).toEqual(`${FILE}::INVALID_TYPE_STATUSCOLLECTION`);
-      expect(e.extra).toStrictEqual({
-        field: validFields[10],
-        value: 'archive',
-      });
-    }
-  });
-
-  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/cache.js

@@ -1,215 +0,0 @@
-import config from 'Config/cache'; // eslint-disable-line import/no-unresolved
-import ElastiCacheService from '../services/ElastiCacheService';
-import LesgoException from '../exceptions/LesgoException';
-import logger from './logger';
-import isEmpty from './isEmpty';
-
-const FILE = 'Lesgo/utils/cache';
-
-/**
- * Reusable instance
- */
-const singleton = {};
-
-/**
- * Instantiate the Cache Service
- *
- * @param {String} connectionName The name of the driver config to connect to
- * @param {boolean} persists To use persistent connection or otherwise
- *
- * @return {object} Returns the driver
- */
-const ec = (connectionName = '', persists = false) => {
-  const conn = connectionName || config.default;
-  if (singleton[conn]) {
-    return singleton[conn];
-  }
-
-  let { options } = config.connections[conn];
-
-  if (config.connections[conn].url) {
-    // this is a legacy config with memcached-elasticache package
-    // remap to new config
-    options = {
-      ...options,
-      hosts: [config.connections[conn].url],
-    };
-  }
-
-  const { driver } = new ElastiCacheService(options);
-
-  if (persists) {
-    singleton[conn] = driver;
-  }
-
-  return driver;
-};
-
-/**
- * Persistent connection if declared in the handler
- */
-const pConnect = (connectionName = '') => {
-  return ec(connectionName, true);
-};
-
-/**
- * Fetch data from cache by key
- *
- * @param {string} key Cache key to fetch data.
- * @return {promise} Returns promised.
- */
-const get = async key => {
-  try {
-    const client = ec();
-    const data = await client.get(key);
-    logger.debug(`${FILE}::Fetched cache data`, { key, data });
-    if (isEmpty(singleton)) {
-      logger.debug(`${FILE}::Ending cache connection`);
-      await client.disconnect();
-      logger.debug(`${FILE}::Ended cache connection`);
-    }
-    return data;
-  } catch (err) {
-    throw new LesgoException(err.message, 'CACHE_GET_EXCEPTION', 500, err);
-  }
-};
-
-/**
- * Fetch data from cache by multiple keys
- *
- * @param {array} keys Array of Cache keys to fetch data.
- * @return {promise} Returns promised.
- */
-const getMulti = async keys => {
-  try {
-    const client = ec();
-    const data = await client.getMulti(keys);
-    logger.debug(`${FILE}::Fetched cache data`, { keys, data });
-    if (isEmpty(singleton)) {
-      logger.debug(`${FILE}::Ending cache connection`);
-      await client.disconnect();
-      logger.debug(`${FILE}::Ended cache connection`);
-    }
-    return data;
-  } catch (err) {
-    throw new LesgoException(
-      err.message,
-      'CACHE_GET_MULTI_EXCEPTION',
-      500,
-      err
-    );
-  }
-};
-
-/**
- * Save data to cache
- *
- * @param {string} key Cache key to save data.
- * @param {string|object} val Value of data to cache.
- * @param {integer} lifetime Time in seconds to expire cache.
- * @return {promise} Returns promised.
- */
-const set = async (key, val, lifetime) => {
-  try {
-    const client = ec();
-    await client.set(key, val, lifetime);
-    logger.debug(`${FILE}::Cache stored`, { key, val, lifetime });
-    if (isEmpty(singleton)) {
-      logger.debug(`${FILE}::Ending cache connection`);
-      await client.disconnect();
-      logger.debug(`${FILE}::Ended cache connection`);
-    }
-  } catch (err) {
-    throw new LesgoException(err.message, 'CACHE_SET_EXCEPTION', 500, err);
-  }
-};
-
-/**
- * Remove the key from cache
- *
- * @param {string} key Cache key to delete.
- * @return {promise} Returns promised.
- */
-const del = async key => {
-  try {
-    const client = ec();
-    await client.delete(key);
-    logger.debug(`${FILE}::Key deleted from cache`, { key });
-    if (isEmpty(singleton)) {
-      logger.debug(`${FILE}::Ending cache connection`);
-      await client.disconnect();
-      logger.debug(`${FILE}::Ended cache connection`);
-    }
-  } catch (err) {
-    throw new LesgoException(err.message, 'CACHE_DEL_EXCEPTION', 500, err);
-  }
-};
-
-/**
- * Remove data from cache by multiple keys
- *
- * @param {array} keys Array of Cache keys to delete data.
- * @return {promise} Returns promised.
- */
-const delMulti = async keys => {
-  try {
-    const client = ec();
-    await client.deleteMulti(keys);
-    logger.debug(`${FILE}::Keys deleted from cache`, { keys });
-    if (isEmpty(singleton)) {
-      logger.debug(`${FILE}::Ending cache connection`);
-      await client.disconnect();
-      logger.debug(`${FILE}::Ended cache connection`);
-    }
-  } catch (err) {
-    throw new LesgoException(
-      err.message,
-      'CACHE_DEL_MULTI_EXCEPTION',
-      500,
-      err
-    );
-  }
-};
-
-/**
- * Ends the connection
- *
- * @return {promise} Returns promised.
- */
-const end = async () => {
-  try {
-    logger.debug(`${FILE}::Ending cache connection`);
-    await ec().disconnect();
-    logger.debug(`${FILE}::Ended cache connection`);
-
-    if (!isEmpty(Object.keys(singleton))) {
-      Object.keys(singleton).forEach(key => {
-        delete singleton[key];
-      });
-    }
-  } catch (err) {
-    throw new LesgoException(err.message, 'CACHE_END_EXCEPTION', 500, err);
-  }
-};
-
-/**
- * Alias of end()
- *
- * @return {promise} Returns promised.
- */
-const disconnect = () => {
-  return end();
-};
-
-export default {
-  pConnect,
-  ec,
-  get,
-  getMulti,
-  set,
-  del,
-  delMulti,
-  end,
-  disconnect,
-  singleton,
-};

package/src/utils/crypto.js

@@ -1,77 +0,0 @@
-import crypto from 'crypto';
-import cryptoConfig from 'Config/crypto'; // eslint-disable-line import/no-unresolved
-import LesgoException from '../exceptions/LesgoException';
-import isEmpty from './isEmpty';
-
-const { algorithm, secretKey } = cryptoConfig;
-const ivLength = 16;
-
-export const encrypt = text => {
-  if (isEmpty(text)) {
-    throw new LesgoException(
-      'Empty parameter supplied on encrypt',
-      'CRYPTO_ENCRYPT_EMPTY_PARAMETER'
-    );
-  }
-
-  const iv = crypto.randomBytes(ivLength);
-  const cipher = crypto.createCipheriv(algorithm, secretKey, iv);
-
-  let encrypted = cipher.update(text);
-  encrypted = Buffer.concat([encrypted, cipher.final()]);
-
-  return `${iv.toString('hex')}:${encrypted.toString('hex')}`;
-};
-
-export const decrypt = text => {
-  if (isEmpty(text)) {
-    throw new LesgoException(
-      'Empty parameter supplied on decryp',
-      'CRYPTO_DECRYPT_EMPTY_PARAMETER'
-    );
-  }
-
-  const textParts = text.split(':');
-  const iv = Buffer.from(textParts.shift(), 'hex');
-  const encryptedText = Buffer.from(textParts.join(':'), 'hex');
-  const decipher = crypto.createDecipheriv(algorithm, secretKey, iv);
-
-  let decrypted = decipher.update(encryptedText);
-  decrypted = Buffer.concat([decrypted, decipher.final()]);
-
-  return decrypted.toString();
-};
-
-export const hash = data => {
-  if (isEmpty(data)) {
-    throw new LesgoException(
-      'Empty parameter supplied on hash',
-      'CRYPTO_HASH_EMPTY_PARAMETER'
-    );
-  }
-
-  const hashedValue = crypto
-    .createHash('sha256', 'utf8')
-    .update(data)
-    .digest('hex');
-
-  return hashedValue;
-};
-
-export const hashMD5 = data => {
-  if (isEmpty(data)) {
-    throw new LesgoException(
-      'Empty parameter supplied on hashMD5',
-      'CRYPTO_HASHMD5_EMPTY_PARAMETER'
-    );
-  }
-
-  const hashedValue = crypto
-    .createHash('md5')
-    .update(data)
-    .digest('hex');
-
-  return hashedValue;
-};
-
-export default { encrypt, decrypt, hash, hashMD5 };