thesimplevalidation 1.2.0 → 2.1.0

package/src/validator.ts

@@ -1,25 +0,0 @@
-import { IValidationPropertyResult } from "./validation-property-result";
-import { IValidatorSetup } from "./validator-setup";
-
-export abstract class Validator<TModel, K extends keyof TModel, TSetup extends IValidatorSetup<TModel, K> = IValidatorSetup<TModel, K>> {
-
-    constructor(protected setup: TSetup) { }
-
-    public isValid = async (value: TModel[K], model: TModel, field: K): Promise<IValidationPropertyResult> => {
-        if (this.setup.isDisabled != null && this.setup.isDisabled(value)) {
-            return {
-                isValid: true,
-                errors: []
-            };
-        }
-
-        const result: IValidationPropertyResult = await this.isValidInternal(value, model, field);
-        if (result.isValid !== true && this.setup.getErrors != null) {
-            result.errors = this.setup.getErrors(value);
-        }
-
-        return result;
-    }
-
-    protected abstract isValidInternal(value: TModel[K], model: TModel, field: K): Promise<IValidationPropertyResult>;
-}

package/src/validators/boolean/index.ts

@@ -1,27 +0,0 @@
-import { IValidationPropertyResult } from "../../validation-property-result";
-import { IValidatorSetup } from "../../validator-setup";
-import { Validator } from "../../validator";
-
-export interface IBooleanValidatorSetup<TModel, K extends keyof TModel> extends IValidatorSetup<TModel, K> {
-    target: () => boolean;
-}
-
-export class BooleanValidator<TModel, K extends keyof TModel> extends Validator<TModel, K, IBooleanValidatorSetup<TModel, K>> {
-    constructor(setup: IBooleanValidatorSetup<TModel, K>) {
-        super(setup);
-    }
-
-    public async isValidInternal(value: TModel[K]): Promise<IValidationPropertyResult> {
-        let isValid: boolean = true;
-        const targetValue: boolean = this.setup.target();
-
-        if (value != null && typeof value === "boolean") {
-            isValid = targetValue === value;
-        }
-
-        return {
-            isValid: isValid,
-            errors: []
-        };
-    }
-}

package/src/validators/index.ts

@@ -1,5 +0,0 @@
-export { SimpleValidator, ISimpleValidatorSetup } from "./simple";
-export { BooleanValidator, IBooleanValidatorSetup } from "./boolean";
-export { RequiredValidator } from "./required";
-export { MinValidator, IMinValidatorSetup } from "./min";
-export { MaxValidator, IMaxValidatorSetup } from "./max";

package/src/validators/max/__tests__/index.test.ts

@@ -1,92 +0,0 @@
-import { MaxValidator } from "..";
-
-describe("[validation].[MaxValidator] checking", () => {
-    test("[validation].[MaxValidator]: null", async () => {
-        const validator = new MaxValidator<{ value: string | null }, "value">({
-            maxValue: () => 1,
-        });
-        const result = await validator.isValidInternal(null);
-        expect(result.isValid).toEqual(true);
-    });
-
-    test("[validation].[MaxValidator]: function", async () => {
-        const validator = new MaxValidator<{ value: () => void; }, "value">({
-            maxValue: () => 1
-        });
-        const result = await validator.isValidInternal(() => { return; });
-        expect(result.isValid).toEqual(true);
-    });
-
-    test("[validation].[MaxValidator]: Empty String. Max=1", async () => {
-        const validator = new MaxValidator<{ value: string; }, "value">({
-            maxValue: () => 1
-        });
-        const result = await validator.isValidInternal("");
-        expect(result.isValid).toEqual(true);
-    });
-
-    test("[validation].[MaxValidator]: Empty String. Max=0", async () => {
-        const validator = new MaxValidator<{ value: string; }, "value">({
-            maxValue: () => 0
-        });
-        const result = await validator.isValidInternal("");
-        expect(result.isValid).toEqual(true);
-    });
-
-    test("[validation].[MaxValidator]: Empty Array. Max=1", async () => {
-        const validator = new MaxValidator<{ value: string[]; }, "value">({
-            maxValue: () => 1
-        });
-        const result = await validator.isValidInternal([]);
-        expect(result.isValid).toEqual(true);
-    });
-
-    test("[validation].[MaxValidator]: Empty Array. Max=0", async () => {
-        const validator = new MaxValidator<{ value: string[]; }, "value">({
-            maxValue: () => 0
-        });
-        const result = await validator.isValidInternal([]);
-        expect(result.isValid).toEqual(true);
-    });
-
-    test("[validation].[MaxValidator]: 0. Max=0", async () => {
-        const validator = new MaxValidator<{ value: number; }, "value">({
-            maxValue: () => 0
-        });
-        const result = await validator.isValidInternal(0);
-        expect(result.isValid).toEqual(true);
-    });
-
-    test("[validation].[MaxValidator]: 0. Max=1", async () => {
-        const validator = new MaxValidator<{ value: number; }, "value">({
-            maxValue: () => 1
-        });
-        const result = await validator.isValidInternal(0);
-        expect(result.isValid).toEqual(true);
-    });
-
-    test("[validation].[MaxValidator]: 1. Max=1", async () => {
-        const validator = new MaxValidator<{ value: number; }, "value">({
-            maxValue: () => 1
-        });
-        const result = await validator.isValidInternal(0);
-        expect(result.isValid).toEqual(true);
-    });
-
-    test("[validation].[MaxValidator]: 2. Max=1", async () => {
-        const validator = new MaxValidator<{ value: number; }, "value">({
-            maxValue: () => 1
-        });
-        const result = await validator.isValidInternal(2);
-        expect(result.isValid).toEqual(false);
-    });
-
-    test("[validation].[MaxValidator]: Disabled", async () => {
-        const validator = new MaxValidator<{ value: number; }, "value">({
-            maxValue: () => 1,
-            isDisabled: () => true
-        });
-        const result = await validator.isValid(2, { value: 2 }, "value");
-        expect(result.isValid).toEqual(true);
-    });
-});

