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

package/mjs/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/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.js';
+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/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/mjs/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/mjs/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/mjs/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/package.json

@@ -1,23 +1,40 @@
 {
   "name": "vovk",
-  "version": "3.0.0-draft.21",
-  "description": "RESTful RPC for Next.js - Transforms Next.js into a powerful REST API platform with RPC capabilities.",
+  "version": "3.0.0-draft.211",
+  "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": "rm -rf dist && tsc && cp {package.json,LICENSE,.npmignore} dist && 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"
@@ -25,5 +42,13 @@
   "homepage": "https://vovk.dev",
   "peerDependencies": {
     "next": "*"
+  },
+  "devDependencies": {
+    "type-fest": "*"
+  },
+  "dependencies": {
+    "@standard-schema/spec": "^1.0.0",
+    "@stoplight/json-schema-sampler": "^0.3.0",
+    "openapi3-ts": "^4.4.0"
   }
 }

package/.npmignore

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

package/Segment.js

@@ -1,182 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._Segment = void 0;
-const types_1 = require("./types");
-const HttpException_1 = require("./HttpException");
-const StreamJSONResponse_1 = require("./StreamJSONResponse");
-const reqQuery_1 = __importDefault(require("./utils/reqQuery"));
-const reqMeta_1 = __importDefault(require("./utils/reqMeta"));
-class _Segment {
-    static getHeadersFromOptions(options) {
-        if (!options)
-            return {};
-        const corsHeaders = {
-            'Access-Control-Allow-Origin': '*',
-            'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS, HEAD',
-            'Access-Control-Allow-Headers': 'Content-Type, Authorization',
-        };
-        const headers = {
-            ...(options.cors ? corsHeaders : {}),
-            ...(options.headers ?? {}),
-        };
-        return headers;
-    }
-    _routes = {
-        GET: new Map(),
-        POST: new Map(),
-        PUT: new Map(),
-        PATCH: new Map(),
-        DELETE: new Map(),
-        HEAD: new Map(),
-        OPTIONS: new Map(),
-    };
-    GET = async (req, data) => this.#callMethod(types_1._HttpMethod.GET, req, await data.params);
-    POST = async (req, data) => this.#callMethod(types_1._HttpMethod.POST, req, await data.params);
-    PUT = async (req, data) => this.#callMethod(types_1._HttpMethod.PUT, req, await data.params);
-    PATCH = async (req, data) => this.#callMethod(types_1._HttpMethod.PATCH, req, await data.params);
-    DELETE = async (req, data) => this.#callMethod(types_1._HttpMethod.DELETE, req, await data.params);
-    HEAD = async (req, data) => this.#callMethod(types_1._HttpMethod.HEAD, req, await data.params);
-    OPTIONS = async (req, data) => this.#callMethod(types_1._HttpMethod.OPTIONS, req, await data.params);
-    respond = (status, body, options) => {
-        return new Response(JSON.stringify(body), {
-            status,
-            headers: {
-                'Content-Type': 'application/json',
-                ..._a.getHeadersFromOptions(options),
-            },
-        });
-    };
-    #respondWithError = (statusCode, message, options) => {
-        return this.respond(statusCode, {
-            statusCode,
-            message,
-            isError: true,
-        }, options);
-    };
-    #callMethod = async (httpMethod, req, params) => {
-        const controllers = this._routes[httpMethod];
-        const methodParams = {};
-        const path = params[Object.keys(params)[0]];
-        const handlers = {};
-        controllers.forEach((staticMethods, controller) => {
-            const prefix = controller._prefix ?? '';
-            if (!controller._activated) {
-                throw new HttpException_1._HttpException(types_1._HttpStatus.INTERNAL_SERVER_ERROR, `Controller "${controller.name}" found but not activated`);
-            }
-            Object.entries(staticMethods).forEach(([path, staticMethod]) => {
-                const fullPath = [prefix, path].filter(Boolean).join('/');
-                handlers[fullPath] = { staticMethod, controller };
-            });
-        });
-        const getHandler = () => {
-            if (Object.keys(params).length === 0) {
-                return handlers[''];
-            }
-            const allMethodKeys = Object.keys(handlers);
-            let methodKeys = [];
-            methodKeys = allMethodKeys
-                // First, try to match literal routes exactly.
-                .filter((p) => {
-                if (p.includes(':'))
-                    return false; // Skip parameterized paths
-                return p === path.join('/');
-            });
-            if (!methodKeys.length) {
-                methodKeys = allMethodKeys.filter((p) => {
-                    const routeSegments = p.split('/');
-                    if (routeSegments.length !== path.length)
-                        return false;
-                    for (let i = 0; i < routeSegments.length; i++) {
-                        const routeSegment = routeSegments[i];
-                        const pathSegment = path[i];
-                        if (routeSegment.startsWith(':')) {
-                            const parameter = routeSegment.slice(1);
-                            if (parameter in methodParams) {
-                                throw new HttpException_1._HttpException(types_1._HttpStatus.INTERNAL_SERVER_ERROR, `Duplicate parameter "${parameter}"`);
-                            }
-                            // If it's a parameterized segment, capture the parameter value.
-                            methodParams[parameter] = pathSegment;
-                        }
-                        else if (routeSegment !== pathSegment) {
-                            // If it's a literal segment and it does not match the corresponding path segment, return false.
-                            return false;
-                        }
-                    }
-                    return true;
-                });
-            }
-            if (methodKeys.length > 1) {
-                throw new HttpException_1._HttpException(types_1._HttpStatus.INTERNAL_SERVER_ERROR, `Conflicting routes found: ${methodKeys.join(', ')}`);
-            }
-            const [methodKey] = methodKeys;
-            if (methodKey) {
-                return handlers[methodKey];
-            }
-            return null;
-        };
-        const handler = getHandler();
-        if (!handler) {
-            return this.#respondWithError(types_1._HttpStatus.NOT_FOUND, `Route ${path.join('/')} is not found`);
-        }
-        const { staticMethod, controller } = handler;
-        req.vovk = {
-            body: () => req.json(),
-            query: () => (0, reqQuery_1.default)(req),
-            meta: (meta) => (0, reqMeta_1.default)(req, meta),
-        };
-        try {
-            const result = await staticMethod.call(controller, req, methodParams);
-            const isIterator = typeof result === 'object' &&
-                !!result &&
-                ((Reflect.has(result, Symbol.iterator) &&
-                    typeof result[Symbol.iterator] === 'function') ||
-                    (Reflect.has(result, Symbol.asyncIterator) &&
-                        typeof result[Symbol.asyncIterator] === 'function'));
-            if (isIterator && !(result instanceof Array)) {
-                const streamResponse = new StreamJSONResponse_1._StreamJSONResponse({
-                    headers: {
-                        ...StreamJSONResponse_1._StreamJSONResponse.defaultHeaders,
-                        ..._a.getHeadersFromOptions(staticMethod._options),
-                    },
-                });
-                void (async () => {
-                    try {
-                        for await (const chunk of result) {
-                            streamResponse.send(chunk);
-                        }
-                    }
-                    catch (e) {
-                        return streamResponse.throw(e);
-                    }
-                    return streamResponse.close();
-                })();
-                return streamResponse;
-            }
-            if (result instanceof Response) {
-                return result;
-            }
-            return this.respond(200, result ?? null, staticMethod._options);
-        }
-        catch (e) {
-            const err = e;
-            try {
-                await controller._onError?.(err, req);
-            }
-            catch (onErrorError) {
-                // eslint-disable-next-line no-console
-                console.error(onErrorError);
-            }
-            if (err.message !== 'NEXT_REDIRECT' && err.message !== 'NEXT_NOT_FOUND') {
-                const statusCode = err.statusCode ?? types_1._HttpStatus.INTERNAL_SERVER_ERROR;
-                return this.#respondWithError(statusCode, err.message, staticMethod._options);
-            }
-            throw e; // if NEXT_REDIRECT or NEXT_NOT_FOUND, rethrow it
-        }
-    };
-}
-exports._Segment = _Segment;
-_a = _Segment;

package/StreamJSONResponse.d.ts

@@ -1,17 +0,0 @@
-import { _KnownAny as KnownAny, _StreamAbortMessage as 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/client/clientizeController.d.ts

@@ -1,4 +0,0 @@
-import { type _VovkControllerSchema as VovkControllerSchema, type _KnownAny as KnownAny } from '../types';
-import { type _VovkClientOptions as VovkClientOptions, type _VovkClient as VovkClient, type _VovkDefaultFetcherOptions as VovkDefaultFetcherOptions } from './types';
-export declare const ARRAY_QUERY_KEY = "_vovkarr";
-export declare const _clientizeController: <T, OPTS extends Record<string, KnownAny> = VovkDefaultFetcherOptions>(controllerSchema: VovkControllerSchema, segmentName?: string, options?: VovkClientOptions<OPTS>) => VovkClient<T, OPTS>;