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

package/cjs/utils/reqForm.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = reqForm;
+const formMap = new WeakMap();
+async function reqForm(req) {
+    if (formMap.has(req)) {
+        return formMap.get(req);
+    }
+    const body = await req.formData();
+    req.formData = () => Promise.resolve(body);
+    const formData = {};
+    for (const [key, value] of body.entries()) {
+        if (value instanceof File) {
+            // If this key already exists, convert to array or append to existing array
+            if (formData[key]) {
+                if (Array.isArray(formData[key])) {
+                    formData[key].push(value);
+                }
+                else {
+                    formData[key] = [formData[key], value];
+                }
+            }
+            else {
+                formData[key] = value;
+            }
+        }
+        else {
+            formData[key] = value.toString();
+        }
+    }
+    formMap.set(req, formData);
+    return formData;
+}

package/{utils → cjs/utils}/reqMeta.d.ts

@@ -1,3 +1,2 @@
-import { VovkRequest } from 'vovk';
-import { _KnownAny as KnownAny } from '../types';
+import type { KnownAny, VovkRequest } from '../types.js';
 export default function reqMeta<T = Record<KnownAny, KnownAny>>(req: VovkRequest<KnownAny, KnownAny>, meta?: T | null): T;

package/cjs/utils/reqQuery.d.ts

@@ -0,0 +1,2 @@
+import type { VovkRequest } from '../types.js';
+export default function reqQuery<T extends object | undefined>(req: VovkRequest<unknown, T>): T;

package/cjs/utils/reqQuery.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = reqQuery;
+const parseQuery_js_1 = __importDefault(require("./parseQuery.js"));
+function reqQuery(req) {
+    return (0, parseQuery_js_1.default)(req.nextUrl.search);
+}

package/cjs/utils/serializeQuery.d.ts

@@ -0,0 +1,13 @@
+import type { KnownAny } from '../types.js';
+/**
+ * Serialize a nested object (including arrays, arrays of objects, etc.)
+ * into a bracket-based query string.
+ *
+ * @example
+ *   serializeQuery({ x: 'xx', y: [1, 2], z: { f: 'x' } })
+ *   => "x=xx&y[0]=1&y[1]=2&z[f]=x"
+ *
+ * @param obj - The input object to be serialized
+ * @returns   - A bracket-based query string (without leading "?")
+ */
+export default function serializeQuery(obj: Record<string, KnownAny>): string;

package/cjs/utils/serializeQuery.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = serializeQuery;
+/**
+ * Recursively build query parameters from an object.
+ *
+ * @param key      - The query key so far (e.g. 'user', 'user[0]', 'user[0][name]')
+ * @param value    - The current value to serialize
+ * @returns        - An array of `key=value` strings
+ */
+function buildParams(key, value) {
+    if (value === null || value === undefined) {
+        return []; // skip null/undefined values entirely
+    }
+    // If value is an object or array, we need to recurse
+    if (typeof value === 'object') {
+        // Array case
+        if (Array.isArray(value)) {
+            /**
+             * We use index-based bracket notation here:
+             *   e.g. for value = ['aa', 'bb'] and key = 'foo'
+             *   => "foo[0]=aa&foo[1]=bb"
+             *
+             * If you prefer "foo[]=aa&foo[]=bb" style, replace:
+             *   `${key}[${i}]`
+             * with:
+             *   `${key}[]`
+             */
+            return value.flatMap((v, i) => {
+                const newKey = `${key}[${i}]`;
+                return buildParams(newKey, v);
+            });
+        }
+        // Plain object case
+        return Object.keys(value).flatMap((k) => {
+            const newKey = `${key}[${k}]`;
+            return buildParams(newKey, value[k]);
+        });
+    }
+    return [`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`];
+}
+/**
+ * Serialize a nested object (including arrays, arrays of objects, etc.)
+ * into a bracket-based query string.
+ *
+ * @example
+ *   serializeQuery({ x: 'xx', y: [1, 2], z: { f: 'x' } })
+ *   => "x=xx&y[0]=1&y[1]=2&z[f]=x"
+ *
+ * @param obj - The input object to be serialized
+ * @returns   - A bracket-based query string (without leading "?")
+ */
+function serializeQuery(obj) {
+    if (!obj || typeof obj !== 'object')
+        return '';
+    // Collect query segments
+    const segments = [];
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            const value = obj[key];
+            segments.push(...buildParams(key, value));
+        }
+    }
+    return segments.join('&');
+}