package/src/validators/max/index.ts

@@ -1,32 +0,0 @@
-import { IValidatorSetup } from "../../validator-setup";
-import { IValidationPropertyResult } from "../../validation-property-result";
-import { Validator } from "../../validator";
-
-export interface IMaxValidatorSetup<TModel, K extends keyof TModel> extends IValidatorSetup<TModel, K> {
-    maxValue: () => number;
-}
-
-export class MaxValidator<TModel, K extends keyof TModel> extends Validator<TModel, K, IMaxValidatorSetup<TModel, K>> {
-    constructor(setup: IMaxValidatorSetup<TModel, K>) {
-        super(setup);
-    }
-
-    public async isValidInternal(value: TModel[K]): Promise<IValidationPropertyResult> {
-        let isValid: boolean = true;
-        if (value != null) {
-            const maxValue: number = this.setup.maxValue();
-            if (Array.isArray(value)) {
-                isValid = value.length <= maxValue;
-            } else if (typeof value === "string") {
-                isValid = value.length <= maxValue;
-            } else if (typeof value === "number") {
-                isValid = value <= maxValue;
-            }
-        }
-
-        return {
-            isValid: isValid,
-            errors: []
-        };
-    }
-}

package/src/validators/min/__tests__/index.test.ts

@@ -1,92 +0,0 @@
-import { MinValidator } from "..";
-
-describe("[validation].[MinValidator] checking", () => {
-    test("[validation].[MinValidator]: null", async () => {
-        const validator = new MinValidator<{ value: string | null; }, "value">({
-            minValue: () => 1
-        });
-        const result = await validator.isValidInternal(null);
-        expect(result.isValid).toEqual(true);
-    });
-
-    test("[validation].[MinValidator]: function", async () => {
-        const validator = new MinValidator<{ value: () => void; }, "value">({
-            minValue: () => 1
-        });
-        const result = await validator.isValidInternal(() => { return; });
-        expect(result.isValid).toEqual(true);
-    });
-
-    test("[validation].[MinValidator]: Empty String. Min=1", async () => {
-        const validator = new MinValidator<{ value: string; }, "value">({
-            minValue: () => 1
-        });
-        const result = await validator.isValidInternal("");
-        expect(result.isValid).toEqual(false);
-    });
-
-    test("[validation].[MinValidator]: Empty String. Min=0", async () => {
-        const validator = new MinValidator<{ value: string; }, "value">({
-            minValue: () => 0
-        });
-        const result = await validator.isValidInternal("");
-        expect(result.isValid).toEqual(true);
-    });
-
-    test("[validation].[MinValidator]: Empty Array. Min=1", async () => {
-        const validator = new MinValidator<{ value: string[]; }, "value">({
-            minValue: () => 1
-        });
-        const result = await validator.isValidInternal([]);
-        expect(result.isValid).toEqual(false);
-    });
-
-    test("[validation].[MinValidator]: Empty Array. Min=0", async () => {
-        const validator = new MinValidator<{ value: string[]; }, "value">({
-            minValue: () => 0
-        });
-        const result = await validator.isValidInternal([]);
-        expect(result.isValid).toEqual(true);
-    });
-
-    test("[validation].[MinValidator]: 0. Min=0", async () => {
-        const validator = new MinValidator<{ value: number; }, "value">({
-            minValue: () => 0
-        });
-        const result = await validator.isValidInternal(0);
-        expect(result.isValid).toEqual(true);
-    });
-
-    test("[validation].[MinValidator]: 0. Min=1", async () => {
-        const validator = new MinValidator<{ value: number; }, "value">({
-            minValue: () => 1
-        });
-        const result = await validator.isValidInternal(0);
-        expect(result.isValid).toEqual(false);
-    });
-
-    test("[validation].[MinValidator]: 1. Min=1", async () => {
-        const validator = new MinValidator<{ value: number; }, "value">({
-            minValue: () => 1
-        });
-        const result = await validator.isValidInternal(0);
-        expect(result.isValid).toEqual(false);
-    });
-
-    test("[validation].[MinValidator]: 8. Min=9", async () => {
-        const validator = new MinValidator<{ value: number; }, "value">({
-            minValue: () => 9
-        });
-        const result = await validator.isValidInternal(8);
-        expect(result.isValid).toEqual(false);
-    });
-
-    test("[validation].[MinValidator]: Disabled", async () => {
-        const validator = new MinValidator<{ value: number; }, "value">({
-            minValue: () => 9,
-            isDisabled: () => true
-        });
-        const result = await validator.isValid(8, { value: 8 }, "value");
-        expect(result.isValid).toEqual(true);
-    });
-});

