vovk 3.0.0-draft.21 → 3.0.0-draft.211

package/cjs/client/fetcher.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetcher = exports.DEFAULT_ERROR_MESSAGE = void 0;
+exports.createFetcher = createFetcher;
+const types_js_1 = require("../types.js");
+const HttpException_js_1 = require("../HttpException.js");
+exports.DEFAULT_ERROR_MESSAGE = 'Unknown error at default fetcher';
+function createFetcher({ prepareRequestInit, transformResponse, } = {}) {
+    // 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 }, options) => {
+        const { params, query, body, apiRoot, disableClientValidation, init, interpretAs } = options;
+        const endpoint = getEndpoint({ apiRoot, params, query });
+        const unusedParams = new URL(endpoint.startsWith('/') ? `http://localhost${endpoint}` : endpoint).pathname
+            .split('/')
+            .filter((segment) => segment.startsWith(':'));
+        if (unusedParams.length) {
+            throw new HttpException_js_1.HttpException(types_js_1.HttpStatus.NULL, `Unused params: ${unusedParams.join(', ')} in ${endpoint}`, {
+                body,
+                query,
+                params,
+                endpoint,
+            });
+        }
+        if (!disableClientValidation) {
+            try {
+                await validate({ body, query, params, endpoint });
+            }
+            catch (e) {
+                // if HttpException is thrown, rethrow it
+                if (e instanceof HttpException_js_1.HttpException)
+                    throw e;
+                // otherwise, throw HttpException with status 0
+                throw new HttpException_js_1.HttpException(types_js_1.HttpStatus.NULL, e.message ?? exports.DEFAULT_ERROR_MESSAGE, {
+                    body,
+                    query,
+                    params,
+                    endpoint,
+                });
+            }
+        }
+        let requestInit = {
+            method: httpMethod,
+            ...init,
+            headers: {
+                accept: 'application/jsonl, application/json',
+                ...init?.headers,
+            },
+        };
+        if (body instanceof FormData) {
+            requestInit.body = body;
+        }
+        else if (body) {
+            requestInit.body = JSON.stringify(body);
+        }
+        requestInit = prepareRequestInit
+            ? ((await prepareRequestInit(requestInit, options)) ?? requestInit)
+            : requestInit;
+        let response;
+        try {
+            response = await fetch(endpoint, requestInit);
+        }
+        catch (e) {
+            // handle network errors
+            throw new HttpException_js_1.HttpException(types_js_1.HttpStatus.NULL, (e?.message ?? exports.DEFAULT_ERROR_MESSAGE) + ' ' + endpoint, {
+                body,
+                query,
+                params,
+                endpoint,
+            });
+        }
+        const contentType = interpretAs ?? response.headers.get('content-type');
+        let resp;
+        if (contentType?.startsWith('application/jsonl')) {
+            resp = defaultStreamHandler(response);
+        }
+        else if (contentType?.startsWith('application/json')) {
+            resp = defaultHandler(response);
+        }
+        else {
+            resp = response;
+        }
+        resp = await resp;
+        return transformResponse
+            ? ((await transformResponse(resp, options, requestInit)) ?? resp)
+            : resp;
+    };
+    return newFetcher;
+}
+exports.fetcher = createFetcher();

package/cjs/client/index.d.ts

@@ -0,0 +1,3 @@
+export { createRPC } from './createRPC.js';
+export { fetcher, createFetcher } from './fetcher.js';
+export type { VovkClient, VovkClientFetcher, VovkDefaultFetcherOptions, VovkValidateOnClient, VovkStreamAsyncIterable, } from './types.js';

package/cjs/client/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFetcher = exports.fetcher = exports.createRPC = void 0;
+var createRPC_js_1 = require("./createRPC.js");
+Object.defineProperty(exports, "createRPC", { enumerable: true, get: function () { return createRPC_js_1.createRPC; } });
+var fetcher_js_1 = require("./fetcher.js");
+Object.defineProperty(exports, "fetcher", { enumerable: true, get: function () { return fetcher_js_1.fetcher; } });
+Object.defineProperty(exports, "createFetcher", { enumerable: true, get: function () { return fetcher_js_1.createFetcher; } });

