@decaf-ts/decorator-validation 1.4.21 → 1.5.2

package/lib/esm/model/constants.d.ts

@@ -1,56 +0,0 @@
-/**
- * @summary References the relevant JS primitives
- *
- * @property {string} STRING references the string primitive
- * @property {string} NUMBER references the number primitive
- * @property {string} BOOLEAN references the boolean primitive
- * @property {string} BIGINT references the bigint primitive
- *
- * @constant Primitives
- * @memberOf module:decorator-validation.Model
- */
-export declare enum Primitives {
-    STRING = "string",
-    NUMBER = "number",
-    BOOLEAN = "boolean",
-    BIGINT = "bigint"
-}
-/**
- * @summary References the Reserved model names to ignore during Model rebuilding
- *
- * @property {string} STRING
- * @property {string} OBJECT
- * @property {string} NUMBER
- * @property {string} BOOLEAN
- * @property {string} BIGINT
- * @property {string} DATE
- *
- * @constant ReservedModels
- * @memberOf module:decorator-validation.Model
- */
-export declare enum ReservedModels {
-    STRING = "string",
-    OBJECT = "object",
-    NUMBER = "number",
-    BOOLEAN = "boolean",
-    BIGINT = "bigint",
-    DATE = "date"
-}
-/**
- * @summary References the basic supported js types
- *
- * @property {string} string
- * @property {string} array
- * @property {string} number
- * @property {string} boolean
- * @property {string} symbol
- * @property {string} function
- * @property {string} object
- * @property {string} undefined
- * @property {string} null
- * @property {string} BIGINT
- *
- * @constant jsTypes
- * @memberOf module:decorator-validation.Model
- */
-export declare const jsTypes: string[];

package/lib/esm/model/constants.js

@@ -1,69 +0,0 @@
-/**
- * @summary References the relevant JS primitives
- *
- * @property {string} STRING references the string primitive
- * @property {string} NUMBER references the number primitive
- * @property {string} BOOLEAN references the boolean primitive
- * @property {string} BIGINT references the bigint primitive
- *
- * @constant Primitives
- * @memberOf module:decorator-validation.Model
- */
-export var Primitives;
-(function (Primitives) {
-    Primitives["STRING"] = "string";
-    Primitives["NUMBER"] = "number";
-    Primitives["BOOLEAN"] = "boolean";
-    Primitives["BIGINT"] = "bigint";
-})(Primitives || (Primitives = {}));
-/**
- * @summary References the Reserved model names to ignore during Model rebuilding
- *
- * @property {string} STRING
- * @property {string} OBJECT
- * @property {string} NUMBER
- * @property {string} BOOLEAN
- * @property {string} BIGINT
- * @property {string} DATE
- *
- * @constant ReservedModels
- * @memberOf module:decorator-validation.Model
- */
-export var ReservedModels;
-(function (ReservedModels) {
-    ReservedModels["STRING"] = "string";
-    ReservedModels["OBJECT"] = "object";
-    ReservedModels["NUMBER"] = "number";
-    ReservedModels["BOOLEAN"] = "boolean";
-    ReservedModels["BIGINT"] = "bigint";
-    ReservedModels["DATE"] = "date";
-})(ReservedModels || (ReservedModels = {}));
-/**
- * @summary References the basic supported js types
- *
- * @property {string} string
- * @property {string} array
- * @property {string} number
- * @property {string} boolean
- * @property {string} symbol
- * @property {string} function
- * @property {string} object
- * @property {string} undefined
- * @property {string} null
- * @property {string} BIGINT
- *
- * @constant jsTypes
- * @memberOf module:decorator-validation.Model
- */
-export const jsTypes = [
-    "string",
-    "array",
-    "number",
-    "boolean",
-    "symbol",
-    "function",
-    "object",
-    "undefined",
-    "null",
-    "bigint",
-];

package/lib/esm/model/construction.d.ts

@@ -1,29 +0,0 @@
-import { Model } from "./Model";
-/**
- * @summary Helper Function to override constructors
- *
- * @param {Function} constructor
- * @param {any[]} [args]
- * @return {T} the new instance
- *
- * @function construct
- * @memberOf module:decorator-validation.Construction
- */
-export declare function construct<T extends Model>(constructor: any, ...args: any[]): T;
-/**
- * @summary Recursively finds the last prototype before Object
- * @param {object} obj
- *
- * @function findLastProtoBeforeObject
- * @memberOf module:decorator-validation.Construction
- */
-export declare function findLastProtoBeforeObject(obj: object): object;
-/**
- * @sumary binds the {@link Model} class as a root prototype of the provided instance
- *
- * @param {unknown} obj
- *
- * @function bindModelPrototype
- * @memberOf module:decorator-validation.Construction
- */
-export declare function bindModelPrototype(obj: unknown): void;

