@decaf-ts/decorator-validation 1.0.7 → 1.0.11

package/lib/model/Model.cjs

@@ -1 +1,321 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Model=exports.validate=void 0;const validation_1=require("../validation/index.cjs"),utils_1=require("../utils/index.cjs"),ModelErrorDefinition_1=require("./ModelErrorDefinition/index.cjs"),constants_1=require("./constants/index.cjs"),constants_2=require("../utils/constants/index.cjs"),construction_1=require("./construction/index.cjs"),Registry_1=require("./Registry/index.cjs"),Validation_1=require("../validation/Validation/index.cjs");function validate(n,...t){var e=[];for(const i in n)n.hasOwnProperty(i)&&-1===t.indexOf(i)&&e.push((0,utils_1.getPropertyDecorators)(validation_1.ValidationKeys.REFLECT,n,i));var r=e.reduce((t,r)=>{const{prop:i,decorators:s}=r;if(s&&s.length){const o=s[0];s.find(t=>t.key===validation_1.ValidationKeys.TYPE||!!t.props.types?.find(t=>t===o.props.name))&&s.shift();let e=s.reduce((t,e)=>{var r=Validation_1.Validation.get(e.key);return r&&(r=r.hasErrors(n[i.toString()],...e.key===constants_2.ModelKeys.TYPE?[e.props]:Object.values(e.props)))&&((t=t||{})[e.key]=r),t},void 0);(e=e||Object.keys(n).filter(t=>!e||!e[t]).reduce((t,r)=>{let i;const s=(0,utils_1.getPropertyDecorators)(validation_1.ValidationKeys.REFLECT,n,r).decorators;var e=s.filter(t=>-1!==[constants_2.ModelKeys.TYPE,validation_1.ValidationKeys.TYPE].indexOf(t.key));if(e&&e.length){e=e.pop(),e=e.props.name?[e.props.name]:Array.isArray(e.props.customTypes)?e.props.customTypes:[e.props.customTypes];const o=Object.values(constants_1.ReservedModels).map(t=>t.toLowerCase());e.forEach(t=>{if(-1===o.indexOf(t.toLowerCase()))switch(t){case"Array":case"Set":var e;s.length&&s.find(t=>t.key===validation_1.ValidationKeys.LIST)&&(e="Array"===t?n[r].find(t=>t.hasErrors()):n[r].values().find(t=>t.hasErrors()))&&(i=(0,utils_1.stringFormat)(validation_1.DEFAULT_ERROR_MESSAGES.LIST_INSIDE,e.toString()));break;default:try{n[r]&&(i=n[r].hasErrors())}catch(t){console.warn((0,utils_1.stringFormat)("Model should be validatable but its not"))}}}),i&&((t=t||{})[r]=i)}return t},void 0))&&((t=t||{})[r.prop.toString()]=e)}return t},void 0);return r?new ModelErrorDefinition_1.ModelErrorDefinition(r):void 0}exports.validate=validate;let modelBuilderFunction,actingModelRegistry,serializer,hashingFunction;class Model{constructor(t){}hasErrors(...t){return validate(this,...t)}equals(t,...e){return(0,utils_1.isEqual)(this,t,...e)}serialize(){return Model.serialize(this)}toString(){return this.constructor.name+": "+JSON.stringify(this,void 0,2)}toHash(){return Model.getHashingFunction()(this).toString()}static deserialize(t){return Model.getSerializer().deserialize(t)}static serialize(t){return Model.getSerializer().serialize(t)}static hash(t){return Model.getHashingFunction()(t)}static fromObject(t,e){return(0,construction_1.constructFromObject)(t,e)}static fromModel(t,e){return(0,construction_1.constructFromModel)(t,e)}static setBuilder(t){modelBuilderFunction=t}static getBuilder(){return modelBuilderFunction}static getRegistry(){return actingModelRegistry=actingModelRegistry||new Registry_1.ModelRegistryManager}static setRegistry(t){actingModelRegistry=t}static register(t,e){return Model.getRegistry().register(t,e)}static get(t){return Model.getRegistry().get(t)}static build(t={},e){return Model.getRegistry().build(t,e)}static setSerializer(t){serializer=t}static getSerializer(){return serializer=serializer||new utils_1.JSONSerializer}static setHashingFunction(t){hashingFunction=t}static getHashingFunction(){return hashingFunction=hashingFunction||utils_1.hashObj}}exports.Model=Model;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Model = void 0;
+exports.validate = validate;
+const constants_1 = require("../validation/Validators/constants/index.cjs");
+const serialization_1 = require("../utils/serialization/index.cjs");
+const ModelErrorDefinition_1 = require("./ModelErrorDefinition/index.cjs");
+const constants_2 = require("./constants/index.cjs");
+const constants_3 = require("../utils/constants/index.cjs");
+const construction_1 = require("./construction/index.cjs");
+const Registry_1 = require("./Registry/index.cjs");
+const Validation_1 = require("../validation/Validation/index.cjs");
+const utils_1 = require("../reflection/utils/index.cjs");
+const hashing_1 = require("../utils/hashing/index.cjs");
+const strings_1 = require("../utils/strings/index.cjs");
+const equality_1 = require("../utils/equality/index.cjs");
+/**
+ * @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
+ */
+function validate(obj, ...propsToIgnore) {
+    const decoratedProperties = [];
+    for (const prop in obj)
+        if (obj.hasOwnProperty(prop) && propsToIgnore.indexOf(prop) === -1)
+            decoratedProperties.push((0, utils_1.getPropertyDecorators)(constants_1.ValidationKeys.REFLECT, obj, prop));
+    const result = decoratedProperties.reduce((accum, decoratedProperty) => {
+        const { prop, decorators } = decoratedProperty;
+        if (!decorators || !decorators.length)
+            return accum;
+        // @ts-expect-error due to type casting in decorators
+        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 === constants_1.ValidationKeys.TYPE)
+                return true;
+            if (d.props.types?.find((t) => t === defaultTypeDecorator.props.name))
+                return true;
+            return false;
+        }))
+            decorators.shift(); // remove the design:type decorator, since the type will already be checked
+        let errs = decorators.reduce((acc, decorator) => {
+            const validator = Validation_1.Validation.get(decorator.key);
+            if (!validator) {
+                return acc;
+            }
+            const err = validator.hasErrors(obj[prop.toString()], ...(decorator.key === constants_3.ModelKeys.TYPE
+                ? [decorator.props]
+                : Object.values(decorator.props)));
+            if (err) {
+                acc = acc || {};
+                acc[decorator.key] = err;
+            }
+            return acc;
+        }, undefined);
+        errs =
+            errs ||
+                Object.keys(obj)
+                    .filter((k) => !errs || !errs[k])
+                    .reduce((acc, prop) => {
+                    let err;
+                    // if a nested Model
+                    const allDecorators = (0, utils_1.getPropertyDecorators)(constants_1.ValidationKeys.REFLECT, obj, prop).decorators;
+                    const decorators = allDecorators.filter((d) => [constants_3.ModelKeys.TYPE, constants_1.ValidationKeys.TYPE].indexOf(d.key) !== -1);
+                    if (!decorators || !decorators.length)
+                        return acc;
+                    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(constants_2.ReservedModels).map((v) => v.toLowerCase());
+                    clazz.forEach((c) => {
+                        if (reserved.indexOf(c.toLowerCase()) === -1) {
+                            switch (c) {
+                                case "Array":
+                                case "Set":
+                                    if (allDecorators.length) {
+                                        const listDec = allDecorators.find((d) => d.key === constants_1.ValidationKeys.LIST);
+                                        if (listDec) {
+                                            const e = c === "Array"
+                                                ? obj[prop].find((c) => c.hasErrors())
+                                                : obj[prop]
+                                                    .values()
+                                                    .find((c) => c.hasErrors());
+                                            if (e)
+                                                err = (0, strings_1.sf)(constants_1.DEFAULT_ERROR_MESSAGES.LIST_INSIDE, e.toString());
+                                        }
+                                    }
+                                    break;
+                                default:
+                                    try {
+                                        if (obj[prop])
+                                            err = obj[prop].hasErrors();
+                                    }
+                                    catch (e) {
+                                        console.warn((0, strings_1.sf)("Model should be validatable but its not"));
+                                    }
+                            }
+                        }
+                    });
+                    if (err) {
+                        acc = acc || {};
+                        acc[prop] = err;
+                    }
+                    return acc;
+                }, undefined);
+        if (errs) {
+            accum = accum || {};
+            accum[decoratedProperty.prop.toString()] = errs;
+        }
+        return accum;
+    }, undefined);
+    return result ? new ModelErrorDefinition_1.ModelErrorDefinition(result) : undefined;
+}
+let modelBuilderFunction;
+let actingModelRegistry;
+let serializer;
+let hashingFunction;
+/**
+ * @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 properties defined as optional;
+ *  - Have all their properties initialized eg:
+ *
+ *  <pre>
+ *      class ClassName {
+ *          propertyName?: PropertyType = undefined;
+ *      }
+ *  </pre>
+ *
+ * @param {Model | {}} model base object from which to populate properties from
+ *
+ * @class Model
+ * @abstract
+ * @implements Validatable
+ * @implements Serializable
+ *
+ * @category Model
+ */
+class Model {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    constructor(model) { }
+    /**
+     * @summary Validates the object according to its decorated properties
+     *
+     * @param {any[]} [exceptions] properties in the object to be ignored for he validation. Marked as 'any' to allow for extension but expects strings
+     */
+    hasErrors(...exceptions) {
+        return 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, equality_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;
+     */
+    toHash() {
+        return Model.getHashingFunction()(this).toString();
+    }
+    /**
+     * @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) {
+        return Model.getSerializer().deserialize(str);
+    }
+    /**
+     * @summary Serializes a Model
+     * @param {Model} model
+     */
+    static serialize(model) {
+        return Model.getSerializer().serialize(model);
+    }
+    static hash(obj) {
+        return Model.getHashingFunction()(obj);
+    }
+    /**
+     * @summary Wrapper around {@link constructFromObject}
+     * @param {T} self
+     * @param {T | Record<string, any>} obj
+     */
+    static fromObject(self, obj) {
+        return (0, construction_1.constructFromObject)(self, obj);
+    }
+    /**
+     * @summary Wrapper around {@link constructFromModel}
+     * @param {T} self
+     * @param {T | Record<string, any>} obj
+     */
+    static fromModel(self, obj) {
+        return (0, construction_1.constructFromModel)(self, obj);
+    }
+    /**
+     * @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 Registry_1.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);
+    }
+    /**
+     * @summary Sets the {@link Serializer}
+     *
+     * @param {Serializer} ser
+     */
+    static setSerializer(ser) {
+        serializer = ser;
+    }
+    /**
+     * @summary Retrieves the current defined {@link Serializer}
+     *
+     */
+    static getSerializer() {
+        if (!serializer)
+            serializer = new serialization_1.JSONSerializer();
+        return serializer;
+    }
+    /**
+     * @summary Sets the {@link HashingFunction}
+     *
+     * @param {HashingFunction} hasher
+     */
+    static setHashingFunction(hasher) {
+        hashingFunction = hasher;
+    }
+    /**
+     * @summary Retrieves the current defined {@link HashingFunction}
+     *
+     */
+    static getHashingFunction() {
+        if (!hashingFunction)
+            hashingFunction = hashing_1.hashObj;
+        return hashingFunction;
+    }
+}
+exports.Model = Model;
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/model/Model.ts"],"names":[],"mappings":";;;AAuCA,4BAqJC;AA5LD,kEAG4C;AAO5C,0DAAoE;AAEpE,iEAA8D;AAE9D,2CAA6C;AAC7C,kDAA+C;AAC/C,iDAIwB;AACxB,yCAAkD;AAClD,yDAAsD;AACtD,+CAA4D;AAC5D,8CAA4D;AAC5D,8CAAsC;AACtC,gDAA4C;AAE5C;;;;;;;;;;GAUG;AACH,SAAgB,QAAQ,CACtB,GAAM,EACN,GAAG,aAAuB;IAE1B,MAAM,mBAAmB,GAA4C,EAAE,CAAC;IACxE,KAAK,MAAM,IAAI,IAAI,GAAG;QACpB,IAAI,GAAG,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAChE,mBAAmB,CAAC,IAAI,CACtB,IAAA,6BAAqB,EACnB,0BAAc,CAAC,OAAO,EACtB,GAAG,EACH,IAAI,CACoC,CAC3C,CAAC;IAEN,MAAM,MAAM,GAAG,mBAAmB,CAAC,MAAM,CACvC,CACE,KAA8B,EAC9B,iBAAwD,EACxD,EAAE;QACF,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,iBAAiB,CAAC;QAE/C,IAAI,CAAC,UAAU,IAAI,CAAC,UAAU,CAAC,MAAM;YAAE,OAAO,KAAK,CAAC;QAEpD,qDAAqD;QACrD,MAAM,oBAAoB,GACxB,UAAU,CAAC,CAAC,CAAC,CAAC;QAEhB,gLAAgL;QAChL,IACE,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;YACpB,IAAI,CAAC,CAAC,GAAG,KAAK,0BAAc,CAAC,IAAI;gBAAE,OAAO,IAAI,CAAC;YAC/C,IAAI,CAAC,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,oBAAoB,CAAC,KAAK,CAAC,IAAI,CAAC;gBACnE,OAAO,IAAI,CAAC;YACd,OAAO,KAAK,CAAC;QACf,CAAC,CAAC;YAEF,UAAU,CAAC,KAAK,EAAE,CAAC,CAAC,2EAA2E;QAEjG,IAAI,IAAI,GAA8C,UAAU,CAAC,MAAM,CACrE,CACE,GAA8C,EAC9C,SAAyC,EACzC,EAAE;YACF,MAAM,SAAS,GAAG,uBAAU,CAAC,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;YAChD,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,OAAO,GAAG,CAAC;YACb,CAAC;YAED,MAAM,GAAG,GAAW,SAAS,CAAC,SAAS,CACrC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,EACpB,GAAG,CAAC,SAAS,CAAC,GAAG,KAAK,qBAAS,CAAC,IAAI;gBAClC,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC;gBACnB,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CACpC,CAAC;YAEF,IAAI,GAAG,EAAE,CAAC;gBACR,GAAG,GAAG,GAAG,IAAI,EAAE,CAAC;gBAChB,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;YAC3B,CAAC;YAED,OAAO,GAAG,CAAC;QACb,CAAC,EACD,SAAS,CACV,CAAC;QAEF,IAAI;YACF,IAAI;gBACJ,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC;qBACb,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;qBAChC,MAAM,CAAC,CAAC,GAAoC,EAAE,IAAI,EAAE,EAAE;oBACrD,IAAI,GAAW,CAAC;oBAChB,oBAAoB;oBACpB,MAAM,aAAa,GAAG,IAAA,6BAAqB,EACzC,0BAAc,CAAC,OAAO,EACtB,GAAG,EACH,IAAI,CACL,CAAC,UAAU,CAAC;oBACb,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CACrC,CAAC,CAAC,EAAE,EAAE,CACJ,CAAC,qBAAS,CAAC,IAAI,EAAE,0BAAc,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAC9D,CAAC;oBACF,IAAI,CAAC,UAAU,IAAI,CAAC,UAAU,CAAC,MAAM;wBAAE,OAAO,GAAG,CAAC;oBAClD,MAAM,GAAG,GAAG,UAAU,CAAC,GAAG,EAAuB,CAAC;oBAClD,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI;wBAC1B,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC;wBAClB,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC;4BACpC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW;4BACvB,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;oBAC9B,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,0BAAc,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CACvD,CAAC,CAAC,WAAW,EAAE,CACJ,CAAC;oBAEd,KAAK,CAAC,OAAO,CAAC,CAAC,CAAS,EAAE,EAAE;wBAC1B,IAAI,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;4BAC7C,QAAQ,CAAC,EAAE,CAAC;gCACV,KAAK,OAAO,CAAC;gCACb,KAAK,KAAK;oCACR,IAAI,aAAa,CAAC,MAAM,EAAE,CAAC;wCACzB,MAAM,OAAO,GAAG,aAAa,CAAC,IAAI,CAChC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,0BAAc,CAAC,IAAI,CACrC,CAAC;wCACF,IAAI,OAAO,EAAE,CAAC;4CACZ,MAAM,CAAC,GACL,CAAC,KAAK,OAAO;gDACX,CAAC,CAAE,GAA2B,CAAC,IAAI,CAAC,CAAC,IAAI,CACrC,CAAC,CAAc,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,EAAE,CAClC;gDACH,CAAC,CAAE,GAA2B,CAAC,IAAI,CAAC;qDAC/B,MAAM,EAAE;qDACR,IAAI,CAAC,CAAC,CAAc,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC;4CACjD,IAAI,CAAC;gDACH,GAAG,GAAG,IAAA,YAAE,EACN,kCAAsB,CAAC,WAAW,EAClC,CAAC,CAAC,QAAQ,EAAE,CACb,CAAC;wCACN,CAAC;oCACH,CAAC;oCACD,MAAM;gCACR;oCACE,IAAI,CAAC;wCACH,IAAK,GAA2B,CAAC,IAAI,CAAC;4CACpC,GAAG,GAAI,GAA2B,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,CAAC;oCACzD,CAAC;oCAAC,OAAO,CAAM,EAAE,CAAC;wCAChB,OAAO,CAAC,IAAI,CACV,IAAA,YAAE,EAAC,yCAAyC,CAAC,CAC9C,CAAC;oCACJ,CAAC;4BACL,CAAC;wBACH,CAAC;oBACH,CAAC,CAAC,CAAC;oBAEH,IAAI,GAAG,EAAE,CAAC;wBACR,GAAG,GAAG,GAAG,IAAI,EAAE,CAAC;wBAChB,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC;oBAClB,CAAC;oBACD,OAAO,GAAG,CAAC;gBACb,CAAC,EAAE,SAAS,CAAC,CAAC;QAElB,IAAI,IAAI,EAAE,CAAC;YACT,KAAK,GAAG,KAAK,IAAI,EAAE,CAAC;YACpB,KAAK,CAAC,iBAAiB,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,GAAG,IAAI,CAAC;QAClD,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC,EACD,SAAS,CACV,CAAC;IACF,OAAO,MAAM,CAAC,CAAC,CAAC,IAAI,2CAAoB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AAC/D,CAAC;AAED,IAAI,oBAAsD,CAAC;AAC3D,IAAI,mBAAyC,CAAC;AAC9C,IAAI,UAA2B,CAAC;AAChC,IAAI,eAAoB,CAAC;AAEzB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAsB,KAAK;IAGzB,6DAA6D;IAC7D,YAAsB,KAAuB,IAAG,CAAC;IAEjD;;;;OAIG;IACI,SAAS,CAAC,GAAG,UAAiB;QACnC,OAAO,QAAQ,CAAC,IAAI,EAAE,GAAG,UAAU,CAAC,CAAC;IACvC,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,GAAQ,EAAE,GAAG,UAAoB;QAC7C,OAAO,IAAA,kBAAO,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,MAAM;QACX,OAAO,KAAK,CAAC,kBAAkB,EAAE,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC;IACrD,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,WAAW,CAAC,GAAW;QAC5B,OAAO,KAAK,CAAC,aAAa,EAAE,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IAChD,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,SAAS,CAAC,KAAU;QACzB,OAAO,KAAK,CAAC,aAAa,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IAChD,CAAC;IAED,MAAM,CAAC,IAAI,CAAC,GAAQ;QAClB,OAAO,KAAK,CAAC,kBAAkB,EAAE,CAAC,GAAG,CAAC,CAAC;IACzC,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,UAAU,CACf,IAAO,EACP,GAA6B;QAE7B,OAAO,IAAA,kCAAmB,EAAI,IAAI,EAAE,GAAG,CAAC,CAAC;IAC3C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAkB,IAAO,EAAE,GAA6B;QACtE,OAAO,IAAA,iCAAkB,EAAI,IAAI,EAAE,GAAG,CAAC,CAAC;IAC1C,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,+BAAoB,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;;;;OAIG;IACH,MAAM,CAAC,aAAa,CAAC,GAAoB;QACvC,UAAU,GAAG,GAAG,CAAC;IACnB,CAAC;IAED;;;OAGG;IACK,MAAM,CAAC,aAAa;QAC1B,IAAI,CAAC,UAAU;YAAE,UAAU,GAAG,IAAI,8BAAc,EAAE,CAAC;QACnD,OAAO,UAAU,CAAC;IACpB,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,kBAAkB,CAAC,MAAuB;QAC/C,eAAe,GAAG,MAAM,CAAC;IAC3B,CAAC;IAED;;;OAGG;IACK,MAAM,CAAC,kBAAkB;QAC/B,IAAI,CAAC,eAAe;YAAE,eAAe,GAAG,iBAAO,CAAC;QAChD,OAAO,eAAe,CAAC;IACzB,CAAC;CACF;AArMD,sBAqMC","file":"model/Model.js","sourcesContent":["import {\n  DEFAULT_ERROR_MESSAGES,\n  ValidationKeys,\n} from \"../validation/Validators/constants\";\nimport {\n  DecoratorMetadata,\n  Errors,\n  ModelErrors,\n  ValidationPropertyDecoratorDefinition,\n} from \"../validation/types\";\nimport { JSONSerializer, Serializer } from \"../utils/serialization\";\nimport { BuilderRegistry } from \"../utils/registry\";\nimport { ModelErrorDefinition } from \"./ModelErrorDefinition\";\nimport { ModelArg, ModelConstructor, Serializable, Validatable } from \"./types\";\nimport { ReservedModels } from \"./constants\";\nimport { ModelKeys } from \"../utils/constants\";\nimport {\n  constructFromModel,\n  constructFromObject,\n  ModelBuilderFunction,\n} from \"./construction\";\nimport { ModelRegistryManager } from \"./Registry\";\nimport { Validation } from \"../validation/Validation\";\nimport { getPropertyDecorators } from \"../reflection/utils\";\nimport { HashingFunction, hashObj } from \"../utils/hashing\";\nimport { sf } from \"../utils/strings\";\nimport { isEqual } from \"../utils/equality\";\n\n/**\n * @summary Analyses the decorations of the properties and validates the obj according to them\n *\n * @typedef T extends Model\n * @prop {T} obj Model object to validate\n * @prop {string[]} [propsToIgnore] object properties to ignore in the validation\n *\n * @function validate\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport function validate<T extends Model>(\n  obj: T,\n  ...propsToIgnore: string[]\n): ModelErrorDefinition | undefined {\n  const decoratedProperties: ValidationPropertyDecoratorDefinition[] = [];\n  for (const prop in obj)\n    if (obj.hasOwnProperty(prop) && propsToIgnore.indexOf(prop) === -1)\n      decoratedProperties.push(\n        getPropertyDecorators(\n          ValidationKeys.REFLECT,\n          obj,\n          prop,\n        ) as ValidationPropertyDecoratorDefinition,\n      );\n\n  const result = decoratedProperties.reduce(\n    (\n      accum: undefined | ModelErrors,\n      decoratedProperty: ValidationPropertyDecoratorDefinition,\n    ) => {\n      const { prop, decorators } = decoratedProperty;\n\n      if (!decorators || !decorators.length) return accum;\n\n      // @ts-expect-error due to type casting in decorators\n      const defaultTypeDecorator: { key: string; props: { name: string } } =\n        decorators[0];\n\n      // 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\n      if (\n        decorators.find((d) => {\n          if (d.key === ValidationKeys.TYPE) return true;\n          if (d.props.types?.find((t) => t === defaultTypeDecorator.props.name))\n            return true;\n          return false;\n        })\n      )\n        decorators.shift(); // remove the design:type decorator, since the type will already be checked\n\n      let errs: { [indexer: string]: Errors } | undefined = decorators.reduce(\n        (\n          acc: undefined | { [indexer: string]: Errors },\n          decorator: { key: string; props: object },\n        ) => {\n          const validator = Validation.get(decorator.key);\n          if (!validator) {\n            return acc;\n          }\n\n          const err: Errors = validator.hasErrors(\n            obj[prop.toString()],\n            ...(decorator.key === ModelKeys.TYPE\n              ? [decorator.props]\n              : Object.values(decorator.props)),\n          );\n\n          if (err) {\n            acc = acc || {};\n            acc[decorator.key] = err;\n          }\n\n          return acc;\n        },\n        undefined,\n      );\n\n      errs =\n        errs ||\n        Object.keys(obj)\n          .filter((k) => !errs || !errs[k])\n          .reduce((acc: Record<string, any> | undefined, prop) => {\n            let err: Errors;\n            // if a nested Model\n            const allDecorators = getPropertyDecorators(\n              ValidationKeys.REFLECT,\n              obj,\n              prop,\n            ).decorators;\n            const decorators = allDecorators.filter(\n              (d) =>\n                [ModelKeys.TYPE, ValidationKeys.TYPE].indexOf(d.key) !== -1,\n            );\n            if (!decorators || !decorators.length) return acc;\n            const 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: string) => {\n              if (reserved.indexOf(c.toLowerCase()) === -1) {\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 e =\n                          c === \"Array\"\n                            ? (obj as Record<string, any>)[prop].find(\n                                (c: Validatable) => c.hasErrors(),\n                              )\n                            : (obj as Record<string, any>)[prop]\n                                .values()\n                                .find((c: Validatable) => c.hasErrors());\n                        if (e)\n                          err = sf(\n                            DEFAULT_ERROR_MESSAGES.LIST_INSIDE,\n                            e.toString(),\n                          );\n                      }\n                    }\n                    break;\n                  default:\n                    try {\n                      if ((obj as Record<string, any>)[prop])\n                        err = (obj as Record<string, any>)[prop].hasErrors();\n                    } catch (e: any) {\n                      console.warn(\n                        sf(\"Model should be validatable but its not\"),\n                      );\n                    }\n                }\n              }\n            });\n\n            if (err) {\n              acc = acc || {};\n              acc[prop] = err;\n            }\n            return acc;\n          }, undefined);\n\n      if (errs) {\n        accum = accum || {};\n        accum[decoratedProperty.prop.toString()] = errs;\n      }\n\n      return accum;\n    },\n    undefined,\n  );\n  return result ? new ModelErrorDefinition(result) : undefined;\n}\n\nlet modelBuilderFunction: ModelBuilderFunction | undefined;\nlet actingModelRegistry: BuilderRegistry<any>;\nlet serializer: Serializer<any>;\nlet hashingFunction: any;\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 properties defined as optional;\n *  - Have all their properties initialized eg:\n *\n *  <pre>\n *      class ClassName {\n *          propertyName?: PropertyType = undefined;\n *      }\n *  </pre>\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 * @category Model\n */\nexport abstract class Model implements Validatable, Serializable {\n  [indexer: string]: any;\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  protected constructor(model?: 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 he 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 toHash(): string {\n    return Model.getHashingFunction()(this).toString();\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    return Model.getSerializer().deserialize(str);\n  }\n\n  /**\n   * @summary Serializes a Model\n   * @param {Model} model\n   */\n  static serialize(model: any) {\n    return Model.getSerializer().serialize(model);\n  }\n\n  static hash(obj: any): string {\n    return Model.getHashingFunction()(obj);\n  }\n\n  /**\n   * @summary Wrapper around {@link constructFromObject}\n   * @param {T} self\n   * @param {T | Record<string, any>} obj\n   */\n  static fromObject<T extends Model>(\n    self: T,\n    obj?: T | Record<string, any>,\n  ): T {\n    return constructFromObject<T>(self, obj);\n  }\n\n  /**\n   * @summary Wrapper around {@link constructFromModel}\n   * @param {T} self\n   * @param {T | Record<string, any>} obj\n   */\n  static fromModel<T extends Model>(self: T, obj?: T | Record<string, any>): T {\n    return constructFromModel<T>(self, obj);\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  /**\n   * @summary Sets the {@link Serializer}\n   *\n   * @param {Serializer} ser\n   */\n  static setSerializer(ser: Serializer<any>) {\n    serializer = ser;\n  }\n\n  /**\n   * @summary Retrieves the current defined {@link Serializer}\n   *\n   */\n  private static getSerializer() {\n    if (!serializer) serializer = new JSONSerializer();\n    return serializer;\n  }\n\n  /**\n   * @summary Sets the {@link HashingFunction}\n   *\n   * @param {HashingFunction} hasher\n   */\n  static setHashingFunction(hasher: HashingFunction) {\n    hashingFunction = hasher;\n  }\n\n  /**\n   * @summary Retrieves the current defined {@link HashingFunction}\n   *\n   */\n  private static getHashingFunction() {\n    if (!hashingFunction) hashingFunction = hashObj;\n    return hashingFunction;\n  }\n}\n"]}

