vovk 3.0.0-draft.46 → 3.0.0-draft.461

package/VovkApp.js

@@ -1,185 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VovkApp = void 0;
-const types_1 = require("./types");
-const HttpException_1 = require("./HttpException");
-const StreamJSONResponse_1 = require("./StreamJSONResponse");
-const reqQuery_1 = __importDefault(require("./utils/reqQuery"));
-const reqMeta_1 = __importDefault(require("./utils/reqMeta"));
-const reqForm_1 = __importDefault(require("./utils/reqForm"));
-class VovkApp {
-    static getHeadersFromOptions(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) => this.#callMethod(types_1.HttpMethod.GET, req, await data.params);
-    POST = async (req, data) => this.#callMethod(types_1.HttpMethod.POST, req, await data.params);
-    PUT = async (req, data) => this.#callMethod(types_1.HttpMethod.PUT, req, await data.params);
-    PATCH = async (req, data) => this.#callMethod(types_1.HttpMethod.PATCH, req, await data.params);
-    DELETE = async (req, data) => this.#callMethod(types_1.HttpMethod.DELETE, req, await data.params);
-    HEAD = async (req, data) => this.#callMethod(types_1.HttpMethod.HEAD, req, await data.params);
-    OPTIONS = async (req, data) => this.#callMethod(types_1.HttpMethod.OPTIONS, req, await data.params);
-    respond = (status, body, options) => {
-        return new Response(JSON.stringify(body), {
-            status,
-            headers: {
-                'Content-Type': 'application/json',
-                ..._a.getHeadersFromOptions(options),
-            },
-        });
-    };
-    #respondWithError = (statusCode, message, options, cause) => {
-        return this.respond(statusCode, {
-            cause,
-            statusCode,
-            message,
-            isError: true,
-        }, options);
-    };
-    #callMethod = async (httpMethod, req, params) => {
-        const controllers = this.routes[httpMethod];
-        const methodParams = {};
-        const path = params[Object.keys(params)[0]];
-        const handlers = {};
-        controllers.forEach((staticMethods, controller) => {
-            const prefix = controller._prefix ?? '';
-            if (!controller._activated) {
-                throw new HttpException_1.HttpException(types_1.HttpStatus.INTERNAL_SERVER_ERROR, `Controller "${controller.name}" found but not activated`);
-            }
-            Object.entries(staticMethods).forEach(([path, staticMethod]) => {
-                const fullPath = [prefix, path].filter(Boolean).join('/');
-                handlers[fullPath] = { staticMethod, controller };
-            });
-        });
-        const getHandler = () => {
-            if (Object.keys(params).length === 0) {
-                return handlers[''];
-            }
-            const allMethodKeys = Object.keys(handlers);
-            let methodKeys = [];
-            methodKeys = allMethodKeys
-                // First, try to match literal routes exactly.
-                .filter((p) => {
-                if (p.includes(':'))
-                    return false; // Skip parameterized paths
-                return p === path.join('/');
-            });
-            if (!methodKeys.length) {
-                methodKeys = allMethodKeys.filter((p) => {
-                    const routeSegments = p.split('/');
-                    if (routeSegments.length !== path.length)
-                        return false;
-                    for (let i = 0; i < routeSegments.length; i++) {
-                        const routeSegment = routeSegments[i];
-                        const pathSegment = path[i];
-                        if (routeSegment.startsWith(':')) {
-                            const parameter = routeSegment.slice(1);
-                            if (parameter in methodParams) {
-                                throw new HttpException_1.HttpException(types_1.HttpStatus.INTERNAL_SERVER_ERROR, `Duplicate parameter "${parameter}"`);
-                            }
-                            // If it's a parameterized segment, capture the parameter value.
-                            methodParams[parameter] = pathSegment;
-                        }
-                        else if (routeSegment !== pathSegment) {
-                            // If it's a literal segment and it does not match the corresponding path segment, return false.
-                            return false;
-                        }
-                    }
-                    return true;
-                });
-            }
-            if (methodKeys.length > 1) {
-                throw new HttpException_1.HttpException(types_1.HttpStatus.INTERNAL_SERVER_ERROR, `Conflicting routes found: ${methodKeys.join(', ')}`);
-            }
-            const [methodKey] = methodKeys;
-            if (methodKey) {
-                return handlers[methodKey];
-            }
-            return null;
-        };
-        const handler = getHandler();
-        if (!handler) {
-            return this.#respondWithError(types_1.HttpStatus.NOT_FOUND, `Route ${path.join('/')} is not found`);
-        }
-        const { staticMethod, controller } = handler;
-        req.vovk = {
-            body: () => req.json(),
-            query: () => (0, reqQuery_1.default)(req),
-            meta: (meta) => (0, reqMeta_1.default)(req, meta),
-            form: () => (0, reqForm_1.default)(req),
-        };
-        try {
-            const result = await staticMethod.call(controller, req, methodParams);
-            const isIterator = typeof result === 'object' &&
-                !!result &&
-                ((Reflect.has(result, Symbol.iterator) &&
-                    typeof result[Symbol.iterator] === 'function') ||
-                    (Reflect.has(result, Symbol.asyncIterator) &&
-                        typeof result[Symbol.asyncIterator] === 'function'));
-            if (isIterator && !(result instanceof Array)) {
-                const streamResponse = new StreamJSONResponse_1.StreamJSONResponse({
-                    headers: {
-                        ...StreamJSONResponse_1.StreamJSONResponse.defaultHeaders,
-                        ..._a.getHeadersFromOptions(staticMethod._options),
-                    },
-                });
-                void (async () => {
-                    try {
-                        for await (const chunk of result) {
-                            streamResponse.send(chunk);
-                        }
-                    }
-                    catch (e) {
-                        return streamResponse.throw(e);
-                    }
-                    return streamResponse.close();
-                })();
-                return streamResponse;
-            }
-            if (result instanceof Response) {
-                return result;
-            }
-            return this.respond(200, result ?? null, staticMethod._options);
-        }
-        catch (e) {
-            const err = e;
-            try {
-                await controller._onError?.(err, req);
-            }
-            catch (onErrorError) {
-                // eslint-disable-next-line no-console
-                console.error(onErrorError);
-            }
-            if (err.message !== 'NEXT_REDIRECT' && err.message !== 'NEXT_NOT_FOUND') {
-                const statusCode = err.statusCode ?? types_1.HttpStatus.INTERNAL_SERVER_ERROR;
-                return this.#respondWithError(statusCode, err.message, staticMethod._options, err.cause);
-            }
-            throw e; // if NEXT_REDIRECT or NEXT_NOT_FOUND, rethrow it
-        }
-    };
-}
-exports.VovkApp = VovkApp;
-_a = VovkApp;

