moost 0.0.1 → 0.2.1

package/dist/index.cjs

@@ -0,0 +1,913 @@
+'use strict';
+
+var eventCore = require('@wooksjs/event-core');
+require('url');
+require('stream');
+require('wooks');
+require('http');
+var mate = require('@prostojs/mate');
+var infact = require('@prostojs/infact');
+var valido$1 = require('@prostojs/valido');
+
+/******************************************************************************
+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.
+***************************************************************************** */
+
+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());
+    });
+}
+
+function useHttpContext() {
+    return eventCore.useEventContext('HTTP');
+}
+
+const httpStatusCodes = {
+    [100]: 'Continue',
+    [101]: 'Switching protocols',
+    [102]: 'Processing',
+    [103]: 'Early Hints',
+    [200]: 'OK',
+    [201]: 'Created',
+    [202]: 'Accepted',
+    [203]: 'Non-Authoritative Information',
+    [204]: 'No Content',
+    [205]: 'Reset Content',
+    [206]: 'Partial Content',
+    [207]: 'Multi-Status',
+    [208]: 'Already Reported',
+    [226]: 'IM Used',
+    [300]: 'Multiple Choices',
+    [301]: 'Moved Permanently',
+    [302]: 'Found (Previously "Moved Temporarily")',
+    [303]: 'See Other',
+    [304]: 'Not Modified',
+    [305]: 'Use Proxy',
+    [306]: 'Switch Proxy',
+    [307]: 'Temporary Redirect',
+    [308]: 'Permanent Redirect',
+    [400]: 'Bad Request',
+    [401]: 'Unauthorized',
+    [402]: 'Payment Required',
+    [403]: 'Forbidden',
+    [404]: 'Not Found',
+    [405]: 'Method Not Allowed',
+    [406]: 'Not Acceptable',
+    [407]: 'Proxy Authentication Required',
+    [408]: 'Request Timeout',
+    [409]: 'Conflict',
+    [410]: 'Gone',
+    [411]: 'Length Required',
+    [412]: 'Precondition Failed',
+    [413]: 'Payload Too Large',
+    [414]: 'URI Too Long',
+    [415]: 'Unsupported Media Type',
+    [416]: 'Range Not Satisfiable',
+    [417]: 'Expectation Failed',
+    [418]: 'I\'m a Teapot',
+    [421]: 'Misdirected Request',
+    [422]: 'Unprocessable Entity',
+    [423]: 'Locked',
+    [424]: 'Failed Dependency',
+    [425]: 'Too Early',
+    [426]: 'Upgrade Required',
+    [428]: 'Precondition Required',
+    [429]: 'Too Many Requests',
+    [431]: 'Request Header Fields Too Large',
+    [451]: 'Unavailable For Legal Reasons',
+    [500]: 'Internal Server Error',
+    [501]: 'Not Implemented',
+    [502]: 'Bad Gateway',
+    [503]: 'Service Unavailable',
+    [504]: 'Gateway Timeout',
+    [505]: 'HTTP Version Not Supported',
+    [506]: 'Variant Also Negotiates',
+    [507]: 'Insufficient Storage',
+    [508]: 'Loop Detected',
+    [510]: 'Not Extended',
+    [511]: 'Network Authentication Required',
+};
+var EHttpStatusCode;
+(function (EHttpStatusCode) {
+    EHttpStatusCode[EHttpStatusCode["Continue"] = 100] = "Continue";
+    EHttpStatusCode[EHttpStatusCode["SwitchingProtocols"] = 101] = "SwitchingProtocols";
+    EHttpStatusCode[EHttpStatusCode["Processing"] = 102] = "Processing";
+    EHttpStatusCode[EHttpStatusCode["EarlyHints"] = 103] = "EarlyHints";
+    EHttpStatusCode[EHttpStatusCode["OK"] = 200] = "OK";
+    EHttpStatusCode[EHttpStatusCode["Created"] = 201] = "Created";
+    EHttpStatusCode[EHttpStatusCode["Accepted"] = 202] = "Accepted";
+    EHttpStatusCode[EHttpStatusCode["NonAuthoritativeInformation"] = 203] = "NonAuthoritativeInformation";
+    EHttpStatusCode[EHttpStatusCode["NoContent"] = 204] = "NoContent";
+    EHttpStatusCode[EHttpStatusCode["ResetContent"] = 205] = "ResetContent";
+    EHttpStatusCode[EHttpStatusCode["PartialContent"] = 206] = "PartialContent";
+    EHttpStatusCode[EHttpStatusCode["MultiStatus"] = 207] = "MultiStatus";
+    EHttpStatusCode[EHttpStatusCode["AlreadyReported"] = 208] = "AlreadyReported";
+    EHttpStatusCode[EHttpStatusCode["IMUsed"] = 226] = "IMUsed";
+    EHttpStatusCode[EHttpStatusCode["MultipleChoices"] = 300] = "MultipleChoices";
+    EHttpStatusCode[EHttpStatusCode["MovedPermanently"] = 301] = "MovedPermanently";
+    EHttpStatusCode[EHttpStatusCode["Found"] = 302] = "Found";
+    EHttpStatusCode[EHttpStatusCode["SeeOther"] = 303] = "SeeOther";
+    EHttpStatusCode[EHttpStatusCode["NotModified"] = 304] = "NotModified";
+    EHttpStatusCode[EHttpStatusCode["UseProxy"] = 305] = "UseProxy";
+    EHttpStatusCode[EHttpStatusCode["SwitchProxy"] = 306] = "SwitchProxy";
+    EHttpStatusCode[EHttpStatusCode["TemporaryRedirect"] = 307] = "TemporaryRedirect";
+    EHttpStatusCode[EHttpStatusCode["PermanentRedirect"] = 308] = "PermanentRedirect";
+    EHttpStatusCode[EHttpStatusCode["BadRequest"] = 400] = "BadRequest";
+    EHttpStatusCode[EHttpStatusCode["Unauthorized"] = 401] = "Unauthorized";
+    EHttpStatusCode[EHttpStatusCode["PaymentRequired"] = 402] = "PaymentRequired";
+    EHttpStatusCode[EHttpStatusCode["Forbidden"] = 403] = "Forbidden";
+    EHttpStatusCode[EHttpStatusCode["NotFound"] = 404] = "NotFound";
+    EHttpStatusCode[EHttpStatusCode["MethodNotAllowed"] = 405] = "MethodNotAllowed";
+    EHttpStatusCode[EHttpStatusCode["NotAcceptable"] = 406] = "NotAcceptable";
+    EHttpStatusCode[EHttpStatusCode["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
+    EHttpStatusCode[EHttpStatusCode["RequestTimeout"] = 408] = "RequestTimeout";
+    EHttpStatusCode[EHttpStatusCode["Conflict"] = 409] = "Conflict";
+    EHttpStatusCode[EHttpStatusCode["Gone"] = 410] = "Gone";
+    EHttpStatusCode[EHttpStatusCode["LengthRequired"] = 411] = "LengthRequired";
+    EHttpStatusCode[EHttpStatusCode["PreconditionFailed"] = 412] = "PreconditionFailed";
+    EHttpStatusCode[EHttpStatusCode["PayloadTooLarge"] = 413] = "PayloadTooLarge";
+    EHttpStatusCode[EHttpStatusCode["URITooLong"] = 414] = "URITooLong";
+    EHttpStatusCode[EHttpStatusCode["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
+    EHttpStatusCode[EHttpStatusCode["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
+    EHttpStatusCode[EHttpStatusCode["ExpectationFailed"] = 417] = "ExpectationFailed";
+    EHttpStatusCode[EHttpStatusCode["ImATeapot"] = 418] = "ImATeapot";
+    EHttpStatusCode[EHttpStatusCode["MisdirectedRequest"] = 421] = "MisdirectedRequest";
+    EHttpStatusCode[EHttpStatusCode["UnprocessableEntity"] = 422] = "UnprocessableEntity";
+    EHttpStatusCode[EHttpStatusCode["Locked"] = 423] = "Locked";
+    EHttpStatusCode[EHttpStatusCode["FailedDependency"] = 424] = "FailedDependency";
+    EHttpStatusCode[EHttpStatusCode["TooEarly"] = 425] = "TooEarly";
+    EHttpStatusCode[EHttpStatusCode["UpgradeRequired"] = 426] = "UpgradeRequired";
+    EHttpStatusCode[EHttpStatusCode["PreconditionRequired"] = 428] = "PreconditionRequired";
+    EHttpStatusCode[EHttpStatusCode["TooManyRequests"] = 429] = "TooManyRequests";
+    EHttpStatusCode[EHttpStatusCode["RequestHeaderFieldsTooLarge"] = 431] = "RequestHeaderFieldsTooLarge";
+    EHttpStatusCode[EHttpStatusCode["UnavailableForLegalReasons"] = 451] = "UnavailableForLegalReasons";
+    EHttpStatusCode[EHttpStatusCode["InternalServerError"] = 500] = "InternalServerError";
+    EHttpStatusCode[EHttpStatusCode["NotImplemented"] = 501] = "NotImplemented";
+    EHttpStatusCode[EHttpStatusCode["BadGateway"] = 502] = "BadGateway";
+    EHttpStatusCode[EHttpStatusCode["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+    EHttpStatusCode[EHttpStatusCode["GatewayTimeout"] = 504] = "GatewayTimeout";
+    EHttpStatusCode[EHttpStatusCode["HTTPVersionNotSupported"] = 505] = "HTTPVersionNotSupported";
+    EHttpStatusCode[EHttpStatusCode["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
+    EHttpStatusCode[EHttpStatusCode["InsufficientStorage"] = 507] = "InsufficientStorage";
+    EHttpStatusCode[EHttpStatusCode["LoopDetected"] = 508] = "LoopDetected";
+    EHttpStatusCode[EHttpStatusCode["NotExtended"] = 510] = "NotExtended";
+    EHttpStatusCode[EHttpStatusCode["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
+})(EHttpStatusCode || (EHttpStatusCode = {}));
+
+({
+    GET: EHttpStatusCode.OK,
+    POST: EHttpStatusCode.Created,
+    PUT: EHttpStatusCode.Created,
+    PATCH: EHttpStatusCode.Accepted,
+    DELETE: EHttpStatusCode.Accepted,
+});
+
+class WooksError extends Error {
+    constructor(code = 500, _body = '') {
+        super(typeof _body === 'string' ? _body : _body.message);
+        this.code = code;
+        this._body = _body;
+    }
+    get body() {
+        return typeof this._body === 'string' ? {
+            statusCode: this.code,
+            message: this.message,
+            error: httpStatusCodes[this.code],
+        } : Object.assign(Object.assign({}, this._body), { statusCode: this.code, message: this.message, error: httpStatusCodes[this.code] });
+    }
+    attachRenderer(renderer) {
+        this.renderer = renderer;
+    }
+    getRenderer() {
+        return this.renderer;
+    }
+}
+
+const METADATA_WORKSPACE = 'moost';
+const moostMate = new mate.Mate(METADATA_WORKSPACE, {
+    readType: true,
+    readReturnType: true,
+});
+function getMoostMate() {
+    return moostMate;
+}
+
+function getInstanceOwnMethods(instance) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const proto = Object.getPrototypeOf(instance);
+    return [
+        ...Object.getOwnPropertyNames(proto),
+        ...Object.getOwnPropertyNames(instance),
+    ].filter(m => typeof instance[m] === 'function');
+}
+
+const banner = () => `[${"moost"}][${new Date().toISOString().replace('T', ' ').replace(/\.\d{3}z$/i, '')}] `;
+
+/* istanbul ignore file */
+function log(text) {
+    console.log('' + '' + banner() + text + '');
+}
+function logError(error) {
+    console.error('' + '' + banner() + error + '');
+}
+
+function panic(error) {
+    logError(error);
+    return new Error(error);
+}
+
+function runPipes(pipes, meta, restoreCtx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let v = undefined;
+        for (const pipe of pipes) {
+            restoreCtx && restoreCtx();
+            v = yield pipe.handler(v, meta);
+        }
+        return v;
+    });
+}
+
+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 = {}));
+
+const resolvePipe = (_value, meta) => {
+    if (meta === null || meta === void 0 ? void 0 : meta.resolver) {
+        return meta.resolver();
+    }
+    return undefined;
+};
+resolvePipe.priority = exports.TPipePriority.RESOLVE;
+
+const sharedPipes = [
+    {
+        handler: resolvePipe,
+        priority: exports.TPipePriority.RESOLVE,
+    },
+];
+
+const sharedMoostInfact = getNewMoostInfact();
+function getMoostInfact() {
+    return sharedMoostInfact;
+}
+function getNewMoostInfact() {
+    return new infact.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,
+                scopeId: (meta === null || meta === void 0 ? void 0 : meta.injectable) === 'FOR_EVENT' ? eventCore.useEventId().getId() : undefined,
+            };
+            return infactMeta;
+        },
+        resolveParam(paramMeta) {
+            if (paramMeta.resolver) {
+                return runPipes(sharedPipes, paramMeta);
+            }
+        },
+        storeProvideRegByInstance: true,
+    });
+}
+
+function getCallableFn(targetInstance, fn, restoreCtx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const mate$1 = getMoostMate();
+        const meta = mate$1.read(fn);
+        if (meta === null || meta === void 0 ? void 0 : meta.injectable) {
+            const infact = getMoostInfact();
+            infact.silent(meta.injectable === 'FOR_EVENT');
+            const instance = yield infact.getForInstance(targetInstance, fn, [], () => { restoreCtx && restoreCtx(); });
+            infact.silent(false);
+            return ((...args) => {
+                return instance.handler(...args);
+            });
+        }
+        if (typeof fn === 'function') {
+            return fn;
+        }
+        throw panic(`getCallableFn failed for "${mate.getConstructor(targetInstance).name}" because the passed arg is not a Function nor TClassFunction`);
+    });
+}
+
+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();
+                yield handler((fn) => { this.before.push(fn); }, (fn) => { this.after.unshift(fn); }, (fn) => { this.onError.unshift(fn); });
+            }
+        });
+    }
+    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;
+        });
+    }
+}
+
+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}`;
+        for (const method of methods) {
+            const methodMeta = getMoostMate().read(fakeInstance, method) || {};
+            if (!methodMeta.handlers || !methodMeta.handlers.length)
+                continue;
+            // preparing interceptors
+            const interceptors = [...(opts.interceptors || []), ...(meta.interceptors || []), ...(methodMeta.interceptors || [])].sort((a, b) => a.priority - b.priority);
+            const getIterceptorHandler = () => __awaiter(this, void 0, void 0, function* () {
+                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 } = useHttpContext();
+                            const targetInstance = yield getInstance();
+                            restoreCtx();
+                            return (yield getCallableFn(targetInstance, handler, restoreCtx))(...args);
+                        }));
+                    }
+                    else {
+                        interceptorHandlers.push(handler);
+                    }
+                }
+                return new InterceptorHandler(interceptorHandlers);
+            });
+            // preparing pipes
+            const pipes = [...(opts.pipes || []), ...(meta.pipes || []), ...(methodMeta.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 } = argsPipes[i];
+                    args[i] = yield runPipes(pipes, meta, restoreCtx);
+                }
+                return args;
+            });
+            // preparing provide
+            // const provide = {...(opts.provide || {}), ...(meta.provide || {})}
+            for (const adapter of adapters) {
+                yield adapter.bindHandler({
+                    prefix,
+                    fakeInstance,
+                    getInstance,
+                    registerEventScope: (scopeId) => {
+                        const infact = getMoostInfact();
+                        infact.registerScope(scopeId);
+                        return () => infact.unregisterScope(scopeId);
+                    },
+                    method,
+                    handlers: methodMeta.handlers,
+                    getIterceptorHandler,
+                    resolveArgs,
+                    logHandler: (eventName) => log(`• ${eventName} ${'' + '' + ''}→ ${classConstructor.name}.${''}${method}${''}()`),
+                });
+            }
+        }
+    });
+}
+
+function Label(value) {
+    return getMoostMate().decorate('label', value);
+}
+function Id(value) {
+    return getMoostMate().decorate('id', value);
+}
+function Optional() {
+    return getMoostMate().decorate('optional', true);
+}
+function Required() {
+    const mate = getMoostMate();
+    return mate.apply(mate.decorate('required', true), 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+    mate.decorateClass((meta, 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) => {
+        fillLabel(target, key, index, label);
+        getMoostMate().decorate('resolver', resolver)(target, key, index);
+    };
+}
+/**
+ * Get Param Value from url parh
+ * @decorator
+ * @param name - param name
+ * @paramType string
+ */
+function Param(name) {
+    return 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);
+}
+function fillLabel(target, key, index, name) {
+    if (name) {
+        const meta = getMoostMate().read(target, key);
+        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);
+        }
+    }
+}
+
+/**
+ * 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
+ * @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;
+});
+
+/**
+ * Set Class as a Controller
+ * @decorator
+ * @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);
+}
+
+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 = {}));
+function Intercept(handler, priority) {
+    return getMoostMate().decorate('interceptors', {
+        handler,
+        priority: priority || handler.priority || exports.TInterceptorPriority.INTERCEPTOR,
+    }, true);
+}
+
+function Provide(type, fn) {
+    return getMoostMate().decorate(meta => {
+        meta.provide = meta.provide || {};
+        Object.assign(meta.provide, infact.createProvideRegistry([type, fn]));
+        return meta;
+    });
+}
+function Inject(type) {
+    return getMoostMate().decorate('inject', type);
+}
+
+function Dto(dtoOptions = {}) {
+    return getMoostMate().decorate('dto', dtoOptions || {});
+}
+let isArrayItemValidator = false;
+function Validate(validator) {
+    return getMoostMate().decorate(isArrayItemValidator ? 'validatorsOfItem' : 'validators', validator, true);
+}
+function IsArray(opts) {
+    const mate = getMoostMate();
+    const decorators = [mate.decorate('arrayType', opts || true)];
+    if ((opts === null || opts === void 0 ? void 0 : opts.itemValidators) && !isArrayItemValidator) {
+        isArrayItemValidator = true;
+        decorators.push(...opts.itemValidators());
+        isArrayItemValidator = false;
+    }
+    else if ((opts === null || opts === void 0 ? void 0 : opts.itemValidators) && isArrayItemValidator) {
+        throw new Error('IsArray validator is not supported inside of array type');
+    }
+    const decorator = mate.apply(...decorators);
+    return decorator;
+}
+function IsTypeOf(type, errorText) {
+    return Validate(valido$1.validoIsTypeOf(type, errorText));
+}
+function IsString(...args) {
+    return Validate(valido$1.validoIsString(...args));
+}
+function IsNumber(...args) {
+    return Validate(valido$1.validoIsNumber(...args));
+}
+function IsBoolean(...args) {
+    return Validate(valido$1.validoIsBoolean(...args));
+}
+
+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;
+}
+
+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.unregisteredControllers = [];
+    }
+    adapter(a) {
+        this.adapters.push(a);
+        return a;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.setProvideRegistry(infact.createProvideRegistry([Moost, () => this]));
+            this.unregisteredControllers.unshift(this);
+            yield this.bindControllers();
+            for (const a of this.adapters) {
+                yield (a.onInit && a.onInit());
+            }
+        });
+    }
+    bindControllers() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            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) {
+                yield this.bindController(controller, provide, ((_a = this.options) === null || _a === void 0 ? void 0 : _a.globalPrefix) || '');
+            }
+            this.unregisteredControllers = [];
+        });
+    }
+    bindController(controller, provide, globalPrefix, replaceOwnPrefix) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const meta = getMoostMate();
+            const classMeta = meta.read(controller);
+            const infact = getMoostInfact();
+            const isControllerConsructor = mate.isConstructor(controller);
+            let instance;
+            if (isControllerConsructor && (classMeta === null || classMeta === void 0 ? void 0 : classMeta.injectable) === 'SINGLETON') {
+                instance = (yield infact.get(controller, provide));
+            }
+            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();
+                const instance = yield infact.get(controller, provide);
+                infact.silent(false);
+                // }
+                return instance;
+            });
+            const classConstructor = mate.isConstructor(controller) ? controller : mate.getConstructor(controller);
+            yield bindControllerMethods({
+                getInstance,
+                classConstructor,
+                adapters: this.adapters,
+                globalPrefix,
+                replaceOwnPrefix,
+                interceptors: [...this.interceptors],
+                pipes: [...this.pipes],
+                provide: (classMeta === null || classMeta === void 0 ? void 0 : classMeta.provide) || {},
+            });
+            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.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,
+                });
+            }
+        }
+        return this;
+    }
+    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,
+                });
+            }
+        }
+        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;
+    }
+}
+
+function useControllerMeta() {
+    const moostStore = useMoostStore();
+    return {
+        getClassMeta: () => getMoostMate().read(moostStore.value.controller),
+        getMethodMeta: () => getMoostMate().read(moostStore.value.controller, moostStore.value.method),
+    };
+}
+function useMoostStore() {
+    return useHttpContext().store('moost');
+}
+
+const genericTypesCastPipe = (strict) => {
+    const handler = (value, 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 WooksError(400, `${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 validatePipe = (opts) => {
+    const pipe = (_value, meta) => __awaiter(void 0, void 0, void 0, function* () {
+        const { restoreCtx } = useHttpContext();
+        const valido = getMoostValido();
+        const result = yield valido.validateParam(_value, meta, undefined, undefined, undefined, undefined, 0, 0, (opts === null || opts === void 0 ? void 0 : opts.errorLimit) || DEFAULT_ERROR_LIMIT, restoreCtx);
+        if (result !== true) {
+            throw new WooksError(400, {
+                statusCode: 400,
+                message: typeof result === 'string' ? result : firstString(result),
+                error: 'Validation Error',
+                details: result,
+            });
+        }
+        return _value;
+    });
+    pipe.priority = exports.TPipePriority.VALIDATE;
+    return pipe;
+};
+
+exports.Circular = Circular;
+exports.Const = Const;
+exports.Controller = Controller;
+exports.Dto = Dto;
+exports.Id = Id;
+exports.ImportController = ImportController;
+exports.Inject = Inject;
+exports.Injectable = Injectable;
+exports.Intercept = Intercept;
+exports.InterceptorHandler = InterceptorHandler;
+exports.IsArray = IsArray;
+exports.IsBoolean = IsBoolean;
+exports.IsNumber = IsNumber;
+exports.IsString = IsString;
+exports.IsTypeOf = IsTypeOf;
+exports.Label = Label;
+exports.Moost = Moost;
+exports.Optional = Optional;
+exports.Param = Param;
+exports.Params = Params;
+exports.Provide = Provide;
+exports.Required = Required;
+exports.Resolve = Resolve;
+exports.Validate = Validate;
+exports.genericTypesCastPipe = genericTypesCastPipe;
+exports.getMoostMate = getMoostMate;
+exports.resolvePipe = resolvePipe;
+exports.useControllerMeta = useControllerMeta;
+exports.validatePipe = validatePipe;