feat: add IsMutuallyExclusiveWith decorator

README.md

@@ -956,6 +956,7 @@ isBoolean(value);
 | `@ArrayUnique(identifier?: (o) => any)`                | Checks if all array's values are unique. Comparison for objects is reference-based. Optional function can be speciefied which return value will be used for the comparsion.                           |
 | **Object validation decorators**                       |
 | `@IsInstance(value: any)`                              | Checks if the property is an instance of the passed value.                                                                                                                                            |
+| `@IsMutuallyExclusiveWith(property: string)`           | Checks if the property and the given related property are not both provided at the same time.                                                                                                         |
 | **Other decorators**                                   |                                                                                                                                                                                                       |
 | `@Allow()`                                             | Prevent stripping off the property when no other constraint is specified for it.                                                                                                                      |
 

src/decorator/common/IsMutuallyExclusiveWith.ts

@@ -0,0 +1,39 @@
+import { ValidationArguments } from '../../validation/ValidationArguments';
+import { ValidationOptions } from '../ValidationOptions';
+import { ValidateBy, buildMessage } from './ValidateBy';
+
+export const IS_MUTUALLY_EXCLUSIVE_WITH = 'isMutuallyExclusiveWith';
+
+/**
+ * Checks if the value and the value of the related property are not both present at the same time.
+ */
+export function isMutuallyExclusiveWith(
+  value: unknown,
+  relatedPropertyName: string,
+  args?: ValidationArguments
+): boolean {
+  const relatedValue = (args?.object as any)?.[relatedPropertyName];
+  const isValuePresent = value !== undefined && value !== null;
+  const isRelatedPresent = relatedValue !== undefined && relatedValue !== null;
+  return !(isValuePresent && isRelatedPresent);
+}
+
+/**
+ * Checks if the property and the given related property are not both provided at the same time.
+ */
+export function IsMutuallyExclusiveWith(property: string, validationOptions?: ValidationOptions): PropertyDecorator {
+  return ValidateBy(
+    {
+      name: IS_MUTUALLY_EXCLUSIVE_WITH,
+      constraints: [property],
+      validator: {
+        validate: (value, args): boolean => isMutuallyExclusiveWith(value, args?.constraints[0], args),
+        defaultMessage: buildMessage(
+          eachPrefix => eachPrefix + `$property and ${property} cannot both be provided`,
+          validationOptions
+        ),
+      },
+    },
+    validationOptions
+  );
+}

src/decorator/decorators.ts

@@ -23,6 +23,7 @@ export * from './common/IsEmpty';
 export * from './common/IsNotEmpty';
 export * from './common/IsIn';
 export * from './common/IsNotIn';
+export * from './common/IsMutuallyExclusiveWith';
 
 // -------------------------------------------------------------------------
 // Number checkers

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

@@ -7,6 +7,7 @@ import {
   IsNegative,
   Contains,
   Equals,
+  IsMutuallyExclusiveWith,
   MinDate,
   MaxDate,
   IsAlpha,
@@ -122,6 +123,7 @@ import {
   maxLength,
   isFirebasePushId,
   equals,
+  isMutuallyExclusiveWith,
   notEquals,
   isEmpty,
   isNotEmpty,
@@ -356,6 +358,52 @@ describe('Equals', () => {
   });
 });
 
+describe('IsMutuallyExclusiveWith', () => {
+  class MyClass {
+    @IsMutuallyExclusiveWith('propertyB')
+    someProperty: string;
+
+    propertyB: string;
+  }
+
+  it('should not fail if only one property is provided', () => {
+    const model1 = new MyClass();
+    const model2 = new MyClass();
+    model2.propertyB = 'bar';
+
+    return Promise.all([checkValidValues(model1, ['foo']), checkValidValues(model2, [undefined])]);
+  });
+
+  it('should not fail if neither property is provided', () => {
+    const model = new MyClass();
+    return checkValidValues(model, [undefined]);
+  });
+
+  it('should fail if both properties are provided', () => {
+    const model = new MyClass();
+    model.propertyB = 'bar';
+
+    return checkInvalidValues(model, ['foo']);
+  });
+
+  it('should not fail if method in validator said that its valid', () => {
+    expect(isMutuallyExclusiveWith('foo', 'propertyB', { object: {} } as any)).toBeTruthy();
+  });
+
+  it('should fail if method in validator said that its invalid', () => {
+    expect(isMutuallyExclusiveWith('foo', 'propertyB', { object: { propertyB: 'bar' } } as any)).toBeFalsy();
+  });
+
+  it('should return error object with proper data', () => {
+    const model = new MyClass();
+    model.propertyB = 'bar';
+
+    const validationType = 'isMutuallyExclusiveWith';
+    const message = 'someProperty and propertyB cannot both be provided';
+    return checkReturnedError(model, ['foo'], validationType, message);
+  });
+});
+
 describe('NotEquals', () => {
   const constraint = 'Alex';
   const validValues = ['Alexxx'];