vovk 3.2.2 → 3.4.0

package/dist/types/standard-tool.d.ts

@@ -0,0 +1,17 @@
+import type { CombinedSpec } from './validation.js';
+import type { KnownAny } from './utils.js';
+/**
+ * The `standard-tool` convention (https://github.com/finom/standard-tool): a neutral LLM tool shape —
+ * `name`, `description`, optional `inputSchema`/`outputSchema`, `execute`. Vendored as a type only
+ * (no logic) so `VovkTool` can extend it with zero added dependencies. Kept identical to the
+ * `StandardTool` type published by `standard-tool` (`meta` is `KnownAny`, i.e. its `any`).
+ */
+export interface StandardTool<Input = unknown, Output = unknown, FormattedOutput = Output | {
+    error: string;
+}> {
+    name: string;
+    description: string;
+    inputSchema?: CombinedSpec<Input>;
+    outputSchema?: CombinedSpec<Output>;
+    execute(input: Input, meta?: KnownAny): FormattedOutput | Promise<FormattedOutput>;
+}

package/dist/types/standard-tool.js

@@ -0,0 +1 @@
+export {};

package/dist/types/tools.d.ts

@@ -1,13 +1,17 @@
 import type { VovkJSONSchemaBase } from './json-schema.js';
 import type { VovkRequest } from './request.js';
 import type { CombinedSpec } from './validation.js';
+import type { StandardTool } from './standard-tool.js';
 import type { KnownAny } from './utils.js';
 export type ToModelOutputFn<TInput, TOutput, TFormattedOutput> = (result: TOutput | Error, tool: VovkTool<TInput, TOutput, unknown>, req: Pick<VovkRequest, 'vovk'> | null) => TFormattedOutput | Promise<TFormattedOutput>;
