detailed/extended error messages

README.md

@@ -124,7 +124,7 @@ export interface ValidatorOptions {
     property: string; // Object's property that haven't pass validation.
     value: any; // Value that haven't pass a validation.
     constraints?: { // Constraints that failed validation with error messages.
-        [type: string]: string;
+        [type: string]: string | ExtendedMessage;
     };
     children?: ValidationError[]; // Contains all nested validation errors of the property
 }
@@ -152,6 +152,37 @@ In our case, when we validated a Post object, we have such array of ValidationEr
 ]
 ```
 
+If you want to build your own error messages (e.g. in an internationalized app), the ExtendedMessage comes into play: 
+you get back all constraint parameters:
+```typescript
+validator.validate(data, { validationError: { extendedMessage: true } });
+```
+The parameter 'detailedMessage' will cause all constraints to have an ExtendedError instead of the plain string message.
+
+So an input of this type:
+```typescript
+export class Post {
+    @MinLength(10)
+    title: string = "Hello"
+}
+```
+will yield e.g.:
+```typescript
+[{
+    target: /* post object */,
+    property: "title",
+    value: "Hello",
+    constraints: {
+        minLength: {
+            type: "minLength",
+            args: [10],
+            message: "title must be longer than or equal to 10 characters"
+        }
+    }
+}]
+```
+Together with [passing context to decorators](#passing-context-to-decorators), the error messages are fully customizable.
+
 If you don't want a `target` to be exposed in validation errors, there is a special option when you use validator:
 
 ```typescript

src/validation/ExtendedMessage.ts

@@ -0,0 +1,12 @@
+/**
+ * Contains necessary information to present good error messages to the user
+ */
+export class ExtendedMessage {
+    constructor(
+        public readonly type: string,
+        public readonly message: string,
+        public readonly args: any[]
+    ) {
+        // nop
+    }
+}

src/validation/ValidationError.ts

@@ -1,6 +1,8 @@
 /**
  * Validation error description.
  */
