@tsed/core 6.88.0 → 6.91.0

package/lib/types/domain/DecoratorTypes.d.ts

@@ -0,0 +1,10 @@
+export declare enum DecoratorTypes {
+    PARAM = "parameter",
+    PARAM_CTOR = "parameter.constructor",
+    PARAM_STC = "parameter.static",
+    PROP = "property",
+    PROP_STC = "property.static",
+    METHOD = "method",
+    METHOD_STC = "method.static",
+    CLASS = "class"
+}

package/lib/types/domain/Env.d.ts

@@ -0,0 +1,13 @@
+/**
+ *
+ */
+export declare enum Env {
+    PROD = "production",
+    DEV = "development",
+    TEST = "test"
+}
+/**
+ * Fallback
+ * @type {Env}
+ */
+export declare const EnvTypes: typeof Env;

package/lib/types/domain/Hooks.d.ts

@@ -0,0 +1,45 @@
+export declare class Hooks {
+    private listeners;
+    /**
+     * Listen a hook event
+     * @param event
+     * @param cb
+     */
+    on(event: string, cb: Function): this;
+    /**
+     * Remove a listener attached to an event
+     * @param event
+     * @param cb
+     */
+    off(event: string, cb: Function): this;
+    /**
+     * Trigger an event and call listener.
+     * @param event
+     * @param args
+     * @param callThis
+     */
+    emit(event: string, args?: any[], callThis?: any): void;
+    /**
+     * Trigger an event, listener alter given value and return it.
+     * @param event
+     * @param value
+     * @param args
+     * @param callThis
+     */
+    alter(event: string, value: any, args?: any[], callThis?: any): any;
+    /**
+     * Trigger an event and call async listener.
+     * @param event
+     * @param args
+     * @param callThis
+     */
+    asyncEmit(event: string, args?: any[], callThis?: any): Promise<void>;
+    /**
+     * Trigger an event, async listener alter given value and return it.
+     * @param event
+     * @param value
+     * @param args
+     * @param callThis
+     */
+    asyncAlter(event: string, value: any, args?: string[], callThis?: any): Promise<any>;
+}

package/lib/types/domain/Metadata.d.ts

