quival 0.2.8 → 0.3.0

package/src/Validator.js

@@ -239,77 +239,83 @@ export default class Validator {
     this.#checkers.clearCaches();
     this.#errors = new ErrorBag();
 
+    const tasks = [];
+
     for (const [attribute, rules] of Object.entries(this.#rules)) {
       let value = this.getValue(attribute);
 
-      if (rules.hasOwnProperty('sometimes') && typeof value === 'undefined') {
+      if (Object.hasOwn(rules, 'sometimes') && typeof value === 'undefined') {
         continue;
       }
 
-      const doBail = this.#alwaysBail || rules.hasOwnProperty('bail');
-      const isNullable = rules.hasOwnProperty('nullable');
-      let hasError = false;
+      tasks.push(async () => {
+        const doBail = this.#alwaysBail || Object.hasOwn(rules, 'bail');
+        const isNullable = Object.hasOwn(rules, 'nullable');
+        let noError = true;
 
-      for (const [rule, parameters] of Object.entries(rules)) {
-        if (rule === '') {
-          continue;
-        }
+        for (const [rule, parameters] of Object.entries(rules)) {
+          if (rule === '') {
+            continue;
+          }
 
-        if (
-          !Validator.#implicitRules.includes(rule) &&
-          (typeof value === 'undefined' || (typeof value === 'string' && value.trim() === '') || (isNullable && value === null))
-        ) {
-          continue;
-        }
+          if (
+            !Validator.#implicitRules.includes(rule) &&
+            (typeof value === 'undefined' || (typeof value === 'string' && value.trim() === '') || (isNullable && value === null))
+          ) {
+            continue;
+          }
 
-        let result, status, message;
-        const camelRule = toCamelCase('check_' + rule);
+          let result, success, message;
+          const camelRule = toCamelCase('check_' + rule);
 
-        if (typeof this.#checkers[camelRule] === 'function') {
-          result = await this.#checkers[camelRule](attribute, value, parameters);
-        } else if (Validator.#dummyRules.includes(rule)) {
-          result = true;
-        } else {
-          throw new Error(`Invalid validation rule: ${rule}`);
-        }
+          if (typeof this.#checkers[camelRule] === 'function') {
+            result = await this.#checkers[camelRule](attribute, value, parameters);
+          } else if (Validator.#dummyRules.includes(rule)) {
+            result = true;
+          } else {
+            throw new Error(`Invalid validation rule: ${rule}`);
+          }
 
-        if (typeof result === 'boolean') {
-          status = result;
-        } else {
-          ({ status, message } = result);
-        }
+          if (typeof result === 'boolean') {
+            success = result;
+          } else {
+            ({ success, message } = result);
+          }
 
-        if (!status) {
-          hasError = true;
-          message = isEmpty(message) ? this.getMessage(attribute, rule) : message;
-          message = this.makeReplacements(message, attribute, rule, parameters);
+          if (!success) {
+            noError = false;
+            message = isEmpty(message) ? this.getMessage(attribute, rule) : message;
+            message = this.makeReplacements(message, attribute, rule, parameters);
 
-          this.#errors.add(attribute, message);
+            this.#errors.add(attribute, message);
 
-          if (doBail || Validator.#implicitRules.includes(rule)) {
-            break;
+            if (doBail || Validator.#implicitRules.includes(rule)) {
+              break;
+            }
           }
         }
-      }
 
-      if (this.#stopOnFirstFailure && hasError) {
-        break;
-      }
+        return noError;
+      });
     }
 
-    if (this.#errors.isNotEmpty()) {
-      throw this.#errors;
+    if (this.#stopOnFirstFailure) {
+      for (const task of tasks) {
+        if (!(await task())) break;
+      }
+    } else {
+      await Promise.allSettled(tasks.map((task) => task()));
+
+      this.#errors.sortByKeys(Object.keys(this.#rules));
     }
+
+    return this.#errors;
   }
 
   async passes() {
-    try {
-      await this.validate();
-    } catch (error) {
-      if (error instanceof Error) {
-        throw error;
-      }
+    await this.validate();
 
+    if (this.#errors.isNotEmpty()) {
       return false;
     }
 
@@ -327,7 +333,7 @@ export default class Validator {
     let message;
 
     for (const key of [`${attribute}.${rule}`, rule]) {
-      if (this.#customMessages.hasOwnProperty(key)) {
+      if (Object.hasOwn(this.#customMessages, key)) {
         message = this.#customMessages[key];
 
         break;
@@ -342,7 +348,7 @@ export default class Validator {
           key += '.array';
         } else if (value instanceof File || this.hasRule(attribute, this.fileRules)) {
           key += '.file';
-        } else if (typeof value === 'number' || this.hasRule(attribute, this.numericRules)) {
+        } else if (isNumeric(value) || this.hasRule(attribute, this.numericRules)) {
           key += '.numeric';
         } else {
           key += '.string';
@@ -390,14 +396,14 @@ export default class Validator {
     const unparsed = this.getPrimaryAttribute(attribute);
 
     for (const name of [attribute, unparsed]) {
-      if (this.#customAttributes.hasOwnProperty(name)) {
+      if (Object.hasOwn(this.#customAttributes, name)) {
         return this.#customAttributes[name];
       } else if (Lang.has(`attributes.${name}`)) {
         return Lang.get(`attributes.${name}`);
       }
     }
 
-    if (this.#implicitAttributes.hasOwnProperty(attribute)) {
+    if (Object.hasOwn(this.#implicitAttributes, attribute)) {
       return attribute;
     }
 
@@ -413,7 +419,7 @@ export default class Validator {
       return 'empty';
     } else if (typeof value === 'boolean' || this.hasRule(attribute, 'boolean')) {
       return Number(value) ? 'true' : 'false';
-    } else if (this.#customValues.hasOwnProperty(path)) {
+    } else if (Object.hasOwn(this.#customValues, path)) {
       return this.#customValues[path];
     } else if (Lang.has(`values.${path}`)) {
       return Lang.get(`values.${path}`);
@@ -431,7 +437,7 @@ export default class Validator {
       return value.size / 1024;
     } else if (isPlainObject(value)) {
       return Object.keys(value).length;
-    } else if (value.hasOwnProperty('length')) {
+    } else if (Object.hasOwn(value, 'length')) {
       return value.length;
     }
 
@@ -448,7 +454,7 @@ export default class Validator {
     attribute = this.getPrimaryAttribute(attribute);
     rules = typeof rules === 'string' ? [rules] : rules;
 
-    if (!this.#rules.hasOwnProperty(attribute)) {
+    if (!Object.hasOwn(this.#rules, attribute)) {
       return false;
     }
 
@@ -462,7 +468,7 @@ export default class Validator {
   }
 
   getPrimaryAttribute(attribute) {
-    return this.#implicitAttributes.hasOwnProperty(attribute) ? this.#implicitAttributes[attribute] : attribute;
+    return Object.hasOwn(this.#implicitAttributes, attribute) ? this.#implicitAttributes[attribute] : attribute;
   }
 
   hasAttribute(attribute) {

package/src/helpers.js

@@ -19,7 +19,7 @@ export function getByPath(obj, path, defaultValue) {
   let current = obj;
 
   for (const key of keys) {
-    if (!current.hasOwnProperty(key)) {
+    if (!Object.hasOwn(current, key)) {
       return defaultValue;
     }
 
@@ -34,7 +34,7 @@ export function setByPath(obj, path, value) {
   let current = obj;
 
   for (const key of keys.slice(0, -1)) {
-    if (!current.hasOwnProperty(key)) {
+    if (!Object.hasOwn(current, key)) {
       current[key] = {};
     }
 
@@ -173,7 +173,7 @@ export function parseDateByFormat(value, format) {
   let index = 1;
 
   for (const char of format) {
-    if (formats.hasOwnProperty(char)) {
+    if (Object.hasOwn(formats, char)) {
       pattern += formats[char];
 
       if (['Y', 'y'].indexOf(char) !== -1) {

package/test/functionalities.js

@@ -0,0 +1,85 @@
+import { strict as assert } from 'assert';
+import Validator from '../src/Validator.js';
+
+describe('Functionalities', () => {
+  it('Create a new instance', () => {
+    const validator = new Validator({ field: 'abc' }, { field: 'string' });
+    assert(validator instanceof Validator);
+  });
+
+  it('Validate data', async () => {
+    const validator = new Validator(
+      {
+        val1: '@bc',
+        val2: 123,
+      },
+      {
+        val1: 'string|alpha|min:5',
+        val2: 'string|alpha',
+      },
+    );
+
+    assert.deepEqual((await validator.validate()).messages(), {
+      val1: ['validation.alpha', 'validation.min'],
+      val2: ['validation.string', 'validation.alpha'],
+    });
+  });
+
+  it('Stop on first failure', async () => {
+    const validator = new Validator(
+      {
+        val1: '@bc',
+        val2: 123,
+      },
+      {
+        val1: 'string|alpha|min:5',
+        val2: 'string|alpha',
+      },
+    );
+
+    validator.stopOnFirstFailure();
+
+    assert.deepEqual((await validator.validate()).messages(), {
+      val1: ['validation.alpha', 'validation.min'],
+    });
+  });
+
+  it('Always bail', async () => {
+    const validator = new Validator(
+      {
+        val1: '@bc',
+        val2: 123,
+      },
+      {
+        val1: 'string|alpha|min:5',
+        val2: 'string|alpha',
+      },
+    );
+
+    validator.alwaysBail();
+
+    assert.deepEqual((await validator.validate()).messages(), {
+      val1: ['validation.alpha'],
+      val2: ['validation.string'],
+    });
+  });
+
+  it('Stop on first failure and always bail', async () => {
+    const validator = new Validator(
+      {
+        val1: '@bc',
+        val2: 123,
+      },
+      {
+        val1: 'string|alpha|min:5',
+        val2: 'string|alpha',
+      },
+    );
+
+    validator.stopOnFirstFailure().alwaysBail();
+
+    assert.deepEqual((await validator.validate()).messages(), {
+      val1: ['validation.alpha'],
+    });
+  });
+});

package/test/helpers.js

@@ -0,0 +1,174 @@
+import { strict as assert } from 'assert';
+import {
+  escapeRegExp,
+  flattenObject,
+  getByPath,
+  isDigits,
+  isEmpty,
+  isNumeric,
+  isPlainObject,
+  isValidDate,
+  parseCsvString,
+  parseDate,
+  parseDateByFormat,
+  setByPath,
+  toCamelCase,
+  toSnakeCase,
+} from '../src/helpers.js';
+
+describe('Helpers', () => {
+  it('toCamelCase', () => {
+    assert.equal(toCamelCase('a_test_name'), 'aTestName');
+    assert.equal(toCamelCase('_test_name'), 'testName');
+    assert.equal(toCamelCase('a-test-name'), 'aTestName');
+    assert.equal(toCamelCase('-test-name'), 'testName');
+    assert.equal(toCamelCase('a test name'), 'aTestName');
+    assert.equal(toCamelCase(' test name'), 'testName');
+  });
+
+  it('toSnakeCase', () => {
+    assert.equal(toSnakeCase('aTestName'), 'a_test_name');
+    assert.equal(toSnakeCase('a_testName'), 'a_test_name');
+    assert.equal(toSnakeCase('ATESTNAME'), 'a_t_e_s_t_n_a_m_e');
+  });
+
+  it('escapeRegExp', () => {
+    assert.equal(escapeRegExp('.*+?^${}()|[]\\'), '\\.\\*\\+\\?\\^\\$\\{\\}\\(\\)\\|\\[\\]\\\\');
+  });
+
+  it('getByPath', () => {
+    assert.equal(getByPath({ a: { b: 1 } }, 'a.b'), 1);
+    assert.equal(getByPath({ a: [1, { c: 2 }] }, 'a.1.c'), 2);
+  });
+
+  it('setByPath', () => {
+    let obj = { a: { b: 1 } };
+    setByPath(obj, 'a.b', 3);
+
+    assert.deepEqual(obj, { a: { b: 3 } });
+
+    obj = { a: [1, { c: 2 }] };
+    setByPath(obj, 'a.1.c', 5);
+
+    assert.deepEqual(obj, { a: [1, { c: 5 }] });
+  });
+
+  it('flattenObject', () => {
+    assert.deepEqual(flattenObject({ a: 1, b: { x: 41, y: 42 } }), { a: 1, 'b.x': 41, 'b.y': 42 });
+    assert.deepEqual(flattenObject({ a: 1, b: [71, 73, 75] }), { a: 1, 'b.0': 71, 'b.1': 73, 'b.2': 75 });
+  });
+
+  it('parseCsvString', () => {
+    assert.deepEqual(parseCsvString('a,b,c'), ['a', 'b', 'c']);
+    assert.deepEqual(parseCsvString('a, b, c'), ['a', ' b', ' c']);
+    assert.deepEqual(parseCsvString('"a","b","c"'), ['a', 'b', 'c']);
+    assert.deepEqual(parseCsvString('"a", "b", "c"'), ['a', 'b', 'c']);
+    assert.deepEqual(parseCsvString('"a", "b", ""'), ['a', 'b', '']);
+
+    assert.deepEqual(parseCsvString('"r2""c1","r2c2","r2c3"'), ['r2"c1', 'r2c2', 'r2c3']);
+    assert.deepEqual(parseCsvString('"r2""c1",r2c2,r2c3'), ['r2"c1', 'r2c2', 'r2c3']);
+    assert.deepEqual(parseCsvString('r1c1,"r1,c2",r1c3'), ['r1c1', 'r1,c2', 'r1c3']);
+    assert.deepEqual(parseCsvString('"r2""c1",r2c2,"r2""""c3"'), ['r2"c1', 'r2c2', 'r2""c3']);
+    assert.deepEqual(parseCsvString('r1c1,"r1,c2","r1"",""c3"'), ['r1c1', 'r1,c2', 'r1","c3']);
+  });
+
+  it('parseDate', () => {
+    const date1 = new Date('2023/08/11 00:00:00');
+    const date2 = new Date('2023/08/11 08:40:50 am');
+    const date3 = new Date();
+    date3.setHours(8);
+    date3.setMinutes(40);
+    date3.setSeconds(50);
+    date3.setMilliseconds(0);
+
+    assert.deepEqual(parseDate('11-08-2023'), date1);
+    assert.deepEqual(parseDate('11-08-2023 08:40:50'), date2);
+    assert.deepEqual(parseDate('11-08-2023 08:40:50 am'), date2);
+    assert.deepEqual(parseDate('11/08/2023'), date1);
+    assert.deepEqual(parseDate('11/08/2023 08:40:50'), date2);
+    assert.deepEqual(parseDate('11/08/2023 08:40:50 am'), date2);
+    assert.deepEqual(parseDate('11.08.2023'), date1);
+    assert.deepEqual(parseDate('11.08.2023 08:40:50'), date2);
+    assert.deepEqual(parseDate('11.08.2023 08:40:50 am'), date2);
+
+    assert.deepEqual(parseDate('2023-08-11'), date1);
+    assert.deepEqual(parseDate('2023-08-11 08:40:50'), date2);
+    assert.deepEqual(parseDate('2023-08-11 08:40:50 am'), date2);
+    assert.deepEqual(parseDate('2023/08/11'), date1);
+    assert.deepEqual(parseDate('2023/08/11 08:40:50'), date2);
+    assert.deepEqual(parseDate('2023/08/11 08:40:50 am'), date2);
+    assert.deepEqual(parseDate('2023.08.11'), date1);
+    assert.deepEqual(parseDate('2023.08.11 08:40:50'), date2);
+    assert.deepEqual(parseDate('2023.08.11 08:40:50 am'), date2);
+
+    assert.deepEqual(parseDate('08:40:50 2023-08-11'), date2);
+    assert.deepEqual(parseDate('08:40:50 am 2023-08-11'), date2);
+    assert.deepEqual(parseDate('08:40:50 2023/08/11'), date2);
+    assert.deepEqual(parseDate('08:40:50 am 2023/08/11'), date2);
+    assert.deepEqual(parseDate('08:40:50 2023.08.11'), date2);
+    assert.deepEqual(parseDate('08:40:50 am 2023.08.11'), date2);
+
+    assert.deepEqual(parseDate('08:40:50'), date3);
+    assert.deepEqual(parseDate('08:40:50 am'), date3);
+    assert.deepEqual(parseDate('08:40:50'), date3);
+    assert.deepEqual(parseDate('08:40:50 am'), date3);
+    assert.deepEqual(parseDate('08:40:50'), date3);
+    assert.deepEqual(parseDate('08:40:50 am'), date3);
+  });
+
+  it('parseDateByFormat', () => {
+    const date1 = new Date('2023/08/11 00:00:00');
+    const date2 = new Date('2023/08/11 08:40:50 am');
+    const date3 = new Date();
+    date3.setHours(8);
+    date3.setMinutes(40);
+    date3.setSeconds(50);
+    date3.setMilliseconds(0);
+
+    assert.deepEqual(parseDateByFormat('08-11-2023', 'm-d-Y'), date1);
+    assert.deepEqual(parseDateByFormat('08-11-23', 'm-d-y'), date1);
+    assert.deepEqual(parseDateByFormat('08-11-2023 08:40:50', 'm-d-Y H:i:s'), date2);
+    assert.deepEqual(parseDateByFormat('08-11-23 08:40:50', 'm-d-y H:i:s'), date2);
+    assert.deepEqual(parseDateByFormat('08-11-2023 08:40:50 am', 'm-d-Y H:i:s a'), date2);
+    assert.deepEqual(parseDateByFormat('08-11-23 08:40:50 am', 'm-d-y H:i:s a'), date2);
+  });
+
+  it('isDigits', () => {
+    assert(isDigits(123));
+    assert(isDigits('123'));
+    assert(!isDigits('abc'));
+    assert(!isDigits('abc123'));
+  });
+
+  it('isEmpty', () => {
+    assert(isEmpty(''));
+    assert(isEmpty(null));
+    assert(isEmpty(undefined));
+    assert(!isEmpty(123));
+    assert(!isEmpty('abc'));
+    assert(!isEmpty({}));
+    assert(!isEmpty([]));
+  });
+
+  it('isNumeric', () => {
+    assert(isNumeric(123));
+    assert(isNumeric('123'));
+    assert(!isNumeric('abc'));
+    assert(!isNumeric(true));
+  });
+
+  it('isPlainObject', () => {
+    assert(isPlainObject({}));
+    assert(!isPlainObject([]));
+    assert(!isPlainObject(new Date()));
+  });
+
+  it('isValidDate', () => {
+    assert(isValidDate(new Date()));
+    assert(isValidDate(new Date('2023/08/11 00:00:00')));
+    assert(isValidDate(new Date('2023/08/11 08:40:50 am')));
+    assert(isValidDate(new Date('08:40:50 am 2023/08/11')));
+    assert(!isValidDate(new Date('')));
+    assert(!isValidDate(new Date('08:40:50 am')));
+  });
+});