package/client/clientizeController.d.ts

@@ -1,4 +0,0 @@
-import { type VovkControllerSchema, type KnownAny } from '../types';
-import { type VovkClientOptions, type VovkClient, type VovkDefaultFetcherOptions } from './types';
-export declare const ARRAY_QUERY_KEY = "_vovkarr";
-export declare const clientizeController: <T, OPTS extends Record<string, KnownAny> = VovkDefaultFetcherOptions>(controllerSchema: VovkControllerSchema, segmentName?: string, options?: VovkClientOptions<OPTS>) => VovkClient<T, OPTS>;

package/client/clientizeController.js

@@ -1,93 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.clientizeController = exports.ARRAY_QUERY_KEY = void 0;
-const defaultFetcher_1 = __importDefault(require("./defaultFetcher"));
-const defaultHandler_1 = require("./defaultHandler");
-const defaultStreamHandler_1 = require("./defaultStreamHandler");
-// TODO Ugly workaround. Need your ideas how to distinguish between array and non-array query params
-exports.ARRAY_QUERY_KEY = '_vovkarr';
-const trimPath = (path) => path.trim().replace(/^\/|\/$/g, '');
-const getHandlerPath = (endpoint, params, query) => {
-    let result = endpoint;
-    for (const [key, value] of Object.entries(params ?? {})) {
-        result = result.replace(`:${key}`, value);
-    }
-    const searchParams = new URLSearchParams();
-    let hasQuery = false;
-    const arrayKeys = [];
-    for (const [key, value] of Object.entries(query ?? {})) {
-        if (typeof value === 'undefined')
-            continue;
-        if (value instanceof Array) {
-            arrayKeys.push(key);
-            for (const val of value) {
-                searchParams.append(key, val);
-            }
-        }
-        else {
-            searchParams.set(key, value);
-        }
-        hasQuery = true;
-    }
-    if (arrayKeys.length) {
-        searchParams.set(exports.ARRAY_QUERY_KEY, arrayKeys.join(','));
-    }
-    return `${result}${hasQuery ? '?' : ''}${searchParams.toString()}`;
-};
-const clientizeController = (controllerSchema, segmentName, options) => {
-    const schema = controllerSchema;
-    const client = {};
-    if (!schema)
-        throw new Error(`Unable to clientize. Controller schema is not provided`);
-    if (!schema.handlers)
-        throw new Error(`Unable to clientize. No schema for controller ${String(schema?.controllerName)} provided`);
-    const controllerPrefix = trimPath(schema.prefix ?? '');
-    const { fetcher: settingsFetcher = defaultFetcher_1.default } = options ?? {};
-    for (const [staticMethodName, { path, httpMethod, validation }] of Object.entries(schema.handlers)) {
-        const getEndpoint = ({ apiRoot, params, query, }) => {
-            const mainPrefix = (apiRoot.startsWith('http://') || apiRoot.startsWith('https://') || apiRoot.startsWith('/') ? '' : '/') +
-                (apiRoot.endsWith('/') ? apiRoot : `${apiRoot}/`) +
-                (segmentName ? `${segmentName}/` : '');
-            return mainPrefix + getHandlerPath([controllerPrefix, path].filter(Boolean).join('/'), params, query);
-        };
-        const handler = (input = {}) => {
-            const fetcher = input.fetcher ?? settingsFetcher;
-            const validate = async ({ body, query, endpoint }) => {
-                await (input.validateOnClient ?? options?.validateOnClient)?.({ body, query, endpoint }, validation ?? {});
-            };
-            const internalOptions = {
-                name: staticMethodName,
-                httpMethod,
-                getEndpoint,
-                validate,
-                defaultHandler: defaultHandler_1.defaultHandler,
-                defaultStreamHandler: defaultStreamHandler_1.defaultStreamHandler,
-            };
-            const internalInput = {
-                ...options?.defaultOptions,
-                ...input,
-                body: input.body ?? null,
-                query: input.query ?? {},
-                params: input.params ?? {},
-                // TS workaround
-                fetcher: undefined,
-                validateOnClient: undefined,
-            };
-            delete internalInput.fetcher;
-            delete internalInput.validateOnClient;
-            if (!fetcher)
-                throw new Error('Fetcher is not provided');
-            const fetcherPromise = fetcher(internalOptions, internalInput);
-            if (!(fetcherPromise instanceof Promise))
-                return Promise.resolve(fetcherPromise);
-            return input.transform ? fetcherPromise.then(input.transform) : fetcherPromise;
-        };
-        // @ts-expect-error TODO
-        client[staticMethodName] = handler;
-    }
-    return client;
-};
-exports.clientizeController = clientizeController;