@@ -0,0 +1,442 @@
+import "reflect-metadata";
+/**
+ * @stable
+ */
+export declare class Metadata {
+    /**
+     * Gets the metadata value for the provided metadata key on the target object or its prototype chain.
+     * @param key A key used to store and retrieve metadata.
+     * @param target The target object on which the metadata is defined.
+     * @param propertyKey The property key for the target.
+     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // constructor
+     * result = Metadata.get("custom:annotation", Example);
+     *
+     * // property (on constructor)
+     * result = Metadata.get("custom:annotation", Example, "staticProperty");
+     *
+     * // property (on prototype)
+     * result = Metadata.get("custom:annotation", Example.prototype, "property");
+     *
+     * // method (on constructor)
+     * result = Metadata.get("custom:annotation", Example, "staticMethod");
+     *
+     * // method (on prototype)
+     * result = Metadata.get("custom:annotation", Example.prototype, "method");
+     * ```
+     *
+     */
+    static get(key: string, target: any, propertyKey?: string | symbol): any;
+    /**
+     * Gets the metadata value for the provided metadata key on the target object or its prototype chain.
+     * @param key A key used to store and retrieve metadata.
+     * @param target The target object on which the metadata is defined.
+     * @param propertyKey The property key for the target.
+     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // constructor
+     * result = Metadata.getOwn("custom:annotation", Example);
+     *
+     * // property (on constructor)
+     * result = Metadata.getOwn("custom:annotation", Example, "staticProperty");
+     *
+     * // property (on prototype)
+     * result = Metadata.getOwn("custom:annotation", Example.prototype, "property");
+     *
+     * // method (on constructor)
+     * result = Metadata.getOwn("custom:annotation", Example, "staticMethod");
+     *
+     * // method (on prototype)
+     * result = Metadata.getOwn("custom:annotation", Example.prototype, "method");
+     * ```
+     *
+     */
+    static getOwn(key: string, target: any, propertyKey?: string | symbol): any;
+    /**
+     * Gets the metadata value for the provided metadata DESIGN_TYPE on the target object or its prototype chain.
+     * @param target The target object on which the metadata is defined.
+     * @param propertyKey The property key for the target.
+     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // on contructor
+     * result = Metadata.getType(Example);
+     *
+     * // property (on constructor)
+     * result = Metadata.getType(Example, "staticProperty");
+     *
+     * // method (on constructor)
+     * result = Metadata.getType(Example, "staticMethod");
+     * ```
+     *
+     */
+    static getType(target: any, propertyKey?: string | symbol): any;
+    /**
+     * Gets the metadata value for the provided metadata DESIGN_TYPE on the target object or its prototype chain.
+     * @param target The target object on which the metadata is defined.
+     * @param propertyKey The property key for the target.
+     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // on contructor
+     * result = Metadata.getOwnType(Example);
+     *
+     * // property (on constructor)
+     * result = Metadata.getOwnType(Example, "staticProperty");
+     *
+     * // method (on constructor)
+     * result = Metadata.getOwnType(Example, "staticMethod");
+     * ```
+     *
+     */
+    static getOwnType(target: any, propertyKey?: string | symbol): any;
+    /**
+     * Gets the metadata value for the provided metadata DESIGN_RETURN_TYPE on the target object or its prototype chain.
+     * @param target The target object on which the metadata is defined.
+     * @param propertyKey The property key for the target.
+     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // on contructor
+     * result = Metadata.getReturnType(Example);
+     *
+     * // property (on constructor)
+     * result = Metadata.getReturnType(Example, "staticProperty");
+     *
+     * // method (on constructor)
+     * result = Metadata.getReturnType(Example, "staticMethod");
+     * ```
+     *
+     */
+    static getReturnType(target: any, propertyKey?: string | symbol): any;
+    /**
+     * Gets the metadata value for the provided metadata DESIGN_RETURN_TYPE on the target object or its prototype chain.
+     * @param target The target object on which the metadata is defined.
+     * @param propertyKey The property key for the target.
+     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // on contructor
+     * result = Metadata.getOwnReturnType(Example);
+     *
+     * // property (on constructor)
+     * result = Metadata.getOwnReturnType(Example, "staticProperty");
+     *
+     * // method (on constructor)
+     * result = Metadata.getOwnReturnType(Example, "staticMethod");
+     * ```
+     *
+     */
+    static getOwnReturnType(target: any, propertyKey?: string | symbol): any;
+    /**
+     * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
+     * @param key A key used to store and retrieve metadata.
+     * @param target The target object on which the metadata is defined.
+     * @param propertyKey The property key for the target.
+     * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // constructor
+     * result = Metadata.has("custom:annotation", Example);
+     *
+     * // property (on constructor)
+     * result = Metadata.has("custom:annotation", Example, "staticProperty");
+     *
+     * // property (on prototype)
+     * result = Metadata.has("custom:annotation", Example.prototype, "property");
+     *
+     * // method (on constructor)
+     * result = Metadata.has("custom:annotation", Example, "staticMethod");
+     *
+     * // method (on prototype)
+     * result = Metadata.has("custom:annotation", Example.prototype, "method");
+     * ```
+     *
+     */
+    static has(key: string, target: any, propertyKey?: string | symbol): boolean;
+    /**
+     * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
+     * @param key A key used to store and retrieve metadata.
+     * @param target The target object on which the metadata is defined.
+     * @param propertyKey The property key for the target.
+     * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // constructor
+     * result = Metadata.has("custom:annotation", Example);
+     *
+     * // property (on constructor)
+     * result = Metadata.hasOwn("custom:annotation", Example, "staticProperty");
+     *
+     * // property (on prototype)
+     * result = Metadata.hasOwn("custom:annotation", Example.prototype, "property");
+     *
+     * // method (on constructor)
+     * result = Metadata.hasOwn("custom:annotation", Example, "staticMethod");
+     *
+     * // method (on prototype)
+     * result = Metadata.hasOwn("custom:annotation", Example.prototype, "method");
+     * ```
+     *
+     */
+    static hasOwn(key: string, target: any, propertyKey?: string | symbol): boolean;
+    /**
+     * Deletes the metadata entry from the target object with the provided key.
+     * @param key A key used to store and retrieve metadata.
+     * @param target The target object on which the metadata is defined.
+     * @param propertyKey The property key for the target.
+     * @returns `true` if the metadata entry was found and deleted; otherwise, false.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // constructor
+     * result = Metadata.delete("custom:annotation", Example);
+     *
+     * // property (on constructor)
+     * result = Metadata.delete("custom:annotation", Example, "staticProperty");
+     *
+     * // property (on prototype)
+     * result = Metadata.delete("custom:annotation", Example.prototype, "property");
+     *
+     * // method (on constructor)
+     * result = Metadata.delete("custom:annotation", Example, "staticMethod");
+     *
+     * // method (on prototype)
+     * result = Metadata.delete("custom:annotation", Example.prototype, "method");
+     * ```
+     *
+     */
+    static delete(key: string, target: any, propertyKey?: string | symbol): boolean;
+    /**
+     * Set the metadata value for the provided metadata DESIGN_PARAM_TYPES on the target object or its prototype chain.
+     * @param target The target object on which the metadata is defined.
+     * @param propertyKey The property key for the target.
+     * @param value A value that contains attached metadata.
+     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // on contructor
+     * result = Metadata.setParamTypes(Example, undefined, [Object]);
+     *
+     * // property (on constructor)
+     * result = Metadata.setParamTypes(Example, "staticProperty", [Object]);
+     *
+     * // property (on prototype)
+     * result = Metadata.setParamTypes(Example.prototype, "property", [Object]);
+     *
+     * // method (on constructor)
+     * result = Metadata.setParamTypes(Example, "staticMethod", [Object]);
+     *
+     * // method (on prototype)
+     * result = Metadata.setParamTypes(Example.prototype, "method", [Object]);
+     * ```
+     *
+     */
+    static setParamTypes(target: any, propertyKey: string | symbol, value: any): void;
+    /**
+     * Get all metadata for a metadataKey.
+     * @param metadataKey
+     */
+    static getTargetsFromPropertyKey: (metadataKey: string | symbol) => any[];
+    /**
+     * Define a unique metadata entry on the target.
+     * @param key A key used to store and retrieve metadata.
+     * @param value A value that contains attached metadata.
+     * @param target The target object on which to define metadata.
+     * @param propertyKey The property key for the target.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // constructor
+     * Reflect.defineMetadata("custom:annotation", options, Example);
+     *
+     * // property (on constructor)
+     * Reflect.defineMetadata("custom:annotation", Number, Example, "staticProperty");
+     *
+     * // property (on prototype)
+     * Reflect.defineMetadata("custom:annotation", Number, Example.prototype, "property");
+     *
+     * // method (on constructor)
+     * Reflect.defineMetadata("custom:annotation", Number, Example, "staticMethod");
+     *
+     * // method (on prototype)
+     * Reflect.defineMetadata("custom:annotation", Number, Example.prototype, "method");
+     *
+     * // decorator factory as metadata-producing annotation.
+     * function MyAnnotation(options): PropertyDecorator {
+     *     return (target, key) => Reflect.defineMetadata("custom:annotation", options, target, key);
+     * }
+     * ```
+     *
+     */
+    static set(key: string, value: any, target: any, propertyKey?: string | symbol): void;
+    /**
+     * Gets the metadata value for the provided metadata DESIGN_PARAM_TYPES on the target object or its prototype chain.
+     * @param targetPrototype
+     * @param propertyKey The property key for the target.
+     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // on contructor
+     * result = Metadata.getParamTypes(Example.prototype);
+     *
+     * // property (on constructor)
+     * result = Metadata.getParamTypes(Example.prototype, "staticProperty");
+     *
+     * // method (on constructor)
+     * result = Metadata.getParamTypes(Example.prototype, "staticMethod");
+     * ```
+     *
+     */
+    static getParamTypes(targetPrototype: any, propertyKey?: string | symbol): any[];
+    /**
+     * Gets the metadata value for the provided metadata DESIGN_PARAM_TYPES on the target object or its prototype chain.
+     * @param target The target object on which the metadata is defined.
+     * @param propertyKey The property key for the target.
+     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // on contructor
+     * result = Metadata.getParamTypes(Example);
+     *
+     * // property (on constructor)
+     * result = Metadata.getParamTypes(Example, "staticProperty");
+     *
+     * // method (on constructor)
+     * result = Metadata.getParamTypes(Example, "staticMethod");
+     * ```
+     *
+     */
+    static getOwnParamTypes(target: any, propertyKey?: string | symbol): any[];
+}

