@decaf-ts/decorator-validation 1.0.7

package/lib/model/Registry.d.ts

@@ -0,0 +1,61 @@
+import { Model } from "./Model";
+import { BuilderRegistry } from "../utils";
+import { Constructor, ModelConstructor } from "./types";
+/**
+ * @summary ModelRegistry Interface
+ *
+ * @interface ModelRegistry
+ * @extends BuilderRegistry<Model>
+ *
+ * @category Model
+ */
+export interface ModelRegistry<T extends Model> extends BuilderRegistry<T> {
+}
+/**
+ * @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
+ */
+export declare class ModelRegistryManager<T extends Model> implements ModelRegistry<T> {
+    private cache;
+    private readonly testFunction;
+    private readonly anchorKey;
+    constructor(anchorKey?: string, testFunction?: (obj: Record<string, any>) => boolean);
+    /**
+     * @summary register new Models
+     * @param {any} constructor
+     * @param {string} [name] when not defined, the name of the constructor will be used
+     */
+    register(constructor: ModelConstructor<T>, name?: string): void;
+    /**
+     * @summary Gets a registered Model {@link ModelConstructor}
+     * @param {string} name
+     */
+    get(name: string): ModelConstructor<T> | 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?: Record<string, any>, clazz?: string): T;
+}
+/**
+ * @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
+ */
+export declare function bulkModelRegister<T extends Model>(...models: (Constructor<T> | {
+    name: string;
+    constructor: Constructor<T>;
+})[]): void;

package/lib/model/constants.cjs

@@ -0,0 +1 @@
+"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={}));

package/lib/model/constants.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @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
+ */
+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.Construction
+ * @category Construction
+ */
+export declare enum ReservedModels {
+    STRING = "string",
+    OBJECT = "object",
+    NUMBER = "number",
+    BOOLEAN = "boolean",
+    BIGINT = "bigint",
+    DATE = "date"
+}

package/lib/model/construction.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.construct=exports.constructFromModel=exports.constructFromObject=void 0;const Model_1=require("./Model/index.cjs"),utils_1=require("../utils/index.cjs"),validation_1=require("../validation/index.cjs"),constants_1=require("./constants/index.cjs"),constants_2=require("../utils/constants/index.cjs");function constructFromObject(o,t){if(t)for(const r in t)t.hasOwnProperty(r)&&(o.hasOwnProperty(r)||o.prototype&&o.prototype.hasOwnProperty(r))&&(o[r]=t[r]);return o}function constructFromModel(s,o){if(o)for(const n in o)if(o.hasOwnProperty(n)&&(s.hasOwnProperty(n)||s.prototype&&s.prototype.hasOwnProperty(n))){if(s[n]=o[n],"object"!=typeof s[n])continue;if((0,utils_1.isModel)(s[n])){try{s[n]=Model_1.Model.build(s[n])}catch(o){console.log(o)}continue}const c=(0,utils_1.getPropertyDecorators)(validation_1.ValidationKeys.REFLECT,s,n).decorators;if(!(t=c.filter(o=>-1!==[constants_2.ModelKeys.TYPE,validation_1.ValidationKeys.TYPE].indexOf(o.key)))||!t.length)throw new Error((0,utils_1.stringFormat)("failed to find decorators for property {0}",n));var t=(t=t.pop()).props.name?[t.props.name]:Array.isArray(t.props.customTypes)?t.props.customTypes:[t.props.customTypes];const i=Object.values(constants_1.ReservedModels).map(o=>o.toLowerCase());t.forEach(o=>{if(-1===i.indexOf(o.toLowerCase()))try{switch(o){case"Array":case"Set":if(c.length){const r=c.find(o=>o.key===validation_1.ValidationKeys.LIST);if(r&&("Array"===o&&(s[n]=s[n].map(o=>Model_1.Model.build(o,r.props.class))),"Set"===o)){var t=new Set;for(const e of s[n])t.add(Model_1.Model.build(e,r.props.class));s[n]=t}}break;default:s[n]&&(s[n]=Model_1.Model.build(s[n],o))}}catch(o){console.log(o)}})}return s}function construct(t,...o){var r=(...o)=>new t(...o);return r.prototype=t.prototype,r(...o)}exports.constructFromObject=constructFromObject,exports.constructFromModel=constructFromModel,exports.construct=construct;

package/lib/model/construction.d.ts

