moost 0.2.26 → 0.2.28

package/dist/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-var mate = require('@prostojs/mate');
-var infact = require('@prostojs/infact');
+var mate$1 = require('@prostojs/mate');
+var infact$1 = require('@prostojs/infact');
 var eventCore = require('@wooksjs/event-core');
 var valido$1 = require('@prostojs/valido');
 var logger = require('@prostojs/logger');
@@ -20,6 +20,8 @@ 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); }); }
@@ -32,7 +34,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
 }
 
 const METADATA_WORKSPACE = 'moost';
-const moostMate = new mate.Mate(METADATA_WORKSPACE, {
+const moostMate = new mate$1.Mate(METADATA_WORKSPACE, {
     readType: true,
     readReturnType: true,
     collectPropKeys: true,
@@ -41,7 +43,7 @@ const moostMate = new mate.Mate(METADATA_WORKSPACE, {
             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) || !!((classMeta === null || classMeta === void 0 ? void 0 : classMeta.inherit) && !targetMeta));
         }
         return !!(targetMeta === null || targetMeta === void 0 ? void 0 : targetMeta.inherit);
     },
@@ -66,7 +68,7 @@ function getMoostInfact() {
     return sharedMoostInfact;
 }
 function getNewMoostInfact() {
-    return new infact.Infact({
+    return new infact$1.Infact({
         describeClass(classConstructor) {
             const meta = getMoostMate().read(classConstructor);
             const infactMeta = {
@@ -75,22 +77,32 @@ function getNewMoostInfact() {
                 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,
+                scopeId: (meta === null || meta === void 0 ? void 0 : meta.injectable) === 'FOR_EVENT'
+                    ? eventCore.useEventId().getId()
+                    : undefined,
             };
             return infactMeta;
         },
         resolveParam({ paramMeta, classMeta, customData }) {
             if (paramMeta && customData && customData.pipes) {
-                return runPipes(customData.pipes, undefined, { paramMeta, classMeta: classMeta }, 'PARAM');
+                return runPipes(customData.pipes, undefined, {
+                    paramMeta,
+                    classMeta: classMeta,
+                }, 'PARAM');
             }
         },
         describeProp(classConstructor, key) {
             const meta = getMoostMate().read(classConstructor, key);
             return meta;
         },
-        resolveProp({ instance, key, initialValue, propMeta, classMeta, customData }) {
+        resolveProp({ instance, key, initialValue, propMeta, classMeta, customData, }) {
             if (propMeta && customData && customData.pipes) {
-                return runPipes(customData.pipes, initialValue, { instance, key, propMeta, classMeta: classMeta }, 'PROP');
+                return runPipes(customData.pipes, initialValue, {
+                    instance,
+                    key,
+                    propMeta,
+                    classMeta: classMeta,
+                }, 'PROP');
             }
         },
         storeProvideRegByInstance: true,
@@ -101,31 +113,41 @@ function getInstanceOwnMethods(instance) {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const proto = Object.getPrototypeOf(instance);
     return [
-        ...getParentProps(mate.getConstructor(instance)),
+        ...getParentProps(mate$1.getConstructor(instance)),
         ...Object.getOwnPropertyNames(proto),
         ...Object.getOwnPropertyNames(instance),
-    ].filter(m => typeof instance[m] === 'function');
+    ].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)];
+    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$1 = getMoostMate();
-        const meta = mate$1.read(fn);
+        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) },
-            });
+            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);
@@ -134,7 +156,7 @@ function getCallableFn(targetInstance, fn, restoreCtx, pipes, logger) {
         if (typeof fn === 'function') {
             return fn;
         }
-        const e = new Error(`getCallableFn failed for "${mate.getConstructor(targetInstance).name}" because the passed arg is not a Function nor TClassFunction`);
+        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;
     });
@@ -157,7 +179,15 @@ class InterceptorHandler {
             const { restoreCtx } = eventCore.useEventContext();
             for (const handler of this.handlers) {
                 restoreCtx();
-                yield handler((fn) => { this.before.push(fn); }, (fn) => { this.after.unshift(fn); }, (fn) => { this.onError.unshift(fn); });
+                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;
             }
         });
     }