package/client/defaultFetcher.d.ts

@@ -1,4 +0,0 @@
-import type { VovkDefaultFetcherOptions, VovkClientFetcher } from './types';
-export declare const DEFAULT_ERROR_MESSAGE = "Unknown error at the defaultFetcher";
-declare const defaultFetcher: VovkClientFetcher<VovkDefaultFetcherOptions>;
-export default defaultFetcher;

package/client/defaultFetcher.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_ERROR_MESSAGE = void 0;
-const types_1 = require("../types");
-const HttpException_1 = require("../HttpException");
-exports.DEFAULT_ERROR_MESSAGE = 'Unknown error at the defaultFetcher';
-// defaultFetcher uses HttpException class to throw errors of fake HTTP status 0 if client-side error occurs
-// For normal HTTP errors, it uses message and status code from the response of VovkErrorResponse type
-const defaultFetcher = async ({ httpMethod, getEndpoint, validate, defaultHandler, defaultStreamHandler }, { params, query, body, apiRoot = '/api', ...options }) => {
-    const endpoint = getEndpoint({ apiRoot, params, query });
-    if (!options.disableClientValidation) {
-        try {
-            await validate({ body, query, endpoint });
-        }
-        catch (e) {
-            // if HttpException is thrown, rethrow it
-            if (e instanceof HttpException_1.HttpException)
-                throw e;
-            // otherwise, throw HttpException with status 0
-            throw new HttpException_1.HttpException(types_1.HttpStatus.NULL, e.message ?? exports.DEFAULT_ERROR_MESSAGE);
-        }
-    }
-    const init = {
-        method: httpMethod,
-        ...options,
-    };
-    if (body instanceof FormData) {
-        init.body = body;
-    }
-    else if (body) {
-        init.body = JSON.stringify(body);
-    }
-    let response;
-    try {
-        response = await fetch(endpoint, init);
-    }
-    catch (e) {
-        // handle network errors
-        throw new HttpException_1.HttpException(types_1.HttpStatus.NULL, e?.message ?? exports.DEFAULT_ERROR_MESSAGE);
-    }
-    if (response.headers.get('content-type')?.includes('application/json')) {
-        return defaultHandler(response);
-    }
-    if (response.headers.get('x-vovk-stream') === 'true') {
-        return defaultStreamHandler(response);
-    }
-    return response;
-};
-exports.default = defaultFetcher;