package/src/validators/min/index.ts

@@ -1,33 +0,0 @@
-import { IValidationPropertyResult } from "../../validation-property-result";
-import { IValidatorSetup } from "../../validator-setup";
-import { Validator } from "../../validator";
-
-export interface IMinValidatorSetup<TModel, K extends keyof TModel> extends IValidatorSetup<TModel, K> {
-    minValue: () => number;
-}
-
-export class MinValidator<TModel, K extends keyof TModel> extends Validator<TModel, K, IMinValidatorSetup<TModel, K>> {
-    constructor(setup: IMinValidatorSetup<TModel, K>) {
-        super(setup);
-    }
-
-    public async isValidInternal(value: TModel[K]): Promise<IValidationPropertyResult> {
-        let isValid: boolean = true;
-        if (value != null) {
-            const minValue: number = this.setup.minValue();
-            // tslint:disable-next-line:prefer-conditional-expression
-            if (Array.isArray(value)) {
-                isValid = value.length >= minValue;
-            } else if (typeof value === "string") {
-                isValid = value.length >= minValue;
-            } else if (typeof value === "number") {
-                isValid = value >= minValue;
-            }
-        }
-
-        return {
-            isValid: isValid,
-            errors: []
-        };
-    }
-}

package/src/validators/required/__tests__/index.test.ts