@@ -195,6 +225,28 @@ class InterceptorHandler {
     }
 }
 
+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));
+    };
+}
+
 function bindControllerMethods(options) {
     var _a;
     return __awaiter(this, void 0, void 0, function* () {
@@ -209,7 +261,9 @@ function bindControllerMethods(options) {
         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 ownPrefix = typeof opts.replaceOwnPrefix === 'string'
+            ? opts.replaceOwnPrefix
+            : ((_a = meta.controller) === null || _a === void 0 ? void 0 : _a.prefix) || '';
         const prefix = `${opts.globalPrefix}/${ownPrefix}`;
         for (const method of methods) {
             const methodMeta = getMoostMate().read(fakeInstance, method) || {};
@@ -217,25 +271,12 @@ function bindControllerMethods(options) {
                 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 = () => {
-                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 getInstance();
-                            restoreCtx();
-                            return (yield getCallableFn(targetInstance, handler, restoreCtx, pipes, options.logger))(...args);
-                        }));
-                    }
-                    else {
-                        interceptorHandlers.push(handler);
-                    }
-                }
-                return Promise.resolve(new InterceptorHandler(interceptorHandlers));
-            };
+            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 || []) {
@@ -264,11 +305,6 @@ function bindControllerMethods(options) {
                     prefix,
                     fakeInstance,
                     getInstance,
-                    registerEventScope: (scopeId) => {
-                        const infact = getMoostInfact();
-                        infact.registerScope(scopeId);
-                        return () => infact.unregisterScope(scopeId);
-                    },
                     method,
                     handlers: methodMeta.handlers,
                     getIterceptorHandler,
@@ -280,21 +316,71 @@ function bindControllerMethods(options) {
     });
 }
 
+/**
+ * ## 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)) {
+        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
@@ -314,7 +400,7 @@ function Required() {
 function Resolve(resolver, label) {
     return (target, key, index) => {
         const i = typeof index === 'number' ? index : undefined;
-        fillLabel(target, key, i, label);
+        fillLabel(target, key || '', i, label);
         getMoostMate().decorate('resolver', resolver)(target, key, i);
     };
 }
@@ -325,7 +411,7 @@ function Resolve(resolver, label) {
  * @paramType string
  */
 function Param(name) {
-    return Resolve(() => eventCore.useRouteParams().get(name), name);
+    return getMoostMate().apply(getMoostMate().decorate('isRouteParam', name), Resolve(() => eventCore.useRouteParams().get(name), name));
 }
 /**
  * Get Parsed Params from url parh
@@ -367,7 +453,9 @@ 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)) {
+            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);
             }
         }
@@ -380,8 +468,9 @@ function fillLabel(target, key, index, name) {
 }
 
 /**
+ * ## Injectable
+ * ### @Decorator
  * Mark the Class as Injectable to enable it to be used in dependency injection
- * @decorator
  * @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
@@ -397,8 +486,9 @@ const insureInjectable = getMoostMate().decorate((meta) => {
 });
 
 /**
+ * ## Controller
+ * ### @Decorator
  * Set Class as a Controller
- * @decorator
  * @param prefix - define the prefix for all the paths of this controller
  */
 function Controller(prefix) {
@@ -408,8 +498,12 @@ function Controller(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,
+        typeResolver: typeof prefix === 'string'
+            ? controller
+            : prefix,
+        provide: typeof prefix === 'string'
+            ? provide || undefined
+            : controller || undefined,
     }, true);
 }
 
@@ -427,26 +521,40 @@ exports.TInterceptorPriority = void 0;
     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,
