moost 0.3.9 → 0.3.11

package/dist/index.cjs

@@ -5,1163 +5,1111 @@ var infact$1 = require('@prostojs/infact');
 var eventCore = require('@wooksjs/event-core');
 var logger = require('@prostojs/logger');
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise */
-
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+const METADATA_WORKSPACE = 'moost';
+const moostMate = new mate$1.Mate(METADATA_WORKSPACE, {
+    readType: true,
+    readReturnType: true,
+    collectPropKeys: true,
+    inherit(classMeta, targetMeta, level) {
+        if (level === 'CLASS') {
+            return !!classMeta?.inherit;
+        }
+        if (level === 'PROP') {
+            return (!!targetMeta?.inherit || !!(classMeta?.inherit && !targetMeta));
+        }
+        return !!targetMeta?.inherit;
+    },
+});
+function getMoostMate() {
+    return moostMate;
 }
 
-const METADATA_WORKSPACE = 'moost';
-const moostMate = new mate$1.Mate(METADATA_WORKSPACE, {
-    readType: true,
-    readReturnType: true,
-    collectPropKeys: true,
-    inherit(classMeta, targetMeta, level) {
-        if (level === 'CLASS') {
-            return !!(classMeta === null || classMeta === void 0 ? void 0 : classMeta.inherit);
-        }
-        if (level === 'PROP') {
-            return (!!(targetMeta === null || targetMeta === void 0 ? void 0 : targetMeta.inherit) || !!((classMeta === null || classMeta === void 0 ? void 0 : classMeta.inherit) && !targetMeta));
-        }
-        return !!(targetMeta === null || targetMeta === void 0 ? void 0 : targetMeta.inherit);
-    },
-});
-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;
 }
 
-function runPipes(pipes, initialValue, metas, level, restoreCtx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let v = initialValue;
-        for (const pipe of pipes) {
-            restoreCtx && restoreCtx();
-            v = yield pipe.handler(v, metas, level);
-        }
-        return v;
-    });
+const sharedMoostInfact = getNewMoostInfact();
+function getMoostInfact() {
+    return sharedMoostInfact;
 }
-
-const sharedMoostInfact = getNewMoostInfact();
-function getMoostInfact() {
-    return sharedMoostInfact;
-}
-function getNewMoostInfact() {
-    return new infact$1.Infact({
-        describeClass(classConstructor) {
-            const meta = getMoostMate().read(classConstructor);
-            const infactMeta = {
-                injectable: !!(meta === null || meta === void 0 ? void 0 : meta.injectable),
-                global: false,
-                constructorParams: (meta === null || meta === void 0 ? void 0 : meta.params) || [],
-                provide: meta === null || meta === void 0 ? void 0 : meta.provide,
-                properties: (meta === null || meta === void 0 ? void 0 : meta.properties) || [],
-                scopeId: (meta === null || meta === void 0 ? void 0 : meta.injectable) === 'FOR_EVENT'
-                    ? eventCore.useEventId().getId()
-                    : undefined,
-            };
-            return infactMeta;
-        },
-        resolveParam({ paramMeta, classMeta, customData, classConstructor, index }) {
-            if (paramMeta && customData && customData.pipes) {
-                return runPipes(customData.pipes, undefined, {
-                    paramMeta,
-                    type: classConstructor,
-                    key: 'constructor',
-                    classMeta: classMeta,
-                    index,
-                    targetMeta: paramMeta,
-                }, 'PARAM');
-            }
-        },
-        describeProp(classConstructor, key) {
-            const meta = getMoostMate().read(classConstructor, key);
-            return meta;
-        },
-        resolveProp({ instance, key, initialValue, propMeta, classMeta, customData, classConstructor, }) {
-            if (propMeta && customData && customData.pipes) {
-                return runPipes(customData.pipes, initialValue, {
-                    instance,
-                    type: classConstructor,
-                    key,
-                    propMeta,
-                    targetMeta: propMeta,
-                    classMeta: classMeta,
-                }, 'PROP');
-            }
-        },
-        storeProvideRegByInstance: true,
-    });
+function getNewMoostInfact() {
+    return new infact$1.Infact({
+        describeClass(classConstructor) {
+            const meta = getMoostMate().read(classConstructor);
+            const infactMeta = {
+                injectable: !!meta?.injectable,
+                global: false,
+                constructorParams: meta?.params || [],
+                provide: meta?.provide,
+                properties: meta?.properties || [],
+                scopeId: meta?.injectable === 'FOR_EVENT'
+                    ? eventCore.useEventId().getId()
+                    : undefined,
+            };
+            return infactMeta;
+        },
+        resolveParam({ paramMeta, classMeta, customData, classConstructor, index }) {
+            if (paramMeta && customData && customData.pipes) {
+                return runPipes(customData.pipes, undefined, {
+                    paramMeta,
+                    type: classConstructor,
+                    key: 'constructor',
+                    classMeta: classMeta,
+                    index,
+                    targetMeta: paramMeta,
+                }, 'PARAM');
+            }
+        },
+        describeProp(classConstructor, key) {
+            const meta = getMoostMate().read(classConstructor, key);
+            return meta;
+        },
+        resolveProp({ instance, key, initialValue, propMeta, classMeta, customData, classConstructor, }) {
+            if (propMeta && customData && customData.pipes) {
+                return runPipes(customData.pipes, initialValue, {
+                    instance,
+                    type: classConstructor,
+                    key,
+                    propMeta,
+                    targetMeta: propMeta,
+                    classMeta: classMeta,
+                }, 'PROP');
+            }
+        },
+        storeProvideRegByInstance: true,
+    });
 }
 
-function getInstanceOwnMethods(instance) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    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 getInstanceOwnMethods(instance) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const proto = Object.getPrototypeOf(instance);
+    return [
+        ...getParentProps(mate$1.getConstructor(instance)), // Inheritance support
+        ...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 getCallableFn(targetInstance, fn, restoreCtx, pipes, logger) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const mate = getMoostMate();
-        const meta = mate.read(fn);
-        if (meta === null || meta === void 0 ? void 0 : meta.injectable) {
-            const infact = getMoostInfact();
-            infact.silent(true);
-            const instance = (yield infact.getForInstance(targetInstance, fn, {
-                syncContextFn: () => {
-                    restoreCtx && restoreCtx();
-                },
-                customData: {
-                    pipes: [...(pipes || []), ...(meta.pipes || [])].sort((a, b) => a.priority - b.priority),
-                },
-            }));
-            infact.silent(false);
-            return ((...args) => {
-                return instance.handler(...args);
-            });
-        }
-        if (typeof fn === 'function') {
-            return fn;
-        }
-        const e = new Error(`getCallableFn failed for "${mate$1.getConstructor(targetInstance).name}" because the passed arg is not a Function nor TClassFunction`);
-        logger.error(e);
-        throw e;
-    });
+async function getCallableFn(targetInstance, fn, restoreCtx, 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, {
+            syncContextFn: () => {
+                restoreCtx && restoreCtx();
+            },
+            customData: {
+                pipes: [...(pipes || []), ...(meta.pipes || [])].sort((a, b) => a.priority - b.priority),
+            },
+        }));
+        infact.silent(false);
+        return ((...args) => {
+            return instance.handler(...args);
+        });
+    }
+    if (typeof fn === 'function') {
+        return fn;
+    }
+    const e = new Error(`getCallableFn failed for "${mate$1.getConstructor(targetInstance).name}" because the passed arg is not a Function nor TClassFunction`);
+    logger.error(e);
+    throw e;
 }
 
