@decaf-ts/decorator-validation 1.5.1 → 1.5.2

package/lib/esm/model/construction.js

@@ -1,63 +0,0 @@
-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 function construct(constructor, ...args) {
-    const _constr = (...argz) => new constructor(...argz);
-    _constr.prototype = constructor.prototype;
-    return _constr(...args);
-}
-/**
- * @summary Recursively finds the last prototype before Object
- * @param {object} obj
- *
- * @function findLastProtoBeforeObject
- * @memberOf module:decorator-validation.Construction
- */
-export function findLastProtoBeforeObject(obj) {
-    let prototype = Object.getPrototypeOf(obj);
-    if (prototype === Object.prototype)
-        return obj;
-    while (prototype !== Object.prototype) {
-        prototype = Object.getPrototypeOf(prototype);
-        if (prototype === Object.prototype)
-            return prototype;
-        if (Object.getPrototypeOf(prototype) === Object.prototype)
-            return prototype;
-    }
-    throw new Error("Could not find proper prototype");
-}
-/**
- * @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 function bindModelPrototype(obj) {
-    if (obj instanceof Model)
-        return;
-    function bindPrototype(objToOverride, prototype) {
-        Object.setPrototypeOf(objToOverride, prototype);
-    }
-    const prototype = Object.getPrototypeOf(obj);
-    if (prototype === Object.prototype) {
-        return bindPrototype(obj, Model.prototype);
-    }
-    while (prototype !== Object.prototype) {
-        const prot = Object.getPrototypeOf(prototype);
-        if (prot === Object.prototype ||
-            Object.getPrototypeOf(prot) === Object.prototype) {
-            return bindPrototype(prototype, Model.prototype);
-        }
-    }
-    throw new Error("Could not find proper prototype to bind");
-}

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

@@ -1,25 +0,0 @@
-/**
- * @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/esm/model/decorators.js

@@ -1,62 +0,0 @@
-import { bindModelPrototype, construct } from "./construction";
-import { ModelKeys } from "../utils/constants";
-import { Model } from "./Model";
-import { metadata } from "@decaf-ts/reflection";
-/**
- * @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 function model(instanceCallback) {
-    return ((original) => {
-        // the new constructor behaviour
-        const newConstructor = function (...args) {
-            const instance = construct(original, ...args);
-            bindModelPrototype(instance);
-            // run a builder function if defined with the first argument (The ModelArg)
-            const builder = Model.getBuilder();
-            if (builder)
-                builder(instance, args.length ? args[0] : undefined);
-            metadata(Model.key(ModelKeys.MODEL), original.name)(instance.constructor);
-            if (instanceCallback)
-                instanceCallback(instance, ...args);
-            return instance;
-        };
-        // copy prototype so instanceof operator still works
-        newConstructor.prototype = original.prototype;
-        // Sets the proper constructor name for type verification
-        Object.defineProperty(newConstructor, "name", {
-            writable: false,
-            enumerable: true,
-            configurable: false,
-            value: original.prototype.constructor.name,
-        });
-        metadata(Model.key(ModelKeys.MODEL), original.name)(original);
-        Model.register(newConstructor, original.name);
-        // return new constructor (will override original)
-        return newConstructor;
-    });
-}
-export function hashedBy(algorithm, ...args) {
-    return metadata(Model.key(ModelKeys.HASHING), {
-        algorithm: algorithm,
-        args: args,
-    });
-}
-export function serializedBy(serializer, ...args) {
-    return metadata(Model.key(ModelKeys.SERIALIZATION), {
-        serializer: serializer,
-        args: args,
-    });
-}

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

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

package/lib/esm/model/index.js

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

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

@@ -1,79 +0,0 @@
-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/esm/model/types.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,11 +0,0 @@
-import { Model } from "./Model";
-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;

package/lib/esm/model/utils.js

@@ -1,25 +0,0 @@
-import { ModelKeys } from "../utils/constants";
-import { Model } from "./Model";
-export function isPropertyModel(target, attribute) {
-    if (isModel(target[attribute]))
-        return true;
-    const metadata = Reflect.getMetadata(ModelKeys.TYPE, target, attribute);
-    return Model.get(metadata.name) ? metadata.name : undefined;
-}
-/**
- * @summary For Serialization/deserialization purposes.
- * @description Reads the {@link ModelKeys.ANCHOR} property of a {@link Model} to discover the class to instantiate
- *
- * @function isModel
- * @memberOf module:decorator-validation.Validation
- * @category Validation
- */
-export function isModel(target) {
-    try {
-        return target instanceof Model || !!Model.getMetadata(target);
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    }
-    catch (e) {
-        return false;
-    }
-}

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

