vovk 3.0.0-draft.8 → 3.0.0-draft.80

package/dist/client/types.d.ts

@@ -0,0 +1,100 @@
+import type { KnownAny, HttpMethod, ControllerStaticMethod, VovkControllerBody, VovkControllerQuery, VovkControllerParams, VovkHandlerSchema, VovkControllerSchema } from '../types';
+import type { StreamJSONResponse } from '../StreamJSONResponse';
+import type { NextResponse } from 'next/server';
+export type StaticMethodInput<T extends ControllerStaticMethod> = (VovkControllerBody<T> extends undefined | void ? {
+    body?: undefined;
+} : VovkControllerBody<T> extends null ? {
+    body?: null;
+} : {
+    body: VovkControllerBody<T>;
+}) & (VovkControllerQuery<T> extends undefined | void ? {
+    query?: undefined;
+} : {
+    query: VovkControllerQuery<T>;
+}) & (VovkControllerParams<T> extends undefined | void ? {
+    params?: undefined;
+} : {
+    params: VovkControllerParams<T>;
+});
+type ToPromise<T> = T extends PromiseLike<unknown> ? T : Promise<T>;
+export type VovkStreamAsyncIterable<T> = {
+    status: number;
+    [Symbol.dispose](): Promise<void> | void;
+    [Symbol.asyncDispose](): Promise<void> | void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    cancel: () => Promise<void> | void;
+};
+type StaticMethodReturn<T extends ControllerStaticMethod> = ReturnType<T> extends NextResponse<infer U> | Promise<NextResponse<infer U>> ? U : ReturnType<T> extends Response | Promise<Response> ? Awaited<ReturnType<T>> : ReturnType<T>;
+type StaticMethodReturnPromise<T extends ControllerStaticMethod> = ToPromise<StaticMethodReturn<T>>;
+type ClientMethod<T extends (...args: KnownAny[]) => void | object | StreamJSONResponse<STREAM> | Promise<StreamJSONResponse<STREAM>>, OPTS extends Record<string, KnownAny>, STREAM extends KnownAny = unknown> = (<R>(options: (StaticMethodInput<T> extends {
+    body?: undefined | null;
+    query?: undefined;
+    params?: undefined;
+} ? unknown : Parameters<T>[0] extends void ? StaticMethodInput<T>['params'] extends object ? {
+    params: StaticMethodInput<T>['params'];
+} : unknown : StaticMethodInput<T>) & (Partial<OPTS & {
+    transform: (staticMethodReturn: Awaited<StaticMethodReturn<T>>) => R;
+}> | void)) => ReturnType<T> extends Promise<StreamJSONResponse<infer U>> | StreamJSONResponse<infer U> | Iterator<infer U> | AsyncIterator<infer U> ? Promise<VovkStreamAsyncIterable<U>> : R extends object ? Promise<R> : StaticMethodReturnPromise<T>) & {
+    schema: VovkHandlerSchema;
+    controllerSchema: VovkControllerSchema;
+};
+type OmitNever<T> = {
+    [K in keyof T as T[K] extends never ? never : K]: T[K];
+};
+type VovkClientWithNever<T, OPTS extends {
+    [key: string]: KnownAny;
+}> = {
+    [K in keyof T]: T[K] extends (...args: KnownAny) => KnownAny ? ClientMethod<T[K], OPTS> : never;
+};
+export type VovkClient<T, OPTS extends {
+    [key: string]: KnownAny;
+}> = OmitNever<VovkClientWithNever<T, OPTS>>;
+export type VovkClientFetcher<OPTS extends Record<string, KnownAny> = Record<string, never>, T = KnownAny> = (options: {
+    name: keyof T;
+    httpMethod: HttpMethod;
+    getEndpoint: (data: {
+        apiRoot: string;
+        params: {
+            [key: string]: string;
+        };
+        query: {
+            [key: string]: string;
+        };
+    }) => string;
+    validate: (input: {
+        body?: unknown;
+        query?: unknown;
+        endpoint: string;
+    }) => void | Promise<void>;
+    defaultStreamHandler: (response: Response) => Promise<VovkStreamAsyncIterable<unknown>>;
+    defaultHandler: (response: Response) => Promise<unknown>;
+}, input: {
+    body: unknown;
+    query: {
+        [key: string]: string;
+    };
+    params: {
+        [key: string]: string;
+    };
+} & OPTS) => KnownAny;
+export interface VovkDefaultFetcherOptions extends Omit<RequestInit, 'body' | 'method'> {
+    reactNative?: {
+        textStreaming: boolean;
+    };
+    apiRoot?: string;
+    segmentName?: string;
+    disableClientValidation?: boolean;
+    validateOnClient?: VovkValidateOnClient;
+    fetcher?: VovkClientFetcher;
+}
+export type VovkValidateOnClient = (input: {
+    body?: unknown;
+    query?: unknown;
+    endpoint: string;
+}, validation: Exclude<VovkHandlerSchema['validation'], undefined>) => void | Promise<void>;
+export type VovkClientOptions<OPTS extends Record<string, KnownAny> = Record<string, never>> = {
+    fetcher?: VovkClientFetcher<OPTS>;
+    validateOnClient?: VovkValidateOnClient;
+    defaultOptions?: Partial<OPTS>;
+};
+export {};

