Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

fix: apply custom constraint class validation to each item in the array #295

Merged
merged 4 commits into from
Oct 1, 2019
Merged

fix: apply custom constraint class validation to each item in the array #295

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
e61ef14
fix: apply custom constraint class validation to each item in the array
zd333 Dec 10, 2018
22351ed
Revert auto-formatting updates
Sep 27, 2019
fa0d045
Revert auto-formatting updates
Sep 27, 2019
5e0ee74
Fix typo in validation options unit test naming
Sep 27, 2019
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
54 changes: 44 additions & 10 deletions src/validation/ValidationExecutor.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -258,20 +258,54 @@ export class ValidationExecutor {
value: value,
constraints: metadata.constraints
};
const validatedValue = customConstraintMetadata.instance.validate(value, validationArguments);
if (isPromise(validatedValue)) {
const promise = validatedValue.then(isValid => {
if (!isValid) {

if (!metadata.each || !(value instanceof Array)) {
const validatedValue = customConstraintMetadata.instance.validate(value, validationArguments);
if (isPromise(validatedValue)) {
const promise = validatedValue.then(isValid => {
if (!isValid) {
const [type, message] = this.createValidationError(object, value, metadata, customConstraintMetadata);
errorMap[type] = message;
}
});
this.awaitingPromises.push(promise);
} else {
if (!validatedValue) {
const [type, message] = this.createValidationError(object, value, metadata, customConstraintMetadata);
errorMap[type] = message;
}
});
this.awaitingPromises.push(promise);
} else {
if (!validatedValue) {
const [type, message] = this.createValidationError(object, value, metadata, customConstraintMetadata);
errorMap[type] = message;
}

return;
}

// Validation needs to be applied to each array item
const validatedSubValues = value.map((subValue: any) => customConstraintMetadata.instance.validate(subValue, validationArguments));
const validationIsAsync = validatedSubValues
.some((validatedSubValue: boolean | Promise<boolean>) => isPromise(validatedSubValue));

if (validationIsAsync) {
// Wrap plain values (if any) in promises, so that all are async
const asyncValidatedSubValues = validatedSubValues
.map((validatedSubValue: boolean | Promise<boolean>) => isPromise(validatedSubValue) ? validatedSubValue : Promise.resolve(validatedSubValue));
const asyncValidationIsFinishedPromise = Promise.all(asyncValidatedSubValues)
.then((flatValidatedValues: boolean[]) => {
const validationResult = flatValidatedValues.every((isValid: boolean) => isValid);
if (!validationResult) {
const [type, message] = this.createValidationError(object, value, metadata, customConstraintMetadata);
errorMap[type] = message;
}
});

this.awaitingPromises.push(asyncValidationIsFinishedPromise);

return;
}

const validationResult = validatedSubValues.every((isValid: boolean) => isValid);
if (!validationResult) {
const [type, message] = this.createValidationError(object, value, metadata, customConstraintMetadata);
errorMap[type] = message;
}
});
});
Expand Down
110 changes: 107 additions & 3 deletions test/functional/validation-options.spec.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,9 +1,9 @@
import "es6-shim";
import {Contains, Matches, MinLength, ValidateNested} from "../../src/decorator/decorators";
import {Contains, Matches, MinLength, ValidateNested, ValidatorConstraint, Validate } from "../../src/decorator/decorators";
import {Validator} from "../../src/validation/Validator";
import {ValidationError} from "../../src";
import {ValidationError, ValidatorConstraintInterface} from "../../src";

import {should, use } from "chai";
import {should, use} from "chai";

import * as chaiAsPromised from "chai-as-promised";

Expand Down Expand Up @@ -163,6 +163,110 @@ describe("validation options", function() {
});
});

it("should apply validation via custom constraint class to array items (but not array itself)", function() {
@ValidatorConstraint({ name: "customIsNotArrayConstraint", async: false })
class CustomIsNotArrayConstraint implements ValidatorConstraintInterface {
validate(value: any) {
return !(value instanceof Array);
}
}

class MyClass {
@Validate(CustomIsNotArrayConstraint, {
each: true
})
someArrayOfNonArrayItems: string[];
}

const model = new MyClass();
model.someArrayOfNonArrayItems = ["not array", "also not array", "not array at all"];
return validator.validate(model).then(errors => {
errors.length.should.be.equal(0);
});
});

it("should apply validation via custom constraint class with synchronous logic to each item in the array", function() {
@ValidatorConstraint({ name: "customContainsHelloConstraint", async: false })
class CustomContainsHelloConstraint implements ValidatorConstraintInterface {
validate(value: any) {
return !(value instanceof Array) && String(value).includes("hello");
}
}

class MyClass {
@Validate(CustomContainsHelloConstraint, {
each: true
})
someProperty: string[];
}

const model = new MyClass();
model.someProperty = ["hell no world", "hello", "helo world", "hello world", "hello dear friend"];
return validator.validate(model).then(errors => {
errors.length.should.be.equal(1);
errors[0].constraints.should.be.eql({ customContainsHelloConstraint: "" });
errors[0].value.should.be.equal(model.someProperty);
errors[0].target.should.be.equal(model);
errors[0].property.should.be.equal("someProperty");
});
});

it("should apply validation via custom constraint class with async logic to each item in the array", function() {
@ValidatorConstraint({ name: "customAsyncContainsHelloConstraint", async: true })
class CustomAsyncContainsHelloConstraint implements ValidatorConstraintInterface {
validate(value: any) {
const isValid = !(value instanceof Array) && String(value).includes("hello");

return Promise.resolve(isValid);
}
}

class MyClass {
@Validate(CustomAsyncContainsHelloConstraint, {
each: true
})
someProperty: string[];
}

const model = new MyClass();
model.someProperty = ["hell no world", "hello", "helo world", "hello world", "hello dear friend"];
return validator.validate(model).then(errors => {
errors.length.should.be.equal(1);
errors[0].constraints.should.be.eql({ customAsyncContainsHelloConstraint: "" });
errors[0].value.should.be.equal(model.someProperty);
errors[0].target.should.be.equal(model);
errors[0].property.should.be.equal("someProperty");
});
});

it("should apply validation via custom constraint class with mixed (synchronous + async) logic to each item in the array", function() {
@ValidatorConstraint({ name: "customMixedContainsHelloConstraint", async: true })
class CustomMixedContainsHelloConstraint implements ValidatorConstraintInterface {
validate(value: any) {
const isValid = !(value instanceof Array) && String(value).includes("hello");

return isValid ? isValid : Promise.resolve(isValid);
}
}

class MyClass {
@Validate(CustomMixedContainsHelloConstraint, {
each: true
})
someProperty: string[];
}

const model = new MyClass();
model.someProperty = ["hell no world", "hello", "helo world", "hello world", "hello dear friend"];
return validator.validate(model).then(errors => {
errors.length.should.be.equal(1);
errors[0].constraints.should.be.eql({ customMixedContainsHelloConstraint: "" });
errors[0].value.should.be.equal(model.someProperty);
errors[0].target.should.be.equal(model);
errors[0].property.should.be.equal("someProperty");
});
});

});

describe("groups", function() {
Expand Down