@@ -1,14 +0,0 @@
-import { ModelErrorDefinition } from "./ModelErrorDefinition";
-import { Model } from "./Model";
-/**
- * @summary Analyses the decorations of the properties and validates the obj according to them
- *
- * @typedef T extends Model
- * @prop {T} obj Model object to validate
- * @prop {string[]} [propsToIgnore] object properties to ignore in the validation
- *
- * @function validate
- * @memberOf module:decorator-validation.Validation
- * @category Validation
- */
-export declare function validate<T extends Model>(obj: T, ...propsToIgnore: string[]): ModelErrorDefinition | undefined;

package/lib/esm/model/validation.js

@@ -1,135 +0,0 @@
-import { ModelErrorDefinition } from "./ModelErrorDefinition";
-import { Reflection } from "@decaf-ts/reflection";
-import { ModelKeys } from "../utils/constants";
-import { sf } from "../utils/strings";
-import { ReservedModels } from "./constants";
-import { Validation } from "../validation/Validation";
-import { ValidationKeys } from "../validation/Validators/constants";
-import { isModel } from "./utils";
-/**
- * @summary Analyses the decorations of the properties and validates the obj according to them
- *
- * @typedef T extends Model
- * @prop {T} obj Model object to validate
- * @prop {string[]} [propsToIgnore] object properties to ignore in the validation
- *
- * @function validate
- * @memberOf module:decorator-validation.Validation
- * @category Validation
- */
-export function validate(obj, ...propsToIgnore) {
-    const decoratedProperties = [];
-    for (const prop in obj)
-        if (Object.prototype.hasOwnProperty.call(obj, prop) &&
-            propsToIgnore.indexOf(prop) === -1)
-            decoratedProperties.push(Reflection.getPropertyDecorators(ValidationKeys.REFLECT, obj, prop));
-    let result = undefined;
-    for (const decoratedProperty of decoratedProperties) {
-        const { prop, decorators } = decoratedProperty;
-        if (!decorators || !decorators.length)
-            continue;
-        const defaultTypeDecorator = decorators[0];
-        // tries to find any type decorators or other decorators that already enforce type (the ones with the allowed types property defined). if so, skip the default type verification
-        if (decorators.find((d) => {
-            if (d.key === ValidationKeys.TYPE)
-                return true;
-            return !!d.props.types?.find((t) => t === defaultTypeDecorator.props.name);
-        })) {
-            decorators.shift(); // remove the design:type decorator, since the type will already be checked
-        }
-        let errs = undefined;
-        for (const decorator of decorators) {
-            const validator = Validation.get(decorator.key);
-            if (!validator) {
-                throw new Error(`Missing validator for ${decorator.key}`);
-            }
-            const decoratorProps = decorator.key === ModelKeys.TYPE
-                ? [decorator.props]
-                : (decorator.props || {});
-            const err = validator.hasErrors(obj[prop.toString()], decoratorProps);
-            if (err) {
-                errs = errs || {};
-                errs[decorator.key] = err;
-            }
-        }
-        if (errs) {
-            result = result || {};
-            result[decoratedProperty.prop.toString()] = errs;
-        }
-    }
-    // tests nested classes
-    for (const prop of Object.keys(obj).filter((k) => !result || !result[k])) {
-        let err;
-        // if a nested Model
-        const allDecorators = Reflection.getPropertyDecorators(ValidationKeys.REFLECT, obj, prop).decorators;
-        const decorators = Reflection.getPropertyDecorators(ValidationKeys.REFLECT, obj, prop).decorators.filter((d) => [ModelKeys.TYPE, ValidationKeys.TYPE].indexOf(d.key) !== -1);
-        if (!decorators || !decorators.length)
-            continue;
-        const dec = decorators.pop();
-        const clazz = dec.props.name
-            ? [dec.props.name]
-            : Array.isArray(dec.props.customTypes)
-                ? dec.props.customTypes
-                : [dec.props.customTypes];
-        const reserved = Object.values(ReservedModels).map((v) => v.toLowerCase());
-        for (const c of clazz) {
-            if (reserved.indexOf(c.toLowerCase()) === -1) {
-                const typeDecoratorKey = Array.isArray(obj[prop])
-                    ? ValidationKeys.LIST
-                    : ValidationKeys.TYPE;
-                const types = allDecorators.find((d) => d.key === typeDecoratorKey) || {};
-                let allowedTypes = [];
-                if (types && types.props) {
-                    const customTypes = Array.isArray(obj[prop])
-                        ? types.props.class
-                        : types.props.customTypes;
-                    if (customTypes)
-                        allowedTypes = Array.isArray(customTypes)
-                            ? customTypes.map((t) => `${t}`.toLowerCase())
-                            : [customTypes.toLowerCase()];
-                }
-                const validate = (prop, value) => {
-                    if (typeof value === "object" || typeof value === "function")
-                        return isModel(value)
-                            ? value.hasErrors()
-                            : allowedTypes.includes(typeof value)
-                                ? undefined
-                                : "Value has no validatable type";
-                };
-                switch (c) {
-                    case Array.name:
-                    case Set.name:
-                        if (allDecorators.length) {
-                            const listDec = allDecorators.find((d) => d.key === ValidationKeys.LIST);
-                            if (listDec) {
-                                err = (c === Array.name
-                                    ? obj[prop]
-                                    : // If it's a Set
-                                        obj[prop].values())
-                                    .map((v) => validate(prop, v))
-                                    .filter((e) => !!e);
-                                if (!err?.length) {
-                                    // if the result is an empty list...
-                                    err = undefined;
-                                }
-                            }
-                        }
-                        break;
-                    default:
-                        try {
-                            if (obj[prop])
-                                err = validate(prop, obj[prop]);
-                        }
-                        catch (e) {
-                            console.warn(sf("Model should be validatable but its not: " + e));
-                        }
-                }
-            }
-            if (err) {
-                result = result || {};
-                result[prop] = err;
-            }
-        }
-    }
-    return result ? new ModelErrorDefinition(result) : undefined;
-}

