added validation of nested objects

Author: Umed Khudoiberdiev

package.json

@@ -1,6 +1,6 @@
 {
   "name": "validator.ts",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Wrapper over validator.js library that allows to use validation decorators in your Typescript classes",
   "license": "Apache-2.0",
   "readmeFilename": "README.md",

sample/sample1-simple-validation/app.ts

@@ -12,6 +12,7 @@ post1.rating = 10; // should pass
 post1.email = 'info@google.com'; // should pass
 post1.site = 'google.com'; // should pass
 post1.createDate = new Date(); // should pass
+post1.tags = ['abcd1', 'abcd2', 'abcd3', 'abcd4', 'abcd4']; // should pass
 
 console.log('should pass: ', validator.validate(Post, post1)); // should pass completely, e.g. return empty array
 
@@ -65,7 +66,7 @@ post6.rating = 10; // should pass
 post6.email = 'info@google.com'; // should pass
 post6.site = 'google.com'; // should pass
 post6.createDate = new Date(); // should pass
-post6.tags = [];
+post6.tags = ['abcd1', 'abcd2', 'abcd3', 'abcd4', 'abcd4'];
 
 console.log('should pass: ', validator.validate(Post, post6)); // should pass completely, e.g. return empty array
 

sample/sample4-nested-objects/Post.ts

@@ -0,0 +1,14 @@
+import {Contains, IsInt, IsLength, IsEmail, IsFQDN, IsDate, ValidateNested} from "../../src/annotation/ValidationAnnotations";
+import {Tag} from "./Tag";
+
+export class Post {
+
+    @IsLength(10, 20, {
+        message: 'Incorrect length!'
+    })
+    title: string;
+
+    @ValidateNested(type => Tag)
+    tags: Tag[];
+
+}

sample/sample4-nested-objects/Tag.ts

@@ -0,0 +1,10 @@
+import {Contains, IsInt, IsLength, IsEmail, IsFQDN, IsDate} from "../../src/annotation/ValidationAnnotations";
+
+export class Tag {
+
+    @IsLength(10, 20, {
+        message: 'Tag is too short or long'
+    })
+    name: string;
+
+}

sample/sample4-nested-objects/app.ts

@@ -0,0 +1,17 @@
+import {Validator} from "../../src/Validator";
+import {Post} from "./Post";
+import {Tag} from "./Tag";
+
+let validator = new Validator();
+
+let tag1 = new Tag();
+tag1.name = 'ja';
+
+let tag2 = new Tag();
+tag2.name = 'node.js';
+
+let post1 = new Post();
+post1.title = 'Hello world';
+post1.tags = [tag1, tag2];
+
+console.log('should not pass: ', validator.validate(Post, post1));

src/ValidationError.ts

@@ -1,4 +1,5 @@
 export interface ValidationError {
+    objectClass: Function;
     property: string;
     errorCode: number;
     errorName: string;

src/Validator.ts

@@ -26,6 +26,23 @@ export class Validator {
     // Public Methods
     // -------------------------------------------------------------------------
 
+    validateAsync<T>(objectClass: Function, object: T, validationOptions?: ValidationOptions): Promise<T> {
+        return new Promise<T>((ok, fail) => { // todo install promise
+            let errors = this.validate(objectClass, object, validationOptions);
+            if (errors.length > 0) {
+                fail(errors);
+            } else {
+                ok(object);
+            }
+        });
+    }
+
+    validateOrThrow(objectClass: Function, object: any, validationOptions?: ValidationOptions) {
+        const errors = this.validate(objectClass, object, validationOptions);
+        if (errors.length > 0)
+            throw new Error('Validation failed: ' + JSON.stringify(errors)); // todo
+    }
+
     validate(objectClass: Function, object: any, validationOptions?: ValidationOptions): ValidationError[] {
         let groups = validationOptions ? validationOptions.groups : undefined;
         let metadatas = this.metadataStorage.getValidationMetadatasForObject(objectClass, groups);
@@ -38,16 +55,16 @@ export class Validator {
             let errors = duplicateMetadatas.map(metadata => {
                 let isValid = true;
                 if (metadata.each) {
-                    if (value instanceof Array) {
-
+                    if (value instanceof Array)
                         isValid = value.every((v: any) => this.performValidation(v, metadata));
-                    }
+
                 } else {
                     isValid = this.performValidation(value, metadata);
                 }
                 if (isValid) return null;
 
                 return <ValidationError> {
+                    objectClass: objectClass,
                     property: metadata.propertyName,
                     errorCode: metadata.type,
                     errorName: ValidationTypesUtils.getCodeName(metadata.type),
@@ -57,12 +74,29 @@ export class Validator {
                 };
             });
 
-            if (value instanceof Array) {
+            let nestedValidation = duplicateMetadatas.reduce((found, metadata) => {
+                return metadata.type === ValidationTypes.NESTED_VALIDATION ? metadata : found;
+            }, undefined);
+            if (nestedValidation) {
+                if (value instanceof Array) {
+                    value.map((v: any) => {
+                        const nestedErrors = this.validate(metadata.value1(), v, validationOptions);
+                        if (nestedErrors && nestedErrors.length)
+                            errors = errors.concat(nestedErrors);
+                    });
+
+                } else if (value instanceof Object) {
+                    const nestedErrors = this.validate(metadata.value1, value, validationOptions);
+                    if (nestedErrors && nestedErrors.length)
+                        errors = errors.concat(nestedErrors);
 
+                } else {
+                    throw new Error('Only objects and arrays are supported to nested validation');
+                }
             }
 
-            if (errors.length > 0 && errors.indexOf(null) !== -1)
-                return null;
+            //if (errors.length > 0 && errors.indexOf(null) !== -1)
+              //  return null;
 
             return errors.reduceRight((found, err) => err !== null ? err : found, null);
 

src/annotation/ValidationAnnotations.ts

@@ -994,4 +994,23 @@ export function MaxElements(max: number, annotationOptions?: ValidationAnnotatio
             each: annotationOptions && annotationOptions.each ? annotationOptions.each : undefined
         });
     }
+}
+
+/**
+ * Checks if array's length is as maximal this number.
+ */
+export function ValidateNested(type: (_?: any) => Function, annotationOptions?: ValidationAnnotationOptions) {
+    return function (object: Object, propertyName: string) {
+        defaultMetadataStorage.addValidationMetadata({
+            type: ValidationTypes.NESTED_VALIDATION,
+            sanitize: false,
+            object: object,
+            propertyName: propertyName,
+            value1: type,
+            groups: annotationOptions && annotationOptions.groups ? annotationOptions.groups : undefined,
+            message: annotationOptions && annotationOptions.message ? annotationOptions.message : undefined,
+            always: annotationOptions && annotationOptions.always ? annotationOptions.always : undefined,
+            each: annotationOptions && annotationOptions.each ? annotationOptions.each : undefined
+        });
+    }
 }

src/types/ValidationTypes.ts

@@ -52,6 +52,8 @@ export enum ValidationTypes {
     NOT_EMPTY_ARRAY = 1002,
     MIN_ELEMENTS = 1003,
     MAX_ELEMENTS = 1004,
+
+    NESTED_VALIDATION = 0
 }
 
 export class ValidationTypesUtils {

tsd.json

@@ -20,6 +20,9 @@
     },
     "sinon/sinon.d.ts": {
       "commit": "7a3ca1f0b8a0960af9fc1838f3234cc9d6ce0645"
+    },
+    "es6-promise/es6-promise.d.ts": {
+      "commit": "b70895565dd5bd5de71c31e573d781409554bbf1"
     }
   }
 }