vovk 3.0.0-draft.99 → 3.0.2

package/dist/core/vovkApp.js

@@ -0,0 +1,318 @@
+var _a;
+import { HttpException } from './HttpException.js';
+import { JSONLinesResponder, Responder } from './JSONLinesResponder.js';
+import { reqQuery } from '../req/reqQuery.js';
+import { reqMeta } from '../req/reqMeta.js';
+import { HttpMethod, HttpStatus } from '../types/enums.js';
+import { parseBody } from '../req/parseBody.js';
+class VovkApp {
+    static getHeadersFromDecoratorOptions(options) {
+        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',
+        };
+        const headers = {
+            ...(options.cors ? corsHeaders : {}),
+            ...(options.headers ?? {}),
+        };
+        return headers;
+    }
+    routes = {
+        GET: new Map(),
+        POST: new Map(),
+        PUT: new Map(),
+        PATCH: new Map(),
+        DELETE: new Map(),
+        HEAD: new Map(),
+        OPTIONS: new Map(),
+    };
+    GET = async (req, data, segmentName) => this.#callMethod({ httpMethod: HttpMethod.GET, req, params: await data.params, segmentName });
+    POST = async (req, data, segmentName) => this.#callMethod({ httpMethod: HttpMethod.POST, req, params: await data.params, segmentName });
+    PUT = async (req, data, segmentName) => this.#callMethod({ httpMethod: HttpMethod.PUT, req, params: await data.params, segmentName });
+    PATCH = async (req, data, segmentName) => this.#callMethod({ httpMethod: HttpMethod.PATCH, req, params: await data.params, segmentName });
+    DELETE = async (req, data, segmentName) => this.#callMethod({ httpMethod: HttpMethod.DELETE, req, params: await data.params, segmentName });
+    HEAD = async (req, data, segmentName) => this.#callMethod({ httpMethod: HttpMethod.HEAD, req, params: await data.params, segmentName });
+    OPTIONS = async (req, data, segmentName) => this.#callMethod({ httpMethod: HttpMethod.OPTIONS, req, params: await data.params, segmentName });
+    respond = async ({ statusCode, responseBody, options, }) => {
+        const response = new Response(JSON.stringify(responseBody), {
+            status: statusCode,
+            headers: {
+                'content-type': 'application/json',
+                ..._a.getHeadersFromDecoratorOptions(options),
+            },
+        });
+        return response;
+    };
+    #respondWithError = ({ req, statusCode, message, options, cause, }) => {
+        return this.respond({
+            req,
+            statusCode,
+            responseBody: {
+                cause,
+                statusCode,
+                message,
+                isError: true,
+            },
+            options,
+        });
+    };
+    #routeRegexCache = new Map();
+    #routeSegmentsCache = new Map();
+    #routeParamPositionsCache = new Map();
+    #routeMatchCache = new Map();
+    #getHandler = ({ handlers, path, params, }) => {
+        let methodParams = {};
+        if (Object.keys(params).length === 0) {
+            return { handler: handlers[''], methodParams };
+        }
+        const pathStr = path.join('/');
+        // Fast path: Check if this exact path has been matched before
+        const cachedMatch = this.#routeMatchCache.get(pathStr);
+        if (cachedMatch) {
+            return {
+                handler: handlers[cachedMatch.route],
+                methodParams: cachedMatch.params,
+            };
+        }
+        // Check for direct static route match
+        let methodKey = handlers[pathStr] ? pathStr : null;
+        if (!methodKey) {
+            const methodKeys = [];
+            const pathLength = path.length;
+            // First pass: group routes by length for quick filtering
+            const routesByLength = new Map();
+            for (const p of Object.keys(handlers)) {
+                let routeSegments = this.#routeSegmentsCache.get(p);
+                if (!routeSegments) {
+                    routeSegments = p.split('/');
+                    this.#routeSegmentsCache.set(p, routeSegments);
+                    // Pre-compute parameter positions for routes with parameters
+                    if (p.includes('{')) {
+                        const paramPositions = [];
+                        for (let i = 0; i < routeSegments.length; i++) {
+                            const segment = routeSegments[i];
+                            if (segment.includes('{')) {
+                                const paramMatch = segment.match(/\{(\w+)\}/);
+                                if (paramMatch) {
+                                    paramPositions.push({ index: i, paramName: paramMatch[1] });
+                                }
+                            }
+                        }
+                        this.#routeParamPositionsCache.set(p, paramPositions);
+                    }
+                }
+                const segmentLength = routeSegments.length;
+                if (segmentLength !== pathLength)
+                    continue;
+                const lengthRoutes = routesByLength.get(segmentLength) || [];
+                lengthRoutes.push(p);
+                routesByLength.set(segmentLength, lengthRoutes);
+            }
+            // Only process routes with matching segment count
+            const candidateRoutes = routesByLength.get(pathLength) || [];
+            for (const p of candidateRoutes) {
+                const routeSegments = this.#routeSegmentsCache.get(p);
+                if (!routeSegments)
+                    continue; // This should never happen, fix TS error
+                const params = {};
+                // Fast path for routes with parameters
+                const paramPositions = this.#routeParamPositionsCache.get(p);
+                if (paramPositions) {
+                    let isMatch = true;
+                    // First check all non-parameter segments for a quick fail
+                    for (let i = 0; i < routeSegments.length; i++) {
+                        const routeSegment = routeSegments[i];
+                        if (!routeSegment.includes('{') && routeSegment !== path[i]) {
+                            isMatch = false;
+                            break;
+                        }
+                    }
+                    if (!isMatch)
+                        continue;
+                    // Now process parameter segments
+                    for (const { index, paramName } of paramPositions) {
+                        const routeSegment = routeSegments[index];
+                        const pathSegment = path[index];
+                        let regex = this.#routeRegexCache.get(routeSegment);
+                        if (!regex) {
+                            const regexPattern = routeSegment
+                                .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+                                .replace(/\\{(\w+)\\}/g, '(?<$1>[^/]+)');
+                            regex = new RegExp(`^${regexPattern}$`);
+                            this.#routeRegexCache.set(routeSegment, regex);
+                        }
+                        const values = pathSegment.match(regex)?.groups;
+                        if (!values) {
+                            isMatch = false;
+                            break;
+                        }
+                        if (paramName in params) {
+                            throw new HttpException(HttpStatus.INTERNAL_SERVER_ERROR, `Duplicate parameter "${paramName}" at ${p}`);
+                        }
+                        params[paramName] = values[paramName];
+                    }
+                    if (isMatch) {
+                        methodParams = params;
+                        methodKeys.push(p);
+                    }
+                }
+                else {
+                    // Static route - simple equality comparison for all segments
+                    let isMatch = true;
+                    for (let i = 0; i < routeSegments.length; i++) {
+                        if (routeSegments[i] !== path[i]) {
+                            isMatch = false;
+                            break;
+                        }
+                    }
+                    if (isMatch) {
+                        methodKeys.push(p);
+                    }
+                }
+            }
+            if (methodKeys.length > 1) {
+                throw new HttpException(HttpStatus.INTERNAL_SERVER_ERROR, `Conflicting routes found: ${methodKeys.join(', ')}`);
+            }
+            [methodKey] = methodKeys;
+            // Cache successful matches
+            if (methodKey) {
+                this.#routeMatchCache.set(pathStr, { route: methodKey, params: methodParams });
+            }
+        }
+        if (methodKey) {
+            return { handler: handlers[methodKey], methodParams };
+        }
+        return { handler: null, methodParams };
+    };
+    #allHandlers = {};
+    #collectHandlers = (httpMethod, segmentName) => {
+        const controllers = this.routes[httpMethod];
+        const handlers = {};
+        controllers.forEach((staticMethods, controller) => {
+            if (segmentName !== controller._segmentName)
+                return;
+            const prefix = controller._prefix ?? '';
+            Object.entries(staticMethods ?? {}).forEach(([path, staticMethod]) => {
+                const fullPath = [prefix, path].filter(Boolean).join('/');
+                handlers[fullPath] = { staticMethod, controller };
+            });
+        });
+        return handlers;
+    };
+    #callMethod = async ({ httpMethod, req: request, params, segmentName, }) => {
+        const req = request;
+        const path = params[Object.keys(params)[0]] ?? [];
+        const handlers = this.#allHandlers[segmentName]?.[httpMethod] ?? this.#collectHandlers(httpMethod, segmentName);
+        this.#allHandlers[segmentName] ??= {};
+        this.#allHandlers[segmentName][httpMethod] = handlers;
+        let headerList;
+        try {
+            headerList = request.headers;
+        }
+        catch {
+            // this is static rendering environment, headers are not available
+            headerList = null;
+        }
+        const xMeta = headerList?.get('x-meta');
+        const xMetaHeader = xMeta && JSON.parse(xMeta);
+        if (xMetaHeader)
+            reqMeta(req, { xMetaHeader });
+        const { handler, methodParams } = this.#getHandler({ handlers, path, params });
+        if (!handler) {
+            return this.#respondWithError({
+                req,
+                statusCode: HttpStatus.NOT_FOUND,
+                message: `Route '${path.join('/')}' is not found for ${httpMethod} method at ${segmentName === '' ? 'the root segment' : `segment '${segmentName}'`}`,
+            });
+        }
+        const { staticMethod, controller } = handler;
+        const headersFromDecoratorOptions = _a.getHeadersFromDecoratorOptions(staticMethod._options);
+        const { _onSuccess: onSuccess, _onBefore: onBefore } = controller;
+        req.vovk = {
+            body: () => parseBody(req),
+            query: () => reqQuery(req),
+            meta: (meta) => reqMeta(req, meta),
+            params: () => methodParams,
+        };
+        try {
+            await staticMethod._options?.before?.call(controller, req);
+            await onBefore?.(req);
+            const result = await staticMethod.call(controller, req, methodParams);
+            if (result instanceof Response) {
+                await onSuccess?.(result, req);
+                // set headers from decorator options
+                for (const [key, value] of Object.entries(headersFromDecoratorOptions)) {
+                    if (!result.headers.has(key)) {
+                        result.headers.set(key, value);
+                    }
+                }
+                return result;
+            }
+            if (result instanceof Responder) {
+                await onSuccess?.(result, req);
+                // set headers from decorator options
+                for (const [key, value] of Object.entries(headersFromDecoratorOptions)) {
+                    if (!result.response.headers.has(key)) {
+                        result.response.headers.set(key, value);
+                    }
+                }
+                return result.response;
+            }
+            const isIterator = typeof result === 'object' &&
+                !!result &&
+                !Array.isArray(result) &&
+                ((Reflect.has(result, Symbol.iterator) &&
+                    typeof result[Symbol.iterator] === 'function') ||
+                    (Reflect.has(result, Symbol.asyncIterator) &&
+                        typeof result[Symbol.asyncIterator] === 'function'));
+            if (isIterator) {
+                const responder = new JSONLinesResponder(req, ({ headers, readableStream }) => new Response(readableStream, {
+                    headers: { ...headersFromDecoratorOptions, ...headers },
+                }));
+                void (async () => {
+                    try {
+                        for await (const chunk of result) {
+                            await responder.send(chunk);
+                        }
+                    }
+                    catch (e) {
+                        return responder.throw(e);
+                    }
+                    return responder.close();
+                })();
+                await onSuccess?.(responder, req);
+                return responder.response;
+            }
+            const responseBody = result ?? null;
+            await onSuccess?.(responseBody, req);
+            return this.respond({ req, statusCode: 200, responseBody, options: staticMethod._options });
+        }
+        catch (e) {
+            const err = e;
+            try {
+                await controller._onError?.(err, req);
+            }
+            catch (onErrorError) {
+                // eslint-disable-next-line no-console
+                console.error('An error caught in onError handler:', onErrorError);
+            }
+            if (err.message !== 'NEXT_REDIRECT' && err.message !== 'NEXT_NOT_FOUND') {
+                const statusCode = err.statusCode || HttpStatus.INTERNAL_SERVER_ERROR;
+                return this.#respondWithError({
+                    req,
+                    statusCode,
+                    message: err.message,
+                    options: staticMethod._options,
+                    cause: err.cause,
+                });
+            }
+            throw e; // if NEXT_REDIRECT or NEXT_NOT_FOUND, rethrow it
+        }
+    };
+}
+_a = VovkApp;
+const vovkApp = new VovkApp();
+export { vovkApp };