package/lib/esm/model/construction.js

@@ -1,63 +0,0 @@
-import { Model } from "./Model";
-/**
- * @summary Helper Function to override constructors
- *
- * @param {Function} constructor
- * @param {any[]} [args]
- * @return {T} the new instance
- *
- * @function construct
- * @memberOf module:decorator-validation.Construction
- */
-export function construct(constructor, ...args) {
-    const _constr = (...argz) => new constructor(...argz);
-    _constr.prototype = constructor.prototype;
-    return _constr(...args);
-}
-/**
- * @summary Recursively finds the last prototype before Object
- * @param {object} obj
- *
- * @function findLastProtoBeforeObject
- * @memberOf module:decorator-validation.Construction
- */
-export function findLastProtoBeforeObject(obj) {
-    let prototype = Object.getPrototypeOf(obj);
-    if (prototype === Object.prototype)
-        return obj;
-    while (prototype !== Object.prototype) {
-        prototype = Object.getPrototypeOf(prototype);
-        if (prototype === Object.prototype)
-            return prototype;
-        if (Object.getPrototypeOf(prototype) === Object.prototype)
-            return prototype;
-    }
-    throw new Error("Could not find proper prototype");
-}
-/**
- * @sumary binds the {@link Model} class as a root prototype of the provided instance
- *
- * @param {unknown} obj
- *
- * @function bindModelPrototype
- * @memberOf module:decorator-validation.Construction
- */
-export function bindModelPrototype(obj) {
-    if (obj instanceof Model)
-        return;
-    function bindPrototype(objToOverride, prototype) {
-        Object.setPrototypeOf(objToOverride, prototype);
-    }
-    const prototype = Object.getPrototypeOf(obj);
-    if (prototype === Object.prototype) {
-        return bindPrototype(obj, Model.prototype);
-    }
-    while (prototype !== Object.prototype) {
-        const prot = Object.getPrototypeOf(prototype);
-        if (prot === Object.prototype ||
-            Object.getPrototypeOf(prot) === Object.prototype) {
-            return bindPrototype(prototype, Model.prototype);
-        }
-    }
-    throw new Error("Could not find proper prototype to bind");
-}

package/lib/esm/model/decorators.d.ts

@@ -1,25 +0,0 @@
-/**
- * @summary defines the tpe os an InstanceCallback function
- *
- * @memberOf module:decorator-validation.Model
- */
-export type InstanceCallback = (instance: any, ...args: any[]) => void;
-/**
- * @summary Defines a class as a Model class
- * @description
- *
- * - Registers the class under the model registry so it can be easily rebuilt;
- * - Overrides the class constructor;
- * - Runs the global {@link ModelBuilderFunction} if defined;
- * - Runs the optional {@link InstanceCallback} if provided;
- *
- * @param {InstanceCallback} [instanceCallback] optional callback that will be called with the instance upon instantiation. defaults to undefined
- *
- * @function model
- *
- * @memberOf module:decorator-validation.Model
- *
- */
-export declare function model(instanceCallback?: InstanceCallback): any;
-export declare function hashedBy(algorithm: string, ...args: any[]): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
-export declare function serializedBy(serializer: string, ...args: any[]): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;

package/lib/esm/model/decorators.js

@@ -1,62 +0,0 @@
-import { bindModelPrototype, construct } from "./construction";
-import { ModelKeys } from "../utils/constants";
-import { Model } from "./Model";
-import { metadata } from "@decaf-ts/reflection";
-/**
- * @summary Defines a class as a Model class
- * @description
- *
- * - Registers the class under the model registry so it can be easily rebuilt;
- * - Overrides the class constructor;
- * - Runs the global {@link ModelBuilderFunction} if defined;
- * - Runs the optional {@link InstanceCallback} if provided;
- *
- * @param {InstanceCallback} [instanceCallback] optional callback that will be called with the instance upon instantiation. defaults to undefined
- *
- * @function model
- *
- * @memberOf module:decorator-validation.Model
- *
- */
-export function model(instanceCallback) {
-    return ((original) => {
-        // the new constructor behaviour
-        const newConstructor = function (...args) {
-            const instance = construct(original, ...args);
-            bindModelPrototype(instance);
-            // run a builder function if defined with the first argument (The ModelArg)
-            const builder = Model.getBuilder();
-            if (builder)
-                builder(instance, args.length ? args[0] : undefined);
-            metadata(Model.key(ModelKeys.MODEL), original.name)(instance.constructor);
-            if (instanceCallback)
-                instanceCallback(instance, ...args);
-            return instance;
-        };
-        // copy prototype so instanceof operator still works
-        newConstructor.prototype = original.prototype;
-        // Sets the proper constructor name for type verification
-        Object.defineProperty(newConstructor, "name", {
-            writable: false,
-            enumerable: true,
-            configurable: false,
-            value: original.prototype.constructor.name,
-        });
-        metadata(Model.key(ModelKeys.MODEL), original.name)(original);
-        Model.register(newConstructor, original.name);
-        // return new constructor (will override original)
-        return newConstructor;
-    });
-}
-export function hashedBy(algorithm, ...args) {
-    return metadata(Model.key(ModelKeys.HASHING), {
-        algorithm: algorithm,
-        args: args,
-    });
-}
-export function serializedBy(serializer, ...args) {
-    return metadata(Model.key(ModelKeys.SERIALIZATION), {
-        serializer: serializer,
-        args: args,
-    });
-}

