feat: add IsInstance decorator

Author: NoNameProvided

src/decorator/decorators.ts

@@ -1120,3 +1120,19 @@ export function ArrayUnique(validationOptions?: ValidationOptions) {
         getFromContainer(MetadataStorage).addValidationMetadata(new ValidationMetadata(args));
     };
 }
+
+/**
+ * Checks if all array's values are unique. Comparison for objects is reference-based.
+ */
+export function IsInstance(targetType: new (...args: any[]) => any, validationOptions?: ValidationOptions) {
+    return function (object: Object, propertyName: string) {
+        const args: ValidationMetadataArgs = {
+            type: ValidationTypes.IS_INSTANCE,
+            target: object.constructor,
+            propertyName: propertyName,
+            constraints: [targetType],
+            validationOptions: validationOptions
+        };
+        getFromContainer(MetadataStorage).addValidationMetadata(new ValidationMetadata(args));
+    };
+}

src/validation/ValidationTypes.ts

@@ -88,6 +88,9 @@ export class ValidationTypes {
     static ARRAY_MAX_SIZE = "arrayMaxSize";
     static ARRAY_UNIQUE = "arrayUnique";
 
+    /* object chekers */
+    static IS_INSTANCE = "isInstance";
+
     /**
      * Checks if validation type is valid.
      */
@@ -252,6 +255,15 @@ export class ValidationTypes {
                 return eachPrefix + "$property must contain not more than $constraint1 elements";
             case this.ARRAY_UNIQUE:
                 return eachPrefix + "All $property's elements must be unique";
+
+            case this.IS_INSTANCE:
+                return (args: ValidationArguments) => {
+                    if (args.constraints[0]) {
+                        return eachPrefix + `$property must be an instance of ${args.constraints[0].name}`;
+                    } else {
+                        return eachPrefix + `${this.IS_INSTANCE} decorator expects and object as value, but got falsy value.`;
+                    }
+                };
         }
 
         return "";

src/validation/Validator.ts

@@ -247,6 +247,9 @@ export class Validator {
                 return this.arrayMaxSize(value, metadata.constraints[0]);
             case ValidationTypes.ARRAY_UNIQUE:
                 return this.arrayUnique(value);
+
+            case ValidationTypes.IS_INSTANCE:
+                return this.isInstance(value, metadata.constraints[0]);
         }
         return true;
     }
@@ -798,4 +801,13 @@ export class Validator {
         return array.length === uniqueItems.length;
     }
 
+    /**
+     * Checks if the value is an instance of the specified object.
+     */
+    isInstance(object: any, targetTypeConstructor: new (...args: any[]) => any) {
+        return targetTypeConstructor
+            && typeof targetTypeConstructor === "function"
+            && object instanceof targetTypeConstructor;
+    }
+
 }

test/functional/validation-functions-and-decorators.spec.ts

@@ -62,7 +62,8 @@ import {
     ArrayNotContains,
     ArrayUnique,
     IsArray,
-    IsDateString
+    IsDateString,
+    IsInstance
 } from "../../src/decorator/decorators";
 import {Validator} from "../../src/validation/Validator";
 import {ValidatorOptions} from "../../src/validation/ValidatorOptions";
@@ -2989,7 +2990,7 @@ describe("ArrayMaxSize", function() {
 
 });
 
-describe("ArrayUnique", function() {
+describe("ArrayUnique", function () {
 
     const validValues = [["world", "hello", "superman"], ["world", "superman", "hello"], ["superman", "world", "hello"]];
     const invalidValues: any[] = [null, undefined, ["world", "hello", "hello"], ["world", "hello", "world"], ["1", "1", "1"]];
@@ -2999,6 +3000,43 @@ describe("ArrayUnique", function() {
         someProperty: string[];
     }
 
+    it("should not fail if validator.validate said that its valid", function (done) {
+        checkValidValues(new MyClass(), validValues, done);
+    });
+
+    it("should fail if validator.validate said that its invalid", function (done) {
+        checkInvalidValues(new MyClass(), invalidValues, done);
+    });
+
+    it("should not fail if method in validator said that its valid", function () {
+        validValues.forEach(value => validator.arrayUnique(value).should.be.true);
+    });
+
+    it("should fail if method in validator said that its invalid", function () {
+        invalidValues.forEach(value => validator.arrayUnique(value).should.be.false);
+    });
+
+    it("should return error object with proper data", function (done) {
+        const validationType = "arrayUnique";
+        const message = "All someProperty's elements must be unique";
+        checkReturnedError(new MyClass(), invalidValues, validationType, message, done);
+    });
+
+});
+
+describe("isInstance", function () {
+
+    class MySubClass { }
+    class WrongSubClass {}
+
+    class MyClass {
+        @IsInstance(MySubClass)
+        someProperty: MySubClass;
+    }
+
+    const validValues = [new MySubClass()];
+    const invalidValues = [null, undefined, 15, "something", new WrongSubClass(), () => <any>null];
+
     it("should not fail if validator.validate said that its valid", function(done) {
         checkValidValues(new MyClass(), validValues, done);
     });
@@ -3008,16 +3046,16 @@ describe("ArrayUnique", function() {
     });
 
     it("should not fail if method in validator said that its valid", function() {
-        validValues.forEach(value => validator.arrayUnique(value).should.be.true);
+        validValues.forEach(value => validator.isInstance(value, MySubClass).should.be.true);
     });
 
     it("should fail if method in validator said that its invalid", function() {
-        invalidValues.forEach(value => validator.arrayUnique(value).should.be.false);
+        invalidValues.forEach(value => validator.isInstance(value, MySubClass).should.be.false);
     });
 
     it("should return error object with proper data", function(done) {
-        const validationType = "arrayUnique";
-        const message = "All someProperty's elements must be unique";
+        const validationType = "isInstance";
+        const message = "someProperty must be an instance of MySubClass";
         checkReturnedError(new MyClass(), invalidValues, validationType, message, done);
     });