vovk 3.0.0-draft.13 → 3.0.0-draft.135

package/mjs/client/defaultStreamHandler.d.ts

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

package/mjs/client/defaultStreamHandler.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultStreamHandler = exports.DEFAULT_ERROR_MESSAGE = void 0;
+const types_js_1 = require("../types.js");
+const HttpException_js_1 = require("../HttpException.js");
+require("../utils/shim.js");
+exports.DEFAULT_ERROR_MESSAGE = 'Unknown error at defaultStreamHandler';
+const defaultStreamHandler = async (response) => {
+    if (!response.ok) {
+        let result;
+        try {
+            result = await response.json();
+        }
+        catch {
+            // ignore parsing errors
+        }
+        // handle server errors
+        throw new HttpException_js_1.HttpException(response.status, result.message ?? exports.DEFAULT_ERROR_MESSAGE);
+    }
+    if (!response.body)
+        throw new HttpException_js_1.HttpException(types_js_1.HttpStatus.NULL, 'Stream body is falsy. Check your controller code.');
+    const reader = response.body.getReader();
+    // if streaming is too rapid, we need to make sure that the loop is stopped
+    let canceled = false;
+    async function* asyncIterator() {
+        let prepend = '';
+        while (true) {
+            let value;
+            let done = false;
+            try {
+                ({ value, done } = await reader.read());
+            }
+            catch (error) {
+                await reader.cancel();
+                const err = new Error('Stream error. ' + String(error));
+                err.cause = error;
+                throw err;
+            }
+            if (done) {
+                return;
+            }
+            // typeof value === 'number' is a workaround for React Native
+            const string = typeof value === 'number' ? String.fromCharCode(value) : new TextDecoder().decode(value);
+            prepend += string;
+            const lines = prepend.split('\n').filter(Boolean);
+            for (const line of lines) {
+                let data;
+                try {
+                    data = JSON.parse(line);
+                    prepend = '';
+                }
+                catch {
+                    break;
+                }
+                if (data) {
+                    if ('isError' in data && 'reason' in data) {
+                        const upcomingError = data.reason;
+                        await reader.cancel();
+                        if (typeof upcomingError === 'string') {
+                            throw new Error(upcomingError);
+                        }
+                        throw upcomingError;
+                    }
+                    else if (!canceled) {
+                        yield data;
+                    }
+                }
+            }
+        }
+    }
+    return {
+        status: response.status,
+        [Symbol.asyncIterator]: asyncIterator,
+        [Symbol.dispose]: () => reader.cancel(),
+        [Symbol.asyncDispose]: () => reader.cancel(),
+        cancel: () => {
+            canceled = true;
+            return reader.cancel();
+        },
+    };
+};
+exports.defaultStreamHandler = defaultStreamHandler;

package/mjs/client/fetcher.d.ts

@@ -0,0 +1,8 @@
+import type { VovkDefaultFetcherOptions, VovkClientFetcher } from './types.js';
+import { KnownAny } from '../types.js';
+export declare const DEFAULT_ERROR_MESSAGE = "Unknown error at default fetcher";
+export declare function createFetcher<T extends Record<string, KnownAny> = Record<string, never>>({ prepareRequestInit, transformResponse, }?: {
+    prepareRequestInit?: (init: RequestInit, options: VovkDefaultFetcherOptions<T> & T) => RequestInit | Promise<RequestInit> | void | Promise<void>;
+    transformResponse?: (resp: unknown, options: VovkDefaultFetcherOptions<T> & T, init: RequestInit) => unknown;
+}): VovkClientFetcher<VovkDefaultFetcherOptions<T>>;
+export declare const fetcher: VovkClientFetcher<VovkDefaultFetcherOptions<Record<string, never>>>;

