knight-validation 2.0.3 → 2.0.5

package/README.md

@@ -33,7 +33,14 @@ import { Validator } from 'knight-validation'
 class UserValidator extends Validator {
   constructor(userDb: UserDb) {
     super()
-    this.add(['firstName', 'lastName'], ...)
+    
+    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
+      }
+    })
   }
 }
 ```
@@ -44,6 +51,11 @@ class UserValidator extends Validator {
 // Check if a property is absent
 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 })
+
 // Check a property's value equals one of the three given strings
 new Enum('Moni', 'Lisa', 'Anna')
 // Check if a property's value equals one of the three given numbers
@@ -54,6 +66,11 @@ 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
+new Length({ min: 5, max: 10})
+// Check if the length of a string has exactly a specific length
+new Length({ exact: 5 })
+
 // Check if a property is there
 new Required
 
@@ -85,19 +102,16 @@ misfits.length == 1
 A misfit contains the following informations by default.
 
 ```typescript
-// The name of the misfit which defaults to the name of the constraint which was not met
+// The name of the constraint that resulted in the misfit
 misfit.constraint == 'Required'
 
-// The property where the misfit occured
-misfit.property == 'email'
-
-// The properties where the misfit occured
-misfit.properties == ['firstName', 'lastName']
+// The involved properties
+misfit.property == [ 'email' ]
 
-// It contains any information that is useful about why checking the constraint resulted in a misfit (Optional)
-misfit.value
+// Contextual values specific to the misfit at hand (Optional)
+misfit.values
 
-// A message (Optional)
+// A misfit message (Optional)
 misift.message == 'The property email is required.'
 ```
 
@@ -129,40 +143,46 @@ class UserValidator extends Validator {
 }
 ```
 
-#### Exclude rules
-
-```typescript
-// Exclude all constraints regarding the email property
-let misfits = validator.validate(user, { exclude: ['email'] })
-
-// Exclude only the required constraint of the email property
-let misfits = validator.validate(user, { exclude: [{ properties: 'email', constraint: 'Required' }] })
-```
-
 ### Anonymous custom constraints
 
-You can add constraints on the fly without creating a class.
+You can create custom constraints on the fly without having to create a dedicated constraint class. 
 
 ```typescript
 let validator = new Validator
 
+// Second parameter is the name of the contstraint
+// Third parameter is the validation function which receives the value of the property
+validator.add('email', 'OnlyGermanMails', async (email: string) {
+  if (! email.endsWith('.de')) {
+
+    // You do not need to set the constraint name nor the property on the misfit.
+    // Those will be set automatically.
+    return new Misfit
+  }
+})
+
+// Second parameter is the name of the contstraint
+// Third parameter is the validation function which receives the complete object owning both properties
 validator.add(['firstName', 'lastName'], 'Different', async (user: User) => {
   if (user.firstName == user.lastName) {
     let misfit = new Misfit
 
-    // You can skip setting a name and the property(s) for the misfit. These will be set automatically.
+    // You do not need to set the constraint name nor the properties on the misfit.
+    // Those will be set automatically.
     
-    // We give it some information here on what went wrong. What you put in here depends on your needs.
-    misfit.constraints = {
+    // You can provide some contextual information
+    misfit.values = {
       firstName: user.firstName,
       lastName: user.lastName
     }
 
-    return misfits
+    return misfit
   }
 })
 ```
 
+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.
+
 ### Custom constraints as classes
 
 If you want to reuse a constraint over and over again, create a new class for it.
@@ -170,39 +190,29 @@ If you want to reuse a constraint over and over again, create a new class for it
 ```typescript
 import { Constraint } from 'knight-validation'
 
-class YourConstraint extends Constraint {
+export interface DifferentMisfitValues {
+  firstName: string
+  lastName: string
+}
+
+export class Different extends Constraint<User, DifferentMisfitValues> {
 
   // Override the abstract method validate
-  async validate(obj: any, properties: string|string[]): Promise<Misfit|undefined> {
+  validate(user: User): Promise<Misfit<DifferentMisfitValues>|null> {
+  if (user.firstName == user.lastName) {
+    let misfit = new Misfit<DifferentMisfitValues>
 
-    // At first you want to check if the properties are absent because in case of absense you do not want to validate because a property may be optional.
-    if (this.arePropertyAbsent(obj, properties)) {
-      return
+    // 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
     }
 
-    // Next you need to check if the properties were single or a nultiple ones. Maybe you just implement on of the two possibilities.
-    if (typeof properties == 'string') {
-      // In case of a single property
-    }
-    else {
-      // In case of multiple properties
-    }
+    return misfit
   }
 }
 ```
 
