@decaf-ts/decorator-validation 1.5.8 → 1.5.10

package/lib/model/Model.js

@@ -1,389 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Model = exports.ModelRegistryManager = void 0;
-exports.isModel = isModel;
-exports.bulkModelRegister = bulkModelRegister;
-const serialization_1 = require("../utils/serialization");
-const reflection_1 = require("@decaf-ts/reflection");
-const validation_1 = require("./validation");
-const hashing_1 = require("../utils/hashing");
-const utils_1 = require("./utils");
-const constants_1 = require("../utils/constants");
-const constants_2 = require("../validation/Validators/constants");
-const strings_1 = require("../utils/strings");
-const constants_3 = require("./constants");
-let modelBuilderFunction;
-let actingModelRegistry;
-/**
- * @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
- */
-function isModel(target) {
-    try {
-        return target instanceof Model || !!Model.getMetadata(target);
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    }
-    catch (e) {
-        return false;
-    }
-}
-/**
- * @summary Util class to enable serialization and correct rebuilding
- *
- * @param {string} anchorKey defaults to {@link ModelKeys.ANCHOR}. The property name where the registered class name is stored;
- * @param {function(Record<string, any>): boolean} [testFunction] method to test if the provided object is a Model Object. defaults to {@link isModel}
- *
- * @class ModelRegistryManager
- * @implements ModelRegistry
- *
- * @category Model
- */
-class ModelRegistryManager {
-    constructor(testFunction = isModel) {
-        this.cache = {};
-        this.testFunction = testFunction;
-    }
-    /**
-     * @summary register new Models
-     * @param {any} constructor
-     * @param {string} [name] when not defined, the name of the constructor will be used
-     */
-    register(constructor, name) {
-        if (typeof constructor !== "function")
-            throw new Error("Model registering failed. Missing Class name or constructor");
-        name = name || constructor.name;
-        this.cache[name] = constructor;
-    }
-    /**
-     * @summary Gets a registered Model {@link ModelConstructor}
-     * @param {string} name
-     */
-    get(name) {
-        try {
-            return this.cache[name];
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        }
-        catch (e) {
-            return undefined;
-        }
-    }
-    /**
-     * @param {Record<string, any>} obj
-     * @param {string} [clazz] when provided, it will attempt to find the matching constructor
-     *
-     * @throws Error If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property
-     */
-    build(obj = {}, clazz) {
-        if (!clazz && !this.testFunction(obj))
-            throw new Error("Provided obj is not a Model object");
-        const name = clazz || Model.getMetadata(obj);
-        if (!(name in this.cache))
-            throw new Error((0, strings_1.sf)("Provided class {0} is not a registered Model object", name));
-        return new this.cache[name](obj);
-    }
-}
-exports.ModelRegistryManager = ModelRegistryManager;
-/**
- * @summary Bulk Registers Models
- * @description Useful when using bundlers that might not evaluate all the code at once
- *
- * @param {Array<Constructor<T>> | Array<{name: string, constructor: Constructor<T>}>} [models]
- *
- * @memberOf module:decorator-validation.Model
- * @category Model
- */
-function bulkModelRegister(...models) {
-    models.forEach((m) => {
-        const constructor = (m.constructor ? m.constructor : m);
-        Model.register(constructor, m.name);
-    });
-}
-/**
- * @summary Abstract class representing a Validatable Model object
- * @description Meant to be used as a base class for all Model classes
- *
- * Model objects must:
- *  - Have all their required properties marked with '!';
- *  - Have all their optional properties marked as '?':
- *
- * @param {Model | {}} model base object from which to populate properties from
- *
- * @class Model
- * @abstract
- * @implements Validatable
- * @implements Serializable
- *
- * @example
- *      class ClassName {
- *          @required()
- *          requiredPropertyName!: PropertyType;
- *
- *          optionalPropertyName?: PropertyType;
- *      }
- */
-class Model {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    constructor(arg) { }
-    /**
-     * @summary Validates the object according to its decorated properties
-     *
-     * @param {any[]} [exceptions] properties in the object to be ignored for the validation. Marked as 'any' to allow for extension but expects strings
-     */
-    hasErrors(...exceptions) {
-        return (0, validation_1.validate)(this, ...exceptions);
-    }
-    /**
-     * @summary Compare object equality recursively
-     * @param {any} obj object to compare to
-     * @param {string} [exceptions] property names to be excluded from the comparison
-     */
-    equals(obj, ...exceptions) {
-        return (0, reflection_1.isEqual)(this, obj, ...exceptions);
-    }
-    /**
-     * @summary Returns the serialized model according to the currently defined {@link Serializer}
-     */
-    serialize() {
-        return Model.serialize(this);
-    }
-    /**
-     * @summary Override the implementation for js's 'toString()' which sucks...
-     * @override
-     */
-    toString() {
-        return this.constructor.name + ": " + JSON.stringify(this, undefined, 2);
-    }
-    /**
-     * @summary Defines a default implementation for object hash. Relies on a very basic implementation based on Java's string hash;
-     */
-    hash() {
-        return Model.hash(this);
-    }
-    /**
-     * @summary Deserializes a Model
-     * @param {string} str
-     *
-     * @throws {Error} If it fails to parse the string, or if it fails to build the model
-     */
-    static deserialize(str) {
-        const metadata = Reflect.getMetadata(Model.key(constants_1.ModelKeys.SERIALIZATION), this.constructor);
-        if (metadata && metadata.serializer)
-            return serialization_1.Serialization.deserialize(str, metadata.serializer, ...(metadata.args || []));
-        return serialization_1.Serialization.deserialize(str);
-    }
-    /**
-     * @summary Repopulates the Object properties with the ones from the new object
-     * @description Iterates all common properties of obj (if existing) and self, and copies them onto self
-     *
-     * @param {T} self
-     * @param {T | Record<string, any>} [obj]
-     *
-     */
-    static fromObject(self, obj) {
-        if (!obj)
-            obj = {};
-        for (const prop of Model.getAttributes(self)) {
-            self[prop] = obj[prop] || undefined;
-        }
-        return self;
-    }
-    /**
-     * @summary Repopulates the instance with the ones from the new Model Object
-     * @description Iterates all common properties of obj (if existing) and self, and copies them onto self.
-     * Is aware of nested Model Objects and rebuilds them also.
-     * When List properties are decorated with {@link list}, they list items will also be rebuilt
-     *
-     * @param {T} self
-     * @param {T | Record<string, any>} [obj]
-     *
-     */
-    static fromModel(self, obj) {
-        if (!obj)
-            obj = {};
-        let decorators, dec;
-        const props = Model.getAttributes(self);
-        for (const prop of props) {
-            self[prop] =
-                obj[prop] || undefined;
-            if (typeof self[prop] !== "object")
-                continue;
-            const propM = (0, utils_1.isPropertyModel)(self, prop);
-            if (propM) {
-                try {
-                    self[prop] = Model.build(self[prop], typeof propM === "string" ? propM : undefined);
-                }
-                catch (e) {
-                    console.log(e);
-                }
-                continue;
-            }
-            const allDecorators = reflection_1.Reflection.getPropertyDecorators(constants_2.ValidationKeys.REFLECT, self, prop).decorators;
-            decorators = allDecorators.filter((d) => [constants_1.ModelKeys.TYPE, constants_2.ValidationKeys.TYPE].indexOf(d.key) !== -1);
-            if (!decorators || !decorators.length)
-                throw new Error((0, strings_1.sf)("failed to find decorators for property {0}", prop));
-            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(constants_3.ReservedModels).map((v) => v.toLowerCase());
-            clazz.forEach((c) => {
-                if (reserved.indexOf(c.toLowerCase()) === -1)
-                    try {
-                        switch (c) {
-                            case "Array":
-                            case "Set":
-                                if (allDecorators.length) {
-                                    const listDec = allDecorators.find((d) => d.key === constants_2.ValidationKeys.LIST);
-                                    if (listDec) {
-                                        const clazzName = listDec.props.clazz.find((t) => !constants_3.jsTypes.includes(t.toLowerCase()));
-                                        if (c === "Array")
-                                            self[prop] = self[prop].map((el) => {
-                                                return ["object", "function"].includes(typeof el) &&
-                                                    clazzName
-                                                    ? Model.build(el, clazzName)
-                                                    : el;
-                                            });
-                                        if (c === "Set") {
-                                            const s = new Set();
-                                            for (const v of self[prop]) {
-                                                if (["object", "function"].includes(typeof v) &&
-                                                    clazzName) {
-                                                    s.add(Model.build(v, clazzName));
-                                                }
-                                                else {
-                                                    s.add(v);
-                                                }
-                                            }
-                                            self[prop] = s;
-                                        }
-                                    }
-                                }
-                                break;
-                            default:
-                                if (self[prop])
-                                    self[prop] = Model.build(self[prop], c);
-                        }
-                    }
-                    catch (e) {
-                        console.log(e);
-                        // do nothing. we have no registry of this class
-                    }
-            });
-        }
-        return self;
-    }
-    /**
-     * @summary Sets the Global {@link ModelBuilderFunction}
-     * @param {ModelBuilderFunction} [builder]
-     */
-    static setBuilder(builder) {
-        modelBuilderFunction = builder;
-    }
-    /**
-     * @summary Retrieves the current global {@link ModelBuilderFunction}
-     */
-    static getBuilder() {
-        return modelBuilderFunction;
-    }
-    /**
-     * Returns the current {@link ModelRegistryManager}
-     *
-     * @return ModelRegistry, defaults to {@link ModelRegistryManager}
-     */
-    static getRegistry() {
-        if (!actingModelRegistry)
-            actingModelRegistry = new ModelRegistryManager();
-        return actingModelRegistry;
-    }
-    /**
-     * Returns the current actingModelRegistry
-     *
-     * @param {BuilderRegistry} modelRegistry the new implementation of Registry
-     */
-    static setRegistry(modelRegistry) {
-        actingModelRegistry = modelRegistry;
-    }
-    /**
-     * @summary register new Models
-     * @param {any} constructor
-     * @param {string} [name] when not defined, the name of the constructor will be used
-     *
-     * @see ModelRegistry
-     */
-    static register(constructor, name) {
-        return Model.getRegistry().register(constructor, name);
-    }
-    /**
-     * @summary Gets a registered Model {@link ModelConstructor}
-     * @param {string} name
-     *
-     * @see ModelRegistry
-     */
-    static get(name) {
-        return Model.getRegistry().get(name);
-    }
-    /**
-     * @param {Record<string, any>} obj
-     * @param {string} [clazz] when provided, it will attempt to find the matching constructor
-     *
-     * @throws Error If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property
-     *
-     * @see ModelRegistry
-     */
-    static build(obj = {}, clazz) {
-        return Model.getRegistry().build(obj, clazz);
-    }
-    static getMetadata(model) {
-        const metadata = Reflect.getMetadata(Model.key(constants_1.ModelKeys.MODEL), model.constructor);
-        if (!metadata)
-            throw new Error("could not find metadata for provided " + model.constructor.name);
-        return metadata;
-    }
-    static getAttributes(model) {
-        const result = [];
-        let prototype = model instanceof Model
-            ? Object.getPrototypeOf(model)
-            : model.prototype;
-        while (prototype != null) {
-            const props = prototype[constants_1.ModelKeys.ATTRIBUTE];
-            if (props) {
-                result.push(...props);
-            }
-            prototype = Object.getPrototypeOf(prototype);
-        }
-        return result;
-    }
-    static equals(obj1, obj2, ...exceptions) {
-        return (0, reflection_1.isEqual)(obj1, obj2, ...exceptions);
-    }
-    static hasErrors(model, ...propsToIgnore) {
-        return (0, validation_1.validate)(model, ...propsToIgnore);
-    }
-    static serialize(model) {
-        const metadata = Reflect.getMetadata(Model.key(constants_1.ModelKeys.SERIALIZATION), model.constructor);
-        if (metadata && metadata.serializer)
-            return serialization_1.Serialization.serialize(this, metadata.serializer, ...(metadata.args || []));
-        return serialization_1.Serialization.serialize(model);
-    }
-    static hash(model) {
-        const metadata = Reflect.getMetadata(Model.key(constants_1.ModelKeys.HASHING), model.constructor);
-        if (metadata && metadata.algorithm)
-            return hashing_1.Hashing.hash(model, metadata.algorithm, ...(metadata.args || []));
-        return hashing_1.Hashing.hash(model);
-    }
-    /**
-     * @summary Builds the key to store as Metadata under Reflections
-     * @description concatenates {@link ModelKeys#REFLECT} with the provided key
-     * @param {string} str
-     */
-    static key(str) {
-        return constants_1.ModelKeys.REFLECT + str;
-    }
-}
-exports.Model = Model;