package/lib/model/Model.d.ts

@@ -1,7 +1,9 @@
-import { BuilderRegistry, HashingFunction, Serializer } from "../utils";
+import { Serializer } from "../utils/serialization";
+import { BuilderRegistry } from "../utils/registry";
 import { ModelErrorDefinition } from "./ModelErrorDefinition";
 import { ModelArg, ModelConstructor, Serializable, Validatable } from "./types";
 import { ModelBuilderFunction } from "./construction";
+import { HashingFunction } from "../utils/hashing";
 /**
  * @summary Analyses the decorations of the properties and validates the obj according to them
  *

package/lib/model/ModelErrorDefinition.cjs

@@ -1,3 +1,59 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.ModelErrorDefinition=void 0;class ModelErrorDefinition{constructor(e){for(const r in e)e.hasOwnProperty(r)&&e[r]&&Object.defineProperty(this,r,{enumerable:!0,configurable:!1,value:e[r],writable:!1})}toString(){const t=this;return Object.keys(t).filter(e=>t.hasOwnProperty(e)&&"function"!=typeof t[e]).reduce((e,o)=>{var r=Object.keys(t[o]).reduce((e,r)=>(e?e+=`
-`+t[o][r]:e=t[o][r],e),void 0);return r&&(r=o+" - "+r,e?e+=`
-`+r:e=r),e},"")}}exports.ModelErrorDefinition=ModelErrorDefinition;
+"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 (errors.hasOwnProperty(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) => self.hasOwnProperty(k) && typeof self[k] !== "function")
+            .reduce((accum, prop) => {
+            let propError = Object.keys(self[prop]).reduce((propAccum, key) => {
+                if (!propAccum)
+                    // @ts-expect-error because i said so
+                    propAccum = self[prop][key];
+                // @ts-expect-error because i said so
+                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/ModelErrorDefinition.d.ts

@@ -1,4 +1,4 @@
-import { Errors, ModelErrors } from "../validation";
+import { Errors, ModelErrors } from "../validation/types";
 /**
  * @summary Helper Class to hold the error results
  * @description holds error results in an 'indexable' manner

package/lib/model/Registry.cjs

@@ -1 +1,81 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.bulkModelRegister=exports.ModelRegistryManager=void 0;const Model_1=require("./Model/index.cjs"),utils_1=require("../utils/index.cjs"),constants_1=require("../utils/constants/index.cjs");class ModelRegistryManager{constructor(e=constants_1.ModelKeys.ANCHOR,t=utils_1.isModel){this.cache={},this.testFunction=t,this.anchorKey=e}register(e,t){if("function"!=typeof e)throw new Error("Model registering failed. Missing Class name or constructor");t=t||e.name,this.cache[t]=e}get(e){try{return this.cache[e]}catch(e){}}build(e={},t){if(!t&&!this.testFunction(e))throw new Error("Provided obj is not a Model object");t=t||e[this.anchorKey].class;if(t in this.cache)return new this.cache[t](e);throw new Error((0,utils_1.stringFormat)("Provided class {0} is not a registered Model object",t))}}function bulkModelRegister(...e){e.forEach(e=>{var t=e.constructor||e;Model_1.Model.register(t,e.name)})}exports.ModelRegistryManager=ModelRegistryManager,exports.bulkModelRegister=bulkModelRegister;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelRegistryManager = void 0;
+exports.bulkModelRegister = bulkModelRegister;
+const Model_1 = require("./Model/index.cjs");
+const constants_1 = require("../utils/constants/index.cjs");
+const utils_1 = require("../reflection/utils/index.cjs");
+const strings_1 = require("../utils/strings/index.cjs");
+/**
+ * @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(anchorKey = constants_1.ModelKeys.ANCHOR, testFunction = utils_1.isModel) {
+        this.cache = {};
+        this.testFunction = testFunction;
+        this.anchorKey = anchorKey;
+    }
+    /**
+     * @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];
+        }
+        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 || obj[this.anchorKey].class;
+        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 of 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_1.Model.register(constructor, m.name);
+    });
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/model/Registry.d.ts

@@ -1,5 +1,5 @@
 import { Model } from "./Model";
-import { BuilderRegistry } from "../utils";
+import { BuilderRegistry } from "../utils/registry";
 import { Constructor, ModelConstructor } from "./types";
 /**
  * @summary ModelRegistry Interface

package/lib/model/constants.cjs

@@ -1 +1,47 @@
-"use strict";var Primitives,ReservedModels;Object.defineProperty(exports,"__esModule",{value:!0}),exports.ReservedModels=exports.Primitives=void 0,function(e){e.STRING="string",e.NUMBER="number",e.BOOLEAN="boolean",e.BIGINT="bigint"}(Primitives||(exports.Primitives=Primitives={})),function(e){e.STRING="string",e.OBJECT="object",e.NUMBER="number",e.BOOLEAN="boolean",e.BIGINT="bigint",e.DATE="date"}(ReservedModels||(exports.ReservedModels=ReservedModels={}));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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.Construction
+ * @category 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.Construction
+ * @category Construction
+ */
+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 = {}));
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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