package/mjs/client/fetcher.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetcher = exports.DEFAULT_ERROR_MESSAGE = void 0;
+exports.createFetcher = createFetcher;
+const types_js_1 = require("../types.js");
+const HttpException_js_1 = require("../HttpException.js");
+exports.DEFAULT_ERROR_MESSAGE = 'Unknown error at default fetcher';
+function createFetcher({ prepareRequestInit, transformResponse, } = {}) {
+    // fetcher 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 newFetcher = async ({ httpMethod, getEndpoint, validate, defaultHandler, defaultStreamHandler }, options) => {
+        const { params, query, body, apiRoot = '/api', disableClientValidation, init, interpretAs } = options;
+        const endpoint = getEndpoint({ apiRoot, params, query });
+        const unusedParams = new URL(endpoint).pathname.split('/').filter((segment) => segment.startsWith(':'));
+        if (unusedParams.length) {
+            throw new HttpException_js_1.HttpException(types_js_1.HttpStatus.NULL, `Unused params: ${unusedParams.join(', ')} in ${endpoint}`, {
+                body,
+                query,
+                params,
+                endpoint,
+            });
+        }
+        if (!disableClientValidation) {
+            try {
+                await validate({ body, query, params, endpoint });
+            }
+            catch (e) {
+                // if HttpException is thrown, rethrow it
+                if (e instanceof HttpException_js_1.HttpException)
+                    throw e;
+                // otherwise, throw HttpException with status 0
+                throw new HttpException_js_1.HttpException(types_js_1.HttpStatus.NULL, e.message ?? exports.DEFAULT_ERROR_MESSAGE, {
+                    body,
+                    query,
+                    params,
+                    endpoint,
+                });
+            }
+        }
+        let requestInit = {
+            method: httpMethod,
+            ...init,
+            headers: {
+                accept: 'application/jsonl, application/json',
+                ...init?.headers,
+            },
+        };
+        if (body instanceof FormData) {
+            requestInit.body = body;
+        }
+        else if (body) {
+            requestInit.body = JSON.stringify(body);
+        }
+        requestInit = prepareRequestInit
+            ? ((await prepareRequestInit(requestInit, options)) ?? requestInit)
+            : requestInit;
+        let response;
+        try {
+            response = await fetch(endpoint, requestInit);
+        }
+        catch (e) {
+            // handle network errors
+            throw new HttpException_js_1.HttpException(types_js_1.HttpStatus.NULL, e?.message ?? exports.DEFAULT_ERROR_MESSAGE, {
+                body,
+                query,
+                params,
+                endpoint,
+            });
+        }
+        const contentType = interpretAs ?? response.headers.get('content-type');
+        let resp;
+        if (contentType?.startsWith('application/jsonl')) {
+            resp = defaultStreamHandler(response);
+        }
+        else if (contentType?.startsWith('application/json')) {
+            resp = defaultHandler(response);
+        }
+        else {
+            resp = response;
+        }
+        resp = await resp;
+        return transformResponse
+            ? ((await transformResponse(resp, options, requestInit)) ?? resp)
+            : resp;
+    };
+    return newFetcher;
+}
+exports.fetcher = createFetcher();

package/mjs/client/index.d.ts

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

package/mjs/client/index.js

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

package/mjs/client/types.d.ts

