vovk 3.0.0-draft.87 → 3.0.0-draft.91

package/dist/StreamJSONResponse.js

@@ -4,7 +4,7 @@ exports.StreamJSONResponse = void 0;
 require("./utils/shim");
 class StreamJSONResponse extends Response {
     static defaultHeaders = {
-        'content-type': 'text/plain; format=jsonlines',
+        'content-type': 'text/plain; x-format=jsonlines',
     };
     isClosed = false;
     controller;

package/dist/VovkApp.js

@@ -16,9 +16,9 @@ class VovkApp {
         if (!options)
             return {};
         const corsHeaders = {
-            'Access-Control-Allow-Origin': '*',
-            'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS, HEAD',
-            'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+            'access-control-allow-origin': '*',
+            'access-control-allow-methods': 'GET, POST, PUT, DELETE, OPTIONS, HEAD',
+            'access-control-allow-headers': 'content-type, authorization',
         };
         const headers = {
             ...(options.cors ? corsHeaders : {}),
@@ -46,7 +46,7 @@ class VovkApp {
         return new Response(JSON.stringify(body), {
             status,
             headers: {
-                'Content-Type': 'application/json',
+                'content-type': 'application/json',
                 ..._a.getHeadersFromOptions(options),
             },
         });
@@ -59,10 +59,57 @@ class VovkApp {
             isError: true,
         }, options);
     };
+    #getHandler = ({ handlers, path, params, }) => {
+        const methodParams = {};
+        if (Object.keys(params).length === 0) {
+            return { handler: handlers[''], methodParams };
+        }
+        const allMethodKeys = Object.keys(handlers);
+        let methodKeys = [];
+        const pathStr = path.join('/');
+        methodKeys = allMethodKeys
+            // First, try to match literal routes exactly.
+            .filter((p) => {
+            if (p.includes(':'))
+                return false; // Skip parameterized paths
+            return p === pathStr;
+        });
+        if (!methodKeys.length) {
+            methodKeys = allMethodKeys.filter((p) => {
+                const routeSegments = p.split('/');
+                if (routeSegments.length !== path.length)
+                    return false;
+                for (let i = 0; i < routeSegments.length; i++) {
+                    const routeSegment = routeSegments[i];
+                    const pathSegment = path[i];
+                    if (routeSegment.startsWith(':')) {
+                        const parameter = routeSegment.slice(1);
+                        if (parameter in methodParams) {
+                            throw new HttpException_1.HttpException(types_1.HttpStatus.INTERNAL_SERVER_ERROR, `Duplicate parameter "${parameter}" at ${p}`);
+                        }
+                        // If it's a parameterized segment, capture the parameter value.
+                        methodParams[parameter] = pathSegment;
+                    }
+                    else if (routeSegment !== pathSegment) {
+                        // If it's a literal segment and it does not match the corresponding path segment, return false.
+                        return false;
+                    }
+                }
+                return true;
+            });
+        }
+        if (methodKeys.length > 1) {
+            throw new HttpException_1.HttpException(types_1.HttpStatus.INTERNAL_SERVER_ERROR, `Conflicting routes found: ${methodKeys.join(', ')}`);
+        }
+        const [methodKey] = methodKeys;
+        if (methodKey) {
+            return { handler: handlers[methodKey], methodParams };
+        }
+        return { handler: null, methodParams };
+    };
     #callMethod = async (httpMethod, nextReq, params) => {
         const req = nextReq;
         const controllers = this.routes[httpMethod];
-        const methodParams = {};
         const path = params[Object.keys(params)[0]];
         const handlers = {};
         controllers.forEach((staticMethods, controller) => {
@@ -75,54 +122,7 @@ class VovkApp {
                 handlers[fullPath] = { staticMethod, controller };
             });
         });