package/lib/esm/utils/constants.d.ts

@@ -1,26 +0,0 @@
-/**
- * @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 = "decaf.model.",
-    TYPE = "design:type",
-    PARAMS = "design:paramtypes",
-    RETURN = "design:returntype",
-    MODEL = "model",
-    ANCHOR = "__model",
-    CONSTRUCTION = "constructed-by",
-    ATTRIBUTE = "__attributes",
-    HASHING = "hashing",
-    SERIALIZATION = "serialization"
-}

package/lib/esm/utils/constants.js

@@ -1,27 +0,0 @@
-/**
- * @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 var ModelKeys;
-(function (ModelKeys) {
-    ModelKeys["REFLECT"] = "decaf.model.";
-    ModelKeys["TYPE"] = "design:type";
-    ModelKeys["PARAMS"] = "design:paramtypes";
-    ModelKeys["RETURN"] = "design:returntype";
-    ModelKeys["MODEL"] = "model";
-    ModelKeys["ANCHOR"] = "__model";
-    ModelKeys["CONSTRUCTION"] = "constructed-by";
-    ModelKeys["ATTRIBUTE"] = "__attributes";
-    ModelKeys["HASHING"] = "hashing";
-    ModelKeys["SERIALIZATION"] = "serialization";
-})(ModelKeys || (ModelKeys = {}));

package/lib/esm/utils/dates.d.ts

@@ -1,76 +0,0 @@
-import "reflect-metadata";
-/**
- * @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;
-/**
- * @summary Binds a date format to a string
- * @param {Date} [date]
- * @param {string} [format]
- * @memberOf module:decorator-validation.Utils.Format
- * @category Utilities
- */
-export declare function bindDateToString(date: Date | undefined, format: string): Date | undefined;
-/**
- * @summary Helper function to be used instead of instanceOf Date
- * @param date
- * @memberOf module:decorator-validation.Utils.Dates
- * @category Validation
- */
-export declare function isValidDate(date: any): boolean;
-/**
- * @summary Util function to pad numbers
- * @param {number} num
- *
- * @return {string}
- *
- * @function twoDigitPad
- * @memberOf module:decorator-validation.Utils.Format
- * @category Format
- */
-export declare function twoDigitPad(num: number): string;
-/**
- * @summary Date Format Handling
- * @description Code from {@link https://stackoverflow.com/questions/3552461/how-to-format-a-javascript-date}
- *
- * <pre>
- *      Using similar formatting as Moment.js, Class DateTimeFormatter (Java), and Class SimpleDateFormat (Java),
- *      I implemented a comprehensive solution formatDate(date, patternStr) where the code is easy to read and modify.
- *      You can display date, time, AM/PM, etc.
- *
- *      Date and Time Patterns
- *      yy = 2-digit year; yyyy = full year
- *      M = digit month; MM = 2-digit month; MMM = short month name; MMMM = full month name
- *      EEEE = full weekday name; EEE = short weekday name
- *      d = digit day; dd = 2-digit day
- *      h = hours am/pm; hh = 2-digit hours am/pm; H = hours; HH = 2-digit hours
- *      m = minutes; mm = 2-digit minutes; aaa = AM/PM
- *      s = seconds; ss = 2-digit seconds
- *      S = miliseconds
- * </pre>
- *
- * @param {Date} date
- * @param {string} [patternStr] defaults to 'yyyy/MM/dd'
- * @return {string} the formatted date
- *
- * @function formatDate
- * @memberOf module:decorator-validation.Utils.Dates
- * @category Format
- */
-export declare function formatDate(date: Date, patternStr?: string): string;
-/**
- * @summary Parses a date from a specified format
- * @param {string} format
- * @param {string | Date | number} [v]
- * @memberOf module:decorator-validation.Utils.Dates
- * @category Format
- */
-export declare function parseDate(format: string, v?: string | Date | number): Date | undefined;