package/dist/index.d.ts

@@ -1,59 +1,25 @@
-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 VovkControllerOutput, type VovkSegmentSchema, type VovkControllerSchema, type VovkHandlerSchema, type VovkFullSchema, type VovkConfig, type VovkStrictConfig, type VovkEnv, type VovkValidationType } from './types';
-import { type VovkClient, type VovkClientOptions, type VovkClientFetcher, type VovkDefaultFetcherOptions, type VovkValidateOnClient, type VovkStreamAsyncIterable, createRPC, fetcher } from './client';
-import { HttpException } from './HttpException';
-import { createDecorator } from './createDecorator';
-import { StreamJSONResponse } from './StreamJSONResponse';
-import { generateStaticAPI } from './utils/generateStaticAPI';
-import { withValidation } from './utils/withValidation';
-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, type VovkValidationType, StreamJSONResponse, HttpException, HttpStatus, HttpMethod, createVovkApp, createDecorator, createRPC, fetcher, generateStaticAPI, withValidation, };
-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, initVovk: (options: {
-    segmentName?: string;
-    controllers: Record<string, import("./types").StaticClass>;
-    exposeValidation?: boolean;
-    emitSchema?: boolean;
-    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>;
-};
+export { HttpException } from './core/HttpException.js';
+export { createDecorator } from './core/createDecorator.js';
+export { controllersToStaticParams } from './core/controllersToStaticParams.js';
+export { multitenant } from './core/multitenant.js';
+export { JSONLinesResponder } from './core/JSONLinesResponder.js';
+export { toDownloadResponse } from './core/toDownloadResponse.js';
+export { get, post, put, patch, del, head, options, prefix, cloneControllerMetadata } from './core/decorators.js';
+export { progressive } from './client/progressive.js';
+export { fetcher, createFetcher } from './client/fetcher.js';
+export { initSegment } from './core/initSegment.js';
+export { operation } from './openapi/operation.js';
+export { createValidateOnClient } from './validation/createValidateOnClient.js';
+export { procedure } from './validation/procedure.js';
+export { ToModelOutput } from './tools/ToModelOutput.js';
+export { createTool } from './tools/createTool.js';
+export { deriveTools } from './tools/deriveTools.js';
+export { HttpStatus, HttpMethod } from './types/enums.js';
+export type { VovkBody, VovkQuery, VovkParams, VovkReturnType, VovkYieldType, VovkOutput, VovkIteration, } from './types/inference.js';
+export type { VovkRequest } from './types/request.js';
+export type { VovkJSONSchemaBase } from './types/json-schema.js';
+export type { VovkConfig } from './types/config.js';
+export type { VovkSchema } from './types/core.js';
+export type { VovkFetcher } from './types/client.js';
+export type { VovkValidateOnClient } from './types/validation.js';
+export type { VovkTool } from './types/tools.js';

package/dist/index.js

@@ -1,23 +1,23 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initVovk = exports.prefix = exports.options = exports.head = exports.del = exports.patch = exports.put = exports.post = exports.get = exports.withValidation = exports.generateStaticAPI = exports.fetcher = exports.createRPC = exports.createDecorator = exports.createVovkApp = exports.HttpMethod = exports.HttpStatus = exports.HttpException = exports.StreamJSONResponse = 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; } });
-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; } });
-const HttpException_1 = require("./HttpException");
-Object.defineProperty(exports, "HttpException", { enumerable: true, get: function () { return HttpException_1.HttpException; } });
-const createDecorator_1 = require("./createDecorator");
-Object.defineProperty(exports, "createDecorator", { enumerable: true, get: function () { return createDecorator_1.createDecorator; } });
-const StreamJSONResponse_1 = require("./StreamJSONResponse");
-Object.defineProperty(exports, "StreamJSONResponse", { enumerable: true, get: function () { return StreamJSONResponse_1.StreamJSONResponse; } });
-const generateStaticAPI_1 = require("./utils/generateStaticAPI");
-Object.defineProperty(exports, "generateStaticAPI", { enumerable: true, get: function () { return generateStaticAPI_1.generateStaticAPI; } });
-const withValidation_1 = require("./utils/withValidation");
-Object.defineProperty(exports, "withValidation", { enumerable: true, get: function () { return withValidation_1.withValidation; } });
-_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.initVovk = _a.initVovk;
+// core
+export { HttpException } from './core/HttpException.js';
+export { createDecorator } from './core/createDecorator.js';
+export { controllersToStaticParams } from './core/controllersToStaticParams.js';
+export { multitenant } from './core/multitenant.js';
+export { JSONLinesResponder } from './core/JSONLinesResponder.js';
+export { toDownloadResponse } from './core/toDownloadResponse.js';
+export { get, post, put, patch, del, head, options, prefix, cloneControllerMetadata } from './core/decorators.js';
+// client
+export { progressive } from './client/progressive.js';
+export { fetcher, createFetcher } from './client/fetcher.js';
+export { initSegment } from './core/initSegment.js';
+// openapi
+export { operation } from './openapi/operation.js';
+// validation
+export { createValidateOnClient } from './validation/createValidateOnClient.js';
+export { procedure } from './validation/procedure.js';
+// tools
+export { ToModelOutput } from './tools/ToModelOutput.js';
+export { createTool } from './tools/createTool.js';
+export { deriveTools } from './tools/deriveTools.js';
+// types
+export { HttpStatus, HttpMethod } from './types/enums.js';

