moost 0.5.0 → 0.5.2

package/dist/index.cjs

@@ -7,6 +7,26 @@ var logger = require('@prostojs/logger');
 var hookable = require('hookable');
 var wooks = require('wooks');
 
+let defaultLogger;
+function setDefaultLogger(logger) {
+    defaultLogger = logger;
+}
+function getDefaultLogger(topic) {
+    if (!defaultLogger) {
+        defaultLogger = new logger.ProstoLogger({
+            level: 4,
+            transports: [
+                logger.createConsoleTransort({
+                    format: logger.coloredConsole,
+                }),
+            ],
+        });
+    }
+    return topic && defaultLogger instanceof logger.ProstoLogger
+        ? defaultLogger.createTopic(topic)
+        : defaultLogger;
+}
+
 async function runPipes(pipes, initialValue, metas, level) {
     let v = initialValue;
     for (const pipe of pipes) {
@@ -35,6 +55,17 @@ function getMoostMate() {
 }
 
 const sharedMoostInfact = getNewMoostInfact();
+let loggingOptions = {
+    newInstance: 'SINGLETON',
+    warn: true,
+    error: true,
+};
+function setInfactLoggingOptions(options) {
+    loggingOptions = {
+        ...loggingOptions,
+        ...options,
+    };
+}
 function getMoostInfact() {
     return sharedMoostInfact;
 }
@@ -80,6 +111,82 @@ function getNewMoostInfact() {
             }
         },
         storeProvideRegByInstance: true,
+        on: (event, targetClass, message, args) => {
+            switch (event) {
+                case 'new-instance': {
+                    const isForEvent = getMoostMate().read(targetClass)?.injectable !== 'SINGLETON';
+                    const isSingleton = !isForEvent;
+                    if (loggingOptions.newInstance === false ||
+                        (loggingOptions.newInstance === 'FOR_EVENT' && !isForEvent) ||
+                        (loggingOptions.newInstance === 'SINGLETON' && isSingleton)) {
+                        return;
+                    }
+                    break;
+                }
+                case 'warn': {
+                    if (!loggingOptions.warn) {
+                        return;
+                    }
+                    break;
+                }
+                case 'error': {
+                    if (!loggingOptions.error) {
+                        return;
+                    }
+                    break;
+                }
+            }
+            let logger;
+            try {
+                logger = eventCore.useEventLogger('infact');
+            }
+            catch (error) {
+                logger = getDefaultLogger('infact');
+            }
+            const instance = `${''}${targetClass.name}${''}`;
+            switch (event) {
+                case 'new-instance': {
+                    const params = args
+                        ?.map(a => {
+                        switch (typeof a) {
+                            case 'number':
+                            case 'boolean': {
+                                return `${''}${a}${'' + ''}`;
+                            }
+                            case 'string': {
+                                return `${''}"${a.slice(0, 1)}..."${'' + ''}`;
+                            }
+                            case 'object': {
+                                if (Array.isArray(a)) {
+                                    return `[${a.length}]`;
+                                }
+                                if (mate$1.getConstructor(a)) {
+                                    return mate$1.getConstructor(a).name;
+                                }
+                                return '{}';
+                            }
+                            default: {
+                                return '*';
+                            }
+                        }
+                    })
+                        .map(a => `${'' + ''}${a}${'' + ''}`)
+                        .join(', ') || '';
+                    logger.info(`new ${instance}${'' + ''}(${params})`);
+                    break;
+                }
+                case 'warn': {
+                    const hier = `${'' + ''}⋱ ${args?.map(String).join(' → ') || ''}`;
+                    logger.warn(`${instance} - ${message} ${hier}`);
+                    break;
+                }
+                case 'error': {
+                    const hier = `${'' + ''}⋱ ${args?.map(String).join(' → ') || ''}`;
+                    logger.error(`Failed to instantiate ${instance}. ${message} ${hier}`);
+                    break;
+                }
+            }
+        },
     });
 }
 
@@ -253,29 +360,16 @@ function getParentProps(constructor) {
     return [];
 }
 
