Merge pull request #52 from Lemoncode/issue#50-validation-rules

Issue#50 validation rules

Author: crsanti

lib/lcformvalidation.d.ts

@@ -33,15 +33,35 @@ export interface FieldValidationFunction {
   (value: any, vm: any, customParams: any): ValidationResult;
 }
 
-export interface FieldValidationConstraint{
+export interface FieldValidationConstraint {
   validator: FieldValidationFunction;
   eventFilters?: ValidationEventsFilter;
   customParams?: any;
 }
 
-export interface ValidationConstraints{
+export interface ValidationConstraints {
   global?: FormValidationFunction[];
   fields?: { [key: string]: FieldValidationConstraint[] }
 }
 
 export function createFormValidation(validationCredentials: ValidationConstraints): FormValidation;
+
+export interface LengthParams {
+  length: number;
+}
+
+export interface PatternParams {
+  pattern: string | RegExp;
+}
+
+export interface RequiredParams {
+  trim: boolean;
+}
+
+export namespace Validators {
+  function required(value: any, vm: any, customParams: RequiredParams): FieldValidationResult;
+  function minLength(value: any, vm: any, customParams: LengthParams): FieldValidationResult;
+  function maxLength(value: any, vm: any, customParams: LengthParams): FieldValidationResult;
+  function email(value: any, vm: any): FieldValidationResult;
+  function pattern(value: any, vm: any, customParams: PatternParams): FieldValidationResult;
+}

lib/src/index.ts

@@ -1,8 +1,10 @@
 import { FormValidationResult, FieldValidationResult } from "./entities";
 import { createFormValidation } from './baseFormValidation';
+import { Validators } from './rules';
 
 export {
   FormValidationResult,
   FieldValidationResult,
   createFormValidation,
+  Validators,
 }

lib/src/rules/email.ts

@@ -0,0 +1,26 @@
+import { FieldValidationResult, FieldValidationFunction } from '../entities';
+
+// RegExp from http://emailregex.com
+const EMAIL_PATTERN = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+
+export const email: FieldValidationFunction = (value: string) => {
+  const validationResult = new FieldValidationResult();
+  const isValid = isValidEmail(value);
+
+  validationResult.succeeded = isValid;
+  validationResult.type = 'EMAIL';
+  validationResult.errorMessage = isValid ? '' : 'Please enter a valid email address.';
+  return validationResult;
+};
+
+function isValidEmail(value): boolean {
+  return isEmptyValue(value) ?
+    true :
+    EMAIL_PATTERN.test(value);
+}
+
+function isEmptyValue(value): boolean {
+  return value === null ||
+    value === undefined ||
+    value === '';
+}

lib/src/rules/index.ts

@@ -0,0 +1,23 @@
+import { required } from './required';
+import { minLength } from './minLength';
+import { maxLength } from './maxLength';
+import { email } from './email';
+import { pattern } from './pattern';
+import { FieldValidationFunction } from '../entities';
+
+
+interface ValidatorFunctions {
+  required: FieldValidationFunction;
+  minLength: FieldValidationFunction;
+  maxLength: FieldValidationFunction;
+  email: FieldValidationFunction;
+  pattern: FieldValidationFunction;
+}
+
+export const Validators: ValidatorFunctions = {
+  required,
+  minLength,
+  maxLength,
+  email,
+  pattern,
+};

lib/src/rules/length.ts

@@ -0,0 +1,23 @@
+export interface LengthParams {
+  length: number;
+}
+
+export function parseLengthParams(customParams: LengthParams, errorMessage: string) {
+  const length = customParams.length === null ? NaN : Number(customParams.length);
+  if (isNaN(length)) {
+    throw new Error(errorMessage);
+  }
+
+  return length;
+}
+
+export function isLengthValid(
+  value,
+  length: number,
+  validatorFn: (value: string, length: number) => boolean
+): boolean {
+  // Don't try to validate non string values
+  return typeof value === 'string' ?
+    validatorFn(value, length) :
+    true;
+}

lib/src/rules/maxLength.ts

@@ -0,0 +1,26 @@
+import { FieldValidationResult, FieldValidationFunction } from '../entities';
+import {
+  LengthParams,
+  parseLengthParams,
+  isLengthValid,
+} from './length';
+
+const DEFAULT_PARAMS = { length: undefined };
+const BAD_PARAMETER = 'FieldValidationError: Parameter "length" for maxLength in customParams is mandatory and should be a valid number. Example: { length: 4 }.';
+
+export function maxLength(value: string, vm, customParams: LengthParams = DEFAULT_PARAMS) {
+  const length = parseLengthParams(customParams, BAD_PARAMETER);
+  const isValid = isLengthValid(value, length, isStringLengthValid);
+  const validationResult = new FieldValidationResult();
+
+  validationResult.succeeded = isValid;
+  validationResult.type = 'MAX_LENGTH';
+  validationResult.errorMessage = isValid ? '' : `The value provided is too long. Length must not exceed ${length} characters.`;
+  return validationResult;
+}
+
+function isStringLengthValid(value: string, length: number): boolean {
+  return isNaN(length) ?
+    false :
+    value.length <= length;
+}

lib/src/rules/minLength.ts

@@ -0,0 +1,24 @@
+import { FieldValidationResult, FieldValidationFunction } from '../entities';
+import {
+  LengthParams,
+  parseLengthParams,
+  isLengthValid,
+} from './length';
+
+const DEFAULT_PARAMS = { length: undefined };
+const BAD_PARAMETER = 'FieldValidationError: Parameter "length" for minLength in customParams is mandatory and should be a valid number. Example: { length: 4 }.';
+
+export const minLength: FieldValidationFunction = (value: string, vm, customParams: LengthParams = DEFAULT_PARAMS) => {
+  const length = parseLengthParams(customParams, BAD_PARAMETER);
+  const isValid = isLengthValid(value, length, isStringLengthValid);
+  const validationResult = new FieldValidationResult();
+
+  validationResult.errorMessage = isValid ? '' : `The value provided must have at least ${length} characters.`;
+  validationResult.succeeded = isValid;
+  validationResult.type = 'MIN_LENGTH';
+  return validationResult;
+}
+
+function isStringLengthValid(value: string, length: number): boolean {
+  return value.length >= length;
+}

lib/src/rules/pattern.ts

@@ -0,0 +1,33 @@
+import { FieldValidationResult } from '../entities';
+
+export interface PatternParams {
+  pattern: string | RegExp;
+}
+
+const BAD_PARAMETER = 'FieldValidationError: pattern option for pattern validation is mandatory. Example: { pattern: /\d+/ }.';
+
+export function pattern(value: string, vm, customParams: PatternParams): FieldValidationResult {
+  const pattern = parsePattern(customParams);
+  const isValid = pattern.test(value);
+  const validationResult = new FieldValidationResult();
+
+  validationResult.succeeded = isValid;
+  validationResult.type = 'PATTERN';
+  validationResult.errorMessage = isValid ? '' : `Please provide a valid format.`;
+
+  return validationResult;
+}
+
+function parsePattern({ pattern }: PatternParams): RegExp {
+  // Avoid RegExp like /true/ /false/ and /null/ without an explicit "true", "false" or "null"
+  if (typeof pattern === 'boolean' || pattern === null) {
+    throw new Error(BAD_PARAMETER);
+  }
+  return getRegExp(pattern);
+}
+
+function getRegExp(pattern): RegExp {
+  return pattern instanceof RegExp ?
+    pattern :
+    new RegExp(pattern);
+}

lib/src/rules/required.ts

@@ -0,0 +1,27 @@
+import { FieldValidationResult, FieldValidationFunction } from '../entities';
+export interface RequiredParams {
+  trim: boolean;
+}
+
+const DEFAULT_PARAMS: RequiredParams = { trim: true };
+
+export const required: FieldValidationFunction = (value, vm, customParams: RequiredParams = DEFAULT_PARAMS) => {
+  const validationResult = new FieldValidationResult();
+  const isValid = isValidField(value, Boolean(customParams.trim));
+  validationResult.errorMessage = isValid ? '' : 'Please fill in this mandatory field.';
+  validationResult.succeeded = isValid;
+  validationResult.type = 'REQUIRED';
+  return validationResult;
+}
+
+function isValidField(value, trim: boolean): boolean {
+  return typeof value === 'string' ?
+    isStringValid(value, trim) :
+    value === true;
+}
+
+function isStringValid(value: string, trim: boolean): boolean {
+  return trim ?
+    value.trim().length > 0 :
+    value.length > 0;
+}

lib/src/rules/spec/email.spec.ts

@@ -0,0 +1,126 @@
+import { email } from '../email';
+import { FieldValidationResult } from '../../entities';
+
+describe('[email] validation rule tests =>', () => {
+  describe('When validating a non string value', () => {
+    it('should return true if value is null', () => {
+      // Arrange
+      const value = null;
+      const vm = undefined;
+      const customParams = undefined;
+
+      // Act
+      const validationResult = email(value, vm, customParams) as FieldValidationResult;
+
+      // Assert
+      expect(validationResult.succeeded).to.be.true;
+      expect(validationResult.type).to.be.equals('EMAIL');
+      expect(validationResult.errorMessage).to.be.empty;
+    });
+
+    it('should return true if value is undefined', () => {
+      // Arrange
+      const value = undefined;
+      const vm = undefined;
+      const customParams = undefined;
+
+      // Act
+      const validationResult = email(value, vm, customParams) as FieldValidationResult;
+
+      // Assert
+      expect(validationResult.succeeded).to.be.true;
+      expect(validationResult.type).to.be.equals('EMAIL');
+      expect(validationResult.errorMessage).to.be.empty;
+    });
+
+    it('should return false if value is number', () => {
+      // Arrange
+      const value = Math.PI;
+      const vm = undefined;
+      const customParams = undefined;
+
+      // Act
+      const validationResult = email(value, vm, customParams) as FieldValidationResult;
+
+      // Assert
+      expect(validationResult.succeeded).to.be.false;
+      expect(validationResult.type).to.be.equals('EMAIL');
+      expect(validationResult.errorMessage).to.be.equals('Please enter a valid email address.');
+    });
+
+    it('should return false if value is an object', () => {
+      // Arrange
+      const value = {};
+      const vm = undefined;
+      const customParams = undefined;
+
+      // Act
+      const validationResult = email(value, vm, customParams) as FieldValidationResult;
+
+      // Assert
+      expect(validationResult.succeeded).to.be.false;
+      expect(validationResult.type).to.be.equals('EMAIL');
+      expect(validationResult.errorMessage).to.be.equals('Please enter a valid email address.');
+    });
+
+    it('should return false if value is an array', () => {
+      // Arrange
+      const value = ['a', '@', 'b', '.', 'c', 'o', 'm'];
+      const vm = undefined;
+      const customParams = undefined;
+
+      // Act
+      const validationResult = email(value, vm, customParams) as FieldValidationResult;
+
+      // Assert
+      expect(validationResult.succeeded).to.be.false;
+      expect(validationResult.type).to.be.equals('EMAIL');
+      expect(validationResult.errorMessage).to.be.equals('Please enter a valid email address.');
+    });
+
+    it('should return false if value is a function', () => {
+      // Arrange
+      const value = () => { };
+      const vm = undefined;
+      const customParams = undefined;
+
+      // Act
+      const validationResult = email(value, vm, customParams) as FieldValidationResult;
+
+      // Assert
+      expect(validationResult.succeeded).to.be.false;
+      expect(validationResult.type).to.be.equals('EMAIL');
+      expect(validationResult.errorMessage).to.be.equals('Please enter a valid email address.');
+    });
+  });
+  describe('When validating a string value', () => {
+    it('should return false for invalid email address', () => {
+      // Arrange
+      const value = 'some text';
+      const vm = undefined;
+      const customParams = undefined;
+
+      // Act
+      const validationResult = email(value, vm, customParams) as FieldValidationResult;
+
+      // Assert
+      expect(validationResult.succeeded).to.be.false;
+      expect(validationResult.type).to.be.equals('EMAIL');
+      expect(validationResult.errorMessage).to.be.equals('Please enter a valid email address.');
+    });
+    it('should return true for a valid email address', () => {
+      // Arrange
+      const value = 'a@b.com';
+      const vm = undefined;
+      const customParams = undefined;
+
+      // Act
+      const validationResult = email(value, vm, customParams) as FieldValidationResult;
+
+      // Assert
+      expect(validationResult.succeeded).to.be.true;
+      expect(validationResult.type).to.be.equals('EMAIL');
+      expect(validationResult.errorMessage).to.be.empty;
+    });
+  });
+});