@@ -0,0 +1,45 @@
+import { Model } from "./Model";
+/**
+ * @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]
+ *
+ * @function constructFromObject
+ * @memberOf module:decorator-validation.Construction
+ * @category Construction
+ */
+export declare function constructFromObject<T extends Model>(self: T, obj?: T | Record<string, any>): T;
+/**
+ * @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]
+ *
+ * @function constructFromModel
+ * @memberOf module:decorator-validation.Construction
+ * @category Construction
+ */
+export declare function constructFromModel<T extends Model>(self: T, obj?: T | Record<string, any>): T;
+/**
+ * @summary Helper Function to override constructors
+ *
+ * @param {Function} constructor
+ * @param {any[]} [args]
+ * @return {T} the new instance
+ *
+ * @function construct
+ * @memberOf module:decorator-validation.Construction
+ * @category Construction
+ */
+export declare function construct<T extends Model>(constructor: any, ...args: any[]): T;
+/**
+ * @summary Typo of a Model builder function
+ * @memberOf module:decorator-validation.Construction
+ * @category Construction
+ */
+export type ModelBuilderFunction = <T extends Model>(self: T, obj?: T | Record<string, any>) => T;

package/lib/model/decorators.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.model=exports.getModelKey=void 0;const construction_1=require("./construction/index.cjs"),constants_1=require("../utils/constants/index.cjs"),Model_1=require("./Model/index.cjs"),getModelKey=e=>constants_1.ModelKeys.REFLECT+e;function model(n,s){return r=>{function e(...e){var t=(0,construction_1.construct)(r,...e),o=((o=Model_1.Model.getBuilder())&&o(t,e.length?e[0]:void 0),Object.assign({},{class:r.name}));return Object.defineProperty(t,constants_1.ModelKeys.ANCHOR,{writable:!1,enumerable:!1,configurable:!1,value:o}),Reflect.defineMetadata((0,exports.getModelKey)(constants_1.ModelKeys.MODEL),Object.assign(o,n||{}),t.constructor),s&&s(t,...e),t}return e.prototype=r.prototype,Object.defineProperty(e,"name",{writable:!1,enumerable:!0,configurable:!1,value:r.prototype.constructor.name}),Model_1.Model.register(e),e}}exports.getModelKey=getModelKey,exports.model=model;

package/lib/model/decorators.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @summary Builds the key to store as Metadata under Reflections
+ * @description concatenates {@link ModelKeys#REFLECT} with the provided key
+ * @param {string} str
+ *
+ * @function getModelKey
+ * @memberOf module:decorator-validation.Model
+ * @category Utilities
+ */
+export declare const getModelKey: (str: string) => string;
+/**
+ * @summary defines the tpe os an InstanceCallback function
+ * @memberOf module:decorator-validation.Construction
+ * @category Construction
+ */
+export type InstanceCallback = (instance: any, ...args: any[]) => void;
+/**
+ * @summary Defines a class as a Model class
+ * @description
+ * - Registers the class under the model registry so it can be easily rebuilt;
+ * - Overrides the class constructor;
+ * - Runs the global {@link ModelBuilderFunction} if defined;
+ * - Runs the optional {@link InstanceCallback} if provided;
+ * - Defines an {@link ModelKeys#ANCHOR} property for serialization and model rebuilding purposes;
+ *
+ * @prop {Record<string, any>} [props] additional properties to store as metadata
+ * @prop {InstanceCallback} [instanceCallback] optional callback that will be call with the instance upon instantiation. defaults to undefined
+ *
+ * @function model
+ * @memberOf module:decorator-validation.Decorators.Model
+ * @category Decorators
+ */
+export declare function model(props?: Record<string, any>, instanceCallback?: InstanceCallback): (original: any) => any;

package/lib/model/index.cjs

@@ -0,0 +1 @@
+"use strict";var __createBinding=this&&this.__createBinding||(Object.create?function(e,r,t,o){void 0===o&&(o=t);var i=Object.getOwnPropertyDescriptor(r,t);i&&("get"in i?r.__esModule:!i.writable&&!i.configurable)||(i={enumerable:!0,get:function(){return r[t]}}),Object.defineProperty(e,o,i)}:function(e,r,t,o){e[o=void 0===o?t:o]=r[t]}),__exportStar=this&&this.__exportStar||function(e,r){for(var t in e)"default"===t||Object.prototype.hasOwnProperty.call(r,t)||__createBinding(r,e,t)};Object.defineProperty(exports,"__esModule",{value:!0}),__exportStar(require("./construction/index.cjs"),exports),__exportStar(require("./Registry/index.cjs"),exports),__exportStar(require("./decorators/index.cjs"),exports),__exportStar(require("./ModelErrorDefinition/index.cjs"),exports),__exportStar(require("./types/index.cjs"),exports),__exportStar(require("./Model/index.cjs"),exports),__exportStar(require("./constants/index.cjs"),exports);

package/lib/model/index.d.ts

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

package/lib/model/types.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});