-interface VovkToolCommon<TInput = unknown, TOutput = unknown, TFormattedOutput = unknown, TIsDerived extends boolean = boolean> {
-    execute: (input: TInput, options?: unknown) => TFormattedOutput | Promise<TFormattedOutput>;
-    name: string;
+/**
+ * Vovk tool — produced by both `deriveTools` (procedures → tools) and
+ * `createTool` (standalone tools); both return the same shape. Extends the
+ * {@link StandardTool} convention with Vovk specifics (`title`, `parameters`, `type`).
+ * @see https://vovk.dev/tools
+ */
+export interface VovkTool<TInput = KnownAny, TOutput = KnownAny, TFormattedOutput = KnownAny> extends StandardTool<TInput, TOutput, TFormattedOutput> {
     title: string | undefined;
-    description: string;
     parameters: {
         type?: 'object';
         properties?: {
@@ -18,26 +22,26 @@ interface VovkToolCommon<TInput = unknown, TOutput = unknown, TFormattedOutput =
         required?: ('body' | 'query' | 'params')[];
         additionalProperties?: false;
     };
-    inputSchema: TIsDerived extends true ? undefined : TInput extends undefined ? undefined : CombinedSpec<TInput>;
-    outputSchema: TIsDerived extends true ? CombinedSpec | undefined : TOutput extends undefined ? undefined : CombinedSpec<TOutput>;
-    inputSchemas: TIsDerived extends true ? {
+    inputSchema: TInput extends undefined ? undefined : CombinedSpec<TInput>;
+    outputSchema: TOutput extends undefined ? undefined : CombinedSpec<TOutput>;
+    /**
+     * Per-slot Standard Schemas, populated only when the tool was built via
+     * `deriveTools` from a procedure. Always `undefined` for tools built via
+     * `createTool`.
+     *
+     * @deprecated Use {@link VovkTool.inputSchema} (a merged Standard Schema)
+     * instead. This field will be removed in the next major version.
+     */
+    inputSchemas?: {
         body?: CombinedSpec;
         query?: CombinedSpec;
         params?: CombinedSpec;
-    } : undefined;
+    };
     type: 'function';
 }
-export type VovkToolDerived<TInput, TOutput, TFormattedOutput> = VovkToolCommon<TInput, TOutput, TFormattedOutput, true>;
-export type VovkToolNonDerived<TInput, TOutput, TFormattedOutput> = VovkToolCommon<TInput, TOutput, TFormattedOutput, false>;
-/**
- * Vovk tool type, which can be either derived or non-derived.
- * @see https://vovk.dev/tools
- */
-export type VovkTool<TInput = KnownAny, TOutput = KnownAny, TFormattedOutput = KnownAny> = VovkToolDerived<TInput, TOutput, TFormattedOutput> | VovkToolNonDerived<TInput, TOutput, TFormattedOutput>;
 export type VovkToolOptions = {
     hidden?: boolean;
     name?: string;
     title?: string;
     description?: string;
 };
-export {};

package/dist/types.d.ts

@@ -0,0 +1,239 @@
+import type { NextRequest } from 'next/server';
+import type { OperationObject } from 'openapi3-ts/oas31';
+import type { JSONLinesResponse } from './JSONLinesResponse';
+import { VovkStreamAsyncIterable } from './client/types';
+import type { PackageJson } from 'type-fest';
+export type KnownAny = any;
+export type StaticClass = Function;
+export type VovkHandlerSchema = {
+    path: string;
+    httpMethod: string;
+    validation?: {
+        query?: KnownAny;
+        body?: KnownAny;
+        params?: KnownAny;
+        output?: KnownAny;
+        iteration?: KnownAny;
+    };
+    openapi?: OperationObject;
+    misc?: Record<string, KnownAny>;
+};
+export type VovkControllerSchema = {
+    rpcModuleName: string;
+    originalControllerName: string;
+    prefix?: string;
+    handlers: Record<string, VovkHandlerSchema>;
+};
+export type VovkSegmentSchema = {
+    emitSchema: boolean;
+    segmentName: string;
+    controllers: Record<string, VovkControllerSchema>;
+};
+export type VovkErrorResponse = {
+    cause?: unknown;
+    statusCode: HttpStatus;
+    message: string;
+    isError: true;
+};
+export type VovkControllerInternal = {
+    _rpcModuleName?: VovkControllerSchema['rpcModuleName'];
+    _prefix?: VovkControllerSchema['prefix'];
+    _handlers: VovkControllerSchema['handlers'];
+    _handlersMetadata?: Record<string, {
+        staticParams?: Record<string, string>[];
+    }>;
+    _activated?: true;
+    _onError?: (err: Error, req: VovkRequest) => void | Promise<void>;
+};
+export type VovkController = StaticClass & VovkControllerInternal & {
+    [key: string]: unknown;
+};
+export type DecoratorOptions = {
+    cors?: boolean;
+    headers?: Record<string, string>;
+    staticParams?: Record<string, string>[];
+    before?: (this: VovkController, req: VovkRequest) => unknown;
+};
+export type RouteHandler = ((req: VovkRequest, params: Record<string, string>) => Response | Promise<Response> | Iterable<unknown> | AsyncIterable<unknown>) & {
+    _options?: DecoratorOptions;
+};
+export interface VovkRequest<BODY extends KnownAny = null, QUERY extends KnownAny = undefined, PARAMS extends KnownAny = undefined> extends Omit<NextRequest, 'json' | 'nextUrl'> {
+    json: () => Promise<BODY>;
+    nextUrl: Omit<NextRequest['nextUrl'], 'searchParams'> & {
+        searchParams: Omit<NextRequest['nextUrl']['searchParams'], 'get' | 'getAll' | 'entries' | 'forEach' | 'keys' | 'values'> & {
+            get: <KEY extends keyof QUERY>(key: KEY) => QUERY[KEY] extends readonly (infer ITEM)[] ? ITEM : QUERY[KEY];
+            getAll: <KEY extends keyof QUERY>(key: KEY) => QUERY[KEY] extends KnownAny[] ? QUERY[KEY] : QUERY[KEY][];
+            entries: () => IterableIterator<[keyof QUERY, QUERY[keyof QUERY]]>;
+            forEach: (callbackfn: (value: QUERY[keyof QUERY], key: keyof QUERY, searchParams: NextRequest['nextUrl']['searchParams']) => void) => void;
+            keys: () => IterableIterator<keyof QUERY>;
+            values: () => IterableIterator<QUERY[keyof QUERY]>;
+        };
+    };
+    vovk: {
+        body: () => Promise<BODY>;
+        query: () => QUERY;
+        meta: <T = Record<KnownAny, KnownAny>>(meta?: T | null) => T;
+        form: <T = KnownAny>() => Promise<T>;
+        params: () => PARAMS;
+    };
+}
+export type ControllerStaticMethod<REQ extends VovkRequest<KnownAny, KnownAny> = VovkRequest<undefined, Record<string, KnownAny>>, PARAMS extends {
+    [key: string]: string;
+} = KnownAny> = ((req: REQ, params: PARAMS) => unknown) & {
+    _controller?: VovkController;
+};
+export type VovkControllerBody<T extends (...args: KnownAny) => KnownAny> = Awaited<ReturnType<Parameters<T>[0]['vovk']['body']>>;
+export type VovkControllerQuery<T extends (...args: KnownAny) => KnownAny> = ReturnType<Parameters<T>[0]['vovk']['query']>;
+export type VovkControllerParams<T extends (...args: KnownAny) => KnownAny> = Parameters<T>[1] extends object ? Parameters<T>[1] : ReturnType<Parameters<T>[0]['vovk']['params']>;
+export type VovkControllerYieldType<T extends (req: VovkRequest<KnownAny, KnownAny>) => KnownAny> = T extends (...args: KnownAny[]) => AsyncGenerator<infer Y, KnownAny, KnownAny> ? Y : T extends (...args: KnownAny[]) => Generator<infer Y, KnownAny, KnownAny> ? Y : T extends (...args: KnownAny[]) => Promise<JSONLinesResponse<infer Y>> | JSONLinesResponse<infer Y> ? Y : never;
+export type VovkControllerOutput<T extends ((...args: KnownAny) => KnownAny) & {
+    __output?: KnownAny;
+}> = T['__output'];
+export type VovkControllerIteration<T extends ((...args: KnownAny) => KnownAny) & {
+    __iteration?: KnownAny;
+}> = T['__iteration'];
+export type VovkBody<T extends (...args: KnownAny[]) => unknown> = Parameters<T>[0]['body'];
+export type VovkQuery<T extends (...args: KnownAny[]) => unknown> = Parameters<T>[0]['query'];
+export type VovkParams<T extends (...args: KnownAny[]) => unknown> = Parameters<T>[0]['params'];
+export type VovkYieldType<T extends (...args: KnownAny[]) => unknown> = T extends (...args: KnownAny[]) => Promise<VovkStreamAsyncIterable<infer Y>> ? Y : never;
+export type VovkReturnType<T extends (...args: KnownAny) => unknown> = Awaited<ReturnType<T>>;
+export type StreamAbortMessage = {
+    isError: true;
+    reason: KnownAny;
+};
+export type VovkValidationType = 'body' | 'query' | 'params' | 'output' | 'iteration';
+export type VovkFullSchema = {
+    config: Partial<VovkStrictConfig>;
+    segments: Record<string, VovkSegmentSchema>;
+};
+export declare enum HttpMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    DELETE = "DELETE",
+    HEAD = "HEAD",
+    OPTIONS = "OPTIONS"
+}
+export declare enum HttpStatus {
+    NULL = 0,
+    CONTINUE = 100,
+    SWITCHING_PROTOCOLS = 101,
+    PROCESSING = 102,
+    EARLYHINTS = 103,
+    OK = 200,
+    CREATED = 201,
+    ACCEPTED = 202,
+    NON_AUTHORITATIVE_INFORMATION = 203,
+    NO_CONTENT = 204,
+    RESET_CONTENT = 205,
+    PARTIAL_CONTENT = 206,
+    AMBIGUOUS = 300,
+    MOVED_PERMANENTLY = 301,
+    FOUND = 302,
+    SEE_OTHER = 303,
+    NOT_MODIFIED = 304,
+    TEMPORARY_REDIRECT = 307,
+    PERMANENT_REDIRECT = 308,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    PAYMENT_REQUIRED = 402,
+    FORBIDDEN = 403,
+    NOT_FOUND = 404,
+    METHOD_NOT_ALLOWED = 405,
+    NOT_ACCEPTABLE = 406,
+    PROXY_AUTHENTICATION_REQUIRED = 407,
+    REQUEST_TIMEOUT = 408,
+    CONFLICT = 409,
+    GONE = 410,
+    LENGTH_REQUIRED = 411,
+    PRECONDITION_FAILED = 412,
+    PAYLOAD_TOO_LARGE = 413,
+    URI_TOO_LONG = 414,
+    UNSUPPORTED_MEDIA_TYPE = 415,
+    REQUESTED_RANGE_NOT_SATISFIABLE = 416,
+    EXPECTATION_FAILED = 417,
+    I_AM_A_TEAPOT = 418,
+    MISDIRECTED = 421,
+    UNPROCESSABLE_ENTITY = 422,
+    FAILED_DEPENDENCY = 424,
+    PRECONDITION_REQUIRED = 428,
+    TOO_MANY_REQUESTS = 429,
+    INTERNAL_SERVER_ERROR = 500,
+    NOT_IMPLEMENTED = 501,
+    BAD_GATEWAY = 502,
+    SERVICE_UNAVAILABLE = 503,
+    GATEWAY_TIMEOUT = 504,
+    HTTP_VERSION_NOT_SUPPORTED = 505
+}
+type ClientConfigCommon = {
+    enabled?: boolean;
+    outDir?: string;
+    fromTemplates?: string[];
+} & ({
+    excludeSegments?: never;
+    includeSegments?: string[];
+} | {
+    excludeSegments?: string[];
+    includeSegments?: never;
+});
+type ClientConfigFull = ClientConfigCommon & {
+    package?: PackageJson;
+};
+type ClientConfigSegmented = ClientConfigCommon & {
+    packages?: Record<string, PackageJson>;
+};
+export type ClientTemplateDef = {
+    extends?: string;
+    templatePath?: string | null;
+    origin?: string | null;
+    fullClient?: Omit<ClientConfigFull, 'fromTemplates' | 'enabled'>;
+    segmentedClient?: Omit<ClientConfigSegmented, 'fromTemplates' | 'enabled'>;
+    segmentConfig?: false | Record<string, {
+        origin?: string;
+        rootEntry?: boolean;
+    }>;
+    requires?: Record<string, string>;
+};
+export type VovkConfig = {
+    emitConfig?: boolean | (keyof VovkStrictConfig)[];
+    schemaOutDir?: string;
+    fullClient?: ClientConfigFull;
+    segmentedClient?: ClientConfigSegmented;
+    imports?: {
+        fetcher?: string | [string, string] | [string];
+        validateOnClient?: string | [string, string] | [string];
+        createRPC?: string | [string, string] | [string];
+    };
+    modulesDir?: string;
+    rootEntry?: string;
+    origin?: string;
+    rootSegmentModulesDirName?: string;
+    logLevel?: 'error' | 'trace' | 'debug' | 'info' | 'warn';
+    prettifyClient?: boolean;
+    devHttps?: boolean;
+    clientTemplateDefs?: Record<string, ClientTemplateDef>;
+    moduleTemplates?: {
+        service?: string;
+        controller?: string;
+        [key: string]: string | undefined;
+    };
+    libs?: Record<string, KnownAny>;
+    segmentConfig?: false | Record<string, {
+        origin?: string;
+        rootEntry?: boolean;
+    }>;
+};
+export type VovkStrictConfig = Required<Omit<VovkConfig, 'emitConfig' | 'libs' | 'imports' | 'fullClient' | 'segmentedClient'>> & {
+    emitConfig: (keyof VovkStrictConfig)[];
+    imports: {
+        fetcher: [string, string] | [string];
+        validateOnClient: [string, string] | [string] | null;
+        createRPC: [string, string] | [string];
+    };
+    libs: Record<string, KnownAny>;
+    fullClient: RequireFields<ClientConfigFull, 'enabled' | 'fromTemplates' | 'outDir'>;
+    segmentedClient: RequireFields<ClientConfigSegmented, 'enabled' | 'fromTemplates' | 'outDir'>;
+};
+type RequireFields<T, K extends keyof T> = T & Required<Pick<T, K>>;
+export {};

package/dist/types.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpStatus = exports.HttpMethod = void 0;
+// Enums
+var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["GET"] = "GET";
+    HttpMethod["POST"] = "POST";
+    HttpMethod["PUT"] = "PUT";
+    HttpMethod["PATCH"] = "PATCH";
+    HttpMethod["DELETE"] = "DELETE";
+    HttpMethod["HEAD"] = "HEAD";
+    HttpMethod["OPTIONS"] = "OPTIONS";
+})(HttpMethod || (exports.HttpMethod = HttpMethod = {}));
+var HttpStatus;
+(function (HttpStatus) {
+    HttpStatus[HttpStatus["NULL"] = 0] = "NULL";
+    HttpStatus[HttpStatus["CONTINUE"] = 100] = "CONTINUE";
+    HttpStatus[HttpStatus["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
+    HttpStatus[HttpStatus["PROCESSING"] = 102] = "PROCESSING";
+    HttpStatus[HttpStatus["EARLYHINTS"] = 103] = "EARLYHINTS";
+    HttpStatus[HttpStatus["OK"] = 200] = "OK";
+    HttpStatus[HttpStatus["CREATED"] = 201] = "CREATED";
+    HttpStatus[HttpStatus["ACCEPTED"] = 202] = "ACCEPTED";
+    HttpStatus[HttpStatus["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
+    HttpStatus[HttpStatus["NO_CONTENT"] = 204] = "NO_CONTENT";
+    HttpStatus[HttpStatus["RESET_CONTENT"] = 205] = "RESET_CONTENT";
+    HttpStatus[HttpStatus["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
+    HttpStatus[HttpStatus["AMBIGUOUS"] = 300] = "AMBIGUOUS";
+    HttpStatus[HttpStatus["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+    HttpStatus[HttpStatus["FOUND"] = 302] = "FOUND";
+    HttpStatus[HttpStatus["SEE_OTHER"] = 303] = "SEE_OTHER";
+    HttpStatus[HttpStatus["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
+    HttpStatus[HttpStatus["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
+    HttpStatus[HttpStatus["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
+    HttpStatus[HttpStatus["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    HttpStatus[HttpStatus["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+    HttpStatus[HttpStatus["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
+    HttpStatus[HttpStatus["FORBIDDEN"] = 403] = "FORBIDDEN";
+    HttpStatus[HttpStatus["NOT_FOUND"] = 404] = "NOT_FOUND";
+    HttpStatus[HttpStatus["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+    HttpStatus[HttpStatus["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+    HttpStatus[HttpStatus["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
+    HttpStatus[HttpStatus["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+    HttpStatus[HttpStatus["CONFLICT"] = 409] = "CONFLICT";
+    HttpStatus[HttpStatus["GONE"] = 410] = "GONE";
+    HttpStatus[HttpStatus["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
+    HttpStatus[HttpStatus["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+    HttpStatus[HttpStatus["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+    HttpStatus[HttpStatus["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
+    HttpStatus[HttpStatus["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+    HttpStatus[HttpStatus["REQUESTED_RANGE_NOT_SATISFIABLE"] = 416] = "REQUESTED_RANGE_NOT_SATISFIABLE";
+    HttpStatus[HttpStatus["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
+    HttpStatus[HttpStatus["I_AM_A_TEAPOT"] = 418] = "I_AM_A_TEAPOT";
+    HttpStatus[HttpStatus["MISDIRECTED"] = 421] = "MISDIRECTED";
+    HttpStatus[HttpStatus["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+    HttpStatus[HttpStatus["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
+    HttpStatus[HttpStatus["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
+    HttpStatus[HttpStatus["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+    HttpStatus[HttpStatus["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+    HttpStatus[HttpStatus["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+    HttpStatus[HttpStatus["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+    HttpStatus[HttpStatus["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+    HttpStatus[HttpStatus["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+    HttpStatus[HttpStatus["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
+})(HttpStatus || (exports.HttpStatus = HttpStatus = {}));

package/dist/utils/generateStaticAPI.d.ts

@@ -0,0 +1,4 @@
+import type { StaticClass } from '../types';
+export declare function generateStaticAPI(c: Record<string, StaticClass>, slug?: string): {
+    [slug]: string[];
+}[];

package/dist/utils/generateStaticAPI.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStaticAPI = generateStaticAPI;
+function generateStaticAPI(c, slug = 'vovk') {
+    const controllers = c;
+    return [
+        { [slug]: ['_schema_'] },
+        ...Object.values(controllers)
+            .map((controller) => {
+            const handlers = controller._handlers;
+            const splitPrefix = controller._prefix?.split('/') ?? [];
+            return Object.entries(handlers)
+                .map(([name, handler]) => {
+                const staticParams = controller._handlersMetadata?.[name]?.staticParams;
+                if (staticParams?.length) {
+                    return staticParams.map((paramsItem) => {
+                        let path = handler.path;
+                        for (const [key, value] of Object.entries(paramsItem)) {
+                            path = path.replace(`:${key}`, value);
+                        }
+                        return { [slug]: [...splitPrefix, ...path.split('/')].filter(Boolean) };
+                    });
+                }
+                return [{ [slug]: [...splitPrefix, ...handler.path.split('/')].filter(Boolean) }];
+            })
+                .flat();
+        })
+            .flat(),
+    ];
+}

package/dist/utils/getSchema.d.ts

@@ -0,0 +1,20 @@
+import type { VovkSegmentSchema, VovkController, StaticClass } from '../types';
+export declare function getControllerSchema(controller: VovkController, rpcModuleName: string, exposeValidation: boolean): {
+    rpcModuleName: string;
+    originalControllerName: string;
+    prefix: string;
+    handlers: {
+        [k: string]: {
+            path: string;
+            httpMethod: string;
+            openapi?: import("openapi3-ts/oas31").OperationObject;
+            misc?: Record<string, import("../types").KnownAny>;
+        };
+    };
+};
+export default function getSchema(options: {
+    emitSchema?: boolean;
+    segmentName?: string;
+    controllers: Record<string, StaticClass>;
+    exposeValidation?: boolean;
+}): VovkSegmentSchema;

package/dist/utils/getSchema.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getControllerSchema = getControllerSchema;
+exports.default = getSchema;
+function getControllerSchema(controller, rpcModuleName, exposeValidation) {
+    return {
+        rpcModuleName,
+        originalControllerName: controller.name,
+        prefix: controller._prefix ?? '',
+        handlers: {
+            ...(exposeValidation
+                ? controller._handlers
+                : Object.fromEntries(
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                Object.entries(controller._handlers ?? {}).map(([key, { validation: _v, ...value }]) => [key, value]))),
+        },
+    };
+}
+function getSchema(options) {
+    const exposeValidation = options?.exposeValidation ?? true;
+    const emitSchema = options.emitSchema ?? true;
+    const schema = {
+        emitSchema,
+        segmentName: options.segmentName ?? '',
+        controllers: {},
+    };
+    if (!emitSchema)
+        return schema;
+    for (const [rpcModuleName, controller] of Object.entries(options.controllers)) {
+        schema.controllers[rpcModuleName] = getControllerSchema(controller, rpcModuleName, exposeValidation);
+    }
+    return schema;
+}

package/dist/utils/parseQuery.d.ts

@@ -0,0 +1,25 @@
+import type { KnownAny } from '../types';
+/**
+ * Deserialize a bracket-based query string into an object.
+ *
+ * Supports:
+ *   - Key/value pairs with nested brackets (e.g. "a[b][0]=value")
+ *   - Arrays with empty bracket (e.g. "arr[]=1&arr[]=2")
+ *   - Mixed arrays of objects, etc.
+ *
+ * @example
+ *   parseQuery("x=xx&y[0]=yy&y[1]=uu&z[f]=x&z[u][0]=uu&z[u][1]=xx&z[d][x]=ee")
+ *   => {
+ *        x: "xx",
+ *        y: ["yy", "uu"],
+ *        z: {
+ *          f: "x",
+ *          u: ["uu", "xx"],
+ *          d: { x: "ee" }
+ *        }
+ *      }
+ *
+ * @param queryString - The raw query string (e.g. location.search.slice(1))
+ * @returns           - A nested object representing the query params
+ */
+export default function parseQuery(queryString: string): Record<string, KnownAny>;

package/dist/utils/parseQuery.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = parseQuery;
+/**
+ * Parse a bracket-based key (e.g. "z[d][0][x]" or "arr[]")
+ * into an array of path segments (strings or special push-markers).
+ *
+ * Example: "z[d][0][x]" => ["z", "d", "0", "x"]
+ * Example: "arr[]"      => ["arr", "" ]  // "" indicates "push" onto array
+ */
+function parseKey(key) {
+    // The first segment is everything up to the first '[' (or the entire key if no '[')
+    const segments = [];
+    const topKeyMatch = key.match(/^([^[\]]+)/);
+    if (topKeyMatch) {
+        segments.push(topKeyMatch[1]);
+    }
+    else {
+        // If it starts with brackets, treat it as empty? (edge case)
+        segments.push('');
+    }
+    // Now capture all bracket parts: [something], [0], []
+    const bracketRegex = /\[([^[\]]*)\]/g;
+    let match;
+    while ((match = bracketRegex.exec(key)) !== null) {
+        // match[1] is the content inside the brackets
+        segments.push(match[1]);
+    }
+    return segments;
+}
+/**
+ * Recursively set a value in a nested object/array, given a path of segments.
+ * - If segment is numeric => treat as array index
+ * - If segment is empty "" => push to array
+ * - Else => object property
+ */
+function setValue(obj, path, value) {
+    let current = obj;
+    for (let i = 0; i < path.length; i++) {
+        const segment = path[i];
+        // If we're at the last segment, set the value
+        if (i === path.length - 1) {
+            if (segment === '') {
+                // Empty bracket => push
+                if (!Array.isArray(current)) {
+                    current = [];
+                }
+                current.push(value);
+            }
+            else if (!isNaN(Number(segment))) {
+                // Numeric segment => array index
+                const idx = Number(segment);
+                if (!Array.isArray(current)) {
+                    current = [];
+                }
+                current[idx] = value;
+            }
+            else {
+                // Object property
+                current[segment] = value;
+            }
+        }
+        else {
+            // Not the last segment: descend into existing structure or create it
+            const nextSegment = path[i + 1];
+            if (segment === '') {
+                // Empty bracket => push
+                if (!Array.isArray(current)) {
+                    // Convert the current node into an array, if not one
+                    current = [];
+                }
+                // If we are not at the last path, we need a placeholder object or array
+                // for the next segment. We'll push something and move current to that.
+                if (current.length === 0) {
+                    // nothing in array yet
+                    current.push(typeof nextSegment === 'string' && !isNaN(Number(nextSegment)) ? [] : {});
+                }
+                else if (typeof nextSegment === 'string' && !isNaN(Number(nextSegment))) {
+                    // next is numeric => we want an array
+                    if (!Array.isArray(current[current.length - 1])) {
+                        current[current.length - 1] = [];
+                    }
+                }
+                else {
+                    // next is not numeric => we want an object
+                    if (typeof current[current.length - 1] !== 'object') {
+                        current[current.length - 1] = {};
+                    }
+                }
+                current = current[current.length - 1];
+            }
+            else if (!isNaN(Number(segment))) {
+                // segment is numeric => array index
+                const idx = Number(segment);
+                if (!Array.isArray(current)) {
+                    current = [];
+                }
+                if (current[idx] === undefined) {
+                    // Create placeholder for next segment
+                    current[idx] = typeof nextSegment === 'string' && !isNaN(Number(nextSegment)) ? [] : {};
+                }
+                current = current[idx];
+            }
+            else {
+                // segment is an object key
+                if (current[segment] === undefined) {
+                    // Create placeholder
+                    current[segment] = typeof nextSegment === 'string' && !isNaN(Number(nextSegment)) ? [] : {};
+                }
+                current = current[segment];
+            }
+        }
+    }
+}
+/**
+ * Deserialize a bracket-based query string into an object.
+ *
+ * Supports:
+ *   - Key/value pairs with nested brackets (e.g. "a[b][0]=value")
+ *   - Arrays with empty bracket (e.g. "arr[]=1&arr[]=2")
+ *   - Mixed arrays of objects, etc.
+ *
+ * @example
+ *   parseQuery("x=xx&y[0]=yy&y[1]=uu&z[f]=x&z[u][0]=uu&z[u][1]=xx&z[d][x]=ee")
+ *   => {
+ *        x: "xx",
+ *        y: ["yy", "uu"],
+ *        z: {
+ *          f: "x",
+ *          u: ["uu", "xx"],
+ *          d: { x: "ee" }
+ *        }
+ *      }
+ *
+ * @param queryString - The raw query string (e.g. location.search.slice(1))
+ * @returns           - A nested object representing the query params
+ */
+function parseQuery(queryString) {
+    const result = {};
+    if (!queryString)
+        return result;
+    // Split into key=value pairs
+    const pairs = queryString
+        .replace(/^\?/, '') // Remove leading "?" if present
+        .split('&');
+    for (const pair of pairs) {
+        const [rawKey, rawVal = ''] = pair.split('=');
+        const decodedKey = decodeURIComponent(rawKey || '');
+        const decodedVal = decodeURIComponent(rawVal);
+        // Parse bracket notation
+        const pathSegments = parseKey(decodedKey);
+        // Insert into the result object
+        setValue(result, pathSegments, decodedVal);
+    }
+    return result;
+}

package/dist/utils/reqForm.d.ts

@@ -0,0 +1,2 @@
+import type { KnownAny, VovkRequest } from '../types';
+export default function reqForm<T = KnownAny>(req: VovkRequest<KnownAny, KnownAny>): Promise<T>;