+        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 => {
+    return getMoostMate().decorate((meta) => {
         meta.provide = meta.provide || {};
-        Object.assign(meta.provide, infact.createProvideRegistry([type, fn]));
+        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 @Nullable())
  * @param type - string or class constructor
@@ -455,6 +563,8 @@ function Inject(type) {
     return getMoostMate().decorate('inject', type);
 }
 /**
+ * ## Nullable
+ * ### @Decorator
  * Makes injectable value optional
  * @param value default true
  */
@@ -496,6 +606,12 @@ function IsBoolean(...args) {
     return Validate(valido$1.validoIsBoolean(...args));
 }
 
+/**
+ * ## Inherit
+ * ### @Decorator
+ * Inherit metadata from super class
+ * @returns
+ */
 const Inherit = () => getMoostMate().decorate('inherit', true);
 
 exports.TPipePriority = void 0;
@@ -511,7 +627,202 @@ exports.TPipePriority = void 0;
     TPipePriority[TPipePriority["AFTER_VALIDATE"] = 8] = "AFTER_VALIDATE";
 })(exports.TPipePriority || (exports.TPipePriority = {}));
 
-const resolvePipe = (_value, metas, level) => {
+const genericTypesCastPipe = (strict) => {
+    const handler = (value, { paramMeta: meta }) => {
+        if (meta === null || meta === void 0 ? void 0 : meta.type) {
+            if ((value === undefined ||
+                value === null ||
+                (meta.type !== String && value === '')) &&
+                meta.optional) {
+                return undefined;
+            }
+            switch (meta.type) {
+                case Date: {
+                    let d;
+                    if (typeof value === 'string') {
+                        d = new Date(/^\d+$/.test(value) ? Number(value) : value);
+                    }
+                    else {
+                        d = new Date(value);
+                    }
+                    if (strict && Number.isNaN(d.getTime())) {
+                        typeError(value, 'Date', meta.label);
+                    }
+                    return Number.isNaN(d.getTime()) ? value : d;
+                }
+                case Boolean:
+                    if ([
+                        true,
+                        'true',
+                        'TRUE',
+                        'True',
+                        1,
+                        '1',
+                        'X',
+                        'x',
+                    ].includes(value)) {
+                        return true;
+                    }
+                    if ([
+                        false,
+                        'false',
+                        'FALSE',
+                        'False',
+                        0,
+                        '0',
+                        '',
+                        ' ',
+                        null,
+                        undefined,
+                    ].includes(value)) {
+                        return false;
+                    }
+                    if (strict) {
+                        typeError(value, 'boolean', meta.label);
+                    }
+                    return value;
+                case Number: {
+                    if (strict && !value && value !== 0) {
+                        typeError(value, 'numeric', meta.label);
+                    }
+                    const n = typeof value === 'string' && value.length > 0
+                        ? Number(value)
+                        : NaN;
+                    if (strict && Number.isNaN(n)) {
+                        typeError(value, 'numeric', meta.label);
+                    }
+                    return Number.isNaN(n) ? value : n;
+                }
+                case String:
+                    if (strict &&
+                        ['object', 'function'].includes(typeof value)) {
+                        typeError(value, 'string', meta.label);
+                    }
+                    return (value && String(value)) || value;
+                default:
+                    return value;
+            }
+        }
+    };
+    handler.priority = exports.TPipePriority.AFTER_TRANSFORM;
+    return handler;
+};
+function typeError(value, targetType, label) {
+    const prefix = label ? `Argument "${label}" with value ` : '';
+    throw new Error(`${prefix}${JSON.stringify(value)} is not a ${targetType} type`);
+}
+
+const valido = new valido$1.Valido({
+    getDtoMeta(value, _type) {
+        let type = _type;
+        if (!type) {
+            type = mate$1.getConstructor(value);
+        }
+        const mate = getMoostMate();
+        return mate.read(type);
+    },
+    getDtoParamMeta(value, type, key) {
+        const mate = getMoostMate();
+        return mate.read(type, key);
+    },
+});
+function getMoostValido() {
+    return valido;
+}
+
+const DEFAULT_ERROR_LIMIT = 10;
+function firstString(errors) {
+    const keys = Object.keys(errors);
+    for (const key of keys) {
+        if (typeof errors[key] === 'string')
+            return errors[key];
+        return firstString(errors[key]);
+    }
+    return '';
+}
+const validatePipe = (opts) => {
+    const pipe = (_value, metas, level) => __awaiter(void 0, void 0, void 0, function* () {
+        const { restoreCtx } = eventCore.useEventContext();
+        const valido = getMoostValido();
+        let meta = {};
+        if (level === 'PARAM') {
+            meta = metas.paramMeta || {};
+        }
+        else if (level === 'PROP') {
+            meta = metas.propMeta || {};
+        }
+        else if (level === 'METHOD') {
+            meta = metas.methodMeta || {};
+        }
+        else if (level === 'CLASS') {
+            meta = metas.classMeta || {};
+        }
+        const result = yield valido.validateParam(_value, meta, metas.key, undefined, metas.instance, undefined, 0, 0, (opts === null || opts === void 0 ? void 0 : opts.errorLimit) || DEFAULT_ERROR_LIMIT, restoreCtx);
+        if (result !== true) {
+            const message = typeof result === 'string' ? result : firstString(result);
+            if (opts === null || opts === void 0 ? void 0 : opts.errorCb) {
+                opts.errorCb(message, result);
+            }
+            else {
+                throw new Error('Validation error: ' + message);
+            }
+        }
+        return _value;
+    });
+    pipe.priority = exports.TPipePriority.VALIDATE;
+    return pipe;
+};
+
+/**
+ * ### 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, _b, _c, _d;
     let resolver;
     if (level === 'PARAM') {
@@ -530,8 +841,7 @@ const resolvePipe = (_value, metas, level) => {
         return resolver(metas, level);
     }
     return undefined;
-};
-resolvePipe.priority = exports.TPipePriority.RESOLVE;
+}, exports.TPipePriority.RESOLVE);
 
 const sharedPipes = [
     {
@@ -540,24 +850,6 @@ const sharedPipes = [
     },
 ];
 
-const valido = new valido$1.Valido({
-    getDtoMeta(value, _type) {
-        let type = _type;
-        if (!type) {
-            type = mate.getConstructor(value);
-        }
-        const mate$1 = getMoostMate();
-        return mate$1.read(type);
-    },
-    getDtoParamMeta(value, type, key) {
-        const mate = getMoostMate();
-        return mate.read(type, key);
-    },
-});
-function getMoostValido() {
-    return valido;
-}
-
 function getDefaultLogger(topic) {
     return new logger.ProstoLogger({
         level: 4,
@@ -569,19 +861,80 @@ function getDefaultLogger(topic) {
     }, 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.provide = infact.createProvideRegistry([infact.Infact, getMoostInfact], [mate.Mate, getMoostMate], [valido$1.Valido, getMoostValido]);
+        this.provide = infact$1.createProvideRegistry([infact$1.Infact, getMoostInfact], [mate$1.Mate, getMoostMate], [valido$1.Valido, getMoostValido]);
         this.unregisteredControllers = [];
         this.logger = (options === null || options === void 0 ? void 0 : options.logger) || getDefaultLogger('moost');
         getMoostInfact().setLogger(this.getLogger('infact'));
-        const mate$1 = getMoostMate();
-        Object.assign(mate$1, { logger: this.getLogger('mate') });
+        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);
@@ -592,13 +945,20 @@ class Moost {
         this.adapters.push(a);
         return a;
     }
+    /**
+     * ### init
+     * Ititializes adapter. Must be called after adapters are attached.
+     */
     init() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.setProvideRegistry(infact.createProvideRegistry([Moost, () => this]));
+            this.setProvideRegistry(infact$1.createProvideRegistry([Moost, () => this]));
             for (const a of this.adapters) {
-                const constructor = mate.getConstructor(a);
+                const constructor = mate$1.getConstructor(a);
                 if (constructor) {
-                    this.setProvideRegistry(infact.createProvideRegistry([constructor, () => a]));
+                    this.setProvideRegistry(infact$1.createProvideRegistry([
+                        constructor,
+                        () => a,
+                    ]));
                 }
                 if (typeof a.getProvideRegistry === 'function') {
                     this.setProvideRegistry(a.getProvideRegistry());
@@ -607,7 +967,7 @@ class Moost {
             this.unregisteredControllers.unshift(this);
             yield this.bindControllers();
             for (const a of this.adapters) {
-                yield (a.onInit && a.onInit());
+                yield (a.onInit && a.onInit(this));
             }
         });
     }
@@ -628,14 +988,16 @@ class Moost {
     bindController(controller, provide, globalPrefix, replaceOwnPrefix) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const mate$1 = getMoostMate();
-            const classMeta = mate$1.read(controller);
+            const mate = getMoostMate();
+            const classMeta = mate.read(controller);
             const infact = getMoostInfact();
-            const isControllerConsructor = mate.isConstructor(controller);
+            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)) {
+            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) {
@@ -643,16 +1005,20 @@ class Moost {
                 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.isConstructor(controller) ? controller : mate.getConstructor(controller);
+            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);
             yield bindControllerMethods({
                 getInstance,
                 classConstructor,
@@ -665,15 +1031,22 @@ class Moost {
                 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 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.isConstructor(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);
+                        isConstr
+                            ? ic.typeResolver
+                            : isFunc
+                                ? yield ic.typeResolver()
+                                : ic.typeResolver, ic.provide
+                            ? Object.assign(Object.assign({}, mergedProvide), ic.provide) : mergedProvide, `${globalPrefix}/${prefix || ''}`, ic.prefix);
                     }
                 }
             }
