@decaf-ts/decorator-validation 1.5.2 → 1.5.4

package/lib/validation/Validators/PatternValidator.d.ts

@@ -0,0 +1,37 @@
+import { Validator } from "./Validator";
+import { PatternValidatorOptions } from "./types";
+export declare const regexpParser: RegExp;
+/**
+ * @summary Pattern Validator
+ *
+ * @param {string} [key] defaults to {@link ValidationKeys#PATTERN}
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#PATTERN}
+ *
+ * @class PatternValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+export declare class PatternValidator extends Validator<PatternValidatorOptions> {
+    constructor(message?: string);
+    /**
+     * @summary parses and validates a pattern
+     *
+     * @param {string} pattern
+     * @private
+     */
+    private getPattern;
+    /**
+     * @summary Validates a Model
+     *
+     * @param {string} value
+     * @param {PatternValidatorOptions} options
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value: string, options: PatternValidatorOptions): string | undefined;
+}

package/lib/validation/Validators/RequiredValidator.cjs

@@ -0,0 +1,62 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredValidator = void 0;
+const Validator_1 = require("./Validator/index.cjs");
+const constants_1 = require("./constants/index.cjs");
+const decorators_1 = require("./decorators/index.cjs");
+/**
+ * @summary Required Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#REQUIRED}
+ *
+ * @class RequiredValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+let RequiredValidator = class RequiredValidator extends Validator_1.Validator {
+    constructor(message = constants_1.DEFAULT_ERROR_MESSAGES.REQUIRED) {
+        super(message);
+    }
+    /**
+     * @summary Validates a model
+     *
+     * @param {string} value
+     * @param {ValidatorOptions} [options={}]
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value, options = {}) {
+        switch (typeof value) {
+            case "boolean":
+            case "number":
+                return typeof value === "undefined"
+                    ? this.getMessage(options.message || this.message)
+                    : undefined;
+            default:
+                return !value
+                    ? this.getMessage(options.message || this.message)
+                    : undefined;
+        }
+    }
+};
+exports.RequiredValidator = RequiredValidator;
+exports.RequiredValidator = RequiredValidator = __decorate([
+    (0, decorators_1.validator)(constants_1.ValidationKeys.REQUIRED),
+    __metadata("design:paramtypes", [String])
+], RequiredValidator);
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/validation/Validators/RequiredValidator.d.ts

@@ -0,0 +1,28 @@
+import { Validator } from "./Validator";
+import { ValidatorOptions } from "./types";
+/**
+ * @summary Required Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#REQUIRED}
+ *
+ * @class RequiredValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+export declare class RequiredValidator extends Validator {
+    constructor(message?: string);
+    /**
+     * @summary Validates a model
+     *
+     * @param {string} value
+     * @param {ValidatorOptions} [options={}]
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value: any, options?: ValidatorOptions): string | undefined;
+}

package/lib/validation/Validators/StepValidator.cjs

@@ -0,0 +1,57 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepValidator = void 0;
+const Validator_1 = require("./Validator/index.cjs");
+const constants_1 = require("./constants/index.cjs");
+const decorators_1 = require("./decorators/index.cjs");
+/**
+ * @summary Step Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#STEP}
+ *
+ * @class StepValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+let StepValidator = class StepValidator extends Validator_1.Validator {
+    constructor(message = constants_1.DEFAULT_ERROR_MESSAGES.STEP) {
+        super(message, "number", "string");
+    }
+    /**
+     * @summary Validates a model
+     *
+     * @param {string} value
+     * @param {number} step
+     * @param {StepValidatorOptions} options
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value, options) {
+        if (typeof value === "undefined")
+            return;
+        return Number(value) % Number(options.step) !== 0
+            ? this.getMessage(options.message || this.message, options.step)
+            : undefined;
+    }
+};
+exports.StepValidator = StepValidator;
+exports.StepValidator = StepValidator = __decorate([
+    (0, decorators_1.validator)(constants_1.ValidationKeys.STEP),
+    __metadata("design:paramtypes", [String])
+], StepValidator);
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/validation/Validators/StepValidator.d.ts

@@ -0,0 +1,29 @@
+import { Validator } from "./Validator";
+import { StepValidatorOptions } from "./types";
+/**
+ * @summary Step Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#STEP}
+ *
+ * @class StepValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+export declare class StepValidator extends Validator<StepValidatorOptions> {
+    constructor(message?: string);
+    /**
+     * @summary Validates a model
+     *
+     * @param {string} value
+     * @param {number} step
+     * @param {StepValidatorOptions} options
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value: number | string, options: StepValidatorOptions): string | undefined;
+}

package/lib/validation/Validators/TypeValidator.cjs

@@ -0,0 +1,65 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeValidator = void 0;
+const Validator_1 = require("./Validator/index.cjs");
+const constants_1 = require("./constants/index.cjs");
+const decorators_1 = require("./decorators/index.cjs");
+const Validation_1 = require("../Validation/index.cjs");
+const constants_2 = require("../../utils/constants/index.cjs");
+const reflection_1 = require("@decaf-ts/reflection");
+/**
+ * @summary Required Validator
+ *
+ * @class RequiredValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+let TypeValidator = class TypeValidator extends Validator_1.Validator {
+    constructor(message = constants_1.DEFAULT_ERROR_MESSAGES.TYPE) {
+        super(message);
+    }
+    /**
+     * @summary Validates a model
+     * @param {string} value
+     * @param {TypeValidatorOptions} options
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value, options) {
+        if (value === undefined)
+            return; // Don't try and enforce type if undefined
+        const { types, message } = options;
+        if (!reflection_1.Reflection.evaluateDesignTypes(value, types))
+            return this.getMessage(message || this.message, typeof types === "string"
+                ? types
+                : Array.isArray(types)
+                    ? types.join(", ")
+                    : types.name, typeof value);
+    }
+};
+exports.TypeValidator = TypeValidator;
+exports.TypeValidator = TypeValidator = __decorate([
+    (0, decorators_1.validator)(constants_1.ValidationKeys.TYPE),
+    __metadata("design:paramtypes", [String])
+], TypeValidator);
+Validation_1.Validation.register({
+    validator: TypeValidator,
+    validationKey: constants_2.ModelKeys.TYPE,
+    save: false,
+});
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/validation/Validators/TypeValidator.d.ts

@@ -0,0 +1,25 @@
+import { Validator } from "./Validator";
+import { TypeValidatorOptions } from "./types";
+/**
+ * @summary Required Validator
+ *
+ * @class RequiredValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+export declare class TypeValidator extends Validator<TypeValidatorOptions> {
+    constructor(message?: string);
+    /**
+     * @summary Validates a model
+     * @param {string} value
+     * @param {TypeValidatorOptions} options
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value: any, options: TypeValidatorOptions): string | undefined;
+}

package/lib/validation/Validators/URLValidator.cjs

@@ -0,0 +1,54 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.URLValidator = void 0;
+const constants_1 = require("./constants/index.cjs");
+const PatternValidator_1 = require("./PatternValidator/index.cjs");
+const decorators_1 = require("./decorators/index.cjs");
+/**
+ * @summary URL Validator
+ * @description Pattern from {@link https://gist.github.com/dperini/729294}
+ *
+ * @class URLValidator
+ * @extends PatternValidator
+ *
+ * @category Validators
+ */
+let URLValidator = class URLValidator extends PatternValidator_1.PatternValidator {
+    constructor(message = constants_1.DEFAULT_ERROR_MESSAGES.URL) {
+        super(message);
+    }
+    /**
+     * @summary Validates a model
+     *
+     * @param {string} value
+     * @param {PatternValidatorOptions} [options={}]
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value, options = {}) {
+        return super.hasErrors(value, {
+            ...options,
+            pattern: options.pattern || constants_1.DEFAULT_PATTERNS.URL,
+        });
+    }
+};
+exports.URLValidator = URLValidator;
+exports.URLValidator = URLValidator = __decorate([
+    (0, decorators_1.validator)(constants_1.ValidationKeys.URL),
+    __metadata("design:paramtypes", [String])
+], URLValidator);
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/validation/Validators/URLValidator.d.ts

@@ -0,0 +1,27 @@
+import { PatternValidator } from "./PatternValidator";
+import { PatternValidatorOptions } from "./types";
+/**
+ * @summary URL Validator
+ * @description Pattern from {@link https://gist.github.com/dperini/729294}
+ *
+ * @class URLValidator
+ * @extends PatternValidator
+ *
+ * @category Validators
+ */
+export declare class URLValidator extends PatternValidator {
+    constructor(message?: string);
+    /**
+     * @summary Validates a model
+     *
+     * @param {string} value
+     * @param {PatternValidatorOptions} [options={}]
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value: string, options?: PatternValidatorOptions): string | undefined;
+}

package/lib/validation/Validators/Validator.cjs

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validator = void 0;
+const constants_1 = require("./constants/index.cjs");
+const strings_1 = require("../../utils/strings/index.cjs");
+const reflection_1 = require("@decaf-ts/reflection");
+/**
+ * @summary Base Implementation for Validators
+ * @description Provides the underlying functionality for {@link Validator}s
+ *
+ * @param {string} validationKey the key to register the validator under
+ * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#DEFAULT}
+ * @param {string[]} [acceptedTypes] defines the value types this validator can validate
+ *
+ * @class Validator
+ * @abstract
+ * @category Validators
+ */
+class Validator {
+    constructor(message = constants_1.DEFAULT_ERROR_MESSAGES.DEFAULT, ...acceptedTypes) {
+        this.message = message;
+        if (acceptedTypes.length)
+            this.acceptedTypes = acceptedTypes;
+        if (this.acceptedTypes)
+            this.hasErrors = this.checkTypeAndHasErrors(this.hasErrors.bind(this));
+    }
+    /**
+     * @summary builds the error message
+     * @param {string} message
+     * @param {any[]} args
+     * @protected
+     */
+    getMessage(message, ...args) {
+        return (0, strings_1.sf)(message, ...args);
+    }
+    /**
+     * @summary Validates type
+     * @param {any} unbound
+     * @private
+     */
+    checkTypeAndHasErrors(unbound) {
+        return function (value, ...args) {
+            if (value === undefined || !this.acceptedTypes)
+                return unbound(value, ...args);
+            if (!reflection_1.Reflection.checkTypes(value, this.acceptedTypes))
+                return this.getMessage(constants_1.DEFAULT_ERROR_MESSAGES.TYPE, this.acceptedTypes.join(", "), typeof value);
+            return unbound(value, ...args);
+        }.bind(this);
+    }
+}
+exports.Validator = Validator;
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/validation/Validators/Validator.d.ts

@@ -0,0 +1,41 @@
+import { ValidatorOptions } from "./types";
+/**
+ * @summary Base Implementation for Validators
+ * @description Provides the underlying functionality for {@link Validator}s
+ *
+ * @param {string} validationKey the key to register the validator under
+ * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#DEFAULT}
+ * @param {string[]} [acceptedTypes] defines the value types this validator can validate
+ *
+ * @class Validator
+ * @abstract
+ * @category Validators
+ */
+export declare abstract class Validator<V extends ValidatorOptions = ValidatorOptions> {
+    readonly message: string;
+    readonly acceptedTypes?: string[];
+    protected constructor(message?: string, ...acceptedTypes: string[]);
+    /**
+     * @summary builds the error message
+     * @param {string} message
+     * @param {any[]} args
+     * @protected
+     */
+    protected getMessage(message: string, ...args: any[]): string;
+    /**
+     * @summary Validates type
+     * @param {any} unbound
+     * @private
+     */
+    private checkTypeAndHasErrors;
+    /**
+     * @summary Validates an attribute
+     * @param {any} value
+     * @param {ValidatorOptions} [options] Validate options for customizing the model validation behavior
+     *
+     * @abstract
+     *
+     * @see Model#hasErrors
+     */
+    abstract hasErrors(value: any, options?: V): string | undefined;
+}

package/lib/validation/Validators/ValidatorRegistry.cjs

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidatorRegistry = void 0;
+exports.isValidator = isValidator;
+/**
+ * @summary Duck typing for Validators
+ * @function isValidator
+ * @param val
+ */
+function isValidator(val) {
+    return val.constructor && val["hasErrors"];
+}
+/**
+ * @summary Base Implementation of a Validator Registry
+ *
+ * @prop {Validator[]} [validators] the initial validators to register
+ *
+ * @class ValidatorRegistry
+ * @implements IValidatorRegistry<T>
+ *
+ * @category Validation
+ */
+class ValidatorRegistry {
+    constructor(...validators) {
+        this.cache = {};
+        this.customKeyCache = {};
+        this.register(...validators);
+    }
+    /**
+     * @summary retrieves the custom keys
+     */
+    getCustomKeys() {
+        return Object.assign({}, this.customKeyCache);
+    }
+    /**
+     * @summary retrieves the registered validators keys
+     */
+    getKeys() {
+        return Object.keys(this.cache);
+    }
+    /**
+     * @summary Retrieves a validator
+     *
+     * @param {string} validatorKey one of the {@link ValidationKeys}
+     * @return {Validator | undefined} the registered Validator or undefined if there is nono matching the provided key
+     */
+    get(validatorKey) {
+        if (!(validatorKey in this.cache))
+            return undefined;
+        const classOrInstance = this.cache[validatorKey];
+        if (isValidator(classOrInstance))
+            return classOrInstance;
+        const constructor = classOrInstance.default || classOrInstance;
+        const instance = new constructor();
+        this.cache[validatorKey] = instance;
+        return instance;
+    }
+    /**
+     * @summary Registers the provided validators onto the registry
+     *
+     * @param {T[] | ValidatorDefinition[]} validator
+     */
+    register(...validator) {
+        validator.forEach((v) => {
+            if (isValidator(v)) {
+                // const k =
+                if (v.validationKey in this.cache)
+                    return;
+                this.cache[v.validationKey] = v;
+            }
+            else {
+                const { validationKey, validator, save } = v;
+                if (validationKey in this.cache)
+                    return;
+                this.cache[validationKey] = validator;
+                if (!save)
+                    return;
+                const obj = {};
+                obj[validationKey.toUpperCase()] = validationKey;
+                this.customKeyCache = Object.assign({}, this.customKeyCache, obj);
+            }
+        });
+    }
+}
+exports.ValidatorRegistry = ValidatorRegistry;
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/validation/Validators/ValidatorRegistry.d.ts

@@ -0,0 +1,47 @@
+import { ValidatorDefinition } from "./types";
+import { IValidatorRegistry } from "./types";
+import type { Validator } from "./Validator";
+/**
+ * @summary Duck typing for Validators
+ * @function isValidator
+ * @param val
+ */
+export declare function isValidator(val: any): any;
+/**
+ * @summary Base Implementation of a Validator Registry
+ *
+ * @prop {Validator[]} [validators] the initial validators to register
+ *
+ * @class ValidatorRegistry
+ * @implements IValidatorRegistry<T>
+ *
+ * @category Validation
+ */
+export declare class ValidatorRegistry<T extends Validator> implements IValidatorRegistry<T> {
+    private cache;
+    private customKeyCache;
+    constructor(...validators: (ValidatorDefinition | Validator)[]);
+    /**
+     * @summary retrieves the custom keys
+     */
+    getCustomKeys(): {
+        [indexer: string]: string;
+    };
+    /**
+     * @summary retrieves the registered validators keys
+     */
+    getKeys(): string[];
+    /**
+     * @summary Retrieves a validator
+     *
+     * @param {string} validatorKey one of the {@link ValidationKeys}
+     * @return {Validator | undefined} the registered Validator or undefined if there is nono matching the provided key
+     */
+    get<T extends Validator>(validatorKey: string): T | undefined;
+    /**
+     * @summary Registers the provided validators onto the registry
+     *
+     * @param {T[] | ValidatorDefinition[]} validator
+     */
+    register<T extends Validator>(...validator: (ValidatorDefinition | T)[]): void;
+}