moost 0.3.23 → 0.3.24

package/dist/index.d.ts

@@ -1,38 +1,116 @@
-import * as _prostojs_mate from '@prostojs/mate';
-import { TMateParamMeta, Mate } from '@prostojs/mate';
+import { useEventLogger } from '@wooksjs/event-core';
+export { EventLogger, THook, useEventContext, useEventLogger } from '@wooksjs/event-core';
 import { TProvideRegistry, Infact, TProvideFn } from '@prostojs/infact';
 export { TProvideRegistry, createProvideRegistry } from '@prostojs/infact';
 import { TConsoleBase } from '@prostojs/logger';
-import { useEventLogger } from '@wooksjs/event-core';
-export { EventLogger, THook, useEventContext, useEventLogger } from '@wooksjs/event-core';
+import * as _prostojs_mate from '@prostojs/mate';
+import { TMateParamMeta, Mate } from '@prostojs/mate';
 
 type TAny = any;
-type TAnyFn = {
-    (...a: TAny[]): unknown;
-};
+type TAnyFn = (...a: TAny[]) => unknown;
 type TObject = object;
 type TFunction = Function;
 type TClassConstructor<T = unknown> = new (...args: TAny[]) => T;
 interface TEmpty {
 }
 
-declare function getInstanceOwnMethods<T = TAny>(instance: T): (keyof T)[];
+declare function Circular<T = unknown>(resolver: () => TClassConstructor<T>): ParameterDecorator;
+
+/**
+ * ## Label
+ * ### @Decorator
+ * _Common purpose decorator that may be used by various adapters for various purposes_
+ *
+ * Stores Label metadata
+ */
+declare function Label(value: string): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
+/**
+ * ## Description
+ * ### @Decorator
+ * _Common purpose decorator that may be used by various adapters for various purposes_
+ *
+ * Stores Description metadata
+ */
+declare function Description(value: string): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
+/**
+ * ## Value
+ * ### @Decorator
+ * _Common purpose decorator that may be used by various adapters for various purposes_
+ *
+ * Stores Value metadata
+ */
+declare function Value(value: unknown): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
+/**
+ * ## Id
+ * ### @Decorator
+ * _Common purpose decorator that may be used by various adapters for various purposes_
+ *
+ * Stores Id metadata
+ */
+declare function Id(value: string): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
+/**
+ * ## Optional
+ * ### @Decorator
+ * _Common purpose decorator that may be used by various adapters for various purposes_
+ *
+ * Stores Optional metadata
+ */
+declare function Optional(): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
+/**
+ * ## Required
+ * ### @Decorator
+ * _Common purpose decorator that may be used by various adapters for various purposes_
+ *
+ * Stores Required metadata
+ */
+declare function Required(): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
+
+/**
+ * ## Controller
+ * ### @Decorator
+ * Set Class as a Controller
+ * @param prefix - define the prefix for all the paths of this controller
+ */
+declare function Controller(prefix?: string): ClassDecorator;
+/**
+ * ## ImportController
+ * ### @Decorator
+ * Attach sub-controller
+ * @param controller - target controller (instance) to import
+ * @param provide - provide registry for the target controller
+ */
+declare function ImportController(controller: TFunction | TObject, provide?: TProvideRegistry): ClassDecorator;
+/**
+ * ## ImportController
+ * ### @Decorator
+ * Attach sub-controller
+ * @param prefix - redefine the prefix for all the paths of this controller
+ * @param controller - point to a controller (instance) to import
+ * @param provide - provide registry for the target controller
+ */
+declare function ImportController(prefix: string, controller: TFunction | TObject, provide?: TProvideRegistry): ClassDecorator;
+
+/**
+ * ## Inherit
+ * ### @Decorator
+ * Inherit metadata from super class
+ * @returns
+ */
+declare const Inherit: () => MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
 
 interface TClassFunction<T extends TAnyFn = TAnyFn> {
     handler: T;
 }
-interface TClassFunctionConstructor<T extends TAnyFn = TAnyFn> {
-    new (...a: TAny[]): TClassFunction<T>;
-}
+type TClassFunctionConstructor<T extends TAnyFn = TAnyFn> = new (...a: TAny[]) => TClassFunction<T>;
 type TCallableClassFunction<T extends TAnyFn = TAnyFn> = T | TClassFunctionConstructor;
 
 type TInterceptorBefore = (reply: (response: TAny) => void) => void | Promise<void>;
 type TInterceptorAfter = (response: TAny, reply: (response: TAny) => void) => void | Promise<void>;
 type TInterceptorOnError = (error: Error, reply: (response: TAny) => void) => void | Promise<void>;