package/lib/esm/model/index.d.ts

@@ -1,9 +0,0 @@
-export * from "./constants";
-export * from "./construction";
-export * from "./decorators";
-export * from "./Model";
-export * from "./ModelErrorDefinition";
-export * from "./Registry";
-export * from "./types";
-export * from "./utils";
-export * from "./validation";

package/lib/esm/model/index.js

@@ -1,9 +0,0 @@
-export * from "./constants";
-export * from "./construction";
-export * from "./decorators";
-export * from "./Model";
-export * from "./ModelErrorDefinition";
-export * from "./Registry";
-export * from "./types";
-export * from "./utils";
-export * from "./validation";

package/lib/esm/model/types.d.ts

@@ -1,79 +0,0 @@
-import { ModelErrorDefinition } from "./ModelErrorDefinition";
-import { Model } from "./Model";
-/**
- * @summary Typo of a Model builder function
- * @memberOf module:decorator-validation.Construction
- * @category Construction
- */
-export type ModelBuilderFunction = <T extends Model>(self: T, obj?: T | Record<string, any>) => T;
-/**
- * @summary Definition of a Model Constructor Argument
- *
- * @memberOf module:decorator-validation.Model
- * @category Model
- *
- * @see ModelConstructor
- */
-export type ModelArg<T> = T | Record<string, any>;
-/**
- * @summary Definition of a Class Constructor
- * @description Generic type for Constructor functions
- *
- * @typedef Constructor
- *
- * @param {any[]} [args]
- * @memberOf module:decorator-validation.Model
- * @category Model
- */
-export type Constructor<T> = {
-    new (...args: any[]): T;
-};
-/**
- * @summary Definition of a Model Constructor
- * @description Generic type for all Model Constructor functions
- *
- * @typedef ModelConstructor
- *
- * @param {ModelArg<T>} [model]
- * @param {any[]} [args]
- * @memberOf module:decorator-validation.Model
- * @category Construction
- */
-export type ModelConstructor<T extends Model> = {
-    new (model?: ModelArg<T>, ...args: any[]): T;
-};
-/**
- * @summary Defines the Validation API for validatable models
- * @interface Validatable
- *
- * @category Validation
- */
-export interface Validatable {
-    /**
-     * @summary Validates the model and returns the {@link ModelErrorDefinition} if any
-     * @param {any} [args]
-     *
-     * @method
-     */
-    hasErrors(...args: any[]): ModelErrorDefinition | undefined;
-}
-/**
- * @summary Serializable interface
- *
- * @interface Serializable
- *
- * @category Serialization
- */
-export interface Serializable {
-    /**
-     * @summary serializes the model
-     * @method
-     */
-    serialize(): string;
-}
-export interface Hashable {
-    hash(): string;
-}
-export interface Comparable<T> {
-    equals(other: T, ...args: any[]): boolean;
-}

package/lib/esm/model/types.js

@@ -1 +0,0 @@
-export {};

package/lib/esm/model/utils.d.ts

@@ -1,11 +0,0 @@
-import { Model } from "./Model";
-export declare function isPropertyModel<M extends Model>(target: M, attribute: string): boolean | string | undefined;
-/**
- * @summary For Serialization/deserialization purposes.
- * @description Reads the {@link ModelKeys.ANCHOR} property of a {@link Model} to discover the class to instantiate
- *
- * @function isModel
- * @memberOf module:decorator-validation.Validation
- * @category Validation
- */
-export declare function isModel(target: Record<string, any>): boolean;

package/lib/esm/model/utils.js

