vovk 3.0.0-draft.99 → 3.0.0

package/dist/{utils → client}/serializeQuery.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = serializeQuery;
 /**
  * Recursively build query parameters from an object.
  *
@@ -50,7 +47,7 @@ function buildParams(key, value) {
  * @param obj - The input object to be serialized
  * @returns   - A bracket-based query string (without leading "?")
  */
-function serializeQuery(obj) {
+export function serializeQuery(obj) {
     if (!obj || typeof obj !== 'object')
         return '';
     // Collect query segments

package/dist/core/HttpException.d.ts

@@ -0,0 +1,16 @@
+import type { VovkErrorResponse } from '../types/core.js';
+import type { HttpStatus } from '../types/enums.js';
+/**
+ * Represents an HTTP exception with a status code and message.
+ * @example
+ * ```ts
+ * throw new HttpException(HttpStatus.BAD_REQUEST, 'Invalid request data');
+ * ```
+ */
+export declare class HttpException extends Error {
+    statusCode: HttpStatus;
+    message: string;
+    cause?: unknown;
+    constructor(statusCode: HttpStatus, message: string, cause?: unknown);
+    toJSON(): VovkErrorResponse;
+}

package/dist/core/HttpException.js

@@ -0,0 +1,26 @@
+/**
+ * Represents an HTTP exception with a status code and message.
+ * @example
+ * ```ts
+ * throw new HttpException(HttpStatus.BAD_REQUEST, 'Invalid request data');
+ * ```
+ */
+export class HttpException extends Error {
+    statusCode;
+    message;
+    cause;
+    constructor(statusCode, message, cause) {
+        super(message);
+        this.statusCode = statusCode;
+        this.message = message;
+        this.cause = cause;
+    }
+    toJSON() {
+        return {
+            isError: true,
+            statusCode: this.statusCode,
+            message: this.message,
+            ...(this.cause ? { cause: this.cause } : {}),
+        };
+    }
+}

package/dist/core/JSONLinesResponder.d.ts

@@ -0,0 +1,42 @@
+import type { StreamAbortMessage } from '../types/core.js';
+import '../utils/shim.js';
+export declare abstract class Responder {
+    response: Response;
+}
+/**
+ * A Responder subclass for streaming JSON Lines (JSONL) data.
+ * @see https://vovk.dev/jsonlines
+ * @param request The incoming Request object.
+ * @param getResponse Optional function to create a custom Response object.
+ * @example
+ * ```ts
+ * import { JSONLinesResponder } from 'vovk';
+ *
+ * const responder = new JSONLinesResponder<MyItemType>(request, (responder) => {
+ *   return new Response(responder.readableStream, { headers: responder.headers });
+ * });
+ *
+ * // Send items
+ * responder.send({ ... });
+ * // Close the stream when done
+ * responder.close();
+ * // Or throw an error
+ * responder.throw(new Error('Something went wrong'));
+ * // get the Response object, headers, etc.
+ * const { response, headers } = responder;
+ * ```
+ */
+export declare class JSONLinesResponder<T> extends Responder {
+    private isClosed;
+    private i;
+    private controller?;
+    private readonly encoder;
+    readonly readableStream: ReadableStream | null;
+    readonly headers: Record<string, string>;
+    onBeforeSend: (item: T, i: number) => T | Promise<T>;
+    constructor(request?: Request | null, getResponse?: (responder: JSONLinesResponder<T>) => Response);
+    readonly send: (item: T) => Promise<void>;
+    sendLineOrError: (data: T | StreamAbortMessage) => void;
+    readonly close: () => void;
+    readonly throw: (e: unknown) => void;
+}

package/dist/core/JSONLinesResponder.js

@@ -0,0 +1,92 @@
+import '../utils/shim.js';
+export class Responder {
+    response;
+}
+/**
+ * A Responder subclass for streaming JSON Lines (JSONL) data.
+ * @see https://vovk.dev/jsonlines
+ * @param request The incoming Request object.
+ * @param getResponse Optional function to create a custom Response object.
+ * @example
+ * ```ts
+ * import { JSONLinesResponder } from 'vovk';
+ *
+ * const responder = new JSONLinesResponder<MyItemType>(request, (responder) => {
+ *   return new Response(responder.readableStream, { headers: responder.headers });
+ * });
+ *
+ * // Send items
+ * responder.send({ ... });
+ * // Close the stream when done
+ * responder.close();
+ * // Or throw an error
+ * responder.throw(new Error('Something went wrong'));
+ * // get the Response object, headers, etc.
+ * const { response, headers } = responder;
+ * ```
+ */
+export class JSONLinesResponder extends Responder {
+    isClosed = false;
+    i = 0;
+    controller;
+    encoder;
+    readableStream;
+    headers;
+    onBeforeSend = (item) => item;
+    constructor(request, getResponse) {
+        super();
+        const encoder = new TextEncoder();
+        let readableController;
+        const readableStream = new ReadableStream({
+            cancel: () => {
+                this.isClosed = true;
+            },
+            start: (controller) => {
+                readableController = controller;
+            },
+        });
+        const accept = request?.headers?.get('accept');
+        const headers = {
+            'content-type': accept?.includes('application/jsonl')
+                ? 'application/jsonl; charset=utf-8'
+                : 'text/plain; charset=utf-8',
+        };
+        this.headers = headers;
+        this.readableStream = readableStream;
+        this.encoder = encoder;
+        this.controller = readableController;
+        this.response = getResponse?.(this) ?? new Response(readableStream, { headers });
+        request?.signal?.addEventListener('abort', this.close, { once: true });
+        // this will make promise on the client-side to resolve immediately, before sending the first JSON line
+        this.controller?.enqueue(encoder?.encode(''));
+    }
+    send = async (item) => {
+        try {
+            // onBeforeSend is set by withValidationLibrary if iteration validation is provided
+            // in case if data is streamed immediately in a controller/service, we're going to lose the first iteration validation
+            // the await with zero timeout ensures onBeforeSend is set before the first send
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            this.sendLineOrError(await this.onBeforeSend(item, this.i++));
+        }
+        catch (e) {
+            this.throw(e);
+        }
+    };
+    sendLineOrError = (data) => {
+        const { controller, encoder } = this;
+        if (this.isClosed)
+            return;
+        controller?.enqueue(encoder?.encode(JSON.stringify(data) + '\n'));
+    };
+    close = () => {
+        const { controller } = this;
+        if (this.isClosed)
+            return;
+        this.isClosed = true;
+        controller?.close();
+    };
+    throw = (e) => {
+        this.sendLineOrError({ isError: true, reason: e instanceof Error ? e.message : e });
+        return this.close();
+    };
+}

package/dist/core/controllersToStaticParams.d.ts

@@ -0,0 +1,13 @@
+import type { StaticClass } from '../types/utils.js';
+/**
+ * Generates static API of the given controllers for a static segment.
+ * @see https://vovk.dev/segment
+ * @example
+ * ```ts
+ * export function generateStaticParams() {
+ *  return controllersToStaticParams(controllers);
+ * }
+ */
+export declare function controllersToStaticParams(c: Record<string, StaticClass>, slug?: string): {
+    [slug]: string[];
+}[];

package/dist/core/controllersToStaticParams.js

@@ -0,0 +1,36 @@
+/**
+ * Generates static API of the given controllers for a static segment.
+ * @see https://vovk.dev/segment
+ * @example
+ * ```ts
+ * export function generateStaticParams() {
+ *  return controllersToStaticParams(controllers);
+ * }
+ */
+export function controllersToStaticParams(c, slug = 'vovk') {
+    const controllers = c;
+    return [
+        { [slug]: ['_schema_'] },
+        ...Object.values(controllers)
+            .map((controller) => {
+            const handlers = controller._handlers;
+            const splitPrefix = controller._prefix?.split('/') ?? [];
+            return Object.entries(handlers ?? {})
+                .map(([name, handler]) => {
+                const staticParams = controller._handlersMetadata?.[name]?.staticParams;
+                if (staticParams?.length) {
+                    return staticParams.map((paramsItem) => {
+                        let path = handler.path;
+                        for (const [key, value] of Object.entries(paramsItem ?? {})) {
+                            path = path.replace(`{${key}}`, value);
+                        }
+                        return { [slug]: [...splitPrefix, ...path.split('/')].filter(Boolean) };
+                    });
+                }
+                return [{ [slug]: [...splitPrefix, ...handler.path.split('/')].filter(Boolean) }];
+            })
+                .flat();
+        })
+            .flat(),
+    ];
+}

package/dist/core/createDecorator.d.ts

@@ -0,0 +1,12 @@
+import type { VovkHandlerSchema, VovkController } from '../types/core.js';
+import type { VovkRequest } from '../types/request.js';
+import type { KnownAny } from '../types/utils.js';
+type Next = () => Promise<unknown>;
+/**
+ * Creates a custom decorator for Vovk controllers.
+ * @see https://vovk.dev/decorator
+ */
+export declare function createDecorator<TArgs extends unknown[], TRequest = VovkRequest>(handler: null | ((this: VovkController, req: TRequest, next: Next, ...args: TArgs) => unknown), initHandler?: (this: VovkController, ...args: TArgs) => Omit<VovkHandlerSchema, 'path' | 'httpMethod'> | ((handlerSchema: VovkHandlerSchema | null, options: {
+    handlerName: string;
+}) => Omit<Partial<VovkHandlerSchema>, 'path' | 'httpMethod'>) | null | undefined): (...args: TArgs) => (target: KnownAny, propertyKey: string) => void;
+export {};

package/dist/{createDecorator.js → core/createDecorator.js}

@@ -1,7 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDecorator = createDecorator;
-function createDecorator(handler, initHandler) {
+/**
+ * Creates a custom decorator for Vovk controllers.
+ * @see https://vovk.dev/decorator
+ */
+export function createDecorator(handler, initHandler) {
     return function decoratorCreator(...args) {
         return function decorator(target, propertyKey) {
             const controller = target;
@@ -12,13 +13,16 @@ function createDecorator(handler, initHandler) {
             const sourceMethod = originalMethod._sourceMethod ?? originalMethod;
             const method = function method(req, params) {
                 const next = async () => {
-                    return (await originalMethod.call(controller, req, params));
+                    return await originalMethod.call(controller, req, params);
                 };
                 return handler ? handler.call(controller, req, next, ...args) : next();
             };
             controller[propertyKey] = method;
             method._controller = controller;
             method._sourceMethod = sourceMethod;
+            method.fn = originalMethod.fn;
+            method.definition = originalMethod.definition;
+            sourceMethod.wrapper = method;
             // TODO define internal method type
             originalMethod._controller = controller;
             const handlerSchema = controller._handlers?.[propertyKey] ?? null;
@@ -28,15 +32,17 @@ function createDecorator(handler, initHandler) {
                     handlerName: propertyKey,
                 })
                 : initResultReturn;
+            const methodSchema = {
+                ...handlerSchema,
+                // avoid override of path and httpMethod
+                ...(initResult?.validation ? { validation: initResult.validation } : {}),
+                ...(initResult?.operationObject ? { operationObject: initResult.operationObject } : {}),
+                ...(initResult?.misc ? { misc: initResult.misc } : {}),
+            };
+            method.schema = methodSchema;
             controller._handlers = {
                 ...controller._handlers,
-                [propertyKey]: {
-                    ...handlerSchema,
-                    // avoid override of path and httpMethod
-                    ...(initResult?.validation ? { validation: initResult.validation } : {}),
-                    ...(initResult?.openapi ? { openapi: initResult.openapi } : {}),
-                    ...(initResult?.custom ? { custom: initResult.custom } : {}),
-                },
+                [propertyKey]: methodSchema,
             };
         };
     };

package/dist/core/decorators.d.ts

@@ -0,0 +1,59 @@
+import type { DecoratorOptions } from '../types/core.js';
+import type { KnownAny } from '../types/utils.js';
+/**
+ * Prefix for all routes in the controller.
+ */
+export declare const prefix: (givenPath?: string) => (givenTarget: KnownAny) => any;
+/**
+ * Clones metadata from parent controller to child controller.
+ */
+export declare function cloneControllerMetadata(): <T extends new (...args: KnownAny[]) => KnownAny>(c: T) => T;
+/**
+ * GET HTTP method decorator.
+ */
+export declare const get: {
+    (givenPath?: string | undefined, options?: DecoratorOptions | undefined): (givenTarget: unknown, propertyKey: string) => void;
+    auto: (options?: DecoratorOptions) => (givenTarget: unknown, propertyKey: string) => void;
+};
+/**
+ *  POST HTTP method decorator.
+ */
+export declare const post: {
+    (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: unknown, propertyKey: string) => void;
+    auto: (options?: DecoratorOptions) => (givenTarget: unknown, propertyKey: string) => void;
+};
+/**
+ *  PUT HTTP method decorator.
+ */
+export declare const put: {
+    (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: unknown, propertyKey: string) => void;
+    auto: (options?: DecoratorOptions) => (givenTarget: unknown, propertyKey: string) => void;
+};
+/**
+ *  PATCH HTTP method decorator.
+ */
+export declare const patch: {
+    (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: unknown, propertyKey: string) => void;
+    auto: (options?: DecoratorOptions) => (givenTarget: unknown, propertyKey: string) => void;
+};
+/**
+ *  DELETE HTTP method decorator.
+ */
+export declare const del: {
+    (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: unknown, propertyKey: string) => void;
+    auto: (options?: DecoratorOptions) => (givenTarget: unknown, propertyKey: string) => void;
+};
+/**
+ * HEAD HTTP method decorator.
+ */
+export declare const head: {
+    (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: unknown, propertyKey: string) => void;
+    auto: (options?: DecoratorOptions) => (givenTarget: unknown, propertyKey: string) => void;
+};
+/**
+ * OPTIONS HTTP method decorator.
+ */
+export declare const options: {
+    (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: unknown, propertyKey: string) => void;
+    auto: (options?: DecoratorOptions) => (givenTarget: unknown, propertyKey: string) => void;
+};

package/dist/core/decorators.js

@@ -0,0 +1,132 @@
+import { vovkApp } from './vovkApp.js';
+import { trimPath } from '../utils/trimPath.js';
+import { toKebabCase } from '../utils/toKebabCase.js';
+import { HttpMethod } from '../types/enums.js';
+const isClass = (func) => typeof func === 'function' && /class/.test(func.toString());
+const assignSchema = ({ controller, propertyKey, path, options, httpMethod, }) => {
+    if (typeof window !== 'undefined') {
+        throw new Error('HTTP decorators can be used on server-side only. You have probably imported a controller on the client-side.');
+    }
+    if (!isClass(controller)) {
+        let decoratorName = httpMethod.toLowerCase();
+        if (decoratorName === 'delete')
+            decoratorName = 'del';
+        throw new Error(`Decorator must be used on a static class method. Check the controller method named "${propertyKey}" used with @${decoratorName}().`);
+    }
+    const methods = vovkApp.routes[httpMethod].get(controller) ?? {};
+    vovkApp.routes[httpMethod].set(controller, methods);
+    if (options?.cors) {
+        const optionsMethods = vovkApp.routes.OPTIONS.get(controller) ?? {};
+        optionsMethods[path] = (() => { });
+        optionsMethods[path]._options = options;
+        vovkApp.routes.OPTIONS.set(controller, optionsMethods);
+    }
+    const originalMethod = controller[propertyKey];
+    originalMethod._controller = controller;
+    originalMethod._sourceMethod = originalMethod._sourceMethod ?? originalMethod;
+    const schema = originalMethod._sourceMethod._getSchema?.(controller);
+    // TODO: Some of these assignments probably not needed anymore
+    originalMethod.schema = schema;
+    originalMethod.fn = originalMethod._sourceMethod?.fn;
+    originalMethod.definition = originalMethod._sourceMethod?.definition;
+    originalMethod._sourceMethod.wrapper = originalMethod;
+    controller._handlers = {
+        ...controller._handlers,
+        [propertyKey]: {
+            ...schema,
+            ...(controller._handlers ?? {})[propertyKey],
+            path,
+            httpMethod,
+        },
+    };
+    methods[path] = originalMethod;
+    methods[path]._options = options;
+    controller._handlersMetadata = {
+        ...controller._handlersMetadata,
+        [propertyKey]: {
+            ...(controller._handlersMetadata ?? {})[propertyKey],
+            staticParams: options?.staticParams,
+        },
+    };
+};
+function createHTTPDecorator(httpMethod) {
+    function decoratorFactory(givenPath = '', options) {
+        const path = trimPath(givenPath);
+        function decorator(givenTarget, propertyKey) {
+            const controller = givenTarget;
+            assignSchema({ controller, propertyKey, path, options, httpMethod });
+        }
+        return decorator;
+    }
+    const auto = (options) => {
+        function decorator(givenTarget, propertyKey) {
+            const controller = givenTarget;
+            // validation is already assigned at procedure function
+            const properties = Object.keys((controller._handlers ?? {})[propertyKey]?.validation?.params?.properties ?? {});
+            const kebabCasePath = toKebabCase(propertyKey);
+            const path = properties.length
+                ? `${kebabCasePath}/${properties.map((prop) => `{${prop}}`).join('/')}`
+                : kebabCasePath;
+            assignSchema({ controller, propertyKey, path, options, httpMethod });
+        }
+        return decorator;
+    };
+    const decoratorFactoryWithAuto = decoratorFactory;
+    decoratorFactoryWithAuto.auto = auto;
+    return decoratorFactoryWithAuto;
+}
+/**
+ * Prefix for all routes in the controller.
+ */
+export const prefix = (givenPath = '') => {
+    const path = trimPath(givenPath);
+    return (givenTarget) => {
+        const controller = givenTarget;
+        controller._prefix = path;
+        return givenTarget;
+    };
+};
+/**
+ * Clones metadata from parent controller to child controller.
+ */
+export function cloneControllerMetadata() {
+    return function inherit(c) {
+        const parent = Object.getPrototypeOf(c);
+        const constructor = c;
+        constructor._handlers = { ...parent._handlers, ...constructor._handlers };
+        constructor._handlersMetadata = { ...parent._handlersMetadata, ...constructor._handlersMetadata };
+        Object.values(vovkApp.routes).forEach((methods) => {
+            const parentMethods = methods.get(parent) ?? {};
+            methods.set(constructor, { ...parentMethods, ...methods.get(constructor) });
+        });
+        return constructor;
+    };
+}
+/**
+ * GET HTTP method decorator.
+ */
+export const get = createHTTPDecorator(HttpMethod.GET);
+/**
+ *  POST HTTP method decorator.
+ */
+export const post = createHTTPDecorator(HttpMethod.POST);
+/**
+ *  PUT HTTP method decorator.
+ */
+export const put = createHTTPDecorator(HttpMethod.PUT);
+/**
+ *  PATCH HTTP method decorator.
+ */
+export const patch = createHTTPDecorator(HttpMethod.PATCH);
+/**
+ *  DELETE HTTP method decorator.
+ */
+export const del = createHTTPDecorator(HttpMethod.DELETE);
+/**
+ * HEAD HTTP method decorator.
+ */
+export const head = createHTTPDecorator(HttpMethod.HEAD);
+/**
+ * OPTIONS HTTP method decorator.
+ */
+export const options = createHTTPDecorator(HttpMethod.OPTIONS);

package/dist/core/getSchema.d.ts

@@ -0,0 +1,21 @@
+import type { VovkSegmentSchema, VovkController } from '../types/core.js';
+import type { StaticClass } from '../types/utils.js';
+export declare function getControllerSchema(controller: VovkController, rpcModuleName: string, exposeValidation: boolean): Promise<{
+    rpcModuleName: string;
+    originalControllerName: string;
+    prefix: string;
+    handlers: {
+        [k: string]: {
+            path: string;
+            httpMethod: string;
+            operationObject?: import("../internal.js").VovkOperationObject;
+            misc?: Record<string, unknown>;
+        };
+    };
+}>;
+export declare function getSchema(options: {
+    emitSchema?: boolean;
+    segmentName?: string;
+    controllers: Record<string, StaticClass>;
+    exposeValidation?: boolean;
+}): Promise<VovkSegmentSchema>;

package/dist/core/getSchema.js

@@ -0,0 +1,31 @@
+import { VovkSchemaIdEnum } from '../types/enums.js';
+export async function getControllerSchema(controller, rpcModuleName, exposeValidation) {
+    const handlers = exposeValidation
+        ? (controller._handlers ?? {})
+        : Object.fromEntries(
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        Object.entries(controller._handlers ?? {}).map(([key, { validation: _v, ...value }]) => [key, value]));
+    return {
+        rpcModuleName,
+        originalControllerName: controller.name,
+        prefix: controller._prefix ?? '',
+        handlers,
+    };
+}
+export async function getSchema(options) {
+    const exposeValidation = options?.exposeValidation ?? true;
+    const emitSchema = options.emitSchema ?? true;
+    const schema = {
+        $schema: VovkSchemaIdEnum.SEGMENT,
+        emitSchema,
+        segmentName: options.segmentName ?? '',
+        segmentType: 'segment',
+        controllers: {},
+    };
+    if (!emitSchema)
+        return schema;
+    for (const [rpcModuleName, controller] of Object.entries(options.controllers ?? {})) {
+        schema.controllers[rpcModuleName] = await getControllerSchema(controller, rpcModuleName, exposeValidation);
+    }
+    return schema;
+}

package/dist/core/initSegment.d.ts

@@ -0,0 +1,33 @@
+import type { VovkRequest } from '../types/request.js';
+import type { StaticClass } from '../types/utils.js';
+export declare const initSegment: (options: {
+    segmentName?: string;
+    controllers: Record<string, StaticClass>;
+    exposeValidation?: boolean;
+    emitSchema?: boolean;
+    onError?: (err: Error, req: VovkRequest) => void | Promise<void>;
+    onSuccess?: (resp: unknown, req: VovkRequest) => void | Promise<void>;
+    onBefore?: (req: VovkRequest) => void | Promise<void>;
+}) => {
+    GET: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    POST: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    PUT: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    PATCH: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    DELETE: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    HEAD: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    OPTIONS: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+};

package/dist/core/initSegment.js

@@ -0,0 +1,35 @@
+import { vovkApp } from './vovkApp.js';
+import { trimPath } from '../utils/trimPath.js';
+import { getSchema } from './getSchema.js';
+export const initSegment = (options) => {
+    const segmentName = trimPath(options.segmentName ?? '');
+    options.segmentName = segmentName;
+    for (const [rpcModuleName, controller] of Object.entries(options.controllers ?? {})) {
+        controller._segmentName = segmentName;
+        controller._rpcModuleName = rpcModuleName;
+        controller._onError = options?.onError;
+        controller._onSuccess = options?.onSuccess;
+        controller._onBefore = options?.onBefore;
+    }
+    async function GET_DEV(req, data) {
+        const params = await data.params;
+        if (params[Object.keys(params)[0]]?.[0] === '_schema_') {
+            const schema = await getSchema(options);
+            return vovkApp.respond({
+                req,
+                statusCode: 200,
+                responseBody: { schema },
+            });
+        }
+        return vovkApp.GET(req, data, segmentName);
+    }
+    return {
+        GET: process.env.NODE_ENV === 'development' ? GET_DEV : (req, data) => vovkApp.GET(req, data, segmentName),
+        POST: (req, data) => vovkApp.POST(req, data, segmentName),
+        PUT: (req, data) => vovkApp.PUT(req, data, segmentName),
+        PATCH: (req, data) => vovkApp.PATCH(req, data, segmentName),
+        DELETE: (req, data) => vovkApp.DELETE(req, data, segmentName),
+        HEAD: (req, data) => vovkApp.HEAD(req, data, segmentName),
+        OPTIONS: (req, data) => vovkApp.OPTIONS(req, data, segmentName),
+    };
+};

package/dist/core/multitenant.d.ts

@@ -0,0 +1,33 @@
+type Override = {
+    from: string;
+    to: string;
+};
+type Config = {
+    requestUrl: string;
+    requestHost: string;
+    targetHost: string;
+    overrides: {
+        [key: string]: Override[];
+    };
+};
+/**
+ * Multitenant function to handle subdomain and path-based routing overrides.
+ * @see https://vovk.dev/multitenant
+ */
+export declare function multitenant(config: Config): {
+    action: null;
+    destination: null;
+    message: string;
+    subdomains: null;
+} | {
+    action: "redirect";
+    destination: string;
+    message: string;
+    subdomains: null;
+} | {
+    action: "rewrite";
+    destination: string;
+    message: string;
+    subdomains: Record<string, string> | null;
+};
+export {};