vovk 3.0.0 → 3.0.3

package/README.md

@@ -9,6 +9,8 @@
   <br>
   <strong>Back-end Framework for Next.js App Router</strong>
   <br />
+  <em>One codebase → type-safe clients, OpenAPI, and AI tools</em>
+  <br />
   <a href="https://vovk.dev/">Documentation</a>
   &nbsp;&nbsp;
   <a href="https://vovk.dev/quick-install">Quick Start</a>
@@ -23,7 +25,7 @@
 The Vovk.ts runtime library with [100% self-composition](https://bundlephobia.com/result?p=vovk). It provides a wrapper for Next.js API routes, client-side tooling, utilities and types.
 
 ```sh
-npm install vovk openapi3-ts
+npm install vovk
 ```
 
 ## Links

package/bin/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { spawn } from 'child_process';
+import { spawn } from 'node:child_process';
 
 console.warn(
   `\x1b[33m🐺 Vovk CLI requires vovk-cli package. Running npx vovk-cli@latest ${process.argv.slice(2).join(' ')} instead.\x1b[0m`

package/dist/client/createRPC.js

@@ -87,7 +87,7 @@ export const createRPC = (givenSchema, segmentName, rpcModuleName, givenFetcher,
                 !(input.body instanceof FormData || input.body instanceof URLSearchParams || input.body instanceof Blob)) {
                 processedBody = new FormData();
                 for (const [key, value] of Object.entries(input.body)) {
-                    if (value instanceof Array) {
+                    if (Array.isArray(value)) {
                         value.forEach((item) => {
                             processedBody.append(key, item);
                         });

package/dist/client/defaultStreamHandler.js

@@ -101,7 +101,7 @@ export const readableStreamToAsyncIterable = ({ readableStream, abortController,
                     if (error?.name === 'AbortError' && isAbortedWithoutError) {
                         break;
                     }
-                    const err = new Error('JSONLines stream error. ' + String(error));
+                    const err = new Error(`JSONLines stream error. ${String(error)}`);
                     err.cause = error;
                     setStreamError(err);
                     return;
@@ -113,7 +113,10 @@ export const readableStreamToAsyncIterable = ({ readableStream, abortController,
                         : new TextDecoder().decode(value);
                 buffer += chunk;
                 let newlineIdx;
-                while ((newlineIdx = buffer.indexOf('\n')) !== -1) {
+                while (true) {
+                    newlineIdx = buffer.indexOf('\n');
+                    if (newlineIdx === -1)
+                        break;
                     if (abortController?.signal.aborted && isAbortedWithoutError) {
                         break;
                     }

package/dist/client/fetcher.js

@@ -92,7 +92,7 @@ export function createFetcher({ prepareRequestInit, transformResponse, onSuccess
             }
             catch (e) {
                 // handle network errors
-                throw new HttpException(HttpStatus.NULL, (e?.message ?? DEFAULT_ERROR_MESSAGE) + ' ' + endpoint, {
+                throw new HttpException(HttpStatus.NULL, `${e?.message ?? DEFAULT_ERROR_MESSAGE} ${endpoint}`, {
                     body,
                     query,
                     params,

package/dist/client/serializeQuery.js

@@ -53,7 +53,7 @@ export function serializeQuery(obj) {
     // Collect query segments
     const segments = [];
     for (const key in obj) {
-        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        if (Object.hasOwn(obj, key)) {
             const value = obj[key];
             segments.push(...buildParams(key, value));
         }

package/dist/core/JSONLinesResponder.js

@@ -29,6 +29,7 @@ export class JSONLinesResponder extends Responder {
     isClosed = false;
     i = 0;
     controller;
+    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: biome bug
     encoder;
     readableStream;
     headers;
@@ -54,6 +55,7 @@ export class JSONLinesResponder extends Responder {
         this.headers = headers;
         this.readableStream = readableStream;
         this.encoder = encoder;
+        // biome-ignore lint/style/noNonNullAssertion: assigned at readableStream start
         this.controller = readableController;
         this.response = getResponse?.(this) ?? new Response(readableStream, { headers });
         request?.signal?.addEventListener('abort', this.close, { once: true });
@@ -76,7 +78,7 @@ export class JSONLinesResponder extends Responder {
         const { controller, encoder } = this;
         if (this.isClosed)
             return;
-        controller?.enqueue(encoder?.encode(JSON.stringify(data) + '\n'));
+        controller?.enqueue(encoder?.encode(`${JSON.stringify(data)}\n`));
     };
     close = () => {
         const { controller } = this;

package/dist/core/controllersToStaticParams.js

@@ -11,12 +11,10 @@ export function controllersToStaticParams(c, slug = 'vovk') {
     const controllers = c;
     return [
         { [slug]: ['_schema_'] },
-        ...Object.values(controllers)
-            .map((controller) => {
+        ...Object.values(controllers).flatMap((controller) => {
             const handlers = controller._handlers;
             const splitPrefix = controller._prefix?.split('/') ?? [];
-            return Object.entries(handlers ?? {})
-                .map(([name, handler]) => {
+            return Object.entries(handlers ?? {}).flatMap(([name, handler]) => {
                 const staticParams = controller._handlersMetadata?.[name]?.staticParams;
                 if (staticParams?.length) {
                     return staticParams.map((paramsItem) => {
@@ -28,9 +26,7 @@ export function controllersToStaticParams(c, slug = 'vovk') {
                     });
                 }
                 return [{ [slug]: [...splitPrefix, ...handler.path.split('/')].filter(Boolean) }];
-            })
-                .flat();
-        })
-            .flat(),
+            });
+        }),
     ];
 }

package/dist/core/createDecorator.d.ts

@@ -2,11 +2,17 @@ import type { VovkHandlerSchema, VovkController } from '../types/core.js';
 import type { VovkRequest } from '../types/request.js';
 import type { KnownAny } from '../types/utils.js';
 type Next = () => Promise<unknown>;
+/** Minimal shape shared by all TC39 Stage 3 decorator context objects. */
+type _Stage3Context = {
+    kind: string;
+    name: string | symbol;
+    addInitializer: (fn: () => void) => void;
+};
 /**
  * Creates a custom decorator for Vovk controllers.
  * @see https://vovk.dev/decorator
  */
 export declare function createDecorator<TArgs extends unknown[], TRequest = VovkRequest>(handler: null | ((this: VovkController, req: TRequest, next: Next, ...args: TArgs) => unknown), initHandler?: (this: VovkController, ...args: TArgs) => Omit<VovkHandlerSchema, 'path' | 'httpMethod'> | ((handlerSchema: VovkHandlerSchema | null, options: {
     handlerName: string;
-}) => Omit<Partial<VovkHandlerSchema>, 'path' | 'httpMethod'>) | null | undefined): (...args: TArgs) => (target: KnownAny, propertyKey: string) => void;
+}) => Omit<Partial<VovkHandlerSchema>, 'path' | 'httpMethod'>) | null | undefined): (...args: TArgs) => (target: KnownAny, propertyKeyOrContext: string | _Stage3Context) => void;
 export {};

package/dist/core/createDecorator.js

@@ -4,46 +4,57 @@
  */
 export 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`);
+        return function decorator(target, propertyKeyOrContext) {
+            if (typeof propertyKeyOrContext === 'object' && propertyKeyOrContext !== null && 'kind' in propertyKeyOrContext) {
+                // TC39 Stage 3 decorator — defer to addInitializer where `this` is the class
+                const propertyKey = String(propertyKeyOrContext.name);
+                propertyKeyOrContext.addInitializer(function () {
+                    applyDecorator(this, propertyKey);
+                });
+                return;
             }
-            const sourceMethod = originalMethod._sourceMethod ?? originalMethod;
-            const method = function method(req, params) {
-                const next = async () => {
-                    return await originalMethod.call(controller, req, params);
+            // Experimental decorator — target is the class for static members
+            applyDecorator(target, propertyKeyOrContext);
+            function applyDecorator(controller, propertyKey) {
+                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();
                 };
-                return handler ? handler.call(controller, req, next, ...args) : next();
-            };
-            controller[propertyKey] = method;
-            method._controller = controller;
-            method._sourceMethod = sourceMethod;
-            method.fn = originalMethod.fn;
-            method.definition = originalMethod.definition;
-            sourceMethod.wrapper = method;
-            // 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;
-            const methodSchema = {
-                ...handlerSchema,
-                // avoid override of path and httpMethod
-                ...(initResult?.validation ? { validation: initResult.validation } : {}),
-                ...(initResult?.operationObject ? { operationObject: initResult.operationObject } : {}),
-                ...(initResult?.misc ? { misc: initResult.misc } : {}),
-            };
-            method.schema = methodSchema;
-            controller._handlers = {
-                ...controller._handlers,
-                [propertyKey]: methodSchema,
-            };
+                controller[propertyKey] = method;
+                method._controller = controller;
+                method._sourceMethod = sourceMethod;
+                method.fn = originalMethod.fn;
+                method.definition = originalMethod.definition;
+                sourceMethod.wrapper = method;
+                // 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;
+                const methodSchema = {
+                    ...handlerSchema,
+                    // avoid override of path and httpMethod
+                    ...(initResult?.validation ? { validation: initResult.validation } : {}),
+                    ...(initResult?.operationObject ? { operationObject: initResult.operationObject } : {}),
+                    ...(initResult?.misc ? { misc: initResult.misc } : {}),
+                };
+                method.schema = methodSchema;
+                controller._handlers = {
+                    ...controller._handlers,
+                    [propertyKey]: methodSchema,
+                };
+            }
         };
     };
 }

package/dist/core/decorators.d.ts

@@ -1,59 +1,66 @@
 import type { DecoratorOptions } from '../types/core.js';
 import type { KnownAny } from '../types/utils.js';
+/** Minimal shape shared by all TC39 Stage 3 decorator context objects. */
+type _Stage3Context = {
+    kind: string;
+    name: string | symbol;
+    addInitializer: (fn: () => void) => void;
+};
 /**
  * Prefix for all routes in the controller.
  */
-export declare const prefix: (givenPath?: string) => (givenTarget: KnownAny) => any;
+export declare const prefix: (givenPath?: string) => (givenTarget: KnownAny, _context?: KnownAny) => any;
 /**
  * Clones metadata from parent controller to child controller.
  */
-export declare function cloneControllerMetadata(): <T extends new (...args: KnownAny[]) => KnownAny>(c: T) => T;
+export declare function cloneControllerMetadata(): <T extends new (...args: KnownAny[]) => KnownAny>(c: T, _context?: KnownAny) => T;
 /**
  * GET HTTP method decorator.
  */
 export declare const get: {
-    (givenPath?: string | undefined, options?: DecoratorOptions | undefined): (givenTarget: unknown, propertyKey: string) => void;
-    auto: (options?: DecoratorOptions) => (givenTarget: unknown, propertyKey: string) => void;
+    (givenPath?: string | undefined, options?: DecoratorOptions | undefined): (givenTarget: unknown, propertyKeyOrContext: string | _Stage3Context) => void;
+    auto: (options?: DecoratorOptions) => (givenTarget: unknown, propertyKeyOrContext: string | _Stage3Context) => void;
 };
 /**
  *  POST HTTP method decorator.
  */
 export declare const post: {
-    (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: unknown, propertyKey: string) => void;
-    auto: (options?: DecoratorOptions) => (givenTarget: unknown, propertyKey: string) => void;
+    (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: unknown, propertyKeyOrContext: string | _Stage3Context) => void;
+    auto: (options?: DecoratorOptions) => (givenTarget: unknown, propertyKeyOrContext: string | _Stage3Context) => void;
 };
 /**
  *  PUT HTTP method decorator.
  */
 export declare const put: {
-    (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: unknown, propertyKey: string) => void;
-    auto: (options?: DecoratorOptions) => (givenTarget: unknown, propertyKey: string) => void;
+    (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: unknown, propertyKeyOrContext: string | _Stage3Context) => void;
+    auto: (options?: DecoratorOptions) => (givenTarget: unknown, propertyKeyOrContext: string | _Stage3Context) => void;
 };
 /**
  *  PATCH HTTP method decorator.
  */
 export declare const patch: {
-    (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: unknown, propertyKey: string) => void;
-    auto: (options?: DecoratorOptions) => (givenTarget: unknown, propertyKey: string) => void;
+    (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: unknown, propertyKeyOrContext: string | _Stage3Context) => void;
+    auto: (options?: DecoratorOptions) => (givenTarget: unknown, propertyKeyOrContext: string | _Stage3Context) => void;
 };
 /**
  *  DELETE HTTP method decorator.
  */
 export declare const del: {
-    (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: unknown, propertyKey: string) => void;
-    auto: (options?: DecoratorOptions) => (givenTarget: unknown, propertyKey: string) => void;
+    (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: unknown, propertyKeyOrContext: string | _Stage3Context) => void;
+    auto: (options?: DecoratorOptions) => (givenTarget: unknown, propertyKeyOrContext: string | _Stage3Context) => void;
 };
 /**
  * HEAD HTTP method decorator.
  */
 export declare const head: {
-    (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: unknown, propertyKey: string) => void;
-    auto: (options?: DecoratorOptions) => (givenTarget: unknown, propertyKey: string) => void;
+    (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: unknown, propertyKeyOrContext: string | _Stage3Context) => void;
+    auto: (options?: DecoratorOptions) => (givenTarget: unknown, propertyKeyOrContext: string | _Stage3Context) => void;
 };
 /**
  * OPTIONS HTTP method decorator.
  */
 export declare const options: {
-    (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: unknown, propertyKey: string) => void;
-    auto: (options?: DecoratorOptions) => (givenTarget: unknown, propertyKey: string) => void;
+    (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: unknown, propertyKeyOrContext: string | _Stage3Context) => void;
+    auto: (options?: DecoratorOptions) => (givenTarget: unknown, propertyKeyOrContext: string | _Stage3Context) => void;
 };
+export {};

package/dist/core/decorators.js

@@ -3,6 +3,8 @@ import { trimPath } from '../utils/trimPath.js';
 import { toKebabCase } from '../utils/toKebabCase.js';
 import { HttpMethod } from '../types/enums.js';
 const isClass = (func) => typeof func === 'function' && /class/.test(func.toString());
+/** Detects whether the second decorator argument is a TC39 Stage 3 context object. */
+const _isStage3 = (arg) => typeof arg === 'object' && arg !== null && 'kind' in arg;
 const assignSchema = ({ controller, propertyKey, path, options, httpMethod, }) => {
     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.');
@@ -34,7 +36,7 @@ const assignSchema = ({ controller, propertyKey, path, options, httpMethod, }) =
         ...controller._handlers,
         [propertyKey]: {
             ...schema,
-            ...(controller._handlers ?? {})[propertyKey],
+            ...controller._handlers?.[propertyKey],
             path,
             httpMethod,
         },
@@ -44,7 +46,7 @@ const assignSchema = ({ controller, propertyKey, path, options, httpMethod, }) =
     controller._handlersMetadata = {
         ...controller._handlersMetadata,
         [propertyKey]: {
-            ...(controller._handlersMetadata ?? {})[propertyKey],
+            ...controller._handlersMetadata?.[propertyKey],
             staticParams: options?.staticParams,
         },
     };
@@ -52,22 +54,43 @@ const assignSchema = ({ controller, propertyKey, path, options, httpMethod, }) =
 function createHTTPDecorator(httpMethod) {
     function decoratorFactory(givenPath = '', options) {
         const path = trimPath(givenPath);
-        function decorator(givenTarget, propertyKey) {
+        function decorator(givenTarget, propertyKeyOrContext) {
+            if (_isStage3(propertyKeyOrContext)) {
+                const propertyKey = String(propertyKeyOrContext.name);
+                propertyKeyOrContext.addInitializer(function () {
+                    assignSchema({ controller: this, propertyKey, path, options, httpMethod });
+                });
+                return;
+            }
             const controller = givenTarget;
-            assignSchema({ controller, propertyKey, path, options, httpMethod });
+            assignSchema({ controller, propertyKey: propertyKeyOrContext, path, options, httpMethod });
         }
         return decorator;
     }
     const auto = (options) => {
-        function decorator(givenTarget, propertyKey) {
+        function decorator(givenTarget, propertyKeyOrContext) {
+            if (_isStage3(propertyKeyOrContext)) {
+                const propertyKey = String(propertyKeyOrContext.name);
+                propertyKeyOrContext.addInitializer(function () {
+                    const controller = this;
+                    // validation is already assigned at procedure function
+                    const properties = Object.keys(controller._handlers?.[propertyKey]?.validation?.params?.properties ?? {});
+                    const kebabCasePath = toKebabCase(propertyKey);
+                    const path = properties.length
+                        ? `${kebabCasePath}/${properties.map((prop) => `{${prop}}`).join('/')}`
+                        : kebabCasePath;
+                    assignSchema({ controller, propertyKey, path, options, httpMethod });
+                });
+                return;
+            }
             const controller = givenTarget;
             // validation is already assigned at procedure function
-            const properties = Object.keys((controller._handlers ?? {})[propertyKey]?.validation?.params?.properties ?? {});
-            const kebabCasePath = toKebabCase(propertyKey);
+            const properties = Object.keys(controller._handlers?.[propertyKeyOrContext]?.validation?.params?.properties ?? {});
+            const kebabCasePath = toKebabCase(propertyKeyOrContext);
             const path = properties.length
                 ? `${kebabCasePath}/${properties.map((prop) => `{${prop}}`).join('/')}`
                 : kebabCasePath;
-            assignSchema({ controller, propertyKey, path, options, httpMethod });
+            assignSchema({ controller, propertyKey: propertyKeyOrContext, path, options, httpMethod });
         }
         return decorator;
     };
@@ -80,7 +103,7 @@ function createHTTPDecorator(httpMethod) {
  */
 export const prefix = (givenPath = '') => {
     const path = trimPath(givenPath);
-    return (givenTarget) => {
+    return (givenTarget, _context) => {
         const controller = givenTarget;
         controller._prefix = path;
         return givenTarget;
@@ -90,16 +113,16 @@ export const prefix = (givenPath = '') => {
  * Clones metadata from parent controller to child controller.
  */
 export function cloneControllerMetadata() {
-    return function inherit(c) {
+    return function inherit(c, _context) {
         const parent = Object.getPrototypeOf(c);
-        const constructor = c;
-        constructor._handlers = { ...parent._handlers, ...constructor._handlers };
-        constructor._handlersMetadata = { ...parent._handlersMetadata, ...constructor._handlersMetadata };
+        const controller = c;
+        controller._handlers = { ...parent._handlers, ...controller._handlers };
+        controller._handlersMetadata = { ...parent._handlersMetadata, ...controller._handlersMetadata };
         Object.values(vovkApp.routes).forEach((methods) => {
             const parentMethods = methods.get(parent) ?? {};
-            methods.set(constructor, { ...parentMethods, ...methods.get(constructor) });
+            methods.set(controller, { ...parentMethods, ...methods.get(controller) });
         });
-        return constructor;
+        return controller;
     };
 }
 /**

package/dist/core/vovkApp.js

@@ -115,6 +115,8 @@ class VovkApp {
             const candidateRoutes = routesByLength.get(pathLength) || [];
             for (const p of candidateRoutes) {
                 const routeSegments = this.#routeSegmentsCache.get(p);
+                if (!routeSegments)
+                    continue; // This should never happen, fix TS error
                 const params = {};
                 // Fast path for routes with parameters
                 const paramPositions = this.#routeParamPositionsCache.get(p);
@@ -261,7 +263,7 @@ class VovkApp {
             }
             const isIterator = typeof result === 'object' &&
                 !!result &&
-                !(result instanceof Array) &&
+                !Array.isArray(result) &&
                 ((Reflect.has(result, Symbol.iterator) &&
                     typeof result[Symbol.iterator] === 'function') ||
                     (Reflect.has(result, Symbol.asyncIterator) &&

package/dist/openapi/error.d.ts

@@ -1,2 +1,6 @@
 import { HttpStatus } from '../types/enums.js';
-export declare const error: (status: HttpStatus, message: string) => (target: import("../types/utils.js").KnownAny, propertyKey: string) => void;
+export declare const error: (status: HttpStatus, message: string) => (target: import("../types/utils.js").KnownAny, propertyKeyOrContext: string | {
+    kind: string;
+    name: string | symbol;
+    addInitializer: (fn: () => void) => void;
+}) => void;

package/dist/openapi/openAPIToVovkSchema/applyComponentsSchemas.js

@@ -37,7 +37,7 @@ export function applyComponentsSchemas(schema, components, mixinName) {
         const $ref = newObj.$ref;
         if ($ref && typeof $ref === 'string' && $ref.startsWith(`#/${key}/`)) {
             const componentName = $ref.replace(`#/${key}/`, '');
-            if (components[componentName]) {
+            if (components?.[componentName]) {
                 newObj.$ref = `#/$defs/${componentName}`;
                 newObj['x-tsType'] ??= `Mixins.${upperFirst(camelCase(mixinName))}.${upperFirst(camelCase(componentName))}`;
             }
@@ -45,7 +45,7 @@ export function applyComponentsSchemas(schema, components, mixinName) {
                 delete newObj.$ref; // Remove $ref if component not found (Telegram API has Type $refs that is not defined in components)
             }
             // Add the component to $defs if not already added
-            if (!addedComponents.has(componentName) && components[componentName]) {
+            if (!addedComponents.has(componentName) && components?.[componentName]) {
                 addedComponents.add(componentName);
                 if (result.$defs) {
                     result.$defs[componentName] = processSchema(cloneJSON(components[componentName]));
@@ -54,7 +54,7 @@ export function applyComponentsSchemas(schema, components, mixinName) {
         }
         // Process properties recursively
         for (const key in newObj) {
-            if (Object.prototype.hasOwnProperty.call(newObj, key)) {
+            if (Object.hasOwn(newObj, key)) {
                 newObj[key] = processSchema(newObj[key]);
             }
         }

package/dist/openapi/operation.d.ts

@@ -1,10 +1,26 @@
 import type { VovkOperationObject } from '../types/operation.js';
-export declare const operationDecorator: (openAPIOperationObject?: VovkOperationObject | undefined) => (target: import("../types/utils.js").KnownAny, propertyKey: string) => void;
+export declare const operationDecorator: (openAPIOperationObject?: VovkOperationObject | undefined) => (target: import("../types/utils.js").KnownAny, propertyKeyOrContext: string | {
+    kind: string;
+    name: string | symbol;
+    addInitializer: (fn: () => void) => void;
+}) => void;
 /**
  * OpenAPI operation decorator to add metadata to API operations. Also includes `error` and `tool` utilities.
  * @see https://vovk.dev/openapi
  */
-export declare const operation: ((openAPIOperationObject?: VovkOperationObject | undefined) => (target: import("../types/utils.js").KnownAny, propertyKey: string) => void) & {
-    error: (status: import("../index.js").HttpStatus, message: string) => (target: import("../types/utils.js").KnownAny, propertyKey: string) => void;
-    tool: (toolOptions: import("../types/tools.js").VovkToolOptions) => (target: import("../types/utils.js").KnownAny, propertyKey: string) => void;
+export declare const operation: ((openAPIOperationObject?: VovkOperationObject | undefined) => (target: import("../types/utils.js").KnownAny, propertyKeyOrContext: string | {
+    kind: string;
+    name: string | symbol;
+    addInitializer: (fn: () => void) => void;
+}) => void) & {
+    error: (status: import("../index.js").HttpStatus, message: string) => (target: import("../types/utils.js").KnownAny, propertyKeyOrContext: string | {
+        kind: string;
+        name: string | symbol;
+        addInitializer: (fn: () => void) => void;
+    }) => void;
+    tool: (toolOptions: import("../types/tools.js").VovkToolOptions) => (target: import("../types/utils.js").KnownAny, propertyKeyOrContext: string | {
+        kind: string;
+        name: string | symbol;
+        addInitializer: (fn: () => void) => void;
+    }) => void;
 };

package/dist/openapi/tool.d.ts

@@ -1,2 +1,6 @@
 import type { VovkToolOptions } from '../types/tools.js';
-export declare const tool: (toolOptions: VovkToolOptions) => (target: import("../types/utils.js").KnownAny, propertyKey: string) => void;
+export declare const tool: (toolOptions: VovkToolOptions) => (target: import("../types/utils.js").KnownAny, propertyKeyOrContext: string | {
+    kind: string;
+    name: string | symbol;
+    addInitializer: (fn: () => void) => void;
+}) => void;

package/dist/openapi/vovkSchemaToOpenAPI.js

@@ -91,7 +91,7 @@ export function vovkSchemaToOpenAPI({ config, rootEntry = 'api', schema: fullSch
                         }))
                         : null;
                     const path = h.misc?.originalPath ??
-                        '/' + [rootEntry.replace(/^\/+|\/+$/g, ''), segmentName, c.prefix, h.path].filter(Boolean).join('/');
+                        `/${[rootEntry.replace(/^\/+|\/+$/g, ''), segmentName, c.prefix, h.path].filter(Boolean).join('/')}`;
                     paths[path] = paths[path] ?? {};
                     const httpMethod = h.httpMethod.toLowerCase();
                     paths[path][httpMethod] ??= {};

package/dist/req/parseQuery.js

@@ -19,7 +19,10 @@ function parseKey(key) {
     // Now capture all bracket parts: [something], [0], []
     const bracketRegex = /\[([^[\]]*)\]/g;
     let match;
-    while ((match = bracketRegex.exec(key)) !== null) {
+    while (true) {
+        match = bracketRegex.exec(key);
+        if (match === null)
+            break;
         // match[1] is the content inside the brackets
         segments.push(match[1]);
     }
@@ -44,7 +47,7 @@ function setValue(obj, path, value) {
                 }
                 current.push(value);
             }
-            else if (!isNaN(Number(segment))) {
+            else if (!Number.isNaN(Number(segment))) {
                 // Numeric segment => array index
                 const idx = Number(segment);
                 if (!Array.isArray(current)) {
@@ -70,9 +73,9 @@ function setValue(obj, path, value) {
                 // 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)) ? [] : {});
+                    current.push(typeof nextSegment === 'string' && !Number.isNaN(Number(nextSegment)) ? [] : {});
                 }
-                else if (typeof nextSegment === 'string' && !isNaN(Number(nextSegment))) {
+                else if (typeof nextSegment === 'string' && !Number.isNaN(Number(nextSegment))) {
                     // next is numeric => we want an array
                     if (!Array.isArray(current[current.length - 1])) {
                         current[current.length - 1] = [];
@@ -86,7 +89,7 @@ function setValue(obj, path, value) {
                 }
                 current = current[current.length - 1];
             }
-            else if (!isNaN(Number(segment))) {
+            else if (!Number.isNaN(Number(segment))) {
                 // segment is numeric => array index
                 const idx = Number(segment);
                 if (!Array.isArray(current)) {
@@ -94,7 +97,7 @@ function setValue(obj, path, value) {
                 }
                 if (current[idx] === undefined) {
                     // Create placeholder for next segment
-                    current[idx] = typeof nextSegment === 'string' && !isNaN(Number(nextSegment)) ? [] : {};
+                    current[idx] = typeof nextSegment === 'string' && !Number.isNaN(Number(nextSegment)) ? [] : {};
                 }
                 current = current[idx];
             }
@@ -102,7 +105,7 @@ function setValue(obj, path, value) {
                 // segment is an object key
                 if (current[segment] === undefined) {
                     // Create placeholder
-                    current[segment] = typeof nextSegment === 'string' && !isNaN(Number(nextSegment)) ? [] : {};
+                    current[segment] = typeof nextSegment === 'string' && !Number.isNaN(Number(nextSegment)) ? [] : {};
                 }
                 current = current[segment];
             }

package/dist/samples/createCodeSamples.js

@@ -81,7 +81,7 @@ ${[
 }`
         : '';
     const TS_CODE = `import { ${rpcName} } from '${packageName}';
-${bodyValidation && isForm(bodyValidation) ? getTsFormSample(bodyValidation) + '\n' : ''}
+${bodyValidation && isForm(bodyValidation) ? `${getTsFormSample(bodyValidation)}\n` : ''}
 ${iterationValidation ? 'using' : 'const'} response = await ${rpcName}.${handlerName}(${tsArgs});
 ${outputValidation
         ? `
@@ -220,7 +220,7 @@ use serde_json::{
   json 
 };
 ${iterationValidation ? 'use futures_util::StreamExt;\n' : ''}${bodyValidation && isForm(bodyValidation) ? `use reqwest::multipart;\n` : ''}#[tokio::main]
-async fn main() {${bodyValidation && isForm(bodyValidation) ? '\n  ' + getRsFormSample(bodyValidation) + '\n' : ''}
+async fn main() {${bodyValidation && isForm(bodyValidation) ? `\n  ${getRsFormSample(bodyValidation)}\n` : ''}
   let response = ${rpcNameSnake}::${handlerNameSnake}(
     ${bodyValidation ? getBody(bodyValidation) : '()'}, /* body */ 
     ${queryValidation ? serdeUnwrap(getRsJSONSample(queryValidation)) : '()'}, /* query */ 

package/dist/samples/schemaToCode.js

@@ -47,7 +47,7 @@ export function getSampleValue(schema, rootSchema, ignoreBinary) {
     }
     if (schema.allOf && schema.allOf.length > 0) {
         // Merge all schemas in allOf
-        const mergedSchema = schema.allOf.reduce((acc, s) => ({ ...acc, ...s }), {});
+        const mergedSchema = schema.allOf.reduce((acc, s) => Object.assign(acc, s), {});
         return getSampleValue(mergedSchema, rootSchema, ignoreBinary);
     }
     // Handle different types
@@ -235,7 +235,7 @@ function handleObject(schema, rootSchema, ignoreBinary) {
     if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
         const value = getSampleValue(schema.additionalProperties, rootSchema, ignoreBinary);
         if (value !== undefined) {
-            result['additionalProp'] = value;
+            result.additionalProp = value;
         }
     }
     return result;

package/dist/samples/schemaToObject.js

@@ -32,7 +32,7 @@ export function schemaToObject(schema, rootSchema) {
     }
     if (schema.allOf && schema.allOf.length > 0) {
         // Merge all schemas in allOf
-        const mergedSchema = schema.allOf.reduce((acc, s) => ({ ...acc, ...s }), {});
+        const mergedSchema = schema.allOf.reduce((acc, s) => Object.assign(acc, s), {});
         return schemaToObject(mergedSchema, rootSchema);
     }
     // Handle different types
@@ -148,7 +148,7 @@ function handleObject(schema, rootSchema) {
     }
     // Handle additionalProperties
     if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
-        result['additionalProp'] = schemaToObject(schema.additionalProperties, rootSchema);
+        result.additionalProp = schemaToObject(schema.additionalProperties, rootSchema);
     }
     return result;
 }

package/dist/samples/schemaToTsType.d.ts

@@ -1,2 +1,2 @@
-import { VovkJSONSchemaBase } from 'vovk';
+import type { VovkJSONSchemaBase } from 'vovk';
 export declare function schemaToTsType(jsonSchema: VovkJSONSchemaBase | boolean): string;

package/dist/tools/createToolFactory.js

@@ -9,6 +9,7 @@ export function createToolFactory({ toJSONSchema, }) {
             title,
             description,
             get parameters() {
+                // biome-ignore lint/suspicious/noAssignInExpressions: TODO
                 return (parameters ??= inputSchema ? toJSONSchema(inputSchema, { validationType: 'tool-input', target }) : {});
             },
             inputSchema: inputSchema,

package/dist/tools/deriveTools.d.ts

@@ -1,4 +1,4 @@
-import { DefaultModelOutput } from './toModelOutputDefault.js';
+import type { DefaultModelOutput } from './toModelOutputDefault.js';
 import type { VovkRequest } from '../types/request.js';
 import type { VovkToolDerived, ToModelOutputFn } from '../types/tools.js';
 type DerivedToolInput = {

package/dist/tools/deriveTools.js

@@ -111,8 +111,7 @@ const makeTool = ({ moduleName, handlerName, module, meta, toModelOutput, onExec
 };
 export function deriveTools(options) {
     const { modules, meta, toModelOutput = ToModelOutput.DEFAULT, onExecute = (result) => result, onError = () => { }, } = options;
-    const tools = Object.entries(modules ?? {})
-        .map(([moduleName, module]) => {
+    const tools = Object.entries(modules ?? {}).flatMap(([moduleName, module]) => {
         return Object.entries(module ?? {})
             .filter(([, handler]) => handler?.schema?.operationObject && !handler?.schema?.operationObject?.['x-tool']?.hidden)
             .map(([handlerName]) => makeTool({
@@ -124,8 +123,7 @@ export function deriveTools(options) {
             onExecute,
             onError,
         }));
-    })
-        .flat();
+    });
     const toolsByName = Object.fromEntries(tools.map((tool) => [tool.name, tool]));
     return {
         tools,

package/dist/types/client.d.ts

@@ -10,28 +10,27 @@ import type { BodyTypeFromContentType, ContentType, VovkValidateOnClient } from
 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?: {
         contentType: ContentType[];
     };
 }> = OmitNullable<(Parameters<T>[0] extends VovkRequest<infer TBody, infer TQuery, infer TParams> ? (T['__types'] extends {
     contentType: infer CT extends ContentType[];
-} ? unknown extends TBody ? Empty : {
+} ? unknown extends TBody ? unknown : {
     body: BodyTypeFromContentType<CT, TBody>;
 } : TBody extends Record<KnownAny, KnownAny> ? {
     body: TBody;
-} : Empty) & (TQuery extends Record<KnownAny, KnownAny> ? {
+} : unknown) & (TQuery extends Record<KnownAny, KnownAny> ? {
     query: TQuery;
-} : Empty) & (TParams extends Record<KnownAny, KnownAny> ? {
+} : unknown) & (TParams extends Record<KnownAny, KnownAny> ? {
     params: TParams;
-} : Empty) & {
+} : unknown) & {
     meta?: {
         [key: string]: KnownAny;
     };
-} : Empty) & (Parameters<T>[1] extends Record<KnownAny, KnownAny> ? {
+} : unknown) & (Parameters<T>[1] extends Record<KnownAny, KnownAny> ? {
     params: Parameters<T>[1];
-} : Empty)>;
+} : unknown)>;
 type ToPromise<T> = T extends PromiseLike<unknown> ? T : Promise<T>;
 export type VovkStreamAsyncIterable<T> = {
     status: number;
@@ -49,7 +48,7 @@ type ActualReturnType<T extends ControllerStaticMethod> = T extends {
 } ? R : ReturnType<T>;
 type StaticMethodReturn<T extends ControllerStaticMethod> = IsNextJs extends true ? ActualReturnType<T> extends NextResponse<infer U> | Promise<NextResponse<infer U>> ? U : ActualReturnType<T> extends Response | Promise<Response> ? Awaited<ActualReturnType<T>> : ActualReturnType<T> : ActualReturnType<T> extends Response | Promise<Response> ? Awaited<ActualReturnType<T>> : ActualReturnType<T>;
 type StaticMethodReturnPromise<T extends ControllerStaticMethod> = ToPromise<StaticMethodReturn<T>>;
-type StaticMethodOptions<T extends (req: VovkRequest<KnownAny, KnownAny, KnownAny>, params: KnownAny) => void | object | JSONLinesResponder<TStreamIteration> | Promise<JSONLinesResponder<TStreamIteration>>, TFetcherOptions extends Record<string, KnownAny>, TStreamIteration, R, F extends VovkFetcherOptions<KnownAny>> = Partial<TFetcherOptions & {
+type StaticMethodOptions<T extends (req: VovkRequest<KnownAny, KnownAny, KnownAny>, params: KnownAny) => undefined | object | JSONLinesResponder<TStreamIteration> | Promise<JSONLinesResponder<TStreamIteration>>, TFetcherOptions extends Record<string, KnownAny>, TStreamIteration, R, F extends VovkFetcherOptions<KnownAny>> = Partial<TFetcherOptions & {
     transform: (staticMethodReturn: T extends {
         __types: {
             iteration: infer U;
@@ -57,12 +56,12 @@ type StaticMethodOptions<T extends (req: VovkRequest<KnownAny, KnownAny, KnownAn
     } ? unknown extends U ? Awaited<StaticMethodReturn<T>> : VovkStreamAsyncIterable<U> : Awaited<StaticMethodReturn<T>> extends JSONLinesResponder<infer U> ? VovkStreamAsyncIterable<U> : Awaited<StaticMethodReturn<T>>, resp: Response) => R;
     fetcher: VovkFetcher<F>;
 }>;
-export type ClientMethodReturn<T extends (req: VovkRequest<KnownAny, KnownAny, KnownAny>, params: KnownAny) => void | object | JSONLinesResponder<TStreamIteration> | Promise<JSONLinesResponder<TStreamIteration>>, TStreamIteration, R> = R extends object ? Promise<Awaited<R>> : T extends {
+export type ClientMethodReturn<T extends (req: VovkRequest<KnownAny, KnownAny, KnownAny>, params: KnownAny) => undefined | object | JSONLinesResponder<TStreamIteration> | Promise<JSONLinesResponder<TStreamIteration>>, TStreamIteration, R> = R extends object ? Promise<Awaited<R>> : T extends {
     __types: {
         iteration: infer U;
     };
 } ? unknown extends U ? StaticMethodReturnPromise<T> : Promise<VovkStreamAsyncIterable<U>> : ActualReturnType<T> extends Promise<JSONLinesResponder<infer U>> | JSONLinesResponder<infer U> | Iterator<infer U> | AsyncIterator<infer U> ? Promise<VovkStreamAsyncIterable<U>> : StaticMethodReturnPromise<T>;
-export type ClientMethod<T extends ((req: VovkRequest<KnownAny, KnownAny, KnownAny>, params: KnownAny) => void | object | JSONLinesResponder<TStreamIteration> | Promise<JSONLinesResponder<TStreamIteration>>) & {
+export type ClientMethod<T extends ((req: VovkRequest<KnownAny, KnownAny, KnownAny>, params: KnownAny) => undefined | object | JSONLinesResponder<TStreamIteration> | Promise<JSONLinesResponder<TStreamIteration>>) & {
     __types?: {
         body: KnownAny;
         query: KnownAny;

package/dist/types/json-schema.d.ts

@@ -1,5 +1,5 @@
-import { KnownAny } from './utils.js';
-import { ContentType } from './validation.js';
+import type { KnownAny } from './utils.js';
+import type { ContentType } from './validation.js';
 type Type = 'object' | 'array' | 'string' | 'number' | 'boolean' | 'null' | 'integer';
 /**
  * Base JSON Schema type used in Vovk.ts for validation and code generation.

package/dist/utils/camelCase.js

@@ -1,5 +1,5 @@
 // Convert any value to string
-function toString(value) {
+function valToString(value) {
     return value == null ? '' : String(value);
 }
 // Regex to match words (including Unicode letters & digits)
@@ -18,7 +18,7 @@ function unicodeWords(str) {
  * @returns {string}
  */
 export function camelCase(input) {
-    const str = toString(input);
+    const str = valToString(input);
     // replace separators with space
     const sanitized = str.replace(/[\s_-]+/g, ' ').trim();
     const words = unicodeWords(sanitized);

package/dist/utils/deepExtend.d.ts

@@ -24,17 +24,18 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+import type { KnownAny } from '../types/utils.js';
 type DeepPartial<T> = {
     [P in keyof T]?: T[P] extends (infer U)[] ? DeepPartial<U>[] : T[P] extends object ? DeepPartial<T[P]> : T[P];
 };
 type SpecificValue = Buffer | Date | RegExp;
-declare function isSpecificValue(val: any): val is SpecificValue;
+declare function isSpecificValue(val: KnownAny): val is SpecificValue;
 declare function cloneSpecificValue(val: SpecificValue): SpecificValue;
 /**
  * Recursive cloning array.
  */
-declare function deepCloneArray<T = any>(arr: T[]): T[];
-declare function safeGetProperty<T extends object>(object: T, property: PropertyKey): any;
+declare function deepCloneArray<T = KnownAny>(arr: T[]): T[];
+declare function safeGetProperty<T extends object>(object: T, property: PropertyKey): KnownAny;
 /**
  * Extending object that entered in first argument.
  *
@@ -48,6 +49,6 @@ declare function deepExtend<T extends object>(...args: [T, ...Partial<T>[]]): T;
 declare function deepExtend<T extends object, U extends object>(target: T, source: U): T & U;
 declare function deepExtend<T extends object, U extends object, V extends object>(target: T, source1: U, source2: V): T & U & V;
 declare function deepExtend<T extends object, U extends object, V extends object, W extends object>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
-declare function deepExtend<T extends object>(target: T, ...sources: any[]): T;
+declare function deepExtend<T extends object>(target: T, ...sources: KnownAny[]): T;
 export { deepExtend, deepCloneArray, isSpecificValue, cloneSpecificValue, safeGetProperty };
 export type { DeepPartial, SpecificValue };

package/dist/utils/deepExtend.js

@@ -25,7 +25,6 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-'use strict';
 function isSpecificValue(val) {
     return val instanceof Buffer || val instanceof Date || val instanceof RegExp;
 }

package/package.json

@@ -7,7 +7,7 @@
   ],
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "version": "3.0.0",
+  "version": "3.0.3",
   "bin": {
     "vovk-cli-npx": "./bin/index.mjs"
   },
@@ -42,7 +42,7 @@
     "postbuild": "chmod +x ./bin/index.mjs",
     "build": "rm -f *.tsbuildinfo && tsc",
     "rm-dist": "rm -rf mjs cjs",
-    "lint": "eslint . --fix",
+    "lint": "biome check --fix",
     "tsc": "tsc --noEmit",
     "npm-publish": "if [ -z \"$NPM_TAG\" ]; then echo 'Error: NPM_TAG is not set'; exit 1; fi; npm publish --tag=$NPM_TAG",
     "ncu": "npm-check-updates -u"