@@ -1,25 +0,0 @@
-import { ModelKeys } from "../utils/constants";
-import { Model } from "./Model";
-export function isPropertyModel(target, attribute) {
-    if (isModel(target[attribute]))
-        return true;
-    const metadata = Reflect.getMetadata(ModelKeys.TYPE, target, attribute);
-    return Model.get(metadata.name) ? metadata.name : undefined;
-}
-/**
- * @summary For Serialization/deserialization purposes.
- * @description Reads the {@link ModelKeys.ANCHOR} property of a {@link Model} to discover the class to instantiate
- *
- * @function isModel
- * @memberOf module:decorator-validation.Validation
- * @category Validation
- */
-export function isModel(target) {
-    try {
-        return target instanceof Model || !!Model.getMetadata(target);
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    }
-    catch (e) {
-        return false;
-    }
-}

package/lib/esm/model/validation.d.ts

@@ -1,14 +0,0 @@
-import { ModelErrorDefinition } from "./ModelErrorDefinition";
-import { Model } from "./Model";
-/**
- * @summary Analyses the decorations of the properties and validates the obj according to them
- *
- * @typedef T extends Model
- * @prop {T} obj Model object to validate
- * @prop {string[]} [propsToIgnore] object properties to ignore in the validation
- *
- * @function validate
- * @memberOf module:decorator-validation.Validation
- * @category Validation
- */
-export declare function validate<T extends Model>(obj: T, ...propsToIgnore: string[]): ModelErrorDefinition | undefined;

package/lib/esm/model/validation.js

@@ -1,134 +0,0 @@
-import { ModelErrorDefinition } from "./ModelErrorDefinition";
-import { Reflection } from "@decaf-ts/reflection";
-import { ModelKeys } from "../utils/constants";
-import { sf } from "../utils/strings";
-import { ReservedModels } from "./constants";
-import { Validation } from "../validation/Validation";
-import { ValidationKeys } from "../validation/Validators/constants";
-import { isModel } from "./utils";
-/**
- * @summary Analyses the decorations of the properties and validates the obj according to them
- *
- * @typedef T extends Model
- * @prop {T} obj Model object to validate
- * @prop {string[]} [propsToIgnore] object properties to ignore in the validation
- *
- * @function validate
- * @memberOf module:decorator-validation.Validation
- * @category Validation
- */
-export function validate(obj, ...propsToIgnore) {
-    const decoratedProperties = [];
-    for (const prop in obj)
-        if (Object.prototype.hasOwnProperty.call(obj, prop) &&
-            propsToIgnore.indexOf(prop) === -1)
-            decoratedProperties.push(Reflection.getPropertyDecorators(ValidationKeys.REFLECT, obj, prop));
-    let result = undefined;
-    for (const decoratedProperty of decoratedProperties) {
-        const { prop, decorators } = decoratedProperty;
-        if (!decorators || !decorators.length)
-            continue;
-        const defaultTypeDecorator = decorators[0];
-        // tries to find any type decorators or other decorators that already enforce type (the ones with the allowed types property defined). if so, skip the default type verification
-        if (decorators.find((d) => {
-            if (d.key === ValidationKeys.TYPE)
-                return true;
-            return !!d.props.types?.find((t) => t === defaultTypeDecorator.props.name);
-        })) {
-            decorators.shift(); // remove the design:type decorator, since the type will already be checked
-        }
-        let errs = undefined;
-        for (const decorator of decorators) {
-            const validator = Validation.get(decorator.key);
-            if (!validator) {
-                throw new Error(`Missing validator for ${decorator.key}`);
-            }
-            const err = validator.hasErrors(obj[prop.toString()], ...(decorator.key === ModelKeys.TYPE
-                ? [decorator.props]
-                : Object.values(decorator.props)));
-            if (err) {
-                errs = errs || {};
-                errs[decorator.key] = err;
-            }
-        }
-        if (errs) {
-            result = result || {};
-            result[decoratedProperty.prop.toString()] = errs;
-        }
-    }
-    // tests nested classes
-    for (const prop of Object.keys(obj).filter((k) => !result || !result[k])) {
-        let err;
-        // if a nested Model
-        const allDecorators = Reflection.getPropertyDecorators(ValidationKeys.REFLECT, obj, prop).decorators;
-        const decorators = Reflection.getPropertyDecorators(ValidationKeys.REFLECT, obj, prop).decorators.filter((d) => [ModelKeys.TYPE, ValidationKeys.TYPE].indexOf(d.key) !== -1);
-        if (!decorators || !decorators.length)
-            continue;
-        const dec = decorators.pop();
-        const clazz = dec.props.name
-            ? [dec.props.name]
-            : Array.isArray(dec.props.customTypes)
-                ? dec.props.customTypes
-                : [dec.props.customTypes];
-        const reserved = Object.values(ReservedModels).map((v) => v.toLowerCase());
-        for (const c of clazz) {
-            if (reserved.indexOf(c.toLowerCase()) === -1) {
-                const typeDecoratorKey = Array.isArray(obj[prop])
-                    ? ValidationKeys.LIST
-                    : ValidationKeys.TYPE;
-                const types = allDecorators.find((d) => d.key === typeDecoratorKey) || {};
-                let allowedTypes = [];
-                if (types && types.props) {
-                    const customTypes = Array.isArray(obj[prop])
-                        ? types.props.class
-                        : types.props.customTypes;
-                    if (customTypes)
-                        allowedTypes = Array.isArray(customTypes)
-                            ? customTypes.map((t) => `${t}`.toLowerCase())
-                            : [customTypes.toLowerCase()];
-                }
-                const validate = (prop, value) => {
-                    if (typeof value === "object" || typeof value === "function")
-                        return isModel(value)
-                            ? value.hasErrors()
-                            : allowedTypes.includes(typeof value)
-                                ? undefined
-                                : "Value has no validatable type";
-                };
-                switch (c) {
-                    case Array.name:
-                    case Set.name:
-                        if (allDecorators.length) {
-                            const listDec = allDecorators.find((d) => d.key === ValidationKeys.LIST);
-                            if (listDec) {
-                                err = (c === Array.name
-                                    ? obj[prop]
-                                    : // If it's a Set
-                                        obj[prop].values())
-                                    .map((v) => validate(prop, v))
-                                    .filter((e) => !!e);
-                                if (!err?.length) {
-                                    // if the result is an empty list...
-                                    err = undefined;
-                                }
-                            }
-                        }
-                        break;
-                    default:
-                        try {
-                            if (obj[prop])
-                                err = validate(prop, obj[prop]);
-                        }
-                        catch (e) {
-                            console.warn(sf("Model should be validatable but its not: " + e));
-                        }
-                }
-            }
-            if (err) {
-                result = result || {};
-                result[prop] = err;
-            }
-        }
-    }
-    return result ? new ModelErrorDefinition(result) : undefined;
-}

