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

package/mjs/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_1 = __importDefault(require("./parseQuery"));
+function reqQuery(req) {
+    return (0, parseQuery_1.default)(req.nextUrl.search);
+}

package/mjs/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/mjs/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/mjs/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/mjs/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/mjs/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/mjs/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/mjs/utils/shim.d.ts

@@ -0,0 +1 @@
+export {};

package/mjs/utils/shim.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+if (typeof Symbol.dispose !== 'symbol') {
+    Object.defineProperty(Symbol, 'dispose', {
+        configurable: false,
+        enumerable: false,
+        writable: false,
+        value: Symbol.for('dispose'),
+    });
+}
+if (typeof Symbol.asyncDispose !== 'symbol') {
+    Object.defineProperty(Symbol, 'asyncDispose', {
+        configurable: false,
+        enumerable: false,
+        writable: false,
+        value: Symbol.for('asyncDispose'),
+    });
+}

package/mjs/utils/upperFirst.d.ts

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

package/mjs/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/mjs/utils/withValidationLibrary.d.ts

@@ -0,0 +1,77 @@
+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, operationObject, }: {
+    isForm?: IS_FORM;
+    disableServerSideValidation?: boolean | VovkValidationType[];
+    skipSchemaEmission?: boolean | VovkValidationType[];
+    validateEachIteration?: boolean;
+    body?: TBody_MODEL;
+    query?: TQuery_MODEL;
+    params?: TParams_MODEL;
+    output?: OUTPUT_MODEL;
+    iteration?: ITERATION_MODEL;
+    handle: T;
+    toJSONSchema?: (model: KnownAny, // performance concern
+    meta: {
+        type: VovkValidationType;
+    }) => KnownAny;
+    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;
+    operationObject?: VovkOperationObject;
+}): 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/mjs/utils/withValidationLibrary.js

@@ -0,0 +1,124 @@
+"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, operationObject, }) {
+    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();
+        let 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.');
+            }
+            data = (await validate(data, output, { type: 'output', req })) ?? 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) {
+                    if (validateEachIteration || i === 0) {
+                        await validate(item, iteration, { type: 'iteration', req, status: 200, i });
+                    }
+                    i++;
+                    yield 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 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 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/package.json

@@ -1,29 +1,51 @@
 {
   "name": "vovk",
-  "version": "3.0.0-draft.46",
-  "description": "RESTful RPC for Next.js - Transforms Next.js into a powerful REST API platform with RPC capabilities.",
+  "version": "3.0.0-draft.460",
+  "main": "./cjs/index.js",
+  "module": "./mjs/index.js",
+  "types": "./mjs/index.d.ts",
+  "bin": {
+    "vovk-cli-npx": "./bin/index.mjs"
+  },
+  "exports": {
+    ".": {
+      "import": "./mjs/index.js",
+      "require": "./cjs/index.js",
+      "types": "./mjs/index.d.ts"
+    }
+  },
+  "description": "RESTful RPC for Next.js",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/finom/vovk.git"
   },
   "scripts": {
-    "build": "shx rm -rf dist && tsc && shx cp package.json LICENSE .npmignore dist && shx cp ../../README.md dist",
+    "postbuild": "shx chmod +x ./bin/index.mjs",
+    "build": "shx rm -f *.tsbuildinfo && npm run build:cjs && npm run build:esm",
+    "build:esm": "tsc --module NodeNext --outDir mjs --moduleResolution nodenext",
+    "build:cjs": "tsc --module commonjs --outDir cjs",
+    "rm-dist": "shx rm -rf mjs cjs",
     "lint": "eslint . --fix",
     "tsc": "tsc --noEmit",
-    "npm-publish": "if [ -z \"$NPM_TAG\" ]; then echo 'Error: NPM_TAG is not set'; exit 1; fi; cd ./dist && npm publish --tag=$NPM_TAG && cd ..",
+    "npm-publish": "if [ -z \"$NPM_TAG\" ]; then echo 'Error: NPM_TAG is not set'; exit 1; fi; npm publish --tag=$NPM_TAG",
     "ncu": "npm-check-updates -u"
   },
   "keywords": [
     "nextjs",
     "router"
   ],
-  "author": "Andrii Gubanov",
+  "author": "Andrey Gubanov",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/finom/vovk/issues"
   },
   "homepage": "https://vovk.dev",
   "peerDependencies": {
-    "next": "*"
+    "next": "*",
+    "openapi3-ts": "^4"
+  },
+  "dependencies": {
+    "@standard-schema/spec": "^1.0.0",
+    "type-fest": "*"
   }
 }

package/.npmignore

@@ -1,2 +0,0 @@
-!*
-tsconfig.*

package/StreamJSONResponse.d.ts

@@ -1,17 +0,0 @@
-import { KnownAny, StreamAbortMessage } from './types';
-import './utils/shim';
-export declare class StreamJSONResponse<T> extends Response {
-    static defaultHeaders: {
-        'content-type': string;
-        'x-vovk-stream': string;
-    };
-    isClosed: boolean;
-    controller?: ReadableStreamDefaultController;
-    readonly encoder: TextEncoder;
-    readonly readableStream: ReadableStream;
-    constructor(init?: ResponseInit);
-    send(data: T | StreamAbortMessage): void;
-    close(): void;
-    throw(e: KnownAny): void;
-    [Symbol.dispose](): void;
-}

package/StreamJSONResponse.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StreamJSONResponse = void 0;
-require("./utils/shim");
-class StreamJSONResponse extends Response {
-    static defaultHeaders = {
-        'content-type': 'text/plain; charset=utf-8',
-        'x-vovk-stream': 'true',
-    };
-    isClosed = false;
-    controller;
-    encoder;
-    readableStream;
-    constructor(init) {
-        const encoder = new TextEncoder();
-        let readableController;
-        const readableStream = new ReadableStream({
-            cancel: () => {
-                this.isClosed = true;
-            },
-            start: (controller) => {
-                readableController = controller;
-            },
-        });
-        super(readableStream, {
-            ...init,
-            headers: init?.headers ?? StreamJSONResponse.defaultHeaders,
-        });
-        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.StreamJSONResponse = StreamJSONResponse;