quival 0.2.7 → 0.3.0

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')));
+  });
+});

package/test/{test.js → validation.js}

@@ -1,20 +1,4 @@
 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';
 import Validator from '../src/Validator.js';
 
 globalThis.File = class {
@@ -29,163 +13,6 @@ globalThis.File = class {
   }
 };
 
-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')));
-  });
-});
-
 describe('Validation', () => {
   describe(`Empty rule`, () => {
     it(`Passes when the rule is empty`, async () => {
@@ -445,6 +272,16 @@ describe('Validation', () => {
     });
   });
 
+  describe(`Rule 'bail'`, () => {
+    it(`Passes when the field is null`, async () => {
+      const validator = new Validator({ field: '@bc' }, { field: 'bail|string|alpha|min:5' });
+
+      assert.deepEqual((await validator.validate()).messages(), {
+        field: ['validation.alpha'],
+      });
+    });
+  });
+
   describe(`Rule 'before'`, () => {
     const date = '2022-01-01';
     const rules1 = { field: `before:${date}` };
@@ -1259,56 +1096,65 @@ describe('Validation', () => {
 
   describe(`Rule 'hex_color'`, () => {
     it(`Passes when the field is a valid color`, async () => {
-      const validator = new Validator({
-        field_1: '#abc',
-        field_2: '#abcd',
-        field_3: '#abcabc',
-        field_4: '#abcdabcd',
-      }, {
-        field_1: 'hex_color',
-        field_2: 'hex_color',
-        field_3: 'hex_color',
-        field_4: 'hex_color',
-      });
+      const validator = new Validator(
+        {
+          field_1: '#abc',
+          field_2: '#abcd',
+          field_3: '#abcabc',
+          field_4: '#abcdabcd',
+        },
+        {
+          field_1: 'hex_color',
+          field_2: 'hex_color',
+          field_3: 'hex_color',
+          field_4: 'hex_color',
+        },
+      );
 
       assert(await validator.passes());
     });
 
     it(`Fails when the field is not a valid color`, async () => {
-      const validator = new Validator({
-        field_1: '#ghi',
-        field_2: '#ghij',
-        field_3: '#ghighi',
-        field_4: '#ghijghij',
-        field_5: 'abc',
-        field_6: 123,
-        field_7: [1, 2, 3],
-      }, {
-        field_1: 'hex_color',
-        field_2: 'hex_color',
-        field_3: 'hex_color',
-        field_4: 'hex_color',
-        field_5: 'hex_color',
-        field_6: 'hex_color',
-        field_7: 'hex_color',
-      });
+      const validator = new Validator(
+        {
+          field_1: '#ghi',
+          field_2: '#ghij',
+          field_3: '#ghighi',
+          field_4: '#ghijghij',
+          field_5: 'abc',
+          field_6: 123,
+          field_7: [1, 2, 3],
+        },
+        {
+          field_1: 'hex_color',
+          field_2: 'hex_color',
+          field_3: 'hex_color',
+          field_4: 'hex_color',
+          field_5: 'hex_color',
+          field_6: 'hex_color',
+          field_7: 'hex_color',
+        },
+      );
 
       assert(await validator.fails());
     });
 
     it(`Fails when the color's value is not 3, 4, 6 or 8 digits.`, async () => {
-      const validator = new Validator({
-        field_1: '#1',
-        field_2: '#12',
-        field_3: '#12345',
-        field_4: '#1234567',
-        field_4: '#123456789',
-      }, {
-        field_1: 'hex_color',
-        field_2: 'hex_color',
-        field_3: 'hex_color',
-        field_4: 'hex_color',
-      });
+      const validator = new Validator(
+        {
+          field_1: '#1',
+          field_2: '#12',
+          field_3: '#12345',
+          field_4: '#1234567',
+          field_4: '#123456789',
+        },
+        {
+          field_1: 'hex_color',
+          field_2: 'hex_color',
+          field_3: 'hex_color',
+          field_4: 'hex_color',
+        },
+      );
 
       assert(await validator.fails());
     });
@@ -1487,6 +1333,26 @@ describe('Validation', () => {
     });
   });
 
+  describe(`Rule 'list'`, () => {
+    const rules = { field: 'list' };
+
+    it(`Passes when the field is a list`, async () => {
+      const validator = new Validator({ field: [1, 2, 3] }, rules);
+      assert(await validator.passes());
+    });
+
+    it(`Fails when the field is not a list`, async () => {
+      const validator = new Validator({ field: { a: 1, b: 2, c: 3 } }, rules);
+      assert(await validator.fails());
+
+      validator.setData({ field: 123 });
+      assert(await validator.fails());
+
+      validator.setData({ field: 'abc' });
+      assert(await validator.fails());
+    });
+  });
+
   describe(`Rule 'lowercase'`, () => {
     const rules = { field: 'lowercase' };