package/client/defaultHandler.d.ts

@@ -1,2 +0,0 @@
-export declare const DEFAULT_ERROR_MESSAGE = "Unknown error at defaultHandler";
-export declare const defaultHandler: (response: Response) => Promise<unknown>;

package/client/defaultStreamHandler.d.ts

@@ -1,4 +0,0 @@
-import type { StreamAsyncIterator } from './types';
-import '../utils/shim';
-export declare const DEFAULT_ERROR_MESSAGE = "Unknown error at defaultStreamHandler";
-export declare const defaultStreamHandler: (response: Response) => Promise<StreamAsyncIterator<unknown>>;

package/client/index.d.ts

@@ -1,4 +0,0 @@
-import { clientizeController } from './clientizeController';
-import type { VovkClientFetcher, VovkClientOptions, VovkDefaultFetcherOptions } from './types';
-export { clientizeController };
-export type { VovkClientFetcher, VovkClientOptions, VovkDefaultFetcherOptions };

package/client/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.clientizeController = void 0;
-const clientizeController_1 = require("./clientizeController");
-Object.defineProperty(exports, "clientizeController", { enumerable: true, get: function () { return clientizeController_1.clientizeController; } });

package/client/types.d.ts

@@ -1,100 +0,0 @@
-import type { KnownAny, HttpMethod, ControllerStaticMethod, VovkControllerBody, VovkControllerQuery, VovkControllerParams } from '../types';
-import type { StreamJSONResponse } from '../StreamJSONResponse';
-import type { NextResponse } from 'next/server';
-export type StaticMethodInput<T extends ControllerStaticMethod> = (VovkControllerBody<T> extends undefined | void ? {
-    body?: undefined;
-} : VovkControllerBody<T> extends null ? {
-    body?: null;
-} : {
-    body: VovkControllerBody<T>;
-}) & (VovkControllerQuery<T> extends undefined | void ? {
-    query?: undefined;
-} : {
-    query: VovkControllerQuery<T>;
-}) & (VovkControllerParams<T> extends undefined | void ? {
-    params?: undefined;
-} : {
-    params: VovkControllerParams<T>;
-});
-type ToPromise<T> = T extends PromiseLike<unknown> ? T : Promise<T>;
-export type StreamAsyncIterator<T> = {
-    status: number;
-    [Symbol.dispose](): Promise<void> | void;
-    [Symbol.asyncDispose](): Promise<void> | void;
-    [Symbol.asyncIterator](): AsyncIterator<T>;
-    cancel: () => Promise<void> | void;
-};
-type StaticMethodReturn<T extends ControllerStaticMethod> = ReturnType<T> extends NextResponse<infer U> | Promise<NextResponse<infer U>> ? U : ReturnType<T> extends Response | Promise<Response> ? Awaited<ReturnType<T>> : ReturnType<T>;
-type StaticMethodReturnPromise<T extends ControllerStaticMethod> = ToPromise<StaticMethodReturn<T>>;
-type ClientMethod<T extends (...args: KnownAny[]) => void | object | StreamJSONResponse<STREAM> | Promise<StreamJSONResponse<STREAM>>, OPTS extends Record<string, KnownAny>, STREAM extends KnownAny = unknown> = <R>(options: (StaticMethodInput<T> extends {
-    body?: undefined | null;
-    query?: undefined;
-    params?: undefined;
-} ? unknown : Parameters<T>[0] extends void ? StaticMethodInput<T>['params'] extends object ? {
-    params: StaticMethodInput<T>['params'];
-} : unknown : StaticMethodInput<T>) & (Partial<OPTS & {
-    transform: (staticMethodReturn: Awaited<StaticMethodReturn<T>>) => R;
-}>)) => ReturnType<T> extends Promise<StreamJSONResponse<infer U>> | StreamJSONResponse<infer U> | Iterator<infer U> | AsyncIterator<infer U> ? Promise<StreamAsyncIterator<U>> : R extends object ? Promise<R> : StaticMethodReturnPromise<T>;
-type OmitNever<T> = {
-    [K in keyof T as T[K] extends never ? never : K]: T[K];
-};
-type VovkClientWithNever<T, OPTS extends {
-    [key: string]: KnownAny;
-}> = {
-    [K in keyof T]: T[K] extends (...args: KnownAny) => KnownAny ? ClientMethod<T[K], OPTS> : never;
-};
-export type VovkClient<T, OPTS extends {
-    [key: string]: KnownAny;
-}> = OmitNever<VovkClientWithNever<T, OPTS>>;
-export type VovkClientFetcher<OPTS extends Record<string, KnownAny> = Record<string, never>, T = KnownAny> = (options: {
-    name: keyof T;
-    httpMethod: HttpMethod;
-    getEndpoint: (data: {
-        apiRoot: string;
-        params: {
-            [key: string]: string;
-        };
-        query: {
-            [key: string]: string;
-        };
-    }) => string;
-    validate: (input: {
-        body?: unknown;
-        query?: unknown;
-        endpoint: string;
-    }) => void | Promise<void>;
-    defaultStreamHandler: (response: Response) => Promise<StreamAsyncIterator<unknown>>;
-    defaultHandler: (response: Response) => Promise<unknown>;
-}, input: {
-    body: unknown;
-    query: {
-        [key: string]: string;
-    };
-    params: {
-        [key: string]: string;
-    };
-} & OPTS) => KnownAny;
-export interface VovkDefaultFetcherOptions extends Omit<RequestInit, 'body' | 'method'> {
-    reactNative?: {
-        textStreaming: boolean;
-    };
-    apiRoot?: string;
-    segmentName?: string;
-    disableClientValidation?: boolean;
-    validateOnClient?: VovkValidateOnClient;
-    fetcher?: VovkClientFetcher;
-}
-export type VovkValidateOnClient = (input: {
-    body?: unknown;
-    query?: unknown;
-    endpoint: string;
-}, validators: {
-    body?: unknown;
-    query?: unknown;
-}) => void | Promise<void>;
-export type VovkClientOptions<OPTS extends Record<string, KnownAny> = Record<string, never>> = {
-    fetcher?: VovkClientFetcher<OPTS>;
-    validateOnClient?: VovkValidateOnClient;
-    defaultOptions?: Partial<OPTS>;
-};
-export {};

