vovk 3.0.0-draft.99 → 3.0.0

package/dist/core/multitenant.js

@@ -0,0 +1,132 @@
+// Get the reserved paths from the overrides configuration
+const getReservedPaths = (overrides) => {
+    return Object.keys(overrides).filter((key) => !key.includes('[') && !key.includes(']')); // Filter out dynamic paths
+};
+/**
+ * Convert a pattern with [placeholders] to a regex pattern and extract placeholder names
+ */
+const patternToRegex = (pattern) => {
+    const paramNames = [];
+    const regexPattern = pattern
+        .replace(/\[([^\]]+)\]/g, (_, name) => {
+        paramNames.push(name);
+        return '([^.]+)';
+    })
+        .replace(/\./g, '\\.'); // Escape dots in the pattern
+    return {
+        regex: new RegExp(`^${regexPattern}$`),
+        paramNames,
+    };
+};
+/**
+ * Multitenant function to handle subdomain and path-based routing overrides.
+ * @see https://vovk.dev/multitenant
+ */
+export function multitenant(config) {
+    const { requestUrl, requestHost, targetHost, overrides } = config;
+    // Parse the URL
+    const urlObj = new URL(requestUrl);
+    const pathname = urlObj.pathname.slice(1); // Remove leading slash
+    // Skip processing for paths ending with "_schema_"
+    if (pathname.endsWith('_schema_')) {
+        return {
+            action: null,
+            destination: null,
+            message: 'Schema endpoint, bypassing overrides',
+            subdomains: null,
+        };
+    }
+    const pathSegments = pathname.split('/').filter(Boolean);
+    // Get reserved paths
+    const reservedPaths = getReservedPaths(overrides);
+    // Check if any path segment matches a reserved path (e.g., "admin")
+    for (let i = 0; i < pathSegments.length; i++) {
+        const segment = pathSegments[i];
+        if (reservedPaths.includes(segment)) {
+            // Create the destination URL with the reserved path as subdomain
+            const destinationHost = `${segment}.${targetHost}`;
+            // Keep path segments before the reserved path
+            const beforeSegments = pathSegments.slice(0, i);
+            // Keep path segments after the reserved path
+            const afterSegments = pathSegments.slice(i + 1);
+            // Construct the new path
+            const newPath = [...beforeSegments, ...afterSegments].join('/');
+            const destinationUrl = new URL(`${urlObj.protocol}//${destinationHost}`);
+            if (newPath) {
+                destinationUrl.pathname = `/${newPath}`;
+            }
+            // Keep any query parameters
+            destinationUrl.search = urlObj.search;
+            return {
+                action: 'redirect',
+                destination: destinationUrl.toString(),
+                message: `Redirecting to ${segment} subdomain`,
+                subdomains: null, // No wildcards used
+            };
+        }
+    }
+    // Process based on host and subdomains
+    for (const pattern in overrides) {
+        const fullPattern = `${pattern}.${targetHost}`;
+        const { regex, paramNames } = patternToRegex(fullPattern);
+        const match = requestHost.match(regex);
+        if (match) {
+            const overrideRules = overrides[pattern];
+            // Extract parameters from the match
+            const params = {};
+            if (match.length > 1) {
+                for (let i = 0; i < paramNames.length; i++) {
+                    params[paramNames[i]] = match[i + 1];
+                }
+            }
+            // Find the appropriate rule based on the path
+            for (const rule of overrideRules) {
+                if (pathname === rule.from || pathname.startsWith(`${rule.from}/`)) {
+                    // Replace path with the destination
+                    let destination = pathname.replace(rule.from, rule.to);
+                    // Replace any dynamic parameters in destination
+                    if (Object.keys(params).length > 0) {
+                        Object.entries(params).forEach(([key, value]) => {
+                            destination = destination.replace(`[${key}]`, value);
+                        });
+                    }
+                    // Only return non-null subdomains if we have wildcard parameters
+                    const wildcardSubdomains = paramNames.length > 0 ? params : null;
+                    return {
+                        action: 'rewrite',
+                        destination: `${urlObj.protocol}//${urlObj.host}/${destination}${urlObj.search}`,
+                        message: `Rewriting to ${destination}`,
+                        subdomains: wildcardSubdomains,
+                    };
+                }
+            }
+        }
+    }
+    // Handle cases where a customer subdomain tries to access reserved paths
+    if (pathSegments.length > 0 && reservedPaths.includes(pathSegments[0])) {
+        const reservedPath = pathSegments[0];
+        const restPath = pathSegments.slice(1).join('/');
+        // Create the destination URL with the reserved path as subdomain
+        const destinationHost = `${reservedPath}.${targetHost}`;
+        const destinationUrl = new URL(`${urlObj.protocol}//${destinationHost}`);
+        // Only add remaining path segments if they exist
+        if (restPath) {
+            destinationUrl.pathname = `/${restPath}`;
+        }
+        // Keep any query parameters
+        destinationUrl.search = urlObj.search;
+        return {
+            action: 'redirect',
+            destination: destinationUrl.toString(),
+            message: `Redirecting to ${reservedPath} subdomain`,
+            subdomains: null, // No wildcards used for reserved paths
+        };
+    }
+    // Default case - pass through
+    return {
+        action: null,
+        destination: null,
+        message: 'No action',
+        subdomains: null, // No wildcards matched
+    };
+}

