Issue#48 support field validation constraint

lib/lcformvalidation.d.ts

@@ -11,14 +11,16 @@ export class FormValidationResult {
   formGlobalErrors: Array<FieldValidationResult>;
 }
 
+export interface ValidationFilters {
+  [key: string]: boolean;
+}
+
 interface FormValidation {
-  validateField(vm: any, key: string, value: any, filter?: any): Promise<FieldValidationResult>;
+  validateField(vm: any, key: string, value: any, filter?: ValidationFilters): Promise<FieldValidationResult>;
   validateForm(vm: any): Promise<FormValidationResult>;
   isValidationInProgress(): boolean;
   isFormDirty(): boolean;
   isFormPristine(): boolean;
-  addFieldValidation(key: string, validation: (value: string, vm: any) => FieldValidationResult, filter?: any): FormValidation;
-  addFieldValidationAsync(key: string, validation: (value: string, vm: any) => Promise<FieldValidationResult>, filter?: any): FormValidation;
 }
 
 export type ValidationResult = FieldValidationResult | Promise<FieldValidationResult>;
@@ -27,8 +29,19 @@ export interface FormValidationFunction {
   (vm: any): ValidationResult;
 }
 
+export interface FieldValidationFunction {
+  (value: any, vm: any, customParams: any): ValidationResult;
+}
+
+export interface FieldValidationConstraint extends Object {
+  validator: FieldValidationFunction;
+  eventFilters?: ValidationFilters,
+  customParams?: Object
+}
+
 export interface ValidationConstraints extends Object {
   global?: FormValidationFunction[];
+  fields?: { [key: string]: FieldValidationConstraint[] }
 }
 
-export function createFormValidation(validationCredentials: ValidationConstraints): FormValidation;
+export function createFormValidation(validationCredentials: ValidationConstraints): FormValidation;

lib/package.json

