@decaf-ts/decorator-validation 1.5.9 → 1.5.10

package/lib/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/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/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/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;

package/lib/utils/decorators.d.ts

@@ -1,2 +0,0 @@
-export declare function prop(key?: string): (model: object, propertyKey?: any) => void;
-export declare function propMetadata<V>(key: string, value: V): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;

package/lib/utils/hashing.d.ts

@@ -1,38 +0,0 @@
-/**
- * @summary Mimics Java's String's Hash implementation
- *
- * @param {string | number | symbol | Date} obj
- * @return {number} hash value of obj
- *
- * @function hashCode
- * @memberOf module:decorator-validation.Utils.Hashing
- * @category Hashing
- */
-export declare function hashCode(obj: string | number | symbol | Date): string;
-/**
- * @summary Defines teh type for a Hashing function
- * @memberOf module:decorator-validation.Utils.Hashing
- * @category Hashing
- */
-export type HashingFunction = (value: any, ...args: any[]) => string;
-/**
- * @summary Hashes an object by combining the hash of all its properties
- *
- * @param {Record<string, any>} obj
- * @return {string} the resulting hash
- *
- * @function hashObj
- * @memberOf module:decorator-validation.Utils.Hashing
- * @category Hashing
- */
-export declare function hashObj(obj: Record<string, any> | any[]): string;
-export declare const DefaultHashingMethod = "default";
-export declare class Hashing {
-    private static current;
-    private static cache;
-    private constructor();
-    private static get;
-    static register(key: string, func: HashingFunction, setDefault?: boolean): void;
-    static hash(obj: any, method?: string, ...args: any[]): any;
-    static setDefault(method: string): void;
-}

package/lib/utils/index.d.ts

@@ -1,8 +0,0 @@
-export * from "./constants";
-export * from "./dates";
-export * from "./decorators";
-export * from "./hashing";
-export * from "./registry";
-export * from "./serialization";
-export * from "./strings";
-export * from "./types";

package/lib/utils/registry.d.ts

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

package/lib/utils/serialization.d.ts

@@ -1,53 +0,0 @@
-import { Constructor } from "../model/types";
-import { Serializer } from "./types";
-import { Model } from "../model/Model";
-export declare const DefaultSerializationMethod = "json";
-/**
- * @summary Concrete implementation of a {@link Serializer} in JSON format
- * @description JS's native JSON.stringify (used here) is not deterministic
- * and therefore should not be used for hashing purposes
- *
- * To keep dependencies low, we will not implement this, but we recommend
- * implementing a similar {@link JSONSerializer} using 'deterministic-json' libraries
- *
- * @class JSONSerializer
- * @implements Serializer
- *
- * @category Serialization
- */
-export declare class JSONSerializer<T extends Model> implements Serializer<T> {
-    constructor();
-    /**
-     * @summary prepares the model for serialization
-     * @description returns a shallow copy of the object, containing an enumerable {@link ModelKeys#ANCHOR} property
-     * so the object can be recognized upon deserialization
-     *
-     * @param {T} model
-     * @protected
-     */
-    protected preSerialize(model: T): Record<string, any>;
-    /**
-     * @summary Rebuilds a model from a serialization
-     * @param {string} str
-     *
-     * @throws {Error} If it fails to parse the string, or to build the model
-     */
-    deserialize(str: string): T;
-    /**
-     * @summary Serializes a model
-     * @param {T} model
-     *
-     * @throws {Error} if fails to serialize
-     */
-    serialize(model: T): string;
-}
-export declare class Serialization {
-    private static current;
-    private static cache;
-    private constructor();
-    private static get;
-    static register(key: string, func: Constructor<Serializer<any>>, setDefault?: boolean): void;
-    static serialize(obj: any, method?: string, ...args: any[]): any;
-    static deserialize(obj: string, method?: string, ...args: any[]): any;
-    static setDefault(method: string): void;
-}

package/lib/utils/strings.d.ts

@@ -1,25 +0,0 @@
-/**
- * @summary Util function to provide string format functionality similar to C#'s string.format
- *
- * @param {string} string
- * @param {Array<string | number>} [args] replacements made by order of appearance (replacement0 wil replace {0} and so on)
- * @return {string} formatted string
- *
- * @function stringFormat
- * @memberOf module:decorator-validation.Utils.Format
- * @category Format
- */
-export declare function stringFormat(string: string, ...args: (string | number)[]): string;
-/**
- * @summary Util function to provide string format functionality similar to C#'s string.format
- * @description alias for {@link stringFormat}
- *
- * @param {string} string
- * @param {string} args replacements made by order of appearance (replacement0 wil replace {0} and so on)
- * @return {string} formatted string
- *
- * @function sf
- * @memberOf module:decorator-validation.Utils.Format
- * @category Format
- */
-export declare const sf: typeof stringFormat;

