knight-validation 2.0.6 → 3.0.0

package/README.md

@@ -8,6 +8,8 @@
 
 ### Constraints for single properties
 
+Add constraints to single properties.
+
 ```typescript
 import { Required, TypeOf, Unique, Validator } from 'knight-validation'
 
@@ -27,20 +29,39 @@ class UserValidator extends Validator {
 
 ### Constraints for multiple properties
 
+You can also use any constraint on multiple properties at once.
+
 ```typescript
-import { Validator } from 'knight-validation'
+import { Required, Validator } from 'knight-validation'
 
 class UserValidator extends Validator {
-  constructor(userDb: UserDb) {
+  constructor() {
     super()
-    
-    this.add(['firstName', 'lastName'], 'Different', async (user: User) => {
-      if (user.firstName == user.lastName) {
-        // You do not need to set the constraint name nor the properties on the misfit.
-        // Those will be set automatically.
-        return new Misfit
-      }
-    })
+
+    this.add(['fistName', 'lastName', 'email'], new Required)
+  }
+}
+```
+
+The given constraint is being applied to every given property. If one property is not fitting the constraint, the whole constraint will be regarded as not fulfilled.
+
+Every constraint offers a set of parameters with which you can fine tune its behavior.
+
+```typescript
+import { Required, Validator } from 'knight-validation'
+
+class UserValidator extends Validator {
+  constructor() {
+    super()
+
+    // Exactly one property is required
+    this.add(['fistName', 'lastName', 'email'], new Required({ exactFits: 1 }))
+
+    // At least two properties are required
+    this.add(['fistName', 'lastName', 'email'], new Required({ minFits: 2 }))
+
+    // At most two properties are required
+    this.add(['fistName', 'lastName', 'email'], new Required({ maxFits: 2 }))
   }
 }
 ```
@@ -54,7 +75,7 @@ new Absent
 // Check if a number is greater and/or lesser than a given number
 new Bounds({ greaterThan: 0, lesserThan: 10 })
 // Check if a number is greater and/or lesser than or equal a given number
-new Bounds({ greaterThanEqual: 0, lesserThanqEqual: 10 })
+new Bounds({ greaterThanEqual: 0, lesserThanEqual: 10 })
 
 // Check a property's value equals one of the three given strings
 new Enum('Moni', 'Lisa', 'Anna')
@@ -66,16 +87,16 @@ new Exists(async (user: User) => {
   // Return true if your exists condition is met
 })
 
-// Check if the length of a string has a minmum and/or maximum length
+// Check if the length of a string or array has a minmum and/or maximum length
 new Length({ min: 5, max: 10})
-// Check if the length of a string has exactly a specific length
+// Check if the length of a string or array has exactly a specific length
 new Length({ exact: 5 })
 
-// Check if a property is there
+// Check that a property is not undefined
 new Required
 
-// Check if a property's value is of the given JavaScript type
-new TypeOf('number')
+// Check if a property's value is one of the given JavaScript type
+new TypeOf('number', null)
 // Check if a property's value is an instance if the given class
 new TypeOf(Date)
 
@@ -99,7 +120,7 @@ let misfits = validator.validate(user)
 misfits.length == 1
 ```
 
-A misfit contains the following informations by default.
+A misfit contains the following information.
 
 ```typescript
 // The name of the constraint that resulted in the misfit
@@ -115,9 +136,24 @@ misfit.values
 misift.message == 'The property email is required.'
 ```
 
+The optional `message` needs to be provided by your application, it is not part of this package.
+
+Every misfit has a `values` property which holds an object containing contextual information specific to the constraint that created the misfit. Every misfit that is provided in this package, extends the interface `ConstraintMisfitValues` to define the appearance of the `values` object. 
+
+```typescript
+interface ConstraintMisfitValues {
+  minFits?: number
+  maxFits?: number
+  exactFits?: number
+  misfits?: Misfit[]
+}
+```
+
+Its properties come into play if the misfit was applied to multiple properties. The `misfits` property references an array of misfits that were found when the constraint was checked on each property individually.
+
 #### Check only what is there
 
-You can validate only what is there. This means any constraint becomes optional.
+You can validate only what is there. This means, every constraint is only applied when the value of a property is not `undefined`. This is useful if you want to work with partial objects for updating purposes.
 
 ```typescript
 let user = new User
@@ -130,6 +166,8 @@ misfits.length == 0 // There are no misfits even though the email property is re
 
 ### Constraints that are only checked if a condition is met
 
+You can provide a condition which is evaluated before the constraint is being checked. If the condition is not met, the constraint will not be checked.
+
 ```typescript
 import { Required, Validator } from 'knight-validation'
 
@@ -181,15 +219,47 @@ validator.add(['firstName', 'lastName'], 'Different', async (user: User) => {
 })
 ```
 
-In the case the misfit involves exactly one property, its corresponding validation function receives the value of that one property as a parameter. In the case the misfit involves more than one property, the corresponding validation function receives the whole object that is being validated, so that all of the involved properties can be accessed.
+In the case the misfit involves exactly one property, its corresponding validation function receives the value of that one property as a parameter. In the case the misfit involves more than one property, the corresponding validation function receives the whole object that is being validated plus the properties that are to be involved in the check. That way, the individual properties can be accessed and involved in the check.
 
 ### Custom constraints as classes
 
 If you want to reuse a constraint over and over again, create a new class for it.
 
+```typescript
+import { Constraint, ConstraintMisfitValues } from 'knight-validation'
+
+// You need to extend from the default ConstraintMisfitValues since it provides 
+// the properties being used when the constraint is being applied to multiple properties
+export interface OnlyGermanMailsMisfitValues extends ConstraintMisfitValues {
+  actualTld?: string
+}
+
+export class OnlyGermanMailsConstraint extends Constraint<string, OnlyGermanMailsMisfitValues> {
+
+validate(email: string): Promise<Misfit<OnlyGermanMailsMisfitValues>|null> {
+    if (! email.endsWith('.de')) {
+      let misfit = new Misfit<OnlyGermanMailsMisfitValues>
+      
+      misfit.values = {
+        actualTld: email.split('.').slice(-1)[0]
+      }
+
+      // You do not need to set the constraint name nor the property on the misfit.
+      // Those will be set automatically.
+
+      return new Misfit
+    }
+  }
+}
+```
+
+If you want to define specific behavior for the case that the constraint is being used to validate multiple properties instead of only one, then overwrite the method `validateMultipleProperties`.
+
 ```typescript
 import { Constraint } from 'knight-validation'
 
+// You do not need to extend the default ConstraintMisfitValues since we are overriding the 
+// method that defines the behavior when the misfit is being used on multiple properties
 export interface DifferentMisfitValues {
   firstName: string
   lastName: string
@@ -197,22 +267,21 @@ export interface DifferentMisfitValues {
 
 export class Different extends Constraint<User, DifferentMisfitValues> {
 
-  // Override the abstract method validate
-  validate(user: User): Promise<Misfit<DifferentMisfitValues>|null> {
+  validateMultipleProperties(object: any, properties: string[]): Promise<Misfit<DifferentMisfitValues>|null> {
   if (user.firstName == user.lastName) {
     let misfit = new Misfit<DifferentMisfitValues>
 
-    // You do not need to set the constraint name nor the properties on the misfit.
-    // Those will be set automatically.
-    
     misfit.values = {
       firstName: user.firstName,
       lastName: user.lastName
     }
 
+    // You do not need to set the constraint name nor the properties on the misfit.
+    // Those will be set automatically.
+    
     return misfit
   }
 }
 ```
 
-You need to pay attention to the parameter of the validate method. In the case your constraint is assigned to a single property, that parameter will have the value of the mentioned property. In the case your constraint is assigned to an array of properties, that parameter will have the complete object as its value which ought to contain the mentioned properties.
+In the `Constraint` super class, the method `validateMultipleProperties` is being implemented with a useful default behavior. It iterates through every property and uses the `validate` method to check each property individually, while also offering the parameters `exactFits`, `minFits` and `maxFits` to adjust its behavior.

package/lib/index.d.ts

@@ -7,7 +7,5 @@ export * from './lib/constraints/Length';
 export * from './lib/constraints/Required';
 export * from './lib/constraints/TypeOf';
 export * from './lib/constraints/Unique';
-export * from './lib/Misfit';
-export * from './lib/MisfitsError';
-export * from './lib/QuickConstraint';
+export * from './lib/constraints/QuickConstraint';
 export * from './lib/Validator';

package/lib/index.js

@@ -23,7 +23,5 @@ __exportStar(require("./lib/constraints/Length"), exports);
 __exportStar(require("./lib/constraints/Required"), exports);
 __exportStar(require("./lib/constraints/TypeOf"), exports);
 __exportStar(require("./lib/constraints/Unique"), exports);
-__exportStar(require("./lib/Misfit"), exports);
-__exportStar(require("./lib/MisfitsError"), exports);
-__exportStar(require("./lib/QuickConstraint"), exports);
+__exportStar(require("./lib/constraints/QuickConstraint"), exports);
 __exportStar(require("./lib/Validator"), exports);

package/lib/lib/Constraint.d.ts

@@ -1,5 +1,15 @@
-import { Misfit } from './Misfit';
-export declare abstract class Constraint<T = any, MisfitValuesType = any> {
+import { Misfit } from 'knight-misfit';
+export interface ConstraintMisfitValues {
+    minFits?: number;
+    maxFits?: number;
+    exactFits?: number;
+    misfits?: Misfit[];
+}
+export declare abstract class Constraint<T = any, MisfitValuesType = ConstraintMisfitValues> {
     name: string;
-    abstract validate(value: T): Promise<Misfit<MisfitValuesType> | null>;
+    minFits?: number;
+    maxFits?: number;
+    exactFits?: number;
+    validate(value: T): Promise<Misfit<MisfitValuesType> | null>;
+    validateMultipleProperties(object: any, properties: string[]): Promise<Misfit<MisfitValuesType> | null>;
 }

package/lib/lib/Constraint.js

@@ -1,9 +1,88 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Constraint = void 0;
+const knight_misfit_1 = require("knight-misfit");
+const DotNotation_1 = require("./DotNotation");
 class Constraint {
     constructor() {
         this.name = this.constructor.name;
     }
+    validate(value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return null;
+        });
+    }
+    validateMultipleProperties(object, properties) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let misfits = [];
+            for (let property of properties) {
+                let dotNotification = new DotNotation_1.DotNotation(property);
+                let value = dotNotification.get(object);
+                let misfit = yield this.validate(value);
+                if (misfit != null) {
+                    misfits.push(misfit);
+                }
+            }
+            let fits = properties.length - misfits.length;
+            if (this.exactFits != undefined) {
+                if (fits != this.exactFits) {
+                    return new knight_misfit_1.Misfit(this.name + 'ExactFits', undefined, {
+                        atLeastFits: this.minFits,
+                        atMostFits: this.maxFits,
+                        exactFits: this.exactFits,
+                        misfits: misfits
+                    });
+                }
+            }
+            else if (this.minFits != undefined && this.maxFits != undefined) {
+                if (fits < this.minFits || fits > this.maxFits) {
+                    return new knight_misfit_1.Misfit(this.name + 'MinAndMaxFits', undefined, {
+                        atLeastFits: this.minFits,
+                        atMostFits: this.maxFits,
+                        exactFits: this.exactFits,
+                        misfits: misfits
+                    });
+                }
+            }
+            else if (this.minFits != undefined) {
+                if (fits < this.minFits) {
+                    return new knight_misfit_1.Misfit(this.name + 'MinFits', undefined, {
+                        atLeastFits: this.minFits,
+                        atMostFits: this.maxFits,
+                        exactFits: this.exactFits,
+                        misfits: misfits
+                    });
+                }
+            }
+            else if (this.maxFits != undefined) {
+                if (fits > this.maxFits) {
+                    return new knight_misfit_1.Misfit(this.name + 'MaxFits', undefined, {
+                        atLeastFits: this.minFits,
+                        atMostFits: this.maxFits,
+                        exactFits: this.exactFits,
+                        misfits: misfits
+                    });
+                }
+            }
+            else if (misfits.length > 0) {
+                return new knight_misfit_1.Misfit(this.name, undefined, {
+                    atLeastFits: this.minFits,
+                    atMostFits: this.maxFits,
+                    exactFits: this.exactFits,
+                    misfits: misfits
+                });
+            }
+            return null;
+        });
+    }
 }
 exports.Constraint = Constraint;

package/lib/lib/{DotNotification.d.ts → DotNotation.d.ts}

@@ -1,4 +1,4 @@
-export declare class DotNotification {
+export declare class DotNotation {
     properties: string[];
     constructor(dotNotification: string);
     exists(obj: any): boolean;

package/lib/lib/{DotNotification.js → DotNotation.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DotNotification = void 0;
-class DotNotification {
+exports.DotNotation = void 0;
+class DotNotation {
     constructor(dotNotification) {
         this.properties = dotNotification.split('.');
     }
@@ -32,4 +32,4 @@ class DotNotification {
         return obj;
     }
 }
-exports.DotNotification = DotNotification;
+exports.DotNotation = DotNotation;

package/lib/lib/Validator.d.ts

@@ -1,5 +1,5 @@
+import { Misfit } from 'knight-misfit';
 import { Constraint } from './Constraint';
-import { Misfit } from './Misfit';
 export interface ValidatorOptions {
     checkOnlyWhatIsThere?: boolean;
 }
@@ -15,7 +15,8 @@ export declare class Validator<T = any> {
     constructor(options?: ValidatorOptions);
     add(property: string, constraint: Constraint<T>, condition?: (object: T) => Promise<boolean>): void;
     add(property: string, constraintName: string, validate: (value: any) => Promise<Misfit | null>, condition?: (object: T) => Promise<boolean>): void;
-    add(properties: string[], constraintName: string, validate: (object: T) => Promise<Misfit | null>, condition?: (object: T) => Promise<boolean>): void;
+    add(properties: string[], constraint: Constraint<T>, condition?: (object: T) => Promise<boolean>): void;
+    add(properties: string[], constraintName: string, validate: (object: T, properties: string[]) => Promise<Misfit | null>, condition?: (object: T) => Promise<boolean>): void;
     add(property: string, validator: Validator<any>, condition?: (object: T) => Promise<boolean>): void;
     add(validator: Validator<any>): void;
     validate(object: T, options?: ValidatorOptions): Promise<Misfit[]>;

package/lib/lib/Validator.js

@@ -11,8 +11,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Validator = void 0;
 const Constraint_1 = require("./Constraint");
-const DotNotification_1 = require("./DotNotification");
-const QuickConstraint_1 = require("./QuickConstraint");
+const DotNotation_1 = require("./DotNotation");
+const QuickConstraint_1 = require("./constraints/QuickConstraint");
 class Validator {
     constructor(options) {
         this.entries = [];
@@ -31,7 +31,12 @@ class Validator {
             let validator = undefined;
             let condition;
             if (typeof args[1] == 'string') {
-                constraint = new QuickConstraint_1.QuickConstraint(args[1], args[2]);
+                if (typeof args[0] == 'string') {
+                    constraint = new QuickConstraint_1.QuickConstraint(args[1], args[2], undefined);
+                }
+                else {
+                    constraint = new QuickConstraint_1.QuickConstraint(args[1], undefined, args[2]);
+                }
                 condition = args.length > 3 ? args[3] : undefined;
             }
             else if (args[1] instanceof Constraint_1.Constraint) {
@@ -74,7 +79,7 @@ class Validator {
                 }
                 let atLeastOnePropertyExists = false;
                 for (let property of entry.properties) {
-                    let dotNotification = new DotNotification_1.DotNotification(property);
+                    let dotNotification = new DotNotation_1.DotNotation(property);
                     if (dotNotification.exists(object)) {
                         atLeastOnePropertyExists = true;
                         break;
@@ -87,12 +92,12 @@ class Validator {
                     let misfit;
                     if (entry.properties.length == 1) {
                         let property = entry.properties[0];
-                        let dotNotification = new DotNotification_1.DotNotification(property);
+                        let dotNotification = new DotNotation_1.DotNotation(property);
                         let value = dotNotification.get(object);
                         misfit = yield entry.constraint.validate(value);
                     }
                     else {
-                        misfit = yield entry.constraint.validate(object);
+                        misfit = yield entry.constraint.validateMultipleProperties(object, entry.properties);
                     }
                     if (misfit) {
                         if (misfit.constraint === undefined) {
@@ -108,7 +113,7 @@ class Validator {
                         throw new Error('Using another validator only works for one property');
                     }
                     let property = entry.properties[0];
-                    let dotNotification = new DotNotification_1.DotNotification(property);
+                    let dotNotification = new DotNotation_1.DotNotation(property);
                     let value = dotNotification.get(object);
                     if (value === undefined) {
                         continue;

package/lib/lib/constraints/Absent.d.ts

@@ -1,6 +1,6 @@
-import { Constraint } from '../Constraint';
-import { Misfit } from '../Misfit';
-export interface AbsentMisfitValues {
+import { Misfit } from 'knight-misfit';
+import { Constraint, ConstraintMisfitValues } from '../Constraint';
+export interface AbsentMisfitValues extends ConstraintMisfitValues {
     actual: any;
 }
 export declare class Absent extends Constraint<any, AbsentMisfitValues> {

package/lib/lib/constraints/Absent.js

@@ -10,12 +10,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Absent = void 0;
+const knight_misfit_1 = require("knight-misfit");
 const Constraint_1 = require("../Constraint");
-const Misfit_1 = require("../Misfit");
 class Absent extends Constraint_1.Constraint {
     validate(value) {
         return __awaiter(this, void 0, void 0, function* () {
-            return value !== undefined ? new Misfit_1.Misfit(this.name, { actual: value }) : null;
+            return value !== undefined ? new knight_misfit_1.Misfit(this.name, undefined, { actual: value }) : null;
         });
     }
 }

package/lib/lib/constraints/Bounds.d.ts

@@ -1,6 +1,6 @@
-import { Constraint } from '../Constraint';
-import { Misfit } from '../Misfit';
-export interface BoundsMisfitValues {
+import { Misfit } from 'knight-misfit';
+import { Constraint, ConstraintMisfitValues } from '../Constraint';
+export interface BoundsMisfitValues extends ConstraintMisfitValues {
     actual: any;
     greaterThan?: number;
     greaterThanEqual?: number;

package/lib/lib/constraints/Bounds.js

@@ -10,8 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Bounds = void 0;
+const knight_misfit_1 = require("knight-misfit");
 const Constraint_1 = require("../Constraint");
-const Misfit_1 = require("../Misfit");
 class Bounds extends Constraint_1.Constraint {
     constructor(constraints) {
         super();
@@ -38,7 +38,7 @@ class Bounds extends Constraint_1.Constraint {
         });
     }
     _createMisfit(actual) {
-        return new Misfit_1.Misfit(this.name, {
+        return new knight_misfit_1.Misfit(this.name, undefined, {
             actual: actual,
             greaterThan: this.greaterThan,
             greaterThanEqual: this.greaterThanEqual,

package/lib/lib/constraints/Enum.d.ts

@@ -1,6 +1,6 @@
-import { Constraint } from '../Constraint';
-import { Misfit } from '../Misfit';
-export interface EnumMisfitValues {
+import { Misfit } from 'knight-misfit';
+import { Constraint, ConstraintMisfitValues } from '../Constraint';
+export interface EnumMisfitValues extends ConstraintMisfitValues {
     actual: any;
     values: any[];
 }

package/lib/lib/constraints/Enum.js

@@ -10,8 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Enum = void 0;
+const knight_misfit_1 = require("knight-misfit");
 const Constraint_1 = require("../Constraint");
-const Misfit_1 = require("../Misfit");
 class Enum extends Constraint_1.Constraint {
     constructor(...values) {
         super();
@@ -38,7 +38,7 @@ class Enum extends Constraint_1.Constraint {
                 return null;
             }
             if (this.values.indexOf(value) == -1) {
-                return new Misfit_1.Misfit(this.name, {
+                return new knight_misfit_1.Misfit(this.name, undefined, {
                     actual: value,
                     values: this.values
                 });

package/lib/lib/constraints/Exists.d.ts

@@ -1,6 +1,6 @@
-import { Constraint } from '../Constraint';
-import { Misfit } from '../Misfit';
-export interface ExistsMisfitValues {
+import { Misfit } from 'knight-misfit';
+import { Constraint, ConstraintMisfitValues } from '../Constraint';
+export interface ExistsMisfitValues extends ConstraintMisfitValues {
     notExistingValue: any;
 }
 export declare class Exists<T> extends Constraint<T, ExistsMisfitValues> {

package/lib/lib/constraints/Exists.js

@@ -10,8 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Exists = void 0;
+const knight_misfit_1 = require("knight-misfit");
 const Constraint_1 = require("../Constraint");
-const Misfit_1 = require("../Misfit");
 class Exists extends Constraint_1.Constraint {
     constructor(doesExist) {
         super();
@@ -21,7 +21,7 @@ class Exists extends Constraint_1.Constraint {
         return __awaiter(this, void 0, void 0, function* () {
             if (value !== undefined) {
                 if (!(yield this.doesExist(value))) {
-                    return new Misfit_1.Misfit(this.name, {
+                    return new knight_misfit_1.Misfit(this.name, undefined, {
                         notExistingValue: value
                     });
                 }

package/lib/lib/constraints/Length.d.ts

@@ -1,6 +1,6 @@
-import { Constraint } from '../Constraint';
-import { Misfit } from '../Misfit';
-export interface LengthMisfitValues {
+import { Misfit } from 'knight-misfit';
+import { Constraint, ConstraintMisfitValues } from '../Constraint';
+export interface LengthMisfitValues extends ConstraintMisfitValues {
     actual: any;
     min?: number;
     max?: number;

package/lib/lib/constraints/Length.js

@@ -10,8 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Length = void 0;
+const knight_misfit_1 = require("knight-misfit");
 const Constraint_1 = require("../Constraint");
-const Misfit_1 = require("../Misfit");
 class Length extends Constraint_1.Constraint {
     constructor(constraints) {
         super();
@@ -35,7 +35,7 @@ class Length extends Constraint_1.Constraint {
         });
     }
     _createMisfit(actual) {
-        return new Misfit_1.Misfit(this.name, {
+        return new knight_misfit_1.Misfit(this.name, undefined, {
             actual: actual,
             exact: this.exact,
             max: this.max,

package/lib/lib/constraints/QuickConstraint.d.ts

@@ -0,0 +1,10 @@
+import { Misfit } from 'knight-misfit';
+import { Constraint } from '../Constraint';
+export declare class QuickConstraint<T> extends Constraint<T, any> {
+    name: string;
+    validateFn?: (obj: T) => Promise<Misfit | null>;
+    validateMultiplePropertiesFn?: (obj: T, properties: string[]) => Promise<Misfit | null>;
+    constructor(name: string, validateFn?: (obj: T) => Promise<Misfit | null>, validateMultiplePropertiesFn?: (obj: T, properties: string[]) => Promise<Misfit | null>);
+    validate(obj: T): Promise<Misfit | null>;
+    validateMultipleProperties(obj: T, properties: string[]): Promise<Misfit | null>;
+}

package/lib/lib/{QuickConstraint.js → constraints/QuickConstraint.js}

@@ -10,17 +10,32 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QuickConstraint = void 0;
-const Constraint_1 = require("./Constraint");
+const Constraint_1 = require("../Constraint");
 class QuickConstraint extends Constraint_1.Constraint {
-    constructor(name, validateFn) {
+    constructor(name, validateFn, validateMultiplePropertiesFn) {
         super();
         this.name = name;
         this.validateFn = validateFn;
+        this.validateMultiplePropertiesFn = validateMultiplePropertiesFn;
     }
     validate(obj) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.validateFn == undefined) {
+                throw new Error('Could not call method because the needed this.validateFn function was not set!');
+            }
             return this.validateFn(obj);
         });
     }
+    validateMultipleProperties(obj, properties) {
+        const _super = Object.create(null, {
+            validateMultipleProperties: { get: () => super.validateMultipleProperties }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.validateMultiplePropertiesFn == undefined) {
+                return _super.validateMultipleProperties.call(this, obj, properties);
+            }
+            return this.validateMultiplePropertiesFn(obj, properties);
+        });
+    }
 }
 exports.QuickConstraint = QuickConstraint;

package/lib/lib/constraints/Required.d.ts

@@ -1,5 +1,5 @@
-import { Constraint } from '../Constraint';
-import { Misfit } from '../Misfit';
-export declare class Required extends Constraint<any, void> {
-    validate(value: any): Promise<Misfit<void> | null>;
+import { Misfit } from 'knight-misfit';
+import { Constraint, ConstraintMisfitValues } from '../Constraint';
+export declare class Required extends Constraint {
+    validate(value: any): Promise<Misfit<ConstraintMisfitValues> | null>;
 }

package/lib/lib/constraints/Required.js

@@ -10,12 +10,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Required = void 0;
+const knight_misfit_1 = require("knight-misfit");
 const Constraint_1 = require("../Constraint");
-const Misfit_1 = require("../Misfit");
 class Required extends Constraint_1.Constraint {
     validate(value) {
         return __awaiter(this, void 0, void 0, function* () {
-            return value === undefined ? new Misfit_1.Misfit(this.name) : null;
+            return value === undefined ? new knight_misfit_1.Misfit(this.name) : null;
         });
     }
 }

package/lib/lib/constraints/TypeOf.d.ts

@@ -1,6 +1,6 @@
-import { Constraint } from '../Constraint';
-import { Misfit } from '../Misfit';
-export interface TypeOfMisfitValues {
+import { Misfit } from 'knight-misfit';
+import { Constraint, ConstraintMisfitValues } from '../Constraint';
+export interface TypeOfMisfitValues extends ConstraintMisfitValues {
     types: (string | null)[];
     actual: string | null;
 }

package/lib/lib/constraints/TypeOf.js

@@ -10,8 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeOf = void 0;
+const knight_misfit_1 = require("knight-misfit");
 const Constraint_1 = require("../Constraint");
-const Misfit_1 = require("../Misfit");
 class TypeOf extends Constraint_1.Constraint {
     constructor(...valueTypes) {
         super();
@@ -47,11 +47,10 @@ class TypeOf extends Constraint_1.Constraint {
             else {
                 actualType = typeof value;
             }
-            let misfit = new Misfit_1.Misfit(this.name);
-            misfit.values = {
+            let misfit = new knight_misfit_1.Misfit(this.name, undefined, {
                 actual: actualType,
                 types: []
-            };
+            });
             for (let valueType of this.valueTypes) {
                 if (typeof valueType == 'string') {
                     misfit.values.types.push(valueType);

package/lib/lib/constraints/Unique.d.ts

@@ -1,6 +1,6 @@
-import { Constraint } from '../Constraint';
-import { Misfit } from '../Misfit';
-export interface UniqueMisfitValues {
+import { Misfit } from 'knight-misfit';
+import { Constraint, ConstraintMisfitValues } from '../Constraint';
+export interface UniqueMisfitValues extends ConstraintMisfitValues {
     notUniqueValue: any;
 }
 export declare class Unique<T> extends Constraint<T, UniqueMisfitValues> {

package/lib/lib/constraints/Unique.js

@@ -10,8 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Unique = void 0;
+const knight_misfit_1 = require("knight-misfit");
 const Constraint_1 = require("../Constraint");
-const Misfit_1 = require("../Misfit");
 class Unique extends Constraint_1.Constraint {
     constructor(isUnique) {
         super();
@@ -23,7 +23,7 @@ class Unique extends Constraint_1.Constraint {
                 return null;
             }
             if (!(yield this.isUnique(value))) {
-                return new Misfit_1.Misfit(this.name, { notUniqueValue: value });
+                return new knight_misfit_1.Misfit(this.name, undefined, { notUniqueValue: value });
             }
             return null;
         });

package/package.json

@@ -1,35 +1,38 @@
 {
   "name": "knight-validation",
-  "version": "2.0.6",
+  "version": "3.0.0",
   "description": "A validation lib",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "files": [
     "lib/**/*"
   ],
-  "devDependencies": {
-    "@types/chai": "^4.3.3",
-    "@types/mocha": "^9.1.1",
-    "@types/node": "^13.5.0",
-    "chai": "^4.3.6",
-    "mocha": "^10.0.0",
-    "ts-node": "^10.9.1",
-    "typescript": "^4.8.2"
-  },
   "scripts": {
     "test": "mocha -r ts-node/register \"test/**/*.test.ts\"",
     "build": "rm -rf lib && tsc"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/c0deritter/knight-validation.git"
+    "url": "git+https://github.com/coderitter/knight-validation.git"
   },
   "keywords": [
     ""
   ],
   "author": "Coderitter GmbH",
   "bugs": {
-    "url": "https://github.com/c0deritter/knight-validation/issues"
+    "url": "https://github.com/coderitter/knight-validation/issues"
+  },
+  "homepage": "https://github.com/coderitter/knight-validation#readme",
+  "devDependencies": {
+    "@types/chai": "^5.2.2",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^24.0.4",
+    "chai": "^5.2.0",
+    "mocha": "^11.7.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
   },
-  "homepage": "https://github.com/c0deritter/knight-validation#readme"
+  "dependencies": {
+    "knight-misfit": "^1.0.0"
+  }
 }

package/lib/lib/Misfit.d.ts

@@ -1,11 +0,0 @@
-export declare class Misfit<ValuesType = any> {
-    constraint: string;
-    properties: string[];
-    values?: ValuesType;
-    message?: string;
-    constructor(constraint?: string, values?: ValuesType);
-    setProperties(property: string | string[]): void;
-    addPrefix(prefix: string): void;
-    isSinglePropery(): boolean;
-    isMultipleProperties(): boolean;
-}

package/lib/lib/Misfit.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Misfit = void 0;
-class Misfit {
-    constructor(constraint, values) {
-        this.properties = [];
-        this.constraint = constraint;
-        this.values = values;
-    }
-    setProperties(property) {
-        if (typeof property == 'string') {
-            this.properties = [property];
-        }
-        else if (property instanceof Array) {
-            this.properties = property;
-        }
-    }
-    addPrefix(prefix) {
-        for (let i = 0; i < this.properties.length; i++) {
-            this.properties[i] = prefix + this.properties[i];
-        }
-    }
-    isSinglePropery() {
-        return this.properties && this.properties.length == 1;
-    }
-    isMultipleProperties() {
-        return this.properties && this.properties.length > 1;
-    }
-}
-exports.Misfit = Misfit;

package/lib/lib/MisfitsError.d.ts

@@ -1,5 +0,0 @@
-import { Misfit } from './Misfit';
-export declare class MisfitsError extends Error {
-    misfits: Misfit[];
-    constructor(misfits: Misfit | Misfit[]);
-}

package/lib/lib/MisfitsError.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MisfitsError = void 0;
-class MisfitsError extends Error {
-    constructor(misfits) {
-        super('Misfits occured ' + JSON.stringify(misfits));
-        this.misfits = misfits instanceof Array ? misfits : [misfits];
-    }
-}
-exports.MisfitsError = MisfitsError;

package/lib/lib/QuickConstraint.d.ts

@@ -1,8 +0,0 @@
-import { Constraint } from './Constraint';
-import { Misfit } from './Misfit';
-export declare class QuickConstraint<T> extends Constraint<T, any> {
-    name: string;
-    validateFn: (obj: T) => Promise<Misfit | null>;
-    constructor(name: string, validateFn: (obj: T) => Promise<Misfit | null>);
-    validate(obj: T): Promise<Misfit | null>;
-}