package/dist/core/resolveGeneratorConfigValues.d.ts

@@ -0,0 +1,19 @@
+import type { OpenAPIObject } from 'openapi3-ts/oas31';
+import type { VovkConfig, VovkOutputConfig, VovkPackageJson, VovkReadmeConfig, VovkSamplesConfig } from '../types/config.js';
+import type { PackageJson } from '../types/package.js';
+export declare function resolveGeneratorConfigValues({ config, outputConfigs, forceOutputConfigs, segmentName, isBundle, projectPackageJson, }: {
+    config: VovkConfig | undefined;
+    outputConfigs: VovkOutputConfig[];
+    forceOutputConfigs?: VovkOutputConfig[];
+    segmentName: string | null;
+    isBundle: boolean;
+    projectPackageJson: PackageJson | undefined;
+}): {
+    readme: VovkReadmeConfig;
+    openAPIObject: OpenAPIObject;
+    samples: VovkSamplesConfig;
+    origin: string;
+    package: VovkPackageJson;
+    imports: VovkOutputConfig['imports'];
+    reExports: VovkOutputConfig['reExports'];
+};

package/dist/core/resolveGeneratorConfigValues.js

@@ -0,0 +1,59 @@
+import { deepExtend } from '../utils/deepExtend.js';
+export function resolveGeneratorConfigValues({ config, outputConfigs, forceOutputConfigs, segmentName, isBundle, projectPackageJson, }) {
+    const packageJson = deepExtend(Object.fromEntries(Object.entries(projectPackageJson ?? {}).filter(([key]) => [
+        'name',
+        'version',
+        'description',
+        'license',
+        'author',
+        'contributors',
+        'repository',
+        'homepage',
+        'bugs',
+        'keywords',
+    ].includes(key))), config?.outputConfig?.package, typeof segmentName === 'string' ? config?.outputConfig?.segments?.[segmentName]?.package : undefined, outputConfigs?.reduce((acc, config) => deepExtend(acc, config.package), {}), isBundle ? config?.bundle?.outputConfig?.package : undefined);
+    const openAPIObject = deepExtend({
+        openapi: '3.1.0',
+        info: {
+            title: packageJson.name,
+            version: packageJson.version,
+            description: packageJson.description,
+        },
+    }, config?.outputConfig?.openAPIObject, typeof segmentName === 'string' ? config?.outputConfig?.segments?.[segmentName]?.openAPIObject : undefined, outputConfigs?.reduce((acc, config) => deepExtend(acc, config.openAPIObject), {}), isBundle ? config?.bundle?.outputConfig?.openAPIObject : undefined, forceOutputConfigs?.reduce((acc, config) => deepExtend(acc, config.openAPIObject), {}));
+    const samples = deepExtend({}, config?.outputConfig?.samples, typeof segmentName === 'string' ? config?.outputConfig?.segments?.[segmentName]?.samples : undefined, outputConfigs?.reduce((acc, config) => deepExtend(acc, config.samples), {}), isBundle ? config?.bundle?.outputConfig?.samples : undefined, forceOutputConfigs?.reduce((acc, config) => deepExtend(acc, config.samples), {}));
+    const readme = deepExtend({}, config?.outputConfig?.readme, typeof segmentName === 'string' ? config?.outputConfig?.segments?.[segmentName]?.readme : undefined, outputConfigs?.reduce((acc, config) => deepExtend(acc, config.readme), {}), isBundle ? config?.bundle?.outputConfig?.readme : undefined, forceOutputConfigs?.reduce((acc, config) => deepExtend(acc, config.readme), {}));
+    const origin = [
+        config?.outputConfig?.origin,
+        typeof segmentName === 'string' ? config?.outputConfig?.segments?.[segmentName]?.origin : undefined,
+        ...(outputConfigs?.map((config) => config.origin) ?? []),
+        isBundle ? config?.bundle?.outputConfig?.origin : undefined,
+        ...(forceOutputConfigs?.map((config) => config.origin) ?? []),
+    ]
+        .filter(Boolean)
+        .at(-1)
+        // remove trailing slash if any
+        ?.replace(/\/$/, '') ?? '';
+    const imports = deepExtend({
+        fetcher: 'vovk/fetcher',
+        validateOnClient: null,
+        createRPC: 'vovk/createRPC',
+    }, config?.outputConfig?.imports, typeof segmentName === 'string' ? config?.outputConfig?.segments?.[segmentName]?.imports : undefined, outputConfigs?.reduce((acc, config) => deepExtend(acc, config.imports), {}), isBundle ? config?.bundle?.outputConfig?.imports : undefined, forceOutputConfigs?.reduce((acc, config) => deepExtend(acc, config.imports), {}));
+    const reExports = deepExtend(
+    // segmentName can be an empty string (for the root segment) and null (for composed clients)
+    // therefore, !segmentName indicates that this either a composed client or a root segment of a segmented client
+    {}, !segmentName && config?.outputConfig?.reExports, 
+    // for segmented client, apply all reExports from all segments
+    typeof segmentName !== 'string' &&
+        Object.values(config?.outputConfig?.segments ?? {}).reduce((acc, segmentConfig) => deepExtend(acc, segmentConfig.reExports ?? {}), {}), 
+    // for a specific segment, apply reExports from that segment
+    typeof segmentName === 'string' ? config?.outputConfig?.segments?.[segmentName]?.reExports : undefined, outputConfigs?.reduce((acc, config) => deepExtend(acc, config.reExports), {}), isBundle ? config?.bundle?.outputConfig?.reExports : undefined, forceOutputConfigs?.reduce((acc, config) => deepExtend(acc, config.reExports), {}));
+    return {
+        package: packageJson,
+        openAPIObject,
+        samples,
+        readme,
+        origin,
+        imports,
+        reExports,
+    };
+}

