vovk 3.0.0-draft.99 → 3.0.2

package/dist/HttpException.d.ts

@@ -1,7 +0,0 @@
-import type { HttpStatus } from './types';
-export declare class HttpException extends Error {
-    statusCode: HttpStatus;
-    message: string;
-    cause?: unknown;
-    constructor(statusCode: HttpStatus, message: string, cause?: unknown);
-}

package/dist/HttpException.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpException = void 0;
-class HttpException extends Error {
-    statusCode;
-    message;
-    cause;
-    constructor(statusCode, message, cause) {
-        super(message);
-        this.statusCode = statusCode;
-        this.message = message;
-        this.cause = cause;
-    }
-}
-exports.HttpException = HttpException;

package/dist/StreamJSONResponse.d.ts

@@ -1,14 +0,0 @@
-import type { headers } from 'next/headers';
-import type { KnownAny, StreamAbortMessage } from './types';
-import './utils/shim';
-export declare class StreamJSONResponse<T> extends Response {
-    isClosed: boolean;
-    controller?: ReadableStreamDefaultController;
-    readonly encoder: TextEncoder;
-    readonly readableStream: ReadableStream;
-    constructor(requestHeaders: Awaited<ReturnType<typeof headers>>, init?: ResponseInit);
-    send(data: T | StreamAbortMessage): void;
-    close(): void;
-    throw(e: KnownAny): void;
-    [Symbol.dispose](): void;
-}

package/dist/StreamJSONResponse.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StreamJSONResponse = void 0;
-require("./utils/shim");
-class StreamJSONResponse extends Response {
-    isClosed = false;
-    controller;
-    encoder;
-    readableStream;
-    constructor(requestHeaders, init) {
-        const encoder = new TextEncoder();
-        let readableController;
-        const readableStream = new ReadableStream({
-            cancel: () => {
-                this.isClosed = true;
-            },
-            start: (controller) => {
-                readableController = controller;
-            },
-        });
-        if (!requestHeaders) {
-            throw new Error('Request headers are required');
-        }
-        const accept = requestHeaders.get('accept');
-        super(readableStream, {
-            ...init,
-            headers: {
-                ...init?.headers,
-                'Content-Type': accept?.includes('application/jsonl') ? 'application/jsonl' : 'text/plain',
-            },
-        });
-        this.readableStream = readableStream;
-        this.encoder = encoder;
-        this.controller = readableController;
-    }
-    send(data) {
-        const { controller, encoder } = this;
-        if (this.isClosed)
-            return;
-        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.send({ isError: true, reason: e instanceof Error ? e.message : e });
-        return this.close();
-    }
-    [Symbol.dispose]() {
-        this.close();
-    }
-}
-exports.StreamJSONResponse = StreamJSONResponse;

package/dist/VovkApp.d.ts

@@ -1,29 +0,0 @@
-import type { NextRequest } from 'next/server';
-import { HttpMethod, HttpStatus, type RouteHandler, type VovkController, type DecoratorOptions } from './types';
-export declare class VovkApp {
-    #private;
-    private static getHeadersFromOptions;
-    routes: Record<HttpMethod, Map<VovkController, Record<string, RouteHandler>>>;
-    GET: (req: NextRequest, data: {
-        params: Promise<Record<string, string[]>>;
-    }) => Promise<Response>;
-    POST: (req: NextRequest, data: {
-        params: Promise<Record<string, string[]>>;
-    }) => Promise<Response>;
-    PUT: (req: NextRequest, data: {
-        params: Promise<Record<string, string[]>>;
-    }) => Promise<Response>;
-    PATCH: (req: NextRequest, data: {
-        params: Promise<Record<string, string[]>>;
-    }) => Promise<Response>;
-    DELETE: (req: NextRequest, data: {
-        params: Promise<Record<string, string[]>>;
-    }) => Promise<Response>;
-    HEAD: (req: NextRequest, data: {
-        params: Promise<Record<string, string[]>>;
-    }) => Promise<Response>;
-    OPTIONS: (req: NextRequest, data: {
-        params: Promise<Record<string, string[]>>;
-    }) => Promise<Response>;
-    respond: (status: HttpStatus, body: unknown, options?: DecoratorOptions) => Response;
-}

package/dist/VovkApp.js