package/lib/model/types.d.ts

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

package/lib/utils/constants.cjs

@@ -0,0 +1 @@
+"use strict";var ModelKeys;Object.defineProperty(exports,"__esModule",{value:!0}),exports.ModelKeys=void 0,function(e){e.REFLECT="model.definition.",e.TYPE="design:type",e.PARAMS="design:paramtypes",e.RETURN="design:returntype",e.MODEL="model",e.ANCHOR="__modelDefinition"}(ModelKeys||(exports.ModelKeys=ModelKeys={}));

package/lib/utils/constants.d.ts

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

package/lib/utils/general.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.dateFromFormat=exports.evaluateDesignTypes=exports.checkTypes=exports.checkType=exports.getClassDecorators=exports.isModel=exports.hashObj=exports.hashSerialization=exports.hashCode=exports.isEqual=exports.stringFormat=exports.getAllProperties=exports.getAllPropertyDecorators=exports.getTypeFromDecorator=exports.getPropertyDecorators=void 0,require("reflect-metadata");const validation_1=require("../validation/index.cjs"),constants_1=require("./constants/index.cjs"),model_1=require("../model/index.cjs");function getPropertyDecorators(e,r,t,o=!1,s=!0,a){o=function(r,o,s,t=!1,e){e=Reflect.getMetadataKeys(o,s).filter(e=>!t&&e===constants_1.ModelKeys.TYPE||e.toString().startsWith(r)).reduce((e,t)=>{t={key:t!==constants_1.ModelKeys.TYPE?t.substring(r.length):t,props:Reflect.getMetadata(t,o,s)};return e.concat(t)},e||[]);return{prop:s.toString(),decorators:e}}(e,r,t,o,a);return s&&Object.getPrototypeOf(r)!==Object.prototype?getPropertyDecorators(e,Object.getPrototypeOf(r.constructor),t,!0,s,o.decorators):{prop:o.prop,decorators:function(e){const t={};return e.filter(e=>e.key in t?(isEqual(e.props,t[e.key])||console.log(stringFormat("Found a similar decorator for the {0} property of a {1} model but with different attributes. The original one will be kept",e.key,r.constructor.name)),!1):(t[e.key.toString()]=e.props,!0))}(o.decorators)}}function getTypeFromDecorator(e,t){var e=getPropertyDecorators(constants_1.ModelKeys.REFLECT,e,t,!1);return e&&e.decorators&&"Function"!==(e=(t=e.decorators.shift()).props?t.props.name:void 0)?e:void 0}exports.getPropertyDecorators=getPropertyDecorators,exports.getTypeFromDecorator=getTypeFromDecorator;const getAllPropertyDecorators=function(a,...e){if(e&&e.length)return Object.getOwnPropertyNames(a).reduce((o,s)=>(e.forEach((e,t)=>{var r,e=getPropertyDecorators(e,a,s,0!==t);t=o=o||{},r=s,(e=e.decorators)&&e.length&&(t[r]||(t[r]=[]),t[r].push(...e))}),o),void 0)};function getAllProperties(e,t=!0,r="Object"){const o=[];let s=e;do{Object.getOwnPropertyNames(s).forEach(function(e){-1===o.indexOf(e)&&o.push(e)})}while(function(){if(t){var e=Object.getPrototypeOf(s);if(e&&e.constructor.name!==r)return s=e}}());return o}function stringFormat(e,...r){return e.replace(/{(\d+)}/g,function(e,t){return void 0!==r[t]?r[t]:e})}function isEqual(t,r,...o){var e;return t===r||(t instanceof Date&&r instanceof Date?t.getTime()===r.getTime():!t||!r||"object"!=typeof t&&"object"!=typeof r?t===r:null!=t&&null!=r&&typeof t==typeof r&&t.prototype===r.prototype&&(e=Object.keys(t).filter(e=>-1===o.indexOf(e))).length===Object.keys(r).filter(e=>-1===o.indexOf(e)).length&&e.every(e=>-1!==o.indexOf(e)||isEqual(t[e],r[e],...o)))}function hashCode(t){t=String(t);let r=0;for(let e=0;e<t.length;e++){var o=t.charCodeAt(e);r=(r<<5)-r+o,r&=r}return r}function hashSerialization(e){return hashCode(model_1.Model.serialize(e))}function hashObj(e){function o(e){return void 0===e?"":-1!==["string","number","symbol"].indexOf(typeof e)?r(e.toString()):e instanceof Date?r(e.getTime()):(Array.isArray(e)?e:Object.values(e)).reduce(t,void 0)}const t=function(e,t){var r=o(t);return"string"==typeof r?o((e||"")+o(t)):(e=((e=e||0)<<5)-e+r)&e},r=hashCode;e=Object.values(e).reduce(t,0);return"number"==typeof e?Math.abs(e):e}function isModel(e){return!!e[constants_1.ModelKeys.ANCHOR]||!!getClassDecorators(constants_1.ModelKeys.REFLECT,e).find(e=>e.key===constants_1.ModelKeys.MODEL&&e.props&&e.props.class)}function getClassDecorators(r,o){return Reflect.getOwnMetadataKeys(o.constructor).filter(e=>e.toString().startsWith(r)).reduce((e,t)=>{t={key:t.substring(r.length),props:Reflect.getMetadata(t,o.constructor)};return e.concat(t)},[])}function checkType(e,t){return typeof e===t||e.constructor&&e.constructor.name.toLowerCase()===t.toLowerCase()}function checkTypes(t,e){return!e.every(e=>!checkType(t,e))}function evaluateDesignTypes(e,t){switch(typeof t){case"string":return checkType(e,t);case"object":return Array.isArray(t)?checkTypes(e,t):!0;case"function":return t.name&&"Object"!==t.name?checkType(e,t.name):!0;default:return!0}}function dateFromFormat(e,t){let r=t;r.match(/hh/)?r=r.replace("hh","(?<hour>\\d{2})"):r.match(/h/)?r=r.replace("h","(?<hour>\\d{1,2})"):r.match(/HH/)?r=r.replace("HH","(?<hour>\\d{2})"):r.match(/H/)&&(r=r.replace("H","(?<hour>\\d{1,2})")),r.match(/mm/)?r=r.replace("mm","(?<minutes>\\d{2})"):r.match(/m/)&&(r=r.replace("m","(?<minutes>\\d{1,2})")),r.match(/ss/)?r=r.replace("ss","(?<seconds>\\d{2})"):r.match(/s/)&&(r=r.replace("s","(?<seconds>\\d{1,2})")),r.match(/dd/)?r=r.replace("dd","(?<day>\\d{2})"):r.match(/d/)&&(r=r.replace("d","(?<day>\\d{1,2})")),r.match(/EEEE/)?r=r.replace("EEEE","(?<dayofweek>\\w+)"):r.match(/EEEE/)&&(r=r.replace("EEE","(?<dayofweek>\\w+)")),r.match(/yyyy/)?r=r.replace("yyyy","(?<year>\\d{4})"):r.match(/yy/)&&(r=r.replace("yy","(?<year>\\d{2})")),r.match(/MMMM/)?r=r.replace("MMMM","(?<monthname>\\w+)"):r.match(/MMM/)&&(r=r.replace("MMM","(?<monthnamesmall>\\w+)")),r.match(/MM/)?r=r.replace("MM","(?<month>\\d{2})"):r.match(/M/)&&(r=r.replace("M","(?<month>\\d{1,2})")),r=r.replace("S","(?<milis>\\d{1,3})").replace("aaa","(?<ampm>\\w{2})");t=new RegExp(r,"g").exec(e);if(!t||!t.groups)return new Date(e);function o(e){return!e||(e=parseInt(e),isNaN(e))?0:e}var s=o(t.groups.year),a=o(t.groups.day),n=t.groups.ampm;let c=o(t.groups.hour);n&&(c="PM"===n?c+12:c);var n=o(t.groups.minutes),p=o(t.groups.seconds),i=o(t.groups.milis),l=t.groups.monthname;const u=t.groups.monthnamesmall;let d=t.groups.month;if(l)d=validation_1.MONTH_NAMES.indexOf(l);else if(u){t=validation_1.MONTH_NAMES.find(e=>e.toLowerCase().startsWith(u.toLowerCase()));if(!t)return new Date(e);d=validation_1.MONTH_NAMES.indexOf(t)}else d=o(""+d);return new Date(s,d-1,a,c,n,p,i)}exports.getAllPropertyDecorators=getAllPropertyDecorators,exports.getAllProperties=getAllProperties,exports.stringFormat=stringFormat,exports.isEqual=isEqual,exports.hashCode=hashCode,exports.hashSerialization=hashSerialization,exports.hashObj=hashObj,exports.isModel=isModel,exports.getClassDecorators=getClassDecorators,exports.checkType=checkType,exports.checkTypes=checkTypes,exports.evaluateDesignTypes=evaluateDesignTypes,exports.dateFromFormat=dateFromFormat;