package/dist/internal.d.ts

@@ -0,0 +1,17 @@
+export { deepExtend } from './utils/deepExtend.js';
+export { resolveGeneratorConfigValues } from './core/resolveGeneratorConfigValues.js';
+export { createCodeSamples } from './samples/createCodeSamples.js';
+export { withValidationLibrary } from './validation/withValidationLibrary.js';
+export { operation } from './openapi/operation.js';
+export { openAPIToVovkSchema } from './openapi/openAPIToVovkSchema/index.js';
+export { vovkSchemaToOpenAPI } from './openapi/vovkSchemaToOpenAPI.js';
+export { readableStreamToAsyncIterable } from './client/defaultStreamHandler.js';
+export { VovkSchemaIdEnum } from './types/enums.js';
+export type { VovkToolDerived, VovkToolNonDerived } from './types/tools.js';
+export type { MCPModelOutput } from './tools/toModelOutputMCP.js';
+export type { VovkErrorResponse, VovkMetaSchema, VovkSegmentSchema, VovkControllerSchema, VovkHandlerSchema, VovkValidationType, } from './types/core.js';
+export type { VovkTypedProcedure } from './types/validation.js';
+export type { VovkOutputConfig, VovkReadmeConfig, VovkSamplesConfig, VovkPackageJson, VovkOpenAPIMixin, VovkOpenAPIMixinNormalized, VovkStrictConfig, VovkBundleConfig, VovkSegmentConfig, } from './types/config.js';
+export type { VovkOperationObject } from './types/operation.js';
+export type { VovkRPCModule, VovkFetcherOptions, VovkStreamAsyncIterable } from './types/client.js';
+export type { IsAny, IsNotAny } from './types/utils.js';

