moost 0.0.1-beta.0

package/dist/moost.esm-bundler.js

@@ -0,0 +1,693 @@
+import { useCurrentWooksContext, useRequest, useHeaders, useCookies, useRouteParams, useSearchParams, useResponse, useBody, Wooks, WooksError } from 'wooks';
+import { Mate, getConstructor, isConstructor } from '@prostojs/mate';
+import { Infact, createProvideRegistry } from '@prostojs/infact';
+import { validoIsTypeOf, validoIsString, validoIsNumber, validoIsBoolean, Valido } from '@prostojs/valido';
+
+const METADATA_WORKSPACE = 'moost';
+const moostMate = new Mate(METADATA_WORKSPACE, {
+    readType: true,
+    readReturnType: true,
+});
+function getMoostMate() {
+    return moostMate;
+}
+
+const prefix = '__moost_';
+function useCacheObject(name, def) {
+    const cc = useCurrentWooksContext().getCtx().customContext;
+    const key = prefix + name;
+    const cache = cc[key] = (cc[key] || def);
+    return cache;
+}
+function setCacheObject(name, value) {
+    const cc = useCurrentWooksContext().getCtx().customContext;
+    const key = prefix + name;
+    cc[key] = value;
+}
+
+function useControllerMeta() {
+    const controller = useCacheObject('controller', undefined);
+    const method = useCacheObject('method', '');
+    return {
+        getClassMeta: () => getMoostMate().read(controller),
+        getMethodMeta: () => getMoostMate().read(controller, method),
+    };
+}
+function setComposableControllerContext(controller, method) {
+    setCacheObject('controller', controller);
+    setCacheObject('method', method);
+}
+
+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 === null || meta === void 0 ? void 0 : 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 === 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_REQUEST' ? useRequest().reqId() : undefined,
+            };
+            return infactMeta;
+        },
+        resolveParam(paramMeta) {
+            if (paramMeta.resolver) {
+                return runPipes(sharedPipes, paramMeta);
+            }
+        },
+        storeProvideRegByInstance: true,
+    });
+}
+
+function bindHandler(getInstance, method, wooksApp, options) {
+    wooksApp.on(options.httpMethod, options.path, async () => {
+        const { restoreCtx } = useCurrentWooksContext();
+        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(instance, method);
+        let response;
+        let responseOverwritten = false;
+        const before = [];
+        const after = [];
+        const onError = [];
+        function replyFn(reply) {
+            response = reply;
+            responseOverwritten = true;
+        }
+        for (const handler of options.interceptorHandlers) {
+            restoreCtx();
+            await handler((fn) => { before.push(fn); }, (fn) => { after.unshift(fn); }, (fn) => { onError.unshift(fn); });
+        }
+        let args = [];
+        try {
+            restoreCtx();
+            args = await applyPipesToArgs(options.argsPipes);
+        }
+        catch (e) {
+            response = e;
+        }
+        if (!response) {
+            for (const handler of before) {
+                restoreCtx();
+                await handler(replyFn);
+                if (responseOverwritten)
+                    break;
+            }
+            if (!responseOverwritten) {
+                try {
+                    restoreCtx();
+                    response = await instance[method](...args);
+                }
+                catch (e) {
+                    response = e;
+                }
+            }
+        }
+        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 } = useCurrentWooksContext();
+    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) {
+    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, '')}] `;
+
+function log(text) {
+    console.log('' + '' + banner() + text + '');
+}
+function logBright(text) {
+    console.log('' + banner() + text + '');
+}
+function logError(error) {
+    console.error('' + '' + banner() + error + '');
+}
+
+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 === null || meta === void 0 ? void 0 : 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) {
+    var _a;
+    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 : (((_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.httpHandler || !methodMeta.httpHandler.length)
+            continue;
+        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 === null || interceptorMeta === void 0 ? void 0 : interceptorMeta.injectable) {
+                interceptorHandlers.push(async (...args) => {
+                    const { restoreCtx } = useCurrentWooksContext();
+                    const targetInstance = await getInstance();
+                    restoreCtx();
+                    return (await getCallableFn(targetInstance, handler, restoreCtx))(...args);
+                });
+            }
+            else {
+                interceptorHandlers.push(handler);
+            }
+        }
+        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 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), mate.decorateClass((meta, key, index) => {
+        if (typeof index !== 'number' && meta && ['string', 'symbol'].includes(typeof key)) {
+            meta.requiredProps = meta.requiredProps || [];
+            meta.requiredProps.push(key);
+        }
+        return meta;
+    }));
+}
+
+function Resolve(resolver, label) {
+    return (target, key, index) => {
+        fillLabel(target, key, index, label);
+        getMoostMate().decorate('resolver', resolver)(target, key, index);
+    };
+}
+function Header(name) {
+    return Resolve(() => {
+        const headers = useHeaders();
+        return headers[name];
+    }, 'header: ' + name);
+}
+function Cookie(name) {
+    return Resolve(() => useCookies().getCookie(name), 'cookie: ' + name);
+}
+function Param(name) {
+    return Resolve(() => useRouteParams().getRouteParam(name), name);
+}
+function Params() {
+    return Resolve(() => useRouteParams().routeParams, 'params');
+}
+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');
+}
+function Url() {
+    return Resolve(() => useRequest().url, 'url');
+}
+function Method() {
+    return Resolve(() => useRequest().method, 'http_method');
+}
+function Req() {
+    return Resolve(() => useRequest().rawRequest, 'request');
+}
+function ReqId() {
+    return Resolve(() => useRequest().reqId(), 'reqId');
+}
+function Ip(opts) {
+    return Resolve(() => useRequest().getIp(opts), 'ip');
+}
+function IpList() {
+    return Resolve(() => useRequest().getIpList(), 'ipList');
+}
+function Res(options) {
+    return Resolve(() => useResponse().rawResponse(options), 'response');
+}
+function Const(value, label) {
+    return Resolve(() => value, label);
+}
+function Body() {
+    return Resolve(() => useBody().parseBody(), 'body');
+}
+function RawBody() {
+    return Resolve(() => useBody().rawBody(), 'body');
+}
+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].label)) {
+            Label(name)(target, key, index);
+        }
+    }
+}
+
+function Controller(prefix) {
+    return getMoostMate().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 Injectable(scope = true) {
+    return getMoostMate().decorate('injectable', scope);
+}
+
+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 === 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(validoIsTypeOf(type, errorText));
+}
+function IsString(...args) {
+    return Validate(validoIsString(...args));
+}
+function IsNumber(...args) {
+    return Validate(validoIsNumber(...args));
+}
+function IsBoolean(...args) {
+    return Validate(validoIsBoolean(...args));
+}
+
+class Moost {
+    constructor(options) {
+        this.options = options;
+        this.pipes = [...sharedPipes];
+        this.interceptors = [];
+        this.provide = {};
+        this.unregisteredControllers = [];
+    }
+    async listen(port, hostname, cb) {
+        var _a, _b, _c;
+        this.wooksApp = new Wooks((_a = this.options) === null || _a === void 0 ? void 0 : _a.wooksOptions);
+        const _port = Number(((_b = this.options) === null || _b === void 0 ? void 0 : _b.port) || port);
+        const _hostname = ((_c = this.options) === null || _c === void 0 ? void 0 : _c.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() {
+        var _a;
+        return (_a = this.wooksApp) === null || _a === void 0 ? void 0 : _a.close();
+    }
+    async init() {
+        if (this.wooksApp) {
+            this.unregisteredControllers.unshift(this);
+            await this.bindControllers();
+        }
+    }
+    async bindControllers() {
+        var _a;
+        if (this.wooksApp) {
+            const meta = getMoostMate();
+            const thisMeta = meta.read(this);
+            const provide = { ...((thisMeta === null || thisMeta === void 0 ? void 0 : thisMeta.provide) || {}), ...this.provide };
+            for (const controller of this.unregisteredControllers) {
+                await this.bindController(controller, provide, ((_a = this.options) === null || _a === void 0 ? void 0 : _a.globalPrefix) || '');
+            }
+            this.unregisteredControllers = [];
+        }
+    }
+    async bindController(controller, provide, globalPrefix, replaceOwnPrefix) {
+        var _a;
+        if (this.wooksApp) {
+            const meta = getMoostMate();
+            const classMeta = meta.read(controller);
+            const infact = getMoostInfact();
+            const isControllerConsructor = isConstructor(controller);
+            let instance;
+            if (isControllerConsructor && (classMeta === null || classMeta === void 0 ? void 0 : classMeta.injectable) === 'SINGLETON') {
+                instance = await infact.get(controller, provide);
+            }
+            else if (!isControllerConsructor) {
+                instance = controller;
+                infact.setProvideRegByInstance(instance, provide);
+            }
+            const getInstance = instance ? () => Promise.resolve(instance) : async () => {
+                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 === 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 = { ...provide, ...((classMeta === null || classMeta === void 0 ? void 0 : 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;
+    }
+    setProvideRegistry(provide) {
+        this.provide = { ...this.provide, ...provide };
+        return this;
+    }
+    registerControllers(...controllers) {
+        this.unregisteredControllers.push(...controllers);
+        return this;
+    }
+}
+
+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 = 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 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;
+}
+
+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 } = useCurrentWooksContext();
+        const valido = getMoostValido();
+        const result = await 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 = TPipePriority.VALIDATE;
+    return pipe;
+};
+
+export { All, Body, Circular, Const, Controller, Cookie, Delete, Dto, Get, Header, 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, TInterceptorPriority, TPipePriority, Url, Validate, genericTypesCastPipe, getMoostMate, resolvePipe, useControllerMeta, validatePipe };