vovk 3.0.0-draft.46 → 3.0.0-draft.461

package/cjs/utils/resolveGeneratorConfigValues.d.ts

@@ -0,0 +1,18 @@
+import type { PackageJson } from 'type-fest';
+import type { VovkGeneratorConfig, VovkReadmeConfig, VovkSamplesConfig, VovkSchema } from '../types';
+import type { OpenAPIObject } from 'openapi3-ts/oas31';
+export declare function resolveGeneratorConfigValues({ schema, configs, segmentName, isBundle, projectPackageJson, }: {
+    schema: VovkSchema;
+    configs?: VovkGeneratorConfig[];
+    segmentName: string | null;
+    isBundle?: boolean;
+    projectPackageJson?: PackageJson;
+}): {
+    readme: VovkReadmeConfig;
+    openAPIObject: OpenAPIObject;
+    samples: VovkSamplesConfig;
+    origin: string;
+    package: PackageJson;
+    imports: VovkGeneratorConfig['imports'];
+    reExports: VovkGeneratorConfig['reExports'];
+};

package/cjs/utils/resolveGeneratorConfigValues.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveGeneratorConfigValues = resolveGeneratorConfigValues;
+const deepExtend_1 = __importDefault(require("./deepExtend"));
+function resolveGeneratorConfigValues({ schema, configs, segmentName, isBundle, projectPackageJson, }) {
+    const packageJson = (0, deepExtend_1.default)({}, {
+        main: './index.cjs',
+        module: './index.mjs',
+        types: './index.d.mts',
+        exports: {
+            '.': {
+                import: './index.mjs',
+                require: './index.cjs',
+                types: './index.d.mts',
+            },
+            './schema': {
+                import: './schema.cjs',
+                require: './schema.cjs',
+                types: './schema.d.cts',
+            },
+            './openapi': {
+                import: './openapi.cjs',
+                require: './openapi.cjs',
+                types: './openapi.d.cts',
+            },
+        },
+    }, projectPackageJson, schema.meta?.config?.generatorConfig?.package, isBundle ? schema.meta?.config?.bundle?.generatorConfig?.package : undefined, typeof segmentName === 'string' ? schema.segments?.[segmentName]?.meta?.package : undefined, typeof segmentName === 'string'
+        ? schema.meta?.config?.generatorConfig?.segments?.[segmentName]?.package
+        : undefined, configs?.reduce((acc, config) => (0, deepExtend_1.default)(acc, config.package), {}));
+    return {
+        package: Object.fromEntries(Object.entries(packageJson).filter(([key]) => ['name', 'version', 'description', 'license', 'authors', 'repository', 'homepage', 'bugs', 'keywords'].includes(key))),
+        openAPIObject: (0, deepExtend_1.default)({}, {
+            openapi: '3.1.0',
+            info: {
+                title: packageJson.name,
+                version: packageJson.version,
+                description: packageJson.description,
+            },
+        }, schema.meta?.config?.generatorConfig?.openAPIObject, isBundle ? schema.meta?.config?.bundle?.generatorConfig?.openAPIObject : undefined, typeof segmentName === 'string' ? schema?.segments?.[segmentName]?.meta?.openAPIObject : undefined, typeof segmentName === 'string'
+            ? schema.meta?.config?.generatorConfig?.segments?.[segmentName]?.openAPIObject
+            : undefined, configs?.reduce((acc, config) => (0, deepExtend_1.default)(acc, config.openAPIObject), {})),
+        samples: (0, deepExtend_1.default)({}, schema.meta?.config?.generatorConfig?.samples, isBundle ? schema.meta?.config?.bundle?.generatorConfig?.samples : undefined, typeof segmentName === 'string'
+            ? schema.meta?.config?.generatorConfig?.segments?.[segmentName]?.samples
+            : undefined, configs?.reduce((acc, config) => (0, deepExtend_1.default)(acc, config.samples), {})),
+        readme: (0, deepExtend_1.default)({}, schema.meta?.config?.generatorConfig?.readme, isBundle ? schema.meta?.config?.bundle?.generatorConfig?.readme : undefined, typeof segmentName === 'string'
+            ? schema.meta?.config?.generatorConfig?.segments?.[segmentName]?.readme
+            : undefined, configs?.reduce((acc, config) => (0, deepExtend_1.default)(acc, config.readme), {})),
+        origin: [
+            isBundle ? schema.meta?.config?.bundle?.generatorConfig?.origin : undefined,
+            typeof segmentName === 'string'
+                ? schema.meta?.config?.generatorConfig?.segments?.[segmentName]?.origin
+                : undefined,
+            schema.meta?.config?.generatorConfig?.origin,
+            ...(configs?.map((config) => config.origin) ?? []),
+        ]
+            .filter(Boolean)
+            .at(-1)
+            // remove trailing slash if any
+            ?.replace(/\/$/, '') ?? '',
+        imports: (0, deepExtend_1.default)({
+            fetcher: ['vovk'],
+            validateOnClient: null,
+            createRPC: ['vovk'],
+        }, schema.meta?.config?.generatorConfig?.imports, isBundle ? schema.meta?.config?.bundle?.generatorConfig?.imports : undefined, typeof segmentName === 'string'
+            ? schema.meta?.config?.generatorConfig?.segments?.[segmentName]?.imports
+            : undefined, configs?.reduce((acc, config) => (0, deepExtend_1.default)(acc, config.imports), {})),
+        reExports: (0, deepExtend_1.default)(
+        // segmentName can be an empty string (for the root segment) and null (for composed clients)
+        // therefore, !segmentName indicates that this either a composed client or a root segment of a segmented client
+        {}, !segmentName && schema.meta?.config?.generatorConfig?.reExports, !segmentName && isBundle ? schema.meta?.config?.bundle?.generatorConfig?.reExports : undefined, 
+        // for segmented client, apply all reExports from all segments
+        typeof segmentName !== 'string' &&
+            Object.values(schema.meta?.config?.generatorConfig?.segments ?? {}).reduce((acc, segmentConfig) => (0, deepExtend_1.default)(acc, segmentConfig.reExports ?? {}), {}), 
+        // for a specific segment, apply reExports from that segment
+        typeof segmentName === 'string'
+            ? schema.meta?.config?.generatorConfig?.segments?.[segmentName]?.reExports
+            : undefined, configs?.reduce((acc, config) => (0, deepExtend_1.default)(acc, config.reExports), {})),
+    };
+}