@@ -0,0 +1,113 @@
+import type { KnownAny, HttpMethod, ControllerStaticMethod, VovkControllerBody, VovkControllerQuery, VovkControllerParams, VovkHandlerSchema, VovkControllerSchema, VovkSegmentSchema, VovkSchema } from '../types.js';
+import type { JSONLinesResponse } from '../JSONLinesResponse.js';
+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 StaticMethodOption<T extends ((...args: KnownAny[]) => void | object | JSONLinesResponse<STREAM> | Promise<JSONLinesResponse<STREAM>>) & {
+    __output?: KnownAny;
+    __iteration?: KnownAny;
+}, OPTS extends Record<string, KnownAny>, STREAM extends KnownAny = unknown, R = KnownAny, F extends VovkDefaultFetcherOptions<KnownAny> = VovkDefaultFetcherOptions<KnownAny>> = (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;
+    fetcher: VovkClientFetcher<F>;
+}> | void) & (Partial<F extends VovkDefaultFetcherOptions<infer U> ? Omit<U, keyof VovkDefaultFetcherOptions<OPTS>> : void> | void);
+type ClientMethod<T extends ((...args: KnownAny[]) => void | object | JSONLinesResponse<STREAM> | Promise<JSONLinesResponse<STREAM>>) & {
+    __output?: KnownAny;
+    __iteration?: KnownAny;
+}, OPTS extends Record<string, KnownAny>, STREAM extends KnownAny = unknown> = (<R, F extends VovkDefaultFetcherOptions<KnownAny> = VovkDefaultFetcherOptions<OPTS>>(options: StaticMethodOption<T, OPTS, STREAM, R, F>) => ReturnType<T> extends Promise<JSONLinesResponse<infer U>> | JSONLinesResponse<infer U> | Iterator<infer U> | AsyncIterator<infer U> ? Promise<VovkStreamAsyncIterable<U>> : R extends object ? Promise<R> : StaticMethodReturnPromise<T>) & {
+    isRPC: true;
+    schema: VovkHandlerSchema;
+    controllerSchema: VovkControllerSchema;
+    segmentSchema: VovkSegmentSchema;
+    fullSchema: VovkSchema;
+    __output: T['__output'];
+    __iteration: T['__iteration'];
+};
+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, 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<T> {
+    apiRoot?: string;
+    disableClientValidation?: boolean;
+    validateOnClient?: VovkValidateOnClient;
+    fetcher?: VovkClientFetcher<T>;
+    interpretAs?: string;
+    init?: RequestInit;
+}
+export type VovkValidateOnClient = (input: {
+    body?: unknown;
+    query?: unknown;
+    params?: unknown;
+    endpoint: string;
+}, validation: Omit<Exclude<VovkHandlerSchema['validation'], undefined>, 'output' | 'iteration'>, fullSchema: VovkSchema) => void | Promise<void>;
+export type VovkClientOptions<OPTS extends Record<string, KnownAny> = Record<string, never>> = {
+    fetcher?: VovkClientFetcher<OPTS>;
+    validateOnClient?: VovkValidateOnClient;
+    defaultOptions?: Partial<OPTS>;
+};
+export {};

package/mjs/createDecorator.d.ts

@@ -0,0 +1,6 @@
+import type { VovkHandlerSchema, KnownAny, VovkController, VovkRequest } from './types.js';
+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/mjs/createDecorator.js

@@ -0,0 +1,43 @@
+"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?.misc ? { misc: initResult.misc } : {}),
+                },
+            };
+        };
+    };
+}

package/mjs/createVovkApp.d.ts

@@ -0,0 +1,62 @@
+import type { NextRequest } from 'next/server';
+import { type KnownAny, type DecoratorOptions, type VovkRequest, type StaticClass } from './types.js';
+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/mjs/createVovkApp.js