-        const getHandler = () => {
-            if (Object.keys(params).length === 0) {
-                return handlers[''];
-            }
-            const allMethodKeys = Object.keys(handlers);
-            let methodKeys = [];
-            const pathStr = path.join('/');
-            methodKeys = allMethodKeys
-                // First, try to match literal routes exactly.
-                .filter((p) => {
-                if (p.includes(':'))
-                    return false; // Skip parameterized paths
-                return p === pathStr;
-            });
-            if (!methodKeys.length) {
-                methodKeys = allMethodKeys.filter((p) => {
-                    const routeSegments = p.split('/');
-                    if (routeSegments.length !== path.length)
-                        return false;
-                    for (let i = 0; i < routeSegments.length; i++) {
-                        const routeSegment = routeSegments[i];
-                        const pathSegment = path[i];
-                        if (routeSegment.startsWith(':')) {
-                            const parameter = routeSegment.slice(1);
-                            if (parameter in methodParams) {
-                                throw new HttpException_1.HttpException(types_1.HttpStatus.INTERNAL_SERVER_ERROR, `Duplicate parameter "${parameter}"`);
-                            }
-                            // If it's a parameterized segment, capture the parameter value.
-                            methodParams[parameter] = pathSegment;
-                        }
-                        else if (routeSegment !== pathSegment) {
-                            // If it's a literal segment and it does not match the corresponding path segment, return false.
-                            return false;
-                        }
-                    }
-                    return true;
-                });
-            }
-            if (methodKeys.length > 1) {
-                throw new HttpException_1.HttpException(types_1.HttpStatus.INTERNAL_SERVER_ERROR, `Conflicting routes found: ${methodKeys.join(', ')}`);
-            }
-            const [methodKey] = methodKeys;
-            if (methodKey) {
-                return handlers[methodKey];
-            }
-            return null;
-        };
-        const handler = getHandler();
+        const { handler, methodParams } = this.#getHandler({ handlers, path, params });
         if (!handler) {
             return this.#respondWithError(types_1.HttpStatus.NOT_FOUND, `Route ${path.join('/')} is not found`);
         }

package/dist/client/createRPC.d.ts

@@ -1,4 +1,4 @@
-import { type VovkControllerSchema, type KnownAny } from '../types';
-import { type VovkClientOptions, type VovkClient, type VovkDefaultFetcherOptions } from './types';
-declare const createRPC: <T, OPTS extends Record<string, KnownAny> = VovkDefaultFetcherOptions>(controllerSchema: VovkControllerSchema, segmentName?: string, options?: VovkClientOptions<OPTS>) => VovkClient<T, OPTS>;
+import type { KnownAny, VovkFullSchema } from '../types';
+import type { VovkClientOptions, VovkClient, VovkDefaultFetcherOptions } from './types';
+declare const createRPC: <T, OPTS extends Record<string, KnownAny> = VovkDefaultFetcherOptions>(fullSchema: VovkFullSchema, segmentName: string, controllerName: string, options?: VovkClientOptions<OPTS>) => VovkClient<T, OPTS>;
 export default createRPC;

package/dist/client/createRPC.js

@@ -10,22 +10,23 @@ const serializeQuery_1 = __importDefault(require("../utils/serializeQuery"));
 const trimPath = (path) => path.trim().replace(/^\/|\/$/g, '');
 const getHandlerPath = (endpoint, params, query) => {
     let result = endpoint;
+    const queryStr = query ? (0, serializeQuery_1.default)(query) : null;
     for (const [key, value] of Object.entries(params ?? {})) {
         result = result.replace(`:${key}`, value);
     }
-    const queryStr = query ? (0, serializeQuery_1.default)(query) : null;
     return `${result}${queryStr ? '?' : ''}${queryStr}`;
 };
