vovk 3.0.0-draft.46 → 3.0.0-draft.460

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

@@ -1,61 +1,64 @@
+import type { NextRequest } from 'next/server';
 import { type KnownAny, type DecoratorOptions, type VovkRequest, type StaticClass } from './types';
 export declare function createVovkApp(): {
     get: {
-        (givenPath?: string | undefined, options?: DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
+        (givenPath?: string | undefined, options?: DecoratorOptions | undefined): (givenTarget: KnownAny, propertyKey: string) => void;
         auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
     };
     post: {
-        (givenPath?: string | undefined, options?: DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
+        (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: KnownAny, propertyKey: string) => void;
         auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
     };
     put: {
-        (givenPath?: string | undefined, options?: DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
+        (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: KnownAny, propertyKey: string) => void;
         auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
     };
     patch: {
-        (givenPath?: string | undefined, options?: DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
+        (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: KnownAny, propertyKey: string) => void;
         auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
     };
     del: {
-        (givenPath?: string | undefined, options?: DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
+        (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: KnownAny, propertyKey: string) => void;
         auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
     };
     head: {
-        (givenPath?: string | undefined, options?: DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
+        (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: KnownAny, propertyKey: string) => void;
         auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
     };
     options: {
-        (givenPath?: string | undefined, options?: DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
+        (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: KnownAny, propertyKey: string) => void;
         auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
     };
     prefix: (givenPath?: string) => (givenTarget: KnownAny) => any;
-    initVovk: (options: {
+    initSegment: (options: {
         segmentName?: string;
         controllers: Record<string, StaticClass>;
-        workers?: Record<string, StaticClass>;
         exposeValidation?: boolean;
         emitSchema?: boolean;
+        forceApiRoot?: string;
         onError?: (err: Error, req: VovkRequest) => void | Promise<void>;
+        onSuccess?: (resp: unknown, req: VovkRequest) => void | Promise<void>;
+        onBefore?: (req: VovkRequest) => void | Promise<void>;
     }) => {
-        GET: (req: VovkRequest, data: {
+        GET: (req: NextRequest, data: {
             params: Promise<Record<string, string[]>>;
         }) => Promise<Response>;
-        POST: (req: VovkRequest, data: {
+        POST: (req: NextRequest, data: {
             params: Promise<Record<string, string[]>>;
         }) => Promise<Response>;
-        PUT: (req: VovkRequest, data: {
+        PUT: (req: NextRequest, data: {
             params: Promise<Record<string, string[]>>;
         }) => Promise<Response>;
-        PATCH: (req: VovkRequest, data: {
+        PATCH: (req: NextRequest, data: {
             params: Promise<Record<string, string[]>>;
         }) => Promise<Response>;
-        DELETE: (req: VovkRequest, data: {
+        DELETE: (req: NextRequest, data: {
             params: Promise<Record<string, string[]>>;
         }) => Promise<Response>;
-        HEAD: (req: VovkRequest, data: {
+        HEAD: (req: NextRequest, data: {
             params: Promise<Record<string, string[]>>;
         }) => Promise<Response>;
-        OPTIONS: (req: VovkRequest, data: {
+        OPTIONS: (req: NextRequest, data: {
             params: Promise<Record<string, string[]>>;
         }) => Promise<Response>;
     };

package/cjs/createVovkApp.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVovkApp = createVovkApp;
+const VovkApp_1 = require("./VovkApp");
+const types_1 = require("./types");
+const getSchema_1 = __importDefault(require("./utils/getSchema"));
+const trimPath = (path) => path.trim().replace(/^\/|\/$/g, '');
+const isClass = (func) => typeof func === 'function' && /class/.test(func.toString());
+const toKebabCase = (str) => str
+    .replace(/([a-z0-9])([A-Z])/g, '$1-$2') // Add hyphen between lowercase/digit and uppercase
+    .replace(/([A-Z])([A-Z])(?=[a-z])/g, '$1-$2') // Add hyphen between uppercase letters if the second one is followed by a lowercase
+    .toLowerCase()
+    .replace(/^-/, ''); // Remove leading hyphen
+const assignSchema = ({ controller, propertyKey, path, options, httpMethod, vovkApp, }) => {
+    if (typeof window !== 'undefined') {
+        throw new Error('HTTP decorators can be used on server-side only. You have probably imported a controller on the client-side.');
+    }
+    if (!isClass(controller)) {
+        let decoratorName = httpMethod.toLowerCase();
+        if (decoratorName === 'delete')
+            decoratorName = 'del';
+        throw new Error(`Decorator must be used on a static class method. Check the controller method named "${propertyKey}" used with @${decoratorName}().`);
+    }
+    const methods = vovkApp.routes[httpMethod].get(controller) ?? {};
+    vovkApp.routes[httpMethod].set(controller, methods);
+    if (options?.cors) {
+        const optionsMethods = vovkApp.routes.OPTIONS.get(controller) ?? {};
+        optionsMethods[path] = (() => { });
+        optionsMethods[path]._options = options;
+        vovkApp.routes.OPTIONS.set(controller, optionsMethods);
+    }
+    const originalMethod = controller[propertyKey];
+    originalMethod._controller = controller;
+    originalMethod._sourceMethod = originalMethod._sourceMethod ?? originalMethod;
+    const schema = originalMethod._sourceMethod._getSchema?.(controller);
+    // TODO: Some of these assignments probably not needed anymore
+    originalMethod.schema = schema;
+    originalMethod.fn = originalMethod._sourceMethod?.fn;
+    originalMethod.models = originalMethod._sourceMethod?.models;
+    originalMethod._sourceMethod.wrapper = originalMethod;
+    controller._handlers = {
+        ...controller._handlers,
+        [propertyKey]: {
+            ...schema,
+            ...(controller._handlers ?? {})[propertyKey],
+            path,
+            httpMethod,
+        },
+    };
+    methods[path] = originalMethod;
+    methods[path]._options = options;
+    controller._handlersMetadata = {
+        ...controller._handlersMetadata,
+        [propertyKey]: {
+            ...(controller._handlersMetadata ?? {})[propertyKey],
+            staticParams: options?.staticParams,
+        },
+    };
+};
+function createVovkApp() {
+    const vovkApp = new VovkApp_1.VovkApp();
+    function createHTTPDecorator(httpMethod) {
+        function decoratorCreator(givenPath = '', options) {
+            const path = trimPath(givenPath);
+            function decorator(givenTarget, propertyKey) {
+                const controller = givenTarget;
+                assignSchema({ controller, propertyKey, path, options, httpMethod, vovkApp });
+            }
+            return decorator;
+        }
+        const auto = (options) => {
+            function decorator(givenTarget, propertyKey) {
+                const controller = givenTarget;
+                const methods = vovkApp.routes[httpMethod].get(controller) ?? {};
+                vovkApp.routes[httpMethod].set(controller, methods);
+                controller._handlers = {
+                    ...controller._handlers,
+                    [propertyKey]: {
+                        ...(controller._handlers ?? {})[propertyKey],
+                        httpMethod,
+                    },
+                };
+                const properties = Object.keys(controller._handlers[propertyKey]?.validation?.params?.properties ?? {});
+                const kebab = toKebabCase(propertyKey); // 🥙
+                const path = properties.length ? `${kebab}/${properties.map((prop) => `{${prop}}`).join('/')}` : kebab;
+                assignSchema({ controller, propertyKey, path, options, httpMethod, vovkApp });
+            }
+            return decorator;
+        };
+        const enhancedDecoratorCreator = decoratorCreator;
+        enhancedDecoratorCreator.auto = auto;
+        return enhancedDecoratorCreator;
+    }
+    const prefix = (givenPath = '') => {
+        const path = trimPath(givenPath);
+        return (givenTarget) => {
+            const controller = givenTarget;
+            controller._prefix = path;
+            return givenTarget;
+        };
+    };
+    const initSegment = (options) => {
+        options.segmentName = trimPath(options.segmentName ?? '');
+        for (const [rpcModuleName, controller] of Object.entries(options.controllers ?? {})) {
+            controller._rpcModuleName = rpcModuleName;
+            controller._onError = options?.onError;
+            controller._onSuccess = options?.onSuccess;
+            controller._onBefore = options?.onBefore;
+        }
+        async function GET_DEV(req, data) {
+            const params = await data.params;
+            if (params[Object.keys(params)[0]]?.[0] === '_schema_') {
+                const schema = await (0, getSchema_1.default)(options);
+                return vovkApp.respond({
+                    req: req,
+                    statusCode: 200,
+                    responseBody: { schema },
+                });
+            }
+            return vovkApp.GET(req, data);
+        }
+        return {
+            GET: process.env.NODE_ENV === 'development' ? GET_DEV : vovkApp.GET,
+            POST: vovkApp.POST,
+            PUT: vovkApp.PUT,
+            PATCH: vovkApp.PATCH,
+            DELETE: vovkApp.DELETE,
+            HEAD: vovkApp.HEAD,
+            OPTIONS: vovkApp.OPTIONS,
+        };
+    };
+    return {
+        get: createHTTPDecorator(types_1.HttpMethod.GET),
+        post: createHTTPDecorator(types_1.HttpMethod.POST),
+        put: createHTTPDecorator(types_1.HttpMethod.PUT),
+        patch: createHTTPDecorator(types_1.HttpMethod.PATCH),
+        del: createHTTPDecorator(types_1.HttpMethod.DELETE),
+        head: createHTTPDecorator(types_1.HttpMethod.HEAD),
+        options: createHTTPDecorator(types_1.HttpMethod.OPTIONS),
+        prefix,
+        initSegment,
+    };
+}

package/cjs/index.d.ts

@@ -0,0 +1,69 @@
+import { createVovkApp } from './createVovkApp';
+import { HttpStatus, HttpMethod, VovkSchemaIdEnum, type KnownAny, type VovkErrorResponse, type VovkRequest, type VovkBody, type VovkQuery, type VovkParams, type VovkReturnType, type VovkYieldType, type VovkOutput, type VovkIteration, type VovkMetaSchema, type VovkSegmentSchema, type VovkControllerSchema, type VovkHandlerSchema, type VovkSchema, type VovkConfig, type VovkGeneratorConfig, type VovkReadmeConfig, type VovkSamplesConfig, type VovkPackageJson, type VovkOpenAPIMixin, type VovkOpenAPIMixinNormalized, type VovkStrictConfig, type VovkValidationType, type VovkLLMTool, type VovkTypedMethod, type VovkBasicJSONSchema, type VovkOperationObject } from './types';
+import { type VovkRPCModule, type VovkFetcher, type VovkFetcherOptions, type VovkValidateOnClient, type VovkStreamAsyncIterable, createRPC, fetcher, createFetcher, progressive } from './client';
+import { operation, openAPIToVovkSchema, vovkSchemaToOpenAPI } from './openapi';
+import { HttpException } from './HttpException';
+import { createDecorator } from './utils/createDecorator';
+import { JSONLinesResponse } from './JSONLinesResponse';
+import { generateStaticAPI } from './utils/generateStaticAPI';
+import { withValidationLibrary } from './utils/withValidationLibrary';
+import { createStandardValidation } from './utils/createStandardValidation';
+import { multitenant } from './utils/multitenant';
+import { createLLMTools } from './utils/createLLMTools';
+import { createCodeSamples } from './utils/createCodeSamples';
+import { createValidateOnClient } from './utils/createValidateOnClient';
+import { resolveGeneratorConfigValues } from './utils/resolveGeneratorConfigValues';
+export { type KnownAny, type VovkRPCModule, type VovkFetcher, type VovkFetcherOptions, type VovkStreamAsyncIterable, type VovkValidateOnClient, type VovkSegmentSchema, type VovkErrorResponse, type VovkRequest, type VovkOutput, type VovkIteration, type VovkBody, type VovkQuery, type VovkParams, type VovkYieldType, type VovkReturnType, type VovkMetaSchema, type VovkControllerSchema, type VovkHandlerSchema, type VovkSchema, type VovkConfig, type VovkStrictConfig, type VovkGeneratorConfig, type VovkPackageJson, type VovkReadmeConfig, type VovkSamplesConfig, type VovkOpenAPIMixin, type VovkOpenAPIMixinNormalized, type VovkValidationType, type VovkLLMTool, type VovkTypedMethod, type VovkBasicJSONSchema, type VovkOperationObject, VovkSchemaIdEnum, JSONLinesResponse, HttpException, HttpStatus, HttpMethod, createVovkApp, createDecorator, createRPC, fetcher, createFetcher, generateStaticAPI, withValidationLibrary, createStandardValidation, multitenant, createLLMTools, createCodeSamples, createValidateOnClient, progressive, operation, openAPIToVovkSchema, vovkSchemaToOpenAPI, resolveGeneratorConfigValues, };
+export declare const get: {
+    (givenPath?: string | undefined, options?: import("./types").DecoratorOptions | undefined): (givenTarget: KnownAny, propertyKey: string) => void;
+    auto: (options?: import("./types").DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+}, post: {
+    (givenPath?: string | undefined, options?: Omit<import("./types").DecoratorOptions, "staticParams"> | undefined): (givenTarget: KnownAny, propertyKey: string) => void;
+    auto: (options?: import("./types").DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+}, put: {
+    (givenPath?: string | undefined, options?: Omit<import("./types").DecoratorOptions, "staticParams"> | undefined): (givenTarget: KnownAny, propertyKey: string) => void;
+    auto: (options?: import("./types").DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+}, patch: {
+    (givenPath?: string | undefined, options?: Omit<import("./types").DecoratorOptions, "staticParams"> | undefined): (givenTarget: KnownAny, propertyKey: string) => void;
+    auto: (options?: import("./types").DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+}, del: {
+    (givenPath?: string | undefined, options?: Omit<import("./types").DecoratorOptions, "staticParams"> | undefined): (givenTarget: KnownAny, propertyKey: string) => void;
+    auto: (options?: import("./types").DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+}, head: {
+    (givenPath?: string | undefined, options?: Omit<import("./types").DecoratorOptions, "staticParams"> | undefined): (givenTarget: KnownAny, propertyKey: string) => void;
+    auto: (options?: import("./types").DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+}, options: {
+    (givenPath?: string | undefined, options?: Omit<import("./types").DecoratorOptions, "staticParams"> | undefined): (givenTarget: KnownAny, propertyKey: string) => void;
+    auto: (options?: import("./types").DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+}, prefix: (givenPath?: string) => (givenTarget: KnownAny) => any, initSegment: (options: {
+    segmentName?: string;
+    controllers: Record<string, import("./types").StaticClass>;
+    exposeValidation?: boolean;
+    emitSchema?: boolean;
+    forceApiRoot?: string;
+    onError?: (err: Error, req: VovkRequest) => void | Promise<void>;
+    onSuccess?: (resp: unknown, req: VovkRequest) => void | Promise<void>;
+    onBefore?: (req: VovkRequest) => void | Promise<void>;
+}) => {
+    GET: (req: import("next/server").NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    POST: (req: import("next/server").NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    PUT: (req: import("next/server").NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    PATCH: (req: import("next/server").NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    DELETE: (req: import("next/server").NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    HEAD: (req: import("next/server").NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    OPTIONS: (req: import("next/server").NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+};

package/cjs/index.js

@@ -0,0 +1,42 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initSegment = exports.prefix = exports.options = exports.head = exports.del = exports.patch = exports.put = exports.post = exports.get = exports.resolveGeneratorConfigValues = exports.vovkSchemaToOpenAPI = exports.openAPIToVovkSchema = exports.operation = exports.progressive = exports.createValidateOnClient = exports.createCodeSamples = exports.createLLMTools = exports.multitenant = exports.createStandardValidation = exports.withValidationLibrary = exports.generateStaticAPI = exports.createFetcher = exports.fetcher = exports.createRPC = exports.createDecorator = exports.createVovkApp = exports.HttpMethod = exports.HttpStatus = exports.HttpException = exports.JSONLinesResponse = exports.VovkSchemaIdEnum = void 0;
+const createVovkApp_1 = require("./createVovkApp");
+Object.defineProperty(exports, "createVovkApp", { enumerable: true, get: function () { return createVovkApp_1.createVovkApp; } });
+const types_1 = require("./types");
+Object.defineProperty(exports, "HttpStatus", { enumerable: true, get: function () { return types_1.HttpStatus; } });
+Object.defineProperty(exports, "HttpMethod", { enumerable: true, get: function () { return types_1.HttpMethod; } });
+Object.defineProperty(exports, "VovkSchemaIdEnum", { enumerable: true, get: function () { return types_1.VovkSchemaIdEnum; } });
+const client_1 = require("./client");
+Object.defineProperty(exports, "createRPC", { enumerable: true, get: function () { return client_1.createRPC; } });
+Object.defineProperty(exports, "fetcher", { enumerable: true, get: function () { return client_1.fetcher; } });
+Object.defineProperty(exports, "createFetcher", { enumerable: true, get: function () { return client_1.createFetcher; } });
+Object.defineProperty(exports, "progressive", { enumerable: true, get: function () { return client_1.progressive; } });
+const openapi_1 = require("./openapi");
+Object.defineProperty(exports, "operation", { enumerable: true, get: function () { return openapi_1.operation; } });
+Object.defineProperty(exports, "openAPIToVovkSchema", { enumerable: true, get: function () { return openapi_1.openAPIToVovkSchema; } });
+Object.defineProperty(exports, "vovkSchemaToOpenAPI", { enumerable: true, get: function () { return openapi_1.vovkSchemaToOpenAPI; } });
+const HttpException_1 = require("./HttpException");
+Object.defineProperty(exports, "HttpException", { enumerable: true, get: function () { return HttpException_1.HttpException; } });
+const createDecorator_1 = require("./utils/createDecorator");
+Object.defineProperty(exports, "createDecorator", { enumerable: true, get: function () { return createDecorator_1.createDecorator; } });
+const JSONLinesResponse_1 = require("./JSONLinesResponse");
+Object.defineProperty(exports, "JSONLinesResponse", { enumerable: true, get: function () { return JSONLinesResponse_1.JSONLinesResponse; } });
+const generateStaticAPI_1 = require("./utils/generateStaticAPI");
+Object.defineProperty(exports, "generateStaticAPI", { enumerable: true, get: function () { return generateStaticAPI_1.generateStaticAPI; } });
+const withValidationLibrary_1 = require("./utils/withValidationLibrary");
+Object.defineProperty(exports, "withValidationLibrary", { enumerable: true, get: function () { return withValidationLibrary_1.withValidationLibrary; } });
+const createStandardValidation_1 = require("./utils/createStandardValidation");
+Object.defineProperty(exports, "createStandardValidation", { enumerable: true, get: function () { return createStandardValidation_1.createStandardValidation; } });
+const multitenant_1 = require("./utils/multitenant");
+Object.defineProperty(exports, "multitenant", { enumerable: true, get: function () { return multitenant_1.multitenant; } });
+const createLLMTools_1 = require("./utils/createLLMTools");
+Object.defineProperty(exports, "createLLMTools", { enumerable: true, get: function () { return createLLMTools_1.createLLMTools; } });
+const createCodeSamples_1 = require("./utils/createCodeSamples");
+Object.defineProperty(exports, "createCodeSamples", { enumerable: true, get: function () { return createCodeSamples_1.createCodeSamples; } });
+const createValidateOnClient_1 = require("./utils/createValidateOnClient");
+Object.defineProperty(exports, "createValidateOnClient", { enumerable: true, get: function () { return createValidateOnClient_1.createValidateOnClient; } });
+const resolveGeneratorConfigValues_1 = require("./utils/resolveGeneratorConfigValues");
+Object.defineProperty(exports, "resolveGeneratorConfigValues", { enumerable: true, get: function () { return resolveGeneratorConfigValues_1.resolveGeneratorConfigValues; } });
+_a = (0, createVovkApp_1.createVovkApp)(), exports.get = _a.get, exports.post = _a.post, exports.put = _a.put, exports.patch = _a.patch, exports.del = _a.del, exports.head = _a.head, exports.options = _a.options, exports.prefix = _a.prefix, exports.initSegment = _a.initSegment;

package/cjs/openapi/error.d.ts

@@ -0,0 +1,2 @@
+import { HttpStatus } from '../types';
+export declare const error: (status: HttpStatus, message: string) => (target: import("../types").KnownAny, propertyKey: string) => void;

package/cjs/openapi/error.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.error = void 0;
+const types_1 = require("../types");
+const createDecorator_1 = require("../utils/createDecorator");
+const statusDisplayText = {
+    [types_1.HttpStatus.NULL]: 'Error',
+    [types_1.HttpStatus.CONTINUE]: 'Continue',
+    [types_1.HttpStatus.SWITCHING_PROTOCOLS]: 'Switching Protocols',
+    [types_1.HttpStatus.PROCESSING]: 'Processing',
+    [types_1.HttpStatus.EARLYHINTS]: 'Early Hints',
+    [types_1.HttpStatus.OK]: 'OK',
+    [types_1.HttpStatus.CREATED]: 'Created',
+    [types_1.HttpStatus.ACCEPTED]: 'Accepted',
+    [types_1.HttpStatus.NON_AUTHORITATIVE_INFORMATION]: 'Non Authoritative Information',
+    [types_1.HttpStatus.NO_CONTENT]: 'No Content',
+    [types_1.HttpStatus.RESET_CONTENT]: 'Reset Content',
+    [types_1.HttpStatus.PARTIAL_CONTENT]: 'Partial Content',
+    [types_1.HttpStatus.AMBIGUOUS]: 'Ambiguous',
+    [types_1.HttpStatus.MOVED_PERMANENTLY]: 'Moved Permanently',
+    [types_1.HttpStatus.FOUND]: 'Found',
+    [types_1.HttpStatus.SEE_OTHER]: 'See Other',
+    [types_1.HttpStatus.NOT_MODIFIED]: 'Not Modified',
+    [types_1.HttpStatus.TEMPORARY_REDIRECT]: 'Temporary Redirect',
+    [types_1.HttpStatus.PERMANENT_REDIRECT]: 'Permanent Redirect',
+    [types_1.HttpStatus.BAD_REQUEST]: 'Bad Request',
+    [types_1.HttpStatus.UNAUTHORIZED]: 'Unauthorized',
+    [types_1.HttpStatus.PAYMENT_REQUIRED]: 'Payment Required',
+    [types_1.HttpStatus.FORBIDDEN]: 'Forbidden',
+    [types_1.HttpStatus.NOT_FOUND]: 'Not Found',
+    [types_1.HttpStatus.METHOD_NOT_ALLOWED]: 'Method Not Allowed',
+    [types_1.HttpStatus.NOT_ACCEPTABLE]: 'Not Acceptable',
+    [types_1.HttpStatus.PROXY_AUTHENTICATION_REQUIRED]: 'Proxy Authentication Required',
+    [types_1.HttpStatus.REQUEST_TIMEOUT]: 'Request Timeout',
+    [types_1.HttpStatus.CONFLICT]: 'Conflict',
+    [types_1.HttpStatus.GONE]: 'Gone',
+    [types_1.HttpStatus.LENGTH_REQUIRED]: 'Length Required',
+    [types_1.HttpStatus.PRECONDITION_FAILED]: 'Precondition Failed',
+    [types_1.HttpStatus.PAYLOAD_TOO_LARGE]: 'Payload Too Large',
+    [types_1.HttpStatus.URI_TOO_LONG]: 'URI Too Long',
+    [types_1.HttpStatus.UNSUPPORTED_MEDIA_TYPE]: 'Unsupported Media Type',
+    [types_1.HttpStatus.REQUESTED_RANGE_NOT_SATISFIABLE]: 'Requested Range Not Satisfiable',
+    [types_1.HttpStatus.EXPECTATION_FAILED]: 'Expectation Failed',
+    [types_1.HttpStatus.I_AM_A_TEAPOT]: 'I am a teapot',
+    [types_1.HttpStatus.MISDIRECTED]: 'Misdirected',
+    [types_1.HttpStatus.UNPROCESSABLE_ENTITY]: 'Unprocessable Entity',
+    [types_1.HttpStatus.FAILED_DEPENDENCY]: 'Failed Dependency',
+    [types_1.HttpStatus.PRECONDITION_REQUIRED]: 'Precondition Required',
+    [types_1.HttpStatus.TOO_MANY_TRequestS]: 'Too Many Requests',
+    [types_1.HttpStatus.INTERNAL_SERVER_ERROR]: 'Internal Server Error',
+    [types_1.HttpStatus.NOT_IMPLEMENTED]: 'Not Implemented',
+    [types_1.HttpStatus.BAD_GATEWAY]: 'Bad Gateway',
+    [types_1.HttpStatus.SERVICE_UNAVAILABLE]: 'Service Unavailable',
+    [types_1.HttpStatus.GATEWAY_TIMEOUT]: 'Gateway Timeout',
+    [types_1.HttpStatus.HTTP_VERSION_NOT_SUPPORTED]: 'HTTP Version Not Supported',
+};
+exports.error = (0, createDecorator_1.createDecorator)(null, (status, message) => {
+    return (handlerSchema) => {
+        return {
+            ...handlerSchema,
+            operationObject: {
+                ...handlerSchema?.operationObject,
+                responses: {
+                    ...handlerSchema?.operationObject?.responses,
+                    [status]: {
+                        description: `${status} ${statusDisplayText[status]}`,
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    allOf: [
+                                        {
+                                            $ref: '#/components/schemas/VovkErrorResponse',
+                                        },
+                                        {
+                                            type: 'object',
+                                            properties: {
+                                                message: {
+                                                    type: 'string',
+                                                    enum: [
+                                                        message,
+                                                        ...(handlerSchema?.operationObject?.responses?.[status]?.content?.['application/json']
+                                                            ?.schema?.allOf?.[1]?.properties?.message?.enum ?? []),
+                                                    ],
+                                                },
+                                                statusCode: {
+                                                    type: 'integer',
+                                                    enum: [status],
+                                                },
+                                            },
+                                        },
+                                    ],
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+    };
+});

package/cjs/openapi/index.d.ts

@@ -0,0 +1,8 @@
+import { vovkSchemaToOpenAPI } from './vovkSchemaToOpenAPI';
+import { openAPIToVovkSchema } from './openAPIToVovkSchema/index';
+import type { VovkOperationObject } from '../types';
+export declare const operationDecorator: (openAPIOperationObject?: VovkOperationObject | undefined) => (target: import("../types").KnownAny, propertyKey: string) => void;
+export declare const operation: ((openAPIOperationObject?: VovkOperationObject | undefined) => (target: import("../types").KnownAny, propertyKey: string) => void) & {
+    error: (status: import("../types").HttpStatus, message: string) => (target: import("../types").KnownAny, propertyKey: string) => void;
+};
+export { vovkSchemaToOpenAPI, openAPIToVovkSchema };

package/cjs/openapi/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openAPIToVovkSchema = exports.vovkSchemaToOpenAPI = exports.operation = exports.operationDecorator = void 0;
+const vovkSchemaToOpenAPI_1 = require("./vovkSchemaToOpenAPI");
+Object.defineProperty(exports, "vovkSchemaToOpenAPI", { enumerable: true, get: function () { return vovkSchemaToOpenAPI_1.vovkSchemaToOpenAPI; } });
+const index_1 = require("./openAPIToVovkSchema/index");
+Object.defineProperty(exports, "openAPIToVovkSchema", { enumerable: true, get: function () { return index_1.openAPIToVovkSchema; } });
+const error_1 = require("./error");
+const createDecorator_1 = require("../utils/createDecorator");
+exports.operationDecorator = (0, createDecorator_1.createDecorator)(null, (openAPIOperationObject = {}) => {
+    return (handlerSchema) => {
+        return {
+            ...handlerSchema,
+            operationObject: {
+                ...handlerSchema?.operationObject,
+                ...openAPIOperationObject,
+            },
+        };
+    };
+});
+exports.operation = Object.assign(exports.operationDecorator, { error: error_1.error });

package/cjs/openapi/openAPIToVovkSchema/applyComponentsSchemas.d.ts

@@ -0,0 +1,3 @@
+import { ComponentsObject } from 'openapi3-ts/oas31';
+import { VovkBasicJSONSchema } from '../../types';
+export declare function applyComponentsSchemas(schema: VovkBasicJSONSchema, components: ComponentsObject['schemas'], mixinName: string): VovkBasicJSONSchema | VovkBasicJSONSchema[];

package/cjs/openapi/openAPIToVovkSchema/applyComponentsSchemas.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyComponentsSchemas = applyComponentsSchemas;
+const camelCase_1 = require("../../utils/camelCase");
+const upperFirst_1 = require("../../utils/upperFirst");
+// fast clone JSON object while ignoring Date, RegExp, and Function types
+function cloneJSON(obj) {
+    if (obj === null || typeof obj !== 'object')
+        return obj;
+    if (Array.isArray(obj))
+        return obj.map(cloneJSON);
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (value instanceof Date || value instanceof RegExp || typeof value === 'function')
+            continue;
+        result[key] = cloneJSON(value);
+    }
+    return result;
+}
+function applyComponentsSchemas(schema, components, mixinName) {
+    const key = 'components/schemas';
+    if (!components || !Object.keys(components).length)
+        return schema;
+    // Create a deep copy of the schema
+    const result = cloneJSON(schema);
+    // Initialize $defs if it doesn't exist
+    result.$defs = result.$defs || {};
+    // Set to track components we've added to $defs
+    const addedComponents = new Set();
+    // Process a schema object and replace $refs
+    function processSchema(obj) {
+        if (!obj || typeof obj !== 'object')
+            return obj;
+        // Handle arrays first - they don't have $ref
+        if (Array.isArray(obj)) {
+            return obj.map((item) => processSchema(item));
+        }
+        // Now we know it's an object, so we can safely access $ref
+        const newObj = { ...obj };
+        const $ref = newObj.$ref;
+        if ($ref && typeof $ref === 'string' && $ref.startsWith(`#/${key}/`)) {
+            const componentName = $ref.replace(`#/${key}/`, '');
+            if (components[componentName]) {
+                newObj.$ref = `#/$defs/${componentName}`;
+                newObj['x-tsType'] ??= `Mixins.${(0, upperFirst_1.upperFirst)((0, camelCase_1.camelCase)(mixinName))}.${(0, upperFirst_1.upperFirst)((0, camelCase_1.camelCase)(componentName))}`;
+            }
+            else {
+                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]) {
+                addedComponents.add(componentName);
+                // TODO: Optimize
+                result.$defs[componentName] = processSchema(cloneJSON(components[componentName]));
+            }
+        }
+        // Process properties recursively
+        for (const key in newObj) {
+            if (Object.prototype.hasOwnProperty.call(newObj, key)) {
+                newObj[key] = processSchema(newObj[key]);
+            }
+        }
+        return newObj;
+    }
+    // Process the main schema
+    return processSchema(result);
+}

package/cjs/openapi/openAPIToVovkSchema/index.d.ts

@@ -0,0 +1,4 @@
+import { VovkOpenAPIMixinNormalized, type VovkSchema } from '../../types';
+export declare function openAPIToVovkSchema({ apiRoot, source: { object: openAPIObject }, getModuleName, getMethodName, errorMessageKey, segmentName, }: VovkOpenAPIMixinNormalized & {
+    segmentName?: string;
+}): VovkSchema;