vovk 3.0.0-draft.7 → 3.0.0-draft.70

package/dist/client/types.d.ts

@@ -0,0 +1,103 @@
+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;
+}, validators: {
+    body?: unknown;
+    query?: unknown;
+}) => 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;
@@ -18,8 +18,9 @@ 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) {

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,8 +26,8 @@ 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);
             controller._handlers = {
                 ...controller._handlers,
                 [propertyKey]: {
@@ -53,8 +53,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]: {
@@ -90,28 +90,28 @@ function _createSegment() {
                 // 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 { setClientValidatorsForHandler } from './utils/setClientValidatorsForHandler';
+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, setClientValidatorsForHandler, };
+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.setClientValidatorsForHandler = 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 setClientValidatorsForHandler_1 = require("./utils/setClientValidatorsForHandler");
+Object.defineProperty(exports, "setClientValidatorsForHandler", { enumerable: true, get: function () { return setClientValidatorsForHandler_1.setClientValidatorsForHandler; } });
+_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 {
+        openapi: '3.1.0',
+        paths,
+        info: extendWith?.info ?? {
+            title: 'API',
+            version: '1.0.0',
+        },
+        ...extendWith,
+    };
+}

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

package/dist/openapi/openapi.js

@@ -0,0 +1,16 @@
+"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,
+            ...openAPIOperationObject,
+        },
+    });
+});
+exports.openapi = openapiDecorator;
+exports.openapi.fromSchema = fromSchema_1.fromSchema;

package/dist/types.d.ts

