@decaf-ts/decorator-validation 1.4.21 → 1.5.2

package/lib/esm/model/Model.d.ts

@@ -1,139 +0,0 @@
-import { BuilderRegistry } from "../utils/registry";
-import { ModelErrorDefinition } from "./ModelErrorDefinition";
-import { Comparable, Constructor, Hashable, ModelArg, ModelBuilderFunction, ModelConstructor, Serializable, Validatable } from "./types";
-/**
- * @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
-     *
-     * @param args
-     * @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, ...exceptions: any[]): 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/esm/model/Model.js

@@ -1,297 +0,0 @@
-import { Serialization } from "../utils/serialization";
-import { ModelRegistryManager } from "./Registry";
-import { isEqual, Reflection } from "@decaf-ts/reflection";
-import { validate } from "./validation";
-import { Hashing } from "../utils/hashing";
-import { isPropertyModel } from "./utils";
-import { ModelKeys } from "../utils/constants";
-import { ValidationKeys } from "../validation/Validators/constants";
-import { sf } from "../utils/strings";
-import { jsTypes, ReservedModels } from "./constants";
-let modelBuilderFunction;
-let actingModelRegistry;
-/**
- * @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 class Model {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    constructor(arg) { }
-    /**
-     * @summary Validates the object according to its decorated properties
-     *
-     * @param {any[]} [exceptions] properties in the object to be ignored for the validation. Marked as 'any' to allow for extension but expects strings
-     */
-    hasErrors(...exceptions) {
-        return 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 isEqual(this, obj, ...exceptions);
-    }
-    /**
-     * @summary Returns the serialized model according to the currently defined {@link Serializer}
-     */
-    serialize() {
-        return Model.serialize(this);
-    }
-    /**
-     * @summary Override the implementation for js's 'toString()' which sucks...
-     * @override
-     */
-    toString() {
-        return this.constructor.name + ": " + JSON.stringify(this, undefined, 2);
-    }
-    /**
-     * @summary Defines a default implementation for object hash. Relies on a very basic implementation based on Java's string hash;
-     */
-    hash() {
-        return Model.hash(this);
-    }
-    /**
-     * @summary Deserializes a Model
-     * @param {string} str
-     *
-     * @param args
-     * @throws {Error} If it fails to parse the string, or if it fails to build the model
-     */
-    static deserialize(str) {
-        const metadata = Reflect.getMetadata(Model.key(ModelKeys.SERIALIZATION), this.constructor);
-        if (metadata && metadata.serializer)
-            return Serialization.deserialize(str, metadata.serializer, ...(metadata.args || []));
-        return Serialization.deserialize(str);
-    }
-    /**
-     * @summary Repopulates the Object properties with the ones from the new object
-     * @description Iterates all common properties of obj (if existing) and self, and copies them onto self
-     *
-     * @param {T} self
-     * @param {T | Record<string, any>} [obj]
-     *
-     */
-    static fromObject(self, obj) {
-        if (!obj)
-            obj = {};
-        for (const prop of Model.getAttributes(self)) {
-            self[prop] = obj[prop] || undefined;
-        }
-        return self;
-    }
-    /**
-     * @summary Repopulates the instance with the ones from the new Model Object
-     * @description Iterates all common properties of obj (if existing) and self, and copies them onto self.
-     * Is aware of nested Model Objects and rebuilds them also.
-     * When List properties are decorated with {@link list}, they list items will also be rebuilt
-     *
-     * @param {T} self
-     * @param {T | Record<string, any>} [obj]
-     *
-     */
-    static fromModel(self, obj) {
-        if (!obj)
-            obj = {};
-        let decorators, dec;
-        const props = Model.getAttributes(self);
-        for (const prop of props) {
-            self[prop] =
-                obj[prop] || undefined;
-            if (typeof self[prop] !== "object")
-                continue;
-            const propM = isPropertyModel(self, prop);
-            if (propM) {
-                try {
-                    self[prop] = Model.build(self[prop], typeof propM === "string" ? propM : undefined);
-                }
-                catch (e) {
-                    console.log(e);
-                }
-                continue;
-            }
-            const allDecorators = Reflection.getPropertyDecorators(ValidationKeys.REFLECT, self, prop).decorators;
-            decorators = allDecorators.filter((d) => [ModelKeys.TYPE, ValidationKeys.TYPE].indexOf(d.key) !== -1);
-            if (!decorators || !decorators.length)
-                throw new Error(sf("failed to find decorators for property {0}", prop));
-            dec = decorators.pop();
-            const clazz = dec.props.name
-                ? [dec.props.name]
-                : Array.isArray(dec.props.customTypes)
-                    ? dec.props.customTypes
-                    : [dec.props.customTypes];
-            const reserved = Object.values(ReservedModels).map((v) => v.toLowerCase());
-            clazz.forEach((c) => {
-                if (reserved.indexOf(c.toLowerCase()) === -1)
-                    try {
-                        switch (c) {
-                            case "Array":
-                            case "Set":
-                                if (allDecorators.length) {
-                                    const listDec = allDecorators.find((d) => d.key === ValidationKeys.LIST);
-                                    if (listDec) {
-                                        const clazzName = listDec.props.class.find((t) => !jsTypes.includes(t.toLowerCase()));
-                                        if (c === "Array")
-                                            self[prop] = self[prop].map((el) => {
-                                                return ["object", "function"].includes(typeof el) &&
-                                                    clazzName
-                                                    ? Model.build(el, clazzName)
-                                                    : el;
-                                            });
-                                        if (c === "Set") {
-                                            const s = new Set();
-                                            for (const v of self[prop]) {
-                                                if (["object", "function"].includes(typeof v) &&
-                                                    clazzName) {
-                                                    s.add(Model.build(v, clazzName));
-                                                }
-                                                else {
-                                                    s.add(v);
-                                                }
-                                            }
-                                            self[prop] = s;
-                                        }
-                                    }
-                                }
-                                break;
-                            default:
-                                if (self[prop])
-                                    self[prop] = Model.build(self[prop], c);
-                        }
-                    }
-                    catch (e) {
-                        console.log(e);
-                        // do nothing. we have no registry of this class
-                    }
-            });
-        }
-        return self;
-    }
-    /**
-     * @summary Sets the Global {@link ModelBuilderFunction}
-     * @param {ModelBuilderFunction} [builder]
-     */
-    static setBuilder(builder) {
-        modelBuilderFunction = builder;
-    }
-    /**
-     * @summary Retrieves the current global {@link ModelBuilderFunction}
-     */
-    static getBuilder() {
-        return modelBuilderFunction;
-    }
-    /**
-     * Returns the current {@link ModelRegistryManager}
-     *
-     * @return ModelRegistry, defaults to {@link ModelRegistryManager}
-     */
-    static getRegistry() {
-        if (!actingModelRegistry)
-            actingModelRegistry = new ModelRegistryManager();
-        return actingModelRegistry;
-    }
-    /**
-     * Returns the current actingModelRegistry
-     *
-     * @param {BuilderRegistry} modelRegistry the new implementation of Registry
-     */
-    static setRegistry(modelRegistry) {
-        actingModelRegistry = modelRegistry;
-    }
-    /**
-     * @summary register new Models
-     * @param {any} constructor
-     * @param {string} [name] when not defined, the name of the constructor will be used
-     *
-     * @see ModelRegistry
-     */
-    static register(constructor, name) {
-        return Model.getRegistry().register(constructor, name);
-    }
-    /**
-     * @summary Gets a registered Model {@link ModelConstructor}
-     * @param {string} name
-     *
-     * @see ModelRegistry
-     */
-    static get(name) {
-        return Model.getRegistry().get(name);
-    }
-    /**
-     * @param {Record<string, any>} obj
-     * @param {string} [clazz] when provided, it will attempt to find the matching constructor
-     *
-     * @throws Error If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property
-     *
-     * @see ModelRegistry
-     */
-    static build(obj = {}, clazz) {
-        return Model.getRegistry().build(obj, clazz);
-    }
-    static getMetadata(model) {
-        const metadata = Reflect.getMetadata(Model.key(ModelKeys.MODEL), model.constructor);
-        if (!metadata)
-            throw new Error("could not find metadata for provided " + model.constructor.name);
-        return metadata;
-    }
-    static getAttributes(model) {
-        const result = [];
-        let prototype = model instanceof Model
-            ? Object.getPrototypeOf(model)
-            : model.prototype;
-        while (prototype != null) {
-            const props = prototype[ModelKeys.ATTRIBUTE];
-            if (props) {
-                result.push(...props);
-            }
-            prototype = Object.getPrototypeOf(prototype);
-        }
-        return result;
-    }
-    static equals(obj1, obj2, ...exceptions) {
-        return isEqual(obj1, obj2, ...exceptions);
-    }
-    static hasErrors(model, ...exceptions) {
-        return validate(model, ...exceptions);
-    }
-    static serialize(model) {
-        const metadata = Reflect.getMetadata(Model.key(ModelKeys.SERIALIZATION), model.constructor);
-        if (metadata && metadata.serializer)
-            return Serialization.serialize(this, metadata.serializer, ...(metadata.args || []));
-        return Serialization.serialize(model);
-    }
-    static hash(model) {
-        const metadata = Reflect.getMetadata(Model.key(ModelKeys.HASHING), model.constructor);
-        if (metadata && metadata.algorithm)
-            return Hashing.hash(model, metadata.algorithm, ...(metadata.args || []));
-        return Hashing.hash(model);
-    }
-    /**
-     * @summary Builds the key to store as Metadata under Reflections
-     * @description concatenates {@link ModelKeys#REFLECT} with the provided key
-     * @param {string} str
-     */
-    static key(str) {
-        return ModelKeys.REFLECT + str;
-    }
-}

