feat: add always & strictGroups to ValidationOptions (#680)

Author: blaugold

src/metadata/MetadataStorage.ts

@@ -63,12 +63,38 @@ export class MetadataStorage {
   getTargetValidationMetadatas(
     targetConstructor: Function,
     targetSchema: string,
+    always: boolean,
+    strictGroups: boolean,
     groups?: string[]
   ): ValidationMetadata[] {
+    const includeMetadataBecauseOfAlwaysOption = (metadata: ValidationMetadata): boolean => {
+      // `metadata.always` overrides global default.
+      if (typeof metadata.always !== 'undefined') return metadata.always;
+
+      // `metadata.groups` overrides global default.
+      if (metadata.groups && metadata.groups.length) return false;
+
+      // Use global default.
+      return always;
+    };
+
+    const excludeMetadataBecauseOfStrictGroupsOption = (metadata: ValidationMetadata): boolean => {
+      if (strictGroups) {
+        // Validation is not using groups.
+        if (!groups || !groups.length) {
+          // `metadata.groups` has at least one group.
+          if (metadata.groups && metadata.groups.length) return true;
+        }
+      }
+
+      return false;
+    };
+
     // get directly related to a target metadatas
     const originalMetadatas = this.validationMetadatas.filter(metadata => {
       if (metadata.target !== targetConstructor && metadata.target !== targetSchema) return false;
-      if (metadata.always) return true;
+      if (includeMetadataBecauseOfAlwaysOption(metadata)) return true;
+      if (excludeMetadataBecauseOfStrictGroupsOption(metadata)) return false;
       if (groups && groups.length > 0)
         return metadata.groups && !!metadata.groups.find(group => groups.indexOf(group) !== -1);
 
@@ -82,7 +108,8 @@ export class MetadataStorage {
       if (metadata.target === targetConstructor) return false;
       if (metadata.target instanceof Function && !(targetConstructor.prototype instanceof metadata.target))
         return false;
-      if (metadata.always) return true;
+      if (includeMetadataBecauseOfAlwaysOption(metadata)) return true;
+      if (excludeMetadataBecauseOfStrictGroupsOption(metadata)) return false;
       if (groups && groups.length > 0)
         return metadata.groups && !!metadata.groups.find(group => groups.indexOf(group) !== -1);
 

src/metadata/ValidationMetadata.ts

@@ -47,7 +47,7 @@ export class ValidationMetadata {
   /**
    * Indicates if validation must be performed always, no matter of validation groups used.
    */
-  always: boolean = false;
+  always?: boolean;
 
   /**
    * Specifies if validated value is an array and each of its item must be validated.

src/validation/ValidationExecutor.ts

@@ -50,7 +50,16 @@ export class ValidationExecutor {
     }
 
     const groups = this.validatorOptions ? this.validatorOptions.groups : undefined;
-    const targetMetadatas = this.metadataStorage.getTargetValidationMetadatas(object.constructor, targetSchema, groups);
+    const strictGroups = (this.validatorOptions && this.validatorOptions.strictGroups) || false;
+    const always = (this.validatorOptions && this.validatorOptions.always) || false;
+
+    const targetMetadatas = this.metadataStorage.getTargetValidationMetadatas(
+      object.constructor,
+      targetSchema,
+      always,
+      strictGroups,
+      groups
+    );
     const groupedMetadatas = this.metadataStorage.groupByPropertyName(targetMetadatas);
 
     if (this.validatorOptions && this.validatorOptions.forbidUnknownValues && !targetMetadatas.length) {

src/validation/ValidatorOptions.ts

@@ -34,6 +34,17 @@ export interface ValidatorOptions {
    */
   groups?: string[];
 
+  /**
+   * Set default for `always` option of decorators. Default can be overridden in decorator options.
+   */
+  always?: boolean;
+
+  /**
+   * If [groups]{@link ValidatorOptions#groups} is not given or is empty,
+   * ignore decorators with at least one group.
+   */
+  strictGroups?: boolean;
+
   /**
    * If set to true, the validation will not use default messages.
    * Error message always will be undefined if its not explicitly set.

test/functional/validation-options.spec.ts

@@ -6,6 +6,8 @@ import {
   Validate,
   ValidateNested,
   ValidatorConstraint,
+  IsOptional,
+  IsNotEmpty,
 } from '../../src/decorator/decorators';
 import { Validator } from '../../src/validation/Validator';
 import {
@@ -863,6 +865,112 @@ describe('groups', () => {
     });
   });
 
+  describe('ValidationOptions.always', function () {
+    class MyClass {
+      @Contains('noOptions')
+      noOptions: string;
+
+      @Contains('groupA', {
+        groups: ['A'],
+      })
+      groupA: string;
+
+      @Contains('alwaysFalse', {
+        always: false,
+      })
+      alwaysFalse: string;
+
+      @Contains('alwaysTrue', {
+        always: true,
+      })
+      alwaysTrue: string;
+    }
+
+    const model1 = new MyClass();
+    model1.noOptions = 'XXX';
+    model1.groupA = 'groupA';
+    model1.alwaysFalse = 'alwaysFalse';
+    model1.alwaysTrue = 'alwaysTrue';
+
+    const model2 = new MyClass();
+    model2.noOptions = 'noOptions';
+    model2.groupA = 'XXX';
+    model2.alwaysFalse = 'alwaysFalse';
+    model2.alwaysTrue = 'alwaysTrue';
+
+    const model3 = new MyClass();
+    model3.noOptions = 'noOptions';
+    model3.groupA = 'groupA';
+    model3.alwaysFalse = 'XXX';
+    model3.alwaysTrue = 'alwaysTrue';
+
+    const model4 = new MyClass();
+    model4.noOptions = 'noOptions';
+    model4.groupA = 'groupA';
+    model4.alwaysFalse = 'alwaysFalse';
+    model4.alwaysTrue = 'XXX';
+
+    it('should validate decorator without options', function () {
+      return validator.validate(model1, { always: true, groups: ['A'] }).then(errors => {
+        expect(errors).toHaveLength(1);
+      });
+    });
+
+    it('should not validate decorator with groups if validating without matching groups', function () {
+      return validator.validate(model2, { always: true, groups: ['B'] }).then(errors => {
+        expect(errors).toHaveLength(0);
+      });
+    });
+
+    it('should not validate decorator with always set to false', function () {
+      return validator.validate(model3, { always: true, groups: ['A'] }).then(errors => {
+        expect(errors).toHaveLength(0);
+      });
+    });
+
+    it('should validate decorator with always set to true', function () {
+      return validator.validate(model4, { always: true, groups: ['A'] }).then(errors => {
+        expect(errors).toHaveLength(1);
+      });
+    });
+  });
+
+  describe('strictGroups', function () {
+    class MyClass {
+      @Contains('hello', {
+        groups: ['A'],
+      })
+      title: string;
+    }
+
+    const model1 = new MyClass();
+
+    it('should ignore decorators with groups if validating without groups', function () {
+      return validator.validate(model1, { strictGroups: true }).then(errors => {
+        expect(errors).toHaveLength(0);
+      });
+    });
+
+    it('should ignore decorators with groups if validating with empty groups array', function () {
+      return validator.validate(model1, { strictGroups: true, groups: [] }).then(errors => {
+        expect(errors).toHaveLength(0);
+      });
+    });
+
+    it('should include decorators with groups if validating with matching groups', function () {
+      return validator.validate(model1, { strictGroups: true, groups: ['A'] }).then(errors => {
+        expect(errors).toHaveLength(1);
+        expectTitleContains(errors[0]);
+      });
+    });
+
+    it('should not include decorators with groups if validating with different groups', function () {
+      return validator.validate(model1, { strictGroups: true, groups: ['B'] }).then(errors => {
+        expect(errors).toHaveLength(0);
+      });
+    });
+  });
+
   describe('always', () => {
     class MyClass {
       @Contains('hello', {