moost 0.3.22 → 0.3.24

package/dist/index.cjs

@@ -1,31 +1,17 @@
 'use strict';
 
-var mate$1 = require('@prostojs/mate');
-var infact$1 = require('@prostojs/infact');
 var eventCore = require('@wooksjs/event-core');
+var infact$1 = require('@prostojs/infact');
+var mate$1 = require('@prostojs/mate');
 var logger = require('@prostojs/logger');
 
-function getInstanceOwnMethods(instance) {
-    const proto = Object.getPrototypeOf(instance);
-    return [
-        ...getParentProps(mate$1.getConstructor(instance)),
-        ...Object.getOwnPropertyNames(proto),
-        ...Object.getOwnPropertyNames(instance),
-    ].filter((m) => typeof instance[m] === 'function');
-}
-const fnProto = Object.getPrototypeOf(Function);
-function getParentProps(constructor) {
-    const parent = Object.getPrototypeOf(constructor);
-    if (typeof parent === 'function' &&
-        parent !== fnProto &&
-        parent !== constructor &&
-        parent.prototype) {
-        return [
-            ...getParentProps(parent),
-            ...Object.getOwnPropertyNames(parent.prototype),
-        ];
+async function runPipes(pipes, initialValue, metas, level, restoreCtx) {
+    let v = initialValue;
+    for (const pipe of pipes) {
+        restoreCtx?.();
+        v = await pipe.handler(v, metas, level);
     }
-    return [];
+    return v;
 }
 
 const METADATA_WORKSPACE = 'moost';
@@ -38,7 +24,7 @@ const moostMate = new mate$1.Mate(METADATA_WORKSPACE, {
             return !!classMeta?.inherit;
         }
         if (level === 'PROP') {
-            return (!!targetMeta?.inherit || !!(classMeta?.inherit && !targetMeta));
+            return !!targetMeta?.inherit || !!(classMeta?.inherit && !targetMeta);
         }
         return !!targetMeta?.inherit;
     },
@@ -47,15 +33,6 @@ function getMoostMate() {
     return moostMate;
 }
 
-async function runPipes(pipes, initialValue, metas, level, restoreCtx) {
-    let v = initialValue;
-    for (const pipe of pipes) {
-        restoreCtx && restoreCtx();
-        v = await pipe.handler(v, metas, level);
-    }
-    return v;
-}
-
 const sharedMoostInfact = getNewMoostInfact();
 function getMoostInfact() {
     return sharedMoostInfact;
@@ -64,20 +41,17 @@ function getNewMoostInfact() {
     return new infact$1.Infact({
         describeClass(classConstructor) {
             const meta = getMoostMate().read(classConstructor);
-            const infactMeta = {
+            return {
                 injectable: !!meta?.injectable,
                 global: false,
                 constructorParams: meta?.params || [],
                 provide: meta?.provide,
                 properties: meta?.properties || [],
-                scopeId: meta?.injectable === 'FOR_EVENT'
-                    ? eventCore.useEventId().getId()
-                    : undefined,
+                scopeId: meta?.injectable === 'FOR_EVENT' ? eventCore.useEventId().getId() : undefined,
             };
-            return infactMeta;
         },
         resolveParam({ paramMeta, classMeta, customData, classConstructor, index }) {
-            if (paramMeta && customData && customData.pipes) {
+            if (paramMeta && customData?.pipes) {
                 return runPipes(customData.pipes, undefined, {
                     paramMeta,
                     type: classConstructor,
@@ -93,7 +67,7 @@ function getNewMoostInfact() {
             return meta;
         },
         resolveProp({ instance, key, initialValue, propMeta, classMeta, customData, classConstructor, }) {
-            if (propMeta && customData && customData.pipes) {
+            if (propMeta && customData?.pipes) {
                 return runPipes(customData.pipes, initialValue, {
                     instance,
                     type: classConstructor,
@@ -108,6 +82,180 @@ function getNewMoostInfact() {
     });
 }
 
+function setControllerContext(controller, method) {
+    const { store } = eventCore.useEventContext();
+    const { set } = store('controller');
+    set('instance', controller);
+    set('method', method);
+}
+function useControllerContext() {
+    const { store } = eventCore.useEventContext();
+    const { get } = store('controller');
+    const getController = () => get('instance');
+    const getMethod = () => get('method');
+    const getControllerMeta = () => getMoostMate().read(getController());
+    const getMethodMeta = (name) => getMoostMate().read(getController(), name || getMethod());
+    function instantiate(c) {
+        return getMoostInfact().getForInstance(getController(), c);
+    }
+    return {
+        instantiate,
+        getController,
+        getMethod,
+        getControllerMeta,
+        getMethodMeta,
+        getPropertiesList: () => getControllerMeta()?.properties || [],
+        getScope: () => getControllerMeta()?.injectable || 'SINGLETON',
+        getParamsMeta: () => getMethodMeta()?.params || [],
+        getPropMeta: (name) => getMethodMeta(name),
+    };
+}
+
+const infact = getMoostInfact();
+function registerEventScope(scopeId) {
+    infact.registerScope(scopeId);
+    return () => {
+        infact.unregisterScope(scopeId);
+    };
+}
+function defineMoostEventHandler(options) {
+    return async () => {
+        const { restoreCtx } = eventCore.useEventContext(options.contextType);
+        const scopeId = eventCore.useEventId().getId();
+        const logger = eventCore.useEventLogger(options.loggerTitle);
+        const unscope = registerEventScope(scopeId);
+        let response;
+        const hookOptions = {
+            restoreCtx,
+            scopeId,
+            logger,
+            unscope,
+            method: options.controllerMethod,
+            getResponse: () => response,
+            reply: (r) => (response = r),
+        };
+        if (options.hooks?.init) {
+            await options.hooks.init(hookOptions);
+            restoreCtx();
+        }
+        const instance = await options.getControllerInstance();
+        restoreCtx();
+        if (instance) {
+            setControllerContext(instance, options.controllerMethod || '');
+        }
+        const interceptorHandler = await options.getIterceptorHandler();
+        if (interceptorHandler) {
+            restoreCtx();
+            try {
+                response = await interceptorHandler.init();
+                if (response !== undefined) {
+                    return await endWithResponse();
+                }
+            }
+            catch (error) {
+                options.logErrors && logger.error(error);
+                response = error;
+                return endWithResponse(true);
+            }
+        }
+        let args = [];
+        if (options.resolveArgs) {
+            restoreCtx();
+            try {
+                args = await options.resolveArgs();
+            }
+            catch (error) {
+                options.logErrors && logger.error(error);
+                response = error;
+                return endWithResponse(true);
+            }
+        }
+        if (interceptorHandler) {
+            restoreCtx();
+            response = await interceptorHandler.fireBefore(response);
+            if (response !== undefined) {
+                return endWithResponse();
+            }
+        }
+        const callControllerMethod = () => {
+            restoreCtx();
+            if (options.callControllerMethod) {
+                return options.callControllerMethod(args);
+            }
+            else if (instance &&
+                options.controllerMethod &&
+                typeof instance[options.controllerMethod] === 'function') {
+                return instance[options.controllerMethod](...args);
+            }
+        };
+        try {
+            response = callControllerMethod();
+        }
+        catch (error) {
+            options.logErrors && logger.error(error);
+            response = error;
+            return endWithResponse(true);
+        }
+        async function endWithResponse(raise = false) {
+            if (interceptorHandler) {
+                restoreCtx();
+                try {
+                    response = await interceptorHandler.fireAfter(response);
+                }
+                catch (error) {
+                    options.logErrors && logger.error(error);
+                    if (!options.manualUnscope) {
+                        unscope();
+                    }
+                    throw error;
+                }
+            }
+            if (!options.manualUnscope) {
+                unscope();
+            }
+            if (options.hooks?.end) {
+                await options.hooks.end(hookOptions);
+            }
+            if (raise) {
+                throw response;
+            }
+            return response;
+        }
+        return endWithResponse();
+    };
+}
+
+function getInstanceOwnMethods(instance) {
+    const proto = Object.getPrototypeOf(instance);
+    return [
+        ...getParentProps(mate$1.getConstructor(instance)),
+        ...Object.getOwnPropertyNames(proto),
+        ...Object.getOwnPropertyNames(instance),
+    ].filter(m => typeof instance[m] === 'function');
+}
+const fnProto = Object.getPrototypeOf(Function);
+function getParentProps(constructor) {
+    const parent = Object.getPrototypeOf(constructor);
+    if (typeof parent === 'function' &&
+        parent !== fnProto &&
+        parent !== constructor &&
+        parent.prototype) {
+        return [...getParentProps(parent), ...Object.getOwnPropertyNames(parent.prototype)];
+    }
+    return [];
+}
+
+function getDefaultLogger(topic) {
+    return new logger.ProstoLogger({
+        level: 4,
+        transports: [
+            logger.createConsoleTransort({
+                format: logger.coloredConsole,
+            }),
+        ],
+    }, topic);
+}
+
 async function getCallableFn(targetInstance, fn, restoreCtx, pipes, logger) {
     const mate = getMoostMate();
     const meta = mate.read(fn);
@@ -116,16 +264,14 @@ async function getCallableFn(targetInstance, fn, restoreCtx, pipes, logger) {
         infact.silent(true);
         const instance = (await infact.getForInstance(targetInstance, fn, {
             syncContextFn: () => {
-                restoreCtx && restoreCtx();
+                restoreCtx();
             },
             customData: {
                 pipes: [...(pipes || []), ...(meta.pipes || [])].sort((a, b) => a.priority - b.priority),
             },
         }));
         infact.silent(false);
-        return ((...args) => {
-            return instance.handler(...args);
-        });
+        return ((...args) => instance.handler(...args));
     }
     if (typeof fn === 'function') {
         return fn;
@@ -151,15 +297,16 @@ class InterceptorHandler {
         const { restoreCtx } = eventCore.useEventContext();
         for (const handler of this.handlers) {
             restoreCtx();
-            const response = await handler((fn) => {
+            const response = await handler(fn => {
                 this.before.push(fn);
-            }, (fn) => {
+            }, fn => {
                 this.after.unshift(fn);
-            }, (fn) => {
+            }, fn => {
                 this.onError.unshift(fn);
             });
-            if (typeof response !== 'undefined')
+            if (response !== undefined) {
                 return response;
+            }
         }
     }
     async fireBefore(response) {
@@ -168,8 +315,9 @@ class InterceptorHandler {
         for (const handler of this.before) {
             restoreCtx();
             await handler(this.replyFn.bind(this));
-            if (this.responseOverwritten)
+            if (this.responseOverwritten) {
                 break;
+            }
         }
         return this.response;
     }
@@ -237,9 +385,9 @@ async function bindControllerMethods(options) {
     };
     for (const method of methods) {
         const methodMeta = getMoostMate().read(fakeInstance, method) || {};
-        methodMeta.handlers;
-        if (!methodMeta.handlers || !methodMeta.handlers.length)
+        if (!methodMeta.handlers?.length) {
             continue;
+        }
         const pipes = [...(opts.pipes || []), ...(methodMeta.pipes || [])].sort((a, b) => a.priority - b.priority);
         const interceptors = [
             ...(opts.interceptors || []),
@@ -257,8 +405,7 @@ async function bindControllerMethods(options) {
         const resolveArgs = async () => {
             const args = [];
             const { restoreCtx } = eventCore.useEventContext();
-            for (let i = 0; i < argsPipes.length; i++) {
-                const { pipes, meta: paramMeta } = argsPipes[i];
+            for (const [i, { pipes, meta: paramMeta }] of argsPipes.entries()) {
                 args[i] = await runPipes(pipes, undefined, {
                     classMeta: meta,
                     methodMeta,
@@ -293,7 +440,9 @@ async function bindControllerMethods(options) {
                 handlers: methodMeta.handlers,
                 getIterceptorHandler,
                 resolveArgs,
-                logHandler: (eventName) => options.logger.info(`• ${eventName} ${'' + '' + ''}→ ${classConstructor.name}.${''}${method}${''}()`),
+                logHandler: (eventName) => {
+                    options.logger.info(`• ${eventName} ${'' + '' + ''}→ ${classConstructor.name}.${''}${method}${''}()`);
+                },
                 register(h, path, args) {
                     const data = wm.get(h);
                     if (data) {
@@ -309,6 +458,10 @@ async function bindControllerMethods(options) {
     return controllerOverview;
 }
 
+function Circular(resolver) {
+    return getMoostMate().decorate('circular', resolver);
+}
+
 function Label(value) {
     return getMoostMate().decorate('label', value);
 }
@@ -327,9 +480,7 @@ function Optional() {
 function Required() {
     const mate = getMoostMate();
     return mate.apply(mate.decorate('required', true), mate.decorateClass((meta, level, key, index) => {
-        if (typeof index !== 'number' &&
-            meta &&
-            ['string', 'symbol'].includes(typeof key)) {
+        if (typeof index !== 'number' && meta && ['string', 'symbol'].includes(typeof key)) {
             meta.requiredProps = meta.requiredProps || [];
             meta.requiredProps.push(key);
         }
@@ -337,58 +488,13 @@ function Required() {
     }));
 }
 
-function Resolve(resolver, label) {
-    return (target, key, index) => {
-        const i = typeof index === 'number' ? index : undefined;
-        getMoostMate().decorate('resolver', (metas, level) => {
-            let newLabel = label;
-            if (!newLabel && level === 'PROP' && typeof metas.key === 'string') {
-                newLabel = metas.key;
-            }
-            fillLabel(target, key || '', i, newLabel);
-            return resolver(metas, level);
-        })(target, key, i);
-    };
-}
-function Param(name) {
-    return getMoostMate().apply(getMoostMate().decorate('paramSource', 'ROUTE'), getMoostMate().decorate('paramName', name), Resolve(() => eventCore.useRouteParams().get(name), name));
-}
-function Params() {
-    return Resolve(() => eventCore.useRouteParams().params, 'params');
-}
-function Const(value, label) {
-    return Resolve(() => value, label);
-}
-function ConstFactory(factory, label) {
-    return Resolve(async () => await factory(), label);
-}
-function InjectEventLogger(topic) {
-    return Resolve(() => eventCore.useEventLogger(topic));
-}
-function fillLabel(target, key, index, name) {
-    if (name) {
-        const meta = getMoostMate().read(target, key);
-        if (typeof index === 'number') {
-            if (!meta?.params ||
-                !meta?.params[index] ||
-                !meta?.params[index].label) {
-                Label(name)(target, key, index);
-            }
-        }
-        else {
-            if (!meta?.label) {
-                Label(name)(target, key);
-            }
-        }
-    }
-}
-
 function Injectable(scope = true) {
     return getMoostMate().decorate('injectable', scope);
 }
-const insureInjectable = getMoostMate().decorate((meta) => {
-    if (!meta.injectable)
+const insureInjectable = getMoostMate().decorate(meta => {
+    if (!meta.injectable) {
         meta.injectable = true;
+    }
     return meta;
 });
 
@@ -408,9 +514,7 @@ function ImportController(prefix, controller, provide) {
     }, true);
 }
 
-function Circular(resolver) {
-    return getMoostMate().decorate('circular', resolver);
-}
+const Inherit = () => getMoostMate().decorate('inherit', true);
 
 exports.TInterceptorPriority = void 0;
 (function (TInterceptorPriority) {
@@ -425,25 +529,10 @@ exports.TInterceptorPriority = void 0;
 function Intercept(handler, priority) {
     return getMoostMate().decorate('interceptors', {
         handler,
-        priority: priority ||
-            handler.priority ||
-            exports.TInterceptorPriority.INTERCEPTOR,
+        priority: priority || handler.priority || exports.TInterceptorPriority.INTERCEPTOR,
     }, true);
 }
 
-function Provide(type, fn) {
-    return getMoostMate().decorate((meta) => {
-        meta.provide = meta.provide || {};
-        Object.assign(meta.provide, infact$1.createProvideRegistry([type, fn]));
-        return meta;
-    });
-}
-function Inject(type) {
-    return getMoostMate().decorate('inject', type);
-}
-
-const Inherit = () => getMoostMate().decorate('inherit', true);
-
 exports.TPipePriority = void 0;
 (function (TPipePriority) {
     TPipePriority[TPipePriority["BEFORE_RESOLVE"] = 0] = "BEFORE_RESOLVE";
@@ -459,14 +548,64 @@ exports.TPipePriority = void 0;
 
 function Pipe(handler, priority) {
     if (typeof priority !== 'number') {
-        priority =
-            typeof handler.priority === 'number'
-                ? handler.priority
-                : exports.TPipePriority.TRANSFORM;
+        priority = typeof handler.priority === 'number' ? handler.priority : exports.TPipePriority.TRANSFORM;
     }
     return getMoostMate().decorate('pipes', { handler, priority }, true);
 }
 
+function Provide(type, fn) {
+    return getMoostMate().decorate(meta => {
+        meta.provide = meta.provide || {};
+        Object.assign(meta.provide, infact$1.createProvideRegistry([type, fn]));
+        return meta;
+    });
+}
+function Inject(type) {
+    return getMoostMate().decorate('inject', type);
+}
+
+function Resolve(resolver, label) {
+    return (target, key, index) => {
+        const i = typeof index === 'number' ? index : undefined;
+        getMoostMate().decorate('resolver', (metas, level) => {
+            let newLabel = label;
+            if (!newLabel && level === 'PROP' && typeof metas.key === 'string') {
+                newLabel = metas.key;
+            }
+            fillLabel(target, key || '', i, newLabel);
+            return resolver(metas, level);
+        })(target, key, i);
+    };
+}
+function Param(name) {
+    return getMoostMate().apply(getMoostMate().decorate('paramSource', 'ROUTE'), getMoostMate().decorate('paramName', name), Resolve(() => eventCore.useRouteParams().get(name), name));
+}
+function Params() {
+    return Resolve(() => eventCore.useRouteParams().params, 'params');
+}
+function Const(value, label) {
+    return Resolve(() => 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);
+        if (typeof index === 'number') {
+            if (!meta?.params || !meta.params[index] || !meta.params[index].label) {
+                Label(name)(target, key, index);
+            }
+        }
+        else if (!meta?.label) {
+            Label(name)(target, key);
+        }
+    }
+}
+
 function defineInterceptorFn(fn, priority = exports.TInterceptorPriority.INTERCEPTOR) {
     fn.priority = priority;
     return fn;
@@ -491,21 +630,10 @@ const sharedPipes = [
     },
 ];
 
-function getDefaultLogger(topic) {
-    return new logger.ProstoLogger({
-        level: 4,
-        transports: [
-            logger.createConsoleTransort({
-                format: logger.coloredConsole,
-            }),
-        ],
-    }, topic);
-}
-
 class Moost {
     constructor(options) {
         this.options = options;
-        this.pipes = [...sharedPipes];
+        this.pipes = Array.from(sharedPipes);
         this.interceptors = [];
         this.adapters = [];
         this.controllersOverview = [];
@@ -534,10 +662,7 @@ class Moost {
         for (const a of this.adapters) {
             const constructor = mate$1.getConstructor(a);
             if (constructor) {
-                this.setProvideRegistry(infact$1.createProvideRegistry([
-                    constructor,
-                    () => a,
-                ]));
+                this.setProvideRegistry(infact$1.createProvideRegistry([constructor, () => a]));
             }
             if (typeof a.getProvideRegistry === 'function') {
                 this.setProvideRegistry(a.getProvideRegistry());
@@ -554,9 +679,9 @@ class Moost {
         infact.setLogger(this.logger);
         const meta = getMoostMate();
         const thisMeta = meta.read(this);
-        const provide = { ...(thisMeta?.provide || {}), ...this.provide };
+        const provide = { ...thisMeta?.provide, ...this.provide };
         for (const _controller of this.unregisteredControllers) {
-            let newPrefix = undefined;
+            let newPrefix;
             let controller = _controller;
             if (Array.isArray(_controller) && typeof _controller[0] === 'string') {
                 newPrefix = _controller[0];
@@ -575,8 +700,7 @@ class Moost {
         let instance;
         const infactOpts = { provide, customData: { pipes } };
         if (isControllerConsructor &&
-            (classMeta?.injectable === 'SINGLETON' ||
-                classMeta?.injectable === true)) {
+            (classMeta?.injectable === 'SINGLETON' || classMeta?.injectable === true)) {
             instance = (await infact.get(controller, infactOpts));
         }
         else if (!isControllerConsructor) {
@@ -588,7 +712,10 @@ class Moost {
             : async () => {
                 infact.silent(true);
                 const { restoreCtx } = eventCore.useEventContext();
-                const instance = (await infact.get(controller, { ...infactOpts, syncContextFn: restoreCtx }));
+                const instance = (await infact.get(controller, {
+                    ...infactOpts,
+                    syncContextFn: restoreCtx,
+                }));
                 infact.silent(false);
                 return instance;
             };
@@ -601,16 +728,14 @@ class Moost {
             adapters: this.adapters,
             globalPrefix,
             replaceOwnPrefix,
-            interceptors: [...this.interceptors],
+            interceptors: Array.from(this.interceptors),
             pipes,
             provide: classMeta?.provide || {},
             logger: this.logger,
         }));
         if (classMeta && classMeta.importController) {
-            const prefix = typeof replaceOwnPrefix === 'string'
-                ? replaceOwnPrefix
-                : classMeta?.controller?.prefix;
-            const mergedProvide = { ...provide, ...(classMeta?.provide || {}) };
+            const prefix = typeof replaceOwnPrefix === 'string' ? replaceOwnPrefix : classMeta.controller?.prefix;
+            const mergedProvide = { ...provide, ...classMeta.provide };
             for (const ic of classMeta.importController) {
                 if (ic.typeResolver) {
                     const isConstr = mate$1.isConstructor(ic.typeResolver);
@@ -619,9 +744,7 @@ class Moost {
                         ? ic.typeResolver
                         : isFunc
                             ? await ic.typeResolver()
-                            : ic.typeResolver, ic.provide
-                        ? { ...mergedProvide, ...ic.provide }
-                        : mergedProvide, `${globalPrefix}/${prefix || ''}`, ic.prefix);
+                            : ic.typeResolver, ic.provide ? { ...mergedProvide, ...ic.provide } : mergedProvide, `${globalPrefix}/${prefix || ''}`, ic.prefix);
                 }
             }
         }
@@ -631,9 +754,7 @@ class Moost {
             if (typeof item === 'function') {
                 this.pipes.push({
                     handler: item,
-                    priority: typeof item.priority === 'number'
-                        ? item.priority
-                        : exports.TPipePriority.TRANSFORM,
+                    priority: typeof item.priority === 'number' ? item.priority : exports.TPipePriority.TRANSFORM,
                 });
             }
             else {
@@ -651,8 +772,7 @@ class Moost {
             const mate = getMoostMate();
             const thisMeta = mate.read(this);
             const pipes = [...(this.pipes || []), ...(thisMeta?.pipes || [])].sort((a, b) => a.priority - b.priority);
-            const interceptors = [...this.interceptors, ...(thisMeta?.interceptors || [])]
-                .sort((a, b) => a.priority - b.priority);
+            const interceptors = [...this.interceptors, ...(thisMeta?.interceptors || [])].sort((a, b) => a.priority - b.priority);
             this.globalInterceptorHandler = getIterceptorHandlerFactory(interceptors, () => Promise.resolve(this), pipes, this.logger);
         }
         return this.globalInterceptorHandler();
@@ -663,8 +783,7 @@ class Moost {
                 this.interceptors.push({
                     handler: item,
                     priority: typeof item.priority === 'number'
-                        ? item
-                            .priority
+                        ? item.priority
                         : exports.TInterceptorPriority.INTERCEPTOR,
                 });
             }
@@ -688,158 +807,21 @@ class Moost {
     }
 }
 
-function setControllerContext(controller, method) {
-    const { store } = eventCore.useEventContext();
-    const { set } = store('controller');
-    set('instance', controller);
-    set('method', method);
-}
-function useControllerContext() {
-    const { store } = eventCore.useEventContext();
-    const { get } = store('controller');
-    const getController = () => get('instance');
-    const getMethod = () => get('method');
-    const getControllerMeta = () => getMoostMate().read(getController());
-    const getMethodMeta = (name) => getMoostMate().read(getController(), name || getMethod());
-    function instantiate(c) {
-        return getMoostInfact().getForInstance(getController(), c);
-    }
-    return {
-        instantiate,
-        getController,
-        getMethod,
-        getControllerMeta,
-        getMethodMeta,
-        getPropertiesList: () => getControllerMeta()?.properties || [],
-        getScope: () => getControllerMeta()?.injectable || 'SINGLETON',
-        getParamsMeta: () => getMethodMeta()?.params || [],
-        getPropMeta: (name) => getMethodMeta(name),
-    };
-}
-
-const infact = getMoostInfact();
-function registerEventScope(scopeId) {
-    infact.registerScope(scopeId);
-    return () => infact.unregisterScope(scopeId);
-}
-function defineMoostEventHandler(options) {
-    return async () => {
-        const { restoreCtx } = eventCore.useEventContext(options.contextType);
-        const scopeId = eventCore.useEventId().getId();
-        const logger = eventCore.useEventLogger(options.loggerTitle);
-        const unscope = registerEventScope(scopeId);
-        let response;
-        const hookOptions = {
-            restoreCtx,
-            scopeId,
-            logger,
-            unscope,
-            method: options.controllerMethod,
-            getResponse: () => response,
-            reply: (r) => response = r,
-        };
-        if (options.hooks?.init) {
-            await options.hooks.init(hookOptions);
-            restoreCtx();
-        }
-        const instance = await options.getControllerInstance();
-        restoreCtx();
-        if (instance) {
-            setControllerContext(instance, options.controllerMethod || '');
-        }
-        const interceptorHandler = await options.getIterceptorHandler();
-        if (interceptorHandler) {
-            restoreCtx();
-            try {
-                response = await interceptorHandler.init();
-                if (typeof response !== 'undefined')
-                    return endWithResponse();
-            }
-            catch (e) {
-                options.logErrors && logger.error(e);
-                response = e;
-                return endWithResponse(true);
-            }
-        }
-        let args = [];
-        if (options.resolveArgs) {
-            restoreCtx();
-            try {
-                args = await options.resolveArgs();
-            }
-            catch (e) {
-                options.logErrors && logger.error(e);
-                response = e;
-                return endWithResponse(true);
-            }
-        }
-        if (interceptorHandler) {
-            restoreCtx();
-            response = await interceptorHandler.fireBefore(response);
-            if (typeof response !== 'undefined')
-                return endWithResponse();
-        }
-        const callControllerMethod = () => {
-            restoreCtx();
-            if (options.callControllerMethod) {
-                return options.callControllerMethod(args);
-            }
-            else if (instance && options.controllerMethod && typeof instance[options.controllerMethod] === 'function') {
-                return instance[options.controllerMethod](...args);
-            }
-        };
-        try {
-            response = callControllerMethod();
-        }
-        catch (e) {
-            options.logErrors && logger.error(e);
-            response = e;
-            return endWithResponse(true);
-        }
-        async function endWithResponse(raise = false) {
-            if (interceptorHandler) {
-                restoreCtx();
-                try {
-                    response = await interceptorHandler.fireAfter(response);
-                }
-                catch (e) {
-                    options.logErrors && logger.error(e);
-                    if (!options.manualUnscope) {
-                        unscope();
-                    }
-                    throw e;
-                }
-            }
-            if (!options.manualUnscope) {
-                unscope();
-            }
-            if (options.hooks?.end) {
-                await options.hooks.end(hookOptions);
-            }
-            if (raise) {
-                throw response;
-            }
-            return response;
-        }
-        return await endWithResponse();
-    };
-}
-
-Object.defineProperty(exports, "createProvideRegistry", {
-    enumerable: true,
-    get: function () { return infact$1.createProvideRegistry; }
-});
 Object.defineProperty(exports, "EventLogger", {
-    enumerable: true,
-    get: function () { return eventCore.EventLogger; }
+  enumerable: true,
+  get: function () { return eventCore.EventLogger; }
 });
 Object.defineProperty(exports, "useEventContext", {
-    enumerable: true,
-    get: function () { return eventCore.useEventContext; }
+  enumerable: true,
+  get: function () { return eventCore.useEventContext; }
 });
 Object.defineProperty(exports, "useEventLogger", {
-    enumerable: true,
-    get: function () { return eventCore.useEventLogger; }
+  enumerable: true,
+  get: function () { return eventCore.useEventLogger; }
+});
+Object.defineProperty(exports, "createProvideRegistry", {
+  enumerable: true,
+  get: function () { return infact$1.createProvideRegistry; }
 });
 exports.Circular = Circular;
 exports.Const = Const;