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

package/mjs/client/fetcher.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetcher = exports.DEFAULT_ERROR_MESSAGE = void 0;
+exports.createFetcher = createFetcher;
+const types_1 = require("../types");
+const HttpException_1 = require("../HttpException");
+exports.DEFAULT_ERROR_MESSAGE = 'Unknown error at default fetcher';
+function createFetcher({ prepareRequestInit, transformResponse, onSuccess, onError, } = {}) {
+    // fetcher uses HttpException class to throw errors of fake HTTP status 0 if client-side error occurs
+    // For normal HTTP errors, it uses message and status code from the response of VovkErrorResponse type
+    const newFetcher = async ({ httpMethod, getEndpoint, validate, defaultHandler, defaultStreamHandler, schema }, inputOptions) => {
+        let response = null;
+        let respData = null;
+        let requestInit = null;
+        try {
+            const { meta, apiRoot, disableClientValidation, init, interpretAs } = inputOptions;
+            let { body, query, params } = inputOptions;
+            const endpoint = getEndpoint({ apiRoot, params, query });
+            const unusedParams = Array.from(new URL(endpoint.startsWith('/') ? `http://localhost${endpoint}` : endpoint).pathname.matchAll(/\{([^}]+)\}/g)).map((m) => m[1]);
+            if (unusedParams.length) {
+                throw new HttpException_1.HttpException(types_1.HttpStatus.NULL, `Unused params: ${unusedParams.join(', ')} in ${endpoint}`, {
+                    body,
+                    query,
+                    params,
+                    endpoint,
+                });
+            }
+            if (!disableClientValidation) {
+                try {
+                    ({ body, query, params } = (await validate(inputOptions, { endpoint })) ?? { body, query, params });
+                }
+                catch (e) {
+                    // if HttpException is thrown, rethrow it
+                    if (e instanceof HttpException_1.HttpException)
+                        throw e;
+                    // otherwise, throw HttpException with status 0
+                    throw new HttpException_1.HttpException(types_1.HttpStatus.NULL, e.message ?? exports.DEFAULT_ERROR_MESSAGE, {
+                        body,
+                        query,
+                        params,
+                        endpoint,
+                    });
+                }
+            }
+            requestInit = {
+                method: httpMethod,
+                ...init,
+                headers: {
+                    accept: 'application/jsonl, application/json',
+                    ...(body instanceof FormData ? {} : { 'content-type': 'application/json' }),
+                    ...(meta ? { 'x-meta': JSON.stringify(meta) } : {}),
+                    ...init?.headers,
+                },
+            };
+            if (body instanceof FormData) {
+                requestInit.body = body;
+            }
+            else if (body) {
+                requestInit.body = JSON.stringify(body);
+            }
+            const abortController = new AbortController();
+            requestInit.signal = abortController.signal;
+            requestInit = prepareRequestInit ? await prepareRequestInit(requestInit, inputOptions) : requestInit;
+            try {
+                response = await fetch(endpoint, requestInit);
+            }
+            catch (e) {
+                // handle network errors
+                throw new HttpException_1.HttpException(types_1.HttpStatus.NULL, (e?.message ?? exports.DEFAULT_ERROR_MESSAGE) + ' ' + endpoint, {
+                    body,
+                    query,
+                    params,
+                    endpoint,
+                });
+            }
+            const contentType = interpretAs ?? response.headers.get('content-type');
+            if (contentType?.startsWith('application/jsonl')) {
+                respData = defaultStreamHandler({ response, abortController, schema });
+            }
+            else if (contentType?.startsWith('application/json')) {
+                respData = await defaultHandler({ response, schema });
+            }
+            else {
+                respData = response;
+            }
+            respData = transformResponse ? await transformResponse(respData, inputOptions, response, requestInit) : respData;
+            await onSuccess?.(respData, inputOptions, response, requestInit);
+            return [respData, response];
+        }
+        catch (error) {
+            await onError?.(error, inputOptions, response, requestInit, respData);
+            throw error;
+        }
+    };
+    return newFetcher;
+}
+exports.fetcher = createFetcher();

package/mjs/client/index.d.ts

@@ -0,0 +1,4 @@
+export { createRPC } from './createRPC';
+export { fetcher, createFetcher } from './fetcher';
+export { progressive } from './progressive';
+export type { VovkRPCModule, VovkFetcher, VovkFetcherOptions, VovkValidateOnClient, VovkStreamAsyncIterable, } from './types';

