co.validation 2.7.1 → 3.0.0

package/lib/__tests__/integration.valueValidation.js

@@ -1,448 +0,0 @@
-"use strict";
-
-var _ = require("..");
-
-describe('createValueValidation', () => {
-  it('supports required', () => {
-    expect((0, _.createValueValidation)({
-      type: 'required'
-    })('')).toEqual(['Required']);
-    expect((0, _.createValueValidation)({
-      type: 'required',
-      getMessage: () => 'Required Field'
-    })('')).toEqual(['Required Field']);
-    expect((0, _.createValueValidation)({
-      type: 'required',
-      getMessage: () => 'Required'
-    })('a')).toEqual(undefined);
-    expect((0, _.createValueValidation)({
-      type: 'required',
-      getMessage: () => 'Required'
-    })(5)).toEqual(undefined);
-    expect((0, _.createValueValidation)({
-      type: 'required',
-      getMessage: () => 'Required'
-    })(0)).toEqual(undefined);
-  });
-  it('supports equals', () => {
-    expect((0, _.createValueValidation)({
-      type: 'equals',
-      to: '123'
-    })('1234')).toEqual(['Must be equal to 123']);
-    expect((0, _.createValueValidation)({
-      type: 'equals',
-      to: 123
-    })('123')).toEqual(['Must be equal to 123']);
-    expect((0, _.createValueValidation)({
-      type: 'equals',
-      to: true
-    })(1)).toEqual(['Must be equal to true']);
-    expect((0, _.createValueValidation)({
-      type: 'equals',
-      to: '123',
-      getMessage: to => to
-    })('1234')).toEqual(['123']);
-    expect((0, _.createValueValidation)({
-      type: 'equals',
-      to: '123'
-    })('123')).toEqual(undefined);
-    expect((0, _.createValueValidation)({
-      type: 'equals',
-      to: 123
-    })(123)).toEqual(undefined);
-    expect((0, _.createValueValidation)({
-      type: 'equals',
-      to: true
-    })(true)).toEqual(undefined);
-    expect((0, _.createValueValidation)({
-      type: 'equals',
-      to: false
-    })(false)).toEqual(undefined);
-  });
-  it('supports equalsToField', () => {
-    expect((0, _.createValueValidation)({
-      type: 'equalsToField',
-      field: 'otherField'
-    })('1234', {
-      otherField: '123'
-    })).toEqual(['Must be equal to otherField']);
-    expect((0, _.createValueValidation)({
-      type: 'equalsToField',
-      field: 'otherField'
-    })(null, {
-      otherField: '123'
-    })).toEqual(['Must be equal to otherField']);
-    expect((0, _.createValueValidation)({
-      type: 'equalsToField',
-      field: 'otherField'
-    })('123', {
-      otherField: 123
-    })).toEqual(['Must be equal to otherField']);
-    expect((0, _.createValueValidation)({
-      type: 'equalsToField',
-      field: 'otherField'
-    })(1, {
-      otherField: true
-    })).toEqual(['Must be equal to otherField']);
-    expect((0, _.createValueValidation)({
-      type: 'equalsToField',
-      field: 'otherField',
-      getMessage: to => to
-    })('1234', {
-      otherField: '123'
-    })).toEqual(['otherField']);
-    expect((0, _.createValueValidation)({
-      type: 'equalsToField',
-      field: 'otherField'
-    })('123', {
-      otherField: '123'
-    })).toEqual(undefined);
-    expect((0, _.createValueValidation)({
-      type: 'equalsToField',
-      field: 'otherField'
-    })(123, {
-      otherField: 123
-    })).toEqual(undefined);
-    expect((0, _.createValueValidation)({
-      type: 'equalsToField',
-      field: 'otherField'
-    })(true, {
-      otherField: true
-    })).toEqual(undefined);
-    expect((0, _.createValueValidation)({
-      type: 'equalsToField',
-      field: 'otherField'
-    })(false, {
-      otherField: false
-    })).toEqual(undefined);
-  });
-  it('supports regex', () => {
-    expect((0, _.createValueValidation)({
-      type: 'regex',
-      regex: /[^0-9]/i
-    })('1234a')).toEqual(['Invalid format']);
-    expect((0, _.createValueValidation)({
-      type: 'regex',
-      regex: /[^0-9]/i
-    })('123 ')).toEqual(['Invalid format']);
-    expect((0, _.createValueValidation)({
-      type: 'regex',
-      regex: /[^0-9]/i
-    })(1)).toEqual(undefined);
-    expect((0, _.createValueValidation)({
-      type: 'regex',
-      regex: /[^0-9]/i,
-      getMessage: to => 'test'
-    })('1234a')).toEqual(['test']);
-    expect((0, _.createValueValidation)({
-      type: 'regex',
-      regex: /[^0-9]/i
-    })('123')).toEqual(undefined);
-  });
-  it('supports maxLength', () => {
-    expect((0, _.createValueValidation)({
-      type: 'maxLength',
-      max: 3
-    })('1234')).toEqual(['Maximum number of characters - 3']);
-    expect((0, _.createValueValidation)({
-      type: 'maxLength',
-      max: 3,
-      getMessage: max => max
-    })('1234')).toEqual(['3']);
-    expect((0, _.createValueValidation)({
-      type: 'maxLength',
-      max: 3,
-      getMessage: max => max
-    })('123')).toEqual(undefined);
-    expect((0, _.createValueValidation)({
-      type: 'maxLength',
-      max: 3,
-      getMessage: max => max
-    })('12')).toEqual(undefined);
-  });
-  it('supports minLength', () => {
-    expect((0, _.createValueValidation)({
-      type: 'minLength',
-      min: 3,
-      getMessage: min => min
-    })('1234')).toEqual(undefined);
-    expect((0, _.createValueValidation)({
-      type: 'minLength',
-      min: 3,
-      getMessage: min => min
-    })('123')).toEqual(undefined);
-    expect((0, _.createValueValidation)({
-      type: 'minLength',
-      min: 3,
-      getMessage: min => min
-    })('12')).toEqual(['3']);
-    expect((0, _.createValueValidation)({
-      type: 'minLength',
-      min: 3
-    })('12')).toEqual(['Minimum number of characters - 3']);
-  });
-  it('supports number', () => {
-    expect((0, _.createValueValidation)({
-      type: 'number',
-      getMessage: () => 'Number'
-    })('1234')).toEqual(undefined);
-    expect((0, _.createValueValidation)({
-      type: 'number',
-      getMessage: () => 'Number'
-    })(123)).toEqual(undefined);
-    expect((0, _.createValueValidation)({
-      type: 'number',
-      getMessage: () => 'Number'
-    })('12x')).toEqual(['Number']);
-    expect((0, _.createValueValidation)({
-      type: 'number'
-    })('12x')).toEqual(['Must be a number']);
-  });
-  it('supports string', () => {
-    expect((0, _.createValueValidation)({
-      type: 'string',
-      getMessage: () => 'String'
-    })('1234')).toEqual(undefined);
-    expect((0, _.createValueValidation)({
-      type: 'string',
-      getMessage: () => 'String'
-    })('o ya !')).toEqual(undefined);
-    expect((0, _.createValueValidation)({
-      type: 'string',
-      getMessage: () => 'String'
-    })(12)).toEqual(['String']);
-    expect((0, _.createValueValidation)({
-      type: 'string'
-    })(true)).toEqual(['Must be a string']);
-  });
-  it('supports boolean', () => {
-    expect((0, _.createValueValidation)({
-      type: 'boolean',
-      getMessage: () => 'Boolean'
-    })(true)).toEqual(undefined);
-    expect((0, _.createValueValidation)({
-      type: 'boolean',
-      getMessage: () => 'Boolean'
-    })(false)).toEqual(undefined);
-    expect((0, _.createValueValidation)({
-      type: 'boolean',
-      getMessage: () => 'Boolean'
-    })('truec')).toEqual(['Boolean']);
-    expect((0, _.createValueValidation)({
-      type: 'boolean'
-    })('truec')).toEqual(['Must be a boolean']);
-  });
-  it('supports email', () => {
-    expect((0, _.createValueValidation)({
-      type: 'email',
-      getMessage: () => 'Wrong email'
-    })('test@test.com')).toEqual(undefined);
-    expect((0, _.createValueValidation)({
-      type: 'email',
-      getMessage: () => 'Wrong email'
-    })('email')).toEqual(['Wrong email']);
-    expect((0, _.createValueValidation)({
-      type: 'email',
-      getMessage: () => 'Wrong email'
-    })('email@')).toEqual(['Wrong email']);
-    expect((0, _.createValueValidation)({
-      type: 'email',
-      getMessage: () => 'Wrong email'
-    })('email@.com')).toEqual(['Wrong email']);
-    expect((0, _.createValueValidation)({
-      type: 'email'
-    })('email@.com')).toEqual(['Invalid email format']);
-  });
-  it('supports alphanumeric', () => {
-    expect((0, _.createValueValidation)({
-      type: 'alphanumeric',
-      getMessage: () => 'alphanumeric'
-    })('te123Aa')).toEqual(undefined);
-    expect((0, _.createValueValidation)({
-      type: 'alphanumeric',
-      getMessage: () => 'alphanumeric'
-    })('asd_')).toEqual(['alphanumeric']);
-    expect((0, _.createValueValidation)({
-      type: 'alphanumeric'
-    })('Aa 1')).toEqual(['Only alphanumeric characters']);
-  });
-  it('supports alphanumeric', () => {
-    expect((0, _.createValueValidation)({
-      type: 'alphanumeric',
-      getMessage: () => 'alphanumeric'
-    })('te123Aa')).toEqual(undefined);
-    expect((0, _.createValueValidation)({
-      type: 'alphanumeric',
-      getMessage: () => 'alphanumeric'
-    })('asd_')).toEqual(['alphanumeric']);
-    expect((0, _.createValueValidation)({
-      type: 'alphanumeric'
-    })('Aa 1')).toEqual(['Only alphanumeric characters']);
-  });
-  it('supports oneOf', () => {
-    expect((0, _.createValueValidation)({
-      type: 'oneOf',
-      validators: [{
-        type: 'equals',
-        to: 1,
-        getMessage: to => to
-      }, {
-        type: 'equals',
-        to: 2,
-        getMessage: to => to
-      }]
-    })('3')).toEqual(['1', '2']);
-    expect((0, _.createValueValidation)({
-      type: 'oneOf',
-      validators: [{
-        type: 'equals',
-        to: 1,
-        getMessage: to => to
-      }, {
-        type: 'equals',
-        to: 2,
-        getMessage: to => to
-      }]
-    })(1)).toEqual(undefined);
-    expect((0, _.createValueValidation)({
-      type: 'oneOf',
-      validators: [{
-        type: 'number',
-        getMessage: () => 'Number'
-      }, {
-        type: 'email',
-        getMessage: () => 'Email'
-      }]
-    })('xz')).toEqual(['Number', 'Email']);
-    expect((0, _.createValueValidation)({
-      type: 'oneOf',
-      validators: [{
-        type: 'number',
-        getMessage: () => 'Number'
-      }, {
-        type: 'email',
-        getMessage: () => 'Email'
-      }]
-    })('123')).toEqual(undefined);
-    expect((0, _.createValueValidation)({
-      type: 'oneOf',
-      validators: [{
-        type: 'number',
-        getMessage: () => 'Number'
-      }, {
-        type: 'email',
-        getMessage: () => 'Email'
-      }]
-    })('test@test.com')).toEqual(undefined);
-  });
-  it('supports all', () => {
-    expect((0, _.createValueValidation)({
-      type: 'all',
-      validators: [{
-        type: 'number',
-        getMessage: () => 'Number'
-      }, {
-        type: 'maxLength',
-        max: 1,
-        getMessage: () => 'MaxLength'
-      }]
-    })('xz')).toEqual(['Number', 'MaxLength']);
-    expect((0, _.createValueValidation)({
-      type: 'all',
-      validators: [{
-        type: 'number',
-        getMessage: () => 'Number'
-      }, {
-        type: 'maxLength',
-        max: 1,
-        getMessage: () => 'MaxLength'
-      }]
-    })('12')).toEqual(['MaxLength']);
-    expect((0, _.createValueValidation)({
-      type: 'all',
-      validators: [{
-        type: 'number',
-        getMessage: () => 'Number'
-      }, {
-        type: 'maxLength',
-        max: 1,
-        getMessage: () => 'MaxLength'
-      }]
-    })('x')).toEqual(['Number']);
-    expect((0, _.createValueValidation)({
-      type: 'all',
-      validators: [{
-        type: 'number',
-        getMessage: () => 'Number'
-      }, {
-        type: 'maxLength',
-        max: 1,
-        getMessage: () => 'MaxLength'
-      }]
-    })('1')).toEqual(undefined);
-  });
-  it('supports nesting of all/oneOf', () => {
-    expect((0, _.createValueValidation)({
-      type: 'all',
-      validators: [{
-        type: 'oneOf',
-        validators: [{
-          type: 'number',
-          getMessage: () => 'Number'
-        }, {
-          type: 'email',
-          getMessage: () => 'Email'
-        }]
-      }, {
-        type: 'maxLength',
-        max: 1,
-        getMessage: () => 'MaxLength'
-      }]
-    })('xz')).toEqual(['Number', 'Email', 'MaxLength']);
-    expect((0, _.createValueValidation)({
-      type: 'all',
-      validators: [{
-        type: 'oneOf',
-        validators: [{
-          type: 'number',
-          getMessage: () => 'Number'
-        }, {
-          type: 'email',
-          getMessage: () => 'Email'
-        }]
-      }, {
-        type: 'maxLength',
-        max: 15,
-        getMessage: () => 'MaxLength'
-      }]
-    })('test@test.com')).toEqual(undefined);
-  });
-  it('can handle login validation', () => {
-    const loginValidation = (0, _.createValueValidation)({
-      type: 'all',
-      validators: [{
-        type: 'required',
-        getMessage: () => 'Required'
-      }, {
-        type: 'oneOf',
-        validators: [{
-          type: 'all',
-          validators: [{
-            type: 'alphanumeric',
-            getMessage: () => 'AlphaNumeric'
-          }, {
-            type: 'minLength',
-            min: 3,
-            getMessage: () => '{min}'
-          }]
-        }, {
-          type: 'email',
-          getMessage: () => 'Email'
-        }]
-      }]
-    });
-    expect(loginValidation('')).toEqual(['Required']);
-    expect(loginValidation('aa')).toEqual(['3', 'Email']);
-    expect(loginValidation('aa3')).toEqual(undefined);
-  });
-});