@@ -0,0 +1,129 @@
+"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_js_1 = require("./VovkApp.js");
+const types_js_1 = require("./types.js");
+const getSchema_js_1 = __importDefault(require("./utils/getSchema.js"));
+const trimPath = (path) => path.trim().replace(/^\/|\/$/g, '');
+const isClass = (func) => typeof func === 'function' && /class/.test(func.toString());
+const toKebabCase = (str) => str
+    .replace(/([a-z0-9])([A-Z])/g, '$1-$2') // Add hyphen between lowercase/digit and uppercase
+    .replace(/([A-Z])([A-Z])(?=[a-z])/g, '$1-$2') // Add hyphen between uppercase letters if the second one is followed by a lowercase
+    .toLowerCase()
+    .replace(/^-/, ''); // Remove leading hyphen
+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;
+    controller._handlersMetadata = {
+        ...controller._handlersMetadata,
+        [propertyKey]: {
+            ...(controller._handlersMetadata ?? {})[propertyKey],
+            staticParams: options?.staticParams,
+        },
+    };
+};
+function createVovkApp() {
+    const vovkApp = new VovkApp_js_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,
+                    },
+                };
+                const properties = Object.keys(controller._handlers[propertyKey]?.validation?.params?.properties ?? {});
+                const kebab = toKebabCase(propertyKey); // 🥙
+                const path = properties.length ? `${kebab}/${properties.map((prop) => `:${prop}`).join('/')}` : kebab;
+                assignSchema({ controller, propertyKey, path, 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 [rpcModuleName, controller] of Object.entries(options.controllers)) {
+            controller._rpcModuleName = rpcModuleName;
+            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_js_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_js_1.HttpMethod.GET),
+        post: createHTTPDecorator(types_js_1.HttpMethod.POST),
+        put: createHTTPDecorator(types_js_1.HttpMethod.PUT),
+        patch: createHTTPDecorator(types_js_1.HttpMethod.PATCH),
+        del: createHTTPDecorator(types_js_1.HttpMethod.DELETE),
+        head: createHTTPDecorator(types_js_1.HttpMethod.HEAD),
+        options: createHTTPDecorator(types_js_1.HttpMethod.OPTIONS),
+        prefix,
+        initVovk,
+    };
+}

package/mjs/index.d.ts