+import {ExtendedMessage} from "./ExtendedMessage";
+
 export class ValidationError {
 
     /**
@@ -26,7 +28,7 @@ export class ValidationError {
      * Constraints that failed validation with error messages.
      */
     constraints: {
-        [type: string]: string
+        [type: string]: string | ExtendedMessage
     };
 
     /**

src/validation/ValidationExecutor.ts

@@ -8,6 +8,7 @@ import {ValidationTypes} from "./ValidationTypes";
 import {ConstraintMetadata} from "../metadata/ConstraintMetadata";
 import {ValidationArguments} from "./ValidationArguments";
 import {ValidationUtils} from "./ValidationUtils";
+import {ExtendedMessage} from "./ExtendedMessage";
 
 /**
  * Executes validation over given object.
@@ -21,6 +22,8 @@ export class ValidationExecutor {
     awaitingPromises: Promise<any>[] = [];
     ignoreAsyncValidations: boolean = false;
 
+    private readonly validatorOptions: ValidatorOptions;
+
     // -------------------------------------------------------------------------
     // Private Properties
     // -------------------------------------------------------------------------
@@ -32,7 +35,8 @@ export class ValidationExecutor {
     // -------------------------------------------------------------------------
 
     constructor(private validator: Validator,
-                private validatorOptions?: ValidatorOptions) {
+                validatorOptions?: ValidatorOptions) {
+        this.validatorOptions = validatorOptions || {};
     }
 
     // -------------------------------------------------------------------------
@@ -50,15 +54,14 @@ export class ValidationExecutor {
             console.warn(`No metadata found. There is more than once class-validator version installed probably. You need to flatten your dependencies.`);
         }
 
-        const groups = this.validatorOptions ? this.validatorOptions.groups : undefined;
+        const groups = this.validatorOptions.groups;
         const targetMetadatas = this.metadataStorage.getTargetValidationMetadatas(object.constructor, targetSchema, groups);
         const groupedMetadatas = this.metadataStorage.groupByPropertyName(targetMetadatas);
 
-        if (this.validatorOptions && this.validatorOptions.forbidUnknownValues && !targetMetadatas.length) {
+        if (this.validatorOptions.forbidUnknownValues && !targetMetadatas.length) {
             const validationError = new ValidationError();
 
-            if (!this.validatorOptions ||
-                !this.validatorOptions.validationError ||
+            if (!this.validatorOptions.validationError ||
                 this.validatorOptions.validationError.target === undefined ||
                 this.validatorOptions.validationError.target === true)
                 validationError.target = object;
@@ -73,7 +76,7 @@ export class ValidationExecutor {
             return;
         }
 
-        if (this.validatorOptions && this.validatorOptions.whitelist)
+        if (this.validatorOptions.whitelist)
             this.whitelist(object, groupedMetadatas, validationErrors);
 
         // General validation
@@ -97,7 +100,7 @@ export class ValidationExecutor {
             // handle IS_DEFINED validation type the special way - it should work no matter skipMissingProperties is set or not
             this.defaultValidations(object, value, definedMetadatas, validationError.constraints);
 
-            if ((value === null || value === undefined) && this.validatorOptions && this.validatorOptions.skipMissingProperties === true) {
+            if ((value === null || value === undefined) && this.validatorOptions.skipMissingProperties === true) {
                 return;
             }
 
@@ -122,7 +125,7 @@ export class ValidationExecutor {
 
         if (notAllowedProperties.length > 0) {
 
-            if (this.validatorOptions && this.validatorOptions.forbidNonWhitelisted) {
+            if (this.validatorOptions.forbidNonWhitelisted) {
 
                 // throw errors
                 notAllowedProperties.forEach(property => {
@@ -166,14 +169,12 @@ export class ValidationExecutor {
     private generateValidationError(object: Object, value: any, propertyName: string) {
         const validationError = new ValidationError();
 
-        if (!this.validatorOptions ||
-            !this.validatorOptions.validationError ||
+        if (!this.validatorOptions.validationError ||
             this.validatorOptions.validationError.target === undefined ||
             this.validatorOptions.validationError.target === true)
             validationError.target = object;
 
-        if (!this.validatorOptions ||
-            !this.validatorOptions.validationError ||
+        if (!this.validatorOptions.validationError ||
             this.validatorOptions.validationError.value === undefined ||
             this.validatorOptions.validationError.value === true)
             validationError.value = value;
@@ -193,10 +194,19 @@ export class ValidationExecutor {
             .reduce((resultA, resultB) => resultA && resultB, true);
     }
 
+    private buildExtendedMessage(metadata: ValidationMetadata, message: string, customConstraintMetadata?: ConstraintMetadata): string | ExtendedMessage {
+        if (this.validatorOptions.validationError && this.validatorOptions.validationError.extendedMessage) {
+            const type = this.getConstraintType(metadata, customConstraintMetadata);
+            return new ExtendedMessage(type, message, metadata.constraints || []);
+        } else {
+            return message;
+        }
+    }
+
     private defaultValidations(object: Object,
                                value: any,
                                metadatas: ValidationMetadata[],
-                               errorMap: { [key: string]: string }) {
+                               errorMap: { [key: string]: string | ExtendedMessage }) {
         return metadatas
             .filter(metadata => {
                 if (metadata.each) {
@@ -210,14 +220,14 @@ export class ValidationExecutor {
             })
             .forEach(metadata => {
                 const [key, message] = this.createValidationError(object, value, metadata);
-                errorMap[key] = message;
+                errorMap[key] = this.buildExtendedMessage(metadata, message);
             });
     }
 
     private customValidations(object: Object,
                               value: any,
                               metadatas: ValidationMetadata[],
-                              errorMap: { [key: string]: string }) {
+                              errorMap: { [key: string]: string | ExtendedMessage }) {
 
         metadatas.forEach(metadata => {
             getFromContainer(MetadataStorage)
@@ -238,14 +248,14 @@ export class ValidationExecutor {
                         const promise = validatedValue.then(isValid => {
                             if (!isValid) {
                                 const [type, message] = this.createValidationError(object, value, metadata, customConstraintMetadata);
-                                errorMap[type] = message;
+                                errorMap[type] = this.buildExtendedMessage(metadata, message, customConstraintMetadata);
                             }
                         });
                         this.awaitingPromises.push(promise);
                     } else {
                         if (!validatedValue) {
                             const [type, message] = this.createValidationError(object, value, metadata, customConstraintMetadata);
-                            errorMap[type] = message;
+                            errorMap[type] = this.buildExtendedMessage(metadata, message, customConstraintMetadata);
                         }
                     }
                 });
@@ -324,8 +334,7 @@ export class ValidationExecutor {
         };
 
         let message = metadata.message;
-        if (!metadata.message &&
-            (!this.validatorOptions || (this.validatorOptions && !this.validatorOptions.dismissDefaultMessages))) {
+        if (!metadata.message && !this.validatorOptions.dismissDefaultMessages) {
             if (customValidatorMetadata && customValidatorMetadata.instance.defaultMessage instanceof Function) {
                 message = customValidatorMetadata.instance.defaultMessage(validationArguments);
             }

src/validation/ValidatorOptions.ts

@@ -46,11 +46,16 @@ export interface ValidatorOptions {
          */
         value?: boolean;
 
+        /**
+         * use ExtendedMessage instead of sring message in ValidationError
+         */
+         extendedMessage?: boolean;
     };
 
     /**
      * Settings true will cause fail validation of unknown objects.
      */
     forbidUnknownValues?: boolean;
 