package/lib/__tests__/operators.js

@@ -1,28 +0,0 @@
-"use strict";
-
-var _operators = require("../operators");
-
-describe('oneOf', () => {
-  it('returns undefined for empty', () => {
-    expect((0, _operators.oneOf)()()).toEqual(undefined);
-  });
-  it('returns returns undefined when 1 is passed', () => {
-    expect((0, _operators.oneOf)(() => ['x'], () => undefined)()).toEqual(undefined);
-    expect((0, _operators.oneOf)(() => undefined, () => ['x'])()).toEqual(undefined);
-    expect((0, _operators.oneOf)(() => ['x'], () => undefined, () => ['x'])()).toEqual(undefined);
-  });
-  it('returns all errors when nothing passed', () => {
-    expect((0, _operators.oneOf)(() => ['x'], () => ['y'])()).toEqual(['x', 'y']);
-  });
-});
-describe('all', () => {
-  it('returns undefined for empty', () => {
-    expect((0, _operators.all)()()).toEqual(undefined);
-  });
-  it('returns all errors if something is not passed', () => {
-    expect((0, _operators.all)(() => 'x', () => undefined)()).toEqual(['x']);
-    expect((0, _operators.all)(() => undefined, () => 'x')()).toEqual(['x']);
-    expect((0, _operators.all)(() => 'x', () => undefined, () => 'x')()).toEqual(['x', 'x']);
-    expect((0, _operators.all)(() => 'x', () => 'x')()).toEqual(['x', 'x']);
-  });
-});