-class InterceptorHandler {
-    constructor(handlers) {
-        this.handlers = handlers;
-        this.before = [];
-        this.after = [];
-        this.onError = [];
-        this.responseOverwritten = false;
-    }
-    replyFn(reply) {
-        this.response = reply;
-        this.responseOverwritten = true;
-    }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { restoreCtx } = eventCore.useEventContext();
-            for (const handler of this.handlers) {
-                restoreCtx();
-                const response = yield handler((fn) => {
-                    this.before.push(fn);
-                }, (fn) => {
-                    this.after.unshift(fn);
-                }, (fn) => {
-                    this.onError.unshift(fn);
-                });
-                if (typeof response !== 'undefined')
-                    return response;
-            }
-        });
-    }
-    fireBefore(response) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { restoreCtx } = eventCore.useEventContext();
-            this.response = response;
-            for (const handler of this.before) {
-                restoreCtx();
-                yield handler(this.replyFn.bind(this));
-                if (this.responseOverwritten)
-                    break;
-            }
-            return this.response;
-        });
-    }
-    fireAfter(response) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { restoreCtx } = eventCore.useEventContext();
-            this.response = response;
-            if (response instanceof Error) {
-                for (const handler of this.onError) {
-                    restoreCtx();
-                    yield handler(response, this.replyFn.bind(this));
-                }
-            }
-            else {
-                for (const handler of this.after) {
-                    restoreCtx();
-                    yield handler(response, this.replyFn.bind(this));
-                }
-            }
-            return this.response;
-        });
-    }
+class InterceptorHandler {
+    constructor(handlers) {
+        this.handlers = handlers;
+        this.before = [];
+        this.after = [];
+        this.onError = [];
+        this.responseOverwritten = false;
+    }
+    replyFn(reply) {
+        this.response = reply;
+        this.responseOverwritten = true;
+    }
+    async init() {
+        const { restoreCtx } = eventCore.useEventContext();
+        for (const handler of this.handlers) {
+            restoreCtx();
+            const response = await handler((fn) => {
+                this.before.push(fn);
+            }, (fn) => {
+                this.after.unshift(fn);
+            }, (fn) => {
+                this.onError.unshift(fn);
+            });
+            if (typeof response !== 'undefined')
+                return response;
+        }
+    }
+    async fireBefore(response) {
+        const { restoreCtx } = eventCore.useEventContext();
+        this.response = response;
+        for (const handler of this.before) {
+            restoreCtx();
+            await handler(this.replyFn.bind(this));
+            if (this.responseOverwritten)
+                break;
+        }
+        return this.response;
+    }
+    async fireAfter(response) {
+        const { restoreCtx } = eventCore.useEventContext();
+        this.response = response;
+        if (response instanceof Error) {
+            for (const handler of this.onError) {
+                restoreCtx();
+                await handler(response, this.replyFn.bind(this));
+            }
+        }
+        else {
+            for (const handler of this.after) {
+                restoreCtx();
+                await handler(response, this.replyFn.bind(this));
+            }
+        }
+        return this.response;
+    }
 }
 