package/lib/esm/utils/constants.d.ts

@@ -1,26 +0,0 @@
-/**
- * @summary Defines the various Model keys used for reflection
- *
- * @property {string} REFLECT prefix to all other keys
- * @property {string} TYPE type key
- * @property {string} PARAMS method params key
- * @property {string} RETURN method return key
- * @property {string} MODEL model key
- * @property {string} ANCHOR anchor key. will serve as a ghost property in the model
- *
- * @constant ModelKeys
- * @memberOf module:decorator-validation.Model
- * @category Model
- */
-export declare enum ModelKeys {
-    REFLECT = "decaf.model.",
-    TYPE = "design:type",
-    PARAMS = "design:paramtypes",
-    RETURN = "design:returntype",
-    MODEL = "model",
-    ANCHOR = "__model",
-    CONSTRUCTION = "constructed-by",
-    ATTRIBUTE = "__attributes",
-    HASHING = "hashing",
-    SERIALIZATION = "serialization"
-}

package/lib/esm/utils/constants.js

@@ -1,27 +0,0 @@
-/**
- * @summary Defines the various Model keys used for reflection
- *
- * @property {string} REFLECT prefix to all other keys
- * @property {string} TYPE type key
- * @property {string} PARAMS method params key
- * @property {string} RETURN method return key
- * @property {string} MODEL model key
- * @property {string} ANCHOR anchor key. will serve as a ghost property in the model
- *
- * @constant ModelKeys
- * @memberOf module:decorator-validation.Model
- * @category Model
- */
-export var ModelKeys;
-(function (ModelKeys) {
-    ModelKeys["REFLECT"] = "decaf.model.";
-    ModelKeys["TYPE"] = "design:type";
-    ModelKeys["PARAMS"] = "design:paramtypes";
-    ModelKeys["RETURN"] = "design:returntype";
-    ModelKeys["MODEL"] = "model";
-    ModelKeys["ANCHOR"] = "__model";
-    ModelKeys["CONSTRUCTION"] = "constructed-by";
-    ModelKeys["ATTRIBUTE"] = "__attributes";
-    ModelKeys["HASHING"] = "hashing";
-    ModelKeys["SERIALIZATION"] = "serialization";
-})(ModelKeys || (ModelKeys = {}));