knight-validation 4.0.1 → 4.0.3

package/lib/lib/Validator.d.ts

@@ -1,5 +1,8 @@
 import { Misfit } from 'knight-misfit';
 import { Constraint } from './Constraint';
+export interface ValidatorMap {
+    [validatorId: string]: Validator;
+}
 export interface ValidatorOptions {
     checkOnlyWhatIsThere?: boolean;
     exclude?: string[];
@@ -10,18 +13,18 @@ export interface ValidatorEntry<T = any> {
     validator?: Validator;
     condition?: (object: T) => Promise<boolean>;
 }
-export interface ValidatorFactory<T = any> {
-    create(): Validator<T>;
-}
-export declare class SimpleValidatorFactory<T = any> implements ValidatorFactory<T> {
-    createFn: () => Validator<T>;
-    constructor(createFn: () => Validator<T>);
-    create(): Validator<T>;
+export declare class ValidatorFactory<T = any> {
+    validatorId: string;
+    createFn: (validators: ValidatorMap) => Validator<T>;
+    constructor(validatorId: string | (new (...args: any[]) => any), createFn: (validators: ValidatorMap) => Validator<T>);
+    createOrGetExisting(validators: ValidatorMap): Validator<T>;
 }
 export declare class Validator<T = any> {
+    validatorId: string;
     options?: ValidatorOptions;
+    validators: ValidatorMap;
     entries: ValidatorEntry<T>[];
-    constructor(options?: ValidatorOptions);
+    constructor(options?: ValidatorOptions, validators?: ValidatorMap, validatorId?: string | (new (...args: any[]) => any));
     add(constraint: Constraint, condition?: (object: T) => Promise<boolean>): void;
     add(constraintName: string, validate: (value: any) => Promise<Misfit | null>, condition?: (object: T) => Promise<boolean>): void;
     add(validatorFactory: ValidatorFactory): void;
@@ -31,5 +34,5 @@ export declare class Validator<T = any> {
     add(properties: string[], constraint: Constraint, 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(validatorEntry: ValidatorEntry): void;
-    validate(object: T, options?: ValidatorOptions): Promise<Misfit[]>;
+    validate(object: T, options?: ValidatorOptions, validated?: WeakSet<any>): Promise<Misfit[]>;
 }

package/lib/lib/Validator.js

@@ -9,25 +9,45 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Validator = exports.SimpleValidatorFactory = void 0;
+exports.Validator = exports.ValidatorFactory = void 0;
 const knight_log_1 = require("knight-log");
 const Constraint_1 = require("./Constraint");
 const DotNotation_1 = require("./DotNotation");
 const QuickConstraint_1 = require("./constraints/QuickConstraint");
 let log = new knight_log_1.Log('knight-validation/Validator.ts');
-class SimpleValidatorFactory {
-    constructor(createFn) {
+class ValidatorFactory {
+    constructor(validatorId, createFn) {
+        this.validatorId = typeof validatorId == 'string' ? validatorId : validatorId.name;
         this.createFn = createFn;
     }
-    create() {
-        return this.createFn();
+    createOrGetExisting(validators) {
+        let l = log.cls('ValidatorFactory', 'createOrGetExisting');
+        l.param('validators', validators);
+        l.creator('this.validatorId', this.validatorId);
+        if (this.validatorId in validators) {
+            l.returning('existing validator', validators[this.validatorId]);
+            return validators[this.validatorId];
+        }
+        l.returning('created validator');
+        return this.createFn(validators);
     }
 }
-exports.SimpleValidatorFactory = SimpleValidatorFactory;
+exports.ValidatorFactory = ValidatorFactory;
 class Validator {
-    constructor(options) {
+    constructor(options, validators, validatorId) {
         this.entries = [];
         this.options = options;
+        this.validators = validators || {};
+        if (typeof validatorId == 'string') {
+            this.validatorId = validatorId;
+        }
+        else if (typeof validatorId == 'function') {
+            this.validatorId = validatorId.name;
+        }
+        else {
+            this.validatorId = this.constructor.name;
+        }
+        this.validators[this.validatorId] = this;
     }
     add(...args) {
         var _a, _b, _c;
@@ -37,20 +57,35 @@ class Validator {
         let constraint;
         let validatorFactory;
         let condition;
-        if (typeof args[0] == 'object' && args[0] !== null && 'create' in args[0] && typeof args[0].create == 'function') {
-            let validator = args[0].create();
-            if (typeof validator == 'object' && validator !== null && 'entries' in validator && Array.isArray(validator.entries)) {
+        if (args[0] instanceof ValidatorFactory) {
+            if (this.options == undefined) {
+                this.options = {};
+            }
+            let validator = args[0].createOrGetExisting(this.validators);
+            if (validator == this) {
+                throw new Error('Cannot add add another validator that is itself which would result in an endless loop of adding itself!');
+            }
+            if (typeof validator == 'object' &&
+                validator !== null &&
+                'entries' in validator &&
+                Array.isArray(validator.entries) &&
+                validator.entries.length > 0) {
+                l.dev('Adding entries from validator', validator);
                 for (let entry of validator.entries) {
                     this.add(entry);
                 }
             }
+            else {
+                l.warn('Given validator to add does not have any entries!', validator);
+            }
         }
         else if (typeof args[0] == 'object' && args[0] !== null && 'properties' in args[0] && Array.isArray(args[0].properties)) {
             properties = args[0].properties;
             constraint = args[0].constraint;
-            validatorFactory = args[0].validator ?
-                { create: () => args[0].validator } : undefined;
             condition = args[0].condition;
+            if (args[0].validator) {
+                validatorFactory = new ValidatorFactory(args[0].validator.constructor.name, () => args[0].validator);
+            }
             if (constraint != undefined && validatorFactory != undefined) {
                 throw new Error('The provided parameter is a ValidatorEntry with both a constraint and a validator defined. This is invalid! Only one may be specified at a time!');
             }
@@ -80,7 +115,7 @@ class Validator {
                 constraint = args[1];
                 condition = args.length > 2 ? args[2] : undefined;
             }
-            else if (typeof args[1] == 'object' && args[1] !== null && 'create' in args[1] && typeof args[1].create == 'function') {
+            else if (args[1] instanceof ValidatorFactory) {
                 validatorFactory = args[1];
                 condition = args.length > 2 ? args[2] : undefined;
             }
@@ -105,10 +140,20 @@ class Validator {
             }
         }
         if (!propertyExcluded) {
+            let validator;
+            if (validatorFactory) {
+                if (this.options == undefined) {
+                    this.options = {};
+                }
+                validator = validatorFactory.createOrGetExisting(this.validators);
+                if (validator == undefined) {
+                    throw new Error('Validator factory did not create a validator!');
+                }
+            }
             let entry = {
                 properties: properties,
                 constraint: constraint,
-                validator: validatorFactory ? validatorFactory.create() : undefined,
+                validator: validator,
                 condition: condition
             };
             this.entries.push(entry);
@@ -116,17 +161,22 @@ class Validator {
         }
         l.returning();
     }
-    validate(object, options) {
+    validate(object, options, validated) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             let l = log.mt('validate');
             l.param('object', object);
             l.param('options', options);
+            if (validated == undefined) {
+                validated = new WeakSet;
+            }
+            validated.add(object);
             options = options || this.options;
             let misfits = [];
             let misfittingProperties = [];
             for (let entry of this.entries) {
                 let constraintOrValidatorName = entry.constraint ? (_a = entry.constraint) === null || _a === void 0 ? void 0 : _a.name : entry.validator ? entry.validator.constructor.name : '';
+                l.dev('Checking constraint', JSON.stringify(entry.properties), constraintOrValidatorName);
                 l.location = ['' + JSON.stringify(entry.properties) + ' > ' + constraintOrValidatorName];
                 let propertyAlreadyHasAMisfit = false;
                 for (let property of entry.properties) {
@@ -212,6 +262,10 @@ class Validator {
                         l.dev('Value of the property is not of type object or null. Skipping...', value);
                         continue;
                     }
+                    if (validated.has(value)) {
+                        l.dev('Object is or was already being validated. Skipping...', value);
+                        continue;
+                    }
                     if (value instanceof Array) {
                         l.dev('Value of the property is an array. Iterating its elements...');
                         for (let i = 0; i < value.length; i++) {
@@ -220,7 +274,7 @@ class Validator {
                                 continue;
                             }
                             l.calling('entry.validator.validate', value[i], options);
-                            let subMisfits = yield entry.validator.validate(value[i], options);
+                            let subMisfits = yield entry.validator.validate(value[i], options, validated);
                             l.called('entry.validator.validate');
                             if (subMisfits.length > 0) {
                                 l.dev('Validator returned misfits', subMisfits);
@@ -241,7 +295,7 @@ class Validator {
                     else {
                         l.dev('Value of the property is not an array');
                         l.calling('entry.validator.validate', value, options);
-                        let subMisfits = yield entry.validator.validate(value, options);
+                        let subMisfits = yield entry.validator.validate(value, options, validated);
                         l.called('entry.validator.validate');
                         if (subMisfits.length > 0) {
                             l.dev('Validator returned misfits', subMisfits);

package/package.json

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