-const mate = getMoostMate();
-function getIterceptorHandlerFactory(interceptors, getTargetInstance, pipes, logger) {
-    return () => {
-        const interceptorHandlers = [];
-        for (const { handler } of interceptors) {
-            const interceptorMeta = mate.read(handler);
-            if (interceptorMeta === null || interceptorMeta === void 0 ? void 0 : interceptorMeta.injectable) {
-                interceptorHandlers.push((...args) => __awaiter(this, void 0, void 0, function* () {
-                    const { restoreCtx } = eventCore.useEventContext();
-                    const targetInstance = yield getTargetInstance();
-                    restoreCtx();
-                    return (yield getCallableFn(targetInstance, handler, restoreCtx, pipes, logger))(...args);
-                }));
-            }
-            else {
-                interceptorHandlers.push(handler);
-            }
-        }
-        return Promise.resolve(new InterceptorHandler(interceptorHandlers));
-    };
+const mate = getMoostMate();
+function getIterceptorHandlerFactory(interceptors, getTargetInstance, pipes, logger) {
+    return () => {
+        const interceptorHandlers = [];
+        for (const { handler } of interceptors) {
+            const interceptorMeta = mate.read(handler);
+            if (interceptorMeta?.injectable) {
+                interceptorHandlers.push(async (...args) => {
+                    const { restoreCtx } = eventCore.useEventContext();
+                    const targetInstance = await getTargetInstance();
+                    restoreCtx();
+                    return (await getCallableFn(targetInstance, handler, restoreCtx, pipes, logger))(...args);
+                });
+            }
+            else {
+                interceptorHandlers.push(handler);
+            }
+        }
+        return Promise.resolve(new InterceptorHandler(interceptorHandlers));
+    };
 }
 
-function bindControllerMethods(options) {
-    var _a;
-    return __awaiter(this, void 0, void 0, function* () {
-        const opts = options || {};
-        const { getInstance } = opts;
-        const { classConstructor } = opts;
-        const { adapters } = opts;
-        opts.globalPrefix = opts.globalPrefix || '';
-        opts.provide = opts.provide || {};
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        const fakeInstance = Object.create(classConstructor.prototype);
-        const methods = getInstanceOwnMethods(fakeInstance);
-        const mate = getMoostMate();
-        const meta = mate.read(classConstructor) || {};
-        const ownPrefix = typeof opts.replaceOwnPrefix === 'string'
-            ? opts.replaceOwnPrefix
-            : ((_a = meta.controller) === null || _a === void 0 ? void 0 : _a.prefix) || '';
-        const prefix = `${opts.globalPrefix}/${ownPrefix}`;
-        const controllerOverview = {
-            meta,
-            computedPrefix: prefix,
-            type: classConstructor,
-            handlers: [],
-        };
-        for (const method of methods) {
-            const methodMeta = getMoostMate().read(fakeInstance, method) || {};
-            methodMeta.handlers;
-            if (!methodMeta.handlers || !methodMeta.handlers.length)
-                continue;
-            const pipes = [...(opts.pipes || []), ...(methodMeta.pipes || [])].sort((a, b) => a.priority - b.priority);
-            // preparing interceptors
-            const interceptors = [
-                ...(opts.interceptors || []),
-                ...(meta.interceptors || []),
-                ...(methodMeta.interceptors || []),
-            ].sort((a, b) => a.priority - b.priority);
-            const getIterceptorHandler = getIterceptorHandlerFactory(interceptors, getInstance, pipes, options.logger);
-            // preparing pipes
-            const argsPipes = [];
-            for (const p of methodMeta.params || []) {
-                argsPipes.push({
-                    meta: p,
-                    pipes: [...pipes, ...(p.pipes || [])].sort((a, b) => a.priority - b.priority),
-                });
-            }
-            const resolveArgs = () => __awaiter(this, void 0, void 0, function* () {
-                const args = [];
-                const { restoreCtx } = eventCore.useEventContext();
-                for (let i = 0; i < argsPipes.length; i++) {
-                    const { pipes, meta: paramMeta } = argsPipes[i];
-                    args[i] = yield runPipes(pipes, undefined, {
-                        classMeta: meta,
-                        methodMeta,
-                        paramMeta,
-                        type: classConstructor,
-                        key: method,
-                        index: i,
-                        targetMeta: paramMeta,
-                    }, 'PARAM', restoreCtx);
-                }
-                return args;
-            });
-            const wm = new WeakMap();
-            controllerOverview.handlers.push(...methodMeta.handlers.map(h => {
-                const data = {
-                    meta: methodMeta,
-                    path: h.path,
-                    type: h.type,
-                    method,
-                    handler: h,
-                    registeredAs: [],
-                };
-                wm.set(h, data);
-                return data;
-            }));
-            for (const adapter of adapters) {
-                yield adapter.bindHandler({
-                    prefix,
-                    fakeInstance,
-                    getInstance,
-                    method,
-                    handlers: methodMeta.handlers,
-                    getIterceptorHandler,
-                    resolveArgs,
-                    logHandler: (eventName) => options.logger.info(`• ${eventName} ${'' + '' + ''}→ ${classConstructor.name}.${''}${method}${''}()`),
-                    register(h, path, args) {
-                        const data = wm.get(h);
-                        if (data) {
-                            data.registeredAs.push({
-                                path,
-                                args,
-                            });
-                        }
-                    },
-                });
-            }
-        }
-        return controllerOverview;
-    });
+async function bindControllerMethods(options) {
+    const opts = options || {};
+    const { getInstance } = opts;
+    const { classConstructor } = opts;
+    const { adapters } = opts;
+    opts.globalPrefix = opts.globalPrefix || '';
+    opts.provide = opts.provide || {};
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    const fakeInstance = Object.create(classConstructor.prototype);
+    const methods = getInstanceOwnMethods(fakeInstance);
+    const mate = getMoostMate();
+    const meta = mate.read(classConstructor) || {};
+    const ownPrefix = typeof opts.replaceOwnPrefix === 'string'
+        ? opts.replaceOwnPrefix
+        : meta.controller?.prefix || '';
+    const prefix = `${opts.globalPrefix}/${ownPrefix}`;
+    const controllerOverview = {
+        meta,
+        computedPrefix: prefix,
+        type: classConstructor,
+        handlers: [],
+    };
+    for (const method of methods) {
+        const methodMeta = getMoostMate().read(fakeInstance, method) || {};
+        methodMeta.handlers;
+        if (!methodMeta.handlers || !methodMeta.handlers.length)
+            continue;
+        const pipes = [...(opts.pipes || []), ...(methodMeta.pipes || [])].sort((a, b) => a.priority - b.priority);
+        // preparing interceptors
+        const interceptors = [
+            ...(opts.interceptors || []),
+            ...(meta.interceptors || []),
+            ...(methodMeta.interceptors || []),
+        ].sort((a, b) => a.priority - b.priority);
+        const getIterceptorHandler = getIterceptorHandlerFactory(interceptors, getInstance, pipes, options.logger);
+        // preparing pipes
+        const argsPipes = [];
+        for (const p of methodMeta.params || []) {
+            argsPipes.push({
+                meta: p,
+                pipes: [...pipes, ...(p.pipes || [])].sort((a, b) => a.priority - b.priority),
+            });
+        }
+        const resolveArgs = async () => {
+            const args = [];
+            const { restoreCtx } = eventCore.useEventContext();
+            for (let i = 0; i < argsPipes.length; i++) {
+                const { pipes, meta: paramMeta } = argsPipes[i];
+                args[i] = await runPipes(pipes, undefined, {
+                    classMeta: meta,
+                    methodMeta,
+                    paramMeta,
+                    type: classConstructor,
+                    key: method,
+                    index: i,
+                    targetMeta: paramMeta,
+                }, 'PARAM', restoreCtx);
+            }
+            return args;
+        };
+        const wm = new WeakMap();
+        controllerOverview.handlers.push(...methodMeta.handlers.map(h => {
+            const data = {
+                meta: methodMeta,
+                path: h.path,
+                type: h.type,
+                method,
+                handler: h,
+                registeredAs: [],
+            };
+            wm.set(h, data);
+            return data;
+        }));
+        for (const adapter of adapters) {
+            await adapter.bindHandler({
+                prefix,
+                fakeInstance,
+                getInstance,
+                method,
+                handlers: methodMeta.handlers,
+                getIterceptorHandler,
+                resolveArgs,
+                logHandler: (eventName) => options.logger.info(`• ${eventName} ${'' + '' + ''}→ ${classConstructor.name}.${''}${method}${''}()`),
+                register(h, path, args) {
+                    const data = wm.get(h);
+                    if (data) {
+                        data.registeredAs.push({
+                            path,
+                            args,
+                        });
+                    }
+                },
+            });
+        }
+    }
+    return controllerOverview;
 }
 
-/**
- * ## Label
- * ### @Decorator
- * _Common purpose decorator that may be used by various adapters for various purposes_
- *
- * Stores Label metadata
- */
-function Label(value) {
-    return getMoostMate().decorate('label', value);
-}
-/**
- * ## Description
- * ### @Decorator
- * _Common purpose decorator that may be used by various adapters for various purposes_
- *
- * Stores Description metadata
- */
-function Description(value) {
-    return getMoostMate().decorate('description', value);
-}
-/**
- * ## Value
- * ### @Decorator
- * _Common purpose decorator that may be used by various adapters for various purposes_
- *
- * Stores Value metadata
- */
-function Value(value) {
-    return getMoostMate().decorate('value', value);
-}
-/**
- * ## Id
- * ### @Decorator
- * _Common purpose decorator that may be used by various adapters for various purposes_
- *
- * Stores Id metadata
- */
-function Id(value) {
-    return getMoostMate().decorate('id', value);
-}
-/**
- * ## Optional
- * ### @Decorator
- * _Common purpose decorator that may be used by various adapters for various purposes_
- *
- * Stores Optional metadata
- */
-function Optional() {
-    return getMoostMate().decorate('optional', true);
-}
-/**
- * ## Required
- * ### @Decorator
- * _Common purpose decorator that may be used by various adapters for various purposes_
- *
- * Stores Required metadata
- */
-function Required() {
-    const mate = getMoostMate();
-    return mate.apply(mate.decorate('required', true), 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-    mate.decorateClass((meta, level, key, index) => {
-        if (typeof index !== 'number' &&
-            meta &&
-            ['string', 'symbol'].includes(typeof key)) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
-            meta.requiredProps = meta.requiredProps || [];
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
-            meta.requiredProps.push(key);
-        }
-        return meta;
-    }));
+/**
+ * ## Label
+ * ### @Decorator
+ * _Common purpose decorator that may be used by various adapters for various purposes_
+ *
+ * Stores Label metadata
+ */
+function Label(value) {
+    return getMoostMate().decorate('label', value);
+}
+/**
+ * ## Description
+ * ### @Decorator
+ * _Common purpose decorator that may be used by various adapters for various purposes_
+ *
+ * Stores Description metadata
+ */
+function Description(value) {
+    return getMoostMate().decorate('description', value);
+}
+/**
+ * ## Value
+ * ### @Decorator
+ * _Common purpose decorator that may be used by various adapters for various purposes_
+ *
+ * Stores Value metadata
+ */
+function Value(value) {
+    return getMoostMate().decorate('value', value);
+}
+/**
+ * ## Id
+ * ### @Decorator
+ * _Common purpose decorator that may be used by various adapters for various purposes_
+ *
+ * Stores Id metadata
+ */
+function Id(value) {
+    return getMoostMate().decorate('id', value);
+}
+/**
+ * ## Optional
+ * ### @Decorator
+ * _Common purpose decorator that may be used by various adapters for various purposes_
+ *
+ * Stores Optional metadata
+ */
+function Optional() {
+    return getMoostMate().decorate('optional', true);
+}
+/**
+ * ## Required
+ * ### @Decorator
+ * _Common purpose decorator that may be used by various adapters for various purposes_
+ *
+ * Stores Required metadata
+ */
+function Required() {
+    const mate = getMoostMate();
+    return mate.apply(mate.decorate('required', true), 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+    mate.decorateClass((meta, level, key, index) => {
+        if (typeof index !== 'number' &&
+            meta &&
+            ['string', 'symbol'].includes(typeof key)) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+            meta.requiredProps = meta.requiredProps || [];
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+            meta.requiredProps.push(key);
+        }
+        return meta;
+    }));
 }
 
-/**
- * Hook to the Response Status
- * @decorator
- * @param resolver - resolver function
- * @param label - field label
- * @paramType unknown
- */
-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);
-    };
-}
-/**
- * Get Param Value from url parh
- * @decorator
- * @param name - param name
- * @paramType string
- */
-function Param(name) {
-    return getMoostMate().apply(getMoostMate().decorate('paramSource', 'ROUTE'), getMoostMate().decorate('paramName', name), Resolve(() => eventCore.useRouteParams().get(name), name));
-}
-/**
- * Get Parsed Params from url parh
- * @decorator
- * @paramType object
- */
-function Params() {
-    return Resolve(() => eventCore.useRouteParams().params, 'params');
-}
-/**
- * Provide Const Value
- * @decorator
- * @param value - provided value
- * @param label - label of the field
- * @paramType unknown
- */
-function Const(value, label) {
-    return Resolve(() => value, label);
-}
-/**
- * Provide Const Value from Factory fn
- * @decorator
- * @param factory - value Factory fn
- * @param label - label of the field
- * @paramType unknown
- */
-function ConstFactory(factory, label) {
-    return Resolve(() => __awaiter(this, void 0, void 0, function* () { return yield factory(); }), label);
-}
-/**
- * Resolves event logger from event context
- * @param topic
- * @returns Resolver to '@wooksjs/event-core' (EventLogger)
- */
-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 === null || meta === void 0 ? void 0 : meta.params) ||
-                !(meta === null || meta === void 0 ? void 0 : meta.params[index]) ||
-                !(meta === null || meta === void 0 ? void 0 : meta.params[index].label)) {
-                Label(name)(target, key, index);
-            }
-        }
-        else {
-            if (!(meta === null || meta === void 0 ? void 0 : meta.label)) {
-                Label(name)(target, key);
-            }
-        }
-    }
+/**
+ * Hook to the Response Status
+ * @decorator
+ * @param resolver - resolver function
+ * @param label - field label
+ * @paramType unknown
+ */
+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);
+    };
+}
+/**
+ * Get Param Value from url parh
+ * @decorator
+ * @param name - param name
+ * @paramType string
+ */
+function Param(name) {
+    return getMoostMate().apply(getMoostMate().decorate('paramSource', 'ROUTE'), getMoostMate().decorate('paramName', name), Resolve(() => eventCore.useRouteParams().get(name), name));
+}
+/**
+ * Get Parsed Params from url parh
+ * @decorator
+ * @paramType object
+ */
+function Params() {
+    return Resolve(() => eventCore.useRouteParams().params, 'params');
+}
+/**
+ * Provide Const Value
+ * @decorator
+ * @param value - provided value
+ * @param label - label of the field
+ * @paramType unknown
+ */
+function Const(value, label) {
+    return Resolve(() => value, label);
+}
+/**
+ * Provide Const Value from Factory fn
+ * @decorator
+ * @param factory - value Factory fn
+ * @param label - label of the field
+ * @paramType unknown
+ */
+function ConstFactory(factory, label) {
+    return Resolve(async () => await factory(), label);
+}
+/**
+ * Resolves event logger from event context
+ * @param topic
+ * @returns Resolver to '@wooksjs/event-core' (EventLogger)
+ */
+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);
+            }
+        }
+    }
 }
 