-Another possibility is to use the `defaultValidation` method. It will do the check for absence and will implement the validation of combined properties.
-
-```typescript
-import { Constraint } from 'knight-validation'
-
-class YourConstraint extends Constraint {
-  async validate(obj: any, properties: string|string[]): Promise<Misfit|undefined> {
-    return this.defaultValidation(obj, properties, async (value: any) => {
-      if (value == 1) {  // Validate the value here
-        return new 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.

package/lib/lib/DotNotification.d.ts

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

package/lib/lib/DotNotification.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DotNotification = void 0;
+class DotNotification {
+    constructor(dotNotification) {
+        this.properties = dotNotification.split('.');
+    }
+    exists(obj) {
+        let exists = false;
+        for (let property of this.properties) {
+            if (typeof obj == 'object' && obj !== null && obj[property] !== undefined) {
+                exists = true;
+                obj = obj[property];
+            }
+            else {
+                exists = false;
+                break;
+            }
+        }
+        return exists;
+    }
+    get(obj) {
+        for (let property of this.properties) {
+            if (typeof obj == 'object' && obj !== null) {
+                obj = obj[property];
+            }
+            else {
+                obj = undefined;
+                break;
+            }
+        }
+        return obj;
+    }
+}
+exports.DotNotification = DotNotification;

package/lib/lib/Validator.d.ts

@@ -3,18 +3,18 @@ import { Misfit } from './Misfit';
 export interface ValidatorOptions {
     checkOnlyWhatIsThere?: boolean;
 }
-interface ValidatorEntry {
+interface ValidatorEntry<T = any> {
     properties: string[];
     constraint?: Constraint;
-    validator?: Validator<any>;
-    condition?: (object: any) => Promise<boolean>;
+    validator?: Validator;
+    condition?: (object: T) => Promise<boolean>;
 }
-export declare class Validator<T> {
+export declare class Validator<T = any> {
     options?: ValidatorOptions;
-    entries: ValidatorEntry[];
+    entries: ValidatorEntry<T>[];
     constructor(options?: ValidatorOptions);
-    add(properties: string, constraint: Constraint, condition?: (object: T) => Promise<boolean>): void;
-    add(properties: string, constraintName: string, validate: (value: any) => Promise<Misfit | null>, condition?: (object: T) => Promise<boolean>): void;
+    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(property: string, validator: Validator<any>, condition?: (object: T) => Promise<boolean>): void;
     add(validator: Validator<any>): void;

package/lib/lib/Validator.js

@@ -11,6 +11,7 @@ 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");
 class Validator {
     constructor(options) {
@@ -42,7 +43,7 @@ class Validator {
                 condition = args.length > 2 ? args[2] : undefined;
             }
             else {
-                throw new Error('Wrong parameters');
+                throw new Error('Invalid parameters');
             }
             this.entries.push({
                 properties: properties,
@@ -73,7 +74,8 @@ class Validator {
                 }
                 let atLeastOnePropertyExists = false;
                 for (let property of entry.properties) {
-                    if (object[property] !== undefined) {
+                    let dotNotification = new DotNotification_1.DotNotification(property);
+                    if (dotNotification.exists(object)) {
                         atLeastOnePropertyExists = true;
                         break;
                     }
@@ -85,7 +87,8 @@ class Validator {
                     let misfit;
                     if (entry.properties.length == 1) {
                         let property = entry.properties[0];
-                        let value = object[property];
+                        let dotNotification = new DotNotification_1.DotNotification(property);
+                        let value = dotNotification.get(object);
                         misfit = yield entry.constraint.validate(value);
                     }
                     else {
@@ -95,7 +98,7 @@ class Validator {
                         if (misfit.constraint === undefined) {
                             misfit.constraint = entry.constraint.name;
                         }
-                        misfit.properties = entry.properties;
+                        misfit.properties = entry.properties.slice();
                         misfittingProperties.push(...entry.properties);
                         misfits.push(misfit);
                     }
@@ -105,8 +108,9 @@ class Validator {
                         throw new Error('Using another validator only works for one property');
                     }
                     let property = entry.properties[0];
-                    let value = object[property];
-                    if (typeof value != 'object' || value === null) {
+                    let dotNotification = new DotNotification_1.DotNotification(property);
+                    let value = dotNotification.get(object);
+                    if (value === undefined) {
                         continue;
                     }
                     if (value instanceof Array) {

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

@@ -3,8 +3,8 @@ import { Misfit } from '../Misfit';
 export interface ExistsMisfitValues {
     notExistingValue: any;
 }
-export declare class Exists extends Constraint<any, ExistsMisfitValues> {
-    doesExist: (value: any) => Promise<boolean>;
-    constructor(doesExist: (value: any) => Promise<boolean>);
-    validate(value: any): Promise<Misfit<ExistsMisfitValues> | null>;
+export declare class Exists<T> extends Constraint<T, ExistsMisfitValues> {
+    doesExist: (value: T) => Promise<boolean>;
+    constructor(doesExist: (value: T) => Promise<boolean>);
+    validate(value: T): Promise<Misfit<ExistsMisfitValues> | null>;
 }

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

@@ -3,8 +3,8 @@ import { Misfit } from '../Misfit';
 export interface UniqueMisfitValues {
     notUniqueValue: any;
 }
-export declare class Unique extends Constraint<any, UniqueMisfitValues> {
-    isUnique: (value: any) => Promise<boolean>;
-    constructor(isUnique: (value: any) => Promise<boolean>);
-    validate(value: any): Promise<Misfit<UniqueMisfitValues> | null>;
+export declare class Unique<T> extends Constraint<T, UniqueMisfitValues> {
+    isUnique: (value: T) => Promise<boolean>;
+    constructor(isUnique: (value: T) => Promise<boolean>);
+    validate(value: T): Promise<Misfit<UniqueMisfitValues> | null>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knight-validation",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "description": "A validation lib",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",