lesgo 0.7.7 → 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/validateFields.js

@@ -4,30 +4,44 @@ import isDecimal from './isDecimal';
 
 const FILE = 'Utils/validateFields';
 
-export default (params, validFields) => {
+const isValidJSON = json => {
+  if (typeof json !== 'string') {
+    return false;
+  }
+
+  // Cannot find a regex solution to this
+  try {
+    JSON.parse(json);
+
+    return true;
+  } catch (_) {
+    return false;
+  }
+};
+
+const validateFields = (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
-        ) {
+    const { required, type, key, isCollection, enumValues = [] } = field;
+
+    if (required) {
+      if (typeof params[key] === 'object') {
+        if (Array.isArray(params[key]) && params[key].length === 0) {
           throw new LesgoException(
-            `Missing required '${field.key}'`,
-            `${FILE}::MISSING_REQUIRED_${field.key.toUpperCase()}`,
+            `Missing required '${key}'`,
+            `${FILE}::MISSING_REQUIRED_${key.toUpperCase()}`,
             500,
             { field }
           );
         }
       }
 
-      if (!params[field.key]) {
-        if (typeof params[field.key] !== 'number') {
+      if (!params[key]) {
+        if (typeof params[key] !== 'number') {
           throw new LesgoException(
-            `Missing required '${field.key}'`,
-            `${FILE}::MISSING_REQUIRED_${field.key.toUpperCase()}`,
+            `Missing required '${key}'`,
+            `${FILE}::MISSING_REQUIRED_${key.toUpperCase()}`,
             500,
             { field }
           );
@@ -35,41 +49,68 @@ export default (params, validFields) => {
       }
     }
 
-    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 (isCollection) {
+      try {
+        validateFields({ [key]: params[key] }, [
+          { key, required, type: 'array' },
+        ]);
+      } catch (_) {
+        throw new LesgoException(
+          `Invalid type for '${key}', expecting collection of '${type}'`,
+          `${FILE}::INVALID_TYPE_${key.toUpperCase()}`,
+          500,
+          { field, value: params[key] }
+        );
+      }
     }
 
-    if (typeof params[field.key] !== 'undefined') {
-      validated[field.key] = params[field.key];
+    (isCollection ? params[key] || [] : [params[key]]).forEach(paramsItem => {
+      if (
+        (type === 'string' &&
+          typeof paramsItem !== 'undefined' &&
+          typeof paramsItem !== 'string') ||
+        (type === 'object' &&
+          typeof paramsItem !== 'undefined' &&
+          typeof paramsItem !== 'object') ||
+        (type === 'number' &&
+          typeof paramsItem !== 'undefined' &&
+          typeof paramsItem !== 'number') ||
+        (type === 'decimal' &&
+          typeof paramsItem !== 'undefined' &&
+          !isDecimal(paramsItem)) ||
+        (type === 'email' &&
+          typeof paramsItem !== 'undefined' &&
+          !isEmail(paramsItem)) ||
+        (type === 'array' &&
+          typeof paramsItem !== 'undefined' &&
+          !Array.isArray(paramsItem)) ||
+        (type === 'enum' &&
+          typeof paramsItem !== 'undefined' &&
+          !enumValues.includes(paramsItem)) ||
+        (type === 'function' &&
+          typeof paramsItem !== 'undefined' &&
+          {}.toString.call(paramsItem) !== '[object Function]') ||
+        (type === 'json' &&
+          typeof paramsItem !== 'undefined' &&
+          !isValidJSON(paramsItem))
+      ) {
+        throw new LesgoException(
+          `Invalid type for '${key}', expecting ${
+            isCollection ? 'collection of ' : ''
+          }'${type}'`,
+          `${FILE}::INVALID_TYPE_${key.toUpperCase()}`,
+          500,
+          { field, value: paramsItem }
+        );
+      }
+    });
+
+    if (typeof params[key] !== 'undefined') {
+      validated[key] = params[key];
     }
   });
 
   return validated;
 };
+
+export default validateFields;