package/mjs/client/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.progressive = exports.createFetcher = exports.fetcher = exports.createRPC = void 0;
+var createRPC_1 = require("./createRPC");
+Object.defineProperty(exports, "createRPC", { enumerable: true, get: function () { return createRPC_1.createRPC; } });
+var fetcher_1 = require("./fetcher");
+Object.defineProperty(exports, "fetcher", { enumerable: true, get: function () { return fetcher_1.fetcher; } });
+Object.defineProperty(exports, "createFetcher", { enumerable: true, get: function () { return fetcher_1.createFetcher; } });
+var progressive_1 = require("./progressive");
+Object.defineProperty(exports, "progressive", { enumerable: true, get: function () { return progressive_1.progressive; } });

package/mjs/client/progressive.d.ts

@@ -0,0 +1,9 @@
+import type { VovkStreamAsyncIterable } from './types';
+import type { KnownAny, VovkYieldType } from '../types';
+type UnionToIntersection<U> = (U extends KnownAny ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type PromisifyProperties<T> = {
+    [K in keyof T]: Promise<T[K]>;
+};
+type TransformUnionToPromises<T> = PromisifyProperties<UnionToIntersection<T>>;
+export declare function progressive<T extends (...args: KnownAny[]) => Promise<VovkStreamAsyncIterable<KnownAny>>>(fn: T, ...args: undefined extends Parameters<T>[0] ? [arg?: Parameters<T>[0]] : [arg: Parameters<T>[0]]): TransformUnionToPromises<VovkYieldType<T>>;
+export {};

package/mjs/client/progressive.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.progressive = progressive;
+function progressive(fn, ...args) {
+    const [arg] = args;
+    const reg = {};
+    void fn(arg)
+        .then(async (result) => {
+        for await (const item of result) {
+            for (const [key, value] of Object.entries(item)) {
+                if (key in reg) {
+                    if (!reg[key].isSettled) {
+                        reg[key].isSettled = true;
+                        reg[key].resolve(value);
+                    }
+                }
+                else {
+                    const { promise, resolve, reject } = Promise.withResolvers();
+                    reg[key] = { resolve, reject, promise, isSettled: true };
+                    reg[key].resolve(value);
+                }
+            }
+        }
+        Object.keys(reg).forEach((key) => {
+            if (reg[key].isSettled)
+                return;
+            reg[key].isSettled = true;
+            reg[key].reject(new Error(`The connection was closed without sending a value for "${key}"`));
+        });
+        return result;
+    })
+        .catch((error) => {
+        Object.keys(reg).forEach((key) => {
+            if (reg[key].isSettled)
+                return;
+            reg[key].isSettled = true;
+            reg[key].reject(error);
+        });
+        return error;
+    });
+    return new Proxy({}, {
+        get(_target, prop) {
+            if (prop in reg) {
+                return reg[prop].promise;
+            }
+            const { promise, resolve, reject } = Promise.withResolvers();
+            reg[prop] = { resolve, reject, promise, isSettled: false };
+            return promise;
+        },
+        ownKeys: () => {
+            throw new Error('Getting own keys is not possible as they are dynamically created');
+        },
+    });
+}

package/mjs/client/types.d.ts

@@ -0,0 +1,120 @@
+import type { NextResponse } from 'next/server';
+import type { KnownAny, HttpMethod, ControllerStaticMethod, VovkHandlerSchema, VovkControllerSchema, VovkSegmentSchema, VovkSchema, VovkRequest, Prettify, IsEmptyObject } from '../types';
+import type { JSONLinesResponse } from '../JSONLinesResponse';
+import type { defaultStreamHandler } from './defaultStreamHandler';
+import type { defaultHandler } from './defaultHandler';
+type OmitNullable<T> = {
+    [K in keyof T as T[K] extends null | undefined ? never : K]: T[K];
+};
+type Empty = {};
+export type StaticMethodInput<T extends ((req: VovkRequest<KnownAny, KnownAny, KnownAny>, params: KnownAny) => KnownAny) & {
+    __types?: {
+        isForm: boolean;
+    };
+}> = OmitNullable<(Parameters<T>[0] extends VovkRequest<infer TBody, infer TQuery, infer TParams> ? (TBody extends Record<KnownAny, KnownAny> ? {
+    body: T['__types'] extends {
+        isForm: true;
+    } ? FormData : TBody;
+} : Empty) & (TQuery extends Record<KnownAny, KnownAny> ? {
+    query: TQuery;
+} : Empty) & (TParams extends Record<KnownAny, KnownAny> ? {
+    params: TParams;
+} : Empty) & {
+    meta?: {
+        [key: string]: KnownAny;
+    };
+} : Empty) & (Parameters<T>[1] extends Record<KnownAny, KnownAny> ? {
+    params: Parameters<T>[1];
+} : Empty)>;
+type ToPromise<T> = T extends PromiseLike<unknown> ? T : Promise<T>;
+export type VovkStreamAsyncIterable<T> = {
+    status: number;
+    asPromise: () => Promise<T[]>;
+    [Symbol.dispose](): Promise<void> | void;
+    [Symbol.asyncDispose](): Promise<void> | void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    onIterate: (cb: (data: T, i: number) => void) => () => void;
+    abortController: AbortController;
+};
+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 StaticMethodOptions<T extends (req: VovkRequest<KnownAny, KnownAny, KnownAny>, params: KnownAny) => void | object | JSONLinesResponse<TStreamIteration> | Promise<JSONLinesResponse<TStreamIteration>>, TFetcherOptions extends Record<string, KnownAny>, TStreamIteration, R, F extends VovkFetcherOptions<KnownAny>> = Partial<TFetcherOptions & {
+    transform: (staticMethodReturn: Awaited<StaticMethodReturn<T>>, resp: Response) => R;
+    fetcher: VovkFetcher<F>;
+}>;
+export type ClientMethodReturn<T extends (req: VovkRequest<KnownAny, KnownAny, KnownAny>, params: KnownAny) => void | object | JSONLinesResponse<TStreamIteration> | Promise<JSONLinesResponse<TStreamIteration>>, TStreamIteration, R> = ReturnType<T> extends Promise<JSONLinesResponse<infer U>> | JSONLinesResponse<infer U> | Iterator<infer U> | AsyncIterator<infer U> ? Promise<VovkStreamAsyncIterable<U>> : R extends object ? Promise<Awaited<R>> : StaticMethodReturnPromise<T>;
+export type ClientMethod<T extends ((req: VovkRequest<KnownAny, KnownAny, KnownAny>, params: KnownAny) => void | object | JSONLinesResponse<TStreamIteration> | Promise<JSONLinesResponse<TStreamIteration>>) & {
+    __types?: {
+        body: KnownAny;
+        query: KnownAny;
+        params: KnownAny;
+        output: KnownAny;
+        iteration: KnownAny;
+        isForm: boolean;
+    };
+}, TFetcherOptions extends Record<string, KnownAny>, TStreamIteration extends KnownAny = unknown> = (IsEmptyObject<StaticMethodInput<T>> extends true ? <R, F extends VovkFetcherOptions<KnownAny> = VovkFetcherOptions<TFetcherOptions>>(options?: Prettify<StaticMethodOptions<T, TFetcherOptions, TStreamIteration, R, F>>) => ClientMethodReturn<T, TStreamIteration, R> : <R, F extends VovkFetcherOptions<KnownAny> = VovkFetcherOptions<TFetcherOptions>>(options: Prettify<StaticMethodInput<T> & StaticMethodOptions<T, TFetcherOptions, TStreamIteration, R, F>>) => ClientMethodReturn<T, TStreamIteration, R>) & {
+    isRPC: true;
+    schema: VovkHandlerSchema;
+    controllerSchema: VovkControllerSchema;
+    segmentSchema: VovkSegmentSchema;
+    fullSchema: VovkSchema;
+    path: string;
+    apiRoot: string;
+    queryKey: (key?: unknown[]) => unknown[];
+    __types: T['__types'];
+};
+type OmitNever<T> = {
+    [K in keyof T as T[K] extends never ? never : K]: T[K];
+};
+type VovkClientWithNever<T, TFetcherOptions extends {
+    [key: string]: KnownAny;
+}> = {
+    [K in keyof T]: T[K] extends (...args: KnownAny) => KnownAny ? ClientMethod<T[K], TFetcherOptions> : never;
+};
+export type VovkRPCModule<T, TFetcherOptions extends {
+    [key: string]: KnownAny;
+}> = OmitNever<VovkClientWithNever<T, TFetcherOptions>>;
+export type VovkFetcher<TFetcherOptions> = (options: {
+    name: string;
+    httpMethod: HttpMethod;
+    getEndpoint: (data: {
+        apiRoot: string | undefined;
+        params: unknown;
+        query: unknown;
+    }) => string;
+    validate: (inputOptions: {
+        body?: unknown;
+        query?: unknown;
+        params?: unknown;
+        meta?: unknown;
+    } & TFetcherOptions, meta: {
+        endpoint: string;
+    }) => KnownAny | Promise<KnownAny>;
+    defaultStreamHandler: typeof defaultStreamHandler;
+    defaultHandler: typeof defaultHandler;
+    schema: VovkHandlerSchema;
+}, input: {
+    body?: unknown;
+    query?: unknown;
+    params?: unknown;
+    meta?: unknown;
+} & TFetcherOptions) => Promise<[KnownAny, Response]>;
+export type VovkFetcherOptions<T> = T & {
+    apiRoot?: string;
+    disableClientValidation?: boolean;
+    validateOnClient?: VovkValidateOnClient<T> | Promise<{
+        validateOnClient: VovkValidateOnClient<T>;
+    }>;
+    interpretAs?: string;
+    init?: RequestInit;
+};
+export type VovkValidateOnClient<TFetcherOptions> = (input: {
+    body?: unknown;
+    query?: unknown;
+    params?: unknown;
+    meta?: unknown;
+} & TFetcherOptions, validation: Omit<Exclude<VovkHandlerSchema['validation'], undefined>, 'output' | 'iteration'>, meta: {
+    fullSchema: VovkSchema;
+    endpoint: string;
+}) => KnownAny | Promise<KnownAny>;
+export {};

package/mjs/createVovkApp.d.ts

@@ -0,0 +1,65 @@
+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): (givenTarget: KnownAny, propertyKey: string) => void;
+        auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+    };
+    post: {
+        (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: KnownAny, propertyKey: string) => void;
+        auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+    };
+    put: {
+        (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: KnownAny, propertyKey: string) => void;
+        auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+    };
+    patch: {
+        (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: KnownAny, propertyKey: string) => void;
+        auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+    };
+    del: {
+        (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: KnownAny, propertyKey: string) => void;
+        auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+    };
+    head: {
+        (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: KnownAny, propertyKey: string) => void;
+        auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+    };
+    options: {
+        (givenPath?: string | undefined, options?: Omit<DecoratorOptions, "staticParams"> | undefined): (givenTarget: KnownAny, propertyKey: string) => void;
+        auto: (options?: DecoratorOptions) => (givenTarget: KnownAny, propertyKey: string) => void;
+    };
+    prefix: (givenPath?: string) => (givenTarget: KnownAny) => any;
+    initSegment: (options: {
+        segmentName?: string;
+        controllers: Record<string, StaticClass>;
+        exposeValidation?: boolean;
+        emitSchema?: boolean;
+        forceApiRoot?: string;
+        onError?: (err: Error, req: VovkRequest) => void | Promise<void>;
+        onSuccess?: (resp: unknown, req: VovkRequest) => void | Promise<void>;
+        onBefore?: (req: VovkRequest) => void | Promise<void>;
+    }) => {
+        GET: (req: NextRequest, data: {
+            params: Promise<Record<string, string[]>>;
+        }) => Promise<Response>;
+        POST: (req: NextRequest, data: {
+            params: Promise<Record<string, string[]>>;
+        }) => Promise<Response>;
+        PUT: (req: NextRequest, data: {
+            params: Promise<Record<string, string[]>>;
+        }) => Promise<Response>;
+        PATCH: (req: NextRequest, data: {
+            params: Promise<Record<string, string[]>>;
+        }) => Promise<Response>;
+        DELETE: (req: NextRequest, data: {
+            params: Promise<Record<string, string[]>>;
+        }) => Promise<Response>;
+        HEAD: (req: NextRequest, data: {
+            params: Promise<Record<string, string[]>>;
+        }) => Promise<Response>;
+        OPTIONS: (req: NextRequest, data: {
+            params: Promise<Record<string, string[]>>;
+        }) => Promise<Response>;
+    };
+};

package/mjs/createVovkApp.js

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

package/mjs/index.d.ts

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

package/mjs/index.js

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

package/mjs/openapi/error.d.ts

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