@decaf-ts/decorator-validation 1.5.8 → 1.5.10

package/lib/model/Model.cjs

@@ -0,0 +1,397 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Model = exports.ModelRegistryManager = void 0;
+exports.isPropertyModel = isPropertyModel;
+exports.isModel = isModel;
+exports.bulkModelRegister = bulkModelRegister;
+const serialization_1 = require("../utils/serialization.cjs");
+const reflection_1 = require("@decaf-ts/reflection");
+const validation_1 = require("./validation.cjs");
+const hashing_1 = require("../utils/hashing.cjs");
+const constants_1 = require("../utils/constants.cjs");
+const constants_2 = require("../validation/Validators/constants.cjs");
+const strings_1 = require("../utils/strings.cjs");
+const constants_3 = require("./constants.cjs");
+let modelBuilderFunction;
+let actingModelRegistry;
+function isPropertyModel(target, attribute) {
+    if (isModel(target[attribute]))
+        return true;
+    const metadata = Reflect.getMetadata(constants_1.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
+ */
+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 = 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;
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/model/Model.ts"],"names":[],"mappings":";;;AAwBA,0CAOC;AAUD,0BAOC;AAqFD,8CAWC;AAhJD,0DAAuD;AAavD,qDAA8E;AAC9E,6CAAwC;AACxC,8CAA2C;AAC3C,kDAA+C;AAC/C,kEAAoE;AACpE,8CAAsC;AACtC,2CAAsD;AAEtD,IAAI,oBAAsD,CAAC;AAC3D,IAAI,mBAAyC,CAAC;AAE9C,SAAgB,eAAe,CAC7B,MAAS,EACT,SAAiB;IAEjB,IAAI,OAAO,CAAE,MAA8B,CAAC,SAAS,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IACrE,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC,qBAAS,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;IACxE,OAAO,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;AAC9D,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,OAAO,CAAC,MAA2B;IACjD,IAAI,CAAC;QACH,OAAO,MAAM,YAAY,KAAK,IAAI,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC,MAAa,CAAC,CAAC;QACrE,6DAA6D;IAC/D,CAAC;IAAC,OAAO,CAAM,EAAE,CAAC;QAChB,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAYD;;;;;;;;;;GAUG;AACH,MAAa,oBAAoB;IAI/B,YAAY,eAAsD,OAAO;QAHjE,UAAK,GAAwC,EAAE,CAAC;QAItD,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;IACnC,CAAC;IAED;;;;OAIG;IACH,QAAQ,CAAC,WAAgC,EAAE,IAAa;QACtD,IAAI,OAAO,WAAW,KAAK,UAAU;YACnC,MAAM,IAAI,KAAK,CACb,6DAA6D,CAC9D,CAAC;QACJ,IAAI,GAAG,IAAI,IAAI,WAAW,CAAC,IAAI,CAAC;QAChC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,WAAW,CAAC;IACjC,CAAC;IAED;;;OAGG;IACH,GAAG,CAAC,IAAY;QACd,IAAI,CAAC;YACH,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACxB,6DAA6D;QAC/D,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,MAA2B,EAAE,EAAE,KAAc;QACjD,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC;YACnC,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;QACxD,MAAM,IAAI,GAAG,KAAK,IAAI,KAAK,CAAC,WAAW,CAAC,GAAU,CAAC,CAAC;QACpD,IAAI,CAAC,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC;YACvB,MAAM,IAAI,KAAK,CACb,IAAA,YAAE,EAAC,qDAAqD,EAAE,IAAI,CAAC,CAChE,CAAC;QACJ,OAAO,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;IACnC,CAAC;CACF;AAnDD,oDAmDC;AAED;;;;;;;;GAQG;AACH,SAAgB,iBAAiB,CAC/B,GAAG,MAA0E;IAE7E,MAAM,CAAC,OAAO,CACZ,CAAC,CAAiE,EAAE,EAAE;QACpE,MAAM,WAAW,GAAmB,CAClC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAChB,CAAC;QACpB,KAAK,CAAC,QAAQ,CAAC,WAAW,EAAG,CAAoB,CAAC,IAAI,CAAC,CAAC;IAC1D,CAAC,CACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAsB,KAAK;IAGzB,6DAA6D;IAC7D,YAAsB,GAAqB,IAAG,CAAC;IAE/C;;;;OAIG;IACI,SAAS,CAAC,GAAG,UAAiB;QACnC,OAAO,IAAA,qBAAQ,EAAC,IAAI,EAAE,GAAG,UAAU,CAAC,CAAC;IACvC,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,GAAQ,EAAE,GAAG,UAAoB;QAC7C,OAAO,IAAA,oBAAO,EAAC,IAAI,EAAE,GAAG,EAAE,GAAG,UAAU,CAAC,CAAC;IAC3C,CAAC;IAED;;OAEG;IACH,SAAS;QACP,OAAO,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAED;;;OAGG;IACI,QAAQ;QACb,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;IAC3E,CAAC;IAED;;OAEG;IACI,IAAI;QACT,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,WAAW,CAAC,GAAW;QAC5B,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAClC,KAAK,CAAC,GAAG,CAAC,qBAAS,CAAC,aAAa,CAAC,EAClC,IAAI,CAAC,WAAW,CACjB,CAAC;QAEF,IAAI,QAAQ,IAAI,QAAQ,CAAC,UAAU;YACjC,OAAO,6BAAa,CAAC,WAAW,CAC9B,GAAG,EACH,QAAQ,CAAC,UAAU,EACnB,GAAG,CAAC,QAAQ,CAAC,IAAI,IAAI,EAAE,CAAC,CACzB,CAAC;QACJ,OAAO,6BAAa,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IACxC,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,UAAU,CACf,IAAO,EACP,GAA6B;QAE7B,IAAI,CAAC,GAAG;YAAE,GAAG,GAAG,EAAE,CAAC;QACnB,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC;YAC5C,IAAY,CAAC,IAAI,CAAC,GAAI,GAAW,CAAC,IAAI,CAAC,IAAI,SAAS,CAAC;QACxD,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;;OASG;IACH,MAAM,CAAC,SAAS,CAAkB,IAAO,EAAE,GAA6B;QACtE,IAAI,CAAC,GAAG;YAAE,GAAG,GAAG,EAAE,CAAC;QAEnB,IAAI,UAA+B,EAAE,GAAsB,CAAC;QAE5D,MAAM,KAAK,GAAG,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QAExC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACxB,IAA4B,CAAC,IAAI,CAAC;gBAChC,GAA2B,CAAC,IAAI,CAAC,IAAI,SAAS,CAAC;YAClD,IAAI,OAAQ,IAAY,CAAC,IAAI,CAAC,KAAK,QAAQ;gBAAE,SAAS;YACtD,MAAM,KAAK,GAAG,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YAC1C,IAAI,KAAK,EAAE,CAAC;gBACV,IAAI,CAAC;oBACF,IAA4B,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,KAAK,CAC9C,IAA4B,CAAC,IAAI,CAAC,EACnC,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAC9C,CAAC;gBACJ,CAAC;gBAAC,OAAO,CAAM,EAAE,CAAC;oBAChB,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;gBACjB,CAAC;gBACD,SAAS;YACX,CAAC;YAED,MAAM,aAAa,GACjB,uBAAU,CAAC,qBAAqB,CAC9B,0BAAc,CAAC,OAAO,EACtB,IAAI,EACJ,IAAI,CACL,CAAC,UAAU,CAAC;YACf,UAAU,GAAG,aAAa,CAAC,MAAM,CAC/B,CAAC,CAAoB,EAAE,EAAE,CACvB,CAAC,qBAAS,CAAC,IAAI,EAAE,0BAAc,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAC9D,CAAC;YACF,IAAI,CAAC,UAAU,IAAI,CAAC,UAAU,CAAC,MAAM;gBACnC,MAAM,IAAI,KAAK,CAAC,IAAA,YAAE,EAAC,4CAA4C,EAAE,IAAI,CAAC,CAAC,CAAC;YAC1E,GAAG,GAAG,UAAU,CAAC,GAAG,EAAuB,CAAC;YAC5C,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI;gBAC1B,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC;gBAClB,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC;oBACpC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW;oBACvB,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;YAC9B,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,0BAAc,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CACvD,CAAC,CAAC,WAAW,EAAE,CACJ,CAAC;YAEd,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;gBAClB,IAAI,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC;oBAC1C,IAAI,CAAC;wBACH,QAAQ,CAAC,EAAE,CAAC;4BACV,KAAK,OAAO,CAAC;4BACb,KAAK,KAAK;gCACR,IAAI,aAAa,CAAC,MAAM,EAAE,CAAC;oCACzB,MAAM,OAAO,GAAG,aAAa,CAAC,IAAI,CAChC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,0BAAc,CAAC,IAAI,CACrC,CAAC;oCACF,IAAI,OAAO,EAAE,CAAC;wCACZ,MAAM,SAAS,GAAI,OAAO,CAAC,KAAK,CAAC,KAAkB,CAAC,IAAI,CACtD,CAAC,CAAS,EAAE,EAAE,CAAC,CAAC,mBAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAClD,CAAC;wCACF,IAAI,CAAC,KAAK,OAAO;4CACd,IAA4B,CAAC,IAAI,CAAC,GACjC,IACD,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,EAAO,EAAE,EAAE;gDACtB,OAAO,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;oDAC/C,SAAS;oDACT,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,EAAE,SAAS,CAAC;oDAC5B,CAAC,CAAC,EAAE,CAAC;4CACT,CAAC,CAAC,CAAC;wCACL,IAAI,CAAC,KAAK,KAAK,EAAE,CAAC;4CAChB,MAAM,CAAC,GAAG,IAAI,GAAG,EAAE,CAAC;4CACpB,KAAK,MAAM,CAAC,IAAK,IAA4B,CAAC,IAAI,CAAC,EAAE,CAAC;gDACpD,IACE,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;oDACzC,SAAS,EACT,CAAC;oDACD,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;gDACnC,CAAC;qDAAM,CAAC;oDACN,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;gDACX,CAAC;4CACH,CAAC;4CACA,IAA4B,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;wCAC1C,CAAC;oCACH,CAAC;gCACH,CAAC;gCACD,MAAM;4BACR;gCACE,IAAK,IAA4B,CAAC,IAAI,CAAC;oCACpC,IAA4B,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,KAAK,CAC9C,IAAY,CAAC,IAAI,CAAC,EACnB,CAAC,CACF,CAAC;wBACR,CAAC;oBACH,CAAC;oBAAC,OAAO,CAAM,EAAE,CAAC;wBAChB,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;wBACf,gDAAgD;oBAClD,CAAC;YACL,CAAC,CAAC,CAAC;QACL,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,UAAU,CAAC,OAA8B;QAC9C,oBAAoB,GAAG,OAAO,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,UAAU;QACf,OAAO,oBAAoB,CAAC;IAC9B,CAAC;IAED;;;;OAIG;IACK,MAAM,CAAC,WAAW;QACxB,IAAI,CAAC,mBAAmB;YAAE,mBAAmB,GAAG,IAAI,oBAAoB,EAAE,CAAC;QAC3E,OAAO,mBAAmB,CAAC;IAC7B,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,WAAW,CAAC,aAAmC;QACpD,mBAAmB,GAAG,aAAa,CAAC;IACtC,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,QAAQ,CACb,WAAgC,EAChC,IAAa;QAEb,OAAO,KAAK,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;IACzD,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,GAAG,CAAkB,IAAY;QACtC,OAAO,KAAK,CAAC,WAAW,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACvC,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,KAAK,CACV,MAA2B,EAAE,EAC7B,KAAc;QAEd,OAAO,KAAK,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IAC/C,CAAC;IAED,MAAM,CAAC,WAAW,CAAkB,KAAQ;QAC1C,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAClC,KAAK,CAAC,GAAG,CAAC,qBAAS,CAAC,KAAK,CAAC,EAC1B,KAAK,CAAC,WAAW,CAClB,CAAC;QACF,IAAI,CAAC,QAAQ;YACX,MAAM,IAAI,KAAK,CACb,uCAAuC,GAAG,KAAK,CAAC,WAAW,CAAC,IAAI,CACjE,CAAC;QACJ,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,MAAM,CAAC,aAAa,CAAkB,KAAyB;QAC7D,MAAM,MAAM,GAAa,EAAE,CAAC;QAC5B,IAAI,SAAS,GACX,KAAK,YAAY,KAAK;YACpB,CAAC,CAAC,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC;YAC9B,CAAC,CAAE,KAAa,CAAC,SAAS,CAAC;QAC/B,OAAO,SAAS,IAAI,IAAI,EAAE,CAAC;YACzB,MAAM,KAAK,GAAa,SAAS,CAAC,qBAAS,CAAC,SAAS,CAAC,CAAC;YACvD,IAAI,KAAK,EAAE,CAAC;gBACV,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC;YACxB,CAAC;YACD,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;QAC/C,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,MAAM,CAAC,MAAM,CAAkB,IAAO,EAAE,IAAO,EAAE,GAAG,UAAiB;QACnE,OAAO,IAAA,oBAAO,EAAC,IAAI,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC,CAAC;IAC5C,CAAC;IAED,MAAM,CAAC,SAAS,CAAkB,KAAQ,EAAE,GAAG,aAAuB;QACpE,OAAO,IAAA,qBAAQ,EAAC,KAAK,EAAE,GAAG,aAAa,CAAC,CAAC;IAC3C,CAAC;IAED,MAAM,CAAC,SAAS,CAAkB,KAAQ;QACxC,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAClC,KAAK,CAAC,GAAG,CAAC,qBAAS,CAAC,aAAa,CAAC,EAClC,KAAK,CAAC,WAAW,CAClB,CAAC;QAEF,IAAI,QAAQ,IAAI,QAAQ,CAAC,UAAU;YACjC,OAAO,6BAAa,CAAC,SAAS,CAC5B,IAAI,EACJ,QAAQ,CAAC,UAAU,EACnB,GAAG,CAAC,QAAQ,CAAC,IAAI,IAAI,EAAE,CAAC,CACzB,CAAC;QACJ,OAAO,6BAAa,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACxC,CAAC;IAED,MAAM,CAAC,IAAI,CAAkB,KAAQ;QACnC,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAClC,KAAK,CAAC,GAAG,CAAC,qBAAS,CAAC,OAAO,CAAC,EAC5B,KAAK,CAAC,WAAW,CAClB,CAAC;QAEF,IAAI,QAAQ,IAAI,QAAQ,CAAC,SAAS;YAChC,OAAO,iBAAO,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,QAAQ,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC;QAC3E,OAAO,iBAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC7B,CAAC;IACD;;;;OAIG;IACH,MAAM,CAAC,GAAG,CAAC,GAAW;QACpB,OAAO,qBAAS,CAAC,OAAO,GAAG,GAAG,CAAC;IACjC,CAAC;CACF;AApVD,sBAoVC","file":"model/Model.js","sourcesContent":["import { Serialization } from \"../utils/serialization\";\nimport { BuilderRegistry } from \"../utils/registry\";\nimport { ModelErrorDefinition } from \"./ModelErrorDefinition\";\nimport {\n  Comparable,\n  Constructor,\n  Hashable,\n  ModelArg,\n  ModelBuilderFunction,\n  ModelConstructor,\n  Serializable,\n  Validatable,\n} from \"./types\";\nimport { DecoratorMetadata, isEqual, Reflection } from \"@decaf-ts/reflection\";\nimport { validate } from \"./validation\";\nimport { Hashing } from \"../utils/hashing\";\nimport { ModelKeys } from \"../utils/constants\";\nimport { ValidationKeys } from \"../validation/Validators/constants\";\nimport { sf } from \"../utils/strings\";\nimport { jsTypes, ReservedModels } from \"./constants\";\n\nlet modelBuilderFunction: ModelBuilderFunction | undefined;\nlet actingModelRegistry: BuilderRegistry<any>;\n\nexport function isPropertyModel<M extends Model>(\n  target: M,\n  attribute: string\n): boolean | string | undefined {\n  if (isModel((target as Record<string, any>)[attribute])) return true;\n  const metadata = Reflect.getMetadata(ModelKeys.TYPE, target, attribute);\n  return Model.get(metadata.name) ? metadata.name : undefined;\n}\n\n/**\n * @summary For Serialization/deserialization purposes.\n * @description Reads the {@link ModelKeys.ANCHOR} property of a {@link Model} to discover the class to instantiate\n *\n * @function isModel\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport function isModel(target: Record<string, any>) {\n  try {\n    return target instanceof Model || !!Model.getMetadata(target as any);\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  } catch (e: any) {\n    return false;\n  }\n}\n\n/**\n * @summary ModelRegistry Interface\n *\n * @interface ModelRegistry\n * @extends BuilderRegistry<Model>\n *\n * @category Model\n */\nexport type ModelRegistry<T extends Model> = BuilderRegistry<T>;\n\n/**\n * @summary Util class to enable serialization and correct rebuilding\n *\n * @param {string} anchorKey defaults to {@link ModelKeys.ANCHOR}. The property name where the registered class name is stored;\n * @param {function(Record<string, any>): boolean} [testFunction] method to test if the provided object is a Model Object. defaults to {@link isModel}\n *\n * @class ModelRegistryManager\n * @implements ModelRegistry\n *\n * @category Model\n */\nexport class ModelRegistryManager<T extends Model> implements ModelRegistry<T> {\n  private cache: Record<string, ModelConstructor<T>> = {};\n  private readonly testFunction: (obj: object) => boolean;\n\n  constructor(testFunction: (obj: Record<string, any>) => boolean = isModel) {\n    this.testFunction = testFunction;\n  }\n\n  /**\n   * @summary register new Models\n   * @param {any} constructor\n   * @param {string} [name] when not defined, the name of the constructor will be used\n   */\n  register(constructor: ModelConstructor<T>, name?: string): void {\n    if (typeof constructor !== \"function\")\n      throw new Error(\n        \"Model registering failed. Missing Class name or constructor\"\n      );\n    name = name || constructor.name;\n    this.cache[name] = constructor;\n  }\n\n  /**\n   * @summary Gets a registered Model {@link ModelConstructor}\n   * @param {string} name\n   */\n  get(name: string): ModelConstructor<T> | undefined {\n    try {\n      return this.cache[name];\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (e: any) {\n      return undefined;\n    }\n  }\n\n  /**\n   * @param {Record<string, any>} obj\n   * @param {string} [clazz] when provided, it will attempt to find the matching constructor\n   *\n   * @throws Error If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property\n   */\n  build(obj: Record<string, any> = {}, clazz?: string): T {\n    if (!clazz && !this.testFunction(obj))\n      throw new Error(\"Provided obj is not a Model object\");\n    const name = clazz || Model.getMetadata(obj as any);\n    if (!(name in this.cache))\n      throw new Error(\n        sf(\"Provided class {0} is not a registered Model object\", name)\n      );\n    return new this.cache[name](obj);\n  }\n}\n\n/**\n * @summary Bulk Registers Models\n * @description Useful when using bundlers that might not evaluate all the code at once\n *\n * @param {Array<Constructor<T>> | Array<{name: string, constructor: Constructor<T>}>} [models]\n *\n * @memberOf module:decorator-validation.Model\n * @category Model\n */\nexport function bulkModelRegister<T extends Model>(\n  ...models: (Constructor<T> | { name: string; constructor: Constructor<T> })[]\n) {\n  models.forEach(\n    (m: Constructor<T> | { name: string; constructor: Constructor<T> }) => {\n      const constructor: Constructor<T> = (\n        m.constructor ? m.constructor : m\n      ) as Constructor<T>;\n      Model.register(constructor, (m as Constructor<T>).name);\n    }\n  );\n}\n\n/**\n * @summary Abstract class representing a Validatable Model object\n * @description Meant to be used as a base class for all Model classes\n *\n * Model objects must:\n *  - Have all their required properties marked with '!';\n *  - Have all their optional properties marked as '?':\n *\n * @param {Model | {}} model base object from which to populate properties from\n *\n * @class Model\n * @abstract\n * @implements Validatable\n * @implements Serializable\n *\n * @example\n *      class ClassName {\n *          @required()\n *          requiredPropertyName!: PropertyType;\n *\n *          optionalPropertyName?: PropertyType;\n *      }\n */\nexport abstract class Model\n  implements Validatable, Serializable, Hashable, Comparable<Model>\n{\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  protected constructor(arg?: ModelArg<Model>) {}\n\n  /**\n   * @summary Validates the object according to its decorated properties\n   *\n   * @param {any[]} [exceptions] properties in the object to be ignored for the validation. Marked as 'any' to allow for extension but expects strings\n   */\n  public hasErrors(...exceptions: any[]): ModelErrorDefinition | undefined {\n    return validate(this, ...exceptions);\n  }\n\n  /**\n   * @summary Compare object equality recursively\n   * @param {any} obj object to compare to\n   * @param {string} [exceptions] property names to be excluded from the comparison\n   */\n  public equals(obj: any, ...exceptions: string[]): boolean {\n    return isEqual(this, obj, ...exceptions);\n  }\n\n  /**\n   * @summary Returns the serialized model according to the currently defined {@link Serializer}\n   */\n  serialize(): string {\n    return Model.serialize(this);\n  }\n\n  /**\n   * @summary Override the implementation for js's 'toString()' which sucks...\n   * @override\n   */\n  public toString(): string {\n    return this.constructor.name + \": \" + JSON.stringify(this, undefined, 2);\n  }\n\n  /**\n   * @summary Defines a default implementation for object hash. Relies on a very basic implementation based on Java's string hash;\n   */\n  public hash(): string {\n    return Model.hash(this);\n  }\n\n  /**\n   * @summary Deserializes a Model\n   * @param {string} str\n   *\n   * @throws {Error} If it fails to parse the string, or if it fails to build the model\n   */\n  static deserialize(str: string) {\n    const metadata = Reflect.getMetadata(\n      Model.key(ModelKeys.SERIALIZATION),\n      this.constructor\n    );\n\n    if (metadata && metadata.serializer)\n      return Serialization.deserialize(\n        str,\n        metadata.serializer,\n        ...(metadata.args || [])\n      );\n    return Serialization.deserialize(str);\n  }\n\n  /**\n   * @summary Repopulates the Object properties with the ones from the new object\n   * @description Iterates all common properties of obj (if existing) and self, and copies them onto self\n   *\n   * @param {T} self\n   * @param {T | Record<string, any>} [obj]\n   *\n   */\n  static fromObject<T extends Model>(\n    self: T,\n    obj?: T | Record<string, any>\n  ): T {\n    if (!obj) obj = {};\n    for (const prop of Model.getAttributes(self)) {\n      (self as any)[prop] = (obj as any)[prop] || undefined;\n    }\n    return self;\n  }\n\n  /**\n   * @summary Repopulates the instance with the ones from the new Model Object\n   * @description Iterates all common properties of obj (if existing) and self, and copies them onto self.\n   * Is aware of nested Model Objects and rebuilds them also.\n   * When List properties are decorated with {@link list}, they list items will also be rebuilt\n   *\n   * @param {T} self\n   * @param {T | Record<string, any>} [obj]\n   *\n   */\n  static fromModel<T extends Model>(self: T, obj?: T | Record<string, any>): T {\n    if (!obj) obj = {};\n\n    let decorators: DecoratorMetadata[], dec: DecoratorMetadata;\n\n    const props = Model.getAttributes(self);\n\n    for (const prop of props) {\n      (self as Record<string, any>)[prop] =\n        (obj as Record<string, any>)[prop] || undefined;\n      if (typeof (self as any)[prop] !== \"object\") continue;\n      const propM = isPropertyModel(self, prop);\n      if (propM) {\n        try {\n          (self as Record<string, any>)[prop] = Model.build(\n            (self as Record<string, any>)[prop],\n            typeof propM === \"string\" ? propM : undefined\n          );\n        } catch (e: any) {\n          console.log(e);\n        }\n        continue;\n      }\n\n      const allDecorators: DecoratorMetadata[] =\n        Reflection.getPropertyDecorators(\n          ValidationKeys.REFLECT,\n          self,\n          prop\n        ).decorators;\n      decorators = allDecorators.filter(\n        (d: DecoratorMetadata) =>\n          [ModelKeys.TYPE, ValidationKeys.TYPE].indexOf(d.key) !== -1\n      );\n      if (!decorators || !decorators.length)\n        throw new Error(sf(\"failed to find decorators for property {0}\", prop));\n      dec = decorators.pop() as DecoratorMetadata;\n      const clazz = dec.props.name\n        ? [dec.props.name]\n        : Array.isArray(dec.props.customTypes)\n          ? dec.props.customTypes\n          : [dec.props.customTypes];\n      const reserved = Object.values(ReservedModels).map((v) =>\n        v.toLowerCase()\n      ) as string[];\n\n      clazz.forEach((c) => {\n        if (reserved.indexOf(c.toLowerCase()) === -1)\n          try {\n            switch (c) {\n              case \"Array\":\n              case \"Set\":\n                if (allDecorators.length) {\n                  const listDec = allDecorators.find(\n                    (d) => d.key === ValidationKeys.LIST\n                  );\n                  if (listDec) {\n                    const clazzName = (listDec.props.clazz as string[]).find(\n                      (t: string) => !jsTypes.includes(t.toLowerCase())\n                    );\n                    if (c === \"Array\")\n                      (self as Record<string, any>)[prop] = (\n                        self as Record<string, any>\n                      )[prop].map((el: any) => {\n                        return [\"object\", \"function\"].includes(typeof el) &&\n                          clazzName\n                          ? Model.build(el, clazzName)\n                          : el;\n                      });\n                    if (c === \"Set\") {\n                      const s = new Set();\n                      for (const v of (self as Record<string, any>)[prop]) {\n                        if (\n                          [\"object\", \"function\"].includes(typeof v) &&\n                          clazzName\n                        ) {\n                          s.add(Model.build(v, clazzName));\n                        } else {\n                          s.add(v);\n                        }\n                      }\n                      (self as Record<string, any>)[prop] = s;\n                    }\n                  }\n                }\n                break;\n              default:\n                if ((self as Record<string, any>)[prop])\n                  (self as Record<string, any>)[prop] = Model.build(\n                    (self as any)[prop],\n                    c\n                  );\n            }\n          } catch (e: any) {\n            console.log(e);\n            // do nothing. we have no registry of this class\n          }\n      });\n    }\n    return self;\n  }\n\n  /**\n   * @summary Sets the Global {@link ModelBuilderFunction}\n   * @param {ModelBuilderFunction} [builder]\n   */\n  static setBuilder(builder?: ModelBuilderFunction) {\n    modelBuilderFunction = builder;\n  }\n\n  /**\n   * @summary Retrieves the current global {@link ModelBuilderFunction}\n   */\n  static getBuilder(): ModelBuilderFunction | undefined {\n    return modelBuilderFunction;\n  }\n\n  /**\n   * Returns the current {@link ModelRegistryManager}\n   *\n   * @return ModelRegistry, defaults to {@link ModelRegistryManager}\n   */\n  private static getRegistry() {\n    if (!actingModelRegistry) actingModelRegistry = new ModelRegistryManager();\n    return actingModelRegistry;\n  }\n\n  /**\n   * Returns the current actingModelRegistry\n   *\n   * @param {BuilderRegistry} modelRegistry the new implementation of Registry\n   */\n  static setRegistry(modelRegistry: BuilderRegistry<any>) {\n    actingModelRegistry = modelRegistry;\n  }\n\n  /**\n   * @summary register new Models\n   * @param {any} constructor\n   * @param {string} [name] when not defined, the name of the constructor will be used\n   *\n   * @see ModelRegistry\n   */\n  static register<T extends Model>(\n    constructor: ModelConstructor<T>,\n    name?: string\n  ): void {\n    return Model.getRegistry().register(constructor, name);\n  }\n\n  /**\n   * @summary Gets a registered Model {@link ModelConstructor}\n   * @param {string} name\n   *\n   * @see ModelRegistry\n   */\n  static get<T extends Model>(name: string): ModelConstructor<T> | undefined {\n    return Model.getRegistry().get(name);\n  }\n\n  /**\n   * @param {Record<string, any>} obj\n   * @param {string} [clazz] when provided, it will attempt to find the matching constructor\n   *\n   * @throws Error If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property\n   *\n   * @see ModelRegistry\n   */\n  static build<T extends Model>(\n    obj: Record<string, any> = {},\n    clazz?: string\n  ): T {\n    return Model.getRegistry().build(obj, clazz);\n  }\n\n  static getMetadata<V extends Model>(model: V) {\n    const metadata = Reflect.getMetadata(\n      Model.key(ModelKeys.MODEL),\n      model.constructor\n    );\n    if (!metadata)\n      throw new Error(\n        \"could not find metadata for provided \" + model.constructor.name\n      );\n    return metadata;\n  }\n\n  static getAttributes<V extends Model>(model: Constructor<V> | V) {\n    const result: string[] = [];\n    let prototype =\n      model instanceof Model\n        ? Object.getPrototypeOf(model)\n        : (model as any).prototype;\n    while (prototype != null) {\n      const props: string[] = prototype[ModelKeys.ATTRIBUTE];\n      if (props) {\n        result.push(...props);\n      }\n      prototype = Object.getPrototypeOf(prototype);\n    }\n    return result;\n  }\n\n  static equals<V extends Model>(obj1: V, obj2: V, ...exceptions: any[]) {\n    return isEqual(obj1, obj2, ...exceptions);\n  }\n\n  static hasErrors<V extends Model>(model: V, ...propsToIgnore: string[]) {\n    return validate(model, ...propsToIgnore);\n  }\n\n  static serialize<V extends Model>(model: V) {\n    const metadata = Reflect.getMetadata(\n      Model.key(ModelKeys.SERIALIZATION),\n      model.constructor\n    );\n\n    if (metadata && metadata.serializer)\n      return Serialization.serialize(\n        this,\n        metadata.serializer,\n        ...(metadata.args || [])\n      );\n    return Serialization.serialize(model);\n  }\n\n  static hash<V extends Model>(model: V) {\n    const metadata = Reflect.getMetadata(\n      Model.key(ModelKeys.HASHING),\n      model.constructor\n    );\n\n    if (metadata && metadata.algorithm)\n      return Hashing.hash(model, metadata.algorithm, ...(metadata.args || []));\n    return Hashing.hash(model);\n  }\n  /**\n   * @summary Builds the key to store as Metadata under Reflections\n   * @description concatenates {@link ModelKeys#REFLECT} with the provided key\n   * @param {string} str\n   */\n  static key(str: string) {\n    return ModelKeys.REFLECT + str;\n  }\n}\n"]}

package/lib/model/ModelErrorDefinition.cjs

@@ -0,0 +1,58 @@
+"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;
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/model/constants.cjs

@@ -0,0 +1,74 @@
+"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",
+];
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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