package/lib/esm/model/ModelErrorDefinition.d.ts

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

package/lib/esm/model/ModelErrorDefinition.js

@@ -1,52 +0,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
- */
-export class ModelErrorDefinition {
-    constructor(errors) {
-        for (const prop in errors) {
-            if (Object.prototype.hasOwnProperty.call(errors, prop) && errors[prop])
-                Object.defineProperty(this, prop, {
-                    enumerable: true,
-                    configurable: false,
-                    value: errors[prop],
-                    writable: false,
-                });
-        }
-    }
-    /**
-     * @summary Outputs the class to a nice readable string
-     *
-     * @override
-     */
-    toString() {
-        const self = this;
-        return Object.keys(self)
-            .filter((k) => Object.prototype.hasOwnProperty.call(self, k) &&
-            typeof self[k] !== "function")
-            .reduce((accum, prop) => {
-            let propError = Object.keys(self[prop]).reduce((propAccum, key) => {
-                if (!propAccum)
-                    propAccum = self[prop][key];
-                else
-                    propAccum += `\n${self[prop][key]}`;
-                return propAccum;
-            }, undefined);
-            if (propError) {
-                propError = `${prop} - ${propError}`;
-                if (!accum)
-                    accum = propError;
-                else
-                    accum += `\n${propError}`;
-            }
-            return accum;
-        }, "");
-    }
-}