package/cjs/utils/setHandlerSchema.d.ts

@@ -0,0 +1,4 @@
+import type { KnownAny, VovkController, VovkHandlerSchema } from '../types.js';
+export declare function setHandlerSchema(h: ((...args: KnownAny[]) => KnownAny) & {
+    _getSchema?: (controller: VovkController) => Omit<VovkHandlerSchema, 'httpMethod' | 'path'>;
+}, schema: Omit<VovkHandlerSchema, 'httpMethod' | 'path'>): Promise<void>;

package/cjs/utils/setHandlerSchema.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setHandlerSchema = setHandlerSchema;
+async function setHandlerSchema(h, schema) {
+    h._getSchema = (controller) => {
+        if (!controller) {
+            throw new Error('Error setting client validators. Controller not found. Did you forget to use an HTTP decorator?');
+        }
+        const handlerName = Object.getOwnPropertyNames(controller).find((key) => controller[key]._sourceMethod === h);
+        if (!handlerName) {
+            throw new Error('Error setting client validators. Handler not found.');
+        }
+        return schema;
+    };
+}

package/cjs/utils/withStandard.d.ts

@@ -0,0 +1,51 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import { KnownAny, VovkRequest, VovkTypedMethod, VovkValidationType } from '../types';
+import { withValidationLibrary } from './withValidationLibrary';
+export declare function withStandard<T extends (req: REQ, params: PARAMS extends StandardSchemaV1 ? StandardSchemaV1.InferInput<PARAMS> : Record<string, string>) => KnownAny, BODY extends StandardSchemaV1, QUERY extends StandardSchemaV1, PARAMS extends StandardSchemaV1, OUTPUT extends StandardSchemaV1, ITERATION extends StandardSchemaV1, REQ extends VovkRequest<KnownAny, KnownAny, KnownAny> = VovkRequest<BODY extends StandardSchemaV1 ? StandardSchemaV1.InferInput<BODY> : undefined, QUERY extends StandardSchemaV1 ? StandardSchemaV1.InferInput<QUERY> : undefined, PARAMS extends StandardSchemaV1 ? StandardSchemaV1.InferInput<PARAMS> : undefined>, IS_FORM extends boolean = false>({ isForm, body, query, params, output, iteration, handle, toJSONSchema, disableServerSideValidation, skipSchemaEmission, validateEachIteration, }: {
+    isForm?: IS_FORM;
+    body?: BODY;
+    query?: QUERY;
+    params?: PARAMS;
+    output?: OUTPUT;
+    iteration?: ITERATION;
+    handle: T;
+    disableServerSideValidation?: boolean | VovkValidationType[];
+    skipSchemaEmission?: boolean | VovkValidationType[];
+    validateEachIteration?: boolean;
+    toJSONSchema: Parameters<typeof withValidationLibrary>[0]['toJSONSchema'];
+}): T & {
+    __types: {
+        body: BODY extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<BODY> : any;
+        query: QUERY extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<QUERY> : any;
+        params: PARAMS extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<PARAMS> : any;
+        output: OUTPUT extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<OUTPUT> : any;
+        iteration: ITERATION extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<ITERATION> : any;
+        isForm: IS_FORM extends true ? true : any;
+    };
+    isRPC?: boolean;
+} & {
+    schema: import("../types").VovkHandlerSchema;
+} & {
+    func: (input: {
+        disableValidation?: boolean;
+    } & (undefined extends BODY | undefined ? {
+        body?: VovkTypedMethod<T, BODY extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<BODY> : any, QUERY extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<QUERY> : any, PARAMS extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<PARAMS> : any, OUTPUT extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<OUTPUT> : any, ITERATION extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<ITERATION> : any, IS_FORM extends true ? true : any>["__types"]["body"] | undefined;
+    } : {
+        body: VovkTypedMethod<T, BODY extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<BODY> : any, QUERY extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<QUERY> : any, PARAMS extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<PARAMS> : any, OUTPUT extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<OUTPUT> : any, ITERATION extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<ITERATION> : any, IS_FORM extends true ? true : any>["__types"]["body"];
+    }) & (undefined extends QUERY | undefined ? {
+        query?: VovkTypedMethod<T, BODY extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<BODY> : any, QUERY extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<QUERY> : any, PARAMS extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<PARAMS> : any, OUTPUT extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<OUTPUT> : any, ITERATION extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<ITERATION> : any, IS_FORM extends true ? true : any>["__types"]["query"] | undefined;
+    } : {
+        query: VovkTypedMethod<T, BODY extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<BODY> : any, QUERY extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<QUERY> : any, PARAMS extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<PARAMS> : any, OUTPUT extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<OUTPUT> : any, ITERATION extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<ITERATION> : any, IS_FORM extends true ? true : any>["__types"]["query"];
+    }) & (undefined extends PARAMS | undefined ? {
+        params?: VovkTypedMethod<T, BODY extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<BODY> : any, QUERY extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<QUERY> : any, PARAMS extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<PARAMS> : any, OUTPUT extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<OUTPUT> : any, ITERATION extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<ITERATION> : any, IS_FORM extends true ? true : any>["__types"]["params"] | undefined;
+    } : {
+        params: VovkTypedMethod<T, BODY extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<BODY> : any, QUERY extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<QUERY> : any, PARAMS extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<PARAMS> : any, OUTPUT extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<OUTPUT> : any, ITERATION extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<ITERATION> : any, IS_FORM extends true ? true : any>["__types"]["params"];
+    })) => ReturnType<VovkTypedMethod<T, BODY extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<BODY> : any, QUERY extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<QUERY> : any, PARAMS extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<PARAMS> : any, OUTPUT extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<OUTPUT> : any, ITERATION extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<ITERATION> : any, IS_FORM extends true ? true : any>>;
+    models: {
+        body: BODY | undefined;
+        query: QUERY | undefined;
+        params: PARAMS | undefined;
+        output: OUTPUT | undefined;
+        iteration: ITERATION | undefined;
+    };
+};