package/lib/utils/general.d.ts

@@ -0,0 +1,193 @@
+import "reflect-metadata";
+import { DecoratorMetadata } from "../validation";
+import { Model } from "../model";
+/**
+ * @summary Util function to retrieve the decorators for the provided Property
+ *
+ * @param {string} annotationPrefix
+ * @param {any} target
+ * @param {string | symbol} propertyName
+ * @param {boolean} [ignoreType] defaults to false. decides if the {@link ModelKeys.TYPE} is ignored or not
+ * @param {boolean} [recursive] defaults to true. decides if it should climb the prototypal tree searching for more decorators on that property
+ * @param {DecoratorMetadata[]} [accumulator] used when recursive is true, to cache decorators while it climbs the prototypal tree
+ *
+ * @function getPropertyDecorators
+ * @memberOf module:decorator-validation.Reflection
+ * @category Reflection
+ */
+export declare function getPropertyDecorators(annotationPrefix: string, target: any, propertyName: string | symbol, ignoreType?: boolean, recursive?: boolean, accumulator?: DecoratorMetadata[]): {
+    prop: string;
+    decorators: DecoratorMetadata[];
+};
+/**
+ * @summary gets the prop type from the decorator
+ * @param {any} model
+ * @param {string | symbol} propKey
+ * @return {string | undefined}
+ *
+ * @function geTypeFromDecorators
+ *
+ * @memberOf module:decorator-validation.Reflection
+ */
+export declare function getTypeFromDecorator(model: any, propKey: string | symbol): string | undefined;
+/**
+ * @summary Retrieves the decorators for an object's properties prefixed by {@param prefixes}
+ *
+ * @param {T} model
+ * @param {string[]} prefixes
+ *
+ * @function getAllPropertyDecorators
+ *
+ * @memberOf module:db-decorators.Reflection
+ */
+export declare const getAllPropertyDecorators: <T extends Model>(model: T, ...prefixes: string[]) => Record<string, any> | undefined;
+/**
+ * @summary Retrieves all properties of an object
+ * @description
+ *  - and of all its prototypes if {@param climbTree} until it reaches {@param stopAt} (or ends the prototype chain)
+ *
+ * @param obj
+ * @param {boolean} [climbTree] default to true
+ * @param {string} [stopAt] defaults to 'Object'
+ *
+ * @function getAllProperties
+ *
+ * @memberOf module:decorator-validation.Model
+ */
+export declare function getAllProperties(obj: Record<any, any>, climbTree?: boolean, stopAt?: string): string[];
+/**
+ * @summary Util function to provide string format functionality similar to C#'s string.format
+ *
+ * @param {string} string
+ * @param {string} args replacements made by order of appearance (replacement0 wil replace {0} and so on)
+ * @return {string} formatted string
+ *
+ * @function stringFormat
+ * @memberOf module:decorator-validation.Utils.Format
+ * @category Format
+ */
+export declare function stringFormat(string: string, ...args: string[]): string;
+/**
+ * @summary Deep Object Comparison
+ * @description algorithm from {@link https://stackoverflow.com/questions/30476150/javascript-deep-comparison-recursively-objects-and-properties}
+ * but with optional ignored properties
+ *
+ * @param {any} a
+ * @param {any} b
+ * @param {string} [propsToIgnore]
+ *
+ * @function isEqual
+ * @memberOf module:decorator-validation.Utils.Equality
+ * @category Validation
+ */
+export declare function isEqual(a: any, b: any, ...propsToIgnore: string[]): boolean;
+/**
+ * @summary Mimics Java's String's Hash implementation
+ *
+ * @param {string | number | symbol | Date} obj
+ * @return {number} hash value of obj
+ *
+ * @function hashCode
+ * @memberOf module:decorator-validation.Utils.Hashing
+ * @category Hashing
+ */
+export declare function hashCode(obj: string | number | symbol | Date): number;
+/**
+ * @summary Defines teh type for a Hashing function
+ * @memberOf module:decorator-validation.Utils.Hashing
+ * @category Hashing
+ */
+export type HashingFunction = (value: any) => string | number;
+/**
+ * @summary Hashes an object serializing it and then hashing the string
+ * @description The Serialization algorithm used by default (JSON.stringify)
+ * is not deterministic and should not be used for hashing
+ *
+ * @param {Record<string, any>} obj
+ * @return {string} the resulting hash
+ *
+ * @function hashSerialization
+ * @memberOf module:decorator-validation.Utils.Hashing
+ *
+ * @category Hashing
+ */
+export declare function hashSerialization(obj: Record<string, any> | any[]): number;
+/**
+ * @summary Hashes an object by combining the hash of all its properties
+ *
+ * @param {Record<string, any>} obj
+ * @return {string} the resulting hash
+ *
+ * @function hashObj
+ * @memberOf module:decorator-validation.Utils.Hashing
+ * @category Hashing
+ */
+export declare function hashObj(obj: Record<string, any> | any[]): string | number;
+/**
+ * @summary For Serialization/deserialization purposes.
+ * @description Reads the {@link ModelKeys.ANCHOR} property of a {@link Model} to discover the class to instantiate
+ *
+ * @function isModel
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+export declare function isModel(target: Record<string, any>): boolean;
+/**
+ * @summary Util function to retrieve the Class decorators
+ *
+ * @function getClassDecorators
+ * @memberOf module:decorator-validation.Reflection
+ * @category Reflection
+ */
+export declare function getClassDecorators(annotationPrefix: string, target: any): {
+    key: string;
+    props: any;
+}[];
+/**
+ * @summary Util function to check a type according to a typeName
+ *
+ * @param {any} value
+ * @param {string} acceptedType
+ * @return {boolean} true for a match, false otherwise
+ *
+ * @function checkType
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+export declare function checkType(value: any, acceptedType: string): any;
+/**
+ * @summary Util function to check a type according multiple possibilities
+ * @param {any} value
+ * @param {string[]} acceptedTypes
+ * @return {boolean} true if any is a match, false otherwise
+ *
+ * @function checkTypes
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+export declare function checkTypes(value: any, acceptedTypes: string[]): boolean;
+/**
+ * @summary The model type
+ *
+ * @param {any} value
+ * @param {string | string[] | {name: string}} types
+ *
+ * @function evaluateDesignTypes
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+export declare function evaluateDesignTypes(value: any, types: string | string[] | {
+    name: string;
+}): any;
+/**
+ * @summary Reverses the process from {@link formatDate}
+ *
+ * @param {string} date the date string to be converted back into date
+ * @param {string} format the date format
+ * @return {Date} the date from the format or the standard new Date({@prop date}) if the string couldn't be parsed (are you sure the format matches the string?)
+ *
+ * @function dateFromFormat
+ * @memberOf module:decorator-validation.Utils.Dates
+ * @category Format
+ */
+export declare function dateFromFormat(date: string, format: string): Date;