package/lib/types/domain/Store.d.ts

@@ -0,0 +1,69 @@
+import type { Type } from "./Type";
+/**
+ * @ignore
+ */
+export declare const CLASS_STORE = "tsed:class:store";
+/**
+ * @ignore
+ */
+export declare const METHOD_STORE = "tsed:method:store";
+/**
+ * @ignore
+ */
+export declare const PROPERTY_STORE = "tsed:property:store";
+/**
+ * @ignore
+ */
+export declare const PARAM_STORE = "tsed:param:store";
+export declare class Store {
+    private _entries;
+    /**
+     * Create or get a Store from args {target + methodName + descriptor}
+     * @param args
+     * @returns {Store}
+     */
+    static from(...args: any[]): Store;
+    /**
+     * Create store on the method.
+     * @param target
+     * @param {string} propertyKey
+     * @returns {Store}
+     */
+    static fromMethod(target: any, propertyKey: string | symbol): Store;
+    static mergeStoreFrom(target: Type<any>, source: Type<any>, ...args: any[]): Store;
+    static mergeStoreMethodFrom(target: Type<any>, source: Type<any>, propertyKey: string | symbol): Store;
+    /**
+     * The get() method returns a specified element from a Map object.
+     * @param key Required. The key of the element to return from the Map object.
+     * @param defaultValue
+     * @returns {T} Returns the element associated with the specified key or undefined if the key can't be found in the Map object.
+     */
+    get<T = any>(key: any, defaultValue?: any): T;
+    /**
+     * The has() method returns a boolean indicating whether an element with the specified key exists or not.
+     * @param key
+     * @returns {boolean}
+     */
+    has(key: any): boolean;
+    /**
+     * The set() method adds or updates an element with a specified key and value to a Map object.
+     * @param key Required. The key of the element to add to the Map object.
+     * @param metadata Required. The value of the element to add to the Map object.
+     */
+    set(key: any, metadata: any): Store;
+    /**
+     * The delete() method removes the specified element from a Map object.
+     * @param key Required. The key of the element to remove from the Map object.
+     * @returns {boolean} Returns true if an element in the Map object existed and has been removed, or false if the element does not exist.
+     */
+    delete(key: string): boolean;
+    /**
+     * Merge given value with existing value.
+     * @param key
+     * @param value
+     * @param inverse Change the merge order. Get the existing value and apply over given value
+     * @returns {Store}
+     */
+    merge(key: any, value: any, inverse?: boolean): Store;
+    toJson(): {};
+}