package/dist/internal.js

@@ -0,0 +1,10 @@
+// internal exports for other packages and tests
+export { deepExtend } from './utils/deepExtend.js';
+export { resolveGeneratorConfigValues } from './core/resolveGeneratorConfigValues.js';
+export { createCodeSamples } from './samples/createCodeSamples.js';
+export { withValidationLibrary } from './validation/withValidationLibrary.js';
+export { operation } from './openapi/operation.js';
+export { openAPIToVovkSchema } from './openapi/openAPIToVovkSchema/index.js';
+export { vovkSchemaToOpenAPI } from './openapi/vovkSchemaToOpenAPI.js';
+export { readableStreamToAsyncIterable } from './client/defaultStreamHandler.js';
+export { VovkSchemaIdEnum } from './types/enums.js';

package/dist/openapi/error.d.ts

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

package/dist/openapi/error.js

@@ -0,0 +1,97 @@
+import { HttpStatus } from '../types/enums.js';
+import { createDecorator } from '../core/createDecorator.js';
+const statusDisplayText = {
+    [HttpStatus.NULL]: 'Error',
+    [HttpStatus.CONTINUE]: 'Continue',
+    [HttpStatus.SWITCHING_PROTOCOLS]: 'Switching Protocols',
+    [HttpStatus.PROCESSING]: 'Processing',
+    [HttpStatus.EARLYHINTS]: 'Early Hints',
+    [HttpStatus.OK]: 'OK',
+    [HttpStatus.CREATED]: 'Created',
+    [HttpStatus.ACCEPTED]: 'Accepted',
+    [HttpStatus.NON_AUTHORITATIVE_INFORMATION]: 'Non Authoritative Information',
+    [HttpStatus.NO_CONTENT]: 'No Content',
+    [HttpStatus.RESET_CONTENT]: 'Reset Content',
+    [HttpStatus.PARTIAL_CONTENT]: 'Partial Content',
+    [HttpStatus.AMBIGUOUS]: 'Ambiguous',
+    [HttpStatus.MOVED_PERMANENTLY]: 'Moved Permanently',
+    [HttpStatus.FOUND]: 'Found',
+    [HttpStatus.SEE_OTHER]: 'See Other',
+    [HttpStatus.NOT_MODIFIED]: 'Not Modified',
+    [HttpStatus.TEMPORARY_REDIRECT]: 'Temporary Redirect',
+    [HttpStatus.PERMANENT_REDIRECT]: 'Permanent Redirect',
+    [HttpStatus.BAD_REQUEST]: 'Bad Request',
+    [HttpStatus.UNAUTHORIZED]: 'Unauthorized',
+    [HttpStatus.PAYMENT_REQUIRED]: 'Payment Required',
+    [HttpStatus.FORBIDDEN]: 'Forbidden',
+    [HttpStatus.NOT_FOUND]: 'Not Found',
+    [HttpStatus.METHOD_NOT_ALLOWED]: 'Method Not Allowed',
+    [HttpStatus.NOT_ACCEPTABLE]: 'Not Acceptable',
+    [HttpStatus.PROXY_AUTHENTICATION_REQUIRED]: 'Proxy Authentication Required',
+    [HttpStatus.REQUEST_TIMEOUT]: 'Request Timeout',
+    [HttpStatus.CONFLICT]: 'Conflict',
+    [HttpStatus.GONE]: 'Gone',
+    [HttpStatus.LENGTH_REQUIRED]: 'Length Required',
+    [HttpStatus.PRECONDITION_FAILED]: 'Precondition Failed',
+    [HttpStatus.PAYLOAD_TOO_LARGE]: 'Payload Too Large',
+    [HttpStatus.URI_TOO_LONG]: 'URI Too Long',
+    [HttpStatus.UNSUPPORTED_MEDIA_TYPE]: 'Unsupported Media Type',
+    [HttpStatus.REQUESTED_RANGE_NOT_SATISFIABLE]: 'Requested Range Not Satisfiable',
+    [HttpStatus.EXPECTATION_FAILED]: 'Expectation Failed',
+    [HttpStatus.I_AM_A_TEAPOT]: 'I am a teapot',
+    [HttpStatus.MISDIRECTED]: 'Misdirected',
+    [HttpStatus.UNPROCESSABLE_ENTITY]: 'Unprocessable Entity',
+    [HttpStatus.FAILED_DEPENDENCY]: 'Failed Dependency',
+    [HttpStatus.PRECONDITION_REQUIRED]: 'Precondition Required',
+    [HttpStatus.TOO_MANY_TRequestS]: 'Too Many Requests',
+    [HttpStatus.INTERNAL_SERVER_ERROR]: 'Internal Server Error',
+    [HttpStatus.NOT_IMPLEMENTED]: 'Not Implemented',
+    [HttpStatus.BAD_GATEWAY]: 'Bad Gateway',
+    [HttpStatus.SERVICE_UNAVAILABLE]: 'Service Unavailable',
+    [HttpStatus.GATEWAY_TIMEOUT]: 'Gateway Timeout',
+    [HttpStatus.HTTP_VERSION_NOT_SUPPORTED]: 'HTTP Version Not Supported',
+};
+export const error = 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/dist/openapi/openAPIToVovkSchema/applyComponentsSchemas.d.ts

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