-function getDefaultLogger(topic) {
-    return new logger.ProstoLogger({
-        level: 4,
-        transports: [
-            logger.createConsoleTransort({
-                format: logger.coloredConsole,
-            }),
-        ],
-    }, topic);
-}
-
 async function getCallableFn(targetInstance, fn, pipes, logger) {
     const mate = getMoostMate();
     const meta = mate.read(fn);
     if (meta?.injectable) {
         const infact = getMoostInfact();
-        infact.silent(true);
         const instance = (await infact.getForInstance(targetInstance, fn, {
             customData: {
                 pipes: [...(pipes || []), ...(meta.pipes || [])].sort((a, b) => a.priority - b.priority),
             },
         }));
-        infact.silent(false);
         return ((...args) => instance.handler(...args));
     }
     if (typeof fn === 'function') {
@@ -462,7 +556,7 @@ async function bindControllerMethods(options) {
                 getIterceptorHandler,
                 resolveArgs,
                 logHandler: (eventName) => {
-                    options.logger.info(`${eventName} ${'' + '' + ''}→ ${classConstructor.name}.${''}${method}${''}()`);
+                    options.moostInstance.logMappedHandler(eventName, classConstructor, method);
                 },
                 register(h, path, args) {
                     const data = wm.get(h);
@@ -618,9 +712,6 @@ function Const(value, label) {
 function ConstFactory(factory, label) {
     return Resolve(async () => factory(), label);
 }
-function InjectEventLogger(topic) {
-    return Resolve(() => eventCore.useEventLogger(topic));
-}
 function fillLabel(target, key, index, name) {
     if (name) {
         const meta = getMoostMate().read(target, key);
@@ -670,10 +761,10 @@ class Moost extends hookable.Hookable {
         this.provide = infact$1.createProvideRegistry([infact$1.Infact, getMoostInfact], [mate$1.Mate, getMoostMate]);
         this.replace = {};
         this.unregisteredControllers = [];
-        this.logger = options?.logger || getDefaultLogger(`${'' + ''}[moost]`);
-        getMoostInfact().setLogger(this.getLogger('[infact]'));
+        this.logger = options?.logger || getDefaultLogger(`${'' + ''}moost`);
+        setDefaultLogger(this.logger);
         const mate = getMoostMate();
-        Object.assign(mate, { logger: this.getLogger('[mate]') });
+        Object.assign(mate, { logger: this.getLogger('mate') });
     }
     _fireEventStart(source) {
         this.callHook('event-start', source);
@@ -682,7 +773,7 @@ class Moost extends hookable.Hookable {
         this.callHook('event-end', source);
     }
     getLogger(topic) {
-        if (this.logger instanceof logger.ProstoLogger) {
+        if (topic && this.logger instanceof logger.ProstoLogger) {
             return this.logger.createTopic(topic);
         }
         return this.logger;
@@ -712,8 +803,6 @@ class Moost extends hookable.Hookable {
         }
     }
     async bindControllers() {
-        const infact = getMoostInfact();
-        infact.setLogger(this.logger);
         const meta = getMoostMate();
         const thisMeta = meta.read(this);
         const provide = { ...thisMeta?.provide, ...this.provide };
@@ -753,14 +842,9 @@ class Moost extends hookable.Hookable {
         }
         const getInstance = instance
             ? () => Promise.resolve(instance)
-            : async () => {
-                infact.silent(true);
-                const instance = (await infact.get(controller, {
-                    ...infactOpts,
-                }));
-                infact.silent(false);
-                return instance;
-            };
+            : async () => (await infact.get(controller, {
+                ...infactOpts,
+            }));
         const classConstructor = mate$1.isConstructor(controller)
             ? controller
             : mate$1.getConstructor(controller);
@@ -775,6 +859,7 @@ class Moost extends hookable.Hookable {
             provide: classMeta?.provide,
             replace: classMeta?.replace,
             logger: this.logger,
+            moostInstance: this,
         }));
         if (classMeta && classMeta.importController) {
             const prefix = typeof replaceOwnPrefix === 'string' ? replaceOwnPrefix : classMeta.controller?.prefix;
@@ -858,6 +943,11 @@ class Moost extends hookable.Hookable {
         this.unregisteredControllers.push(...controllers);
         return this;
     }
+    logMappedHandler(eventName, classConstructor, method, stroke, prefix) {
+        const c = stroke ? __DYE_CROSSED__ : '';
+        const coff = stroke ? __DYE_CROSSED_OFF__ : '';
+        this.logger.info(`${prefix || ''}${c}${eventName} ${'' + '' + '' + c}→ ${classConstructor.name}.${'' + c}${method}${''}()${coff}`);
+    }
 }
 
 Object.defineProperty(exports, "getConstructor", {
@@ -900,6 +990,14 @@ Object.defineProperty(exports, "createReplaceRegistry", {
   enumerable: true,
   get: function () { return infact$1.createReplaceRegistry; }
 });
+Object.defineProperty(exports, "ProstoLogger", {
+  enumerable: true,
+  get: function () { return logger.ProstoLogger; }
+});
+Object.defineProperty(exports, "clearGlobalWooks", {
+  enumerable: true,
+  get: function () { return wooks.clearGlobalWooks; }
+});
 Object.defineProperty(exports, "getGlobalWooks", {
   enumerable: true,
   get: function () { return wooks.getGlobalWooks; }
@@ -913,7 +1011,6 @@ exports.Id = Id;
 exports.ImportController = ImportController;
 exports.Inherit = Inherit;
 exports.Inject = Inject;
-exports.InjectEventLogger = InjectEventLogger;
 exports.Injectable = Injectable;
 exports.Intercept = Intercept;
 exports.InterceptorHandler = InterceptorHandler;
@@ -939,4 +1036,5 @@ exports.getNewMoostInfact = getNewMoostInfact;
 exports.registerEventScope = registerEventScope;
 exports.resolvePipe = resolvePipe;
 exports.setControllerContext = setControllerContext;
+exports.setInfactLoggingOptions = setInfactLoggingOptions;
 exports.useControllerContext = useControllerContext;

package/dist/index.d.ts

@@ -1,13 +1,14 @@
 import { useEventLogger } from '@wooksjs/event-core';
 export { ContextInjector, EventLogger, THook, getContextInjector, replaceContextInjector, useAsyncEventContext, useEventLogger } from '@wooksjs/event-core';
+import { TConsoleBase } from '@prostojs/logger';
+export { ProstoLogger, TConsoleBase } from '@prostojs/logger';
 import { TProvideRegistry, Infact, TReplaceRegistry, TProvideFn } from '@prostojs/infact';
 export { TProvideRegistry, createProvideRegistry, createReplaceRegistry } from '@prostojs/infact';
-import { TConsoleBase } from '@prostojs/logger';
 import { Hookable } from 'hookable';
 import * as _prostojs_mate from '@prostojs/mate';
 import { TMateParamMeta, Mate } from '@prostojs/mate';
 export { getConstructor, isConstructor } from '@prostojs/mate';
-export { getGlobalWooks } from 'wooks';
+export { clearGlobalWooks, getGlobalWooks } from 'wooks';
 
 type TAny = any;
 type TAnyFn = (...a: TAny[]) => unknown;
@@ -136,6 +137,12 @@ declare function Intercept(handler: TCallableClassFunction<TInterceptorFn>, prio
 
 type TDecoratorLevel = 'CLASS' | 'METHOD' | 'PROP' | 'PARAM';
 
+interface TInfactLoggingOptions {
+    newInstance?: true | false | 'FOR_EVENT' | 'SINGLETON';
+    warn?: true | false;
+    error?: true | false;
+}
+declare function setInfactLoggingOptions(options: TInfactLoggingOptions): void;
 declare function getMoostInfact(): Infact<TMoostMetadata<TEmpty>, TMoostMetadata<TEmpty>, TMoostParamsMetadata, TCustom>;
 interface TCustom {
     pipes?: TPipeData[];
@@ -192,6 +199,7 @@ interface TMoostMetadata<H extends TObject = TEmpty> extends TCommonMetaFields,
     returnType?: TFunction;
     provide?: TProvideRegistry;
     replace?: TReplaceRegistry;
+    loggerTopic?: string;
     params: Array<TMateParamMeta & TMoostParamsMetadata>;
 }
 interface TMoostParamsMetadata extends TCommonMetaFields, TCommonMoostMeta {
@@ -314,12 +322,6 @@ declare function Const<T>(value: T, label?: string): ParameterDecorator & Proper
  * @paramType unknown
  */
 declare function ConstFactory<T>(factory: () => T | Promise<T>, label?: string): ParameterDecorator & PropertyDecorator;
-/**
- * Resolves event logger from event context
- * @param topic
- * @returns Resolver to '@wooksjs/event-core' (EventLogger)
- */
-declare function InjectEventLogger(topic?: string): ParameterDecorator & PropertyDecorator;
 
 declare class InterceptorHandler {
     protected handlers: Array<{
@@ -432,7 +434,7 @@ interface TMoostOptions {
  * │  const app = new MyServer()
  * │  const http = new MoostHttp()
  * │  app.adapter(http).listen(3000, () => {
- * │      app.getLogger('[MyApp]').log('Up on port 3000')
+ * │      app.getLogger('MyApp').log('Up on port 3000')
  * │  })
  * │  app.init()
  * ```
@@ -480,13 +482,13 @@ declare class Moost extends Hookable {
      * Provides application logger
      * ```js
      * // get logger with topic = "App"
-     * const logger = app.getLogger('[App]')
+     * const logger = app.getLogger('App')
      * logger.log('...')
      * ```
      * @param topic
      * @returns
      */
-    getLogger(topic: string): TConsoleBase;
+    getLogger(topic?: string): TConsoleBase;
     adapter<T extends TMoostAdapter<TAny>>(a: T): T;
     getControllersOverview(): TControllerOverview[];
     /**
@@ -524,6 +526,7 @@ declare class Moost extends Hookable {
      * @returns
      */
     registerControllers(...controllers: Array<TObject | TFunction | [string, TObject | TFunction]>): this;
+    logMappedHandler(eventName: string, classConstructor: Function, method: string, stroke?: boolean, prefix?: string): void;
 }
 interface TMoostAdapterOptions<H, T> {
     prefix: string;
@@ -637,4 +640,4 @@ type TInterceptorClass = TClassFunction<TInterceptorFn>;
  */
 declare function definePipeFn<T extends TObject = TEmpty>(fn: TPipeFn<T>, priority?: TPipePriority): TPipeFn<T>;
 
-export { Circular, Const, ConstFactory, Controller, Description, Id, ImportController, Inherit, Inject, InjectEventLogger, Injectable, Intercept, InterceptorHandler, Label, Moost, Optional, Param, Params, Pipe, Provide, Replace, Required, Resolve, type TCallableClassFunction, type TClassConstructor, type TClassFunction, type TContextInjectorHook, type TControllerOverview, type TInjectableScope, type TInterceptorAfter, type TInterceptorBefore, type TInterceptorClass, type TInterceptorData, type TInterceptorFn, type TInterceptorOnError, TInterceptorPriority, type TMoostAdapter, type TMoostAdapterOptions, type TMoostEventHandlerHookOptions, type TMoostEventHandlerOptions, type TMoostHandler, type TMoostMetadata, type TMoostOptions, type TMoostParamsMetadata, type TPipeData, type TPipeFn, type TPipeMetas, TPipePriority, Value, defineInterceptorFn, defineMoostEventHandler, definePipeFn, getInstanceOwnMethods, getInstanceOwnProps, getMoostInfact, getMoostMate, getNewMoostInfact, registerEventScope, resolvePipe, setControllerContext, useControllerContext };
+export { Circular, Const, ConstFactory, Controller, Description, Id, ImportController, Inherit, Inject, Injectable, Intercept, InterceptorHandler, Label, Moost, Optional, Param, Params, Pipe, Provide, Replace, Required, Resolve, type TCallableClassFunction, type TClassConstructor, type TClassFunction, type TContextInjectorHook, type TControllerOverview, type TInjectableScope, type TInterceptorAfter, type TInterceptorBefore, type TInterceptorClass, type TInterceptorData, type TInterceptorFn, type TInterceptorOnError, TInterceptorPriority, type TMoostAdapter, type TMoostAdapterOptions, type TMoostEventHandlerHookOptions, type TMoostEventHandlerOptions, type TMoostHandler, type TMoostMetadata, type TMoostOptions, type TMoostParamsMetadata, type TPipeData, type TPipeFn, type TPipeMetas, TPipePriority, Value, defineInterceptorFn, defineMoostEventHandler, definePipeFn, getInstanceOwnMethods, getInstanceOwnProps, getMoostInfact, getMoostMate, getNewMoostInfact, registerEventScope, resolvePipe, setControllerContext, setInfactLoggingOptions, useControllerContext };

package/dist/index.mjs

@@ -1,12 +1,33 @@
 import { Mate, getConstructor, isConstructor } from '@prostojs/mate';
 export { getConstructor, isConstructor } from '@prostojs/mate';
-import { useEventId, useAsyncEventContext, getContextInjector, useEventLogger, useRouteParams, createAsyncEventContext } from '@wooksjs/event-core';
+import { useEventId, useEventLogger, useAsyncEventContext, getContextInjector, useRouteParams, createAsyncEventContext } from '@wooksjs/event-core';
 export { ContextInjector, EventLogger, getContextInjector, replaceContextInjector, useAsyncEventContext, useEventLogger } from '@wooksjs/event-core';
 import { Infact, createProvideRegistry, createReplaceRegistry } from '@prostojs/infact';
 export { createProvideRegistry, createReplaceRegistry } from '@prostojs/infact';
 import { ProstoLogger, createConsoleTransort, coloredConsole } from '@prostojs/logger';
+export { ProstoLogger } from '@prostojs/logger';
 import { Hookable } from 'hookable';
-export { getGlobalWooks } from 'wooks';
+export { clearGlobalWooks, getGlobalWooks } from 'wooks';
+
+let defaultLogger;
+function setDefaultLogger(logger) {
+    defaultLogger = logger;
+}
+function getDefaultLogger(topic) {
+    if (!defaultLogger) {
+        defaultLogger = new ProstoLogger({
+            level: 4,
+            transports: [
+                createConsoleTransort({
+                    format: coloredConsole,
+                }),
+            ],
+        });
+    }
+    return topic && defaultLogger instanceof ProstoLogger
+        ? defaultLogger.createTopic(topic)
+        : defaultLogger;
+}
 
 async function runPipes(pipes, initialValue, metas, level) {
     let v = initialValue;
@@ -36,6 +57,17 @@ function getMoostMate() {
 }
 
 const sharedMoostInfact = getNewMoostInfact();
+let loggingOptions = {
+    newInstance: 'SINGLETON',
+    warn: true,
+    error: true,
+};
+function setInfactLoggingOptions(options) {
+    loggingOptions = {
+        ...loggingOptions,
+        ...options,
+    };
+}
 function getMoostInfact() {
     return sharedMoostInfact;
 }
@@ -81,6 +113,82 @@ function getNewMoostInfact() {
             }
         },
         storeProvideRegByInstance: true,
+        on: (event, targetClass, message, args) => {
+            switch (event) {
+                case 'new-instance': {
+                    const isForEvent = getMoostMate().read(targetClass)?.injectable !== 'SINGLETON';
+                    const isSingleton = !isForEvent;
+                    if (loggingOptions.newInstance === false ||
+                        (loggingOptions.newInstance === 'FOR_EVENT' && !isForEvent) ||
+                        (loggingOptions.newInstance === 'SINGLETON' && isSingleton)) {
+                        return;
+                    }
+                    break;
+                }
+                case 'warn': {
+                    if (!loggingOptions.warn) {
+                        return;
+                    }
+                    break;
+                }
+                case 'error': {
+                    if (!loggingOptions.error) {
+                        return;
+                    }
+                    break;
+                }
+            }
+            let logger;
+            try {
+                logger = useEventLogger('infact');
+            }
+            catch (error) {
+                logger = getDefaultLogger('infact');
+            }
+            const instance = `${''}${targetClass.name}${''}`;
+            switch (event) {
+                case 'new-instance': {
+                    const params = args
+                        ?.map(a => {
+                        switch (typeof a) {
+                            case 'number':
+                            case 'boolean': {
+                                return `${''}${a}${'' + ''}`;
+                            }
+                            case 'string': {
+                                return `${''}"${a.slice(0, 1)}..."${'' + ''}`;
+                            }
+                            case 'object': {
+                                if (Array.isArray(a)) {
+                                    return `[${a.length}]`;
+                                }
+                                if (getConstructor(a)) {
+                                    return getConstructor(a).name;
+                                }
+                                return '{}';
+                            }
+                            default: {
+                                return '*';
+                            }
+                        }
+                    })
+                        .map(a => `${'' + ''}${a}${'' + ''}`)
+                        .join(', ') || '';
+                    logger.info(`new ${instance}${'' + ''}(${params})`);
+                    break;
+                }
+                case 'warn': {
+                    const hier = `${'' + ''}⋱ ${args?.map(String).join(' → ') || ''}`;
+                    logger.warn(`${instance} - ${message} ${hier}`);
+                    break;
+                }
+                case 'error': {
+                    const hier = `${'' + ''}⋱ ${args?.map(String).join(' → ') || ''}`;
+                    logger.error(`Failed to instantiate ${instance}. ${message} ${hier}`);
+                    break;
+                }
+            }
+        },
     });
 }
 
@@ -254,29 +362,16 @@ function getParentProps(constructor) {
     return [];
 }
 
-function getDefaultLogger(topic) {
-    return new ProstoLogger({
-        level: 4,
-        transports: [
-            createConsoleTransort({
-                format: coloredConsole,
-            }),
-        ],
-    }, topic);
-}
-
 async function getCallableFn(targetInstance, fn, pipes, logger) {
     const mate = getMoostMate();
     const meta = mate.read(fn);
     if (meta?.injectable) {
         const infact = getMoostInfact();
-        infact.silent(true);
         const instance = (await infact.getForInstance(targetInstance, fn, {
             customData: {
                 pipes: [...(pipes || []), ...(meta.pipes || [])].sort((a, b) => a.priority - b.priority),
             },
         }));
-        infact.silent(false);
         return ((...args) => instance.handler(...args));
     }
     if (typeof fn === 'function') {
@@ -463,7 +558,7 @@ async function bindControllerMethods(options) {
                 getIterceptorHandler,
                 resolveArgs,
                 logHandler: (eventName) => {
-                    options.logger.info(`${eventName} ${'' + '' + ''}→ ${classConstructor.name}.${''}${method}${''}()`);
+                    options.moostInstance.logMappedHandler(eventName, classConstructor, method);
                 },
                 register(h, path, args) {
                     const data = wm.get(h);
@@ -619,9 +714,6 @@ function Const(value, label) {
 function ConstFactory(factory, label) {
     return Resolve(async () => factory(), label);
 }
-function InjectEventLogger(topic) {
-    return Resolve(() => useEventLogger(topic));
-}
 function fillLabel(target, key, index, name) {
     if (name) {
         const meta = getMoostMate().read(target, key);
@@ -671,10 +763,10 @@ class Moost extends Hookable {
         this.provide = createProvideRegistry([Infact, getMoostInfact], [Mate, getMoostMate]);
         this.replace = {};
         this.unregisteredControllers = [];
-        this.logger = options?.logger || getDefaultLogger(`${'' + ''}[moost]`);
-        getMoostInfact().setLogger(this.getLogger('[infact]'));
+        this.logger = options?.logger || getDefaultLogger(`${'' + ''}moost`);
+        setDefaultLogger(this.logger);
         const mate = getMoostMate();
-        Object.assign(mate, { logger: this.getLogger('[mate]') });
+        Object.assign(mate, { logger: this.getLogger('mate') });
     }
     _fireEventStart(source) {
         this.callHook('event-start', source);
@@ -683,7 +775,7 @@ class Moost extends Hookable {
         this.callHook('event-end', source);
     }
     getLogger(topic) {
-        if (this.logger instanceof ProstoLogger) {
+        if (topic && this.logger instanceof ProstoLogger) {
             return this.logger.createTopic(topic);
         }
         return this.logger;
@@ -713,8 +805,6 @@ class Moost extends Hookable {
         }
     }
     async bindControllers() {
-        const infact = getMoostInfact();
-        infact.setLogger(this.logger);
         const meta = getMoostMate();
         const thisMeta = meta.read(this);
         const provide = { ...thisMeta?.provide, ...this.provide };
@@ -754,14 +844,9 @@ class Moost extends Hookable {
         }
         const getInstance = instance
             ? () => Promise.resolve(instance)
-            : async () => {
-                infact.silent(true);
-                const instance = (await infact.get(controller, {
-                    ...infactOpts,
-                }));
-                infact.silent(false);
-                return instance;
-            };
+            : async () => (await infact.get(controller, {
+                ...infactOpts,
+            }));
         const classConstructor = isConstructor(controller)
             ? controller
             : getConstructor(controller);
@@ -776,6 +861,7 @@ class Moost extends Hookable {
             provide: classMeta?.provide,
             replace: classMeta?.replace,
             logger: this.logger,
+            moostInstance: this,
         }));
         if (classMeta && classMeta.importController) {
             const prefix = typeof replaceOwnPrefix === 'string' ? replaceOwnPrefix : classMeta.controller?.prefix;
@@ -859,6 +945,11 @@ class Moost extends Hookable {
         this.unregisteredControllers.push(...controllers);
         return this;
     }
+    logMappedHandler(eventName, classConstructor, method, stroke, prefix) {
+        const c = stroke ? __DYE_CROSSED__ : '';
+        const coff = stroke ? __DYE_CROSSED_OFF__ : '';
+        this.logger.info(`${prefix || ''}${c}${eventName} ${'' + '' + '' + c}→ ${classConstructor.name}.${'' + c}${method}${''}()${coff}`);
+    }
 }
 
-export { Circular, Const, ConstFactory, Controller, Description, Id, ImportController, Inherit, Inject, InjectEventLogger, Injectable, Intercept, InterceptorHandler, Label, Moost, Optional, Param, Params, Pipe, Provide, Replace, Required, Resolve, TInterceptorPriority, TPipePriority, Value, defineInterceptorFn, defineMoostEventHandler, definePipeFn, getInstanceOwnMethods, getInstanceOwnProps, getMoostInfact, getMoostMate, getNewMoostInfact, registerEventScope, resolvePipe, setControllerContext, useControllerContext };
+export { Circular, Const, ConstFactory, Controller, Description, Id, ImportController, Inherit, Inject, Injectable, Intercept, InterceptorHandler, Label, Moost, Optional, Param, Params, Pipe, Provide, Replace, Required, Resolve, TInterceptorPriority, TPipePriority, Value, defineInterceptorFn, defineMoostEventHandler, definePipeFn, getInstanceOwnMethods, getInstanceOwnProps, getMoostInfact, getMoostMate, getNewMoostInfact, registerEventScope, resolvePipe, setControllerContext, setInfactLoggingOptions, useControllerContext };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moost",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "moost",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -31,12 +31,12 @@
     "prostojs"
   ],
   "dependencies": {
-    "@prostojs/infact": "^0.2.4",
+    "@prostojs/infact": "^0.3.0",
     "@prostojs/mate": "^0.3.3",
     "@prostojs/logger": "^0.4.3",
-    "@wooksjs/event-core": "^0.5.18",
+    "@wooksjs/event-core": "^0.5.19",
     "hookable": "^5.5.3",
-    "wooks": "^0.5.18"
+    "wooks": "^0.5.19"
   },
   "author": "Artem Maltsev",
   "license": "MIT",