package/lib/types/domain/Type.d.ts

@@ -0,0 +1,11 @@
+/**
+ * An example of a `Type` is `MyCustomComponent` filters, which in JavaScript is be represented by
+ * the `MyCustomComponent` constructor function.
+ */
+/**
+ *
+ */
+export interface Type<T = any> extends Function {
+    new (...args: any[]): T;
+}
+export declare const Type: FunctionConstructor;

package/lib/types/domain/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./DecoratorTypes";
+export * from "./Env";
+export * from "./Hooks";
+export * from "./Metadata";
+export * from "./Store";
+export * from "./Type";
+export * from "./AnyToPromise";

package/lib/types/errors/UnsupportedDecoratorType.d.ts

@@ -0,0 +1,5 @@
+export declare class UnsupportedDecoratorType extends Error {
+    name: "UNSUPPORTED_DECORATOR_TYPE";
+    constructor(decorator: any, args: any[]);
+    private static buildMessage;
+}

package/lib/types/index.d.ts

@@ -0,0 +1,6 @@
+import "reflect-metadata";
+export type { DecoratorParameters, DecoratorMethodParameters, StaticMethodDecorator, MetadataTypes, ValueOf, HashOf } from "./interfaces";
+export * from "./utils";
+export * from "./domain";
+export * from "./errors/UnsupportedDecoratorType";
+export * from "./decorators";