@@ -0,0 +1,147 @@
+import type { NextRequest } from 'next/server';
+import type { OperationObject } from 'openapi3-ts/oas31';
+import type { StreamJSONResponse } from './StreamJSONResponse';
+import { VovkStreamAsyncIterable } from './client/types';
+export type KnownAny = any;
+export type StaticClass = Function;
+export type VovkHandlerSchema = {
+    path: string;
+    httpMethod: string;
+    validation?: {
+        query?: KnownAny;
+        body?: KnownAny;
+    };
+    openapi?: OperationObject;
+    custom?: Record<string, KnownAny>;
+};
+export type VovkControllerSchema = {
+    controllerName: string;
+    originalControllerName: string;
+    prefix?: string;
+    handlers: Record<string, VovkHandlerSchema>;
+};
+export type VovkSchema = {
+    emitSchema: boolean;
+    segmentName: string;
+    controllers: Record<string, VovkControllerSchema>;
+};
+export type VovkErrorResponse = {
+    cause?: unknown;
+    statusCode: HttpStatus;
+    message: string;
+    isError: true;
+};
+export type VovkControllerInternal = {
+    _controllerName?: VovkControllerSchema['controllerName'];
+    _prefix?: VovkControllerSchema['prefix'];
+    _handlers: VovkControllerSchema['handlers'];
+    _activated?: true;
+    _onError?: (err: Error, req: VovkRequest) => void | Promise<void>;
+};
+export type VovkController = StaticClass & VovkControllerInternal & {
+    [key: string]: unknown;
+};
+export type DecoratorOptions = {
+    cors?: boolean;
+    headers?: Record<string, string>;
+};
+export type RouteHandler = ((req: VovkRequest, params: Record<string, string>) => Response | Promise<Response> | Iterable<unknown> | AsyncIterable<unknown>) & {
+    _options?: DecoratorOptions;
+};
+export interface VovkRequest<BODY = undefined, QUERY extends object | undefined = undefined> extends Omit<NextRequest, 'json' | 'nextUrl'> {
+    json: () => Promise<BODY>;
+    nextUrl: Omit<NextRequest['nextUrl'], 'searchParams'> & {
+        searchParams: Omit<NextRequest['nextUrl']['searchParams'], 'get' | 'getAll' | 'entries' | 'forEach' | 'keys' | 'values'> & {
+            get: <KEY extends keyof QUERY>(key: KEY) => QUERY[KEY] extends readonly (infer ITEM)[] ? ITEM : QUERY[KEY];
+            getAll: <KEY extends keyof QUERY>(key: KEY) => QUERY[KEY] extends KnownAny[] ? QUERY[KEY] : QUERY[KEY][];
+            entries: () => IterableIterator<[keyof QUERY, QUERY[keyof QUERY]]>;
+            forEach: (callbackfn: (value: QUERY[keyof QUERY], key: keyof QUERY, searchParams: NextRequest['nextUrl']['searchParams']) => void) => void;
+            keys: () => IterableIterator<keyof QUERY>;
+            values: () => IterableIterator<QUERY[keyof QUERY]>;
+        };
+    };
+    vovk: {
+        body: () => Promise<BODY>;
+        query: () => QUERY;
+        meta: <T = Record<KnownAny, KnownAny>>(meta?: T | null) => T;
+        form: <T = KnownAny>() => Promise<T>;
+    };
+}
+export type ControllerStaticMethod<REQ extends VovkRequest<KnownAny, KnownAny> = VovkRequest<undefined, Record<string, KnownAny>>, PARAMS extends {
+    [key: string]: string;
+} = KnownAny> = ((req: REQ, params: PARAMS) => unknown) & {
+    _controller?: VovkController;
+};
+export type VovkControllerBody<T extends (...args: KnownAny) => KnownAny> = Awaited<ReturnType<Parameters<T>[0]['vovk']['body']>>;
+export type VovkControllerQuery<T extends (...args: KnownAny) => KnownAny> = ReturnType<Parameters<T>[0]['vovk']['query']>;
+export type VovkControllerParams<T extends (...args: KnownAny) => KnownAny> = Parameters<T>[1];
+export type VovkControllerYieldType<T extends (req: VovkRequest<KnownAny, KnownAny>) => KnownAny> = T extends (...args: KnownAny[]) => AsyncGenerator<infer Y, KnownAny, KnownAny> ? Y : T extends (...args: KnownAny[]) => Generator<infer Y, KnownAny, KnownAny> ? Y : T extends (...args: KnownAny[]) => Promise<StreamJSONResponse<infer Y>> | StreamJSONResponse<infer Y> ? Y : never;
+export type VovkBody<T extends (...args: KnownAny[]) => unknown> = Parameters<T>[0]['body'];
+export type VovkQuery<T extends (...args: KnownAny[]) => unknown> = Parameters<T>[0]['query'];
+export type VovkParams<T extends (...args: KnownAny[]) => unknown> = Parameters<T>[0]['params'];
+export type VovkYieldType<T extends (...args: KnownAny[]) => unknown> = T extends (...args: KnownAny[]) => Promise<VovkStreamAsyncIterable<infer Y>> ? Y : never;
+export type VovkReturnType<T extends (...args: KnownAny) => unknown> = Awaited<ReturnType<T>>;
+export type StreamAbortMessage = {
+    isError: true;
+    reason: KnownAny;
+};
+export declare enum HttpMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    DELETE = "DELETE",
+    HEAD = "HEAD",
+    OPTIONS = "OPTIONS"
+}
+export declare enum HttpStatus {
+    NULL = 0,
+    CONTINUE = 100,
+    SWITCHING_PROTOCOLS = 101,
+    PROCESSING = 102,
+    EARLYHINTS = 103,
+    OK = 200,
+    CREATED = 201,
+    ACCEPTED = 202,
+    NON_AUTHORITATIVE_INFORMATION = 203,
+    NO_CONTENT = 204,
+    RESET_CONTENT = 205,
+    PARTIAL_CONTENT = 206,
+    AMBIGUOUS = 300,
+    MOVED_PERMANENTLY = 301,
+    FOUND = 302,
+    SEE_OTHER = 303,
+    NOT_MODIFIED = 304,
+    TEMPORARY_REDIRECT = 307,
+    PERMANENT_REDIRECT = 308,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    PAYMENT_REQUIRED = 402,
+    FORBIDDEN = 403,
+    NOT_FOUND = 404,
+    METHOD_NOT_ALLOWED = 405,
+    NOT_ACCEPTABLE = 406,
+    PROXY_AUTHENTICATION_REQUIRED = 407,
+    REQUEST_TIMEOUT = 408,
+    CONFLICT = 409,
+    GONE = 410,
+    LENGTH_REQUIRED = 411,
+    PRECONDITION_FAILED = 412,
+    PAYLOAD_TOO_LARGE = 413,
+    URI_TOO_LONG = 414,
+    UNSUPPORTED_MEDIA_TYPE = 415,
+    REQUESTED_RANGE_NOT_SATISFIABLE = 416,
+    EXPECTATION_FAILED = 417,
+    I_AM_A_TEAPOT = 418,
+    MISDIRECTED = 421,
+    UNPROCESSABLE_ENTITY = 422,
+    FAILED_DEPENDENCY = 424,
+    PRECONDITION_REQUIRED = 428,
+    TOO_MANY_REQUESTS = 429,
+    INTERNAL_SERVER_ERROR = 500,
+    NOT_IMPLEMENTED = 501,
+    BAD_GATEWAY = 502,
+    SERVICE_UNAVAILABLE = 503,
+    GATEWAY_TIMEOUT = 504,
+    HTTP_VERSION_NOT_SUPPORTED = 505
+}