package/lib/__tests__/unit.operators.js

@@ -1,125 +0,0 @@
-"use strict";
-
-var _operators = require("../operators");
-
-describe('oneOf', () => {
-  it('throws error when no validators passed', () => {
-    expect(() => (0, _operators.oneOf)()()).toThrow(Error);
-  });
-  it('returns returns undefined when 1 is passed', () => {
-    expect((0, _operators.oneOf)(() => ({
-      data: undefined,
-      errors: ['x']
-    }), () => ({
-      data: 1,
-      errors: undefined
-    }))(1)).toEqual({
-      data: 1,
-      errors: undefined
-    });
-    expect((0, _operators.oneOf)(() => ({
-      data: 1,
-      errors: undefined
-    }), () => ({
-      data: undefined,
-      errors: ['x']
-    }))(1)).toEqual({
-      data: 1,
-      errors: undefined
-    });
-    expect((0, _operators.oneOf)(() => ({
-      data: undefined,
-      errors: ['x']
-    }), () => ({
-      data: 1,
-      errors: undefined
-    }), () => ({
-      data: undefined,
-      errors: ['x']
-    }))(1)).toEqual({
-      data: 1,
-      errors: undefined
-    });
-  });
-  it('returns all errors when nothing passed', () => {
-    expect((0, _operators.oneOf)(() => ({
-      data: undefined,
-      errors: ['x']
-    }), () => ({
-      data: undefined,
-      errors: ['y']
-    }))(1)).toEqual({
-      data: undefined,
-      errors: ['x', 'y']
-    });
-  });
-});
-describe('all', () => {
-  it('throws error when no validators passed', () => {
-    expect(() => (0, _operators.all)()()).toThrow(Error);
-  });
-  it('returns all errors if something is not passed', () => {
-    expect((0, _operators.all)(() => ({
-      data: undefined,
-      errors: ['x']
-    }), () => ({
-      data: 1,
-      errors: undefined
-    }))(1)).toEqual({
-      data: undefined,
-      errors: ['x']
-    });
-    expect((0, _operators.all)(() => ({
-      data: 1,
-      errors: undefined
-    }), () => ({
-      data: undefined,
-      errors: ['x']
-    }))(1)).toEqual({
-      data: undefined,
-      errors: ['x']
-    });
-    expect((0, _operators.all)(() => ({
-      data: undefined,
-      errors: ['x']
-    }), () => ({
-      data: 1,
-      errors: undefined
-    }), () => ({
-      data: undefined,
-      errors: ['x']
-    }))(1)).toEqual({
-      data: undefined,
-      errors: ['x', 'x']
-    });
-    expect((0, _operators.all)(() => ({
-      data: undefined,
-      errors: ['x']
-    }), () => ({
-      data: undefined,
-      errors: ['x']
-    }))(1)).toEqual({
-      data: undefined,
-      errors: ['x', 'x']
-    });
-  });
-  it('returns data if all valid', () => {
-    expect((0, _operators.all)(() => ({
-      data: 1,
-      errors: undefined
-    }))(1)).toEqual({
-      data: 1,
-      errors: undefined
-    });
-    expect((0, _operators.all)(() => ({
-      data: 1,
-      errors: undefined
-    }), () => ({
-      data: 1,
-      errors: undefined
-    }))(1)).toEqual({
-      data: 1,
-      errors: undefined
-    });
-  });
-});