@@ -684,7 +1057,9 @@ 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 {
@@ -694,14 +1069,35 @@ class Moost {
                 });
             }
         }
+        this.globalInterceptorHandler = undefined;
         return this;
     }
+    /**
+     * Provides InterceptorHandler with global interceptors and pipes.
+     * Used to process interceptors when event handler was not found.
+     *
+     * @returns array of interceptors
+     */
+    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,
+                    priority: typeof item.priority === 'number'
+                        ? item
+                            .priority
+                        : exports.TInterceptorPriority.INTERCEPTOR,
                 });
             }
             else {
@@ -711,6 +1107,7 @@ class Moost {
                 });
             }
         }
+        this.globalInterceptorHandler = undefined;
         return this;
     }
     /**
@@ -733,112 +1130,148 @@ class Moost {
     }
 }
 
-const genericTypesCastPipe = (strict) => {
-    const handler = (value, { paramMeta: meta }) => {
-        if (meta === null || meta === void 0 ? void 0 : meta.type) {
-            if ((value === undefined || value === null || (meta.type !== String && value === '')) && meta.optional) {
-                return undefined;
-            }
-            switch (meta.type) {
-                case Date: {
-                    let d;
-                    if (typeof value === 'string') {
-                        d = new Date(/^\d+$/.test(value) ? Number(value) : value);
-                    }
-                    else {
-                        d = new Date(value);
-                    }
-                    if (strict && Number.isNaN(d.getTime())) {
-                        typeError(value, 'Date', meta.label);
-                    }
-                    return Number.isNaN(d.getTime()) ? value : d;
-                }
-                case Boolean:
-                    if ([true, 'true', 'TRUE', 'True', 1, '1', 'X', 'x'].includes(value)) {
-                        return true;
-                    }
-                    if ([false, 'false', 'FALSE', 'False', 0, '0', '', ' ', null, undefined].includes(value)) {
-                        return false;
-                    }
-                    if (strict) {
-                        typeError(value, 'boolean', meta.label);
-                    }
-                    return value;
-                case Number: {
-                    if (strict && !value && value !== 0) {
-                        typeError(value, 'numeric', meta.label);
-                    }
-                    const n = typeof value === 'string' && value.length > 0 ? Number(value) : NaN;
-                    if (strict && Number.isNaN(n)) {
-                        typeError(value, 'numeric', meta.label);
-                    }
-                    return Number.isNaN(n) ? value : n;
-                }
-                case String:
-                    if (strict && ['object', 'function'].includes(typeof value)) {
-                        typeError(value, 'string', meta.label);
-                    }
-                    return value && String(value) || value;
-                default:
-                    return value;
-            }
-        }
+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 = () => getMoostMate().read(getController(), getMethod());
+    return {
+        getController,
+        getMethod,
+        getControllerMeta,
+        getMethodMeta,
     };
-    handler.priority = exports.TPipePriority.AFTER_TRANSFORM;
-    return handler;
-};
-function typeError(value, targetType, label) {
-    const prefix = label ? `Argument "${label}" with value ` : '';
-    throw new Error(`${prefix}${JSON.stringify(value)} is not a ${targetType} type`);
 }
 
-const DEFAULT_ERROR_LIMIT = 10;
-function firstString(errors) {
-    const keys = Object.keys(errors);
-    for (const key of keys) {
-        if (typeof errors[key] === 'string')
-            return errors[key];
-        return firstString(errors[key]);
-    }
-    return '';
+const infact = getMoostInfact();
+function registerEventScope(scopeId) {
+    infact.registerScope(scopeId);
+    return () => infact.unregisterScope(scopeId);
 }
-const validatePipe = (opts) => {
-    const pipe = (_value, metas, level) => __awaiter(void 0, void 0, void 0, function* () {
-        const { restoreCtx } = eventCore.useEventContext();
-        const valido = getMoostValido();
-        let meta = {};
-        if (level === 'PARAM') {
-            meta = metas.paramMeta || {};
+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();
         }
-        else if (level === 'PROP') {
-            meta = metas.propMeta || {};
+        const instance = yield options.getControllerInstance();
+        restoreCtx();
+        if (instance) {
+            setControllerContext(instance, options.controllerMethod || '');
         }
-        else if (level === 'METHOD') {
-            meta = metas.methodMeta || {};
+        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();
+            }
         }
-        else if (level === 'CLASS') {
-            meta = metas.classMeta || {};
+        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();
+            }
         }
-        const result = yield valido.validateParam(_value, meta, metas.key, undefined, metas.instance, undefined, 0, 0, (opts === null || opts === void 0 ? void 0 : opts.errorLimit) || DEFAULT_ERROR_LIMIT, restoreCtx);
-        if (result !== true) {
-            const message = typeof result === 'string' ? result : firstString(result);
-            if (opts === null || opts === void 0 ? void 0 : opts.errorCb) {
-                opts.errorCb(message, result);
+        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 {
-                throw new Error('Validation error: ' + message);
+            else if (instance && options.controllerMethod && typeof instance[options.controllerMethod] === 'function') {
+                return instance[options.controllerMethod](...args);
             }
+        };
+        try {
+            response = callControllerMethod();
         }
-        return _value;
+        catch (e) {
+            options.logErrors && logger.error(e);
+            response = e;
+        }
+        function endWithResponse() {
+            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);
+                }
+                return response;
+            });
+        }
+        return yield endWithResponse();
     });
-    pipe.priority = exports.TPipePriority.VALIDATE;
-    return pipe;
-};
+}
 
 exports.Circular = Circular;
 exports.Const = Const;
 exports.ConstFactory = ConstFactory;
 exports.Controller = Controller;
+exports.Description = Description;
 exports.Dto = Dto;
 exports.Id = Id;
 exports.ImportController = ImportController;
@@ -863,9 +1296,16 @@ exports.Provide = Provide;
 exports.Required = Required;
 exports.Resolve = Resolve;
 exports.Validate = Validate;
+exports.Value = Value;
+exports.defineInterceptorFn = defineInterceptorFn;
+exports.defineMoostEventHandler = defineMoostEventHandler;
+exports.definePipeFn = definePipeFn;
 exports.genericTypesCastPipe = genericTypesCastPipe;
 exports.getMoostInfact = getMoostInfact;
 exports.getMoostMate = getMoostMate;
 exports.getNewMoostInfact = getNewMoostInfact;
+exports.registerEventScope = registerEventScope;
 exports.resolvePipe = resolvePipe;
+exports.setControllerContext = setControllerContext;
+exports.useControllerContext = useControllerContext;
 exports.validatePipe = validatePipe;