+
 }

test/functional/ExtendedMessage.spec.ts

@@ -0,0 +1,144 @@
+import "es6-shim";
+import {
+    ValidationArguments,
+    Validator,
+    ValidatorConstraint,
+    ValidatorConstraintInterface, ValidatorOptions
+} from "../../src";
+import {MinLength} from "../../src";
+
+import {should, use} from "chai";
+
+import * as chaiAsPromised from "chai-as-promised";
+import {Validate} from "../../src";
+
+should();
+use(chaiAsPromised);
+
+const validator = new Validator();
+const DETAILS_ENABLED: ValidatorOptions = {validationError: {extendedMessage: true}};
+
+class StandardValidation {
+    @MinLength(10)
+    public readonly text: string = "invalid";
+}
+
+@ValidatorConstraint({name: "customText", async: false})
+export class CustomTextLength implements ValidatorConstraintInterface {
+
+    validate(text: string, args: ValidationArguments) {
+        return text.length > (args.constraints || [10])[0];
+    }
+
+    defaultMessage(args: ValidationArguments) { // here you can provide default error message if validation failed
+        return "Text ($value) is too short or too long: " + (args.constraints || [10])[0];
+    }
+
+}
+
+describe("ExtendedMessage", () => {
+
+    describe("disabled", () => {
+        it("validates with simple message with default options", () => {
+            // given
+            const fixture = new StandardValidation();
+            // when
+            const errors = validator.validateSync(fixture);
+            // then
+            errors[0].constraints.should.be.eql({minLength: "text must be longer than or equal to 10 characters"});
+        });
+
+        it("validates with simple message with option disabled", () => {
+            // given
+            const fixture = new StandardValidation();
+            // when
+            const errors = validator.validateSync(fixture, {validationError: {extendedMessage: false}});
+            // then
+            errors[0].constraints.should.be.eql({minLength: "text must be longer than or equal to 10 characters"});
+        });
+
+    });
+
+    describe("with standard validations", () => {
+        it("validates with extended message", () => {
+            // given
+            const fixture = new StandardValidation();
+            // when
+            const errors = validator.validateSync(fixture, DETAILS_ENABLED);
+            // then
+            errors[0].constraints.should.be.eql({
+                minLength: {
+                    type: "minLength",
+                    args: [10],
+                    message: "text must be longer than or equal to 10 characters"
+                }
+            });
+        });
+    });
+
+    describe("with custom validator", () => {
+        it("validates with extended message (no arguments)", () => {
+            // given
+            class CustomValidation {
+                @Validate(CustomTextLength)
+                public readonly text: string = "invalid";
+            }
+            const fixture = new CustomValidation();
+
+            // when
+            const errors = validator.validateSync(fixture, DETAILS_ENABLED);
+
+            // then
+            errors[0].constraints.should.be.eql({
+                customText: {
+                    type: "customText",
+                    args: [],
+                    message: "Text (invalid) is too short or too long: 10"
+                }
+            });
+        });
+
+        it("validates with extended message (with arguments)", () => {
+            // given
+            class CustomValidation {
+                @Validate(CustomTextLength, [20])
+                public readonly text: string = "invalid";
+            }
+            const fixture = new CustomValidation();
+
+            // when
+            const errors = validator.validateSync(fixture, DETAILS_ENABLED);
+
+            // then
+            errors[0].constraints.should.be.eql({
+                customText: {
+                    type: "customText",
+                    args: [20],
+                    message: "Text (invalid) is too short or too long: 20"
+                }
+            });
+        });
+
+        it("validates with extended message (handles 'undefined' argument)", () => {
+            // given
+            class CustomValidation {
+                @Validate(CustomTextLength, [undefined])
+                public readonly text: string = "invalid";
+            }
+            const fixture = new CustomValidation();
+
+            // when
+            const errors = validator.validateSync(fixture, DETAILS_ENABLED);
+
+            // then
+            errors[0].constraints.should.be.eql({
+                customText: {
+                    type: "customText",
+                    args: [undefined],
+                    message: "Text (invalid) is too short or too long: undefined"
+                }
+            });
+        });
+    });
+
+});