-type TInterceptorFn = {
+interface TInterceptorFn {
     (before: (fn: TInterceptorBefore) => void, after: (fn: TInterceptorAfter) => void, onError: (fn: TInterceptorOnError) => void): unknown | Promise<unknown>;
     priority?: TInterceptorPriority;
-};
+}
 declare enum TInterceptorPriority {
     BEFORE_ALL = 0,
     BEFORE_GUARD = 1,
@@ -54,6 +132,12 @@ declare function Intercept(handler: TCallableClassFunction<TInterceptorFn>, prio
 
 type TDecoratorLevel = 'CLASS' | 'METHOD' | 'PROP' | 'PARAM';
 
+declare function getMoostInfact(): Infact<TMoostMetadata<TEmpty>, TMoostMetadata<TEmpty>, TMoostParamsMetadata, TCustom>;
+interface TCustom {
+    pipes?: TPipeData[];
+}
+declare function getNewMoostInfact(): Infact<TMoostMetadata<TEmpty>, TMoostMetadata<TEmpty>, TMoostParamsMetadata, TCustom>;
+
 interface TPipeMetas<T extends TObject = TEmpty> {
     classMeta?: TMoostMetadata & T;
     methodMeta?: TMoostMetadata & T;
@@ -65,10 +149,10 @@ interface TPipeMetas<T extends TObject = TEmpty> {
     index?: number;
     key: string | symbol;
 }
-type TPipeFn<T extends TObject = TEmpty> = {
+interface TPipeFn<T extends TObject = TEmpty> {
     (value: unknown, metas: TPipeMetas<T>, level: TDecoratorLevel): unknown | Promise<unknown>;
     priority?: TPipePriority;
-};
+}
 declare enum TPipePriority {
     BEFORE_RESOLVE = 0,
     RESOLVE = 1,
@@ -88,22 +172,22 @@ interface TPipeData {
 declare const resolvePipe: TPipeFn<TEmpty>;
 
 interface TMoostMetadata<H extends TObject = TEmpty> extends TCommonMetaFields, TCommonMoostMeta {
-    requiredProps?: (string | symbol)[];
+    requiredProps?: Array<string | symbol>;
     controller?: {
         prefix?: string;
     };
-    importController?: {
+    importController?: Array<{
         prefix?: string;
         typeResolver?: TClassConstructor | (() => TClassConstructor | TObject | Promise<TClassConstructor | TObject>);
         provide?: TProvideRegistry;
-    }[];
-    properties?: (string | symbol)[];
+    }>;
+    properties?: Array<string | symbol>;
     injectable?: true | TInjectableScope;
     interceptors?: TInterceptorData[];
-    handlers?: TMoostHandler<H>[];
+    handlers?: Array<TMoostHandler<H>>;
     returnType?: TFunction;
     provide?: TProvideRegistry;
-    params: (TMateParamMeta & TMoostParamsMetadata)[];
+    params: Array<TMateParamMeta & TMoostParamsMetadata>;
 }
 interface TMoostParamsMetadata extends TCommonMetaFields, TCommonMoostMeta {
     circular?: () => TAny;
@@ -122,9 +206,9 @@ interface TInterceptorData {
     priority: TInterceptorPriority;
 }
 declare function getMoostMate<Class extends TObject = TEmpty, Prop extends TObject = TEmpty, Param extends TObject = TEmpty>(): Mate<TMoostMetadata<TEmpty> & Class & {
-    params: (Param & TMateParamMeta)[];
+    params: Array<Param & TMateParamMeta>;
 }, TMoostMetadata<TEmpty> & Prop & {
-    params: (Param & TMateParamMeta)[];
+    params: Array<Param & TMateParamMeta>;
 }>;
 interface TCommonMetaFields {
     id?: string;
@@ -141,11 +225,43 @@ interface TCommonMoostMeta {
     type?: TFunction;
 }
 
-declare function getMoostInfact(): Infact<TMoostMetadata<TEmpty>, TMoostMetadata<TEmpty>, TMoostParamsMetadata, TCustom>;
-interface TCustom {
-    pipes?: TPipeData[];
-}
-declare function getNewMoostInfact(): Infact<TMoostMetadata<TEmpty>, TMoostMetadata<TEmpty>, TMoostParamsMetadata, TCustom>;
+/**
+ * ## Injectable
+ * ### @Decorator
+ * Mark the Class as Injectable to enable it to be used in dependency injection
+ * @param scope - Scope for injection ("FOR_EVENT" | "SINGLETON" | true)
+ * FOR_EVENT - will create a new instance for each incoming request
+ * SINGLETON | true - will create a new instance only once
+ * @param label - field label
+ */
+declare function Injectable(scope?: true | TInjectableScope): ClassDecorator;
+
+/**
+ * ## Pipe
+ * ### @Decorator
+ * Attach pipe
+ * @param handler pipe handler
+ * @param priority pipe priority
+ * @returns
+ */
+declare function Pipe(handler: TPipeFn, priority?: TPipePriority): ClassDecorator & MethodDecorator & ParameterDecorator;
+
+/**
+ * ## Provide
+ * ### @Decorator
+ * Defines provide registry for class (and all the children)
+ * @param type - string or class constructor
+ * @param fn - factory function for provided value
+ */
+declare function Provide(type: string | TClassConstructor, fn: TProvideFn): ClassDecorator;
+/**
+ * ## Inject
+ * ### @Decorator
+ * Defines a key from provide registry to inject value
+ * (For optional values use with @Optional())
+ * @param type - string or class constructor
+ */
+declare function Inject(type: string | TClassConstructor): ParameterDecorator;
 
 /**
  * Hook to the Response Status
@@ -191,128 +307,6 @@ declare function ConstFactory<T>(factory: () => T | Promise<T>, label?: string):
  */
 declare function InjectEventLogger(topic?: string): ParameterDecorator & PropertyDecorator;
 
-/**
- * ## Controller
- * ### @Decorator
- * Set Class as a Controller
- * @param prefix - define the prefix for all the paths of this controller
- */
-declare function Controller(prefix?: string): ClassDecorator;
-/**
- * ## ImportController
- * ### @Decorator
- * Attach sub-controller
- * @param controller - target controller (instance) to import
- * @param provide - provide registry for the target controller
- */
-declare function ImportController(controller: TFunction | TObject, provide?: TProvideRegistry): ClassDecorator;
-/**
- * ## ImportController
- * ### @Decorator
- * Attach sub-controller
- * @param prefix - redefine the prefix for all the paths of this controller
- * @param controller - point to a controller (instance) to import
- * @param provide - provide registry for the target controller
- */
-declare function ImportController(prefix: string, controller: TFunction | TObject, provide?: TProvideRegistry): ClassDecorator;
-
-/**
- * ## Injectable
- * ### @Decorator
- * Mark the Class as Injectable to enable it to be used in dependency injection
- * @param scope - Scope for injection ("FOR_EVENT" | "SINGLETON" | true)
- * FOR_EVENT - will create a new instance for each incoming request
- * SINGLETON | true - will create a new instance only once
- * @param label - field label
- */
-declare function Injectable(scope?: true | TInjectableScope): ClassDecorator;
-
-declare function Circular<T = unknown>(resolver: () => TClassConstructor<T>): ParameterDecorator;
-
-/**
- * ## Provide
- * ### @Decorator
- * Defines provide registry for class (and all the children)
- * @param type - string or class constructor
- * @param fn - factory function for provided value
- */
-declare function Provide(type: string | TClassConstructor, fn: TProvideFn): ClassDecorator;
-/**
- * ## Inject
- * ### @Decorator
- * Defines a key from provide registry to inject value
- * (For optional values use with @Optional())
- * @param type - string or class constructor
- */
-declare function Inject(type: string | TClassConstructor): ParameterDecorator;
-
-/**
- * ## Label
- * ### @Decorator
- * _Common purpose decorator that may be used by various adapters for various purposes_
- *
- * Stores Label metadata
- */
-declare function Label(value: string): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-/**
- * ## Description
- * ### @Decorator
- * _Common purpose decorator that may be used by various adapters for various purposes_
- *
- * Stores Description metadata
- */
-declare function Description(value: string): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-/**
- * ## Value
- * ### @Decorator
- * _Common purpose decorator that may be used by various adapters for various purposes_
- *
- * Stores Value metadata
- */
-declare function Value(value: unknown): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-/**
- * ## Id
- * ### @Decorator
- * _Common purpose decorator that may be used by various adapters for various purposes_
- *
- * Stores Id metadata
- */
-declare function Id(value: string): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-/**
- * ## Optional
- * ### @Decorator
- * _Common purpose decorator that may be used by various adapters for various purposes_
- *
- * Stores Optional metadata
- */
-declare function Optional(): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-/**
- * ## Required
- * ### @Decorator
- * _Common purpose decorator that may be used by various adapters for various purposes_
- *
- * Stores Required metadata
- */
-declare function Required(): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-
-/**
- * ## Inherit
- * ### @Decorator
- * Inherit metadata from super class
- * @returns
- */
-declare const Inherit: () => MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-
-/**
- * ## Pipe
- * ### @Decorator
- * Attach pipe
- * @param handler pipe handler
- * @param priority pipe priority
- * @returns
- */
-declare function Pipe(handler: TPipeFn, priority?: TPipePriority): ClassDecorator & MethodDecorator & ParameterDecorator;
-
 declare class InterceptorHandler {
     protected handlers: TInterceptorFn[];
     constructor(handlers: TInterceptorFn[]);
@@ -327,6 +321,36 @@ declare class InterceptorHandler {
     fireAfter(response: unknown): Promise<unknown>;
 }
 
+interface TMoostEventHandlerHookOptions<T> {
+    restoreCtx: () => void;
+    scopeId: string;
+    logger: ReturnType<typeof useEventLogger>;
+    unscope: () => void;
+    instance?: T;
+    method?: keyof T;
+    getResponse: () => unknown;
+    reply: (r: unknown) => void;
+}
+interface TMoostEventHandlerOptions<T> {
+    contextType?: string | string[];
+    loggerTitle: string;
+    getIterceptorHandler: () => Promise<InterceptorHandler> | InterceptorHandler | undefined;
+    getControllerInstance: () => Promise<T> | T | undefined;
+    controllerMethod?: keyof T;
+    callControllerMethod?: (args: unknown[]) => unknown;
+    resolveArgs?: () => Promise<unknown[]> | unknown[];
+    logErrors?: boolean;
+    manualUnscope?: boolean;
+    hooks?: {
+        init?: (opts: TMoostEventHandlerHookOptions<T>) => unknown;
+        end?: (opts: TMoostEventHandlerHookOptions<T>) => unknown;
+    };
+}
+declare function registerEventScope(scopeId: string): () => void;
+declare function defineMoostEventHandler<T>(options: TMoostEventHandlerOptions<T>): () => Promise<unknown>;
+
+declare function getInstanceOwnMethods<T = TAny>(instance: T): Array<keyof T>;
+
 interface TControllerOverview {
     meta: TMoostMetadata;
     computedPrefix: string;
@@ -339,10 +363,10 @@ interface THandlerOverview {
     type: string;
     method: string;
     handler: TMoostHandler<TEmpty>;
-    registeredAs: {
+    registeredAs: Array<{
         path: string;
         args: string[];
-    }[];
+    }>;
 }
 
 interface TMoostOptions {
@@ -407,10 +431,10 @@ declare class Moost {
     protected logger: TConsoleBase;
     protected pipes: TPipeData[];
     protected interceptors: TInterceptorData[];
-    protected adapters: TMoostAdapter<TAny>[];
+    protected adapters: Array<TMoostAdapter<TAny>>;
     protected controllersOverview: TControllerOverview[];
     protected provide: TProvideRegistry;
-    protected unregisteredControllers: (TObject | TFunction | [string, TObject | TFunction])[];
+    protected unregisteredControllers: Array<TObject | TFunction | [string, TObject | TFunction]>;
     constructor(options?: TMoostOptions | undefined);
     /**
      * ### getLogger
@@ -433,7 +457,7 @@ declare class Moost {
     init(): Promise<void>;
     protected bindControllers(): Promise<void>;
     protected bindController(controller: TFunction | TObject, provide: TProvideRegistry, globalPrefix: string, replaceOwnPrefix?: string): Promise<void>;
-    applyGlobalPipes(...items: (TPipeFn | TPipeData)[]): this;
+    applyGlobalPipes(...items: Array<TPipeFn | TPipeData>): this;
     protected globalInterceptorHandler?: () => Promise<InterceptorHandler>;
     /**
      * Provides InterceptorHandler with global interceptors and pipes.
@@ -442,7 +466,7 @@ declare class Moost {
      * @returns IterceptorHandler
      */
     getGlobalInterceptorHandler(): Promise<InterceptorHandler>;
-    applyGlobalInterceptors(...items: (TInterceptorData['handler'] | TInterceptorData)[]): this;
+    applyGlobalInterceptors(...items: Array<TInterceptorData['handler'] | TInterceptorData>): this;
     /**
      * Register new entried to provide as dependency injections
      * @param provide - Provide Registry (use createProvideRegistry from '\@prostojs/infact')
@@ -454,21 +478,21 @@ declare class Moost {
      * @param controllers - list of target controllers (instances)
      * @returns
      */
-    registerControllers(...controllers: (TObject | TFunction | [string, TObject | TFunction])[]): this;
+    registerControllers(...controllers: Array<TObject | TFunction | [string, TObject | TFunction]>): this;
 }
 interface TMoostAdapterOptions<H, T> {
     prefix: string;
     fakeInstance: T;
     getInstance: () => Promise<T>;
     method: keyof T;
-    handlers: TMoostHandler<H>[];
+    handlers: Array<TMoostHandler<H>>;
     getIterceptorHandler: () => Promise<InterceptorHandler>;
     resolveArgs: () => Promise<unknown[]>;
     logHandler: (eventName: string) => void;
     register: (handler: TMoostHandler<TEmpty>, path: string, args: string[]) => void;
 }
 interface TMoostAdapter<H> {
-    bindHandler<T extends TObject = TObject>(options: TMoostAdapterOptions<H, T>): void | Promise<void>;
+    bindHandler: <T extends TObject = TObject>(options: TMoostAdapterOptions<H, T>) => void | Promise<void>;
     onInit?: (moost: Moost) => void | Promise<void>;
     getProvideRegistry?: () => TProvideRegistry;
 }
@@ -477,7 +501,7 @@ declare function setControllerContext<T>(controller: T, method: keyof T): void;
 declare function useControllerContext<T extends object>(): {
     instantiate: <T_1>(c: TClassConstructor<T_1>) => Promise<T_1>;
     getController: () => T;
-    getMethod: () => keyof T;
+    getMethod: () => string | undefined;
     getControllerMeta: () => (TMoostMetadata<TEmpty> & TEmpty & {
         params: (TEmpty & _prostojs_mate.TMateParamMeta)[];
     }) | undefined;
@@ -496,34 +520,6 @@ declare function useControllerContext<T extends object>(): {
     } & _prostojs_mate.TMateClassMeta<_prostojs_mate.TMateParamMeta & TMoostParamsMetadata & TEmpty> & _prostojs_mate.TMatePropMeta<_prostojs_mate.TMateParamMeta & TMoostParamsMetadata & TEmpty>) | undefined;
 };
 
-interface TMoostEventHandlerHookOptions<T> {
-    restoreCtx: () => void;
-    scopeId: string;
-    logger: ReturnType<typeof useEventLogger>;
-    unscope: () => void;
-    instance?: T;
-    method?: keyof T;
-    getResponse: () => unknown;
-    reply: (r: unknown) => void;
-}
-interface TMoostEventHandlerOptions<T> {
-    contextType?: string | string[];
-    loggerTitle: string;
-    getIterceptorHandler: () => Promise<InterceptorHandler> | InterceptorHandler | undefined;
-    getControllerInstance: () => Promise<T> | T | undefined;
-    controllerMethod?: keyof T;
-    callControllerMethod?: (args: unknown[]) => unknown;
-    resolveArgs?: () => Promise<unknown[]> | unknown[];
-    logErrors?: boolean;
-    manualUnscope?: boolean;
-    hooks?: {
-        init?: (opts: TMoostEventHandlerHookOptions<T>) => unknown;
-        end?: (opts: TMoostEventHandlerHookOptions<T>) => unknown;
-    };
-}
-declare function registerEventScope(scopeId: string): () => void;
-declare function defineMoostEventHandler<T>(options: TMoostEventHandlerOptions<T>): () => Promise<unknown>;
-
 /**
  * ### Define Interceptor Function
  *