package/lib/model/ModelErrorDefinition.d.ts

@@ -1,22 +0,0 @@
-import { ModelErrors } from "../validation/types";
-/**
- * @summary Helper Class to hold the error results
- * @description holds error results in an 'indexable' manner
- * while still providing the same result on toString
- *
- * @param {ModelErrors} errors
- *
- * @class ModelErrorDefinition
- *
- * @category Model
- */
-export declare class ModelErrorDefinition {
-    [indexer: string]: Record<string, string | undefined> | (() => string | undefined);
-    constructor(errors: ModelErrors);
-    /**
-     * @summary Outputs the class to a nice readable string
-     *
-     * @override
-     */
-    toString(): string;
-}

package/lib/model/ModelErrorDefinition.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModelErrorDefinition = void 0;
-/**
- * @summary Helper Class to hold the error results
- * @description holds error results in an 'indexable' manner
- * while still providing the same result on toString
- *
- * @param {ModelErrors} errors
- *
- * @class ModelErrorDefinition
- *
- * @category Model
- */
-class ModelErrorDefinition {
-    constructor(errors) {
-        for (const prop in errors) {
-            if (Object.prototype.hasOwnProperty.call(errors, prop) && errors[prop])
-                Object.defineProperty(this, prop, {
-                    enumerable: true,
-                    configurable: false,
-                    value: errors[prop],
-                    writable: false,
-                });
-        }
-    }
-    /**
-     * @summary Outputs the class to a nice readable string
-     *
-     * @override
-     */
-    toString() {
-        const self = this;
-        return Object.keys(self)
-            .filter((k) => Object.prototype.hasOwnProperty.call(self, k) &&
-            typeof self[k] !== "function")
-            .reduce((accum, prop) => {
-            let propError = Object.keys(self[prop]).reduce((propAccum, key) => {
-                if (!propAccum)
-                    propAccum = self[prop][key];
-                else
-                    propAccum += `\n${self[prop][key]}`;
-                return propAccum;
-            }, undefined);
-            if (propError) {
-                propError = `${prop} - ${propError}`;
-                if (!accum)
-                    accum = propError;
-                else
-                    accum += `\n${propError}`;
-            }
-            return accum;
-        }, "");
-    }
-}
-exports.ModelErrorDefinition = ModelErrorDefinition;