package/cjs/utils/serializeQuery.d.ts

@@ -0,0 +1,13 @@
+import type { KnownAny } from '../types';
+/**
+ * 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';
+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/upperFirst.d.ts

@@ -0,0 +1 @@
+export declare function upperFirst(str: string): string;

package/cjs/utils/upperFirst.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upperFirst = upperFirst;
+function upperFirst(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/cjs/utils/withValidationLibrary.d.ts

@@ -0,0 +1,78 @@
+import { VovkHandlerSchema, VovkTypedMethod, VovkValidationType, type KnownAny, type VovkRequest, type VovkOperationObject } from '../types';
+type VovkRequestAny = VovkRequest<KnownAny, KnownAny, KnownAny>;
+type Meta = {
+    __disableClientValidation?: boolean;
+    [key: string]: KnownAny;
+};
+export declare function withValidationLibrary<T extends VovkTypedMethod<(req: KnownAny, params: KnownAny) => KnownAny, KnownAny, KnownAny, KnownAny, KnownAny, KnownAny, boolean>, TBody_MODEL, TQuery_MODEL, TParams_MODEL, OUTPUT_MODEL, ITERATION_MODEL, IS_FORM extends boolean = false>({ isForm, disableServerSideValidation, skipSchemaEmission, validateEachIteration, body, query, params, output, iteration, handle, toJSONSchema, validate, preferTransformed, operationObject, }: {
+    isForm: IS_FORM | undefined;
+    disableServerSideValidation: boolean | VovkValidationType[] | undefined;
+    skipSchemaEmission: boolean | VovkValidationType[] | undefined;
+    validateEachIteration: boolean | undefined;
+    body: TBody_MODEL | undefined;
+    query: TQuery_MODEL | undefined;
+    params: TParams_MODEL | undefined;
+    output: OUTPUT_MODEL | undefined;
+    iteration: ITERATION_MODEL | undefined;
+    handle: T;
+    toJSONSchema: ((model: KnownAny, // performance concern
+    meta: {
+        type: VovkValidationType;
+    }) => KnownAny) | undefined;
+    validate: (data: KnownAny, model: NonNullable<TBody_MODEL | TQuery_MODEL | TParams_MODEL | OUTPUT_MODEL | ITERATION_MODEL>, meta: {
+        type: VovkValidationType | 'form';
+        req: VovkRequestAny;
+        status?: number;
+        i?: number;
+    }) => KnownAny;
+    preferTransformed: boolean | undefined;
+    operationObject: VovkOperationObject | undefined;
+}): T & {
+    schema: Omit<VovkHandlerSchema, "httpMethod" | "path"> & Partial<VovkHandlerSchema>;
+    wrapper?: (req: VovkRequestAny, params: Parameters<T>[1]) => ReturnType<T>;
+} & {
+    fn: {
+        <RETURN_TYPE = ReturnType<T>>(input?: (undefined extends TBody_MODEL | undefined ? undefined extends TQuery_MODEL | undefined ? undefined extends TParams_MODEL | undefined ? true : false : false : false) extends true ? {
+            disableClientValidation?: boolean;
+        } & (undefined extends TBody_MODEL | undefined ? {
+            body?: T["__types"]["body"];
+        } : {
+            body: T["__types"]["body"];
+        }) & (undefined extends TQuery_MODEL | undefined ? {
+            query?: T["__types"]["query"];
+        } : {
+            query: T["__types"]["query"];
+        }) & (undefined extends TParams_MODEL | undefined ? {
+            params?: T["__types"]["params"];
+        } : {
+            params: T["__types"]["params"];
+        }) & {
+            meta?: Meta;
+        } : never): (undefined extends TBody_MODEL | undefined ? undefined extends TQuery_MODEL | undefined ? undefined extends TParams_MODEL | undefined ? true : false : false : false) extends true ? RETURN_TYPE : never;
+        <RETURN_TYPE = ReturnType<T>>(input: {
+            disableClientValidation?: boolean;
+        } & (undefined extends TBody_MODEL | undefined ? {
+            body?: T["__types"]["body"];
+        } : {
+            body: T["__types"]["body"];
+        }) & (undefined extends TQuery_MODEL | undefined ? {
+            query?: T["__types"]["query"];
+        } : {
+            query: T["__types"]["query"];
+        }) & (undefined extends TParams_MODEL | undefined ? {
+            params?: T["__types"]["params"];
+        } : {
+            params: T["__types"]["params"];
+        }) & {
+            meta?: Meta;
+        }): RETURN_TYPE;
+    };
+    models: {
+        iteration?: (ITERATION_MODEL & ({} | null)) | undefined;
+        output?: (OUTPUT_MODEL & ({} | null)) | undefined;
+        params?: (TParams_MODEL & ({} | null)) | undefined;
+        query?: (TQuery_MODEL & ({} | null)) | undefined;
+        body?: (TBody_MODEL & ({} | null)) | undefined;
+    };
+};
+export {};

package/cjs/utils/withValidationLibrary.js

@@ -0,0 +1,133 @@
+"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_1 = require("../HttpException");
+const types_1 = require("../types");
+const reqMeta_1 = __importDefault(require("./reqMeta"));
+const setHandlerSchema_1 = require("./setHandlerSchema");
+const validationTypes = ['body', 'query', 'params', 'output', 'iteration'];
+function withValidationLibrary({ isForm, disableServerSideValidation, skipSchemaEmission, validateEachIteration, body, query, params, output, iteration, handle, toJSONSchema, validate, preferTransformed, operationObject, }) {
+    preferTransformed = preferTransformed ?? true;
+    const disableServerSideValidationKeys = disableServerSideValidation === false
+        ? []
+        : disableServerSideValidation === true
+            ? validationTypes
+            : (disableServerSideValidation ?? []);
+    const skipSchemaEmissionKeys = skipSchemaEmission === false ? [] : skipSchemaEmission === true ? validationTypes : (skipSchemaEmission ?? []);
+    const outputHandler = async (req, handlerParams) => {
+        const { __disableClientValidation } = req.vovk.meta();
+        const data = await handle(req, handlerParams);
+        if (__disableClientValidation) {
+            return data;
+        }
+        if (output && iteration) {
+            throw new HttpException_1.HttpException(types_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_1.HttpException(types_1.HttpStatus.INTERNAL_SERVER_ERROR, 'Output is required. You probably forgot to return something from your handler.');
+            }
+            const parsed = (await validate(data, output, { type: 'output', req })) ?? data;
+            return preferTransformed ? parsed : data;
+        }
+        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_1.HttpException(types_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) {
+                    let parsed;
+                    if (validateEachIteration || i === 0) {
+                        parsed = (await validate(item, iteration, { type: 'iteration', req, status: 200, i })) ?? item;
+                    }
+                    else {
+                        parsed = item;
+                    }
+                    i++;
+                    yield preferTransformed ? parsed : item;
+                }
+            })();
+        }
+        else if (validateEachIteration) {
+            throw new HttpException_1.HttpException(types_1.HttpStatus.INTERNAL_SERVER_ERROR, 'validateEachIteration is set but iteration is not defined.');
+        }
+        return data;
+    };
+    const resultHandler = (async (req, handlerParams) => {
+        const { __disableClientValidation } = req.vovk.meta();
+        if (!__disableClientValidation) {
+            if (body && !disableServerSideValidationKeys.includes('body')) {
+                const data = await req.vovk[isForm ? 'form' : 'body']();
+                const parsed = (await validate(data, body, { type: isForm ? 'form' : 'body', req })) ?? data;
+                const instance = preferTransformed ? parsed : 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 parsed = (await validate(data, query, { type: 'query', req })) ?? data;
+                const instance = preferTransformed ? parsed : data;
+                req.vovk.query = () => instance;
+            }
+            if (params && !disableServerSideValidationKeys.includes('params')) {
+                const data = req.vovk.params();
+                const parsed = (await validate(data, params, { type: 'params', req })) ?? data;
+                const instance = preferTransformed ? parsed : data;
+                req.vovk.params = () => instance;
+            }
+        }
+        return outputHandler(req, handlerParams);
+    });
+    function fn(input) {
+        const fakeReq = {
+            vovk: {
+                body: () => Promise.resolve((input?.body ?? {})),
+                query: () => (input?.query ?? {}),
+                params: () => (input?.params ?? {}),
+                meta: (meta) => (0, reqMeta_1.default)(fakeReq, meta),
+                form: () => {
+                    throw new Error('Form data is not supported in this context.');
+                },
+            },
+        };
+        fakeReq.vovk.meta({ __disableClientValidation: input?.disableClientValidation, ...input?.meta });
+        return (resultHandler.wrapper ?? resultHandler)(fakeReq, (input?.params ?? {}));
+    }
+    const models = {
+        ...(body !== undefined ? { body } : {}),
+        ...(query !== undefined ? { query } : {}),
+        ...(params !== undefined ? { params } : {}),
+        ...(output !== undefined ? { output } : {}),
+        ...(iteration !== undefined ? { iteration } : {}),
+    };
+    const resultHandlerEnhanced = Object.assign(resultHandler, { fn, models });
+    if (toJSONSchema) {
+        const getJSONSchema = (model, type) => Object.assign(toJSONSchema(model, { type }), type === 'body' && isForm ? { 'x-isForm': 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');
+        }
+        resultHandlerEnhanced.schema = { validation, operationObject };
+        (0, setHandlerSchema_1.setHandlerSchema)(resultHandlerEnhanced, { validation, operationObject });
+    }
+    return resultHandlerEnhanced;
+}

package/mjs/HttpException.d.ts

@@ -0,0 +1,7 @@
+import type { HttpStatus } from './types';
+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,19 @@
+import type { KnownAny, StreamAbortMessage } from './types';
+import './utils/shim';
+export declare class JSONLinesResponse<T> extends Response {
+    isClosed: boolean;
+    controller?: ReadableStreamDefaultController | null;
+    readonly encoder: TextEncoder | null;
+    readonly readableStream: ReadableStream | null;
+    private iteratorQueue;
+    private iteratorResolvers;
+    constructor(request?: Request, init?: ResponseInit);
+    send: (data: T | StreamAbortMessage) => void;
+    close: () => void;
+    throw: (e: KnownAny) => void;
+    [Symbol.dispose]: () => void;
+    [Symbol.asyncDispose]: () => void;
+    [Symbol.asyncIterator]: () => {
+        next: () => Promise<IteratorResult<T | StreamAbortMessage>>;
+    };
+}

package/mjs/JSONLinesResponse.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONLinesResponse = void 0;
+require("./utils/shim");
+class JSONLinesResponse extends Response {
+    isClosed = false;
+    controller;
+    encoder;
+    readableStream;
+    iteratorQueue = [];
+    iteratorResolvers = [];
+    constructor(request, init) {
+        const encoder = new TextEncoder();
+        let readableController;
+        const readableStream = new ReadableStream({
+            cancel: () => {
+                this.isClosed = true;
+            },
+            start: (controller) => {
+                readableController = controller;
+            },
+        });
+        const accept = request?.headers?.get('accept');
+        super(readableStream, {
+            ...init,
+            headers: {
+                'content-type': !request || accept?.includes('application/jsonl')
+                    ? 'application/jsonl; charset=utf-8'
+                    : 'text/plain; charset=utf-8',
+                ...init?.headers,
+            },
+        });
+        this.readableStream = request ? readableStream : null;
+        this.encoder = request ? encoder : null;
+        this.controller = request ? readableController : null;
+        request?.signal?.addEventListener('abort', this.close, { once: true });
+        // this will make promise on the client-side to resolve immediately
+        this.controller?.enqueue(encoder?.encode(''));
+    }
+    send = (data) => {
+        const { controller, encoder } = this;
+        if (this.isClosed)
+            return;
+        // Enqueue to the ReadableStream
+        controller?.enqueue(encoder?.encode(JSON.stringify(data) + '\n'));
+        // Handle async iterator consumers
+        if (this.iteratorResolvers.length > 0) {
+            // If there's a pending next() call, resolve it immediately
+            const resolve = this.iteratorResolvers.shift();
+            resolve({ value: data, done: false });
+        }
+        else {
+            // Otherwise, queue the value for later consumption
+            this.iteratorQueue.push(data);
+        }
+    };
+    close = () => {
+        const { controller } = this;
+        if (this.isClosed)
+            return;
+        this.isClosed = true;
+        controller?.close();
+        // Resolve all pending iterator next() calls with done: true
+        while (this.iteratorResolvers.length > 0) {
+            const resolve = this.iteratorResolvers.shift();
+            resolve({ done: true, value: undefined });
+        }
+    };
+    throw = (e) => {
+        this.send({ isError: true, reason: e instanceof Error ? e.message : e });
+        return this.close();
+    };
+    [Symbol.dispose] = () => this.close();
+    [Symbol.asyncDispose] = () => this.close();
+    [Symbol.asyncIterator] = () => {
+        return {
+            next: async () => {
+                // If we have queued values, return them immediately
+                if (this.iteratorQueue.length > 0) {
+                    const value = this.iteratorQueue.shift();
+                    return { value, done: false };
+                }
+                // If the stream is closed and no more values, we're done
+                if (this.isClosed) {
+                    return { done: true, value: undefined };
+                }
+                // Otherwise, wait for the next value or close
+                return new Promise((resolve) => {
+                    this.iteratorResolvers.push(resolve);
+                });
+            },
+        };
+    };
+}
+exports.JSONLinesResponse = JSONLinesResponse;

package/mjs/VovkApp.d.ts

@@ -0,0 +1,34 @@
+import type { NextRequest } from 'next/server';
+import { HttpMethod, HttpStatus, type RouteHandler, type VovkController, type DecoratorOptions, type VovkRequest } from './types';
+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: ({ statusCode, responseBody, options, }: {
+        req: VovkRequest;
+        statusCode: HttpStatus;
+        responseBody: unknown;
+        options?: DecoratorOptions;
+    }) => Promise<Response>;
+}