package/lib/createObjectValidation.js

@@ -1,34 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _ = require(".");
-
-var _default = rulesObject => {
-  const fieldValidations = Object.getOwnPropertyNames(rulesObject).map(ruleProp => ({
-    prop: ruleProp,
-    validation: (0, _.createValueValidation)(rulesObject[ruleProp])
-  }));
-  return object => {
-    const resultData = {};
-    const resultErrors = {};
-    fieldValidations.forEach(fv => {
-      const fieldValidationErrors = fv.validation(object[fv.prop], object);
-
-      if (fieldValidationErrors) {
-        resultErrors[fv.prop] = fieldValidationErrors;
-      }
-
-      resultData[fv.prop] = object[fv.prop];
-    });
-    return {
-      data: resultData,
-      errors: Object.getOwnPropertyNames(resultErrors).length > 0 ? resultErrors : undefined
-    };
-  };
-};
-
-exports.default = _default;

package/lib/createValueValidation.js

@@ -1,71 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _validators = require("./validators");
-
-var _operators = require("./operators");
-
-const ruleProcessor = rule => {
-  switch (rule.type) {
-    case 'required':
-      return (0, _validators.required)(rule);
-
-    case 'equals':
-      return (0, _validators.equals)(rule);
-
-    case 'maxLength':
-      return (0, _validators.maxLength)(rule);
-
-    case 'minLength':
-      return (0, _validators.minLength)(rule);
-
-    case 'minValue':
-      return (0, _validators.minValue)(rule);
-
-    case 'maxValue':
-      return (0, _validators.maxValue)(rule);
-
-    case 'number':
-      return (0, _validators.number)(rule);
-
-    case 'boolean':
-      return (0, _validators.boolean)(rule);
-
-    case 'string':
-      return (0, _validators.string)(rule);
-
-    case 'email':
-      return (0, _validators.email)(rule);
-
-    case 'alphanumeric':
-      return (0, _validators.alphanumeric)(rule);
-
-    case 'equalsToField':
-      return (0, _validators.equalsToField)(rule);
-
-    case 'regex':
-      return (0, _validators.regex)(rule);
-
-    case 'oneOf':
-      return (0, _operators.oneOf)(...rule.validators.map(ruleProcessor));
-
-    case 'all':
-      return (0, _operators.all)(...rule.validators.map(ruleProcessor));
-
-    default:
-      throw new Error(`invalid validator type: {rule.type}`);
-  }
-};
-
-var _default = rule => {
-  const validator = ruleProcessor(rule);
-  return (value, allValues) => {
-    return validator(value, allValues);
-  };
-};
-
-exports.default = _default;