package/lib/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/model/constants.js

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.jsTypes = exports.ReservedModels = exports.Primitives = void 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
- */
-var Primitives;
-(function (Primitives) {
-    Primitives["STRING"] = "string";
-    Primitives["NUMBER"] = "number";
-    Primitives["BOOLEAN"] = "boolean";
-    Primitives["BIGINT"] = "bigint";
-})(Primitives || (exports.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
- */
-var ReservedModels;
-(function (ReservedModels) {
-    ReservedModels["STRING"] = "string";
-    ReservedModels["OBJECT"] = "object";
-    ReservedModels["NUMBER"] = "number";
-    ReservedModels["BOOLEAN"] = "boolean";
-    ReservedModels["BIGINT"] = "bigint";
-    ReservedModels["DATE"] = "date";
-})(ReservedModels || (exports.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
- */
-exports.jsTypes = [
-    "string",
-    "array",
-    "number",
-    "boolean",
-    "symbol",
-    "function",
-    "object",
-    "undefined",
-    "null",
-    "bigint",
-];

package/lib/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/model/construction.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.construct = construct;
-exports.findLastProtoBeforeObject = findLastProtoBeforeObject;
-exports.bindModelPrototype = bindModelPrototype;
-const Model_1 = require("./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
- */
-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
- */
-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
- */
-function bindModelPrototype(obj) {
-    if (obj instanceof Model_1.Model)
-        return;
-    function bindPrototype(objToOverride, prototype) {
-        Object.setPrototypeOf(objToOverride, prototype);
-    }
-    const prototype = Object.getPrototypeOf(obj);
-    if (prototype === Object.prototype) {
-        return bindPrototype(obj, Model_1.Model.prototype);
-    }
-    while (prototype !== Object.prototype) {
-        const prot = Object.getPrototypeOf(prototype);
-        if (prot === Object.prototype ||
-            Object.getPrototypeOf(prot) === Object.prototype) {
-            return bindPrototype(prototype, Model_1.Model.prototype);
-        }
-    }
-    throw new Error("Could not find proper prototype to bind");
-}