package/lib/esm/model/Registry.d.ts

@@ -1,59 +0,0 @@
-import { Model } from "./Model";
-import { BuilderRegistry } from "../utils/registry";
-import { Constructor, ModelConstructor } from "./types";
-/**
- * @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;

package/lib/esm/model/Registry.js

@@ -1,73 +0,0 @@
-import { Model } from "./Model";
-import { sf } from "../utils/strings";
-import { isModel } from "./utils";
-/**
- * @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 class ModelRegistryManager {
-    constructor(testFunction = isModel) {
-        this.cache = {};
-        this.testFunction = testFunction;
-    }
-    /**
-     * @summary register new Models
-     * @param {any} constructor
-     * @param {string} [name] when not defined, the name of the constructor will be used
-     */
-    register(constructor, name) {
-        if (typeof constructor !== "function")
-            throw new Error("Model registering failed. Missing Class name or constructor");
-        name = name || constructor.name;
-        this.cache[name] = constructor;
-    }
-    /**
-     * @summary Gets a registered Model {@link ModelConstructor}
-     * @param {string} name
-     */
-    get(name) {
-        try {
-            return this.cache[name];
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        }
-        catch (e) {
-            return undefined;
-        }
-    }
-    /**
-     * @param {Record<string, any>} obj
-     * @param {string} [clazz] when provided, it will attempt to find the matching constructor
-     *
-     * @throws Error If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property
-     */
-    build(obj = {}, clazz) {
-        if (!clazz && !this.testFunction(obj))
-            throw new Error("Provided obj is not a Model object");
-        const name = clazz || Model.getMetadata(obj);
-        if (!(name in this.cache))
-            throw new Error(sf("Provided class {0} is not a registered Model object", name));
-        return new this.cache[name](obj);
-    }
-}
-/**
- * @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 function bulkModelRegister(...models) {
-    models.forEach((m) => {
-        const constructor = (m.constructor ? m.constructor : m);
-        Model.register(constructor, m.name);
-    });
-}