@@ -1,188 +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"));
-const headers_1 = require("next/headers");
-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);
-    };
-    #getHandler = ({ handlers, path, params, }) => {
-        const methodParams = {};
-        if (Object.keys(params).length === 0) {
-            return { handler: handlers[''], methodParams };
-        }
-        const allMethodKeys = Object.keys(handlers);
-        let methodKeys = [];
-        const pathStr = path.join('/');
-        methodKeys = allMethodKeys
-            // First, try to match literal routes exactly.
-            .filter((p) => {
-            if (p.includes(':'))
-                return false; // Skip parameterized paths
-            return p === pathStr;
-        });
-        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}" at ${p}`);
-                        }
-                        // 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 { handler: handlers[methodKey], methodParams };
-        }
-        return { handler: null, methodParams };
-    };
-    #callMethod = async (httpMethod, nextReq, params) => {
-        const req = nextReq;
-        const controllers = this.routes[httpMethod];
-        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 { handler, methodParams } = this.#getHandler({ handlers, path, params });
-        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),
-            params: () => methodParams,
-        };
-        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(await (0, headers_1.headers)(), {
-                    headers: {
-                        ..._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/dist/client/index.d.ts

@@ -1,3 +0,0 @@
-export { createRPC } from './createRPC';
-export { fetcher } from './fetcher';
-export type { VovkClient, VovkClientFetcher, VovkClientOptions, VovkDefaultFetcherOptions, VovkValidateOnClient, VovkStreamAsyncIterable, } from './types';

package/dist/client/index.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetcher = exports.createRPC = void 0;
-var createRPC_1 = require("./createRPC");
-Object.defineProperty(exports, "createRPC", { enumerable: true, get: function () { return createRPC_1.createRPC; } });
-var fetcher_1 = require("./fetcher");
-Object.defineProperty(exports, "fetcher", { enumerable: true, get: function () { return fetcher_1.fetcher; } });

package/dist/client/types.d.ts

@@ -1,104 +0,0 @@
-import type { KnownAny, HttpMethod, ControllerStaticMethod, VovkControllerBody, VovkControllerQuery, VovkControllerParams, VovkHandlerSchema, VovkControllerSchema, VovkSegmentSchema, VovkFullSchema } 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 VovkStreamAsyncIterable<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;
-}> | void)) => ReturnType<T> extends Promise<StreamJSONResponse<infer U>> | StreamJSONResponse<infer U> | Iterator<infer U> | AsyncIterator<infer U> ? Promise<VovkStreamAsyncIterable<U>> : R extends object ? Promise<R> : StaticMethodReturnPromise<T>) & {
-    schema: VovkHandlerSchema;
-    controllerSchema: VovkControllerSchema;
-    segmentSchema: VovkSegmentSchema;
-    fullSchema: VovkFullSchema;
-};
-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;
-        params?: unknown;
-        endpoint: string;
-    }) => void | Promise<void>;
-    defaultStreamHandler: (response: Response) => Promise<VovkStreamAsyncIterable<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;
-    params?: unknown;
-    endpoint: string;
-}, validation: Exclude<VovkHandlerSchema['validation'], undefined>, fullSchema: VovkFullSchema) => void | Promise<void>;
-export type VovkClientOptions<OPTS extends Record<string, KnownAny> = Record<string, never>> = {
-    fetcher?: VovkClientFetcher<OPTS>;
-    validateOnClient?: VovkValidateOnClient;
-    defaultOptions?: Partial<OPTS>;
-};
-export {};

package/dist/client/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/createDecorator.d.ts

@@ -1,6 +0,0 @@
-import type { VovkHandlerSchema, 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<VovkHandlerSchema, 'path' | 'httpMethod'> | ((handlerSchema: VovkHandlerSchema | null, options: {
-    handlerName: string;
-}) => Omit<Partial<VovkHandlerSchema>, 'path' | 'httpMethod'>) | null | undefined): (...args: ARGS) => (target: KnownAny, propertyKey: string) => void;
-export {};

