knight-validation 2.0.1 → 2.0.4

package/lib/index.d.ts

@@ -0,0 +1,12 @@
+export * from './lib/constraints/Absent';
+export * from './lib/constraints/Bounds';
+export * from './lib/constraints/Enum';
+export * from './lib/constraints/Exists';
+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/Validator';

package/lib/lib/Constraint.d.ts

@@ -0,0 +1,5 @@
+import { Misfit } from './Misfit';
+export declare abstract class Constraint<T = any, MisfitValuesType = any> {
+    name: string;
+    abstract validate(value: T): Promise<Misfit<MisfitValuesType> | null>;
+}

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/Misfit.d.ts

@@ -0,0 +1,11 @@
+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/MisfitsError.d.ts

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

package/lib/lib/QuickConstraint.d.ts

@@ -0,0 +1,8 @@
+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>;
+}

package/lib/lib/Validator.d.ts

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

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) {
@@ -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 {
@@ -105,17 +108,32 @@ class Validator {
                         throw new Error('Using another validator only works for one property');
                     }
                     let property = entry.properties[0];
-                    let value = object[property];
-                    if (value == undefined) {
+                    let dotNotification = new DotNotification_1.DotNotification(property);
+                    let value = dotNotification.get(object);
+                    if (value === undefined) {
                         continue;
                     }
-                    let subMisfits = yield entry.validator.validate(value, options);
-                    if (subMisfits.length > 0) {
-                        for (let misfit of subMisfits) {
-                            misfit.addPrefix(property + '.');
+                    if (value instanceof Array) {
+                        for (let i = 0; i < value.length; i++) {
+                            let subMisfits = yield entry.validator.validate(value[i], options);
+                            if (subMisfits.length > 0) {
+                                for (let misfit of subMisfits) {
+                                    misfit.addPrefix(`${property}[${i}].`);
+                                }
+                                misfittingProperties.push(...entry.properties);
+                                misfits.push(...subMisfits);
+                            }
+                        }
+                    }
+                    else {
+                        let subMisfits = yield entry.validator.validate(value, options);
+                        if (subMisfits.length > 0) {
+                            for (let misfit of subMisfits) {
+                                misfit.addPrefix(property + '.');
+                            }
+                            misfittingProperties.push(...entry.properties);
+                            misfits.push(...subMisfits);
                         }
-                        misfittingProperties.push(...entry.properties);
-                        misfits.push(...subMisfits);
                     }
                 }
             }

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

@@ -0,0 +1,8 @@
+import { Constraint } from '../Constraint';
+import { Misfit } from '../Misfit';
+export interface AbsentMisfitValues {
+    actual: any;
+}
+export declare class Absent extends Constraint<any, AbsentMisfitValues> {
+    validate(value: any): Promise<Misfit<AbsentMisfitValues> | null>;
+}

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

@@ -0,0 +1,18 @@
+import { Constraint } from '../Constraint';
+import { Misfit } from '../Misfit';
+export interface BoundsMisfitValues {
+    actual: any;
+    greaterThan?: number;
+    greaterThanEqual?: number;
+    lesserThan?: number;
+    lesserThanEqual?: number;
+}
+export declare class Bounds extends Constraint<any, BoundsMisfitValues> {
+    greaterThan?: number;
+    greaterThanEqual?: number;
+    lesserThan?: number;
+    lesserThanEqual?: number;
+    constructor(constraints: Partial<Bounds>);
+    validate(value: any): Promise<Misfit<BoundsMisfitValues> | null>;
+    private _createMisfit;
+}

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

@@ -0,0 +1,13 @@
+import { Constraint } from '../Constraint';
+import { Misfit } from '../Misfit';
+export interface EnumMisfitValues {
+    actual: any;
+    values: any[];
+}
+export declare class Enum extends Constraint<any, EnumMisfitValues> {
+    values: any[];
+    constructor(values: any[]);
+    constructor(...values: any[]);
+    constructor(values: object);
+    validate(value: any): Promise<Misfit<EnumMisfitValues> | null>;
+}

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

@@ -0,0 +1,10 @@
+import { Constraint } from '../Constraint';
+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>;
+}

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

@@ -0,0 +1,16 @@
+import { Constraint } from '../Constraint';
+import { Misfit } from '../Misfit';
+export interface LengthMisfitValues {
+    actual: any;
+    min?: number;
+    max?: number;
+    exact?: number;
+}
+export declare class Length extends Constraint<any, LengthMisfitValues> {
+    min?: number;
+    max?: number;
+    exact?: number;
+    constructor(constraints: Partial<Length>);
+    validate(value: any): Promise<Misfit<LengthMisfitValues> | null>;
+    private _createMisfit;
+}

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

@@ -0,0 +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>;
+}

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

@@ -0,0 +1,11 @@
+import { Constraint } from '../Constraint';
+import { Misfit } from '../Misfit';
+export interface TypeOfMisfitValues {
+    types: (string | null)[];
+    actual: string | null;
+}
+export declare class TypeOf extends Constraint<any, TypeOfMisfitValues> {
+    valueTypes: (string | null | (new (...params: any[]) => any))[];
+    constructor(...valueTypes: (string | null | (new (...params: any[]) => any))[]);
+    validate(value: any): Promise<Misfit<TypeOfMisfitValues> | null>;
+}

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

@@ -0,0 +1,10 @@
+import { Constraint } from '../Constraint';
+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>;
+}

package/package.json

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