vovk 3.5.0 → 3.7.0

package/dist/types/core.d.ts

@@ -5,7 +5,7 @@ import type { VovkJSONSchemaBase } from './json-schema.js';
 import type { VovkOperationObject } from './operation.js';
 import type { VovkRequest } from './request.js';
 import type { KnownAny, RequireFields, StaticClass } from './utils.js';
-import type { Responder } from '../core/JSONLinesResponder.js';
+import type { Responder } from '../core/json-lines-responder.js';
 /**
  * Schema for an individual handler, available as MyRPC.myHandler.schema and MyController.myHandler.schema
  */

package/dist/types/inference.d.ts

@@ -1,4 +1,4 @@
-import type { JSONLinesResponder } from '../core/JSONLinesResponder.js';
+import type { JSONLinesResponder } from '../core/json-lines-responder.js';
 import type { VovkStreamAsyncIterable } from './client.js';
 import type { VovkRequest } from './request.js';
 import type { KnownAny } from './utils.js';

package/dist/types/validation.d.ts

@@ -1,7 +1,7 @@
 import type { StandardSchemaV1, StandardJSONSchemaV1 } from './standard-schema.js';
 import type { KnownAny } from './utils.js';
 import type { VovkHandlerSchema, VovkSchema } from './core.js';
-import type { textTypes } from '../req/parseBody.js';
+import type { textTypes } from '../req/parse-body.js';
 export interface CombinedProps<Input = unknown, Output = Input> extends StandardSchemaV1.Props<Input, Output>, StandardJSONSchemaV1.Props<Input, Output> {
 }
 /**

package/dist/utils/camel-case.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Converts string to camel case.
+ * @param {*} input - The value to convert to camel case.
+ * @returns {string}
+ */
+export declare function camelCase(input: string): string;

package/dist/utils/camel-case.js

@@ -0,0 +1,34 @@
+// Convert any value to string
+function valToString(value) {
+    return value == null ? '' : String(value);
+}
+// Regex to match words (including Unicode letters & digits)
+const reUnicodeWord = /[\p{Lu}]{2,}(?=[\p{Lu}][\p{Ll}]+[0-9]*|\b)|[\p{Lu}]?[\p{Ll}]+[0-9]*|[\p{Lu}]|[0-9]+/gu;
+/**
+ * Splits string into an array of words based on Unicode word boundaries
+ * @param {string} str
+ * @returns {string[]}
+ */
+function unicodeWords(str) {
+    return str.match(reUnicodeWord) || [];
+}
+/**
+ * Converts string to camel case.
+ * @param {*} input - The value to convert to camel case.
+ * @returns {string}
+ */
+export function camelCase(input) {
+    const str = valToString(input);
+    // replace separators with space
+    const sanitized = str.replace(/[\s_-]+/g, ' ').trim();
+    const words = unicodeWords(sanitized);
+    return words
+        .map((word, index) => {
+        const lower = word.toLowerCase();
+        if (index === 0) {
+            return lower;
+        }
+        return lower.charAt(0).toUpperCase() + lower.slice(1);
+    })
+        .join('');
+}

package/dist/utils/deep-extend.d.ts

@@ -0,0 +1,54 @@
+/*!
+ * @description Recursive object extending
+ * @author Viacheslav Lotsmanov <lotsmanov89@gmail.com>
+ * @license MIT
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013-2018 Viacheslav Lotsmanov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+import type { KnownAny } from '../types/utils.js';
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? DeepPartial<U>[] : T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+type SpecificValue = Buffer | Date | RegExp;
+declare function isSpecificValue(val: KnownAny): val is SpecificValue;
+declare function cloneSpecificValue(val: SpecificValue): SpecificValue;
+/**
+ * Recursive cloning array.
+ */
+declare function deepCloneArray<T = KnownAny>(arr: T[]): T[];
+declare function safeGetProperty<T extends object>(object: T, property: PropertyKey): KnownAny;
+/**
+ * Extending object that entered in first argument.
+ *
+ * Returns extended object or false if have no target object or incorrect type.
+ *
+ * If you wish to clone source object (without modify it), just use empty new
+ * object as first argument, like this:
+ *   deepExtend({}, yourObj_1, [yourObj_N]);
+ */
+declare function deepExtend<T extends object>(...args: [T, ...Partial<T>[]]): T;
+declare function deepExtend<T extends object, U extends object>(target: T, source: U): T & U;
+declare function deepExtend<T extends object, U extends object, V extends object>(target: T, source1: U, source2: V): T & U & V;
+declare function deepExtend<T extends object, U extends object, V extends object, W extends object>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
+declare function deepExtend<T extends object>(target: T, ...sources: KnownAny[]): T;
+export { deepExtend, deepCloneArray, isSpecificValue, cloneSpecificValue, safeGetProperty };
+export type { DeepPartial, SpecificValue };