-/**
- * ## 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
- */
-function Injectable(scope = true) {
-    return getMoostMate().decorate('injectable', scope);
-}
-const insureInjectable = getMoostMate().decorate((meta) => {
-    if (!meta.injectable)
-        meta.injectable = true;
-    return meta;
+/**
+ * ## 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
+ */
+function Injectable(scope = true) {
+    return getMoostMate().decorate('injectable', scope);
+}
+const insureInjectable = getMoostMate().decorate((meta) => {
+    if (!meta.injectable)
+        meta.injectable = true;
+    return meta;
 });
 
-/**
- * ## Controller
- * ### @Decorator
- * Set Class as a Controller
- * @param prefix - define the prefix for all the paths of this controller
- */
-function Controller(prefix) {
-    const mate = getMoostMate();
-    return mate.apply(insureInjectable, mate.decorate('controller', { prefix: prefix || '' }));
-}
-function ImportController(prefix, controller, provide) {
-    return getMoostMate().decorate('importController', {
-        prefix: typeof prefix === 'string' ? prefix : undefined,
-        typeResolver: typeof prefix === 'string'
-            ? controller
-            : prefix,
-        provide: typeof prefix === 'string'
-            ? provide || undefined
-            : controller || undefined,
-    }, true);
+/**
+ * ## Controller
+ * ### @Decorator
+ * Set Class as a Controller
+ * @param prefix - define the prefix for all the paths of this controller
+ */
+function Controller(prefix) {
+    const mate = getMoostMate();
+    return mate.apply(insureInjectable, mate.decorate('controller', { prefix: prefix || '' }));
+}
+function ImportController(prefix, controller, provide) {
+    return getMoostMate().decorate('importController', {
+        prefix: typeof prefix === 'string' ? prefix : undefined,
+        typeResolver: typeof prefix === 'string'
+            ? controller
+            : prefix,
+        provide: typeof prefix === 'string'
+            ? provide || undefined
+            : controller || undefined,
+    }, true);
 }
 
-function Circular(resolver) {
-    return getMoostMate().decorate('circular', resolver);
+function Circular(resolver) {
+    return getMoostMate().decorate('circular', resolver);
 }
 
-exports.TInterceptorPriority = void 0;
-(function (TInterceptorPriority) {
-    TInterceptorPriority[TInterceptorPriority["BEFORE_ALL"] = 0] = "BEFORE_ALL";
-    TInterceptorPriority[TInterceptorPriority["BEFORE_GUARD"] = 1] = "BEFORE_GUARD";
-    TInterceptorPriority[TInterceptorPriority["GUARD"] = 2] = "GUARD";
-    TInterceptorPriority[TInterceptorPriority["AFTER_GUARD"] = 3] = "AFTER_GUARD";
-    TInterceptorPriority[TInterceptorPriority["INTERCEPTOR"] = 4] = "INTERCEPTOR";
-    TInterceptorPriority[TInterceptorPriority["CATCH_ERROR"] = 5] = "CATCH_ERROR";
-    TInterceptorPriority[TInterceptorPriority["AFTER_ALL"] = 6] = "AFTER_ALL";
-})(exports.TInterceptorPriority || (exports.TInterceptorPriority = {}));
-/**
- * ## Intercept
- * ### @Decorator
- * Set interceptor
- * @param handler interceptor fn (use defineInterceptorFn)
- * @param priority interceptor priority
- * @returns
- */
-function Intercept(handler, priority) {
-    return getMoostMate().decorate('interceptors', {
-        handler,
-        priority: priority ||
-            handler.priority ||
-            exports.TInterceptorPriority.INTERCEPTOR,
-    }, true);
+exports.TInterceptorPriority = void 0;
+(function (TInterceptorPriority) {
+    TInterceptorPriority[TInterceptorPriority["BEFORE_ALL"] = 0] = "BEFORE_ALL";
+    TInterceptorPriority[TInterceptorPriority["BEFORE_GUARD"] = 1] = "BEFORE_GUARD";
+    TInterceptorPriority[TInterceptorPriority["GUARD"] = 2] = "GUARD";
+    TInterceptorPriority[TInterceptorPriority["AFTER_GUARD"] = 3] = "AFTER_GUARD";
+    TInterceptorPriority[TInterceptorPriority["INTERCEPTOR"] = 4] = "INTERCEPTOR";
+    TInterceptorPriority[TInterceptorPriority["CATCH_ERROR"] = 5] = "CATCH_ERROR";
+    TInterceptorPriority[TInterceptorPriority["AFTER_ALL"] = 6] = "AFTER_ALL";
+})(exports.TInterceptorPriority || (exports.TInterceptorPriority = {}));
+/**
+ * ## Intercept
+ * ### @Decorator
+ * Set interceptor
+ * @param handler interceptor fn (use defineInterceptorFn)
+ * @param priority interceptor priority
+ * @returns
+ */
+function Intercept(handler, priority) {
+    return getMoostMate().decorate('interceptors', {
+        handler,
+        priority: priority ||
+            handler.priority ||
+            exports.TInterceptorPriority.INTERCEPTOR,
+    }, true);
 }
 
-/**
- * ## Provide
- * ### @Decorator
- * Defines provide registry for class (and all the children)
- * @param type - string or class constructor
- * @param fn - factory function for provided value
- */
-function Provide(type, fn) {
-    return getMoostMate().decorate((meta) => {
-        meta.provide = meta.provide || {};
-        Object.assign(meta.provide, infact$1.createProvideRegistry([type, fn]));
-        return meta;
-    });
-}
-/**
- * ## Inject
- * ### @Decorator
- * Defines a key from provide registry to inject value
- * (For optional values use with @Optional())
- * @param type - string or class constructor
- */
-function Inject(type) {
-    return getMoostMate().decorate('inject', type);
+/**
+ * ## Provide
+ * ### @Decorator
+ * Defines provide registry for class (and all the children)
+ * @param type - string or class constructor
+ * @param fn - factory function for provided value
+ */
+function Provide(type, fn) {
+    return getMoostMate().decorate((meta) => {
+        meta.provide = meta.provide || {};
+        Object.assign(meta.provide, infact$1.createProvideRegistry([type, fn]));
+        return meta;
+    });
+}
+/**
+ * ## Inject
+ * ### @Decorator
+ * Defines a key from provide registry to inject value
+ * (For optional values use with @Optional())
+ * @param type - string or class constructor
+ */
+function Inject(type) {
+    return getMoostMate().decorate('inject', type);
 }
 
-/**
- * ## Inherit
- * ### @Decorator
- * Inherit metadata from super class
- * @returns
- */
+/**
+ * ## Inherit
+ * ### @Decorator
+ * Inherit metadata from super class
+ * @returns
+ */
 const Inherit = () => getMoostMate().decorate('inherit', true);
 
-exports.TPipePriority = void 0;
-(function (TPipePriority) {
-    TPipePriority[TPipePriority["BEFORE_RESOLVE"] = 0] = "BEFORE_RESOLVE";
-    TPipePriority[TPipePriority["RESOLVE"] = 1] = "RESOLVE";
-    TPipePriority[TPipePriority["AFTER_RESOLVE"] = 2] = "AFTER_RESOLVE";
-    TPipePriority[TPipePriority["BEFORE_TRANSFORM"] = 3] = "BEFORE_TRANSFORM";
-    TPipePriority[TPipePriority["TRANSFORM"] = 4] = "TRANSFORM";
-    TPipePriority[TPipePriority["AFTER_TRANSFORM"] = 5] = "AFTER_TRANSFORM";
-    TPipePriority[TPipePriority["BEFORE_VALIDATE"] = 6] = "BEFORE_VALIDATE";
-    TPipePriority[TPipePriority["VALIDATE"] = 7] = "VALIDATE";
-    TPipePriority[TPipePriority["AFTER_VALIDATE"] = 8] = "AFTER_VALIDATE";
+exports.TPipePriority = void 0;
+(function (TPipePriority) {
+    TPipePriority[TPipePriority["BEFORE_RESOLVE"] = 0] = "BEFORE_RESOLVE";
+    TPipePriority[TPipePriority["RESOLVE"] = 1] = "RESOLVE";
+    TPipePriority[TPipePriority["AFTER_RESOLVE"] = 2] = "AFTER_RESOLVE";
+    TPipePriority[TPipePriority["BEFORE_TRANSFORM"] = 3] = "BEFORE_TRANSFORM";
+    TPipePriority[TPipePriority["TRANSFORM"] = 4] = "TRANSFORM";
+    TPipePriority[TPipePriority["AFTER_TRANSFORM"] = 5] = "AFTER_TRANSFORM";
+    TPipePriority[TPipePriority["BEFORE_VALIDATE"] = 6] = "BEFORE_VALIDATE";
+    TPipePriority[TPipePriority["VALIDATE"] = 7] = "VALIDATE";
+    TPipePriority[TPipePriority["AFTER_VALIDATE"] = 8] = "AFTER_VALIDATE";
 })(exports.TPipePriority || (exports.TPipePriority = {}));
 
-/**
- * ## Pipe
- * ### @Decorator
- * Attach pipe
- * @param handler pipe handler
- * @param priority pipe priority
- * @returns
- */
-function Pipe(handler, priority) {
-    if (typeof priority !== 'number') {
-        priority =
-            typeof handler.priority === 'number'
-                ? handler.priority
-                : exports.TPipePriority.TRANSFORM;
-    }
-    return getMoostMate().decorate('pipes', { handler, priority }, true);
+/**
+ * ## Pipe
+ * ### @Decorator
+ * Attach pipe
+ * @param handler pipe handler
+ * @param priority pipe priority
+ * @returns
+ */
+function Pipe(handler, priority) {
+    if (typeof priority !== 'number') {
+        priority =
+            typeof handler.priority === 'number'
+                ? handler.priority
+                : exports.TPipePriority.TRANSFORM;
+    }
+    return getMoostMate().decorate('pipes', { handler, priority }, true);
 }
 
-/**
- * ### Define Interceptor Function
- *
- * ```ts
- * defineInterceptorFn((before, after, onError) => {
- *         //init
- *         before(() => {
- *              // before handler
- *         })
- *         after((response, reply) => {
- *              // after handler
- *         })
- *         onError((error, reply) => {
- *              // when error occured
- *         })
- *     },
- *     TInterceptorPriority.INTERCEPTOR,
- * )
- * ```
- *
- * @param fn interceptor function
- * @param priority priority of the interceptor where BEFORE_ALL = 0, BEFORE_GUARD = 1, GUARD = 2, AFTER_GUARD = 3, INTERCEPTOR = 4, CATCH_ERROR = 5, AFTER_ALL = 6
- * @returns
- */
-function defineInterceptorFn(fn, priority = exports.TInterceptorPriority.INTERCEPTOR) {
-    fn.priority = priority;
-    return fn;
-}
-/**
- * ### Define Pipe Function
- *
- * ```ts
- * // example of a transform pipe
- * const uppercaseTransformPipe = definePipeFn((value, metas, level) => {
- *         return typeof value === 'string' ? value.toUpperCase() : value
- *     },
- *     TPipePriority.TRANSFORM,
- * )
- * ```
- *
- * @param fn interceptor function
- * @param priority priority of the pipe where BEFORE_RESOLVE = 0, RESOLVE = 1, AFTER_RESOLVE = 2, BEFORE_TRANSFORM = 3, TRANSFORM = 4, AFTER_TRANSFORM = 5, BEFORE_VALIDATE = 6, VALIDATE = 7, AFTER_VALIDATE = 8
- * @returns
- */
-function definePipeFn(fn, priority = exports.TPipePriority.TRANSFORM) {
-    fn.priority = priority;
-    return fn;
+/**
+ * ### Define Interceptor Function
+ *
+ * ```ts
+ * defineInterceptorFn((before, after, onError) => {
+ *         //init
+ *         before(() => {
+ *              // before handler
+ *         })
+ *         after((response, reply) => {
+ *              // after handler
+ *         })
+ *         onError((error, reply) => {
+ *              // when error occured
+ *         })
+ *     },
+ *     TInterceptorPriority.INTERCEPTOR,
+ * )
+ * ```
+ *
+ * @param fn interceptor function
+ * @param priority priority of the interceptor where BEFORE_ALL = 0, BEFORE_GUARD = 1, GUARD = 2, AFTER_GUARD = 3, INTERCEPTOR = 4, CATCH_ERROR = 5, AFTER_ALL = 6
+ * @returns
+ */
+function defineInterceptorFn(fn, priority = exports.TInterceptorPriority.INTERCEPTOR) {
+    fn.priority = priority;
+    return fn;
+}
+/**
+ * ### Define Pipe Function
+ *
+ * ```ts
+ * // example of a transform pipe
+ * const uppercaseTransformPipe = definePipeFn((value, metas, level) => {
+ *         return typeof value === 'string' ? value.toUpperCase() : value
+ *     },
+ *     TPipePriority.TRANSFORM,
+ * )
+ * ```
+ *
+ * @param fn interceptor function
+ * @param priority priority of the pipe where BEFORE_RESOLVE = 0, RESOLVE = 1, AFTER_RESOLVE = 2, BEFORE_TRANSFORM = 3, TRANSFORM = 4, AFTER_TRANSFORM = 5, BEFORE_VALIDATE = 6, VALIDATE = 7, AFTER_VALIDATE = 8
+ * @returns
+ */
+function definePipeFn(fn, priority = exports.TPipePriority.TRANSFORM) {
+    fn.priority = priority;
+    return fn;
 }
 
-const resolvePipe = definePipeFn((_value, metas, level) => {
-    var _a;
-    const resolver = (_a = metas.targetMeta) === null || _a === void 0 ? void 0 : _a.resolver;
-    if (resolver) {
-        return resolver(metas, level);
-    }
-    return undefined;
+const resolvePipe = definePipeFn((_value, metas, level) => {
+    const resolver = metas.targetMeta?.resolver;
+    if (resolver) {
+        return resolver(metas, level);
+    }
+    return undefined;
 }, exports.TPipePriority.RESOLVE);
 
-const sharedPipes = [
-    {
-        handler: resolvePipe,
-        priority: exports.TPipePriority.RESOLVE,
-    },
+const sharedPipes = [
+    {
+        handler: resolvePipe,
+        priority: exports.TPipePriority.RESOLVE,
+    },
 ];
 
-function getDefaultLogger(topic) {
-    return new logger.ProstoLogger({
-        level: 4,
-        transports: [
-            logger.createConsoleTransort({
-                format: logger.coloredConsole,
-            }),
-        ],
-    }, topic);
+function getDefaultLogger(topic) {
+    return new logger.ProstoLogger({
+        level: 4,
+        transports: [
+            logger.createConsoleTransort({
+                format: logger.coloredConsole,
+            }),
+        ],
+    }, topic);
 }
 
-/**
- * ## Moost
- * Main moostjs class that serves as a shell for Moost Adapters
- *
- * ### Usage with HTTP Adapter
- * ```ts
- * │  // HTTP server example
- * │  import { MoostHttp, Get } from '@moostjs/event-http'
- * │  import { Moost, Param } from 'moost'
- * │
- * │  class MyServer extends Moost {
- * │      @Get('test/:name')
- * │      test(@Param('name') name: string) {
- * │          return { message: `Hello ${name}!` }
- * │      }
- * │  }
- * │
- * │  const app = new MyServer()
- * │  const http = new MoostHttp()
- * │  app.adapter(http).listen(3000, () => {
- * │      app.getLogger('MyApp').log('Up on port 3000')
- * │  })
- * │  app.init()
- * ```
- * ### Usage with CLI Adapter
- * ```ts
- * │  // CLI example
- * │  import { MoostCli, Cli, CliOption, cliHelpInterceptor } from '@moostjs/event-cli'
- * │  import { Moost, Param } from 'moost'
- * │
- * │  class MyApp extends Moost {
- * │      @Cli('command/:arg')
- * │      command(
- * │         @Param('arg')
- * │         arg: string,
- * │         @CliOption('test', 't')
- * │         test: boolean,
- * │      ) {
- * │          return `command run with flag arg=${ arg }, test=${ test }`
- * │      }
- * │  }
- * │
- * │  const app = new MyApp()
- * │  app.applyGlobalInterceptors(cliHelpInterceptor())
- * │
- * │  const cli = new MoostCli()
- * │  app.adapter(cli)
- * │  app.init()
- * ```
- */
-class Moost {
-    constructor(options) {
-        this.options = options;
-        this.pipes = [...sharedPipes];
-        this.interceptors = [];
-        this.adapters = [];
-        this.controllersOverview = [];
-        this.provide = infact$1.createProvideRegistry([infact$1.Infact, getMoostInfact], [mate$1.Mate, getMoostMate]);
-        this.unregisteredControllers = [];
-        this.logger = (options === null || options === void 0 ? void 0 : options.logger) || getDefaultLogger('moost');
-        getMoostInfact().setLogger(this.getLogger('infact'));
-        const mate = getMoostMate();
-        Object.assign(mate, { logger: this.getLogger('mate') });
-    }
-    /**
-     * ### getLogger
-     * Provides application logger
-     * ```js
-     * // get logger with topic = "App"
-     * const logger = app.getLogger('App')
-     * logger.log('...')
-     * ```
-     * @param topic
-     * @returns
-     */
-    getLogger(topic) {
-        if (this.logger instanceof logger.ProstoLogger) {
-            return this.logger.createTopic(topic);
-        }
-        return this.logger;
-    }
-    adapter(a) {
-        this.adapters.push(a);
-        return a;
-    }
-    getControllersOverview() {
-        return this.controllersOverview;
-    }
-    /**
-     * ### init
-     * Ititializes adapter. Must be called after adapters are attached.
-     */
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.setProvideRegistry(infact$1.createProvideRegistry([Moost, () => this], [logger.ProstoLogger, () => this.logger], ['MOOST_LOGGER', () => this.logger]));
-            for (const a of this.adapters) {
-                const constructor = mate$1.getConstructor(a);
-                if (constructor) {
-                    this.setProvideRegistry(infact$1.createProvideRegistry([
-                        constructor,
-                        () => a,
-                    ]));
-                }
-                if (typeof a.getProvideRegistry === 'function') {
-                    this.setProvideRegistry(a.getProvideRegistry());
-                }
-            }
-            this.unregisteredControllers.unshift(this);
-            yield this.bindControllers();
-            for (const a of this.adapters) {
-                yield (a.onInit && a.onInit(this));
-            }
-        });
-    }
-    bindControllers() {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const infact = getMoostInfact();
-            infact.setLogger(this.logger);
-            const meta = getMoostMate();
-            const thisMeta = meta.read(this);
-            const provide = Object.assign(Object.assign({}, ((thisMeta === null || thisMeta === void 0 ? void 0 : thisMeta.provide) || {})), this.provide);
-            for (const _controller of this.unregisteredControllers) {
-                let newPrefix = undefined;
-                let controller = _controller;
-                if (Array.isArray(_controller) && typeof _controller[0] === 'string') {
-                    newPrefix = _controller[0];
-                    controller = _controller[1];
-                }
-                yield this.bindController(controller, provide, ((_a = this.options) === null || _a === void 0 ? void 0 : _a.globalPrefix) || '', newPrefix);
-            }
-            this.unregisteredControllers = [];
-        });
-    }
-    bindController(controller, provide, globalPrefix, replaceOwnPrefix) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const mate = getMoostMate();
-            const classMeta = mate.read(controller);
-            const infact = getMoostInfact();
-            const isControllerConsructor = mate$1.isConstructor(controller);
-            const pipes = [...this.pipes, ...((classMeta === null || classMeta === void 0 ? void 0 : classMeta.pipes) || [])].sort((a, b) => a.priority - b.priority);
-            let instance;
-            const infactOpts = { provide, customData: { pipes } };
-            if (isControllerConsructor &&
-                ((classMeta === null || classMeta === void 0 ? void 0 : classMeta.injectable) === 'SINGLETON' ||
-                    (classMeta === null || classMeta === void 0 ? void 0 : classMeta.injectable) === true)) {
-                instance = (yield infact.get(controller, infactOpts));
-            }
-            else if (!isControllerConsructor) {
-                instance = controller;
-                infact.setProvideRegByInstance(instance, provide);
-            }
-            // getInstance - instance factory for resolving SINGLETON and FOR_EVENT instance
-            const getInstance = instance
-                ? () => Promise.resolve(instance)
-                : () => __awaiter(this, void 0, void 0, function* () {
-                    // if (!instance) {
-                    infact.silent(true);
-                    const { restoreCtx } = eventCore.useEventContext();
-                    const instance = (yield infact.get(controller, Object.assign(Object.assign({}, infactOpts), { syncContextFn: restoreCtx })));
-                    infact.silent(false);
-                    // }
-                    return instance;
-                });
-            const classConstructor = mate$1.isConstructor(controller)
-                ? controller
-                : mate$1.getConstructor(controller);
-            this.controllersOverview.push(yield bindControllerMethods({
-                getInstance,
-                classConstructor,
-                adapters: this.adapters,
-                globalPrefix,
-                replaceOwnPrefix,
-                interceptors: [...this.interceptors],
-                pipes,
-                provide: (classMeta === null || classMeta === void 0 ? void 0 : classMeta.provide) || {},
-                logger: this.logger,
-            }));
-            if (classMeta && classMeta.importController) {
-                const prefix = typeof replaceOwnPrefix === 'string'
-                    ? replaceOwnPrefix
-                    : (_a = classMeta === null || classMeta === void 0 ? void 0 : classMeta.controller) === null || _a === void 0 ? void 0 : _a.prefix;
-                const mergedProvide = Object.assign(Object.assign({}, provide), ((classMeta === null || classMeta === void 0 ? void 0 : classMeta.provide) || {}));
-                for (const ic of classMeta.importController) {
-                    if (ic.typeResolver) {
-                        const isConstr = mate$1.isConstructor(ic.typeResolver);
-                        const isFunc = typeof ic.typeResolver === 'function';
-                        yield this.bindController(
-                        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                        isConstr
-                            ? ic.typeResolver
-                            : isFunc
-                                ? yield ic.typeResolver()
-                                : ic.typeResolver, ic.provide
-                            ? Object.assign(Object.assign({}, mergedProvide), ic.provide) : mergedProvide, `${globalPrefix}/${prefix || ''}`, ic.prefix);
-                    }
-                }
-            }
-        });
-    }
-    applyGlobalPipes(...items) {
-        for (const item of items) {
-            if (typeof item === 'function') {
-                this.pipes.push({
-                    handler: item,
-                    priority: typeof item.priority === 'number'
-                        ? item.priority
-                        : exports.TPipePriority.TRANSFORM,
-                });
-            }
-            else {
-                this.pipes.push({
-                    handler: item.handler,
-                    priority: item.priority,
-                });
-            }
-        }
-        this.globalInterceptorHandler = undefined;
-        return this;
-    }
-    /**
-     * Provides InterceptorHandler with global interceptors and pipes.
-     * Used to process interceptors when event handler was not found.
-     *
-     * @returns IterceptorHandler
-     */
-    getGlobalInterceptorHandler() {
-        if (!this.globalInterceptorHandler) {
-            const mate = getMoostMate();
-            const thisMeta = mate.read(this);
-            const pipes = [...(this.pipes || []), ...((thisMeta === null || thisMeta === void 0 ? void 0 : thisMeta.pipes) || [])].sort((a, b) => a.priority - b.priority);
-            const interceptors = [...this.interceptors, ...((thisMeta === null || thisMeta === void 0 ? void 0 : thisMeta.interceptors) || [])]
-                .sort((a, b) => a.priority - b.priority);
-            this.globalInterceptorHandler = getIterceptorHandlerFactory(interceptors, () => Promise.resolve(this), pipes, this.logger);
-        }
-        return this.globalInterceptorHandler();
-    }
-    applyGlobalInterceptors(...items) {
-        for (const item of items) {
-            if (typeof item === 'function') {
-                this.interceptors.push({
-                    handler: item,
-                    priority: typeof item.priority === 'number'
-                        ? item
-                            .priority
-                        : exports.TInterceptorPriority.INTERCEPTOR,
-                });
-            }
-            else {
-                this.interceptors.push({
-                    handler: item.handler,
-                    priority: item.priority,
-                });
-            }
-        }
-        this.globalInterceptorHandler = undefined;
-        return this;
-    }
-    /**
-     * Register new entried to provide as dependency injections
-     * @param provide - Provide Registry (use createProvideRegistry from '\@prostojs/infact')
-     * @returns
-     */
-    setProvideRegistry(provide) {
-        this.provide = Object.assign(Object.assign({}, this.provide), provide);
-        return this;
-    }
-    /**
-     * Register controllers (similar to @ImportController decorator)
-     * @param controllers - list of target controllers (instances)
-     * @returns
-     */
-    registerControllers(...controllers) {
-        this.unregisteredControllers.push(...controllers);
-        return this;
-    }
+/**
+ * ## Moost
+ * Main moostjs class that serves as a shell for Moost Adapters
+ *
+ * ### Usage with HTTP Adapter
+ * ```ts
+ * │  // HTTP server example
+ * │  import { MoostHttp, Get } from '@moostjs/event-http'
+ * │  import { Moost, Param } from 'moost'
+ * │
+ * │  class MyServer extends Moost {
+ * │      @Get('test/:name')
+ * │      test(@Param('name') name: string) {
+ * │          return { message: `Hello ${name}!` }
+ * │      }
+ * │  }
+ * │
+ * │  const app = new MyServer()
+ * │  const http = new MoostHttp()
+ * │  app.adapter(http).listen(3000, () => {
+ * │      app.getLogger('MyApp').log('Up on port 3000')
+ * │  })
+ * │  app.init()
+ * ```
+ * ### Usage with CLI Adapter
+ * ```ts
+ * │  // CLI example
+ * │  import { MoostCli, Cli, CliOption, cliHelpInterceptor } from '@moostjs/event-cli'
+ * │  import { Moost, Param } from 'moost'
+ * │
+ * │  class MyApp extends Moost {
+ * │      @Cli('command/:arg')
+ * │      command(
+ * │         @Param('arg')
+ * │         arg: string,
+ * │         @CliOption('test', 't')
+ * │         test: boolean,
+ * │      ) {
+ * │          return `command run with flag arg=${ arg }, test=${ test }`
+ * │      }
+ * │  }
+ * │
+ * │  const app = new MyApp()
+ * │  app.applyGlobalInterceptors(cliHelpInterceptor())
+ * │
+ * │  const cli = new MoostCli()
+ * │  app.adapter(cli)
+ * │  app.init()
+ * ```
+ */
+class Moost {
+    constructor(options) {
+        this.options = options;
+        this.pipes = [...sharedPipes];
+        this.interceptors = [];
+        this.adapters = [];
+        this.controllersOverview = [];
+        this.provide = infact$1.createProvideRegistry([infact$1.Infact, getMoostInfact], [mate$1.Mate, getMoostMate]);
+        this.unregisteredControllers = [];
+        this.logger = options?.logger || getDefaultLogger('moost');
+        getMoostInfact().setLogger(this.getLogger('infact'));
+        const mate = getMoostMate();
+        Object.assign(mate, { logger: this.getLogger('mate') });
+    }
+    /**
+     * ### getLogger
+     * Provides application logger
+     * ```js
+     * // get logger with topic = "App"
+     * const logger = app.getLogger('App')
+     * logger.log('...')
+     * ```
+     * @param topic
+     * @returns
+     */
+    getLogger(topic) {
+        if (this.logger instanceof logger.ProstoLogger) {
+            return this.logger.createTopic(topic);
+        }
+        return this.logger;
+    }
+    adapter(a) {
+        this.adapters.push(a);
+        return a;
+    }
+    getControllersOverview() {
+        return this.controllersOverview;
+    }
+    /**
+     * ### init
+     * Ititializes adapter. Must be called after adapters are attached.
+     */
+    async init() {
+        this.setProvideRegistry(infact$1.createProvideRegistry([Moost, () => this], [logger.ProstoLogger, () => this.logger], ['MOOST_LOGGER', () => this.logger]));
+        for (const a of this.adapters) {
+            const constructor = mate$1.getConstructor(a);
+            if (constructor) {
+                this.setProvideRegistry(infact$1.createProvideRegistry([
+                    constructor,
+                    () => a,
+                ]));
+            }
+            if (typeof a.getProvideRegistry === 'function') {
+                this.setProvideRegistry(a.getProvideRegistry());
+            }
+        }
+        this.unregisteredControllers.unshift(this);
+        await this.bindControllers();
+        for (const a of this.adapters) {
+            await (a.onInit && a.onInit(this));
+        }
+    }
+    async bindControllers() {
+        const infact = getMoostInfact();
+        infact.setLogger(this.logger);
+        const meta = getMoostMate();
+        const thisMeta = meta.read(this);
+        const provide = { ...(thisMeta?.provide || {}), ...this.provide };
+        for (const _controller of this.unregisteredControllers) {
+            let newPrefix = undefined;
+            let controller = _controller;
+            if (Array.isArray(_controller) && typeof _controller[0] === 'string') {
+                newPrefix = _controller[0];
+                controller = _controller[1];
+            }
+            await this.bindController(controller, provide, this.options?.globalPrefix || '', newPrefix);
+        }
+        this.unregisteredControllers = [];
+    }
+    async bindController(controller, provide, globalPrefix, replaceOwnPrefix) {
+        const mate = getMoostMate();
+        const classMeta = mate.read(controller);
+        const infact = getMoostInfact();
+        const isControllerConsructor = mate$1.isConstructor(controller);
+        const pipes = [...this.pipes, ...(classMeta?.pipes || [])].sort((a, b) => a.priority - b.priority);
+        let instance;
+        const infactOpts = { provide, customData: { pipes } };
+        if (isControllerConsructor &&
+            (classMeta?.injectable === 'SINGLETON' ||
+                classMeta?.injectable === true)) {
+            instance = (await infact.get(controller, infactOpts));
+        }
+        else if (!isControllerConsructor) {
+            instance = controller;
+            infact.setProvideRegByInstance(instance, provide);
+        }
+        // getInstance - instance factory for resolving SINGLETON and FOR_EVENT instance
+        const getInstance = instance
+            ? () => Promise.resolve(instance)
+            : async () => {
+                // if (!instance) {
+                infact.silent(true);
+                const { restoreCtx } = eventCore.useEventContext();
+                const instance = (await infact.get(controller, { ...infactOpts, syncContextFn: restoreCtx }));
+                infact.silent(false);
+                // }
+                return instance;
+            };
+        const classConstructor = mate$1.isConstructor(controller)
+            ? controller
+            : mate$1.getConstructor(controller);
+        this.controllersOverview.push(await bindControllerMethods({
+            getInstance,
+            classConstructor,
+            adapters: this.adapters,
+            globalPrefix,
+            replaceOwnPrefix,
+            interceptors: [...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 || {}) };
+            for (const ic of classMeta.importController) {
+                if (ic.typeResolver) {
+                    const isConstr = mate$1.isConstructor(ic.typeResolver);
+                    const isFunc = typeof ic.typeResolver === 'function';
+                    await this.bindController(
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                    isConstr
+                        ? ic.typeResolver
+                        : isFunc
+                            ? await ic.typeResolver()
+                            : ic.typeResolver, ic.provide
+                        ? { ...mergedProvide, ...ic.provide }
+                        : mergedProvide, `${globalPrefix}/${prefix || ''}`, ic.prefix);
+                }
+            }
+        }
+    }
+    applyGlobalPipes(...items) {
+        for (const item of items) {
+            if (typeof item === 'function') {
+                this.pipes.push({
+                    handler: item,
+                    priority: typeof item.priority === 'number'
+                        ? item.priority
+                        : exports.TPipePriority.TRANSFORM,
+                });
+            }
+            else {
+                this.pipes.push({
+                    handler: item.handler,
+                    priority: item.priority,
+                });
+            }
+        }
+        this.globalInterceptorHandler = undefined;
+        return this;
+    }
+    /**
+     * Provides InterceptorHandler with global interceptors and pipes.
+     * Used to process interceptors when event handler was not found.
+     *
+     * @returns IterceptorHandler
+     */
+    getGlobalInterceptorHandler() {
+        if (!this.globalInterceptorHandler) {
+            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);
+            this.globalInterceptorHandler = getIterceptorHandlerFactory(interceptors, () => Promise.resolve(this), pipes, this.logger);
+        }
+        return this.globalInterceptorHandler();
+    }
+    applyGlobalInterceptors(...items) {
+        for (const item of items) {
+            if (typeof item === 'function') {
+                this.interceptors.push({
+                    handler: item,
+                    priority: typeof item.priority === 'number'
+                        ? item
+                            .priority
+                        : exports.TInterceptorPriority.INTERCEPTOR,
+                });
+            }
+            else {
+                this.interceptors.push({
+                    handler: item.handler,
+                    priority: item.priority,
+                });
+            }
+        }
+        this.globalInterceptorHandler = undefined;
+        return this;
+    }
+    /**
+     * Register new entried to provide as dependency injections
+     * @param provide - Provide Registry (use createProvideRegistry from '\@prostojs/infact')
+     * @returns
+     */
+    setProvideRegistry(provide) {
+        this.provide = { ...this.provide, ...provide };
+        return this;
+    }
+    /**
+     * Register controllers (similar to @ImportController decorator)
+     * @param controllers - list of target controllers (instances)
+     * @returns
+     */
+    registerControllers(...controllers) {
+        this.unregisteredControllers.push(...controllers);
+        return this;
+    }
 }
 
-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');
-    // todo: add generic types to getControllerMeta
-    const getControllerMeta = () => getMoostMate().read(getController());
-    // todo: add generic types to getMethodMeta
-    const getMethodMeta = (name) => getMoostMate().read(getController(), name || getMethod());
-    function instantiate(c) {
-        return getMoostInfact().getForInstance(getController(), c);
-    }
-    return {
-        instantiate,
-        getController,
-        getMethod,
-        getControllerMeta,
-        getMethodMeta,
-        getPropertiesList: () => { var _a; return ((_a = getControllerMeta()) === null || _a === void 0 ? void 0 : _a.properties) || []; },
-        getScope: () => { var _a; return ((_a = getControllerMeta()) === null || _a === void 0 ? void 0 : _a.injectable) || 'SINGLETON'; },
-        getParamsMeta: () => { var _a; return ((_a = getMethodMeta()) === null || _a === void 0 ? void 0 : _a.params) || []; },
-        getPropMeta: (name) => getMethodMeta(name),
-    };
+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');
+    // todo: add generic types to getControllerMeta
+    const getControllerMeta = () => getMoostMate().read(getController());
+    // todo: add generic types to getMethodMeta
+    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 () => __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        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 ((_a = options.hooks) === null || _a === void 0 ? void 0 : _a.init) {
-            yield options.hooks.init(hookOptions);
-            restoreCtx();
-        }
-        const instance = yield options.getControllerInstance();
-        restoreCtx();
-        if (instance) {
-            setControllerContext(instance, options.controllerMethod || '');
-        }
-        const interceptorHandler = yield options.getIterceptorHandler();
-        if (interceptorHandler) {
-            restoreCtx();
-            try {
-                response = yield 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) {
-            // params
-            restoreCtx();
-            try {
-                // logger.trace(`resolving method args for "${ opts.method as string }"`)
-                args = yield options.resolveArgs();
-                // logger.trace(`args for method "${ opts.method as string }" resolved (count ${String(args.length)})`)
-            }
-            catch (e) {
-                options.logErrors && logger.error(e);
-                response = e;
-                return endWithResponse(true);
-            }
-        }
-        if (interceptorHandler) {
-            restoreCtx();
-            response = yield interceptorHandler.fireBefore(response);
-            if (typeof response !== 'undefined')
-                return endWithResponse();
-        }
-        // fire request handler
-        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);
-        }
-        function endWithResponse(raise = false) {
-            var _a;
-            return __awaiter(this, void 0, void 0, function* () {
-                // fire after interceptors
-                if (interceptorHandler) {
-                    restoreCtx();
-                    try {
-                        // logger.trace('firing after interceptors')
-                        response = yield interceptorHandler.fireAfter(response);
-                    }
-                    catch (e) {
-                        options.logErrors && logger.error(e);
-                        if (!options.manualUnscope) {
-                            unscope();
-                        }
-                        throw e;
-                    }
-                }
-                if (!options.manualUnscope) {
-                    unscope();
-                }
-                if ((_a = options.hooks) === null || _a === void 0 ? void 0 : _a.end) {
-                    yield options.hooks.end(hookOptions);
-                }
-                if (raise) {
-                    throw response;
-                }
-                return response;
-            });
-        }
-        return yield endWithResponse();
-    });
+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) {
+            // params
+            restoreCtx();
+            try {
+                // logger.trace(`resolving method args for "${ opts.method as string }"`)
+                args = await options.resolveArgs();
+                // logger.trace(`args for method "${ opts.method as string }" resolved (count ${String(args.length)})`)
+            }
+            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();
+        }
+        // fire request handler
+        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) {
+            // fire after interceptors
+            if (interceptorHandler) {
+                restoreCtx();
+                try {
+                    // logger.trace('firing after interceptors')
+                    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', {
+Object.defineProperty(exports, "createProvideRegistry", {
     enumerable: true,
     get: function () { return infact$1.createProvideRegistry; }
 });
-Object.defineProperty(exports, 'EventLogger', {
+Object.defineProperty(exports, "EventLogger", {
     enumerable: true,
     get: function () { return eventCore.EventLogger; }
 });
-Object.defineProperty(exports, 'useEventContext', {
+Object.defineProperty(exports, "useEventContext", {
     enumerable: true,
     get: function () { return eventCore.useEventContext; }
 });
-Object.defineProperty(exports, 'useEventLogger', {
+Object.defineProperty(exports, "useEventLogger", {
     enumerable: true,
     get: function () { return eventCore.useEventLogger; }
 });