@decaf-ts/decorator-validation 1.5.12 → 1.6.0

package/lib/model/Model.d.ts

@@ -0,0 +1,204 @@
+import { BuilderRegistry } from "../utils/registry";
+import { ModelErrorDefinition } from "./ModelErrorDefinition";
+import { Comparable, Constructor, Hashable, ModelArg, ModelBuilderFunction, ModelConstructor, Serializable, Validatable } from "./types";
+export declare function isPropertyModel<M extends Model>(target: M, attribute: string): boolean | string | undefined;
+/**
+ * @summary For Serialization/deserialization purposes.
+ * @description Reads the {@link ModelKeys.ANCHOR} property of a {@link Model} to discover the class to instantiate
+ *
+ * @function isModel
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+export declare function isModel(target: Record<string, any>): boolean;
+/**
+ * @summary ModelRegistry Interface
+ *
+ * @interface ModelRegistry
+ * @extends BuilderRegistry<Model>
+ *
+ * @category Model
+ */
+export type ModelRegistry<T extends Model> = 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;
+    constructor(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 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;
+/**
+ * @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;
+ *      }
+ */
+export declare abstract class Model implements Validatable, Serializable, Hashable, Comparable<Model> {
+    protected constructor(arg?: ModelArg<Model>);
+    /**
+     * @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: any[]): ModelErrorDefinition | undefined;
+    /**
+     * @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: any, ...exceptions: string[]): boolean;
+    /**
+     * @summary Returns the serialized model according to the currently defined {@link Serializer}
+     */
+    serialize(): string;
+    /**
+     * @summary Override the implementation for js's 'toString()' which sucks...
+     * @override
+     */
+    toString(): string;
+    /**
+     * @summary Defines a default implementation for object hash. Relies on a very basic implementation based on Java's string hash;
+     */
+    hash(): string;
+    /**
+     * @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: string): any;
+    /**
+     * @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<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]
+     *
+     */
+    static fromModel<T extends Model>(self: T, obj?: T | Record<string, any>): T;
+    /**
+     * @summary Sets the Global {@link ModelBuilderFunction}
+     * @param {ModelBuilderFunction} [builder]
+     */
+    static setBuilder(builder?: ModelBuilderFunction): void;
+    /**
+     * @summary Retrieves the current global {@link ModelBuilderFunction}
+     */
+    static getBuilder(): ModelBuilderFunction | undefined;
+    /**
+     * Returns the current {@link ModelRegistryManager}
+     *
+     * @return ModelRegistry, defaults to {@link ModelRegistryManager}
+     */
+    private static getRegistry;
+    /**
+     * Returns the current actingModelRegistry
+     *
+     * @param {BuilderRegistry} modelRegistry the new implementation of Registry
+     */
+    static setRegistry(modelRegistry: BuilderRegistry<any>): void;
+    /**
+     * @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<T extends Model>(constructor: ModelConstructor<T>, name?: string): void;
+    /**
+     * @summary Gets a registered Model {@link ModelConstructor}
+     * @param {string} name
+     *
+     * @see ModelRegistry
+     */
+    static get<T extends Model>(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
+     *
+     * @see ModelRegistry
+     */
+    static build<T extends Model>(obj?: Record<string, any>, clazz?: string): T;
+    static getMetadata<V extends Model>(model: V): any;
+    static getAttributes<V extends Model>(model: Constructor<V> | V): string[];
+    static equals<V extends Model>(obj1: V, obj2: V, ...exceptions: any[]): boolean;
+    static hasErrors<V extends Model>(model: V, ...propsToIgnore: string[]): ModelErrorDefinition | undefined;
+    static serialize<V extends Model>(model: V): any;
+    static hash<V extends Model>(model: V): any;
+    /**
+     * @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: string): string;
+}

package/lib/model/ModelErrorDefinition.cjs

@@ -54,5 +54,4 @@ class ModelErrorDefinition {
     }
 }
 exports.ModelErrorDefinition = ModelErrorDefinition;
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/model/ModelErrorDefinition.d.ts

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

package/lib/model/constants.cjs

@@ -70,5 +70,4 @@ exports.jsTypes = [
     "null",
     "bigint",
 ];
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9tb2RlbC9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUE7Ozs7Ozs7Ozs7R0FVRztBQUNILElBQVksVUFLWDtBQUxELFdBQVksVUFBVTtJQUNwQiwrQkFBaUIsQ0FBQTtJQUNqQiwrQkFBaUIsQ0FBQTtJQUNqQixpQ0FBbUIsQ0FBQTtJQUNuQiwrQkFBaUIsQ0FBQTtBQUNuQixDQUFDLEVBTFcsVUFBVSwwQkFBVixVQUFVLFFBS3JCO0FBRUQ7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gsSUFBWSxjQU9YO0FBUEQsV0FBWSxjQUFjO0lBQ3hCLG1DQUFpQixDQUFBO0lBQ2pCLG1DQUFpQixDQUFBO0lBQ2pCLG1DQUFpQixDQUFBO0lBQ2pCLHFDQUFtQixDQUFBO0lBQ25CLG1DQUFpQixDQUFBO0lBQ2pCLCtCQUFhLENBQUE7QUFDZixDQUFDLEVBUFcsY0FBYyw4QkFBZCxjQUFjLFFBT3pCO0FBRUQ7Ozs7Ozs7Ozs7Ozs7Ozs7R0FnQkc7QUFDVSxRQUFBLE9BQU8sR0FBRztJQUNyQixRQUFRO0lBQ1IsT0FBTztJQUNQLFFBQVE7SUFDUixTQUFTO0lBQ1QsUUFBUTtJQUNSLFVBQVU7SUFDVixRQUFRO0lBQ1IsV0FBVztJQUNYLE1BQU07SUFDTixRQUFRO0NBQ1QsQ0FBQyIsImZpbGUiOiJtb2RlbC9jb25zdGFudHMuanMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBzdW1tYXJ5IFJlZmVyZW5jZXMgdGhlIHJlbGV2YW50IEpTIHByaW1pdGl2ZXNcbiAqXG4gKiBAcHJvcGVydHkge3N0cmluZ30gU1RSSU5HIHJlZmVyZW5jZXMgdGhlIHN0cmluZyBwcmltaXRpdmVcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBOVU1CRVIgcmVmZXJlbmNlcyB0aGUgbnVtYmVyIHByaW1pdGl2ZVxuICogQHByb3BlcnR5IHtzdHJpbmd9IEJPT0xFQU4gcmVmZXJlbmNlcyB0aGUgYm9vbGVhbiBwcmltaXRpdmVcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBCSUdJTlQgcmVmZXJlbmNlcyB0aGUgYmlnaW50IHByaW1pdGl2ZVxuICpcbiAqIEBjb25zdGFudCBQcmltaXRpdmVzXG4gKiBAbWVtYmVyT2YgbW9kdWxlOmRlY29yYXRvci12YWxpZGF0aW9uLk1vZGVsXG4gKi9cbmV4cG9ydCBlbnVtIFByaW1pdGl2ZXMge1xuICBTVFJJTkcgPSBcInN0cmluZ1wiLFxuICBOVU1CRVIgPSBcIm51bWJlclwiLFxuICBCT09MRUFOID0gXCJib29sZWFuXCIsXG4gIEJJR0lOVCA9IFwiYmlnaW50XCIsXG59XG5cbi8qKlxuICogQHN1bW1hcnkgUmVmZXJlbmNlcyB0aGUgUmVzZXJ2ZWQgbW9kZWwgbmFtZXMgdG8gaWdub3JlIGR1cmluZyBNb2RlbCByZWJ1aWxkaW5nXG4gKlxuICogQHByb3BlcnR5IHtzdHJpbmd9IFNUUklOR1xuICogQHByb3BlcnR5IHtzdHJpbmd9IE9CSkVDVFxuICogQHByb3BlcnR5IHtzdHJpbmd9IE5VTUJFUlxuICogQHByb3BlcnR5IHtzdHJpbmd9IEJPT0xFQU5cbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBCSUdJTlRcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBEQVRFXG4gKlxuICogQGNvbnN0YW50IFJlc2VydmVkTW9kZWxzXG4gKiBAbWVtYmVyT2YgbW9kdWxlOmRlY29yYXRvci12YWxpZGF0aW9uLk1vZGVsXG4gKi9cbmV4cG9ydCBlbnVtIFJlc2VydmVkTW9kZWxzIHtcbiAgU1RSSU5HID0gXCJzdHJpbmdcIixcbiAgT0JKRUNUID0gXCJvYmplY3RcIixcbiAgTlVNQkVSID0gXCJudW1iZXJcIixcbiAgQk9PTEVBTiA9IFwiYm9vbGVhblwiLFxuICBCSUdJTlQgPSBcImJpZ2ludFwiLFxuICBEQVRFID0gXCJkYXRlXCIsXG59XG5cbi8qKlxuICogQHN1bW1hcnkgUmVmZXJlbmNlcyB0aGUgYmFzaWMgc3VwcG9ydGVkIGpzIHR5cGVzXG4gKlxuICogQHByb3BlcnR5IHtzdHJpbmd9IHN0cmluZ1xuICogQHByb3BlcnR5IHtzdHJpbmd9IGFycmF5XG4gKiBAcHJvcGVydHkge3N0cmluZ30gbnVtYmVyXG4gKiBAcHJvcGVydHkge3N0cmluZ30gYm9vbGVhblxuICogQHByb3BlcnR5IHtzdHJpbmd9IHN5bWJvbFxuICogQHByb3BlcnR5IHtzdHJpbmd9IGZ1bmN0aW9uXG4gKiBAcHJvcGVydHkge3N0cmluZ30gb2JqZWN0XG4gKiBAcHJvcGVydHkge3N0cmluZ30gdW5kZWZpbmVkXG4gKiBAcHJvcGVydHkge3N0cmluZ30gbnVsbFxuICogQHByb3BlcnR5IHtzdHJpbmd9IEJJR0lOVFxuICpcbiAqIEBjb25zdGFudCBqc1R5cGVzXG4gKiBAbWVtYmVyT2YgbW9kdWxlOmRlY29yYXRvci12YWxpZGF0aW9uLk1vZGVsXG4gKi9cbmV4cG9ydCBjb25zdCBqc1R5cGVzID0gW1xuICBcInN0cmluZ1wiLFxuICBcImFycmF5XCIsXG4gIFwibnVtYmVyXCIsXG4gIFwiYm9vbGVhblwiLFxuICBcInN5bWJvbFwiLFxuICBcImZ1bmN0aW9uXCIsXG4gIFwib2JqZWN0XCIsXG4gIFwidW5kZWZpbmVkXCIsXG4gIFwibnVsbFwiLFxuICBcImJpZ2ludFwiLFxuXTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/lib/model/constants.d.ts

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

package/lib/model/construction.cjs

@@ -66,5 +66,4 @@ function bindModelPrototype(obj) {
     }
     throw new Error("Could not find proper prototype to bind");
 }
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/model/construction.d.ts

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

package/lib/model/decorators.cjs

@@ -65,5 +65,4 @@ function serializedBy(serializer, ...args) {
         args: args,
     });
 }
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/model/decorators.d.ts

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

package/lib/model/index.cjs

@@ -21,5 +21,4 @@ __exportStar(require("./Model.cjs"), exports);
 __exportStar(require("./ModelErrorDefinition.cjs"), exports);
 __exportStar(require("./types.cjs"), exports);
 __exportStar(require("./validation.cjs"), exports);
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9tb2RlbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsOENBQTRCO0FBQzVCLGlEQUErQjtBQUMvQiwrQ0FBNkI7QUFDN0IsMENBQXdCO0FBQ3hCLHlEQUF1QztBQUN2QywwQ0FBd0I7QUFDeEIsK0NBQTZCIiwiZmlsZSI6Im1vZGVsL2luZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb25zdHJ1Y3Rpb25cIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RlY29yYXRvcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL01vZGVsXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9Nb2RlbEVycm9yRGVmaW5pdGlvblwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdHlwZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3ZhbGlkYXRpb25cIjtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbW9kZWwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDhDQUE0QjtBQUM1QixpREFBK0I7QUFDL0IsK0NBQTZCO0FBQzdCLDBDQUF3QjtBQUN4Qix5REFBdUM7QUFDdkMsMENBQXdCO0FBQ3hCLCtDQUE2QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2NvbnN0YW50c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29uc3RydWN0aW9uXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZWNvcmF0b3JzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9Nb2RlbFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vTW9kZWxFcnJvckRlZmluaXRpb25cIjtcbmV4cG9ydCAqIGZyb20gXCIuL3R5cGVzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi92YWxpZGF0aW9uXCI7XG4iXX0=

package/lib/model/index.d.ts

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

package/lib/model/types.cjs

@@ -1,4 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/model/types.d.ts

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

package/lib/model/validation.cjs

@@ -136,5 +136,4 @@ function validate(obj, ...propsToIgnore) {
     }
     return result ? new ModelErrorDefinition_1.ModelErrorDefinition(result) : undefined;
 }
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/model/validation.ts"],"names":[],"mappings":";;AA0BA,4BAsKC;AAhMD,iEAA8D;AAC9D,qDAAqE;AACrE,kDAA+C;AAC/C,8CAAsC;AACtC,2CAA6C;AAE7C,mCAAyC;AACzC,yDAAsD;AACtD,kEAAoE;AAOpE;;;;;;;;;;GAUG;AACH,SAAgB,QAAQ,CACtB,GAAM,EACN,GAAG,aAAuB;IAE1B,MAAM,mBAAmB,GAA4C,EAAE,CAAC;IACxE,KAAK,MAAM,IAAI,IAAI,GAAG;QACpB,IACE,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC;YAC/C,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAElC,mBAAmB,CAAC,IAAI,CACtB,uBAAU,CAAC,qBAAqB,CAC9B,0BAAc,CAAC,OAAO,EACtB,GAAG,EACH,IAAI,CACoC,CAC3C,CAAC;IAEN,IAAI,MAAM,GAA4B,SAAS,CAAC;IAEhD,KAAK,MAAM,iBAAiB,IAAI,mBAAmB,EAAE,CAAC;QACpD,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,iBAAiB,CAAC;QAE/C,IAAI,CAAC,UAAU,IAAI,CAAC,UAAU,CAAC,MAAM;YAAE,SAAS;QAEhD,MAAM,oBAAoB,GAAsB,UAAU,CAAC,CAAC,CAAC,CAAC;QAE9D,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,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,CAC1B,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,oBAAoB,CAAC,KAAK,CAAC,IAAI,CAC7C,CAAC;QACJ,CAAC,CAAC,EACF,CAAC;YACD,UAAU,CAAC,KAAK,EAAE,CAAC,CAAC,2EAA2E;QACjG,CAAC;QAED,IAAI,IAAI,GAAmD,SAAS,CAAC;QAErE,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,MAAM,SAAS,GAAG,uBAAU,CAAC,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;YAChD,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,MAAM,IAAI,KAAK,CAAC,yBAAyB,SAAS,CAAC,GAAG,EAAE,CAAC,CAAC;YAC5D,CAAC;YAED,MAAM,cAAc,GAClB,SAAS,CAAC,GAAG,KAAK,qBAAS,CAAC,IAAI;gBAC9B,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC;gBACnB,CAAC,CAAC,SAAS,CAAC,KAAK,IAAI,EAAE,CAAC;YAE5B,MAAM,GAAG,GAAuB,SAAS,CAAC,SAAS,CAChD,GAAW,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,EAC7B,cAAkC,CACnC,CAAC;YAEF,IAAI,GAAG,EAAE,CAAC;gBACR,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;gBAClB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;YAC5B,CAAC;QACH,CAAC;QAED,IAAI,IAAI,EAAE,CAAC;YACT,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;YACtB,MAAM,CAAC,iBAAiB,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,GAAG,IAAI,CAAC;QACnD,CAAC;IACH,CAAC;IAED,uBAAuB;IACvB,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACzE,IAAI,GAAuB,CAAC;QAC5B,oBAAoB;QACpB,MAAM,aAAa,GAAG,uBAAU,CAAC,qBAAqB,CACpD,0BAAc,CAAC,OAAO,EACtB,GAAG,EACH,IAAI,CACL,CAAC,UAAU,CAAC;QACb,MAAM,UAAU,GAAG,uBAAU,CAAC,qBAAqB,CACjD,0BAAc,CAAC,OAAO,EACtB,GAAG,EACH,IAAI,CACL,CAAC,UAAU,CAAC,MAAM,CACjB,CAAC,CAAkB,EAAE,EAAE,CACrB,CAAC,qBAAS,CAAC,IAAI,EAAE,0BAAc,CAAC,IAAc,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CACxE,CAAC;QACF,IAAI,CAAC,UAAU,IAAI,CAAC,UAAU,CAAC,MAAM;YAAE,SAAS;QAChD,MAAM,GAAG,GAAG,UAAU,CAAC,GAAG,EAAuB,CAAC;QAClD,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI;YAC1B,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC;YAClB,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC;gBACpC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW;gBACvB,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QAC9B,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,0BAAc,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CACvD,CAAC,CAAC,WAAW,EAAE,CACJ,CAAC;QAEd,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;YACtB,IAAI,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;gBAC7C,MAAM,gBAAgB,GAAG,KAAK,CAAC,OAAO,CAAE,GAAW,CAAC,IAAI,CAAC,CAAC;oBACxD,CAAC,CAAC,0BAAc,CAAC,IAAI;oBACrB,CAAC,CAAC,0BAAc,CAAC,IAAI,CAAC;gBACxB,MAAM,KAAK,GACT,aAAa,CAAC,IAAI,CAChB,CAAC,CAAkB,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,gBAAgB,CACnD,IAAI,EAAE,CAAC;gBACV,IAAI,YAAY,GAAa,EAAE,CAAC;gBAChC,IAAI,KAAK,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;oBACzB,MAAM,WAAW,GAAG,KAAK,CAAC,OAAO,CAAE,GAAW,CAAC,IAAI,CAAC,CAAC;wBACnD,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK;wBACnB,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC;oBAC5B,IAAI,WAAW;wBACb,YAAY,GAAG,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC;4BACvC,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC;4BAC9C,CAAC,CAAC,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC,CAAC;gBACpC,CAAC;gBAED,MAAM,QAAQ,GAAG,CAAC,IAAY,EAAE,KAAU,EAAO,EAAE;oBACjD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,UAAU;wBAC1D,OAAO,IAAA,eAAO,EAAC,KAAK,CAAC;4BACnB,CAAC,CAAE,KAAe,CAAC,SAAS,EAAE;4BAC9B,CAAC,CAAC,YAAY,CAAC,QAAQ,CAAC,OAAO,KAAK,CAAC;gCACnC,CAAC,CAAC,SAAS;gCACX,CAAC,CAAC,+BAA+B,CAAC;gBAC1C,CAAC,CAAC;gBAEF,QAAQ,CAAC,EAAE,CAAC;oBACV,KAAK,KAAK,CAAC,IAAI,CAAC;oBAChB,KAAK,GAAG,CAAC,IAAI;wBACX,IAAI,aAAa,CAAC,MAAM,EAAE,CAAC;4BACzB,MAAM,OAAO,GAAG,aAAa,CAAC,IAAI,CAChC,CAAC,CAAkB,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,0BAAc,CAAC,IAAI,CACtD,CAAC;4BACF,IAAI,OAAO,EAAE,CAAC;gCACZ,GAAG,GAAG,CACJ,CAAC,KAAK,KAAK,CAAC,IAAI;oCACd,CAAC,CAAE,GAA2B,CAAC,IAAI,CAAC;oCACpC,CAAC,CAAC,gBAAgB;wCACf,GAA2B,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAChD;qCACE,GAAG,CAAC,CAAC,CAAc,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;qCAC1C,MAAM,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAQ,CAAC;gCAClC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,CAAC;oCACjB,oCAAoC;oCACpC,GAAG,GAAG,SAAS,CAAC;gCAClB,CAAC;4BACH,CAAC;wBACH,CAAC;wBACD,MAAM;oBACR;wBACE,IAAI,CAAC;4BACH,IAAK,GAA2B,CAAC,IAAI,CAAC;gCACpC,GAAG,GAAG,QAAQ,CAAC,IAAI,EAAG,GAAW,CAAC,IAAI,CAAC,CAAC,CAAC;wBAC7C,CAAC;wBAAC,OAAO,CAAM,EAAE,CAAC;4BAChB,OAAO,CAAC,IAAI,CAAC,IAAA,YAAE,EAAC,2CAA2C,GAAG,CAAC,CAAC,CAAC,CAAC;wBACpE,CAAC;gBACL,CAAC;YACH,CAAC;YACD,IAAI,GAAG,EAAE,CAAC;gBACR,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;gBACtB,MAAM,CAAC,IAAI,CAAC,GAAG,GAAU,CAAC;YAC5B,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC,CAAC,CAAC,IAAI,2CAAoB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AAC/D,CAAC","file":"model/validation.js","sourcesContent":["import { ModelErrorDefinition } from \"./ModelErrorDefinition\";\nimport { DecoratorMetadata, Reflection } from \"@decaf-ts/reflection\";\nimport { ModelKeys } from \"../utils/constants\";\nimport { sf } from \"../utils/strings\";\nimport { ReservedModels } from \"./constants\";\nimport { Validatable } from \"./types\";\nimport { isModel, Model } from \"./Model\";\nimport { Validation } from \"../validation/Validation\";\nimport { ValidationKeys } from \"../validation/Validators/constants\";\nimport {\n  ModelErrors,\n  ValidationPropertyDecoratorDefinition,\n} from \"../validation/types\";\nimport { ValidatorOptions } from \"../validation/types\";\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 (\n      Object.prototype.hasOwnProperty.call(obj, prop) &&\n      propsToIgnore.indexOf(prop) === -1\n    )\n      decoratedProperties.push(\n        Reflection.getPropertyDecorators(\n          ValidationKeys.REFLECT,\n          obj,\n          prop\n        ) as ValidationPropertyDecoratorDefinition\n      );\n\n  let result: ModelErrors | undefined = undefined;\n\n  for (const decoratedProperty of decoratedProperties) {\n    const { prop, decorators } = decoratedProperty;\n\n    if (!decorators || !decorators.length) continue;\n\n    const defaultTypeDecorator: DecoratorMetadata = 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        return !!d.props.types?.find(\n          (t) => t === defaultTypeDecorator.props.name\n        );\n      })\n    ) {\n      decorators.shift(); // remove the design:type decorator, since the type will already be checked\n    }\n\n    let errs: Record<string, string | undefined> | undefined = undefined;\n\n    for (const decorator of decorators) {\n      const validator = Validation.get(decorator.key);\n      if (!validator) {\n        throw new Error(`Missing validator for ${decorator.key}`);\n      }\n\n      const decoratorProps =\n        decorator.key === ModelKeys.TYPE\n          ? [decorator.props]\n          : decorator.props || {};\n\n      const err: string | undefined = validator.hasErrors(\n        (obj as any)[prop.toString()],\n        decoratorProps as ValidatorOptions\n      );\n\n      if (err) {\n        errs = errs || {};\n        errs[decorator.key] = err;\n      }\n    }\n\n    if (errs) {\n      result = result || {};\n      result[decoratedProperty.prop.toString()] = errs;\n    }\n  }\n\n  // tests nested classes\n  for (const prop of Object.keys(obj).filter((k) => !result || !result[k])) {\n    let err: string | undefined;\n    // if a nested Model\n    const allDecorators = Reflection.getPropertyDecorators(\n      ValidationKeys.REFLECT,\n      obj,\n      prop\n    ).decorators;\n    const decorators = Reflection.getPropertyDecorators(\n      ValidationKeys.REFLECT,\n      obj,\n      prop\n    ).decorators.filter(\n      (d: { key: string }) =>\n        [ModelKeys.TYPE, ValidationKeys.TYPE as string].indexOf(d.key) !== -1\n    );\n    if (!decorators || !decorators.length) continue;\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    for (const c of clazz) {\n      if (reserved.indexOf(c.toLowerCase()) === -1) {\n        const typeDecoratorKey = Array.isArray((obj as any)[prop])\n          ? ValidationKeys.LIST\n          : ValidationKeys.TYPE;\n        const types: any =\n          allDecorators.find(\n            (d: { key: string }) => d.key === typeDecoratorKey\n          ) || {};\n        let allowedTypes: string[] = [];\n        if (types && types.props) {\n          const customTypes = Array.isArray((obj as any)[prop])\n            ? types.props.class\n            : types.props.customTypes;\n          if (customTypes)\n            allowedTypes = Array.isArray(customTypes)\n              ? customTypes.map((t) => `${t}`.toLowerCase())\n              : [customTypes.toLowerCase()];\n        }\n\n        const validate = (prop: string, value: any): any => {\n          if (typeof value === \"object\" || typeof value === \"function\")\n            return isModel(value)\n              ? (value as Model).hasErrors()\n              : allowedTypes.includes(typeof value)\n                ? undefined\n                : \"Value has no validatable type\";\n        };\n\n        switch (c) {\n          case Array.name:\n          case Set.name:\n            if (allDecorators.length) {\n              const listDec = allDecorators.find(\n                (d: { key: string }) => d.key === ValidationKeys.LIST\n              );\n              if (listDec) {\n                err = (\n                  c === Array.name\n                    ? (obj as Record<string, any>)[prop]\n                    : // If it's a Set\n                      (obj as Record<string, any>)[prop].values()\n                )\n                  .map((v: Validatable) => validate(prop, v))\n                  .filter((e: any) => !!e) as any;\n                if (!err?.length) {\n                  // if the result is an empty list...\n                  err = undefined;\n                }\n              }\n            }\n            break;\n          default:\n            try {\n              if ((obj as Record<string, any>)[prop])\n                err = validate(prop, (obj as any)[prop]);\n            } catch (e: any) {\n              console.warn(sf(\"Model should be validatable but its not: \" + e));\n            }\n        }\n      }\n      if (err) {\n        result = result || {};\n        result[prop] = err as any;\n      }\n    }\n  }\n\n  return result ? new ModelErrorDefinition(result) : undefined;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validation.js","sourceRoot":"","sources":["../../src/model/validation.ts"],"names":[],"mappings":";;AA0BA,4BAsKC;AAhMD,iEAA8D;AAC9D,qDAAqE;AACrE,kDAA+C;AAC/C,8CAAsC;AACtC,2CAA6C;AAE7C,mCAAyC;AACzC,yDAAsD;AACtD,kEAAoE;AAOpE;;;;;;;;;;GAUG;AACH,SAAgB,QAAQ,CACtB,GAAM,EACN,GAAG,aAAuB;IAE1B,MAAM,mBAAmB,GAA4C,EAAE,CAAC;IACxE,KAAK,MAAM,IAAI,IAAI,GAAG;QACpB,IACE,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC;YAC/C,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAElC,mBAAmB,CAAC,IAAI,CACtB,uBAAU,CAAC,qBAAqB,CAC9B,0BAAc,CAAC,OAAO,EACtB,GAAG,EACH,IAAI,CACoC,CAC3C,CAAC;IAEN,IAAI,MAAM,GAA4B,SAAS,CAAC;IAEhD,KAAK,MAAM,iBAAiB,IAAI,mBAAmB,EAAE,CAAC;QACpD,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,iBAAiB,CAAC;QAE/C,IAAI,CAAC,UAAU,IAAI,CAAC,UAAU,CAAC,MAAM;YAAE,SAAS;QAEhD,MAAM,oBAAoB,GAAsB,UAAU,CAAC,CAAC,CAAC,CAAC;QAE9D,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,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,CAC1B,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,oBAAoB,CAAC,KAAK,CAAC,IAAI,CAC7C,CAAC;QACJ,CAAC,CAAC,EACF,CAAC;YACD,UAAU,CAAC,KAAK,EAAE,CAAC,CAAC,2EAA2E;QACjG,CAAC;QAED,IAAI,IAAI,GAAmD,SAAS,CAAC;QAErE,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,MAAM,SAAS,GAAG,uBAAU,CAAC,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;YAChD,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,MAAM,IAAI,KAAK,CAAC,yBAAyB,SAAS,CAAC,GAAG,EAAE,CAAC,CAAC;YAC5D,CAAC;YAED,MAAM,cAAc,GAClB,SAAS,CAAC,GAAG,KAAK,qBAAS,CAAC,IAAI;gBAC9B,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC;gBACnB,CAAC,CAAC,SAAS,CAAC,KAAK,IAAI,EAAE,CAAC;YAE5B,MAAM,GAAG,GAAuB,SAAS,CAAC,SAAS,CAChD,GAAW,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,EAC7B,cAAkC,CACnC,CAAC;YAEF,IAAI,GAAG,EAAE,CAAC;gBACR,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;gBAClB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;YAC5B,CAAC;QACH,CAAC;QAED,IAAI,IAAI,EAAE,CAAC;YACT,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;YACtB,MAAM,CAAC,iBAAiB,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,GAAG,IAAI,CAAC;QACnD,CAAC;IACH,CAAC;IAED,uBAAuB;IACvB,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACzE,IAAI,GAAuB,CAAC;QAC5B,oBAAoB;QACpB,MAAM,aAAa,GAAG,uBAAU,CAAC,qBAAqB,CACpD,0BAAc,CAAC,OAAO,EACtB,GAAG,EACH,IAAI,CACL,CAAC,UAAU,CAAC;QACb,MAAM,UAAU,GAAG,uBAAU,CAAC,qBAAqB,CACjD,0BAAc,CAAC,OAAO,EACtB,GAAG,EACH,IAAI,CACL,CAAC,UAAU,CAAC,MAAM,CACjB,CAAC,CAAkB,EAAE,EAAE,CACrB,CAAC,qBAAS,CAAC,IAAI,EAAE,0BAAc,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAC9D,CAAC;QACF,IAAI,CAAC,UAAU,IAAI,CAAC,UAAU,CAAC,MAAM;YAAE,SAAS;QAChD,MAAM,GAAG,GAAG,UAAU,CAAC,GAAG,EAAuB,CAAC;QAClD,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI;YAC1B,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC;YAClB,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC;gBACpC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW;gBACvB,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QAC9B,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,0BAAc,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CACvD,CAAC,CAAC,WAAW,EAAE,CACJ,CAAC;QAEd,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;YACtB,IAAI,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;gBAC7C,MAAM,gBAAgB,GAAG,KAAK,CAAC,OAAO,CAAE,GAAW,CAAC,IAAI,CAAC,CAAC;oBACxD,CAAC,CAAC,0BAAc,CAAC,IAAI;oBACrB,CAAC,CAAC,0BAAc,CAAC,IAAI,CAAC;gBACxB,MAAM,KAAK,GACT,aAAa,CAAC,IAAI,CAChB,CAAC,CAAkB,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,gBAAgB,CACnD,IAAI,EAAE,CAAC;gBACV,IAAI,YAAY,GAAa,EAAE,CAAC;gBAChC,IAAI,KAAK,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;oBACzB,MAAM,WAAW,GAAG,KAAK,CAAC,OAAO,CAAE,GAAW,CAAC,IAAI,CAAC,CAAC;wBACnD,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK;wBACnB,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC;oBAC5B,IAAI,WAAW;wBACb,YAAY,GAAG,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC;4BACvC,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC;4BAC9C,CAAC,CAAC,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC,CAAC;gBACpC,CAAC;gBAED,MAAM,QAAQ,GAAG,CAAC,IAAY,EAAE,KAAU,EAAO,EAAE;oBACjD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,UAAU;wBAC1D,OAAO,IAAA,eAAO,EAAC,KAAK,CAAC;4BACnB,CAAC,CAAE,KAAe,CAAC,SAAS,EAAE;4BAC9B,CAAC,CAAC,YAAY,CAAC,QAAQ,CAAC,OAAO,KAAK,CAAC;gCACnC,CAAC,CAAC,SAAS;gCACX,CAAC,CAAC,+BAA+B,CAAC;gBAC1C,CAAC,CAAC;gBAEF,QAAQ,CAAC,EAAE,CAAC;oBACV,KAAK,KAAK,CAAC,IAAI,CAAC;oBAChB,KAAK,GAAG,CAAC,IAAI;wBACX,IAAI,aAAa,CAAC,MAAM,EAAE,CAAC;4BACzB,MAAM,OAAO,GAAG,aAAa,CAAC,IAAI,CAChC,CAAC,CAAkB,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,0BAAc,CAAC,IAAI,CACtD,CAAC;4BACF,IAAI,OAAO,EAAE,CAAC;gCACZ,GAAG,GAAG,CACJ,CAAC,KAAK,KAAK,CAAC,IAAI;oCACd,CAAC,CAAE,GAA2B,CAAC,IAAI,CAAC;oCACpC,CAAC,CAAC,gBAAgB;wCACf,GAA2B,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAChD;qCACE,GAAG,CAAC,CAAC,CAAc,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;qCAC1C,MAAM,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAQ,CAAC;gCAClC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,CAAC;oCACjB,oCAAoC;oCACpC,GAAG,GAAG,SAAS,CAAC;gCAClB,CAAC;4BACH,CAAC;wBACH,CAAC;wBACD,MAAM;oBACR;wBACE,IAAI,CAAC;4BACH,IAAK,GAA2B,CAAC,IAAI,CAAC;gCACpC,GAAG,GAAG,QAAQ,CAAC,IAAI,EAAG,GAAW,CAAC,IAAI,CAAC,CAAC,CAAC;wBAC7C,CAAC;wBAAC,OAAO,CAAM,EAAE,CAAC;4BAChB,OAAO,CAAC,IAAI,CAAC,IAAA,YAAE,EAAC,2CAA2C,GAAG,CAAC,CAAC,CAAC,CAAC;wBACpE,CAAC;gBACL,CAAC;YACH,CAAC;YACD,IAAI,GAAG,EAAE,CAAC;gBACR,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;gBACtB,MAAM,CAAC,IAAI,CAAC,GAAG,GAAU,CAAC;YAC5B,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC,CAAC,CAAC,IAAI,2CAAoB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AAC/D,CAAC","sourcesContent":["import { ModelErrorDefinition } from \"./ModelErrorDefinition\";\nimport { DecoratorMetadata, Reflection } from \"@decaf-ts/reflection\";\nimport { ModelKeys } from \"../utils/constants\";\nimport { sf } from \"../utils/strings\";\nimport { ReservedModels } from \"./constants\";\nimport { Validatable } from \"./types\";\nimport { isModel, Model } from \"./Model\";\nimport { Validation } from \"../validation/Validation\";\nimport { ValidationKeys } from \"../validation/Validators/constants\";\nimport {\n  ModelErrors,\n  ValidationPropertyDecoratorDefinition,\n} from \"../validation/types\";\nimport { ValidatorOptions } from \"../validation/types\";\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 (\n      Object.prototype.hasOwnProperty.call(obj, prop) &&\n      propsToIgnore.indexOf(prop) === -1\n    )\n      decoratedProperties.push(\n        Reflection.getPropertyDecorators(\n          ValidationKeys.REFLECT,\n          obj,\n          prop\n        ) as ValidationPropertyDecoratorDefinition\n      );\n\n  let result: ModelErrors | undefined = undefined;\n\n  for (const decoratedProperty of decoratedProperties) {\n    const { prop, decorators } = decoratedProperty;\n\n    if (!decorators || !decorators.length) continue;\n\n    const defaultTypeDecorator: DecoratorMetadata = 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        return !!d.props.types?.find(\n          (t) => t === defaultTypeDecorator.props.name\n        );\n      })\n    ) {\n      decorators.shift(); // remove the design:type decorator, since the type will already be checked\n    }\n\n    let errs: Record<string, string | undefined> | undefined = undefined;\n\n    for (const decorator of decorators) {\n      const validator = Validation.get(decorator.key);\n      if (!validator) {\n        throw new Error(`Missing validator for ${decorator.key}`);\n      }\n\n      const decoratorProps =\n        decorator.key === ModelKeys.TYPE\n          ? [decorator.props]\n          : decorator.props || {};\n\n      const err: string | undefined = validator.hasErrors(\n        (obj as any)[prop.toString()],\n        decoratorProps as ValidatorOptions\n      );\n\n      if (err) {\n        errs = errs || {};\n        errs[decorator.key] = err;\n      }\n    }\n\n    if (errs) {\n      result = result || {};\n      result[decoratedProperty.prop.toString()] = errs;\n    }\n  }\n\n  // tests nested classes\n  for (const prop of Object.keys(obj).filter((k) => !result || !result[k])) {\n    let err: string | undefined;\n    // if a nested Model\n    const allDecorators = Reflection.getPropertyDecorators(\n      ValidationKeys.REFLECT,\n      obj,\n      prop\n    ).decorators;\n    const decorators = Reflection.getPropertyDecorators(\n      ValidationKeys.REFLECT,\n      obj,\n      prop\n    ).decorators.filter(\n      (d: { key: string }) =>\n        [ModelKeys.TYPE, ValidationKeys.TYPE].indexOf(d.key) !== -1\n    );\n    if (!decorators || !decorators.length) continue;\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    for (const c of clazz) {\n      if (reserved.indexOf(c.toLowerCase()) === -1) {\n        const typeDecoratorKey = Array.isArray((obj as any)[prop])\n          ? ValidationKeys.LIST\n          : ValidationKeys.TYPE;\n        const types: any =\n          allDecorators.find(\n            (d: { key: string }) => d.key === typeDecoratorKey\n          ) || {};\n        let allowedTypes: string[] = [];\n        if (types && types.props) {\n          const customTypes = Array.isArray((obj as any)[prop])\n            ? types.props.class\n            : types.props.customTypes;\n          if (customTypes)\n            allowedTypes = Array.isArray(customTypes)\n              ? customTypes.map((t) => `${t}`.toLowerCase())\n              : [customTypes.toLowerCase()];\n        }\n\n        const validate = (prop: string, value: any): any => {\n          if (typeof value === \"object\" || typeof value === \"function\")\n            return isModel(value)\n              ? (value as Model).hasErrors()\n              : allowedTypes.includes(typeof value)\n                ? undefined\n                : \"Value has no validatable type\";\n        };\n\n        switch (c) {\n          case Array.name:\n          case Set.name:\n            if (allDecorators.length) {\n              const listDec = allDecorators.find(\n                (d: { key: string }) => d.key === ValidationKeys.LIST\n              );\n              if (listDec) {\n                err = (\n                  c === Array.name\n                    ? (obj as Record<string, any>)[prop]\n                    : // If it's a Set\n                      (obj as Record<string, any>)[prop].values()\n                )\n                  .map((v: Validatable) => validate(prop, v))\n                  .filter((e: any) => !!e) as any;\n                if (!err?.length) {\n                  // if the result is an empty list...\n                  err = undefined;\n                }\n              }\n            }\n            break;\n          default:\n            try {\n              if ((obj as Record<string, any>)[prop])\n                err = validate(prop, (obj as any)[prop]);\n            } catch (e: any) {\n              console.warn(sf(\"Model should be validatable but its not: \" + e));\n            }\n        }\n      }\n      if (err) {\n        result = result || {};\n        result[prop] = err as any;\n      }\n    }\n  }\n\n  return result ? new ModelErrorDefinition(result) : undefined;\n}\n"]}