package/dist/utils/deep-extend.js

@@ -0,0 +1,127 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/*!
+ * @description Recursive object extending
+ * @author Viacheslav Lotsmanov <lotsmanov89@gmail.com>
+ * @license MIT
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013-2018 Viacheslav Lotsmanov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+function isSpecificValue(val) {
+    return val instanceof Buffer || val instanceof Date || val instanceof RegExp;
+}
+function cloneSpecificValue(val) {
+    if (val instanceof Buffer) {
+        const x = Buffer.alloc ? Buffer.alloc(val.length) : Buffer.from(val);
+        val.copy(x);
+        return x;
+    }
+    else if (val instanceof Date) {
+        return new Date(val.getTime());
+    }
+    else if (val instanceof RegExp) {
+        return new RegExp(val);
+    }
+    else {
+        throw new Error('Unexpected situation');
+    }
+}
+/**
+ * Recursive cloning array.
+ */
+function deepCloneArray(arr) {
+    const clone = [];
+    arr.forEach((item, index) => {
+        if (typeof item === 'object' && item !== null) {
+            if (Array.isArray(item)) {
+                clone[index] = deepCloneArray(item);
+            }
+            else if (isSpecificValue(item)) {
+                clone[index] = cloneSpecificValue(item);
+            }
+            else {
+                clone[index] = deepExtend({}, item);
+            }
+        }
+        else {
+            clone[index] = item;
+        }
+    });
+    return clone;
+}
+function safeGetProperty(object, property) {
+    return property === '__proto__' ? undefined : object[property];
+}
+function deepExtend(...args) {
+    if (args.length < 1 || typeof args[0] !== 'object') {
+        return false;
+    }
+    if (args.length < 2) {
+        return args[0];
+    }
+    const target = args[0];
+    // convert arguments to array and cut off target object
+    const sources = args.slice(1);
+    sources.forEach((obj) => {
+        // skip argument if isn't an object, is null, or is an array
+        if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+            return;
+        }
+        Object.keys(obj).forEach((key) => {
+            const src = safeGetProperty(target, key); // source value
+            const val = safeGetProperty(obj, key); // new value
+            // recursion prevention
+            if (val === target) {
+                return;
+            }
+            else if (typeof val !== 'object' || val === null) {
+                /**
+                 * if new value isn't object then just overwrite by new value
+                 * instead of extending.
+                 */
+                target[key] = val;
+                return;
+            }
+            // just clone arrays (and recursive clone objects inside)
+            else if (Array.isArray(val)) {
+                target[key] = deepCloneArray(val);
+                return;
+            }
+            // custom cloning and overwrite for specific objects
+            else if (isSpecificValue(val)) {
+                target[key] = cloneSpecificValue(val);
+                return;
+            }
+            // overwrite by new value if source isn't object or array
+            else if (typeof src !== 'object' || src === null || Array.isArray(src)) {
+                target[key] = deepExtend({}, val);
+                return;
+            }
+            // source value and new value is objects both, extending...
+            else {
+                target[key] = deepExtend(src, val);
+                return;
+            }
+        });
+    });
+    return target;
+}
+export { deepExtend, deepCloneArray, isSpecificValue, cloneSpecificValue, safeGetProperty };