package/dist/{utils → core}/setHandlerSchema.d.ts

@@ -1,4 +1,4 @@
-import type { KnownAny, VovkController, VovkHandlerSchema } from '../types';
-export declare function setHandlerSchema(h: ((...args: KnownAny[]) => KnownAny) & {
+import type { VovkController, VovkHandlerSchema } from '../types/core.js';
+export declare function setHandlerSchema(h: ((...args: unknown[]) => unknown) & {
     _getSchema?: (controller: VovkController) => Omit<VovkHandlerSchema, 'httpMethod' | 'path'>;
 }, schema: Omit<VovkHandlerSchema, 'httpMethod' | 'path'>): Promise<void>;

package/dist/{utils → core}/setHandlerSchema.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setHandlerSchema = setHandlerSchema;
-async function setHandlerSchema(h, schema) {
+export async function setHandlerSchema(h, schema) {
     h._getSchema = (controller) => {
         if (!controller) {
             throw new Error('Error setting client validators. Controller not found. Did you forget to use an HTTP decorator?');

package/dist/core/toDownloadResponse.d.ts

@@ -0,0 +1,11 @@
+type BinaryData = Blob | File | ArrayBuffer | Uint8Array | ReadableStream<Uint8Array> | string;
+/**
+ * Creates a Response object for downloading binary data with appropriate headers.
+ * @see https://vovk.dev/response
+ */
+export declare function toDownloadResponse(data: BinaryData, { filename, type, headers }?: {
+    filename?: string;
+    type?: string;
+    headers?: Record<string, string>;
+}): Response;
+export {};

package/dist/core/toDownloadResponse.js

@@ -0,0 +1,25 @@
+import { fileNameToDisposition } from '../utils/fileNameToDisposition.js';
+/**
+ * Creates a Response object for downloading binary data with appropriate headers.
+ * @see https://vovk.dev/response
+ */
+export function toDownloadResponse(data, { filename, type, headers } = {}) {
+    const body = data instanceof Blob
+        ? data
+        : data instanceof ReadableStream
+            ? data
+            : new Blob([data], { type: type ?? 'application/octet-stream' });
+    const resolvedName = filename ?? (data instanceof File ? data.name : undefined);
+    const resolvedType = type ?? (body instanceof Blob ? body.type : undefined);
+    return new Response(body, {
+        headers: {
+            ...(resolvedType ? { 'Content-Type': resolvedType } : {}),
+            ...(resolvedName
+                ? {
+                    'Content-Disposition': fileNameToDisposition(resolvedName),
+                }
+                : {}),
+            ...headers,
+        },
+    });
+}

package/dist/core/vovkApp.d.ts

@@ -0,0 +1,36 @@
+import { HttpMethod, HttpStatus } from '../types/enums.js';
+import type { RouteHandler, VovkController, DecoratorOptions } from '../types/core.js';
+declare class VovkApp {
+    #private;
+    private static getHeadersFromDecoratorOptions;
+    routes: Record<HttpMethod, Map<VovkController, Record<string, RouteHandler>>>;
+    GET: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }, segmentName: string) => Promise<Response>;
+    POST: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }, segmentName: string) => Promise<Response>;
+    PUT: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }, segmentName: string) => Promise<Response>;
+    PATCH: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }, segmentName: string) => Promise<Response>;
+    DELETE: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }, segmentName: string) => Promise<Response>;
+    HEAD: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }, segmentName: string) => Promise<Response>;
+    OPTIONS: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }, segmentName: string) => Promise<Response>;
+    respond: ({ statusCode, responseBody, options, }: {
+        req: Request;
+        statusCode: HttpStatus;
+        responseBody: unknown;
+        options?: DecoratorOptions;
+    }) => Promise<Response>;
+}
+declare const vovkApp: VovkApp;
+export { vovkApp };

