vovk 3.0.0-draft.33 → 3.0.0-draft.331

package/{client → cjs/client}/defaultStreamHandler.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._defaultStreamHandler = exports.DEFAULT_ERROR_MESSAGE = void 0;
+exports.defaultStreamHandler = exports.DEFAULT_ERROR_MESSAGE = void 0;
 const types_1 = require("../types");
 const HttpException_1 = require("../HttpException");
 require("../utils/shim");
 exports.DEFAULT_ERROR_MESSAGE = 'Unknown error at defaultStreamHandler';
-const _defaultStreamHandler = async (response) => {
+const defaultStreamHandler = async ({ response, controller, }) => {
     if (!response.ok) {
         let result;
         try {
@@ -15,20 +15,23 @@ const _defaultStreamHandler = async (response) => {
             // ignore parsing errors
         }
         // handle server errors
-        throw new HttpException_1._HttpException(response.status, result.message ?? exports.DEFAULT_ERROR_MESSAGE);
+        throw new HttpException_1.HttpException(response.status, result.message ?? exports.DEFAULT_ERROR_MESSAGE);
     }
     if (!response.body)
-        throw new HttpException_1._HttpException(types_1._HttpStatus.NULL, 'Stream body is falsy. Check your controller code.');
+        throw new HttpException_1.HttpException(types_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;
+    const subscribers = new Set();
     async function* asyncIterator() {
         let prepend = '';
         while (true) {
             let value;
-            let done = false;
             try {
+                let done;
                 ({ value, done } = await reader.read());
+                if (done)
+                    break;
             }
             catch (error) {
                 await reader.cancel();
@@ -36,9 +39,6 @@ const _defaultStreamHandler = async (response) => {
                 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;
@@ -53,6 +53,10 @@ const _defaultStreamHandler = async (response) => {
                     break;
                 }
                 if (data) {
+                    subscribers.forEach((cb) => {
+                        if (!canceled)
+                            cb(data);
+                    });
                     if ('isError' in data && 'reason' in data) {
                         const upcomingError = data.reason;
                         await reader.cancel();
@@ -71,12 +75,20 @@ const _defaultStreamHandler = async (response) => {
     return {
         status: response.status,
         [Symbol.asyncIterator]: asyncIterator,
-        [Symbol.dispose]: () => reader.cancel(),
-        [Symbol.asyncDispose]: () => reader.cancel(),
-        cancel: () => {
+        [Symbol.dispose]: () => controller.abort(),
+        [Symbol.asyncDispose]: () => controller.abort(),
+        onIterate: (cb) => {
+            if (canceled)
+                return () => { };
+            subscribers.add(cb);
+            return () => {
+                subscribers.delete(cb);
+            };
+        },
+        abort: () => {
             canceled = true;
-            return reader.cancel();
+            return controller.abort();
         },
     };
 };
-exports._defaultStreamHandler = _defaultStreamHandler;
+exports.defaultStreamHandler = defaultStreamHandler;

package/cjs/client/fetcher.d.ts

@@ -0,0 +1,14 @@
+import type { VovkDefaultFetcherOptions, VovkClientFetcher } from './types';
+import { KnownAny } from '../types';
+export declare const DEFAULT_ERROR_MESSAGE = "Unknown error at default fetcher";
+export declare function createFetcher<T>({ prepareRequestInit, transformResponse, }?: {
+    prepareRequestInit?: (init: RequestInit, options: VovkDefaultFetcherOptions<T>) => RequestInit | Promise<RequestInit> | void | Promise<void>;
+    transformResponse?: (respData: KnownAny, response: Response, options: VovkDefaultFetcherOptions<T>, init: RequestInit) => unknown;
+}): VovkClientFetcher<VovkDefaultFetcherOptions<T>>;
+export declare const fetcher: VovkClientFetcher<{
+    apiRoot?: string;
+    disableClientValidation?: boolean;
+    validateOnClient?: import("./types").VovkValidateOnClient;
+    interpretAs?: string;
+    init?: RequestInit;
+}>;

package/cjs/client/fetcher.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetcher = exports.DEFAULT_ERROR_MESSAGE = void 0;
+exports.createFetcher = createFetcher;
+const types_1 = require("../types");
+const HttpException_1 = require("../HttpException");
+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, schema }, options) => {
+        const { params, query, body, meta, apiRoot, disableClientValidation, init, interpretAs } = options;
+        const endpoint = getEndpoint({ apiRoot, params, query });
+        const unusedParams = Array.from(new URL(endpoint.startsWith('/') ? `http://localhost${endpoint}` : endpoint).pathname.matchAll(/\{([^}]+)\}/g)).map((m) => m[1]);
+        if (unusedParams.length) {
+            throw new HttpException_1.HttpException(types_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_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, {
+                    body,
+                    query,
+                    params,
+                    endpoint,
+                });
+            }
+        }
+        let requestInit = {
+            method: httpMethod,
+            ...init,
+            headers: {
+                accept: 'application/jsonl, application/json',
+                ...(body instanceof FormData ? {} : { 'content-type': 'application/json' }),
+                ...(meta ? { 'x-meta': JSON.stringify(meta) } : {}),
+                ...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;
+        const controller = new AbortController();
+        requestInit.signal = controller.signal;
+        try {
+            response = await fetch(endpoint, requestInit);
+        }
+        catch (e) {
+            // handle network errors
+            throw new HttpException_1.HttpException(types_1.HttpStatus.NULL, (e?.message ?? exports.DEFAULT_ERROR_MESSAGE) + ' ' + endpoint, {
+                body,
+                query,
+                params,
+                endpoint,
+            });
+        }
+        const contentType = interpretAs ?? response.headers.get('content-type');
+        let resp;
+        if (contentType?.startsWith('application/jsonl')) {
+            resp = defaultStreamHandler({ response, controller, schema });
+        }
+        else if (contentType?.startsWith('application/json')) {
+            resp = defaultHandler({ response, schema });
+        }
+        else {
+            resp = response;
+        }
+        resp = await resp;
+        resp = transformResponse
+            ? await transformResponse(resp, response, options, requestInit)
+            : resp;
+        return [resp, response];
+    };
+    return newFetcher;
+}
+exports.fetcher = createFetcher();

package/cjs/client/index.d.ts

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

package/cjs/client/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.progressive = exports.createFetcher = 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; } });
+Object.defineProperty(exports, "createFetcher", { enumerable: true, get: function () { return fetcher_1.createFetcher; } });
+var progressive_1 = require("./progressive");
+Object.defineProperty(exports, "progressive", { enumerable: true, get: function () { return progressive_1.progressive; } });

package/cjs/client/progressive.d.ts

@@ -0,0 +1,9 @@
+import type { VovkStreamAsyncIterable } from './types';
+import type { KnownAny, VovkYieldType } from '../types';
+type UnionToIntersection<U> = (U extends KnownAny ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type PromisifyProperties<T> = {
+    [K in keyof T]: Promise<T[K]>;
+};
+type TransformUnionToPromises<T> = PromisifyProperties<UnionToIntersection<T>>;
+export declare function progressive<T extends (...args: KnownAny[]) => Promise<VovkStreamAsyncIterable<KnownAny>>>(fn: T, ...args: undefined extends Parameters<T>[0] ? [arg?: Parameters<T>[0]] : [arg: Parameters<T>[0]]): TransformUnionToPromises<VovkYieldType<T>>;
+export {};

package/cjs/client/progressive.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.progressive = progressive;
+function progressive(fn, ...args) {
+    const [arg] = args;
+    const reg = {};
+    void fn(arg)
+        .then(async (result) => {
+        for await (const item of result) {
+            for (const [key, value] of Object.entries(item)) {
+                if (key in reg) {
+                    if (!reg[key].isSettled) {
+                        reg[key].isSettled = true;
+                        reg[key].resolve(value);
+                    }
+                }
+                else {
+                    const { promise, resolve, reject } = Promise.withResolvers();
+                    reg[key] = { resolve, reject, promise, isSettled: true };
+                    reg[key].resolve(value);
+                }
+            }
+        }
+        return result;
+    })
+        .catch((error) => {
+        Object.keys(reg).forEach((key) => {
+            if (reg[key].isSettled)
+                return;
+            reg[key].isSettled = true;
+            reg[key].reject(error);
+        });
+        return error;
+    });
+    return new Proxy({}, {
+        get(_target, prop) {
+            if (prop in reg) {
+                return reg[prop].promise;
+            }
+            const { promise, resolve, reject } = Promise.withResolvers();
+            reg[prop] = { resolve, reject, promise, isSettled: false };
+            return promise;
+        },
+    });
+}

package/cjs/client/types.d.ts

@@ -0,0 +1,123 @@
+import type { KnownAny, HttpMethod, ControllerStaticMethod, VovkHandlerSchema, VovkControllerSchema, VovkSegmentSchema, VovkSchema, VovkRequest } from '../types';
+import type { JSONLinesResponse } from '../JSONLinesResponse';
+import type { NextResponse } from 'next/server';
+import type { defaultStreamHandler } from './defaultStreamHandler';
+import type { defaultHandler } from './defaultHandler';
+type OmitNullable<T> = {
+    [K in keyof T as T[K] extends null | undefined ? never : K]: T[K];
+};
+type Empty = {};
+export type StaticMethodInput<T extends ((req: VovkRequest<KnownAny, KnownAny, KnownAny>, params: KnownAny) => KnownAny) & {
+    __types?: {
+        isForm: boolean;
+    };
+}> = OmitNullable<(Parameters<T>[0] extends VovkRequest<infer BODY, infer QUERY, infer PARAMS> ? (BODY extends Record<KnownAny, KnownAny> ? {
+    body: T['__types'] extends {
+        isForm: true;
+    } ? FormData : BODY;
+} : Empty) & (QUERY extends Record<KnownAny, KnownAny> ? {
+    query: QUERY;
+} : Empty) & (PARAMS extends Record<KnownAny, KnownAny> ? {
+    params: PARAMS;
+} : Empty) & {
+    meta?: {
+        [key: string]: KnownAny;
+    };
+} : Empty) & (Parameters<T>[1] extends Record<KnownAny, KnownAny> ? {
+    params: Parameters<T>[1];
+} : Empty)>;
+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>;
+    onIterate: (cb: (data: T) => void) => () => void;
+    abort: () => 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 StaticMethodOptions<T extends (req: VovkRequest<KnownAny, KnownAny, KnownAny>, params: KnownAny) => void | object | JSONLinesResponse<STREAM> | Promise<JSONLinesResponse<STREAM>>, OPTS extends Record<string, KnownAny>, STREAM, R, F extends VovkDefaultFetcherOptions<KnownAny>> = Partial<OPTS & {
+    transform: (staticMethodReturn: Awaited<StaticMethodReturn<T>>, resp: Response) => R;
+    fetcher: VovkClientFetcher<F>;
+}>;
+type ClientMethodReturn<T extends (req: VovkRequest<KnownAny, KnownAny, KnownAny>, params: KnownAny) => void | object | JSONLinesResponse<STREAM> | Promise<JSONLinesResponse<STREAM>>, STREAM, R> = ReturnType<T> extends Promise<JSONLinesResponse<infer U>> | JSONLinesResponse<infer U> | Iterator<infer U> | AsyncIterator<infer U> ? Promise<VovkStreamAsyncIterable<U>> : R extends object ? Promise<Awaited<R>> : StaticMethodReturnPromise<T>;
+type ClientMethod<T extends ((req: VovkRequest<KnownAny, KnownAny, KnownAny>, params: KnownAny) => void | object | JSONLinesResponse<STREAM> | Promise<JSONLinesResponse<STREAM>>) & {
+    __types?: {
+        body: KnownAny;
+        query: KnownAny;
+        params: KnownAny;
+        output: KnownAny;
+        iteration: KnownAny;
+        isForm: boolean;
+    };
+}, OPTS extends Record<string, KnownAny>, STREAM extends KnownAny = unknown> = (IsEmptyObject<StaticMethodInput<T>> extends true ? <R, F extends VovkDefaultFetcherOptions<KnownAny> = VovkDefaultFetcherOptions<OPTS>>(options?: Prettify<StaticMethodOptions<T, OPTS, STREAM, R, F>>) => ClientMethodReturn<T, STREAM, R> : <R, F extends VovkDefaultFetcherOptions<KnownAny> = VovkDefaultFetcherOptions<OPTS>>(options: Prettify<StaticMethodInput<T> & StaticMethodOptions<T, OPTS, STREAM, R, F>>) => ClientMethodReturn<T, STREAM, R>) & {
+    isRPC: true;
+    schema: VovkHandlerSchema;
+    controllerSchema: VovkControllerSchema;
+    segmentSchema: VovkSegmentSchema;
+    fullSchema: VovkSchema;
+    __types: T['__types'];
+};
+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> = (options: {
+    name: string;
+    httpMethod: HttpMethod;
+    getEndpoint: (data: {
+        apiRoot: string | undefined;
+        params: {
+            [key: string]: string;
+        };
+        query: {
+            [key: string]: string;
+        };
+    }) => string;
+    validate: (input: {
+        body?: unknown;
+        query?: unknown;
+        params?: unknown;
+        endpoint: string;
+    }) => void | Promise<void>;
+    defaultStreamHandler: typeof defaultStreamHandler;
+    defaultHandler: typeof defaultHandler;
+    schema: VovkHandlerSchema;
+}, input: {
+    body: unknown;
+    query: {
+        [key: string]: string;
+    };
+    params: {
+        [key: string]: string;
+    };
+    meta?: {
+        [key: string]: KnownAny;
+    };
+} & OPTS) => Promise<[KnownAny, Response]>;
+export type VovkDefaultFetcherOptions<T> = T & {
+    apiRoot?: string;
+    disableClientValidation?: boolean;
+    validateOnClient?: VovkValidateOnClient;
+    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>;
+type IsEmptyObject<T> = T extends object ? keyof T extends never ? true : T extends Partial<T> ? Partial<T> extends T ? true : false : false : false;
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export {};

package/{createVovkApp.d.ts → cjs/createVovkApp.d.ts}

@@ -1,5 +1,6 @@
-import { type _KnownAny as KnownAny, type _DecoratorOptions as DecoratorOptions, type _VovkRequest as VovkRequest, type _StaticClass as StaticClass } from './types';
-export declare function _createVovkApp(): {
+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;
@@ -29,33 +30,33 @@ export declare function _createVovkApp(): {
         auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
     };
     prefix: (givenPath?: string) => (givenTarget: KnownAny) => any;
-    initVovk: (options: {
+    initSegment: (options: {
         segmentName?: string;
         controllers: Record<string, StaticClass>;
-        workers?: Record<string, StaticClass>;
         exposeValidation?: boolean;
         emitSchema?: boolean;
+        forceApiRoot?: string;
         onError?: (err: Error, req: VovkRequest) => void | Promise<void>;
     }) => {
-        GET: (req: VovkRequest, data: {
+        GET: (req: NextRequest, data: {
             params: Promise<Record<string, string[]>>;
         }) => Promise<Response>;
-        POST: (req: VovkRequest, data: {
+        POST: (req: NextRequest, data: {
             params: Promise<Record<string, string[]>>;
         }) => Promise<Response>;
-        PUT: (req: VovkRequest, data: {
+        PUT: (req: NextRequest, data: {
             params: Promise<Record<string, string[]>>;
         }) => Promise<Response>;
-        PATCH: (req: VovkRequest, data: {
+        PATCH: (req: NextRequest, data: {
             params: Promise<Record<string, string[]>>;
         }) => Promise<Response>;
-        DELETE: (req: VovkRequest, data: {
+        DELETE: (req: NextRequest, data: {
             params: Promise<Record<string, string[]>>;
         }) => Promise<Response>;
-        HEAD: (req: VovkRequest, data: {
+        HEAD: (req: NextRequest, data: {
             params: Promise<Record<string, string[]>>;
         }) => Promise<Response>;
-        OPTIONS: (req: VovkRequest, data: {
+        OPTIONS: (req: NextRequest, data: {
             params: Promise<Record<string, string[]>>;
         }) => Promise<Response>;
     };

package/cjs/createVovkApp.js

@@ -0,0 +1,133 @@
+"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-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('HTTP decorators can be used on server-side only. You have probably imported a controller on the client-side.');
+    }
+    if (!isClass(controller)) {
+        let decoratorName = httpMethod.toLowerCase();
+        if (decoratorName === 'delete')
+            decoratorName = 'del';
+        throw new Error(`Decorator must be used on a static class method. Check the controller method named "${propertyKey}" used with @${decoratorName}().`);
+    }
+    const methods = vovkApp.routes[httpMethod].get(controller) ?? {};
+    vovkApp.routes[httpMethod].set(controller, methods);
+    const originalMethod = controller[propertyKey];
+    originalMethod._controller = controller;
+    originalMethod._sourceMethod = originalMethod._sourceMethod ?? originalMethod;
+    const schema = originalMethod._sourceMethod._getSchema?.(controller);
+    originalMethod.schema = schema;
+    originalMethod.fn = originalMethod._sourceMethod?.fn;
+    originalMethod.models = originalMethod._sourceMethod?.models;
+    originalMethod._sourceMethod.wrapper = originalMethod;
+    controller._handlers = {
+        ...controller._handlers,
+        [propertyKey]: {
+            ...schema,
+            ...(controller._handlers ?? {})[propertyKey],
+            path,
+            httpMethod,
+        },
+    };
+    methods[path] = originalMethod;
+    methods[path]._options = options;
+    controller._handlersMetadata = {
+        ...controller._handlersMetadata,
+        [propertyKey]: {
+            ...(controller._handlersMetadata ?? {})[propertyKey],
+            staticParams: options?.staticParams,
+        },
+    };
+};
+function 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,
+                    },
+                };
+                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 initSegment = (options) => {
+        options.segmentName = trimPath(options.segmentName ?? '');
+        for (const [rpcModuleName, controller] of Object.entries(options.controllers ?? {})) {
+            controller._rpcModuleName = rpcModuleName;
+            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 = await (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,
+        initSegment,
+    };
+}

package/cjs/index.d.ts

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