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

package/mjs/createVovkApp.js

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

package/mjs/index.d.ts

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

package/mjs/index.js

@@ -0,0 +1,38 @@
+"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.vovkSchemaToOpenAPI = exports.openAPIToVovkSchema = exports.openapi = exports.progressive = exports.createCodeExamples = 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 index_1 = require("./client/index");
+Object.defineProperty(exports, "createRPC", { enumerable: true, get: function () { return index_1.createRPC; } });
+Object.defineProperty(exports, "fetcher", { enumerable: true, get: function () { return index_1.fetcher; } });
+Object.defineProperty(exports, "createFetcher", { enumerable: true, get: function () { return index_1.createFetcher; } });
+Object.defineProperty(exports, "progressive", { enumerable: true, get: function () { return index_1.progressive; } });
+const index_2 = require("./openapi/index");
+Object.defineProperty(exports, "openapi", { enumerable: true, get: function () { return index_2.openapi; } });
+Object.defineProperty(exports, "openAPIToVovkSchema", { enumerable: true, get: function () { return index_2.openAPIToVovkSchema; } });
+Object.defineProperty(exports, "vovkSchemaToOpenAPI", { enumerable: true, get: function () { return index_2.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 createCodeExamples_1 = require("./utils/createCodeExamples");
+Object.defineProperty(exports, "createCodeExamples", { enumerable: true, get: function () { return createCodeExamples_1.createCodeExamples; } });
+_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/mjs/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/mjs/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_REQUESTS]: '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,
+            openapi: {
+                ...handlerSchema?.openapi,
+                responses: {
+                    ...handlerSchema?.openapi?.responses,
+                    [status]: {
+                        description: `${status} ${statusDisplayText[status]}`,
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    allOf: [
+                                        {
+                                            $ref: '#/components/schemas/VovkErrorResponse',
+                                        },
+                                        {
+                                            type: 'object',
+                                            properties: {
+                                                message: {
+                                                    type: 'string',
+                                                    enum: [
+                                                        message,
+                                                        ...(handlerSchema?.openapi?.responses?.[status]?.content?.['application/json']?.schema
+                                                            ?.allOf?.[1]?.properties?.message?.enum ?? []),
+                                                    ],
+                                                },
+                                                statusCode: {
+                                                    type: 'integer',
+                                                    enum: [status],
+                                                },
+                                            },
+                                        },
+                                    ],
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+    };
+});

package/mjs/openapi/generateFnName.d.ts

@@ -0,0 +1,23 @@
+import { HttpMethod } from '../types';
+export interface VerbMapEntry {
+    noParams?: string;
+    withParams?: string;
+    default?: string;
+}
+export declare const VERB_MAP: Record<HttpMethod, VerbMapEntry>;
+export declare function capitalize(str: string): string;
+interface GenerateFnNameOptions {
+    /** Segments to strip out (e.g. ['api','v1']) */
+    ignoreSegments?: string[];
+}
+/**
+ * Turn an HTTP method + OpenAPI path into a camelCased function name.
+ *
+ * Examples:
+ *   generateFnName('GET', '/users')                     // "listUsers"
+ *   generateFnName('GET', '/users/{id}')                // "getUsersById"
+ *   generateFnName('POST', '/v1/api/orders')            // "createOrders"
+ *   generateFnName('PATCH', '/users/{userId}/profile')  // "patchUsersProfileByUserId"
+ */
+export declare function generateFnName(method: HttpMethod, rawPath: string, opts?: GenerateFnNameOptions): string;
+export {};

package/mjs/openapi/generateFnName.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERB_MAP = void 0;
+exports.capitalize = capitalize;
+exports.generateFnName = generateFnName;
+exports.VERB_MAP = {
+    GET: { noParams: 'list', withParams: 'get' },
+    POST: { default: 'create' },
+    PUT: { default: 'update' },
+    PATCH: { default: 'patch' },
+    DELETE: { default: 'delete' },
+    HEAD: { default: 'head' },
+    OPTIONS: { default: 'options' },
+};
+function capitalize(str) {
+    if (str.length === 0)
+        return '';
+    return str[0].toUpperCase() + str.slice(1);
+}
+const DEFAULT_OPTIONS = {
+    ignoreSegments: ['api'],
+};
+/**
+ * Turn an HTTP method + OpenAPI path into a camelCased function name.
+ *
+ * Examples:
+ *   generateFnName('GET', '/users')                     // "listUsers"
+ *   generateFnName('GET', '/users/{id}')                // "getUsersById"
+ *   generateFnName('POST', '/v1/api/orders')            // "createOrders"
+ *   generateFnName('PATCH', '/users/{userId}/profile')  // "patchUsersProfileByUserId"
+ */
+function generateFnName(method, rawPath, opts = {}) {
+    const { ignoreSegments } = {
+        ...DEFAULT_OPTIONS,
+        ...opts,
+    };
+    // 1. Clean & split path
+    const parts = rawPath
+        .replace(/^\/|\/$/g, '') // strip leading/trailing slash
+        .split('/')
+        .filter((seg) => !ignoreSegments?.includes(seg.toLowerCase()))
+        .filter(Boolean);
+    // 2. Separate resource tokens from path-params
+    const resources = [];
+    const params = [];
+    parts.forEach((seg) => {
+        const match = seg.match(/^{?([^}]+)}?$/);
+        if (match) {
+            params.push(match[1]);
+        }
+        else {
+            resources.push(seg);
+        }
+    });
+    // 3. Pick base verb from VERB_MAP
+    let baseVerb;
+    if (method === 'GET') {
+        baseVerb = params.length ? exports.VERB_MAP.GET.withParams : exports.VERB_MAP.GET.noParams;
+    }
+    else {
+        baseVerb = exports.VERB_MAP[method].default;
+    }
+    // 4. Build the “resource” part
+    const resourcePart = resources.map(capitalize).join('');
+    // 5. Build the “ByParam” suffix
+    const byParams = params.length ? 'By' + params.map(capitalize).join('') : '';
+    // 6. Combine and ensure camelCase
+    const rawName = `${baseVerb}${resourcePart}${byParams}`;
+    return rawName[0].toLowerCase() + rawName.slice(1);
+}
+/*
+// --- Example usage ---
+console.log(generateFnName('GET', '/users')); // listUsers
+console.log(generateFnName('GET', '/users/{id}')); // getUsersById
+console.log(generateFnName('POST', '/users')); // createUsers
+console.log(generateFnName('PATCH', '/users/{userId}/profile')); // patchUsersProfileByUserId
+console.log(generateFnName('DELETE', '/v1/api/orders/{orderId}')); // deleteOrdersByOrderId
+
+// You can also enable singularization:
+console.log(generateFnName('GET', '/users/{userId}/orders', { singularizeResources: true })); // getUserOrderByUserId
+*/

package/mjs/openapi/index.d.ts

@@ -0,0 +1,12 @@
+import type { OperationObject } from 'openapi3-ts/oas31';
+import { vovkSchemaToOpenAPI } from './vovkSchemaToOpenAPI';
+import { openAPIToVovkSchema } from './openAPIToVovkSchema';
+import type { KnownAny } from '../types';
+type OperationObjectWithCustomProperties = OperationObject & {
+    [key in `${'x' | 'X'}-${string}`]: KnownAny;
+};
+export declare const openapiDecorator: (openAPIOperationObject?: OperationObjectWithCustomProperties | undefined) => (target: KnownAny, propertyKey: string) => void;
+export declare const openapi: ((openAPIOperationObject?: OperationObjectWithCustomProperties | undefined) => (target: KnownAny, propertyKey: string) => void) & {
+    error: (status: import("../types").HttpStatus, message: string) => (target: KnownAny, propertyKey: string) => void;
+};
+export { vovkSchemaToOpenAPI, openAPIToVovkSchema };

package/mjs/openapi/index.js

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

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

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

package/mjs/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/mjs/openapi/openAPIToVovkSchema/index.d.ts

@@ -0,0 +1,4 @@
+import { type VovkSchema, VovkStrictConfig } from '../../types';
+export declare function openAPIToVovkSchema({ apiRoot, source: { object: openAPIObject }, getModuleName, getMethodName, errorMessageKey, package: packageJson, mixinName, }: VovkStrictConfig['openApiMixins'][string] & {
+    mixinName: string;
+}): VovkSchema;