package/dist/core/vovkApp.js

@@ -0,0 +1,316 @@
+var _a;
+import { HttpException } from './HttpException.js';
+import { JSONLinesResponder, Responder } from './JSONLinesResponder.js';
+import { reqQuery } from '../req/reqQuery.js';
+import { reqMeta } from '../req/reqMeta.js';
+import { HttpMethod, HttpStatus } from '../types/enums.js';
+import { parseBody } from '../req/parseBody.js';
+class VovkApp {
+    static getHeadersFromDecoratorOptions(options) {
+        if (!options)
+            return {};
+        const corsHeaders = {
+            'access-control-allow-origin': '*',
+            'access-control-allow-methods': 'GET, POST, PUT, DELETE, OPTIONS, HEAD',
+            'access-control-allow-headers': 'content-type, authorization',
+        };
+        const headers = {
+            ...(options.cors ? corsHeaders : {}),
+            ...(options.headers ?? {}),
+        };
+        return headers;
+    }
+    routes = {
+        GET: new Map(),
+        POST: new Map(),
+        PUT: new Map(),
+        PATCH: new Map(),
+        DELETE: new Map(),
+        HEAD: new Map(),
+        OPTIONS: new Map(),
+    };
+    GET = async (req, data, segmentName) => this.#callMethod({ httpMethod: HttpMethod.GET, req, params: await data.params, segmentName });
+    POST = async (req, data, segmentName) => this.#callMethod({ httpMethod: HttpMethod.POST, req, params: await data.params, segmentName });
+    PUT = async (req, data, segmentName) => this.#callMethod({ httpMethod: HttpMethod.PUT, req, params: await data.params, segmentName });
+    PATCH = async (req, data, segmentName) => this.#callMethod({ httpMethod: HttpMethod.PATCH, req, params: await data.params, segmentName });
+    DELETE = async (req, data, segmentName) => this.#callMethod({ httpMethod: HttpMethod.DELETE, req, params: await data.params, segmentName });
+    HEAD = async (req, data, segmentName) => this.#callMethod({ httpMethod: HttpMethod.HEAD, req, params: await data.params, segmentName });
+    OPTIONS = async (req, data, segmentName) => this.#callMethod({ httpMethod: HttpMethod.OPTIONS, req, params: await data.params, segmentName });
+    respond = async ({ statusCode, responseBody, options, }) => {
+        const response = new Response(JSON.stringify(responseBody), {
+            status: statusCode,
+            headers: {
+                'content-type': 'application/json',
+                ..._a.getHeadersFromDecoratorOptions(options),
+            },
+        });
+        return response;
+    };
+    #respondWithError = ({ req, statusCode, message, options, cause, }) => {
+        return this.respond({
+            req,
+            statusCode,
+            responseBody: {
+                cause,
+                statusCode,
+                message,
+                isError: true,
+            },
+            options,
+        });
+    };
+    #routeRegexCache = new Map();
+    #routeSegmentsCache = new Map();
+    #routeParamPositionsCache = new Map();
+    #routeMatchCache = new Map();
+    #getHandler = ({ handlers, path, params, }) => {
+        let methodParams = {};
+        if (Object.keys(params).length === 0) {
+            return { handler: handlers[''], methodParams };
+        }
+        const pathStr = path.join('/');
+        // Fast path: Check if this exact path has been matched before
+        const cachedMatch = this.#routeMatchCache.get(pathStr);
+        if (cachedMatch) {
+            return {
+                handler: handlers[cachedMatch.route],
+                methodParams: cachedMatch.params,
+            };
+        }
+        // Check for direct static route match
+        let methodKey = handlers[pathStr] ? pathStr : null;
+        if (!methodKey) {
+            const methodKeys = [];
+            const pathLength = path.length;
+            // First pass: group routes by length for quick filtering
+            const routesByLength = new Map();
+            for (const p of Object.keys(handlers)) {
+                let routeSegments = this.#routeSegmentsCache.get(p);
+                if (!routeSegments) {
+                    routeSegments = p.split('/');
+                    this.#routeSegmentsCache.set(p, routeSegments);
+                    // Pre-compute parameter positions for routes with parameters
+                    if (p.includes('{')) {
+                        const paramPositions = [];
+                        for (let i = 0; i < routeSegments.length; i++) {
+                            const segment = routeSegments[i];
+                            if (segment.includes('{')) {
+                                const paramMatch = segment.match(/\{(\w+)\}/);
+                                if (paramMatch) {
+                                    paramPositions.push({ index: i, paramName: paramMatch[1] });
+                                }
+                            }
+                        }
+                        this.#routeParamPositionsCache.set(p, paramPositions);
+                    }
+                }
+                const segmentLength = routeSegments.length;
+                if (segmentLength !== pathLength)
+                    continue;
+                const lengthRoutes = routesByLength.get(segmentLength) || [];
+                lengthRoutes.push(p);
+                routesByLength.set(segmentLength, lengthRoutes);
+            }
+            // Only process routes with matching segment count
+            const candidateRoutes = routesByLength.get(pathLength) || [];
+            for (const p of candidateRoutes) {
+                const routeSegments = this.#routeSegmentsCache.get(p);
+                const params = {};
+                // Fast path for routes with parameters
+                const paramPositions = this.#routeParamPositionsCache.get(p);
+                if (paramPositions) {
+                    let isMatch = true;
+                    // First check all non-parameter segments for a quick fail
+                    for (let i = 0; i < routeSegments.length; i++) {
+                        const routeSegment = routeSegments[i];
+                        if (!routeSegment.includes('{') && routeSegment !== path[i]) {
+                            isMatch = false;
+                            break;
+                        }
+                    }
+                    if (!isMatch)
+                        continue;
+                    // Now process parameter segments
+                    for (const { index, paramName } of paramPositions) {
+                        const routeSegment = routeSegments[index];
+                        const pathSegment = path[index];
+                        let regex = this.#routeRegexCache.get(routeSegment);
+                        if (!regex) {
+                            const regexPattern = routeSegment
+                                .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+                                .replace(/\\{(\w+)\\}/g, '(?<$1>[^/]+)');
+                            regex = new RegExp(`^${regexPattern}$`);
+                            this.#routeRegexCache.set(routeSegment, regex);
+                        }
+                        const values = pathSegment.match(regex)?.groups;
+                        if (!values) {
+                            isMatch = false;
+                            break;
+                        }
+                        if (paramName in params) {
+                            throw new HttpException(HttpStatus.INTERNAL_SERVER_ERROR, `Duplicate parameter "${paramName}" at ${p}`);
+                        }
+                        params[paramName] = values[paramName];
+                    }
+                    if (isMatch) {
+                        methodParams = params;
+                        methodKeys.push(p);
+                    }
+                }
+                else {
+                    // Static route - simple equality comparison for all segments
+                    let isMatch = true;
+                    for (let i = 0; i < routeSegments.length; i++) {
+                        if (routeSegments[i] !== path[i]) {
+                            isMatch = false;
+                            break;
+                        }
+                    }
+                    if (isMatch) {
+                        methodKeys.push(p);
+                    }
+                }
+            }
+            if (methodKeys.length > 1) {
+                throw new HttpException(HttpStatus.INTERNAL_SERVER_ERROR, `Conflicting routes found: ${methodKeys.join(', ')}`);
+            }
+            [methodKey] = methodKeys;
+            // Cache successful matches
+            if (methodKey) {
+                this.#routeMatchCache.set(pathStr, { route: methodKey, params: methodParams });
+            }
+        }
+        if (methodKey) {
+            return { handler: handlers[methodKey], methodParams };
+        }
+        return { handler: null, methodParams };
+    };
+    #allHandlers = {};
+    #collectHandlers = (httpMethod, segmentName) => {
+        const controllers = this.routes[httpMethod];
+        const handlers = {};
+        controllers.forEach((staticMethods, controller) => {
+            if (segmentName !== controller._segmentName)
+                return;
+            const prefix = controller._prefix ?? '';
+            Object.entries(staticMethods ?? {}).forEach(([path, staticMethod]) => {
+                const fullPath = [prefix, path].filter(Boolean).join('/');
+                handlers[fullPath] = { staticMethod, controller };
+            });
+        });
+        return handlers;
+    };
+    #callMethod = async ({ httpMethod, req: request, params, segmentName, }) => {
+        const req = request;
+        const path = params[Object.keys(params)[0]] ?? [];
+        const handlers = this.#allHandlers[segmentName]?.[httpMethod] ?? this.#collectHandlers(httpMethod, segmentName);
+        this.#allHandlers[segmentName] ??= {};
+        this.#allHandlers[segmentName][httpMethod] = handlers;
+        let headerList;
+        try {
+            headerList = request.headers;
+        }
+        catch {
+            // this is static rendering environment, headers are not available
+            headerList = null;
+        }
+        const xMeta = headerList?.get('x-meta');
+        const xMetaHeader = xMeta && JSON.parse(xMeta);
+        if (xMetaHeader)
+            reqMeta(req, { xMetaHeader });
+        const { handler, methodParams } = this.#getHandler({ handlers, path, params });
+        if (!handler) {
+            return this.#respondWithError({
+                req,
+                statusCode: HttpStatus.NOT_FOUND,
+                message: `Route '${path.join('/')}' is not found for ${httpMethod} method at ${segmentName === '' ? 'the root segment' : `segment '${segmentName}'`}`,
+            });
+        }
+        const { staticMethod, controller } = handler;
+        const headersFromDecoratorOptions = _a.getHeadersFromDecoratorOptions(staticMethod._options);
+        const { _onSuccess: onSuccess, _onBefore: onBefore } = controller;
+        req.vovk = {
+            body: () => parseBody(req),
+            query: () => reqQuery(req),
+            meta: (meta) => reqMeta(req, meta),
+            params: () => methodParams,
+        };
+        try {
+            await staticMethod._options?.before?.call(controller, req);
+            await onBefore?.(req);
+            const result = await staticMethod.call(controller, req, methodParams);
+            if (result instanceof Response) {
+                await onSuccess?.(result, req);
+                // set headers from decorator options
+                for (const [key, value] of Object.entries(headersFromDecoratorOptions)) {
+                    if (!result.headers.has(key)) {
+                        result.headers.set(key, value);
+                    }
+                }
+                return result;
+            }
+            if (result instanceof Responder) {
+                await onSuccess?.(result, req);
+                // set headers from decorator options
+                for (const [key, value] of Object.entries(headersFromDecoratorOptions)) {
+                    if (!result.response.headers.has(key)) {
+                        result.response.headers.set(key, value);
+                    }
+                }
+                return result.response;
+            }
+            const isIterator = typeof result === 'object' &&
+                !!result &&
+                !(result instanceof Array) &&
+                ((Reflect.has(result, Symbol.iterator) &&
+                    typeof result[Symbol.iterator] === 'function') ||
+                    (Reflect.has(result, Symbol.asyncIterator) &&
+                        typeof result[Symbol.asyncIterator] === 'function'));
+            if (isIterator) {
+                const responder = new JSONLinesResponder(req, ({ headers, readableStream }) => new Response(readableStream, {
+                    headers: { ...headersFromDecoratorOptions, ...headers },
+                }));
+                void (async () => {
+                    try {
+                        for await (const chunk of result) {
+                            await responder.send(chunk);
+                        }
+                    }
+                    catch (e) {
+                        return responder.throw(e);
+                    }
+                    return responder.close();
+                })();
+                await onSuccess?.(responder, req);
+                return responder.response;
+            }
+            const responseBody = result ?? null;
+            await onSuccess?.(responseBody, req);
+            return this.respond({ req, statusCode: 200, responseBody, options: staticMethod._options });
+        }
+        catch (e) {
+            const err = e;
+            try {
+                await controller._onError?.(err, req);
+            }
+            catch (onErrorError) {
+                // eslint-disable-next-line no-console
+                console.error('An error caught in onError handler:', onErrorError);
+            }
+            if (err.message !== 'NEXT_REDIRECT' && err.message !== 'NEXT_NOT_FOUND') {
+                const statusCode = err.statusCode || HttpStatus.INTERNAL_SERVER_ERROR;
+                return this.#respondWithError({
+                    req,
+                    statusCode,
+                    message: err.message,
+                    options: staticMethod._options,
+                    cause: err.cause,
+                });
+            }
+            throw e; // if NEXT_REDIRECT or NEXT_NOT_FOUND, rethrow it
+        }
+    };
+}
+_a = VovkApp;
+const vovkApp = new VovkApp();
+export { vovkApp };