lesgo 0.7.6 → 0.7.8

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

@@ -12,6 +12,13 @@ const params = {
   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 = [
@@ -26,8 +33,29 @@ 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 },
+  {
+    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', () => {
@@ -39,56 +67,92 @@ describe('test Utils/validateFields', () => {
     const newParams = { ...params };
     delete newParams.email;
 
-    expect(() => validateFields(newParams, validFields)).toThrow(
-      new LesgoException(
-        "Missing required 'email'",
-        `${FILE}::MISSING_REQUIRED_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 };
 
-    expect(() => validateFields(newParams, validFields)).toThrow(
-      new LesgoException(
-        `Invalid type for 'name', expecting 'string'`,
-        `${FILE}::INVALID_TYPE_NAME`
-      )
-    );
+    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 };
 
-    expect(() => validateFields(newParams, validFields)).toThrow(
-      new LesgoException(
-        `Invalid type for 'roles', expecting 'object'`,
-        `${FILE}::INVALID_TYPE_ROLES`
-      )
-    );
+    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' };
 
-    expect(() => validateFields(newParams, validFields)).toThrow(
-      new LesgoException(
-        `Invalid type for 'Id', expecting 'number'`,
-        `${FILE}::INVALID_TYPE_ID`
-      )
-    );
+    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 } };
 
-    expect(() => validateFields(newParams, validFields)).toThrow(
-      new LesgoException(
-        `Invalid type for 'listItem', expecting 'array'`,
-        `${FILE}::INVALID_TYPE_LISTITEM`
-      )
-    );
+    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', () => {
@@ -119,9 +183,136 @@ describe('test Utils/validateFields', () => {
     expect(() => validateFields(newParams, validFields)).toThrow(
       new LesgoException(
         `Invalid type for 'status', expecting 'enum'`,
-        `${FILE}::INVALID_TYPE_STATUS`
+        `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', () => {

package/src/utils/cache.js

@@ -1,54 +1,104 @@
 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 = [];
+const singleton = {};
 
 /**
  * Instantiate the Cache Service
  *
- * @param {object} conn The connection options
+ * @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 = (conn = null) => {
+const ec = (connectionName = '', persists = false) => {
+  const conn = connectionName || config.default;
   if (singleton[conn]) {
     return singleton[conn];
   }
 
-  const { driver } = new ElastiCacheService({
-    ...config.connections[conn || config.default],
-  });
+  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);
 
-  singleton[conn] = driver;
+  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 = key => {
-  return new Promise((res, rej) => {
-    try {
-      ec().get(key, (err, data) => {
-        if (err) {
-          rej(new LesgoException(err, 'CACHE_GET_ERROR'));
-        } else {
-          res(data);
-        }
-
-        ec().end();
-      });
-    } catch (err) {
-      rej(new LesgoException(err.message, 'CACHE_GET_EXCEPTION', 500, err));
+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
+    );
+  }
 };
 
 /**
@@ -59,22 +109,19 @@ const get = key => {
  * @param {integer} lifetime Time in seconds to expire cache.
  * @return {promise} Returns promised.
  */
-const set = (key, val, lifetime) => {
-  return new Promise((res, rej) => {
-    try {
-      ec().set(key, val, lifetime, err => {
-        if (err) {
-          rej(new LesgoException(err, 'CACHE_SET_ERROR'));
-        } else {
-          res(true);
-        }
-
-        ec().end();
-      });
-    } catch (err) {
-      rej(new LesgoException(err.message, 'CACHE_SET_EXCEPTION', 500, err));
+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);
+  }
 };
 
 /**
@@ -83,27 +130,86 @@ const set = (key, val, lifetime) => {
  * @param {string} key Cache key to delete.
  * @return {promise} Returns promised.
  */
-const del = key => {
-  return new Promise((res, rej) => {
-    try {
-      ec().del(key, err => {
-        if (err) {
-          rej(new LesgoException(err, 'CACHE_DEL_ERROR'));
-        } else {
-          res(true);
-        }
-
-        ec().end();
+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) {
-      rej(new LesgoException(err.message, 'CACHE_DEL_EXCEPTION', 500, err));
     }
-  });
+  } 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,
 };