knight-validation 2.0.1 → 2.0.2

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/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/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.2",
   "description": "A validation lib",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",