-const createRPC = (controllerSchema, segmentName, options) => {
-    const schema = controllerSchema;
+const createRPC = (fullSchema, segmentName, controllerName, options) => {
+    const segmentSchema = fullSchema.segments[segmentName];
+    if (!segmentSchema)
+        throw new Error(`Unable to create RPC object. Segment schema is missing. Check client template.`);
+    const controllerSchema = fullSchema.segments[segmentName]?.controllers[controllerName];
     const client = {};
-    if (!schema)
-        throw new Error(`Unable to clientize. Controller schema is not provided`);
-    if (!schema.handlers)
-        throw new Error(`Unable to clientize. No schema for controller ${String(schema?.controllerName)} provided`);
-    const controllerPrefix = trimPath(schema.prefix ?? '');
+    if (!controllerSchema)
+        throw new Error(`Unable to create RPC object. Controller schema is missing. Check client template.`);
+    const controllerPrefix = trimPath(controllerSchema.prefix ?? '');
     const { fetcher: settingsFetcher = defaultFetcher_1.default } = options ?? {};
-    for (const [staticMethodName, handlerSchema] of Object.entries(schema.handlers)) {
+    for (const [staticMethodName, handlerSchema] of Object.entries(controllerSchema.handlers)) {
         const { path, httpMethod, validation } = handlerSchema;
         const getEndpoint = ({ apiRoot, params, query, }) => {
             const mainPrefix = (apiRoot.startsWith('http://') || apiRoot.startsWith('https://') || apiRoot.startsWith('/') ? '' : '/') +
@@ -36,7 +37,13 @@ const createRPC = (controllerSchema, segmentName, options) => {
         const handler = (input = {}) => {
             const fetcher = input.fetcher ?? settingsFetcher;
             const validate = async ({ body, query, params, endpoint, }) => {
-                await (input.validateOnClient ?? options?.validateOnClient)?.({ body, query, params, endpoint }, validation ?? {});
+                const validateOnClient = input.validateOnClient ?? options?.validateOnClient;
+                if (validateOnClient) {
+                    if (typeof validateOnClient !== 'function') {
+                        throw new Error('validateOnClient must be a function');
+                    }
+                    await validateOnClient({ body, query, params, endpoint }, validation ?? {});
+                }
             };
             const internalOptions = {
                 name: staticMethodName,
@@ -66,7 +73,9 @@ const createRPC = (controllerSchema, segmentName, options) => {
             return input.transform ? fetcherPromise.then(input.transform) : fetcherPromise;
         };
         handler.schema = handlerSchema;
-        handler.controllerSchema = schema;
+        handler.controllerSchema = controllerSchema;
+        handler.segmentSchema = segmentSchema;
+        handler.fullSchema = fullSchema;
         // @ts-expect-error TODO
         client[staticMethodName] = handler;
     }

package/dist/client/defaultFetcher.js

@@ -52,7 +52,7 @@ const defaultFetcher = async ({ httpMethod, getEndpoint, validate, defaultHandle
     if (contentType?.startsWith('application/json')) {
         return defaultHandler(response);
     }
-    if (contentType === 'text/plain; format=jsonlines') {
+    if (contentType?.startsWith('text/plain') && contentType.includes('x-format=jsonlines')) {
         return defaultStreamHandler(response);
     }
     return response;

package/dist/client/types.d.ts

@@ -1,4 +1,4 @@
-import type { KnownAny, HttpMethod, ControllerStaticMethod, VovkControllerBody, VovkControllerQuery, VovkControllerParams, VovkHandlerSchema, VovkControllerSchema } from '../types';
+import type { KnownAny, HttpMethod, ControllerStaticMethod, VovkControllerBody, VovkControllerQuery, VovkControllerParams, VovkHandlerSchema, VovkControllerSchema, VovkSegmentSchema, VovkFullSchema } from '../types';
 import type { StreamJSONResponse } from '../StreamJSONResponse';
 import type { NextResponse } from 'next/server';
 export type StaticMethodInput<T extends ControllerStaticMethod> = (VovkControllerBody<T> extends undefined | void ? {
@@ -37,6 +37,8 @@ type ClientMethod<T extends (...args: KnownAny[]) => void | object | StreamJSONR
 }> | void)) => ReturnType<T> extends Promise<StreamJSONResponse<infer U>> | StreamJSONResponse<infer U> | Iterator<infer U> | AsyncIterator<infer U> ? Promise<VovkStreamAsyncIterable<U>> : R extends object ? Promise<R> : StaticMethodReturnPromise<T>) & {
     schema: VovkHandlerSchema;
     controllerSchema: VovkControllerSchema;
+    segmentSchema: VovkSegmentSchema;
+    fullSchema: VovkFullSchema;
 };
 type OmitNever<T> = {
     [K in keyof T as T[K] extends never ? never : K]: T[K];

package/dist/createVovkApp.js

@@ -13,42 +13,42 @@ const toKebabCase = (str) => str
     .replace(/([A-Z])/g, '-$1')
     .toLowerCase()
     .replace(/^-/, '');
+const assignSchema = ({ controller, propertyKey, path, options, httpMethod, vovkApp, }) => {
+    if (typeof window !== 'undefined') {
+        throw new Error('Decorators are intended for server-side use only. You have probably imported a controller on the client-side.');
+    }
+    if (!isClass(controller)) {
+        let decoratorName = httpMethod.toLowerCase();
+        if (decoratorName === 'delete')
+            decoratorName = 'del';
+        throw new Error(`Decorator must be used on a static class method. Check the controller method named "${propertyKey}" used with @${decoratorName}().`);
+    }
+    const methods = vovkApp.routes[httpMethod].get(controller) ?? {};
+    vovkApp.routes[httpMethod].set(controller, methods);
+    const originalMethod = controller[propertyKey];
+    originalMethod._controller = controller;
+    originalMethod._sourceMethod = originalMethod._sourceMethod ?? originalMethod;
+    const validation = originalMethod._sourceMethod._getValidation?.(controller);
+    controller._handlers = {
+        ...controller._handlers,
+        [propertyKey]: {
+            ...(validation ? { validation } : {}),
+            ...(controller._handlers ?? {})[propertyKey],
+            path,
+            httpMethod,
+        },
+    };
+    methods[path] = controller[propertyKey];
+    methods[path]._options = options;
+};
 function createVovkApp() {
     const vovkApp = new VovkApp_1.VovkApp();
     const createHTTPDecorator = (httpMethod) => {
-        const assignSchema = (controller, propertyKey, path, options) => {
-            if (typeof window !== 'undefined') {
-                throw new Error('Decorators are intended for server-side use only. You have probably imported a controller on the client-side.');
-            }
-            if (!isClass(controller)) {
-                let decoratorName = httpMethod.toLowerCase();
-                if (decoratorName === 'delete')
-                    decoratorName = 'del';
-                throw new Error(`Decorator must be used on a static class method. Check the controller method named "${propertyKey}" used with @${decoratorName}.`);
-            }
-            const methods = vovkApp.routes[httpMethod].get(controller) ?? {};
-            vovkApp.routes[httpMethod].set(controller, methods);
-            const originalMethod = controller[propertyKey];
-            originalMethod._controller = controller;
-            originalMethod._sourceMethod = originalMethod._sourceMethod ?? originalMethod;
-            const validation = originalMethod._sourceMethod._getValidation?.(controller);
-            controller._handlers = {
-                ...controller._handlers,
-                [propertyKey]: {
-                    ...(validation ? { validation } : {}),
-                    ...(controller._handlers ?? {})[propertyKey],
-                    path,
-                    httpMethod,
-                },
-            };
-            methods[path] = controller[propertyKey];
-            methods[path]._options = options;
-        };
         function decoratorCreator(givenPath = '', options) {
             const path = trimPath(givenPath);
             function decorator(givenTarget, propertyKey) {
-                const target = givenTarget;
-                assignSchema(target, propertyKey, path, options);
+                const controller = givenTarget;
+                assignSchema({ controller, propertyKey, path, options, httpMethod, vovkApp });
             }
             return decorator;
         }
@@ -64,7 +64,7 @@ function createVovkApp() {
                         httpMethod,
                     },
                 };
-                assignSchema(controller, propertyKey, toKebabCase(propertyKey), options);
+                assignSchema({ controller, propertyKey, path: toKebabCase(propertyKey), options, httpMethod, vovkApp });
             }
             return decorator;
         };

package/dist/index.d.ts

@@ -1,12 +1,12 @@
 import { createVovkApp } from './createVovkApp';
-import { HttpStatus as HttpStatus, HttpMethod as HttpMethod, type KnownAny, type VovkErrorResponse, type VovkRequest, type VovkBody, type VovkQuery, type VovkParams, type VovkReturnType, type VovkYieldType, type VovkControllerBody, type VovkControllerQuery, type VovkControllerParams, type VovkControllerYieldType, type VovkSchema, type VovkControllerSchema, type VovkHandlerSchema } from './types';
+import { HttpStatus as HttpStatus, HttpMethod as HttpMethod, type KnownAny, type VovkErrorResponse, type VovkRequest, type VovkBody, type VovkQuery, type VovkParams, type VovkReturnType, type VovkYieldType, type VovkControllerBody, type VovkControllerQuery, type VovkControllerParams, type VovkControllerYieldType, type VovkControllerOutput, type VovkSegmentSchema, type VovkControllerSchema, type VovkHandlerSchema, type VovkFullSchema, type VovkConfig, type VovkStrictConfig, type VovkEnv } from './types';
 import { type VovkClient, type VovkClientOptions, type VovkClientFetcher, type VovkDefaultFetcherOptions, type VovkValidateOnClient, type VovkStreamAsyncIterable, createRPC } from './client';
 import { HttpException } from './HttpException';
 import { createDecorator } from './createDecorator';
 import { StreamJSONResponse } from './StreamJSONResponse';
 import { generateStaticAPI } from './utils/generateStaticAPI';
 import { setHandlerValidation } from './utils/setHandlerValidation';
-export { type KnownAny, type VovkClient, type VovkClientFetcher, type VovkDefaultFetcherOptions, type VovkStreamAsyncIterable, type VovkValidateOnClient, type VovkSchema, type VovkErrorResponse, type VovkRequest, type VovkControllerBody, type VovkControllerQuery, type VovkControllerParams, type VovkControllerYieldType, type VovkBody, type VovkQuery, type VovkParams, type VovkYieldType, type VovkReturnType, type VovkClientOptions, type VovkControllerSchema, type VovkHandlerSchema, StreamJSONResponse, HttpException, HttpStatus, HttpMethod, createVovkApp, createDecorator, createRPC, generateStaticAPI, setHandlerValidation, };
+export { type KnownAny, type VovkClient, type VovkClientFetcher, type VovkDefaultFetcherOptions, type VovkStreamAsyncIterable, type VovkValidateOnClient, type VovkSegmentSchema, type VovkErrorResponse, type VovkRequest, type VovkControllerBody, type VovkControllerQuery, type VovkControllerParams, type VovkControllerYieldType, type VovkControllerOutput, type VovkBody, type VovkQuery, type VovkParams, type VovkYieldType, type VovkReturnType, type VovkClientOptions, type VovkControllerSchema, type VovkHandlerSchema, type VovkFullSchema, type VovkConfig, type VovkStrictConfig, type VovkEnv, StreamJSONResponse, HttpException, HttpStatus, HttpMethod, createVovkApp, createDecorator, createRPC, generateStaticAPI, setHandlerValidation, };
 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;

package/dist/types.d.ts

@@ -22,7 +22,7 @@ export type VovkControllerSchema = {
     prefix?: string;
     handlers: Record<string, VovkHandlerSchema>;
 };
-export type VovkSchema = {
+export type VovkSegmentSchema = {
     emitSchema: boolean;
     segmentName: string;
     controllers: Record<string, VovkControllerSchema>;
@@ -79,6 +79,9 @@ export type VovkControllerBody<T extends (...args: KnownAny) => KnownAny> = Awai
 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<StreamJSONResponse<infer Y>> | StreamJSONResponse<infer Y> ? Y : never;
+export type VovkControllerOutput<T extends ((...args: KnownAny) => KnownAny) & {
+    __output?: KnownAny;
+}> = T['__output'];
 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'];
@@ -88,6 +91,65 @@ export type StreamAbortMessage = {
     isError: true;
     reason: KnownAny;
 };
+type LogLevelNames = 'trace' | 'debug' | 'info' | 'warn' | 'error';
+export type VovkEnv = {
+    PORT?: string;
+    VOVK_CLIENT_OUT_DIR?: string;
+    VOVK_SCHEMA_OUT_DIR?: string;
+    VOVK_FETCHER_PATH?: string;
+    VOVK_VALIDATE_ON_CLIENT_PATH?: string;
+    VOVK_CREATE_RPC_PATH?: string;
+    VOVK_MODULES_DIR?: string;
+    VOVK_ORIGIN?: string;
+    VOVK_ROOT_ENTRY?: string;
+    VOVK_API_ENTRY_POINT?: string;
+    VOVK_ROOT_SEGMENT_MODULES_DIR_NAME?: string;
+    VOVK_LOG_LEVEL?: LogLevelNames;
+    VOVK_PRETTIFY_CLIENT?: string;
+    VOVK_DEV_HTTPS?: string;
+    __VOVK_START_WATCHER_IN_STANDALONE_MODE__?: 'true';
+    __VOVK_EXIT__?: 'true' | 'false';
+};
+type GenerateFrom = (string | {
+    templatePath: string;
+    outDir?: string;
+    templateName?: string;
+    fullSchema?: string | boolean;
+})[];
+export type VovkConfig = {
+    emitConfig?: boolean | (keyof VovkStrictConfig)[];
+    clientOutDir?: string;
+    schemaOutDir?: string;
+    fetcherImport?: string | string[];
+    validateOnClientImport?: string | string[] | null;
+    createRPCImport?: string | string[];
+    modulesDir?: string;
+    rootEntry?: string;
+    origin?: string;
+    rootSegmentModulesDirName?: string;
+    logLevel?: LogLevelNames;
+    prettifyClient?: boolean;
+    devHttps?: boolean;
+    generateFrom?: GenerateFrom | ((value: GenerateFrom) => GenerateFrom);
+    templates?: {
+        service?: string;
+        controller?: string;
+        [key: string]: string | undefined;
+    };
+    custom?: Record<string, KnownAny>;
+};
+export type VovkStrictConfig = Required<Omit<VovkConfig, 'emitConfig' | 'validateOnClientImport' | 'fetcherImport' | 'createRPCImport' | 'generateFrom' | 'custom'>> & {
+    emitConfig: (keyof VovkStrictConfig)[];
+    validateOnClientImport: string[] | null;
+    fetcherImport: string[];
+    createRPCImport: string[];
+    generateFrom: GenerateFrom;
+    custom: Record<string, KnownAny>;
+};
+export type VovkFullSchema = {
+    config: Partial<VovkStrictConfig>;
+    segments: Record<string, VovkSegmentSchema>;
+};
 export declare enum HttpMethod {
     GET = "GET",
     POST = "POST",
@@ -148,3 +210,4 @@ export declare enum HttpStatus {
     GATEWAY_TIMEOUT = 504,
     HTTP_VERSION_NOT_SUPPORTED = 505
 }
+export {};

package/dist/types.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpStatus = exports.HttpMethod = void 0;
+// Enums
 var HttpMethod;
 (function (HttpMethod) {
     HttpMethod["GET"] = "GET";

package/dist/utils/getSchema.d.ts

@@ -1,4 +1,4 @@
-import type { VovkSchema, VovkController, StaticClass } from '../types';
+import type { VovkSegmentSchema, VovkController, StaticClass } from '../types';
 export declare function getControllerSchema(controller: VovkController, controllerName: string, exposeValidation: boolean): {
     controllerName: string;
     originalControllerName: string;
@@ -17,4 +17,4 @@ export default function getSchema(options: {
     segmentName?: string;
     controllers: Record<string, StaticClass>;
     exposeValidation?: boolean;
-}): VovkSchema;
+}): VovkSegmentSchema;

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "vovk",
-  "version": "3.0.0-draft.87",
+  "version": "3.0.0-draft.91",
   "main": "dist/index.js",
+  "module": "dist/index.js",
   "description": "RESTful RPC for Next.js - Transforms Next.js into a powerful REST API platform with RPC capabilities.",
   "repository": {
     "type": "git",
@@ -27,5 +28,8 @@
   "homepage": "https://vovk.dev",
   "peerDependencies": {
     "next": "*"
+  },
+  "optionalDependencies": {
+    "openapi3-ts": "*"
   }
 }