knight-validation 3.0.0 → 3.1.0

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

@@ -4,5 +4,6 @@ export interface AbsentMisfitValues extends ConstraintMisfitValues {
     actual: any;
 }
 export declare class Absent extends Constraint<any, AbsentMisfitValues> {
+    constructor(constraints?: Partial<Absent>);
     validate(value: any): Promise<Misfit<AbsentMisfitValues> | null>;
 }

package/lib/lib/constraints/Absent.js

@@ -13,6 +13,10 @@ exports.Absent = void 0;
 const knight_misfit_1 = require("knight-misfit");
 const Constraint_1 = require("../Constraint");
 class Absent extends Constraint_1.Constraint {
+    constructor(constraints) {
+        super();
+        Object.assign(this, constraints);
+    }
     validate(value) {
         return __awaiter(this, void 0, void 0, function* () {
             return value !== undefined ? new knight_misfit_1.Misfit(this.name, undefined, { actual: value }) : null;

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

@@ -6,8 +6,8 @@ export interface EnumMisfitValues extends ConstraintMisfitValues {
 }
 export declare class Enum extends Constraint<any, EnumMisfitValues> {
     values: any[];
-    constructor(values: any[]);
+    constructor(values: any[], constraints?: Partial<Constraint>);
     constructor(...values: any[]);
-    constructor(values: object);
+    constructor(values: object, constraints?: Partial<Constraint>);
     validate(value: any): Promise<Misfit<EnumMisfitValues> | null>;
 }

package/lib/lib/constraints/Enum.js

@@ -13,22 +13,33 @@ exports.Enum = void 0;
 const knight_misfit_1 = require("knight-misfit");
 const Constraint_1 = require("../Constraint");
 class Enum extends Constraint_1.Constraint {
-    constructor(...values) {
+    constructor(...args) {
         super();
         this.values = [];
-        for (let value of values) {
-            if (value instanceof Array) {
-                this.values.push(...value);
-            }
-            else if (typeof value == 'object') {
-                for (let key in value) {
-                    if (isNaN(parseInt(key, 10))) {
-                        this.values.push(value[key]);
+        for (let i = 0; i < args.length; i++) {
+            let arg = args[i];
+            if (i == 0) {
+                if (Array.isArray(arg)) {
+                    this.values.push(...arg);
+                }
+                else if (typeof arg == 'object') {
+                    for (let key in arg) {
+                        if (isNaN(parseInt(key, 10))) {
+                            this.values.push(arg[key]);
+                        }
                     }
                 }
+                else {
+                    this.values.push(arg);
+                }
+            }
+            else if (i == args.length - 1) {
+                if (typeof arg == 'object') {
+                    Object.assign(this, arg);
+                }
             }
             else {
-                this.values.push(value);
+                this.values.push(arg);
             }
         }
     }

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

@@ -5,6 +5,6 @@ export interface ExistsMisfitValues extends ConstraintMisfitValues {
 }
 export declare class Exists<T> extends Constraint<T, ExistsMisfitValues> {
     doesExist: (value: T) => Promise<boolean>;
-    constructor(doesExist: (value: T) => Promise<boolean>);
+    constructor(doesExist: (value: T) => Promise<boolean>, constraints?: Partial<Constraint>);
     validate(value: T): Promise<Misfit<ExistsMisfitValues> | null>;
 }

package/lib/lib/constraints/Exists.js

@@ -13,8 +13,9 @@ exports.Exists = void 0;
 const knight_misfit_1 = require("knight-misfit");
 const Constraint_1 = require("../Constraint");
 class Exists extends Constraint_1.Constraint {
-    constructor(doesExist) {
+    constructor(doesExist, constraints) {
         super();
+        Object.assign(this, constraints);
         this.doesExist = doesExist;
     }
     validate(value) {

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

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

package/lib/lib/constraints/Required.js

@@ -13,6 +13,10 @@ exports.Required = void 0;
 const knight_misfit_1 = require("knight-misfit");
 const Constraint_1 = require("../Constraint");
 class Required extends Constraint_1.Constraint {
+    constructor(constraints) {
+        super();
+        Object.assign(this, constraints);
+    }
     validate(value) {
         return __awaiter(this, void 0, void 0, function* () {
             return value === undefined ? new knight_misfit_1.Misfit(this.name) : null;

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

@@ -5,7 +5,7 @@ export interface TypeOfMisfitValues extends ConstraintMisfitValues {
     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))[]);
+    types: (string | null | (new (...params: any[]) => any))[];
+    constructor(...valueTypes: (string | null | (new (...params: any[]) => any) | Partial<Constraint>)[]);
     validate(value: any): Promise<Misfit<TypeOfMisfitValues> | null>;
 }

package/lib/lib/constraints/TypeOf.js

@@ -15,14 +15,25 @@ const Constraint_1 = require("../Constraint");
 class TypeOf extends Constraint_1.Constraint {
     constructor(...valueTypes) {
         super();
-        this.valueTypes = valueTypes;
+        this.types = [];
+        for (let i = 0; i < valueTypes.length; i++) {
+            let valueType = valueTypes[i];
+            if (i == valueTypes.length - 1 &&
+                typeof valueType == 'object' &&
+                valueType !== null) {
+                Object.assign(this, valueType);
+            }
+            else if (!(typeof valueType == 'object') || valueType === null) {
+                this.types.push(valueType);
+            }
+        }
     }
     validate(value) {
         return __awaiter(this, void 0, void 0, function* () {
             if (value === undefined) {
                 return null;
             }
-            for (let valueType of this.valueTypes) {
+            for (let valueType of this.types) {
                 if (typeof valueType == 'string') {
                     if (typeof value === valueType) {
                         return null;
@@ -51,7 +62,7 @@ class TypeOf extends Constraint_1.Constraint {
                 actual: actualType,
                 types: []
             });
-            for (let valueType of this.valueTypes) {
+            for (let valueType of this.types) {
                 if (typeof valueType == 'string') {
                     misfit.values.types.push(valueType);
                 }

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

@@ -5,6 +5,6 @@ export interface UniqueMisfitValues extends ConstraintMisfitValues {
 }
 export declare class Unique<T> extends Constraint<T, UniqueMisfitValues> {
     isUnique: (value: T) => Promise<boolean>;
-    constructor(isUnique: (value: T) => Promise<boolean>);
+    constructor(isUnique: (value: T) => Promise<boolean>, constraints?: Partial<Constraint>);
     validate(value: T): Promise<Misfit<UniqueMisfitValues> | null>;
 }

package/lib/lib/constraints/Unique.js

@@ -13,8 +13,9 @@ exports.Unique = void 0;
 const knight_misfit_1 = require("knight-misfit");
 const Constraint_1 = require("../Constraint");
 class Unique extends Constraint_1.Constraint {
-    constructor(isUnique) {
+    constructor(isUnique, constraints) {
         super();
+        Object.assign(this, constraints);
         this.isUnique = isUnique;
     }
     validate(value) {

package/package.json

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