package/lib/utils/types.d.ts

@@ -1,29 +0,0 @@
-import { Model } from "../model";
-/**
- * @summary Helper in serialization
- *
- * @interface Serializer
- * @category Serialization
- */
-export interface Serializer<T extends Model> {
-    /**
-     * @summary Serializes a model
-     * @param {T} model
-     *
-     * @param args
-     * @method
-     *
-     * @throws {Error}
-     */
-    serialize(model: T, ...args: any[]): string;
-    /**
-     * @summary Rebuilds a model from serialization
-     * @param {string} str
-     *
-     * @param args
-     * @method
-     *
-     * @throws {Error}
-     */
-    deserialize(str: string, ...args: any[]): T;
-}

package/lib/validation/Validation.d.ts

@@ -1,51 +0,0 @@
-import { Validator } from "./Validators/Validator";
-import { IValidatorRegistry, ValidatorDefinition } from "./types";
-/**
- * @summary Static class acting as a namespace for the Validation
- *
- * @class Validation
- * @static
- *
- * @category Validation
- */
-export declare class Validation {
-    private static actingValidatorRegistry?;
-    private constructor();
-    /**
-     * @summary Defines the acting ValidatorRegistry
-     *
-     * @param {IValidatorRegistry} validatorRegistry the new implementation of the validator Registry
-     * @param {function(Validator): Validator} [migrationHandler] the method to map the validator if required;
-     */
-    static setRegistry(validatorRegistry: IValidatorRegistry<Validator>, migrationHandler?: (validator: Validator) => Validator): void;
-    /**
-     * @summary Returns the current ValidatorRegistry
-     *
-     * @return IValidatorRegistry, defaults to {@link ValidatorRegistry}
-     */
-    private static getRegistry;
-    /**
-     * @summary Retrieves a validator
-     *
-     * @param {string} validatorKey one of the {@link ValidationKeys}
-     * @return {Validator | undefined} the registered Validator or undefined if there is nono matching the provided key
-     */
-    static get<T extends Validator>(validatorKey: string): T | undefined;
-    /**
-     * @summary Registers the provided validators onto the registry
-     *
-     * @param {T[] | ValidatorDefinition[]} validator
-     */
-    static register<T extends Validator>(...validator: (ValidatorDefinition | T)[]): void;
-    /**
-     * @summary Builds the key to store as Metadata under Reflections
-     * @description concatenates {@link ValidationKeys#REFLECT} with the provided key
-     *
-     * @param {string} key
-     */
-    static key(key: string): string;
-    /**
-     * @summary Returns all registered validation keys
-     */
-    static keys(): string[];
-}

package/lib/validation/Validators/DateValidator.d.ts

@@ -1,28 +0,0 @@
-import { Validator } from "./Validator";
-import { DateValidatorOptions } from "../types";
-/**
- * @summary Date Validator
- *
- * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#DATE}
- *
- * @class DateValidator
- * @extends Validator
- *
- * @category Validators
- */
-export declare class DateValidator extends Validator<DateValidatorOptions> {
-    constructor(message?: string);
-    /**
-     * @summary Validates a model
-     *
-     * @param {Date | string} value
-     * @param {DateValidatorOptions} [options]
-     *
-     * @return {string | undefined}
-     *
-     * @override
-     *
-     * @see Validator#hasErrors
-     */
-    hasErrors(value: Date | string, options?: DateValidatorOptions): string | undefined;
-}

package/lib/validation/Validators/EmailValidator.d.ts

@@ -1,28 +0,0 @@
-import { PatternValidator } from "./PatternValidator";
-import { PatternValidatorOptions } from "../types";
-/**
- * @summary Email Validator
- *
- * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#EMAIL}
- *
- * @class EmailValidator
- * @extends PatternValidator
- *
- * @category Validators
- */
-export declare class EmailValidator extends PatternValidator {
-    constructor(message?: string);
-    /**
-     * @summary Validates a model
-     *
-     * @param {string} value
-     * @param {PatternValidatorOptions} [options]
-     *
-     * @return {string | undefined}
-     *
-     * @override
-     *
-     * @see Validator#hasErrors
-     */
-    hasErrors(value: string, options?: PatternValidatorOptions): string | undefined;
-}