@@ -1,229 +0,0 @@
-import { Validator } from "../../../validator";
-import { RequiredValidator } from "..";
-
-// String check
-test("[validation].[RequiredValidator]: check null string", async () => {
-    interface IModelType {
-        val: string | null;
-    }
-
-    const model: IModelType = {
-        val: null
-    };
-
-    const validator: Validator<IModelType, "val"> = new RequiredValidator({
-        getErrors: () => ["Error.Message"]
-    });
-    await expect(validator.isValid(model.val, model, "val"))
-        .resolves
-        .toEqual({ errors: ["Error.Message"], isValid: false });
-});
-
-test("[validation].[RequiredValidator]: check empty string", async () => {
-    interface IModelType {
-        val: string | null;
-    }
-
-    const model: IModelType = {
-        val: ""
-    };
-
-    const validator: Validator<IModelType, "val"> = new RequiredValidator({
-        getErrors: () => ["Error.Message"]
-    });
-    await expect(validator.isValid(model.val, model, "val"))
-        .resolves
-        .toEqual({ errors: ["Error.Message"], isValid: false });
-});
-
-test("[validation].[RequiredValidator]: check non-empty string", async () => {
-    interface IModelType {
-        val: string | null;
-    }
-
-    const model: IModelType = {
-        val: "HelloWorld"
-    };
-
-    const validator: Validator<IModelType, "val"> = new RequiredValidator({
-        getErrors: () => ["Error.Message"]
-    });
-    await expect(validator.isValid(model.val, model, "val"))
-        .resolves
-        .toEqual({ errors: [], isValid: true });
-});
-
-// Number check
-test("[validation].[RequiredValidator]: check null number", async () => {
-    interface IModelType {
-        val: number | null;
-    }
-
-    const model: IModelType = {
-        val: null
-    };
-
-    const validator: Validator<IModelType, "val"> = new RequiredValidator({
-        getErrors: () => ["Error.Message"]
-    });
-    await expect(validator.isValid(model.val, model, "val"))
-        .resolves
-        .toEqual({ errors: ["Error.Message"], isValid: false });
-});
-
-test("[validation].[RequiredValidator]: check 0 number", async () => {
-    interface IModelType {
-        val: number | null;
-    }
-
-    const model: IModelType = {
-        val: 0
-    };
-
-    const validator: Validator<IModelType, "val"> = new RequiredValidator({
-        getErrors: () => ["Error.Message"]
-    });
-    await expect(validator.isValid(model.val, model, "val"))
-        .resolves
-        .toEqual({ errors: ["Error.Message"], isValid: false });
-});
-
-test("[validation].[RequiredValidator]: check > 0 number", async () => {
-    interface IModelType {
-        val: number | null;
-    }
-
-    const model: IModelType = {
-        val: 0.1
-    };
-
-    const validator: Validator<IModelType, "val"> = new RequiredValidator({
-        getErrors: () => ["Error.Message"]
-    });
-    await expect(validator.isValid(model.val, model, "val"))
-        .resolves
-        .toEqual({ errors: [], isValid: true });
-});
-
-test("[validation].[RequiredValidator]: check < 0 number", async () => {
-    interface IModelType {
-        val: number | null;
-    }
-
-    const model: IModelType = {
-        val: -0.1
-    };
-
-    const validator: Validator<IModelType, "val"> = new RequiredValidator({
-        getErrors: () => ["Error.Message"]
-    });
-    await expect(validator.isValid(model.val, model, "val"))
-        .resolves
-        .toEqual({ errors: [], isValid: true });
-});
-
-// Array check
-test("[validation].[RequiredValidator]: check null array", async () => {
-    interface IModelType {
-        val: string[] | null;
-    }
-
-    const model: IModelType = {
-        val: null
-    };
-
-    const validator: Validator<IModelType, "val"> = new RequiredValidator({
-        getErrors: () => ["Error.Message"]
-    });
-    await expect(validator.isValid(model.val, model, "val"))
-        .resolves
-        .toEqual({ errors: ["Error.Message"], isValid: false });
-});
-
-test("[validation].[RequiredValidator]: check empty array", async () => {
-    interface IModelType {
-        val: string[] | null;
-    }
-
-    const model: IModelType = {
-        val: []
-    };
-
-    const validator: Validator<IModelType, "val"> = new RequiredValidator({
-        getErrors: () => ["Error.Message"]
-    });
-    await expect(validator.isValid(model.val, model, "val"))
-        .resolves
-        .toEqual({ errors: ["Error.Message"], isValid: false });
-});
-
-test("[validation].[RequiredValidator]: check non-empty array", async () => {
-    interface IModelType {
-        val: string[] | null;
-    }
-
-    const model: IModelType = {
-        val: ["HelloWorld"]
-    };
-
-    const validator: Validator<IModelType, "val"> = new RequiredValidator({
-        getErrors: () => ["Error.Message"]
-    });
-    await expect(validator.isValid(model.val, model, "val"))
-        .resolves
-        .toEqual({ errors: [], isValid: true });
-});
-
-// Object check
-test("[validation].[RequiredValidator]: check null object", async () => {
-    interface IModelType {
-        val: {} | null;
-    }
-
-    const model: IModelType = {
-        val: null
-    };
-
-    const validator: Validator<IModelType, "val"> = new RequiredValidator({
-        getErrors: () => ["Error.Message"]
-    });
-    await expect(validator.isValid(model.val, model, "val"))
-        .resolves
-        .toEqual({ errors: ["Error.Message"], isValid: false });
-});
-
-test("[validation].[RequiredValidator]: check non-null object", async () => {
-    interface IModelType {
-        val: {} | null;
-    }
-
-    const model: IModelType = {
-        val: {}
-    };
-
-    const validator: Validator<IModelType, "val"> = new RequiredValidator({
-        getErrors: () => ["Error.Message"]
-    });
-    await expect(validator.isValid(model.val, model, "val"))
-        .resolves
-        .toEqual({ errors: [], isValid: true });
-});
-
-// Disabling
-test("[validation].[RequiredValidator]: disabling check", async () => {
-    interface IModelType {
-        val: {} | null;
-    }
-
-    const model: IModelType = {
-        val: null
-    };
-
-    const validator: Validator<IModelType, "val"> = new RequiredValidator({
-        getErrors: () => ["Error.Message"],
-        isDisabled: () => true
-    });
-    await expect(validator.isValid(model.val, model, "val"))
-        .resolves
-        .toEqual({ errors: [], isValid: true });
-});