package/lib/types/interfaces/AnyDecorator.d.ts

@@ -0,0 +1 @@
+export declare type AnyDecorator = any | ClassDecorator | MethodDecorator | PropertyDescriptor | ParameterDecorator;

package/lib/types/interfaces/DecoratorParameters.d.ts

@@ -0,0 +1,3 @@
+export declare type DecoratorParameters = [any, string | symbol, number | PropertyDescriptor];
+export declare type DecoratorMethodParameters = [any, string | symbol, PropertyDescriptor];
+export declare type StaticMethodDecorator = <TFunction extends Function, T>(target: TFunction, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void;

package/lib/types/interfaces/HashOf.d.ts

@@ -0,0 +1 @@
+export declare type HashOf<T> = Record<string, T>;

package/lib/types/interfaces/MetadataTypes.d.ts

@@ -0,0 +1,5 @@
+import type { Type } from "../domain/Type";
+export interface MetadataTypes<T = any, C = any> {
+    type?: Type<T> | T;
+    collectionType?: Type<C> | C;
+}

package/lib/types/interfaces/ValueOf.d.ts

@@ -0,0 +1 @@
+export declare type ValueOf<T> = T[keyof T];

package/lib/types/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+export type { DecoratorParameters, DecoratorMethodParameters, StaticMethodDecorator } from "./DecoratorParameters";
+export type { MetadataTypes } from "./MetadataTypes";
+export type { ValueOf } from "./ValueOf";
+export type { HashOf } from "./HashOf";

package/lib/types/utils/catchError.d.ts

@@ -0,0 +1,2 @@
+export declare function catchError<T extends Error>(cb: Function): T | undefined;
+export declare function catchAsyncError<T extends Error>(cb: Function): Promise<T | undefined>;

package/lib/types/utils/decorators/decorateMethodsOf.d.ts

@@ -0,0 +1 @@
+export declare function decorateMethodsOf(klass: any, decorator: any): void;

package/lib/types/utils/decorators/decoratorArgs.d.ts

@@ -0,0 +1,2 @@
+import { DecoratorParameters } from "../../interfaces/DecoratorParameters";
+export declare function decoratorArgs(target: any, propertyKey: string): DecoratorParameters;

package/lib/types/utils/decorators/decoratorTypeOf.d.ts

@@ -0,0 +1,2 @@
+import { DecoratorTypes } from "../../domain/DecoratorTypes";
+export declare function decoratorTypeOf(args: any[]): DecoratorTypes;

package/lib/types/utils/decorators/inheritedDescriptorOf.d.ts

@@ -0,0 +1 @@
+export declare function inheritedDescriptorOf(target: any, propertyKey: string): PropertyDescriptor | undefined;

package/lib/types/utils/decorators/useDecorators.d.ts

@@ -0,0 +1,2 @@
+import { AnyDecorator } from "../../interfaces/AnyDecorator";
+export declare function useDecorators(...decorators: AnyDecorator[]): any;

package/lib/types/utils/decorators/useMethodDecorators.d.ts

@@ -0,0 +1,3 @@
+import { AnyDecorator } from "../../interfaces/AnyDecorator";
+export declare function useMethodDecorator(decorator: AnyDecorator): (target: any, propertyKey: string | symbol) => any;
+export declare function useMethodDecorators(...decorators: AnyDecorator[]): (target: any, propertyKey: string | symbol) => void;

package/lib/types/utils/imports/importPackage.d.ts

@@ -0,0 +1 @@
+export declare function importPackage(packageName: string, loaderFn?: Function, optional?: boolean): Promise<any>;