package/lib/utils/index.cjs

@@ -0,0 +1 @@
+"use strict";var __createBinding=this&&this.__createBinding||(Object.create?function(e,r,t,i){void 0===i&&(i=t);var o=Object.getOwnPropertyDescriptor(r,t);o&&("get"in o?r.__esModule:!o.writable&&!o.configurable)||(o={enumerable:!0,get:function(){return r[t]}}),Object.defineProperty(e,i,o)}:function(e,r,t,i){e[i=void 0===i?t:i]=r[t]}),__exportStar=this&&this.__exportStar||function(e,r){for(var t in e)"default"===t||Object.prototype.hasOwnProperty.call(r,t)||__createBinding(r,e,t)};Object.defineProperty(exports,"__esModule",{value:!0}),__exportStar(require("./general/index.cjs"),exports),__exportStar(require("./registry/index.cjs"),exports),__exportStar(require("./serialization/index.cjs"),exports),__exportStar(require("./constants/index.cjs"),exports);

package/lib/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./general";
+export * from "./registry";
+export * from "./serialization";
+export * from "./constants";

package/lib/utils/registry.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});

package/lib/utils/registry.d.ts

@@ -0,0 +1,68 @@
+import { Constructor } from "../model/types";
+/**
+ * @summary Basic interface for Registries
+ *
+ * @interface IRegistry
+ *
+ * @category Utilities
+ */
+export interface IRegistry<T> {
+    /**
+     * @summary Registers an Object
+     *
+     * @param {T} obj
+     * @param {any[]} args
+     *
+     * @method
+     */
+    register(obj: T | any, ...args: any[]): void;
+    /**
+     * @summary Retrieves an Object if it can find it
+     *
+     * @param {any} key
+     * @param {any[]} args
+     * @return {T | undefined}
+     *
+     * @method
+     */
+    get(key: any, ...args: any[]): T | undefined;
+}
+/**
+ * @summary Basic Builder Registry Interface
+ *
+ * @typedef T
+ * @interface BuilderRegistry<T>
+ *
+ * @category Construction
+ */
+export interface BuilderRegistry<T> extends IRegistry<Constructor<T>> {
+    /**
+     * @summary Retrieves an Builder Object by name if it can
+     *
+     * @param {string} name
+     * @param {any[]} args
+     *
+     * @method
+     */
+    get(name: string, ...args: any[]): Constructor<T> | undefined;
+    /**
+     * @summary Registers a constructor by name
+     *
+     * @param {Constructor<T>} [constructor]
+     * @param {name} name
+     * @param {any[]} args
+     *
+     * @method
+     */
+    register(constructor: Constructor<T>, name?: string, ...args: any[]): void;
+    /**
+     * @summary Builds an Object by name
+     *
+     * @param {{}} obj
+     * @param {any[]} args
+     * @return T
+     *
+     * @method
+     */
+    build(obj: Record<string, any> | T, ...args: any[]): T;
+}