package/createDecorator.d.ts

@@ -1,4 +0,0 @@
-import type { HandlerSchema, KnownAny, VovkController, VovkRequest } from './types';
-type Next = () => Promise<unknown>;
-export declare function createDecorator<ARGS extends unknown[], REQUEST = VovkRequest>(handler: null | ((this: VovkController, req: REQUEST, next: Next, ...args: ARGS) => unknown), initHandler?: (this: VovkController, ...args: ARGS) => Omit<HandlerSchema, 'path' | 'httpMethod'> | ((handlerSchema: HandlerSchema | null) => Omit<HandlerSchema, 'path' | 'httpMethod'>) | null | undefined): (...args: ARGS) => (target: KnownAny, propertyKey: string) => void;
-export {};

package/createVovkApp.js

@@ -1,118 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createVovkApp = createVovkApp;
-const VovkApp_1 = require("./VovkApp");
-const types_1 = require("./types");
-const getSchema_1 = __importDefault(require("./utils/getSchema"));
-const trimPath = (path) => path.trim().replace(/^\/|\/$/g, '');
-const isClass = (func) => typeof func === 'function' && /class/.test(func.toString());
-const toKebabCase = (str) => str
-    .replace(/([A-Z])/g, '-$1')
-    .toLowerCase()
-    .replace(/^-/, '');
-function createVovkApp() {
-    const vovkApp = new VovkApp_1.VovkApp();
-    const createHTTPDecorator = (httpMethod) => {
-        const assignSchema = (controller, propertyKey, path, options) => {
-            if (typeof window !== 'undefined') {
-                throw new Error('Decorators are intended for server-side use 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);
-            controller._handlers = {
-                ...controller._handlers,
-                [propertyKey]: {
-                    ...(controller._handlers ?? {})[propertyKey],
-                    path,
-                    httpMethod,
-                },
-            };
-            const originalMethod = controller[propertyKey];
-            originalMethod._controller = controller;
-            originalMethod._sourceMethod = originalMethod._sourceMethod ?? originalMethod;
-            methods[path] = controller[propertyKey];
-            methods[path]._options = options;
-        };
-        function decoratorCreator(givenPath = '', options) {
-            const path = trimPath(givenPath);
-            function decorator(givenTarget, propertyKey) {
-                const target = givenTarget;
-                assignSchema(target, propertyKey, path, options);
-            }
-            return decorator;
-        }
-        const auto = (options) => {
-            function decorator(givenTarget, propertyKey) {
-                const controller = givenTarget;
-                const methods = vovkApp.routes[httpMethod].get(controller) ?? {};
-                vovkApp.routes[httpMethod].set(controller, methods);
-                controller._handlers = {
-                    ...controller._handlers,
-                    [propertyKey]: {
-                        ...(controller._handlers ?? {})[propertyKey],
-                        httpMethod,
-                    },
-                };
-                assignSchema(controller, propertyKey, toKebabCase(propertyKey), options);
-            }
-            return decorator;
-        };
-        const enhancedDecoratorCreator = decoratorCreator;
-        enhancedDecoratorCreator.auto = auto;
-        return enhancedDecoratorCreator;
-    };
-    const prefix = (givenPath = '') => {
-        const path = trimPath(givenPath);
-        return (givenTarget) => {
-            const controller = givenTarget;
-            controller._prefix = path;
-            return givenTarget;
-        };
-    };
-    const initVovk = (options) => {
-        for (const [controllerName, controller] of Object.entries(options.controllers)) {
-            controller._controllerName = controllerName;
-            controller._activated = true;
-            controller._onError = options?.onError;
-        }
-        async function GET_DEV(req, data) {
-            const params = await data.params;
-            if (params[Object.keys(params)[0]]?.[0] === '_schema_') {
-                // Wait for schema to be set (it can be set after decorators are called with another setTimeout)
-                await new Promise((resolve) => setTimeout(resolve, 10));
-                const schema = (0, getSchema_1.default)(options);
-                return vovkApp.respond(200, { schema });
-            }
-            return vovkApp.GET(req, data);
-        }
-        return {
-            GET: process.env.NODE_ENV === 'development' ? GET_DEV : vovkApp.GET,
-            POST: vovkApp.POST,
-            PUT: vovkApp.PUT,
-            PATCH: vovkApp.PATCH,
-            DELETE: vovkApp.DELETE,
-            HEAD: vovkApp.HEAD,
-            OPTIONS: vovkApp.OPTIONS,
-        };
-    };
-    return {
-        get: createHTTPDecorator(types_1.HttpMethod.GET),
-        post: createHTTPDecorator(types_1.HttpMethod.POST),
-        put: createHTTPDecorator(types_1.HttpMethod.PUT),
-        patch: createHTTPDecorator(types_1.HttpMethod.PATCH),
-        del: createHTTPDecorator(types_1.HttpMethod.DELETE),
-        head: createHTTPDecorator(types_1.HttpMethod.HEAD),
-        options: createHTTPDecorator(types_1.HttpMethod.OPTIONS),
-        prefix,
-        initVovk,
-    };
-}

package/index.d.ts

@@ -1,60 +0,0 @@
-import { createVovkApp } from './createVovkApp';
-import { HttpStatus as HttpStatus, HttpMethod as HttpMethod, type VovkErrorResponse, type VovkRequest, type VovkBody, type VovkQuery, type VovkParams, type VovkReturnType, type VovkYieldType, type VovkControllerBody, type VovkControllerQuery, type VovkControllerParams, type VovkControllerYieldType, type VovkSchema } from './types';
-import type { VovkClientOptions as VovkClientOptions, VovkClientFetcher as VovkClientFetcher, VovkDefaultFetcherOptions as VovkDefaultFetcherOptions, VovkValidateOnClient as VovkValidateOnClient } from './client/types';
-import { HttpException } from './HttpException';
-import { createDecorator } from './createDecorator';
-import { StreamJSONResponse } from './StreamJSONResponse';
-import { worker } from './worker';
-import { generateStaticAPI } from './utils/generateStaticAPI';
-export { type VovkClientFetcher, type VovkDefaultFetcherOptions, type VovkValidateOnClient, type VovkSchema, type VovkErrorResponse, type VovkRequest, type VovkControllerBody, type VovkControllerQuery, type VovkControllerParams, type VovkControllerYieldType, type VovkBody, type VovkQuery, type VovkParams, type VovkYieldType, type VovkReturnType, type VovkClientOptions, StreamJSONResponse, HttpException, HttpStatus, HttpMethod, createVovkApp, createDecorator, worker, generateStaticAPI, };
-export declare const get: {
-    (givenPath?: string | undefined, options?: import("./types").DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: import("./types").DecoratorOptions) => (givenTarget: import("./types").KnownAny, propertyKey: string) => void>;
-    auto: (options?: import("./types").DecoratorOptions) => (givenTarget: import("./types").KnownAny, propertyKey: string) => void;
-}, post: {
-    (givenPath?: string | undefined, options?: import("./types").DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: import("./types").DecoratorOptions) => (givenTarget: import("./types").KnownAny, propertyKey: string) => void>;
-    auto: (options?: import("./types").DecoratorOptions) => (givenTarget: import("./types").KnownAny, propertyKey: string) => void;
-}, put: {
-    (givenPath?: string | undefined, options?: import("./types").DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: import("./types").DecoratorOptions) => (givenTarget: import("./types").KnownAny, propertyKey: string) => void>;
-    auto: (options?: import("./types").DecoratorOptions) => (givenTarget: import("./types").KnownAny, propertyKey: string) => void;
-}, patch: {
-    (givenPath?: string | undefined, options?: import("./types").DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: import("./types").DecoratorOptions) => (givenTarget: import("./types").KnownAny, propertyKey: string) => void>;
-    auto: (options?: import("./types").DecoratorOptions) => (givenTarget: import("./types").KnownAny, propertyKey: string) => void;
-}, del: {
-    (givenPath?: string | undefined, options?: import("./types").DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: import("./types").DecoratorOptions) => (givenTarget: import("./types").KnownAny, propertyKey: string) => void>;
-    auto: (options?: import("./types").DecoratorOptions) => (givenTarget: import("./types").KnownAny, propertyKey: string) => void;
-}, head: {
-    (givenPath?: string | undefined, options?: import("./types").DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: import("./types").DecoratorOptions) => (givenTarget: import("./types").KnownAny, propertyKey: string) => void>;
-    auto: (options?: import("./types").DecoratorOptions) => (givenTarget: import("./types").KnownAny, propertyKey: string) => void;
-}, options: {
-    (givenPath?: string | undefined, options?: import("./types").DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: import("./types").DecoratorOptions) => (givenTarget: import("./types").KnownAny, propertyKey: string) => void>;
-    auto: (options?: import("./types").DecoratorOptions) => (givenTarget: import("./types").KnownAny, propertyKey: string) => void;
-}, prefix: (givenPath?: string) => (givenTarget: import("./types").KnownAny) => any, initVovk: (options: {
-    segmentName?: string;
-    controllers: Record<string, import("./types").StaticClass>;
-    workers?: Record<string, import("./types").StaticClass>;
-    exposeValidation?: boolean;
-    emitSchema?: boolean;
-    onError?: (err: Error, req: VovkRequest) => void | Promise<void>;
-}) => {
-    GET: (req: VovkRequest, data: {
-        params: Promise<Record<string, string[]>>;
-    }) => Promise<Response>;
-    POST: (req: VovkRequest, data: {
-        params: Promise<Record<string, string[]>>;
-    }) => Promise<Response>;
-    PUT: (req: VovkRequest, data: {
-        params: Promise<Record<string, string[]>>;
-    }) => Promise<Response>;
-    PATCH: (req: VovkRequest, data: {
-        params: Promise<Record<string, string[]>>;
-    }) => Promise<Response>;
-    DELETE: (req: VovkRequest, data: {
-        params: Promise<Record<string, string[]>>;
-    }) => Promise<Response>;
-    HEAD: (req: VovkRequest, data: {
-        params: Promise<Record<string, string[]>>;
-    }) => Promise<Response>;
-    OPTIONS: (req: VovkRequest, data: {
-        params: Promise<Record<string, string[]>>;
-    }) => Promise<Response>;
-};