moost 0.0.1-beta.5 → 0.2.0

package/dist/moost.esm-bundler.js

@@ -1,869 +0,0 @@
-import { Wooks } from 'wooks';
-import { useCacheStore, useRequest, useWooksCtx, useStatus, useSetHeader, useSetCookie, useAuthorization, useHeaders, useCookies, useRouteParams, useSearchParams, useResponse, WooksError } from '@wooksjs/composables';
-import { Mate, getConstructor, isConstructor } from '@prostojs/mate';
-import { Infact, createProvideRegistry } from '@prostojs/infact';
-import { validoIsTypeOf, validoIsString, validoIsNumber, validoIsBoolean, Valido } from '@prostojs/valido';
-import { useBody } from '@wooksjs/body';
-
-const METADATA_WORKSPACE = 'moost';
-const moostMate = new Mate(METADATA_WORKSPACE, {
-    readType: true,
-    readReturnType: true,
-});
-function getMoostMate() {
-    return moostMate;
-}
-
-const STORE = Symbol('__moost__');
-function useControllerMeta() {
-    const { get } = useMoostStore();
-    return {
-        getClassMeta: () => getMoostMate().read(get('controller')),
-        getMethodMeta: () => getMoostMate().read(get('controller'), get('method')),
-    };
-}
-function setComposableControllerContext(data) {
-    const { set } = useMoostStore();
-    set('controller', data.controller);
-    set('method', data.method);
-    set('pathBuilder', data.pathBuilder);
-}
-function useMoostStore() {
-    return useCacheStore(STORE);
-}
-
-async function runPipes(pipes, meta, restoreCtx) {
-    let v = undefined;
-    for (const pipe of pipes) {
-        restoreCtx && restoreCtx();
-        v = await pipe.handler(v, meta);
-    }
-    return v;
-}
-
-var TPipePriority;
-(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";
-})(TPipePriority || (TPipePriority = {}));
-
-const resolvePipe = (_value, meta) => {
-    if (meta?.resolver) {
-        return meta.resolver();
-    }
-    return undefined;
-};
-resolvePipe.priority = TPipePriority.RESOLVE;
-
-const sharedPipes = [
-    {
-        handler: resolvePipe,
-        priority: TPipePriority.RESOLVE,
-    },
-];
-
-const sharedMoostInfact = getNewMoostInfact();
-function getMoostInfact() {
-    return sharedMoostInfact;
-}
-function getNewMoostInfact() {
-    return new Infact({
-        describeClass(classConstructor) {
-            const meta = getMoostMate().read(classConstructor);
-            const infactMeta = {
-                injectable: !!meta?.injectable,
-                global: false,
-                constructorParams: meta?.params || [],
-                provide: meta?.provide,
-                scopeId: meta?.injectable === 'FOR_REQUEST' ? useRequest().reqId() : undefined,
-            };
-            return infactMeta;
-        },
-        resolveParam(paramMeta) {
-            if (paramMeta.resolver) {
-                return runPipes(sharedPipes, paramMeta);
-            }
-        },
-        storeProvideRegByInstance: true,
-    });
-}
-
-function bindHandler(getInstance, method, wooksApp, options) {
-    const pathBuilder = wooksApp.on(options.httpMethod, options.path, async () => {
-        const { restoreCtx } = useWooksCtx();
-        const { reqId, rawRequest } = useRequest();
-        const infact = getMoostInfact();
-        const scopeId = reqId();
-        infact.registerScope(scopeId);
-        rawRequest.on('end', () => infact.unregisterScope(scopeId));
-        const instance = await getInstance();
-        restoreCtx();
-        setComposableControllerContext({
-            controller: instance,
-            method: method,
-            pathBuilder: pathBuilder,
-        });
-        let response;
-        let responseOverwritten = false;
-        const before = [];
-        const after = [];
-        const onError = [];
-        function replyFn(reply) {
-            response = reply;
-            responseOverwritten = true;
-        }
-        // init interceptors
-        for (const handler of options.interceptorHandlers) {
-            restoreCtx();
-            await handler((fn) => { before.push(fn); }, (fn) => { after.unshift(fn); }, (fn) => { onError.unshift(fn); });
-        }
-        // params
-        let args = [];
-        try {
-            restoreCtx();
-            args = await applyPipesToArgs(options.argsPipes);
-        }
-        catch (e) {
-            response = e;
-        }
-        if (!response) {
-            // fire before interceptors
-            for (const handler of before) {
-                restoreCtx();
-                await handler(replyFn);
-                if (responseOverwritten)
-                    break;
-            }
-            // fire request handler
-            if (!responseOverwritten) {
-                try {
-                    restoreCtx();
-                    response = await instance[method](...args);
-                }
-                catch (e) {
-                    response = e;
-                }
-            }
-        }
-        // fire after interceptors
-        if (response instanceof Error) {
-            for (const handler of onError) {
-                restoreCtx();
-                await handler(response, replyFn);
-            }
-        }
-        else {
-            for (const handler of after) {
-                restoreCtx();
-                await handler(response, replyFn);
-            }
-        }
-        return response;
-    });
-}
-async function applyPipesToArgs(argsPipes) {
-    const args = [];
-    const { restoreCtx } = useWooksCtx();
-    for (let i = 0; i < argsPipes.length; i++) {
-        const { pipes, meta } = argsPipes[i];
-        args[i] = await runPipes(pipes, meta, restoreCtx);
-    }
-    return args;
-}
-
-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');
-}
-
-/* istanbul ignore file */
-const banner = () => `[moost][${new Date().toISOString().replace('T', ' ').replace(/\.\d{3}z$/i, '')}] `;
-
-/* istanbul ignore file */
-function log(text) {
-    console.log('' + '' + banner() + text + '');
-}
-function logBright(text) {
-    console.log('' + banner() + text + '');
-}
-function logError(error) {
-    console.error('' + '' + banner() + error + '');
-}
-
-/* istanbul ignore file */
-function panic(error) {
-    logError(error);
-    return new Error(error);
-}
-
-async function getCallableFn(targetInstance, fn, restoreCtx) {
-    const mate = getMoostMate();
-    const meta = mate.read(fn);
-    if (meta?.injectable) {
-        const infact = getMoostInfact();
-        infact.silent(meta.injectable === 'FOR_REQUEST');
-        const instance = await 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 "${getConstructor(targetInstance).name}" because the passed arg is not a Function nor TClassFunction`);
-}
-
-function bindControllerMethods(getInstance, classConstructor, wooksApp, options) {
-    const opts = options || {};
-    opts.globalPrefix = opts.globalPrefix || '';
-    opts.provide = opts.provide || {};
-    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}`;
-    for (const method of methods) {
-        const methodMeta = getMoostMate().read(fakeInstance, method) || {};
-        if (!methodMeta.httpHandler || !methodMeta.httpHandler.length)
-            continue;
-        // preparing interceptors
-        const interceptors = [...(opts.interceptors || []), ...(meta.interceptors || []), ...(methodMeta.interceptors || [])].sort((a, b) => a.priority - b.priority);
-        const interceptorHandlers = [];
-        for (const { handler } of interceptors) {
-            const interceptorMeta = mate.read(handler);
-            if (interceptorMeta?.injectable) {
-                interceptorHandlers.push(async (...args) => {
-                    const { restoreCtx } = useWooksCtx();
-                    const targetInstance = await getInstance();
-                    restoreCtx();
-                    return (await getCallableFn(targetInstance, handler, restoreCtx))(...args);
-                });
-            }
-            else {
-                interceptorHandlers.push(handler);
-            }
-        }
-        // 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),
-            });
-        }
-        // preparing provide
-        const provide = { ...(opts.provide || {}), ...(meta.provide || {}) };
-        for (const { method: httpMethod, path: httpPath } of methodMeta.httpHandler) {
-            const path = typeof httpPath === 'string' ? httpPath : typeof method === 'string' ? method : '';
-            const targetPath = `${prefix || ''}/${path}`.replace(/\/\/+/g, '/');
-            bindHandler(getInstance, method, wooksApp, {
-                path: targetPath,
-                httpMethod,
-                interceptorHandlers,
-                provide,
-                argsMeta: methodMeta.params,
-                argsPipes,
-            });
-            log(`• ${httpMethod}${''} ${targetPath} ${''}→ ${classConstructor.name}.${''}${method}${''}()`);
-        }
-    }
-}
-
-function HttpMethod(method, path) {
-    return getMoostMate().decorate('httpHandler', { method, path }, true);
-}
-const All = (path) => HttpMethod('*', path);
-const Get = (path) => HttpMethod('GET', path);
-const Post = (path) => HttpMethod('POST', path);
-const Put = (path) => HttpMethod('PUT', path);
-const Delete = (path) => HttpMethod('DELETE', path);
-const Patch = (path) => HttpMethod('PATCH', path);
-
-function Label(value) {
-    return getMoostMate().decorate('label', 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);
-    };
-}
-/**
- * Hook to the Response Status
- * @decorator
- * @paramType TStatusHook
- */
-const StatusHook = Resolve(() => useStatus(), 'status');
-/**
- * Hook to the Response Header
- * @decorator
- * @param name - header name
- * @paramType THeaderHook
- */
-const HeaderHook = (name) => Resolve(() => useSetHeader(name), name);
-/**
- * Hook to the Response Cookie
- * @decorator
- * @param name - header name
- * @paramType TCookieHook
- */
-const CookieHook = (name) => Resolve(() => useSetCookie(name), name);
-/**
- * Parse Authorisation Header
- * @decorator
- * @param name - define what to take from the Auth header
- * @paramType string
- */
-function Authorization(name) {
-    return Resolve(() => {
-        const auth = useAuthorization();
-        switch (name) {
-            case 'username':
-                return auth.isBasic() ? auth.basicCredentials()?.username : undefined;
-            case 'password':
-                return auth.isBasic() ? auth.basicCredentials()?.password : undefined;
-            case 'bearer':
-                return auth.isBearer() ? auth.authorization : undefined;
-            case 'raw':
-                return auth.authRawCredentials();
-            case 'type':
-                return auth.authType();
-        }
-    }, 'authorization');
-}
-/**
- * Get Request Header Value
- * @decorator
- * @param name - header name
- * @paramType string
- */
-function Header(name) {
-    return Resolve(() => {
-        const headers = useHeaders();
-        return headers[name];
-    }, 'header: ' + name);
-}
-/**
- * Get Request Cookie Value
- * @decorator
- * @param name - cookie name
- * @paramType string
- */
-function Cookie(name) {
-    return Resolve(() => useCookies().getCookie(name), 'cookie: ' + name);
-}
-/**
- * Get Param Value from url parh
- * @decorator
- * @param name - param name
- * @paramType string
- */
-function Param(name) {
-    return Resolve(() => useRouteParams().getRouteParam(name), name);
-}
-/**
- * Get Parsed Params from url parh
- * @decorator
- * @paramType object
- */
-function Params() {
-    return Resolve(() => useRouteParams().routeParams, 'params');
-}
-/**
- * Get Query Item value or the whole parsed Query as an object
- * @decorator
- * @param name - query item name (optional)
- * @paramType string | object
- */
-function Query(name) {
-    return Resolve(() => {
-        const { jsonSearchParams, urlSearchParams } = useSearchParams();
-        if (name) {
-            const p = urlSearchParams();
-            const value = p.get(name);
-            console.log(name + ' = ', value);
-            return value === '' && p.has(name) || value;
-        }
-        const json = jsonSearchParams();
-        return Object.keys(json).length ? json : undefined;
-    }, name || 'Query');
-}
-/**
- * Get Requested URL
- * @decorator
- * @paramType string
- */
-function Url() {
-    return Resolve(() => useRequest().url, 'url');
-}
-/**
- * Get Requested HTTP Method
- * @decorator
- * @paramType string
- */
-function Method() {
-    return Resolve(() => useRequest().method, 'http_method');
-}
-/**
- * Get Raw Request Instance
- * @decorator
- * @paramType IncomingMessage
- */
-function Req() {
-    return Resolve(() => useRequest().rawRequest, 'request');
-}
-/**
- * Get Request Unique Identificator (UUID)
- * @decorator
- * @paramType string
- */
-function ReqId() {
-    return Resolve(() => useRequest().reqId(), 'reqId');
-}
-/**
- * Get Request IP Address
- * @decorator
- * @paramType string
- */
-function Ip(opts) {
-    return Resolve(() => useRequest().getIp(opts), 'ip');
-}
-/**
- * Get Request IP Address list
- * @decorator
- * @paramType string[]
- */
-function IpList() {
-    return Resolve(() => useRequest().getIpList(), 'ipList');
-}
-/**
- * Get Raw Response Object
- * @decorator
- * @param options - passthrough options
- * @paramType string
- */
-function Res(options) {
-    return Resolve(() => useResponse().rawResponse(options), 'response');
-}
-/**
- * Provide Const Value
- * @decorator
- * @param value - provided value
- * @param label - label of the field
- * @paramType unknown
- */
-function Const(value, label) {
-    return Resolve(() => value, label);
-}
-/**
- * Get Parsed Request Body
- * @decorator
- * @paramType object | string | unknown
- */
-function Body() {
-    return Resolve(() => useBody().parseBody(), 'body');
-}
-/**
- * Get Raw Request Body Buffer
- * @decorator
- * @paramType Promise<Buffer>
- */
-function RawBody() {
-    return Resolve(() => useBody().rawBody(), 'body');
-}
-function fillLabel(target, key, index, name) {
-    if (name) {
-        const meta = getMoostMate().read(target, key);
-        if (!meta?.params || !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_REQUEST" | "SINGLETON" | true)
- * FOR_REQUEST - 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);
-}
-
-var TInterceptorPriority;
-(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";
-})(TInterceptorPriority || (TInterceptorPriority = {}));
-function Intercept(handler, priority) {
-    return getMoostMate().decorate('interceptors', {
-        handler,
-        priority: priority || handler.priority || TInterceptorPriority.INTERCEPTOR,
-    }, true);
-}
-
-function Provide(type, fn) {
-    return getMoostMate().decorate(meta => {
-        meta.provide = meta.provide || {};
-        Object.assign(meta.provide, 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?.itemValidators && !isArrayItemValidator) {
-        isArrayItemValidator = true;
-        decorators.push(...opts.itemValidators());
-        isArrayItemValidator = false;
-    }
-    else if (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(validoIsTypeOf(type, errorText));
-}
-function IsString(...args) {
-    return Validate(validoIsString(...args));
-}
-function IsNumber(...args) {
-    return Validate(validoIsNumber(...args));
-}
-function IsBoolean(...args) {
-    return Validate(validoIsBoolean(...args));
-}
-
-const valido = new Valido({
-    getDtoMeta(value, _type) {
-        let type = _type;
-        if (!type) {
-            type = 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;
-}
-
-class Moost {
-    options;
-    pipes = [...sharedPipes];
-    interceptors = [];
-    provide = createProvideRegistry([Infact, getMoostInfact], [Mate, getMoostMate], [Valido, getMoostValido]);
-    constructor(options) {
-        this.options = options;
-    }
-    wooksApp;
-    unregisteredControllers = [];
-    async listen(port, hostname, cb) {
-        this.wooksApp = new Wooks(this.options?.wooksOptions);
-        this.setProvideRegistry(createProvideRegistry([Wooks, () => this.wooksApp], [Moost, () => this]));
-        const _port = Number(this.options?.port || port);
-        const _hostname = this.options?.hostname || hostname;
-        if (!_port) {
-            throw panic('Port is not specified for "listen" method');
-        }
-        await this.init();
-        await this.wooksApp.listen(_port, _hostname, cb);
-        logBright(`🚀 ${getConstructor(this).name} is up and running on port ${_port}`);
-        return this.wooksApp;
-    }
-    close() {
-        return this.wooksApp?.close();
-    }
-    async init() {
-        if (this.wooksApp) {
-            this.unregisteredControllers.unshift(this);
-            await this.bindControllers();
-        }
-    }
-    async bindControllers() {
-        if (this.wooksApp) {
-            const meta = getMoostMate();
-            const thisMeta = meta.read(this);
-            const provide = { ...(thisMeta?.provide || {}), ...this.provide };
-            for (const controller of this.unregisteredControllers) {
-                await this.bindController(controller, provide, this.options?.globalPrefix || '');
-            }
-            this.unregisteredControllers = [];
-        }
-    }
-    async bindController(controller, provide, globalPrefix, replaceOwnPrefix) {
-        if (this.wooksApp) {
-            const meta = getMoostMate();
-            const classMeta = meta.read(controller);
-            const infact = getMoostInfact();
-            const isControllerConsructor = isConstructor(controller);
-            let instance;
-            if (isControllerConsructor && classMeta?.injectable === 'SINGLETON') {
-                instance = await infact.get(controller, provide);
-            }
-            else if (!isControllerConsructor) {
-                instance = controller;
-                infact.setProvideRegByInstance(instance, provide);
-            }
-            // getInstance - instance factory for resolving SINGLETON and FOR_REQUEST instance
-            const getInstance = instance ? () => Promise.resolve(instance) : async () => {
-                // if (!instance) {
-                infact.silent();
-                const instance = await infact.get(controller, provide);
-                infact.silent(false);
-                // }
-                return instance;
-            };
-            const classConstructor = isConstructor(controller) ? controller : getConstructor(controller);
-            bindControllerMethods(getInstance, classConstructor, this.wooksApp, {
-                globalPrefix,
-                replaceOwnPrefix,
-                interceptors: [...this.interceptors],
-                pipes: [...this.pipes],
-                provide: classMeta?.provide || {},
-            });
-            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 = isConstructor(ic.typeResolver);
-                        const isFunc = typeof ic.typeResolver === 'function';
-                        await this.bindController(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 : 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 : 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 = { ...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;
-    }
-}
-
-const genericTypesCastPipe = (strict) => {
-    const handler = (value, meta) => {
-        if (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 = 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 = async (_value, meta) => {
-        const { restoreCtx } = useWooksCtx();
-        const valido = getMoostValido();
-        const result = await valido.validateParam(_value, meta, undefined, undefined, undefined, undefined, 0, 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 = TPipePriority.VALIDATE;
-    return pipe;
-};
-
-export { All, Authorization, Body, Circular, Const, Controller, Cookie, CookieHook, Delete, Dto, Get, Header, HeaderHook, HttpMethod, ImportController, Inject, Injectable, Intercept, Ip, IpList, IsArray, IsBoolean, IsNumber, IsString, IsTypeOf, Label, Method, Moost, Optional, Param, Params, Patch, Post, Provide, Put, Query, RawBody, Req, ReqId, Required, Res, Resolve, StatusHook, TInterceptorPriority, TPipePriority, Url, Validate, genericTypesCastPipe, getMoostMate, resolvePipe, useControllerMeta, validatePipe };