@@ -5,7 +5,7 @@
   "main": "dist/lc-form-validation.js",
   "scripts": {
     "test": "karma start --browsers PhantomJS --single-run",
-    "test:watch": "karma start --browsers PhantomJS",
+    "test:watch": "karma start",
     "clean": "rimraf dist ReadmeResources",
     "build:prod": "cross-env NODE_ENV=production webpack --output-filename dist/lc-form-validation.min.js",
     "build:dev": "cross-env NODE_ENV=development webpack --output-filename dist/lc-form-validation.js",
@@ -31,7 +31,7 @@
   "devDependencies": {
     "@types/chai": "^3.4.35",
     "@types/chai-as-promised": "^0.0.30",
-    "@types/core-js": "^0.9.34",
+    "@types/core-js": "0.9.36",
     "@types/karma-chai-sinon": "^0.1.5",
     "@types/mocha": "^2.2.39",
     "@types/sinon": "^1.16.31",

lib/src/baseFormValidation.ts

@@ -1,9 +1,12 @@
 import { ValidationEngine } from './validationEngine';
 import {
   ValidationConstraints,
+  FieldValidationFunction,
   FormValidationFunction,
   FieldValidationResult,
   FormValidationResult,
+  FieldValidationConstraint,
+  ValidationFilters,
 } from './entities';
 import { consts } from './consts';
 
@@ -13,35 +16,64 @@ interface FormValidation {
   isValidationInProgress(): boolean;
   isFormDirty(): boolean;
   isFormPristine(): boolean;
-  addFieldValidation(key: string, validation: (value: string, vm: any) => FieldValidationResult, filter?: any): FormValidation;
-  addFieldValidationAsync(key: string, validation: (value: string, vm: any) => Promise<FieldValidationResult>, filter?: any): FormValidation;
 }
 
 export class BaseFormValidation implements FormValidation {
   private validationEngine: ValidationEngine;
+
   constructor(validationConstraints: ValidationConstraints) {
     this.validationEngine = new ValidationEngine();
     this.parseValidationConstraints(validationConstraints);
   }
 
   private parseValidationConstraints(validationConstraints: ValidationConstraints) {
     if (validationConstraints && typeof validationConstraints === 'object') {
-      if (validationConstraints.global && validationConstraints.global instanceof Array) {
-        this.addFormValidationFunctions(validationConstraints.global);
+      const { global, fields } = validationConstraints;
+      if (global && global instanceof Array) {
+        this.parseFormValidations(global);
+      }
+      if (fields && typeof fields === 'object') {
+        this.parseAllFieldsValidations(fields);
       }
     }
   }
 
-  private addFormValidationFunctions(validationFunctions: FormValidationFunction[]) {
+  private parseFieldValidations(constraint: string, fieldValidationConstraints: FieldValidationConstraint[]) {
+    if (fieldValidationConstraints instanceof Array) {
+      fieldValidationConstraints.forEach((fieldValidationConstraint) => {
+        if (fieldValidationConstraint && typeof fieldValidationConstraint === 'object') {
+          this.addFieldValidation(constraint, fieldValidationConstraint);
+        }
+      });
+    }
+  }
+
+  private parseAllFieldsValidations(fields: { [key: string]: FieldValidationConstraint[] }) {
+    for (let field in fields) {
+      this.parseFieldValidations(field, fields[field]);
+    }
+  }
+
+  private parseFormValidations(validationFunctions: FormValidationFunction[]) {
     validationFunctions.forEach((validationFunction: FormValidationFunction) => {
       if (typeof validationFunction === 'function') {
         this.validationEngine.addFormValidation(validationFunction);
       }
     });
   }
 
-  validateField(vm: any, key: string, value: any, filter?: any): Promise<FieldValidationResult> {
-    return this.validationEngine.validateSingleField(vm, key, value, filter);
+  private addFieldValidation(constraint: string, validationConstraint: FieldValidationConstraint): FormValidation {
+    this.validationEngine.addFieldValidation(
+      constraint,
+      validationConstraint.validator,
+      validationConstraint.eventFilters,
+      validationConstraint.customParams
+    );
+    return this;
+  }
+
+  validateField(vm: any, key: string, value: any, filter?: ValidationFilters): Promise<FieldValidationResult> {
+    return this.validationEngine.triggerFieldValidation(vm, key, value, filter);
   }
 
   validateForm(vm: any): Promise<FormValidationResult> {
@@ -59,18 +91,8 @@ export class BaseFormValidation implements FormValidation {
   isFormPristine(): boolean {
     return this.validationEngine.isFormPristine();
   }
-
-  addFieldValidation(key: string, validationFunction: (value: string, vm: any) => FieldValidationResult): FormValidation {
-    this.validationEngine.addFieldValidation(key, validationFunction);
-    return this;
-  }
-
-  addFieldValidationAsync(key: string, validationFunction: (value: string, vm: any) => Promise<FieldValidationResult>): FormValidation {
-    this.validationEngine.addFieldValidationAsync(key, validationFunction);
-    return this;
-  }
 }
 
 export function createFormValidation(validationConstraints: ValidationConstraints): FormValidation {
   return new BaseFormValidation(validationConstraints);
-}
+}

lib/src/entities.ts

@@ -1,6 +1,11 @@
+export interface ValidationFilters {
+  [key: string]: boolean;
+}
+
 export class FieldValidation {
-  public validationFn: (value, vm) => Promise<FieldValidationResult>;
-  public filter: any;
+  validationFn: (value, vm, customParams) => Promise<FieldValidationResult>;
+  filters: ValidationFilters;
+  customParams: any;
 }
 
 export class FieldValidationResult {
@@ -19,8 +24,8 @@ export class FieldValidationResult {
 
 export class FormValidationResult {
   succeeded: boolean;
-  fieldErrors: Array<FieldValidationResult>;
-  formGlobalErrors: Array<FieldValidationResult>;
+  fieldErrors: FieldValidationResult[];
+  formGlobalErrors: FieldValidationResult[];
 
   constructor() {
     this.succeeded = false;
@@ -34,6 +39,23 @@ export interface FormValidationFunction {
   (vm: any): ValidationResult;
 }
 
-export interface ValidationConstraints extends Object {
+export interface SyncValidationFunction {
+  (value: any, vm: any, customParams: any): ValidationResult;
+}
+
+export interface AsyncFieldValidationFunction {
+  (value: any, vm: any, customParams: any): Promise<FieldValidationResult>;
+}
+
+export type FieldValidationFunction = SyncValidationFunction | AsyncFieldValidationFunction;
+
+export interface FieldValidationConstraint {
+  validator: FieldValidationFunction;
+  eventFilters?: ValidationFilters;
+  customParams?: any;
+}
+
+export interface ValidationConstraints {
   global?: FormValidationFunction[];
+  fields?: { [key: string]: FieldValidationConstraint[] };
 }

lib/src/fieldValidationEventFilter.ts

@@ -1,37 +1,25 @@
-import { FieldValidation } from './entities';
+import { FieldValidation, ValidationFilters } from './entities';
 
 class FieldValidationEventFilter {
 
-  public filter(fieldValidations: Array<FieldValidation>, filter: any): Array<FieldValidation> {
-    let result = new Array<FieldValidation>();
+  public filter(fieldValidations: FieldValidation[], filters: ValidationFilters): FieldValidation[] {
+    let result: FieldValidation[] = [];
 
-    if (filter) {
-      result = fieldValidations.filter((element) => {
-        return this.matchFilterOr(element, filter)
-      });
+    if (filters) {
+      result = fieldValidations.filter((fieldValidation) =>
+        this.matchsAnyFilter(fieldValidation, filters)
+      );
     } else {
       result = fieldValidations;
     }
 
     return result;
   }
 
-  private matchFilterOr(itemFilter, globalFilter) {
-    let result: boolean = false;
-
-    for (var property in globalFilter) {
-      if (this.propertyMatched(itemFilter, property, globalFilter)) {
-        result = true;
-        break;
-      }
-    }
-
-    return result;
-  }
-
-  private propertyMatched(item: any, property: any, globalFilter: any): boolean {
-    return (globalFilter.hasOwnProperty(property) &&
-      globalFilter[property] == item.filter[property]);
+  private matchsAnyFilter(fieldValidation: FieldValidation, filters: ValidationFilters) {
+    return Object.keys(filters).some(filter =>
+      filters[filter] === fieldValidation.filters[filter]
+    );
   }
 }