package/lib/utils/serialization.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.JSONSerializer=void 0;const Model_1=require("../model/Model/index.cjs"),constants_1=require("./constants/index.cjs");class JSONSerializer{preSerialize(e){var r=Object.assign({},e);return r[constants_1.ModelKeys.ANCHOR]=e[constants_1.ModelKeys.ANCHOR],r}deserialize(e){e=JSON.parse(e);return Model_1.Model.build(e)}serialize(e){return JSON.stringify(this.preSerialize(e))}}exports.JSONSerializer=JSONSerializer;

package/lib/utils/serialization.d.ts

@@ -0,0 +1,65 @@
+import { Model } from "../model/Model";
+/**
+ * @summary Helper in serialization
+ *
+ * @interface Serializer
+ * @category Serialization
+ */
+export interface Serializer<T extends Model> {
+    /**
+     * @summary Serializes a model
+     * @param {T} model
+     *
+     * @method
+     *
+     * @throws {Error}
+     */
+    serialize(model: T): string;
+    /**
+     * @summary Rebuilds a model from serialization
+     * @param {string} str
+     *
+     * @method
+     *
+     * @throws {Error}
+     */
+    deserialize(str: string): T;
+}
+/**
+ * @summary Concrete implementation of a {@link Serializer} in JSON format
+ * @description JS's native JSON.stringify (used here) is not deterministic
+ * and therefore should not be used for hashing purposes
+ *
+ * To keep dependencies low, we will not implement this, but we recommend
+ * implementing a similar {@link JSONSerializer} using 'deterministic-json' libraries
+ *
+ * @class JSONSerializer
+ * @implements Serializer
+ *
+ * @category Serialization
+ */
+export declare class JSONSerializer<T extends Model> implements Serializer<T> {
+    /**
+     * @summary prepares the model for serialization
+     * @description returns a shallow copy of the object, containing an enumerable {@link ModelKeys#ANCHOR} property
+     * so the object can be recognized upon deserialization
+     *
+     * @param {T} model
+     * @protected
+     */
+    protected preSerialize(model: T): {} & T;
+    /**
+     * @summary Rebuilds a model from a serialization
+     * @param {string} str
+     *
+     * @throws {Error} If it fails to parse the string, or to build the model
+     */
+    deserialize(str: string): T;
+    /**
+     * @summary Serializes a model
+     * @param {T} model
+     *
+     * @throws {Error} if fails to serialize
+     */
+    serialize(model: T): string;
+}