@@ -0,0 +1,60 @@
+import { createVovkApp } from './createVovkApp.js';
+import { HttpStatus, HttpMethod, VovkSchemaIdEnum, // TODO: not documented
+type KnownAny, type VovkErrorResponse, type VovkRequest, type VovkBody, type VovkQuery, type VovkParams, type VovkReturnType, type VovkYieldType, type VovkOutput, type VovkIteration, type VovkSegmentSchema, type VovkControllerSchema, type VovkHandlerSchema, type VovkSchema, type VovkConfig, type VovkStrictConfig, type VovkValidationType } from './types.js';
+import { type VovkClient, type VovkClientOptions, type VovkClientFetcher, type VovkDefaultFetcherOptions, type VovkValidateOnClient, type VovkStreamAsyncIterable, createRPC, fetcher, createFetcher } from './client/index.js';
+import { HttpException } from './HttpException.js';
+import { createDecorator } from './createDecorator.js';
+import { JSONLinesResponse } from './JSONLinesResponse.js';
+import { generateStaticAPI } from './utils/generateStaticAPI.js';
+import { withValidation } from './utils/withValidation.js';
+export { type KnownAny, type VovkClient, type VovkClientFetcher, type VovkDefaultFetcherOptions, type VovkStreamAsyncIterable, type VovkValidateOnClient, type VovkSegmentSchema, type VovkErrorResponse, type VovkRequest, type VovkOutput, type VovkIteration, type VovkBody, type VovkQuery, type VovkParams, type VovkYieldType, type VovkReturnType, type VovkClientOptions, type VovkControllerSchema, type VovkHandlerSchema, type VovkSchema, type VovkConfig, type VovkStrictConfig, type VovkValidationType, VovkSchemaIdEnum, JSONLinesResponse, HttpException, HttpStatus, HttpMethod, createVovkApp, createDecorator, createRPC, fetcher, createFetcher, generateStaticAPI, withValidation, };
+export declare const get: {
+    (givenPath?: string | undefined, options?: import("./types.js").DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: import("./types.js").DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
+    auto: (options?: import("./types.js").DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+}, post: {
+    (givenPath?: string | undefined, options?: import("./types.js").DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: import("./types.js").DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
+    auto: (options?: import("./types.js").DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+}, put: {
+    (givenPath?: string | undefined, options?: import("./types.js").DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: import("./types.js").DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
+    auto: (options?: import("./types.js").DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+}, patch: {
+    (givenPath?: string | undefined, options?: import("./types.js").DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: import("./types.js").DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
+    auto: (options?: import("./types.js").DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+}, del: {
+    (givenPath?: string | undefined, options?: import("./types.js").DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: import("./types.js").DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
+    auto: (options?: import("./types.js").DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+}, head: {
+    (givenPath?: string | undefined, options?: import("./types.js").DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: import("./types.js").DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
+    auto: (options?: import("./types.js").DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+}, options: {
+    (givenPath?: string | undefined, options?: import("./types.js").DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: import("./types.js").DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
+    auto: (options?: import("./types.js").DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+}, prefix: (givenPath?: string) => (givenTarget: KnownAny) => any, initVovk: (options: {
+    segmentName?: string;
+    controllers: Record<string, import("./types.js").StaticClass>;
+    exposeValidation?: boolean;
+    emitSchema?: boolean;
+    onError?: (err: Error, req: VovkRequest) => void | Promise<void>;
+}) => {
+    GET: (req: import("next/server.js").NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    POST: (req: import("next/server.js").NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    PUT: (req: import("next/server.js").NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    PATCH: (req: import("next/server.js").NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    DELETE: (req: import("next/server.js").NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    HEAD: (req: import("next/server.js").NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    OPTIONS: (req: import("next/server.js").NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+};

package/mjs/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initVovk = exports.prefix = exports.options = exports.head = exports.del = exports.patch = exports.put = exports.post = exports.get = exports.withValidation = exports.generateStaticAPI = exports.createFetcher = exports.fetcher = exports.createRPC = exports.createDecorator = exports.createVovkApp = exports.HttpMethod = exports.HttpStatus = exports.HttpException = exports.JSONLinesResponse = exports.VovkSchemaIdEnum = void 0;
+const createVovkApp_js_1 = require("./createVovkApp.js");
+Object.defineProperty(exports, "createVovkApp", { enumerable: true, get: function () { return createVovkApp_js_1.createVovkApp; } });
+const types_js_1 = require("./types.js");
+Object.defineProperty(exports, "HttpStatus", { enumerable: true, get: function () { return types_js_1.HttpStatus; } });
+Object.defineProperty(exports, "HttpMethod", { enumerable: true, get: function () { return types_js_1.HttpMethod; } });
+Object.defineProperty(exports, "VovkSchemaIdEnum", { enumerable: true, get: function () { return types_js_1.VovkSchemaIdEnum; } });
+const index_js_1 = require("./client/index.js");
+Object.defineProperty(exports, "createRPC", { enumerable: true, get: function () { return index_js_1.createRPC; } });
+Object.defineProperty(exports, "fetcher", { enumerable: true, get: function () { return index_js_1.fetcher; } });
+Object.defineProperty(exports, "createFetcher", { enumerable: true, get: function () { return index_js_1.createFetcher; } });
+const HttpException_js_1 = require("./HttpException.js");
+Object.defineProperty(exports, "HttpException", { enumerable: true, get: function () { return HttpException_js_1.HttpException; } });
+const createDecorator_js_1 = require("./createDecorator.js");
+Object.defineProperty(exports, "createDecorator", { enumerable: true, get: function () { return createDecorator_js_1.createDecorator; } });
+const JSONLinesResponse_js_1 = require("./JSONLinesResponse.js");
+Object.defineProperty(exports, "JSONLinesResponse", { enumerable: true, get: function () { return JSONLinesResponse_js_1.JSONLinesResponse; } });
+const generateStaticAPI_js_1 = require("./utils/generateStaticAPI.js");
+Object.defineProperty(exports, "generateStaticAPI", { enumerable: true, get: function () { return generateStaticAPI_js_1.generateStaticAPI; } });
+const withValidation_js_1 = require("./utils/withValidation.js");
+Object.defineProperty(exports, "withValidation", { enumerable: true, get: function () { return withValidation_js_1.withValidation; } });
+_a = (0, createVovkApp_js_1.createVovkApp)(), exports.get = _a.get, exports.post = _a.post, exports.put = _a.put, exports.patch = _a.patch, exports.del = _a.del, exports.head = _a.head, exports.options = _a.options, exports.prefix = _a.prefix, exports.initVovk = _a.initVovk;