package/dist/utils/file-name-to-disposition.d.ts

@@ -0,0 +1 @@
+export declare function fileNameToDisposition(filename: string): string;

package/dist/utils/file-name-to-disposition.js

@@ -0,0 +1,3 @@
+export function fileNameToDisposition(filename) {
+    return `attachment; filename="${filename.replace(/[^\x20-\x7E]|"/g, '_')}"; filename*=UTF-8''${encodeURIComponent(filename)}`;
+}

package/dist/utils/to-kebab-case.d.ts

@@ -0,0 +1 @@
+export declare const toKebabCase: (str: string) => string;

package/dist/utils/to-kebab-case.js

@@ -0,0 +1,5 @@
+export const toKebabCase = (str) => str
+    .replace(/([a-z0-9])([A-Z])/g, '$1-$2') // Add hyphen between lowercase/digit and uppercase
+    .replace(/([A-Z])([A-Z])(?=[a-z])/g, '$1-$2') // Add hyphen between uppercase letters if the second one is followed by a lowercase
+    .toLowerCase()
+    .replace(/^-/, ''); // Remove leading hyphen

package/dist/utils/trim-path.d.ts

@@ -0,0 +1 @@
+export declare const trimPath: (path: string) => string;

package/dist/utils/trim-path.js

@@ -0,0 +1 @@
+export const trimPath = (path) => path.trim().replace(/^\/|\/$/g, '');

package/dist/utils/upper-first.d.ts

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

package/dist/utils/upper-first.js