package/src/validators/required/index.ts

@@ -1,24 +0,0 @@
-import { IValidationPropertyResult } from "../../validation-property-result";
-import { IValidatorSetup } from "../../validator-setup";
-import { Validator } from "../../validator";
-
-export class RequiredValidator<TModel, K extends keyof TModel> extends Validator<TModel, K> {
-    constructor(setup: IValidatorSetup<TModel, K> = {}) {
-        super(setup);
-    }
-
-    public async isValidInternal(value: TModel[K]): Promise<IValidationPropertyResult> {
-        let isValid: boolean = true;
-        // tslint:disable-next-line:prefer-conditional-expression
-        if (Array.isArray(value)) {
-            isValid = value.length > 0;
-        } else {
-            isValid = !!value;
-        }
-
-        return {
-            isValid: isValid,
-            errors: []
-        };
-    }
-}

package/src/validators/simple/index.ts

@@ -1,22 +0,0 @@
-import { IValidationPropertyResult } from "../../validation-property-result";
-import { IValidatorSetup } from "../../validator-setup";
-import { Validator } from "../../validator";
-
-export interface ISimpleValidatorSetup<TModel, K extends keyof TModel> extends IValidatorSetup<TModel, K> {
-    getValidation: () => boolean;
-}
-
-export class SimpleValidator<TModel, K extends keyof TModel> extends Validator<TModel, K, ISimpleValidatorSetup<TModel, K>> {
-    constructor(setup: ISimpleValidatorSetup<TModel, K>) {
-        super(setup);
-    }
-
-    public async isValidInternal(_value: TModel[K]): Promise<IValidationPropertyResult> {
-        const isValid: boolean = this.setup.getValidation();
-
-        return {
-            isValid: isValid,
-            errors: []
-        };
-    }
-}

package/thesimplevalidation.code-workspace

@@ -1,10 +0,0 @@
-{
-	"folders": [
-		{
-			"path": "."
-		}
-	],
-	"settings": {
-		"typescript.tsdk": "node_modules\\typescript\\lib"
-	}
-}

package/tsconfig.json

@@ -1,23 +0,0 @@
-{
-    "compilerOptions": {
-        "outDir": "./dist/",
-        "sourceMap": true,
-        "declaration": true,
-        "noImplicitAny": true,
-        "module": "commonjs",
-        "moduleResolution": "node",
-        "esModuleInterop": true,
-        "noUnusedLocals": true,
-        "noImplicitReturns": true,
-        "traceResolution": false,
-        "allowSyntheticDefaultImports": true,
-        "target": "es5",
-        "lib": [
-            "dom",
-            "es2015"
-        ]
-    },
-    "include": [
-        "./index.ts"
-    ]
-}

package/tslint.json

@@ -1,18 +0,0 @@
-{
-    "defaultSeverity": "error",
-    "extends": [
-        "tslint:recommended"
-    ],
-    "jsRules": {},
-    "rules": {
-        "curly": [true, "ignore-same-line"],
-        "object-literal-shorthand": [true, "never"],
-        "trailing-comma": false,
-        "object-literal-sort-keys": false,
-        "max-line-length": false,
-        "no-console": false,
-        "arrow-parens": false,
-        "ordered-imports": false
-    },
-    "rulesDirectory": []
-}