package/dist/types.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpStatus = exports.HttpMethod = void 0;
+var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["GET"] = "GET";
+    HttpMethod["POST"] = "POST";
+    HttpMethod["PUT"] = "PUT";
+    HttpMethod["PATCH"] = "PATCH";
+    HttpMethod["DELETE"] = "DELETE";
+    HttpMethod["HEAD"] = "HEAD";
+    HttpMethod["OPTIONS"] = "OPTIONS";
+})(HttpMethod || (exports.HttpMethod = HttpMethod = {}));
+var HttpStatus;
+(function (HttpStatus) {
+    HttpStatus[HttpStatus["NULL"] = 0] = "NULL";
+    HttpStatus[HttpStatus["CONTINUE"] = 100] = "CONTINUE";
+    HttpStatus[HttpStatus["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
+    HttpStatus[HttpStatus["PROCESSING"] = 102] = "PROCESSING";
+    HttpStatus[HttpStatus["EARLYHINTS"] = 103] = "EARLYHINTS";
+    HttpStatus[HttpStatus["OK"] = 200] = "OK";
+    HttpStatus[HttpStatus["CREATED"] = 201] = "CREATED";
+    HttpStatus[HttpStatus["ACCEPTED"] = 202] = "ACCEPTED";
+    HttpStatus[HttpStatus["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
+    HttpStatus[HttpStatus["NO_CONTENT"] = 204] = "NO_CONTENT";
+    HttpStatus[HttpStatus["RESET_CONTENT"] = 205] = "RESET_CONTENT";
+    HttpStatus[HttpStatus["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
+    HttpStatus[HttpStatus["AMBIGUOUS"] = 300] = "AMBIGUOUS";
+    HttpStatus[HttpStatus["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+    HttpStatus[HttpStatus["FOUND"] = 302] = "FOUND";
+    HttpStatus[HttpStatus["SEE_OTHER"] = 303] = "SEE_OTHER";
+    HttpStatus[HttpStatus["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
+    HttpStatus[HttpStatus["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
+    HttpStatus[HttpStatus["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
+    HttpStatus[HttpStatus["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    HttpStatus[HttpStatus["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+    HttpStatus[HttpStatus["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
+    HttpStatus[HttpStatus["FORBIDDEN"] = 403] = "FORBIDDEN";
+    HttpStatus[HttpStatus["NOT_FOUND"] = 404] = "NOT_FOUND";
+    HttpStatus[HttpStatus["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+    HttpStatus[HttpStatus["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+    HttpStatus[HttpStatus["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
+    HttpStatus[HttpStatus["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+    HttpStatus[HttpStatus["CONFLICT"] = 409] = "CONFLICT";
+    HttpStatus[HttpStatus["GONE"] = 410] = "GONE";
+    HttpStatus[HttpStatus["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
+    HttpStatus[HttpStatus["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+    HttpStatus[HttpStatus["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+    HttpStatus[HttpStatus["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
+    HttpStatus[HttpStatus["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+    HttpStatus[HttpStatus["REQUESTED_RANGE_NOT_SATISFIABLE"] = 416] = "REQUESTED_RANGE_NOT_SATISFIABLE";
+    HttpStatus[HttpStatus["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
+    HttpStatus[HttpStatus["I_AM_A_TEAPOT"] = 418] = "I_AM_A_TEAPOT";
+    HttpStatus[HttpStatus["MISDIRECTED"] = 421] = "MISDIRECTED";
+    HttpStatus[HttpStatus["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+    HttpStatus[HttpStatus["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
+    HttpStatus[HttpStatus["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
+    HttpStatus[HttpStatus["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+    HttpStatus[HttpStatus["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+    HttpStatus[HttpStatus["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+    HttpStatus[HttpStatus["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+    HttpStatus[HttpStatus["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+    HttpStatus[HttpStatus["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+    HttpStatus[HttpStatus["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
+})(HttpStatus || (exports.HttpStatus = HttpStatus = {}));