@@ -0,0 +1,3 @@
+export function upperFirst(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/dist/validation/create-standard-validation.d.ts

@@ -0,0 +1,268 @@
+import type { VovkRequest } from '../types/request.js';
+import type { BodyTypeFromContentType, CombinedSpec, ContentType, NormalizeContentType } from '../types/validation.js';
+import type { VovkValidationType } from '../types/core.js';
+import type { VovkOperationObject } from '../types/operation.js';
+import type { KnownAny } from '../types/utils.js';
+type ProcedureOptions<TBody extends CombinedSpec, TQuery extends CombinedSpec, TParams extends CombinedSpec, TOutput extends CombinedSpec, TIteration extends CombinedSpec, TContentType extends ContentType | ContentType[]> = {
+    contentType?: TContentType;
+    body?: TBody;
+    query?: TQuery;
+    params?: TParams;
+    output?: TOutput;
+    iteration?: TIteration;
+    disableServerSideValidation?: boolean | VovkValidationType[];
+    skipSchemaEmission?: boolean | VovkValidationType[];
+    validateEachIteration?: boolean;
+    preferTransformed?: boolean;
+    operationObject?: VovkOperationObject;
+    target?: CombinedSpec.Target;
+};
+export declare function createStandardValidation({ toJSONSchema, }: {
+    toJSONSchema: (model: KnownAny, meta: {
+        validationType: VovkValidationType;
+        target: CombinedSpec.Target | undefined;
+    }) => KnownAny;
+}): (<TBody extends CombinedSpec, TQuery extends CombinedSpec, TParams extends CombinedSpec, TOutput extends CombinedSpec, TIteration extends CombinedSpec, TReq extends VovkRequest<KnownAny, KnownAny, KnownAny> = VovkRequest<TBody extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TBody> : undefined, TQuery extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TQuery> : undefined, TParams extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TParams> : undefined>, TContentType extends ContentType | ContentType[] = ["application/json"]>(options?: ProcedureOptions<TBody, TQuery, TParams, TOutput, TIteration, TContentType>) => {
+    (req: TReq, params: TParams extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TParams> : Record<string, string>): KnownAny;
+    __types: {
+        body: TBody extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TBody> : any;
+        query: TQuery extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TQuery> : any;
+        params: TParams extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TParams> : any;
+        output: unknown extends CombinedSpec.InferOutput<TOutput> ? any : CombinedSpec.InferOutput<TOutput>;
+        iteration: TIteration extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TIteration> : any;
+        contentType: NormalizeContentType<TContentType>;
+    };
+    __handleFn: (...args: KnownAny[]) => KnownAny;
+    isRPC?: boolean;
+    fn: {
+        <TTransformed>(input: {
+            body?: (TBody extends CombinedSpec<unknown, unknown> ? BodyTypeFromContentType<NormalizeContentType<TContentType>, CombinedSpec.InferOutput<TBody>> : undefined) | undefined;
+            query?: (TQuery extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TQuery> : undefined) | undefined;
+            params?: (TParams extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TParams> : undefined) | undefined;
+            meta?: Record<string, KnownAny>;
+            disableClientValidation?: boolean;
+            transform: (data: any, fakeReq: Pick<TReq, "vovk">) => TTransformed;
+        }): Promise<TTransformed>;
+        <TReturnType = any>(input?: {
+            body?: (TBody extends CombinedSpec<unknown, unknown> ? BodyTypeFromContentType<NormalizeContentType<TContentType>, CombinedSpec.InferOutput<TBody>> : undefined) | undefined;
+            query?: (TQuery extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TQuery> : undefined) | undefined;
+            params?: (TParams extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TParams> : undefined) | undefined;
+            meta?: Record<string, KnownAny>;
+            disableClientValidation?: boolean;
+        } | undefined): TReturnType;
+        (input?: {
+            body?: (TBody extends CombinedSpec<unknown, unknown> ? BodyTypeFromContentType<NormalizeContentType<TContentType>, CombinedSpec.InferOutput<TBody>> : undefined) | undefined;
+            query?: (TQuery extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TQuery> : undefined) | undefined;
+            params?: (TParams extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TParams> : undefined) | undefined;
+            meta?: Record<string, KnownAny>;
+            disableClientValidation?: boolean;
+        } | undefined): any;
+    };
+    definition: KnownAny;
+    schema: KnownAny;
+    wrapper?: KnownAny;
+} & {
+    handle: unknown extends CombinedSpec.InferOutput<TOutput> ? <THandleFn extends (req: TReq, params: TParams extends CombinedSpec ? CombinedSpec.InferOutput<TParams> : Record<string, string>) => KnownAny>(fn: THandleFn) => {
+        (req: TReq, params: TParams extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TParams> : Record<string, string>): KnownAny;
+        __types: {
+            body: TBody extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TBody> : any;
+            query: TQuery extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TQuery> : any;
+            params: TParams extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TParams> : any;
+            output: unknown extends CombinedSpec.InferOutput<TOutput> ? any : CombinedSpec.InferOutput<TOutput>;
+            iteration: TIteration extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TIteration> : any;
+            contentType: NormalizeContentType<TContentType>;
+        };
+        __handleFn: THandleFn;
+        isRPC?: boolean;
+        fn: {
+            <TTransformed>(input: {
+                body?: (TBody extends CombinedSpec<unknown, unknown> ? BodyTypeFromContentType<NormalizeContentType<TContentType>, CombinedSpec.InferOutput<TBody>> : undefined) | undefined;
+                query?: (TQuery extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TQuery> : undefined) | undefined;
+                params?: (TParams extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TParams> : undefined) | undefined;
+                meta?: Record<string, KnownAny>;
+                disableClientValidation?: boolean;
+                transform: (data: Awaited<ReturnType<THandleFn>>, fakeReq: Pick<TReq, "vovk">) => TTransformed;
+            }): Promise<TTransformed>;
+            <TReturnType = ReturnType<THandleFn>>(input?: {
+                body?: (TBody extends CombinedSpec<unknown, unknown> ? BodyTypeFromContentType<NormalizeContentType<TContentType>, CombinedSpec.InferOutput<TBody>> : undefined) | undefined;
+                query?: (TQuery extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TQuery> : undefined) | undefined;
+                params?: (TParams extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TParams> : undefined) | undefined;
+                meta?: Record<string, KnownAny>;
+                disableClientValidation?: boolean;
+            } | undefined): TReturnType;
+            (input?: {
+                body?: (TBody extends CombinedSpec<unknown, unknown> ? BodyTypeFromContentType<NormalizeContentType<TContentType>, CombinedSpec.InferOutput<TBody>> : undefined) | undefined;
+                query?: (TQuery extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TQuery> : undefined) | undefined;
+                params?: (TParams extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TParams> : undefined) | undefined;
+                meta?: Record<string, KnownAny>;
+                disableClientValidation?: boolean;
+            } | undefined): ReturnType<THandleFn>;
+        };
+        definition: KnownAny;
+        schema: KnownAny;
+        wrapper?: KnownAny;
+    } : (fn: (req: TReq, params: TParams extends CombinedSpec ? CombinedSpec.InferOutput<TParams> : Record<string, string>) => unknown extends CombinedSpec.InferOutput<TOutput> ? any : CombinedSpec.InferOutput<TOutput> | Promise<CombinedSpec.InferOutput<TOutput>> | (unknown extends CombinedSpec.InferOutput<TIteration> ? never : AsyncGenerator<CombinedSpec.InferOutput<TIteration>, any, any>)) => {
+        (req: TReq, params: TParams extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TParams> : Record<string, string>): KnownAny;
+        __types: {
+            body: TBody extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TBody> : any;
+            query: TQuery extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TQuery> : any;
+            params: TParams extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TParams> : any;
+            output: unknown extends CombinedSpec.InferOutput<TOutput> ? any : CombinedSpec.InferOutput<TOutput>;
+            iteration: TIteration extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TIteration> : any;
+            contentType: NormalizeContentType<TContentType>;
+        };
+        __handleFn: (req: TReq, params: TParams extends CombinedSpec ? CombinedSpec.InferOutput<TParams> : Record<string, string>) => unknown extends CombinedSpec.InferOutput<TOutput> ? any : CombinedSpec.InferOutput<TOutput> | Promise<CombinedSpec.InferOutput<TOutput>> | (unknown extends CombinedSpec.InferOutput<TIteration> ? never : AsyncGenerator<CombinedSpec.InferOutput<TIteration>, any, any>);
+        isRPC?: boolean;
+        fn: {
+            <TTransformed>(input: {
+                body?: (TBody extends CombinedSpec<unknown, unknown> ? BodyTypeFromContentType<NormalizeContentType<TContentType>, CombinedSpec.InferOutput<TBody>> : undefined) | undefined;
+                query?: (TQuery extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TQuery> : undefined) | undefined;
+                params?: (TParams extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TParams> : undefined) | undefined;
+                meta?: Record<string, KnownAny>;
+                disableClientValidation?: boolean;
+                transform: (data: Awaited<unknown extends CombinedSpec.InferOutput<TOutput> ? any : CombinedSpec.InferOutput<TOutput> | Promise<CombinedSpec.InferOutput<TOutput>> | (unknown extends CombinedSpec.InferOutput<TIteration> ? never : AsyncGenerator<CombinedSpec.InferOutput<TIteration>, any, any>)>, fakeReq: Pick<TReq, "vovk">) => TTransformed;
+            }): Promise<TTransformed>;
+            <TReturnType = unknown extends CombinedSpec.InferOutput<TOutput> ? any : CombinedSpec.InferOutput<TOutput> | Promise<CombinedSpec.InferOutput<TOutput>> | (unknown extends CombinedSpec.InferOutput<TIteration> ? never : AsyncGenerator<CombinedSpec.InferOutput<TIteration>, any, any>)>(input?: {
+                body?: (TBody extends CombinedSpec<unknown, unknown> ? BodyTypeFromContentType<NormalizeContentType<TContentType>, CombinedSpec.InferOutput<TBody>> : undefined) | undefined;
+                query?: (TQuery extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TQuery> : undefined) | undefined;
+                params?: (TParams extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TParams> : undefined) | undefined;
+                meta?: Record<string, KnownAny>;
+                disableClientValidation?: boolean;
+            } | undefined): TReturnType;
+            (input?: {
+                body?: (TBody extends CombinedSpec<unknown, unknown> ? BodyTypeFromContentType<NormalizeContentType<TContentType>, CombinedSpec.InferOutput<TBody>> : undefined) | undefined;
+                query?: (TQuery extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TQuery> : undefined) | undefined;
+                params?: (TParams extends CombinedSpec<unknown, unknown> ? CombinedSpec.InferOutput<TParams> : undefined) | undefined;
+                meta?: Record<string, KnownAny>;
+                disableClientValidation?: boolean;
+            } | undefined): unknown extends CombinedSpec.InferOutput<TOutput> ? any : CombinedSpec.InferOutput<TOutput> | Promise<CombinedSpec.InferOutput<TOutput>> | (unknown extends CombinedSpec.InferOutput<TIteration> ? never : AsyncGenerator<CombinedSpec.InferOutput<TIteration>, any, any>);
+        };
+        definition: KnownAny;
+        schema: KnownAny;
+        wrapper?: KnownAny;
+    };
+}) & {
+    createTool: {
+        <TInput, TOutput, TToModelOutput extends (...args: KnownAny[]) => KnownAny>(options: {
+            name: string;
+            title?: string;
+            description: string;
+            onExecute?: ((result: unknown, tool: import("../index.js").VovkTool<TInput, TOutput, TToModelOutput extends import("../tools/to-model-output-default.js").ToModelOutputDefaultFn ? import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>) => void) | undefined;
+            onError?: ((error: Error, tool: import("../index.js").VovkTool<TInput, TOutput, TToModelOutput extends import("../tools/to-model-output-default.js").ToModelOutputDefaultFn ? import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>) => void) | undefined;
+            target?: CombinedSpec.Target;
+        } & {
+            inputSchema: CombinedSpec<TInput, TInput>;
+        } & {
+            outputSchema: CombinedSpec<TOutput, TOutput>;
+        } & {
+            execute: (input: TInput, processingMeta?: KnownAny) => TOutput | Promise<TOutput>;
+            toModelOutput: TToModelOutput;
+        }): import("../index.js").VovkTool<TInput, TOutput, TToModelOutput extends import("../tools/to-model-output-default.js").ToModelOutputDefaultFn ? import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>;
+        <TInput, TOutput>(options: {
+            name: string;
+            title?: string;
+            description: string;
+            onExecute?: ((result: unknown, tool: import("../index.js").VovkTool<TInput, TOutput, import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput>>) => void) | undefined;
+            onError?: ((error: Error, tool: import("../index.js").VovkTool<TInput, TOutput, import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput>>) => void) | undefined;
+            target?: CombinedSpec.Target;
+        } & {
+            inputSchema: CombinedSpec<TInput, TInput>;
+        } & {
+            outputSchema: CombinedSpec<TOutput, TOutput>;
+        } & {
+            execute: (input: TInput, processingMeta?: KnownAny) => TOutput | Promise<TOutput>;
+            toModelOutput?: undefined;
+        }): import("../index.js").VovkTool<TInput, TOutput, import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput>>;
+        <TInput, TOutput, TToModelOutput extends (...args: KnownAny[]) => KnownAny>(options: {
+            name: string;
+            title?: string;
+            description: string;
+            onExecute?: ((result: unknown, tool: import("../index.js").VovkTool<TInput, TOutput, TToModelOutput extends import("../tools/to-model-output-default.js").ToModelOutputDefaultFn ? import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>) => void) | undefined;
+            onError?: ((error: Error, tool: import("../index.js").VovkTool<TInput, TOutput, TToModelOutput extends import("../tools/to-model-output-default.js").ToModelOutputDefaultFn ? import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>) => void) | undefined;
+            target?: CombinedSpec.Target;
+        } & {
+            inputSchema: CombinedSpec<TInput, TInput>;
+        } & {
+            outputSchema?: undefined;
+        } & {
+            execute: (input: TInput, processingMeta?: KnownAny) => TOutput | Promise<TOutput>;
+            toModelOutput: TToModelOutput;
+        }): import("../index.js").VovkTool<TInput, TOutput, TToModelOutput extends import("../tools/to-model-output-default.js").ToModelOutputDefaultFn ? import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>;
+        <TInput, TOutput>(options: {
+            name: string;
+            title?: string;
+            description: string;
+            onExecute?: ((result: unknown, tool: import("../index.js").VovkTool<TInput, TOutput, import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput>>) => void) | undefined;
+            onError?: ((error: Error, tool: import("../index.js").VovkTool<TInput, TOutput, import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput>>) => void) | undefined;
+            target?: CombinedSpec.Target;
+        } & {
+            inputSchema: CombinedSpec<TInput, TInput>;
+        } & {
+            outputSchema?: undefined;
+        } & {
+            execute: (input: TInput, processingMeta?: KnownAny) => TOutput | Promise<TOutput>;
+            toModelOutput?: undefined;
+        }): import("../index.js").VovkTool<TInput, TOutput, import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput>>;
+        <TOutput, TToModelOutput extends (...args: KnownAny[]) => KnownAny>(options: {
+            name: string;
+            title?: string;
+            description: string;
+            onExecute?: ((result: unknown, tool: import("../index.js").VovkTool<null, TOutput, TToModelOutput extends import("../tools/to-model-output-default.js").ToModelOutputDefaultFn ? import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>) => void) | undefined;
+            onError?: ((error: Error, tool: import("../index.js").VovkTool<null, TOutput, TToModelOutput extends import("../tools/to-model-output-default.js").ToModelOutputDefaultFn ? import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>) => void) | undefined;
+            target?: CombinedSpec.Target;
+        } & {
+            inputSchema?: undefined;
+        } & {
+            outputSchema: CombinedSpec<TOutput, TOutput>;
+        } & {
+            execute: (input: null, processingMeta?: KnownAny) => TOutput | Promise<TOutput>;
+            toModelOutput: TToModelOutput;
+        }): import("../index.js").VovkTool<null, TOutput, TToModelOutput extends import("../tools/to-model-output-default.js").ToModelOutputDefaultFn ? import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>;
+        <TOutput>(options: {
+            name: string;
+            title?: string;
+            description: string;
+            onExecute?: ((result: unknown, tool: import("../index.js").VovkTool<null, TOutput, import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput>>) => void) | undefined;
+            onError?: ((error: Error, tool: import("../index.js").VovkTool<null, TOutput, import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput>>) => void) | undefined;
+            target?: CombinedSpec.Target;
+        } & {
+            inputSchema?: undefined;
+        } & {
+            outputSchema: CombinedSpec<TOutput, TOutput>;
+        } & {
+            execute: (input: null, processingMeta?: KnownAny) => TOutput | Promise<TOutput>;
+            toModelOutput?: undefined;
+        }): import("../index.js").VovkTool<null, TOutput, import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput>>;
+        <TOutput, TToModelOutput extends (...args: KnownAny[]) => KnownAny>(options: {
+            name: string;
+            title?: string;
+            description: string;
+            onExecute?: ((result: unknown, tool: import("../index.js").VovkTool<null, TOutput, TToModelOutput extends import("../tools/to-model-output-default.js").ToModelOutputDefaultFn ? import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>) => void) | undefined;
+            onError?: ((error: Error, tool: import("../index.js").VovkTool<null, TOutput, TToModelOutput extends import("../tools/to-model-output-default.js").ToModelOutputDefaultFn ? import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>) => void) | undefined;
+            target?: CombinedSpec.Target;
+        } & {
+            inputSchema?: undefined;
+        } & {
+            outputSchema?: undefined;
+        } & {
+            execute: (input: null, processingMeta?: KnownAny) => TOutput | Promise<TOutput>;
+            toModelOutput: TToModelOutput;
+        }): import("../index.js").VovkTool<null, TOutput, TToModelOutput extends import("../tools/to-model-output-default.js").ToModelOutputDefaultFn ? import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>;
+        <TOutput>(options: {
+            name: string;
+            title?: string;
+            description: string;
+            onExecute?: ((result: unknown, tool: import("../index.js").VovkTool<null, TOutput, import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput>>) => void) | undefined;
+            onError?: ((error: Error, tool: import("../index.js").VovkTool<null, TOutput, import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput>>) => void) | undefined;
+            target?: CombinedSpec.Target;
+        } & {
+            inputSchema?: undefined;
+        } & {
+            outputSchema?: undefined;
+        } & {
+            execute: (input: null, processingMeta?: KnownAny) => TOutput | Promise<TOutput>;
+            toModelOutput?: undefined;
+        }): import("../index.js").VovkTool<null, TOutput, import("../tools/to-model-output-default.js").DefaultModelOutput<TOutput>>;
+    };
+};
+export {};

package/dist/validation/create-standard-validation.js

@@ -0,0 +1,45 @@
+import { withValidationLibrary } from './with-validation-library.js';
+import { HttpException } from '../core/http-exception.js';
+import { createToolFactory } from '../tools/create-tool-factory.js';
+import { HttpStatus } from './create-validate-on-client.js';
+export function createStandardValidation({ toJSONSchema, }) {
+    function callWithValidationLibrary(options, handle) {
+        const normalizedContentType = (typeof options.contentType === 'string' ? [options.contentType] : options.contentType);
+        return withValidationLibrary({
+            contentType: normalizedContentType,
+            body: options.body,
+            query: options.query,
+            params: options.params,
+            output: options.output,
+            iteration: options.iteration,
+            disableServerSideValidation: options.disableServerSideValidation,
+            skipSchemaEmission: options.skipSchemaEmission,
+            validateEachIteration: options.validateEachIteration,
+            handle: handle,
+            toJSONSchema: (model, opts) => toJSONSchema(model, { validationType: opts.validationType, target: options.target }),
+            validate: async (data, model, { validationType, i }) => {
+                const result = await model['~standard'].validate(data);
+                if (result.issues?.length) {
+                    throw new HttpException(HttpStatus.BAD_REQUEST, `Validation failed. Invalid ${validationType === 'iteration' ? `${validationType} #${i}` : validationType}: ${result.issues
+                        .map(({ message, path }) => `${message}${path ? ` at ${path.join('.')}` : ''}`)
+                        .join(', ')}`, { issues: result.issues });
+                }
+                return result.value;
+            },
+            preferTransformed: options.preferTransformed,
+            operationObject: options.operationObject,
+        });
+    }
+    // Implementation
+    function procedure(options) {
+        const notImplementedHandler = callWithValidationLibrary(options ?? {}, () => {
+            throw new HttpException(HttpStatus.NOT_IMPLEMENTED, 'Not implemented');
+        });
+        return Object.assign(notImplementedHandler, {
+            handle(fn) {
+                return callWithValidationLibrary(options ?? {}, fn);
+            },
+        });
+    }
+    return Object.assign(procedure, { createTool: createToolFactory({ toJSONSchema }) });
+}

package/dist/validation/create-validate-on-client.d.ts

@@ -0,0 +1,14 @@
+import { HttpException } from '../core/http-exception.js';
+import { HttpStatus } from '../types/enums.js';
+import type { VovkValidateOnClient } from '../types/validation.js';
+import type { VovkJSONSchemaBase } from '../types/json-schema.js';
+import type { VovkSchema } from '../types/core.js';
+export { createValidateOnClient, HttpException, HttpStatus, type VovkJSONSchemaBase, type VovkValidateOnClient, type VovkSchema, };
+/**
+ * Creates a validation function for client-side input validation.
+ */
+declare function createValidateOnClient<TFetcherOptions>({ validate, }: {
+    validate: (input: unknown, schema: VovkJSONSchemaBase, meta: Parameters<VovkValidateOnClient<TFetcherOptions>>[2] & {
+        type: 'body' | 'query' | 'params';
+    }) => unknown | Promise<unknown>;
+}): VovkValidateOnClient<TFetcherOptions>;