package/cjs/utils/withStandard.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withStandard = withStandard;
+const types_1 = require("../types");
+const withValidationLibrary_1 = require("./withValidationLibrary");
+const HttpException_1 = require("../HttpException");
+function withStandard({ isForm, body, query, params, output, iteration, handle, toJSONSchema, disableServerSideValidation, skipSchemaEmission, validateEachIteration, }) {
+    return (0, withValidationLibrary_1.withValidationLibrary)({
+        isForm,
+        body,
+        query,
+        params,
+        output,
+        iteration,
+        disableServerSideValidation,
+        skipSchemaEmission,
+        validateEachIteration,
+        handle: handle,
+        toJSONSchema,
+        validate: async (data, model, { type, i }) => {
+            const result = await model['~standard'].validate(data);
+            if (result.issues?.length) {
+                throw new HttpException_1.HttpException(types_1.HttpStatus.BAD_REQUEST, `Validation failed. Invalid ${type === 'iteration' ? `${type} #${i}` : type} on server: ${result.issues
+                    .map(({ message, path }) => `${message}${path ? ` at ${path.join('.')}` : ''}`)
+                    .join(', ')}`, { [type]: data, result });
+            }
+            return result.value;
+        },
+    });
+}

package/cjs/utils/withValidationLibrary.d.ts

@@ -0,0 +1,49 @@
+import { VovkHandlerSchema, VovkTypedMethod, VovkValidationType, type KnownAny, type VovkRequest } from '../types.js';
+type VovkRequestAny = VovkRequest<KnownAny, KnownAny, KnownAny>;
+export declare function withValidationLibrary<T extends VovkTypedMethod<(req: KnownAny, params: KnownAny) => KnownAny>, BODY_MODEL, QUERY_MODEL, PARAMS_MODEL, OUTPUT_MODEL, ITERATION_MODEL, IS_FORM extends boolean = false>({ isForm, disableServerSideValidation, skipSchemaEmission, validateEachIteration, body, query, params, output, iteration, handle, toJSONSchema, validate, }: {
+    isForm?: IS_FORM;
+    disableServerSideValidation?: boolean | VovkValidationType[];
+    skipSchemaEmission?: boolean | VovkValidationType[];
+    validateEachIteration?: boolean;
+    body?: BODY_MODEL;
+    query?: QUERY_MODEL;
+    params?: PARAMS_MODEL;
+    output?: OUTPUT_MODEL;
+    iteration?: ITERATION_MODEL;
+    handle: T;
+    toJSONSchema?: (model: NonNullable<BODY_MODEL | QUERY_MODEL | PARAMS_MODEL | OUTPUT_MODEL | ITERATION_MODEL>, meta: {
+        type: VovkValidationType;
+    }) => KnownAny;
+    validate: (data: KnownAny, model: NonNullable<BODY_MODEL | QUERY_MODEL | PARAMS_MODEL | OUTPUT_MODEL | ITERATION_MODEL>, meta: {
+        type: VovkValidationType | 'form';
+        req: VovkRequestAny;
+        status?: number;
+        i?: number;
+    }) => KnownAny;
+}): T & {
+    schema: VovkHandlerSchema;
+} & {
+    func: (input: {
+        disableValidation?: boolean;
+    } & (undefined extends typeof body ? {
+        body?: T["__types"]["body"];
+    } : {
+        body: T["__types"]["body"];
+    }) & (undefined extends typeof query ? {
+        query?: T["__types"]["query"];
+    } : {
+        query: T["__types"]["query"];
+    }) & (undefined extends typeof params ? {
+        params?: T["__types"]["params"];
+    } : {
+        params: T["__types"]["params"];
+    })) => ReturnType<T>;
+    models: {
+        body: BODY_MODEL | undefined;
+        query: QUERY_MODEL | undefined;
+        params: PARAMS_MODEL | undefined;
+        output: OUTPUT_MODEL | undefined;
+        iteration: ITERATION_MODEL | undefined;
+    };
+};
+export {};

package/cjs/utils/withValidationLibrary.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withValidationLibrary = withValidationLibrary;
+const HttpException_js_1 = require("../HttpException.js");
+const types_js_1 = require("../types.js");
+const reqMeta_js_1 = __importDefault(require("./reqMeta.js"));
+const setHandlerSchema_js_1 = require("./setHandlerSchema.js");
+const validationTypes = ['body', 'query', 'params', 'output', 'iteration'];
+function withValidationLibrary({ isForm, disableServerSideValidation, skipSchemaEmission, validateEachIteration, body, query, params, output, iteration, handle, toJSONSchema, validate, }) {
+    const disableServerSideValidationKeys = disableServerSideValidation === false
+        ? []
+        : disableServerSideValidation === true
+            ? validationTypes
+            : (disableServerSideValidation ?? []);
+    const skipSchemaEmissionKeys = skipSchemaEmission === false ? [] : skipSchemaEmission === true ? validationTypes : (skipSchemaEmission ?? []);
+    const outputHandler = async (req, handlerParams) => {
+        const { __disableValidation } = req.vovk.meta();
+        const data = await handle(req, handlerParams);
+        if (__disableValidation) {
+            return data;
+        }
+        if (output && iteration) {
+            throw new HttpException_js_1.HttpException(types_js_1.HttpStatus.INTERNAL_SERVER_ERROR, "Output and iteration are mutually exclusive. You can't use them together.");
+        }
+        if (output && !disableServerSideValidationKeys.includes('output')) {
+            if (!data) {
+                throw new HttpException_js_1.HttpException(types_js_1.HttpStatus.INTERNAL_SERVER_ERROR, 'Output is required. You probably forgot to return something from your handler.');
+            }
+            await validate(data, output, { type: 'output', req });
+        }
+        if (iteration && !disableServerSideValidationKeys.includes('iteration')) {
+            // We assume `data` is an async iterable here; you might want to check that:
+            if (!data || typeof data[Symbol.asyncIterator] !== 'function') {
+                throw new HttpException_js_1.HttpException(types_js_1.HttpStatus.INTERNAL_SERVER_ERROR, 'Data is not an async iterable but iteration validation is defined.');
+            }
+            // Return a brand-new async generator that yields validated items
+            return (async function* () {
+                let i = 0;
+                for await (const item of data) {
+                    if (validateEachIteration || i === 0) {
+                        await validate(item, iteration, { type: 'iteration', req, status: 200, i });
+                    }
+                    i++;
+                    yield item;
+                }
+            })();
+        }
+        else if (validateEachIteration) {
+            throw new HttpException_js_1.HttpException(types_js_1.HttpStatus.INTERNAL_SERVER_ERROR, 'validateEachIteration is set but iteration is not defined.');
+        }
+        return data;
+    };
+    const resultHandler = (async (req, handlerParams) => {
+        const { __disableValidation } = req.vovk.meta();
+        if (!__disableValidation) {
+            if (body && !disableServerSideValidationKeys.includes('body')) {
+                const data = await req.vovk[isForm ? 'form' : 'body']();
+                const instance = (await validate(data, body, { type: isForm ? 'form' : 'body', req })) ?? data;
+                // redeclare to add ability to call req.json() and req.vovk.body() again
+                req.json = () => Promise.resolve(data);
+                req.vovk[isForm ? 'form' : 'body'] = () => Promise.resolve(instance);
+            }
+            if (query && !disableServerSideValidationKeys.includes('query')) {
+                const data = req.vovk.query();
+                const instance = (await validate(data, query, { type: 'query', req })) ?? data;
+                req.vovk.query = () => instance;
+            }
+            if (params && !disableServerSideValidationKeys.includes('params')) {
+                const data = req.vovk.params();
+                const instance = (await validate(data, params, { type: 'params', req })) ?? data;
+                req.vovk.params = () => instance;
+            }
+        }
+        return outputHandler(req, handlerParams);
+    });
+    function func(input) {
+        const fakeReq = {
+            vovk: {
+                body: () => Promise.resolve(input.body),
+                query: () => input.query,
+                params: () => input.params,
+                meta: (meta) => (0, reqMeta_js_1.default)(fakeReq, meta),
+                form: () => {
+                    throw new Error('Form data is not supported in this context.');
+                },
+            },
+        };
+        fakeReq.vovk.meta({ __disableValidation: input.disableValidation });
+        return resultHandler(fakeReq, input.params ?? {});
+    }
+    const models = {
+        body,
+        query,
+        params,
+        output,
+        iteration,
+    };
+    const resultHandlerEnhanced = Object.assign(resultHandler, { func, models });
+    if (toJSONSchema) {
+        const getJsonSchema = (model, type) => Object.assign(toJSONSchema(model, { type }), type === 'body' && isForm ? { 'x-formData': isForm } : {});
+        const validation = {};
+        if (body && !skipSchemaEmissionKeys.includes('body')) {
+            validation.body = getJsonSchema(body, 'body');
+        }
+        if (query && !skipSchemaEmissionKeys.includes('query')) {
+            validation.query = getJsonSchema(query, 'query');
+        }
+        if (params && !skipSchemaEmissionKeys.includes('params')) {
+            validation.params = getJsonSchema(params, 'params');
+        }
+        if (output && !skipSchemaEmissionKeys.includes('output')) {
+            validation.output = getJsonSchema(output, 'output');
+        }
+        if (iteration && !skipSchemaEmissionKeys.includes('iteration')) {
+            validation.iteration = getJsonSchema(iteration, 'iteration');
+        }
+        (0, setHandlerSchema_js_1.setHandlerSchema)(resultHandlerEnhanced, { validation });
+    }
+    return resultHandlerEnhanced;
+}

package/mjs/HttpException.d.ts

@@ -0,0 +1,7 @@
+import type { HttpStatus } from './types.js';
+export declare class HttpException extends Error {
+    statusCode: HttpStatus;
+    message: string;
+    cause?: unknown;
+    constructor(statusCode: HttpStatus, message: string, cause?: unknown);
+}

package/mjs/HttpException.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpException = void 0;
+class HttpException extends Error {
+    statusCode;
+    message;
+    cause;
+    constructor(statusCode, message, cause) {
+        super(message);
+        this.statusCode = statusCode;
+        this.message = message;
+        this.cause = cause;
+    }
+}
+exports.HttpException = HttpException;

package/mjs/JSONLinesResponse.d.ts

@@ -0,0 +1,14 @@
+import { headers } from 'next/headers';
+import type { KnownAny, StreamAbortMessage } from './types.js';
+import './utils/shim.js';
+export declare class JSONLinesResponse<T> extends Response {
+    isClosed: boolean;
+    controller?: ReadableStreamDefaultController;
+    readonly encoder: TextEncoder;
+    readonly readableStream: ReadableStream;
+    constructor(requestHeaders: Awaited<ReturnType<typeof headers>>, init?: ResponseInit);
+    send(data: T | StreamAbortMessage): void;
+    close(): void;
+    throw(e: KnownAny): void;
+    [Symbol.dispose](): void;
+}

package/mjs/JSONLinesResponse.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONLinesResponse = void 0;
+require("./utils/shim.js");
+class JSONLinesResponse extends Response {
+    isClosed = false;
+    controller;
+    encoder;
+    readableStream;
+    constructor(requestHeaders, init) {
+        const encoder = new TextEncoder();
+        let readableController;
+        const readableStream = new ReadableStream({
+            cancel: () => {
+                this.isClosed = true;
+            },
+            start: (controller) => {
+                readableController = controller;
+            },
+        });
+        if (!requestHeaders) {
+            throw new Error('Request headers are required');
+        }
+        const accept = requestHeaders.get('accept');
+        super(readableStream, {
+            ...init,
+            headers: {
+                ...init?.headers,
+                'Content-Type': accept?.includes('application/jsonl')
+                    ? 'application/jsonl; charset=utf-8'
+                    : 'text/plain; charset=utf-8',
+            },
+        });
+        this.readableStream = readableStream;
+        this.encoder = encoder;
+        this.controller = readableController;
+    }
+    send(data) {
+        const { controller, encoder } = this;
+        if (this.isClosed)
+            return;
+        return controller?.enqueue(encoder.encode(JSON.stringify(data) + '\n'));
+    }
+    close() {
+        const { controller } = this;
+        if (this.isClosed)
+            return;
+        this.isClosed = true;
+        controller?.close();
+    }
+    throw(e) {
+        this.send({ isError: true, reason: e instanceof Error ? e.message : e });
+        return this.close();
+    }
+    [Symbol.dispose]() {
+        this.close();
+    }
+}
+exports.JSONLinesResponse = JSONLinesResponse;

package/mjs/VovkApp.d.ts

@@ -0,0 +1,29 @@
+import type { NextRequest } from 'next/server';
+import { HttpMethod, HttpStatus, type RouteHandler, type VovkController, type DecoratorOptions } from './types.js';
+export declare class VovkApp {
+    #private;
+    private static getHeadersFromOptions;
+    routes: Record<HttpMethod, Map<VovkController, Record<string, RouteHandler>>>;
+    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>;
+    respond: (status: HttpStatus, body: unknown, options?: DecoratorOptions) => Response;
+}