package/dist/createDecorator.d.ts

@@ -0,0 +1,4 @@
+import type { VovkHandlerSchema, KnownAny, VovkController, VovkRequest } from './types';
+type Next = () => Promise<unknown>;
+export declare function createDecorator<ARGS extends unknown[], REQUEST = VovkRequest>(handler: null | ((this: VovkController, req: REQUEST, next: Next, ...args: ARGS) => unknown), initHandler?: (this: VovkController, ...args: ARGS) => Omit<VovkHandlerSchema, 'path' | 'httpMethod'> | ((handlerSchema: VovkHandlerSchema | null) => Omit<Partial<VovkHandlerSchema>, 'path' | 'httpMethod'>) | null | undefined): (...args: ARGS) => (target: KnownAny, propertyKey: string) => void;
+export {};

package/{createDecorator.js → dist/createDecorator.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._createDecorator = _createDecorator;
-function _createDecorator(handler, initHandler) {
+exports.createDecorator = createDecorator;
+function createDecorator(handler, initHandler) {
     return function decoratorCreator(...args) {
         return function decorator(target, propertyKey) {
             const controller = target;
@@ -10,6 +10,17 @@ function _createDecorator(handler, initHandler) {
                 throw new Error(`Unable to decorate: ${propertyKey} is not a function`);
             }
             const sourceMethod = originalMethod._sourceMethod ?? originalMethod;
+            const method = function method(req, params) {
+                const next = async () => {
+                    return (await originalMethod.call(controller, req, params));
+                };
+                return handler ? handler.call(controller, req, next, ...args) : next();
+            };
+            controller[propertyKey] = method;
+            method._controller = controller;
+            method._sourceMethod = sourceMethod;
+            // TODO define internal method type
+            originalMethod._controller = controller;
             const handlerSchema = controller._handlers?.[propertyKey] ?? null;
             const initResultReturn = initHandler?.call(controller, ...args);
             const initResult = typeof initResultReturn === 'function' ? initResultReturn(handlerSchema) : initResultReturn;
@@ -18,21 +29,11 @@ function _createDecorator(handler, initHandler) {
                 [propertyKey]: {
                     ...handlerSchema,
                     // avoid override of path and httpMethod
-                    ...(initResult?.clientValidators ? { clientValidators: initResult.clientValidators } : {}),
-                    ...(initResult?.customSchema ? { customSchema: initResult.customSchema } : {}),
+                    ...(initResult?.validation ? { validation: initResult.validation } : {}),
+                    ...(initResult?.openapi ? { openapi: initResult.openapi } : {}),
+                    ...(initResult?.custom ? { custom: initResult.custom } : {}),
                 },
             };
-            const method = function method(req, params) {
-                const next = async () => {
-                    return (await originalMethod.call(controller, req, params));
-                };
-                return handler ? handler.call(controller, req, next, ...args) : next();
-            };
-            method._controller = controller;
-            // TODO define internal method type
-            originalMethod._controller = controller;
-            controller[propertyKey] = method;
-            method._sourceMethod = sourceMethod;
         };
     };
 }

package/{createSegment.d.ts → dist/createVovkApp.d.ts}

@@ -1,5 +1,6 @@
-import { type _KnownAny as KnownAny, type _DecoratorOptions as DecoratorOptions, type _VovkRequest as VovkRequest, type _StaticClass as StaticClass } from './types';
-export declare function _createSegment(): {
+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>;
         auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
@@ -32,30 +33,29 @@ export declare function _createSegment(): {
     initVovk: (options: {
         segmentName?: string;
         controllers: Record<string, StaticClass>;
-        workers?: Record<string, StaticClass>;
         exposeValidation?: boolean;
         emitSchema?: boolean;
         onError?: (err: Error, 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/{createSegment.js → dist/createVovkApp.js}

@@ -3,8 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._createSegment = _createSegment;
-const Segment_1 = require("./Segment");
+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, '');
@@ -13,9 +13,9 @@ const toKebabCase = (str) => str
     .replace(/([A-Z])/g, '-$1')
     .toLowerCase()
     .replace(/^-/, '');
-function _createSegment() {
-    const segment = new Segment_1._Segment();
-    const getDecoratorCreator = (httpMethod) => {
+function createVovkApp() {
+    const vovkApp = new VovkApp_1.VovkApp();
+    const createHTTPDecorator = (httpMethod) => {
         const assignSchema = (controller, propertyKey, path, options) => {
             if (typeof window !== 'undefined') {
                 throw new Error('Decorators are intended for server-side use only. You have probably imported a controller on the client-side.');
@@ -26,19 +26,21 @@ function _createSegment() {
                     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 = segment._routes[httpMethod].get(controller) ?? {};
-            segment._routes[httpMethod].set(controller, methods);
+            const methods = vovkApp.routes[httpMethod].get(controller) ?? {};
+            vovkApp.routes[httpMethod].set(controller, methods);
+            const originalMethod = controller[propertyKey];
+            originalMethod._controller = controller;
+            originalMethod._sourceMethod = originalMethod._sourceMethod ?? originalMethod;
+            const validation = originalMethod._sourceMethod._getValidation?.(controller);
             controller._handlers = {
                 ...controller._handlers,
                 [propertyKey]: {
+                    ...(validation ? { validation } : {}),
                     ...(controller._handlers ?? {})[propertyKey],
                     path,
                     httpMethod,
                 },
             };
-            const originalMethod = controller[propertyKey];
-            originalMethod._controller = controller;
-            originalMethod._sourceMethod = originalMethod._sourceMethod ?? originalMethod;
             methods[path] = controller[propertyKey];
             methods[path]._options = options;
         };
@@ -53,8 +55,8 @@ function _createSegment() {
         const auto = (options) => {
             function decorator(givenTarget, propertyKey) {
                 const controller = givenTarget;
-                const methods = segment._routes[httpMethod].get(controller) ?? {};
-                segment._routes[httpMethod].set(controller, methods);
+                const methods = vovkApp.routes[httpMethod].get(controller) ?? {};
+                vovkApp.routes[httpMethod].set(controller, methods);
                 controller._handlers = {
                     ...controller._handlers,
                     [propertyKey]: {
@@ -87,31 +89,29 @@ function _createSegment() {
         async function GET_DEV(req, data) {
             const params = await data.params;
             if (params[Object.keys(params)[0]]?.[0] === '_schema_') {
-                // Wait for schema to be set (it can be set after decorators are called with another setTimeout)
-                await new Promise((resolve) => setTimeout(resolve, 10));
                 const schema = (0, getSchema_1.default)(options);
-                return segment.respond(200, { schema });
+                return vovkApp.respond(200, { schema });
             }
-            return segment.GET(req, data);
+            return vovkApp.GET(req, data);
         }
         return {
-            GET: process.env.NODE_ENV === 'development' ? GET_DEV : segment.GET,
-            POST: segment.POST,
-            PUT: segment.PUT,
-            PATCH: segment.PATCH,
-            DELETE: segment.DELETE,
-            HEAD: segment.HEAD,
-            OPTIONS: segment.OPTIONS,
+            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: getDecoratorCreator(types_1._HttpMethod.GET),
-        post: getDecoratorCreator(types_1._HttpMethod.POST),
-        put: getDecoratorCreator(types_1._HttpMethod.PUT),
-        patch: getDecoratorCreator(types_1._HttpMethod.PATCH),
-        del: getDecoratorCreator(types_1._HttpMethod.DELETE),
-        head: getDecoratorCreator(types_1._HttpMethod.HEAD),
-        options: getDecoratorCreator(types_1._HttpMethod.OPTIONS),
+        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,
         initVovk,
     };

package/dist/index.d.ts

@@ -0,0 +1,60 @@
+import { createVovkApp } from './createVovkApp';
+import { HttpStatus as HttpStatus, HttpMethod as HttpMethod, type KnownAny, type VovkErrorResponse, type VovkRequest, type VovkBody, type VovkQuery, type VovkParams, type VovkReturnType, type VovkYieldType, type VovkControllerBody, type VovkControllerQuery, type VovkControllerParams, type VovkControllerYieldType, type VovkSchema, type VovkControllerSchema, type VovkHandlerSchema } from './types';
+import { type VovkClient, type VovkClientOptions, type VovkClientFetcher, type VovkDefaultFetcherOptions, type VovkValidateOnClient, type VovkStreamAsyncIterable, createRPC } from './client';
+import { openapi } from './openapi';
+import { HttpException } from './HttpException';
+import { createDecorator } from './createDecorator';
+import { StreamJSONResponse } from './StreamJSONResponse';
+import { generateStaticAPI } from './utils/generateStaticAPI';
+import { setHandlerValidation } from './utils/setHandlerValidation';
+export { type KnownAny, type VovkClient, type VovkClientFetcher, type VovkDefaultFetcherOptions, type VovkStreamAsyncIterable, type VovkValidateOnClient, type VovkSchema, type VovkErrorResponse, type VovkRequest, type VovkControllerBody, type VovkControllerQuery, type VovkControllerParams, type VovkControllerYieldType, type VovkBody, type VovkQuery, type VovkParams, type VovkYieldType, type VovkReturnType, type VovkClientOptions, type VovkControllerSchema, type VovkHandlerSchema, StreamJSONResponse, HttpException, HttpStatus, HttpMethod, createVovkApp, createDecorator, createRPC, generateStaticAPI, openapi, setHandlerValidation, };
+export declare const get: {
+    (givenPath?: string | undefined, options?: import("./types").DecoratorOptions | undefined): ReturnType<(givenPath?: string, options?: import("./types").DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void>;
+    auto: (options?: import("./types").DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+}, 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>;
+};

package/dist/index.js

@@ -0,0 +1,24 @@
+"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.setHandlerValidation = exports.openapi = exports.generateStaticAPI = 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; } });
+const openapi_1 = require("./openapi");
+Object.defineProperty(exports, "openapi", { enumerable: true, get: function () { return openapi_1.openapi; } });
+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 setHandlerValidation_1 = require("./utils/setHandlerValidation");
+Object.defineProperty(exports, "setHandlerValidation", { enumerable: true, get: function () { return setHandlerValidation_1.setHandlerValidation; } });
+_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;

package/dist/openapi/fromSchema.d.ts

@@ -0,0 +1,3 @@
+import type { OpenAPIObject } from 'openapi3-ts/oas31';
+import type { VovkSchema } from '../types';
+export declare function fromSchema(apiRoot: string, vovkSchema: Record<string, VovkSchema>, extendWith?: Partial<OpenAPIObject>): OpenAPIObject;

package/dist/openapi/fromSchema.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromSchema = fromSchema;
+function fromSchema(apiRoot, vovkSchema, extendWith) {
+    const paths = {};
+    for (const [segmentName, schema] of Object.entries(vovkSchema)) {
+        for (const c of Object.values(schema.controllers)) {
+            for (const h of Object.values(c.handlers)) {
+                if (h.openapi) {
+                    const path = '/' + [apiRoot.replace(/^\/+|\/+$/g, ''), segmentName, c.prefix, h.path].filter(Boolean).join('/');
+                    paths[path] = paths[path] ?? {};
+                    paths[path][h.httpMethod.toLowerCase()] = { ...h.openapi };
+                }
+            }
+        }
+    }
+    return {
+        ...extendWith,
+        openapi: '3.1.0',
+        info: extendWith?.info ?? {
+            title: 'API',
+            version: '1.0.0',
+        },
+        paths,
+    };
+}

package/dist/openapi/index.d.ts

@@ -0,0 +1 @@
+export { openapi } from './openapi';

package/dist/openapi/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openapi = void 0;
+var openapi_1 = require("./openapi");
+Object.defineProperty(exports, "openapi", { enumerable: true, get: function () { return openapi_1.openapi; } });

package/dist/openapi/openapi.d.ts

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

package/dist/openapi/openapi.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openapi = void 0;
+const createDecorator_1 = require("../createDecorator");
+const fromSchema_1 = require("./fromSchema");
+const openapiDecorator = (0, createDecorator_1.createDecorator)(null, (openAPIOperationObject = {}) => {
+    return (handlerSchema) => ({
+        ...handlerSchema,
+        openapi: {
+            ...handlerSchema?.openapi,
+            ...(handlerSchema?.validation?.output &&
+                'type' in handlerSchema.validation.output &&
+                'properties' in handlerSchema.validation.output
+                ? {
+                    responses: {
+                        200: {
+                            description: 'description' in handlerSchema.validation.output
+                                ? handlerSchema.validation.output.description
+                                : 'Success',
+                            content: {
+                                'application/json': {
+                                    schema: handlerSchema.validation.output,
+                                },
+                            },
+                        },
+                    },
+                }
+                : {}),
+            ...(handlerSchema?.validation?.body &&
+                'type' in handlerSchema.validation.body &&
+                'properties' in handlerSchema.validation.body
+                ? {
+                    requestBody: {
+                        description: 'description' in handlerSchema.validation.body
+                            ? handlerSchema.validation.body.description
+                            : 'Request body',
+                        required: true,
+                        content: {
+                            'application/json': {
+                                schema: handlerSchema.validation.body,
+                            },
+                        },
+                    },
+                }
+                : {}),
+            ...(handlerSchema?.validation?.query &&
+                'type' in handlerSchema.validation.query &&
+                'properties' in handlerSchema.validation.query
+                ? {
+                    parameters: Object.entries(handlerSchema.validation.query.properties)
+                        // .filter(([, propSchema]) => propSchema.type !== 'object')
+                        .map(([propName, propSchema]) => ({
+                        name: propName,
+                        in: 'query',
+                        description: propSchema.description || '',
+                        required: handlerSchema.validation?.query.required
+                            ? handlerSchema.validation.query.required.includes(propName)
+                            : false,
+                        schema: {
+                            type: 'string',
+                        },
+                    })),
+                }
+                : {}),
+            ...openAPIOperationObject,
+        },
+    });
+});
+exports.openapi = openapiDecorator;
+exports.openapi.fromSchema = fromSchema_1.fromSchema;