package/cjs/client/types.d.ts

@@ -0,0 +1,111 @@
+import type { KnownAny, HttpMethod, ControllerStaticMethod, VovkHandlerSchema, VovkControllerSchema, VovkSegmentSchema, VovkSchema, VovkRequest } from '../types.js';
+import type { JSONLinesResponse } from '../JSONLinesResponse.js';
+import type { NextResponse } from 'next/server';
+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 BODY, infer QUERY, infer PARAMS> ? (BODY extends Record<KnownAny, KnownAny> ? {
+    body: NonNullable<T['__types']>['isForm'] extends true ? FormData : BODY;
+} : Empty) & (QUERY extends Record<KnownAny, KnownAny> ? {
+    query: QUERY;
+} : Empty) & (PARAMS extends Record<KnownAny, KnownAny> ? {
+    params: PARAMS;
+} : Empty) : 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;
+    [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 StaticMethodOptions<T extends (req: VovkRequest<KnownAny, KnownAny, KnownAny>, params: KnownAny) => void | object | JSONLinesResponse<STREAM> | Promise<JSONLinesResponse<STREAM>>, OPTS extends Record<string, KnownAny>, STREAM, R, F extends VovkDefaultFetcherOptions<KnownAny>> = Partial<OPTS & {
+    transform: (staticMethodReturn: Awaited<StaticMethodReturn<T>>) => R;
+    fetcher: VovkClientFetcher<F>;
+}>;
+type ClientMethodReturn<T extends (req: VovkRequest<KnownAny, KnownAny, KnownAny>, params: KnownAny) => void | object | JSONLinesResponse<STREAM> | Promise<JSONLinesResponse<STREAM>>, STREAM, 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>;
+type ClientMethod<T extends ((req: VovkRequest<KnownAny, KnownAny, KnownAny>, params: KnownAny) => void | object | JSONLinesResponse<STREAM> | Promise<JSONLinesResponse<STREAM>>) & {
+    __types?: {
+        body: KnownAny;
+        query: KnownAny;
+        params: KnownAny;
+        output: KnownAny;
+        iteration: KnownAny;
+        isForm: boolean;
+    };
+}, OPTS extends Record<string, KnownAny>, STREAM extends KnownAny = unknown> = (IsEmptyObject<StaticMethodInput<T>> extends true ? <R, F extends VovkDefaultFetcherOptions<KnownAny> = VovkDefaultFetcherOptions<OPTS>>(options?: Prettify<StaticMethodOptions<T, OPTS, STREAM, R, F>>) => ClientMethodReturn<T, STREAM, R> : <R, F extends VovkDefaultFetcherOptions<KnownAny> = VovkDefaultFetcherOptions<OPTS>>(options: Prettify<StaticMethodInput<T> & StaticMethodOptions<T, OPTS, STREAM, R, F>>) => ClientMethodReturn<T, STREAM, R>) & {
+    isRPC: true;
+    path: string;
+    schema: VovkHandlerSchema;
+    controllerSchema: VovkControllerSchema;
+    segmentSchema: VovkSegmentSchema;
+    fullSchema: VovkSchema;
+    __types: T['__types'];
+};
+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> = (options: {
+    name: string;
+    httpMethod: HttpMethod;
+    getEndpoint: (data: {
+        apiRoot: string | undefined;
+        params: {
+            [key: string]: string;
+        };
+        query: {
+            [key: string]: string;
+        };
+    }) => string;
+    validate: (input: {
+        body?: unknown;
+        query?: unknown;
+        params?: 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 type VovkDefaultFetcherOptions<T> = T & {
+    apiRoot?: string;
+    disableClientValidation?: boolean;
+    validateOnClient?: VovkValidateOnClient;
+    interpretAs?: string;
+    init?: RequestInit;
+};
+export type VovkValidateOnClient = (input: {
+    body?: unknown;
+    query?: unknown;
+    params?: unknown;
+    endpoint: string;
+}, validation: Omit<Exclude<VovkHandlerSchema['validation'], undefined>, 'output' | 'iteration'>, fullSchema: VovkSchema) => void | Promise<void>;
+type IsEmptyObject<T> = T extends object ? keyof T extends never ? true : false : false;
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export {};

package/{createSegment.d.ts → cjs/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.js';
+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,30 @@ export declare function _createSegment(): {
     initVovk: (options: {
         segmentName?: string;
         controllers: Record<string, StaticClass>;
-        workers?: Record<string, StaticClass>;
         exposeValidation?: boolean;
         emitSchema?: boolean;
+        forceApiRoot?: string;
         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/cjs/createVovkApp.js

@@ -0,0 +1,132 @@
+"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_js_1 = require("./VovkApp.js");
+const types_js_1 = require("./types.js");
+const getSchema_js_1 = __importDefault(require("./utils/getSchema.js"));
+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('Decorators are intended for server-side use only. You have probably imported a controller on the client-side.');
+    }
+    if (!isClass(controller)) {
+        let decoratorName = httpMethod.toLowerCase();
+        if (decoratorName === 'delete')
+            decoratorName = 'del';
+        throw new Error(`Decorator must be used on a static class method. Check the controller method named "${propertyKey}" used with @${decoratorName}().`);
+    }
+    const methods = vovkApp.routes[httpMethod].get(controller) ?? {};
+    vovkApp.routes[httpMethod].set(controller, methods);
+    const originalMethod = controller[propertyKey];
+    originalMethod._controller = controller;
+    originalMethod._sourceMethod = originalMethod._sourceMethod ?? originalMethod;
+    const schema = originalMethod._sourceMethod._getSchema?.(controller);
+    originalMethod.schema = schema;
+    originalMethod.func = originalMethod._sourceMethod?.func;
+    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_js_1.VovkApp();
+    const createHTTPDecorator = (httpMethod) => {
+        function decoratorCreator(givenPath = '', options) {
+            const path = trimPath(givenPath);
+            function decorator(givenTarget, propertyKey) {
+                const controller = givenTarget;
+                assignSchema({ controller, propertyKey, path, options, httpMethod, vovkApp });
+            }
+            return decorator;
+        }
+        const auto = (options) => {
+            function decorator(givenTarget, propertyKey) {
+                const controller = givenTarget;
+                const methods = vovkApp.routes[httpMethod].get(controller) ?? {};
+                vovkApp.routes[httpMethod].set(controller, methods);
+                controller._handlers = {
+                    ...controller._handlers,
+                    [propertyKey]: {
+                        ...(controller._handlers ?? {})[propertyKey],
+                        httpMethod,
+                    },
+                };
+                const properties = Object.keys(controller._handlers[propertyKey]?.validation?.params?.properties ?? {});
+                const kebab = toKebabCase(propertyKey); // 🥙
+                const path = properties.length ? `${kebab}/${properties.map((prop) => `:${prop}`).join('/')}` : kebab;
+                assignSchema({ controller, propertyKey, path, options, httpMethod, vovkApp });
+            }
+            return decorator;
+        };
+        const enhancedDecoratorCreator = decoratorCreator;
+        enhancedDecoratorCreator.auto = auto;
+        return enhancedDecoratorCreator;
+    };
+    const prefix = (givenPath = '') => {
+        const path = trimPath(givenPath);
+        return (givenTarget) => {
+            const controller = givenTarget;
+            controller._prefix = path;
+            return givenTarget;
+        };
+    };
+    const initVovk = (options) => {
+        options.segmentName = trimPath(options.segmentName ?? '');
+        for (const [rpcModuleName, controller] of Object.entries(options.controllers ?? {})) {
+            controller._rpcModuleName = rpcModuleName;
+            controller._activated = true;
+            controller._onError = options?.onError;
+        }
+        async function GET_DEV(req, data) {
+            const params = await data.params;
+            if (params[Object.keys(params)[0]]?.[0] === '_schema_') {
+                const schema = await (0, getSchema_js_1.default)(options);
+                return vovkApp.respond(200, { schema });
+            }
+            return vovkApp.GET(req, data);
+        }
+        return {
+            GET: process.env.NODE_ENV === 'development' ? GET_DEV : vovkApp.GET,
+            POST: vovkApp.POST,
+            PUT: vovkApp.PUT,
+            PATCH: vovkApp.PATCH,
+            DELETE: vovkApp.DELETE,
+            HEAD: vovkApp.HEAD,
+            OPTIONS: vovkApp.OPTIONS,
+        };
+    };
+    return {
+        get: createHTTPDecorator(types_js_1.HttpMethod.GET),
+        post: createHTTPDecorator(types_js_1.HttpMethod.POST),
+        put: createHTTPDecorator(types_js_1.HttpMethod.PUT),
+        patch: createHTTPDecorator(types_js_1.HttpMethod.PATCH),
+        del: createHTTPDecorator(types_js_1.HttpMethod.DELETE),
+        head: createHTTPDecorator(types_js_1.HttpMethod.HEAD),
+        options: createHTTPDecorator(types_js_1.HttpMethod.OPTIONS),
+        prefix,
+        initVovk,
+    };
+}

package/cjs/index.d.ts

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

package/cjs/index.js

@@ -0,0 +1,37 @@
+"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.vovkSchemaToOpenAPI = exports.openAPIToVovkSchema = exports.openapi = exports.createCodeExamples = exports.createLLMFunctions = exports.multitenant = exports.withStandard = exports.withValidationLibrary = exports.generateStaticAPI = exports.createFetcher = exports.fetcher = exports.createRPC = exports.createDecorator = exports.createVovkApp = exports.HttpMethod = exports.HttpStatus = exports.HttpException = exports.JSONLinesResponse = exports.VovkSchemaIdEnum = void 0;
+const createVovkApp_1 = require("./createVovkApp");
+Object.defineProperty(exports, "createVovkApp", { enumerable: true, get: function () { return createVovkApp_1.createVovkApp; } });
+const types_1 = require("./types");
+Object.defineProperty(exports, "HttpStatus", { enumerable: true, get: function () { return types_1.HttpStatus; } });
+Object.defineProperty(exports, "HttpMethod", { enumerable: true, get: function () { return types_1.HttpMethod; } });
+Object.defineProperty(exports, "VovkSchemaIdEnum", { enumerable: true, get: function () { return types_1.VovkSchemaIdEnum; } });
+const index_1 = require("./client/index");
+Object.defineProperty(exports, "createRPC", { enumerable: true, get: function () { return index_1.createRPC; } });
+Object.defineProperty(exports, "fetcher", { enumerable: true, get: function () { return index_1.fetcher; } });
+Object.defineProperty(exports, "createFetcher", { enumerable: true, get: function () { return index_1.createFetcher; } });
+const index_2 = require("./openapi/index");
+Object.defineProperty(exports, "openapi", { enumerable: true, get: function () { return index_2.openapi; } });
+Object.defineProperty(exports, "openAPIToVovkSchema", { enumerable: true, get: function () { return index_2.openAPIToVovkSchema; } });
+Object.defineProperty(exports, "vovkSchemaToOpenAPI", { enumerable: true, get: function () { return index_2.vovkSchemaToOpenAPI; } });
+const HttpException_1 = require("./HttpException");
+Object.defineProperty(exports, "HttpException", { enumerable: true, get: function () { return HttpException_1.HttpException; } });
+const createDecorator_1 = require("./utils/createDecorator");
+Object.defineProperty(exports, "createDecorator", { enumerable: true, get: function () { return createDecorator_1.createDecorator; } });
+const JSONLinesResponse_1 = require("./JSONLinesResponse");
+Object.defineProperty(exports, "JSONLinesResponse", { enumerable: true, get: function () { return JSONLinesResponse_1.JSONLinesResponse; } });
+const generateStaticAPI_1 = require("./utils/generateStaticAPI");
+Object.defineProperty(exports, "generateStaticAPI", { enumerable: true, get: function () { return generateStaticAPI_1.generateStaticAPI; } });
+const withValidationLibrary_1 = require("./utils/withValidationLibrary");
+Object.defineProperty(exports, "withValidationLibrary", { enumerable: true, get: function () { return withValidationLibrary_1.withValidationLibrary; } });
+const withStandard_1 = require("./utils/withStandard");
+Object.defineProperty(exports, "withStandard", { enumerable: true, get: function () { return withStandard_1.withStandard; } });
+const multitenant_1 = require("./utils/multitenant");
+Object.defineProperty(exports, "multitenant", { enumerable: true, get: function () { return multitenant_1.multitenant; } });
+const createLLMFunctions_1 = require("./utils/createLLMFunctions");
+Object.defineProperty(exports, "createLLMFunctions", { enumerable: true, get: function () { return createLLMFunctions_1.createLLMFunctions; } });
+const createCodeExamples_1 = require("./utils/createCodeExamples");
+Object.defineProperty(exports, "createCodeExamples", { enumerable: true, get: function () { return createCodeExamples_1.createCodeExamples; } });
+_a = (0, createVovkApp_1.createVovkApp)(), exports.get = _a.get, exports.post = _a.post, exports.put = _a.put, exports.patch = _a.patch, exports.del = _a.del, exports.head = _a.head, exports.options = _a.options, exports.prefix = _a.prefix, exports.initVovk = _a.initVovk;

package/cjs/openapi/error.d.ts

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

package/cjs/openapi/error.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.error = void 0;
+const types_1 = require("../types");
+const createDecorator_1 = require("../utils/createDecorator");
+const statusDisplayText = {
+    [types_1.HttpStatus.NULL]: 'Error',
+    [types_1.HttpStatus.CONTINUE]: 'Continue',
+    [types_1.HttpStatus.SWITCHING_PROTOCOLS]: 'Switching Protocols',
+    [types_1.HttpStatus.PROCESSING]: 'Processing',
+    [types_1.HttpStatus.EARLYHINTS]: 'Early Hints',
+    [types_1.HttpStatus.OK]: 'OK',
+    [types_1.HttpStatus.CREATED]: 'Created',
+    [types_1.HttpStatus.ACCEPTED]: 'Accepted',
+    [types_1.HttpStatus.NON_AUTHORITATIVE_INFORMATION]: 'Non Authoritative Information',
+    [types_1.HttpStatus.NO_CONTENT]: 'No Content',
+    [types_1.HttpStatus.RESET_CONTENT]: 'Reset Content',
+    [types_1.HttpStatus.PARTIAL_CONTENT]: 'Partial Content',
+    [types_1.HttpStatus.AMBIGUOUS]: 'Ambiguous',
+    [types_1.HttpStatus.MOVED_PERMANENTLY]: 'Moved Permanently',
+    [types_1.HttpStatus.FOUND]: 'Found',
+    [types_1.HttpStatus.SEE_OTHER]: 'See Other',
+    [types_1.HttpStatus.NOT_MODIFIED]: 'Not Modified',
+    [types_1.HttpStatus.TEMPORARY_REDIRECT]: 'Temporary Redirect',
+    [types_1.HttpStatus.PERMANENT_REDIRECT]: 'Permanent Redirect',
+    [types_1.HttpStatus.BAD_REQUEST]: 'Bad Request',
+    [types_1.HttpStatus.UNAUTHORIZED]: 'Unauthorized',
+    [types_1.HttpStatus.PAYMENT_REQUIRED]: 'Payment Required',
+    [types_1.HttpStatus.FORBIDDEN]: 'Forbidden',
+    [types_1.HttpStatus.NOT_FOUND]: 'Not Found',
+    [types_1.HttpStatus.METHOD_NOT_ALLOWED]: 'Method Not Allowed',
+    [types_1.HttpStatus.NOT_ACCEPTABLE]: 'Not Acceptable',
+    [types_1.HttpStatus.PROXY_AUTHENTICATION_REQUIRED]: 'Proxy Authentication Required',
+    [types_1.HttpStatus.REQUEST_TIMEOUT]: 'Request Timeout',
+    [types_1.HttpStatus.CONFLICT]: 'Conflict',
+    [types_1.HttpStatus.GONE]: 'Gone',
+    [types_1.HttpStatus.LENGTH_REQUIRED]: 'Length Required',
+    [types_1.HttpStatus.PRECONDITION_FAILED]: 'Precondition Failed',
+    [types_1.HttpStatus.PAYLOAD_TOO_LARGE]: 'Payload Too Large',
+    [types_1.HttpStatus.URI_TOO_LONG]: 'URI Too Long',
+    [types_1.HttpStatus.UNSUPPORTED_MEDIA_TYPE]: 'Unsupported Media Type',
+    [types_1.HttpStatus.REQUESTED_RANGE_NOT_SATISFIABLE]: 'Requested Range Not Satisfiable',
+    [types_1.HttpStatus.EXPECTATION_FAILED]: 'Expectation Failed',
+    [types_1.HttpStatus.I_AM_A_TEAPOT]: 'I am a teapot',
+    [types_1.HttpStatus.MISDIRECTED]: 'Misdirected',
+    [types_1.HttpStatus.UNPROCESSABLE_ENTITY]: 'Unprocessable Entity',
+    [types_1.HttpStatus.FAILED_DEPENDENCY]: 'Failed Dependency',
+    [types_1.HttpStatus.PRECONDITION_REQUIRED]: 'Precondition Required',
+    [types_1.HttpStatus.TOO_MANY_REQUESTS]: 'Too Many Requests',
+    [types_1.HttpStatus.INTERNAL_SERVER_ERROR]: 'Internal Server Error',
+    [types_1.HttpStatus.NOT_IMPLEMENTED]: 'Not Implemented',
+    [types_1.HttpStatus.BAD_GATEWAY]: 'Bad Gateway',
+    [types_1.HttpStatus.SERVICE_UNAVAILABLE]: 'Service Unavailable',
+    [types_1.HttpStatus.GATEWAY_TIMEOUT]: 'Gateway Timeout',
+    [types_1.HttpStatus.HTTP_VERSION_NOT_SUPPORTED]: 'HTTP Version Not Supported',
+};
+exports.error = (0, createDecorator_1.createDecorator)(null, (status, message) => {
+    return (handlerSchema) => {
+        return {
+            ...handlerSchema,
+            openapi: {
+                ...handlerSchema?.openapi,
+                responses: {
+                    ...handlerSchema?.openapi?.responses,
+                    [status]: {
+                        description: `${status} ${statusDisplayText[status]}`,
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    allOf: [
+                                        {
+                                            $ref: '#/components/schemas/VovkErrorResponse',
+                                        },
+                                        {
+                                            type: 'object',
+                                            properties: {
+                                                message: {
+                                                    type: 'string',
+                                                    enum: [
+                                                        message,
+                                                        ...(handlerSchema?.openapi?.responses?.[status]?.content?.['application/json']?.schema
+                                                            ?.allOf?.[1]?.properties?.message?.enum ?? []),
+                                                    ],
+                                                },
+                                                statusCode: {
+                                                    type: 'integer',
+                                                    enum: [status],
+                                                },
+                                            },
+                                        },
+                                    ],
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+    };
+});

package/cjs/openapi/generateFnName.d.ts

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