package/dist/createDecorator.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDecorator = createDecorator;
-function createDecorator(handler, initHandler) {
-    return function decoratorCreator(...args) {
-        return function decorator(target, propertyKey) {
-            const controller = target;
-            const originalMethod = controller[propertyKey];
-            if (typeof originalMethod !== 'function') {
-                throw new Error(`Unable to decorate: ${propertyKey} is not a function`);
-            }
-            const sourceMethod = originalMethod._sourceMethod ?? originalMethod;
-            const method = function method(req, params) {
-                const next = async () => {
-                    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;
-            // TODO define internal method type
-            originalMethod._controller = controller;
-            const handlerSchema = controller._handlers?.[propertyKey] ?? null;
-            const initResultReturn = initHandler?.call(controller, ...args);
-            const initResult = typeof initResultReturn === 'function'
-                ? initResultReturn(handlerSchema, {
-                    handlerName: propertyKey,
-                })
-                : initResultReturn;
-            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 } : {}),
-                },
-            };
-        };
-    };
-}

package/dist/createVovkApp.d.ts

@@ -1,62 +0,0 @@
-import type { NextRequest } from 'next/server';
-import { type KnownAny, type DecoratorOptions, type VovkRequest, type StaticClass } from './types';
-export declare function createVovkApp(): {
-    get: {
-        (givenPath?: string | undefined, options?: DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
-        auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
-    };
-    post: {
-        (givenPath?: string | undefined, options?: DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
-        auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
-    };
-    put: {
-        (givenPath?: string | undefined, options?: DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
-        auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
-    };
-    patch: {
-        (givenPath?: string | undefined, options?: DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
-        auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
-    };
-    del: {
-        (givenPath?: string | undefined, options?: DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
-        auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
-    };
-    head: {
-        (givenPath?: string | undefined, options?: DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
-        auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
-    };
-    options: {
-        (givenPath?: string | undefined, options?: DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
-        auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
-    };
-    prefix: (givenPath?: string) => (givenTarget: KnownAny) => any;
-    initVovk: (options: {
-        segmentName?: string;
-        controllers: Record<string, StaticClass>;
-        exposeValidation?: boolean;
-        emitSchema?: boolean;
-        onError?: (err: Error, req: VovkRequest) => void | Promise<void>;
-    }) => {
-        GET: (req: NextRequest, data: {
-            params: Promise<Record<string, string[]>>;
-        }) => Promise<Response>;
-        POST: (req: NextRequest, data: {
-            params: Promise<Record<string, string[]>>;
-        }) => Promise<Response>;
-        PUT: (req: NextRequest, data: {
-            params: Promise<Record<string, string[]>>;
-        }) => Promise<Response>;
-        PATCH: (req: NextRequest, data: {
-            params: Promise<Record<string, string[]>>;
-        }) => Promise<Response>;
-        DELETE: (req: NextRequest, data: {
-            params: Promise<Record<string, string[]>>;
-        }) => Promise<Response>;
-        HEAD: (req: NextRequest, data: {
-            params: Promise<Record<string, string[]>>;
-        }) => Promise<Response>;
-        OPTIONS: (req: NextRequest, data: {
-            params: Promise<Record<string, string[]>>;
-        }) => Promise<Response>;
-    };
-};

package/dist/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(/^-/, '');
-const assignSchema = ({ controller, propertyKey, path, options, httpMethod, vovkApp, }) => {
-    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);
-    const originalMethod = controller[propertyKey];
-    originalMethod._controller = controller;
-    originalMethod._sourceMethod = originalMethod._sourceMethod ?? originalMethod;
-    const schema = originalMethod._sourceMethod._getSchema?.(controller);
-    controller._handlers = {
-        ...controller._handlers,
-        [propertyKey]: {
-            ...schema,
-            ...(controller._handlers ?? {})[propertyKey],
-            path,
-            httpMethod,
-        },
-    };
-    methods[path] = controller[propertyKey];
-    methods[path]._options = options;
-};
-function createVovkApp() {
-    const vovkApp = new VovkApp_1.VovkApp();
-    const createHTTPDecorator = (httpMethod) => {
-        function decoratorCreator(givenPath = '', options) {
-            const path = trimPath(givenPath);
-            function decorator(givenTarget, propertyKey) {
-                const controller = givenTarget;
-                assignSchema({ controller, propertyKey, path, options, httpMethod, vovkApp });
-            }
-            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, path: toKebabCase(propertyKey), options, httpMethod, vovkApp });
-            }
-            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_') {
-                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,
-    };
-}