package/lib/validation/Validators/ListValidator.d.ts

@@ -1,28 +0,0 @@
-import { Validator } from "./Validator";
-import { ListValidatorOptions } from "../types";
-/**
- * @summary List Validator
- *
- * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}
- *
- * @class ListValidator
- * @extends Validator
- *
- * @category Validators
- */
-export declare class ListValidator extends Validator<ListValidatorOptions> {
-    constructor(message?: string);
-    /**
-     * @summary Validates a model
-     *
-     * @param {any[] | Set<any>} value
-     * @param {ListValidatorOptions} options
-     *
-     * @return {string | undefined}
-     *
-     * @override
-     *
-     * @see Validator#hasErrors
-     */
-    hasErrors(value: any[] | Set<any>, options: ListValidatorOptions): string | undefined;
-}

package/lib/validation/Validators/MaxLengthValidator.d.ts

@@ -1,29 +0,0 @@
-import { Validator } from "./Validator";
-import { MaxLengthValidatorOptions } from "../types";
-/**
- * @summary Maximum Length Validator
- * @description Validates strings and Arrays on their maximum length
- *
- * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#MAX_LENGTH}
- *
- * @class MinLengthValidator
- * @extends Validator
- *
- * @category Validators
- */
-export declare class MaxLengthValidator extends Validator<MaxLengthValidatorOptions> {
-    constructor(message?: string);
-    /**
-     * @summary Validates a model
-     *
-     * @param {string} value
-     * @param {MaxLengthValidatorOptions} options
-     *
-     * @return {string | undefined}
-     *
-     * @override
-     *
-     * @see Validator#hasErrors
-     */
-    hasErrors(value: string | any[], options: MaxLengthValidatorOptions): string | undefined;
-}

package/lib/validation/Validators/MaxValidator.d.ts

@@ -1,28 +0,0 @@
-import { Validator } from "./Validator";
-import { MaxValidatorOptions } from "../types";
-/**
- * @summary Max Validator
- *
- * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#MAX}
- *
- * @class MaxValidator
- * @extends Validator
- *
- * @category Validators
- */
-export declare class MaxValidator extends Validator<MaxValidatorOptions> {
-    constructor(message?: string);
-    /**
-     * @summary Validates a Model
-     *
-     * @param {string} value
-     * @param {MaxValidatorOptions} options
-     *
-     * @return {string | undefined}
-     *
-     * @override
-     *
-     * @see Validator#hasErrors
-     */
-    hasErrors(value: number | Date | string, options: MaxValidatorOptions): string | undefined;
-}

package/lib/validation/Validators/MinLengthValidator.d.ts

@@ -1,29 +0,0 @@
-import { Validator } from "./Validator";
-import { MinLengthValidatorOptions } from "../types";
-/**
- * @summary Minimum Length Validator
- * @description Validates strings and Arrays on their minimum length
- *
- * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#MIN_LENGTH}
- *
- * @class MinLengthValidator
- * @extends Validator
- *
- * @category Validators
- */
-export declare class MinLengthValidator extends Validator<MinLengthValidatorOptions> {
-    constructor(message?: string);
-    /**
-     *
-     * @param {string | Array} value
-     * @param {MinLengthValidatorOptions} options
-     *
-     * @return {string | undefined}
-     *
-     * @memberOf MinLengthValidator
-     * @override
-     *
-     * @see Validator#hasErrors
-     */
-    hasErrors(value: string | any[], options: MinLengthValidatorOptions): string | undefined;
-}

package/lib/validation/Validators/MinValidator.d.ts

@@ -1,28 +0,0 @@
-import { Validator } from "./Validator";
-import { MinValidatorOptions } from "../types";
-/**
- * @summary Min Validator
- *
- * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#MIN}
- *
- * @class MinValidator
- * @extends Validator
- *
- * @category Validators
- */
-export declare class MinValidator extends Validator<MinValidatorOptions> {
-    constructor(message?: string);
-    /**
-     * @summary Validates Model
-     *
-     * @param {string} value
-     * @param {MaxValidatorOptions} options
-     *
-     * @return {string | undefined}
-     *
-     * @override
-     *
-     * @see Validator#hasErrors
-     */
-    hasErrors(value: number | Date | string, options: MinValidatorOptions): string | undefined;
-}