vovk 3.5.0 → 3.7.0

package/dist/req/parse-body.d.ts

@@ -0,0 +1,4 @@
+/** Application MIME types that are parsed as text by parseBody. */
+export declare const textTypes: readonly ["application/xml", "application/xhtml+xml", "application/javascript", "application/x-javascript", "application/ecmascript", "application/yaml", "application/x-yaml", "application/graphql", "application/sql", "application/toml", "application/x-ndjson", "application/ndjson", "application/jsonl", "application/jsonlines", "application/x-jsonlines"];
+export declare const textSuffixPattern: RegExp;
+export declare function parseBody(req: Request): Promise<Record<string, unknown> | FormData | URLSearchParams | string | File>;

package/dist/req/parse-body.js

@@ -0,0 +1,49 @@
+import { parseForm } from './parse-form.js';
+const formTypes = ['multipart/form-data', 'application/x-www-form-urlencoded'];
+/** Application MIME types that are parsed as text by parseBody. */
+export const textTypes = [
+    'application/xml',
+    'application/xhtml+xml',
+    'application/javascript',
+    'application/x-javascript',
+    'application/ecmascript',
+    'application/yaml',
+    'application/x-yaml',
+    'application/graphql',
+    'application/sql',
+    'application/toml',
+    'application/x-ndjson',
+    'application/ndjson',
+    'application/jsonl',
+    'application/jsonlines',
+    'application/x-jsonlines',
+];
+export const textSuffixPattern = /\+(xml|text|yaml|json-seq)\b/;
+const includes = (ct, types) => types.some((t) => ct.includes(t));
+export async function parseBody(req) {
+    const contentType = req.headers?.get('content-type');
+    // application/json or +json suffix types (e.g. application/ld+json, application/vnd.api+json) → object
+    if (!contentType || contentType.includes('application/json') || contentType.includes('+json')) {
+        const body = await req.json();
+        req.json = () => Promise.resolve(body);
+        return body;
+    }
+    // multipart/form-data → FormData
+    if (includes(contentType, formTypes)) {
+        const body = await req.formData();
+        req.formData = () => Promise.resolve(body);
+        return parseForm(body);
+    }
+    // text/* or known text-based application types → string
+    if (contentType.startsWith('text/') || includes(contentType, textTypes) || textSuffixPattern.test(contentType)) {
+        const body = await req.text();
+        req.text = () => Promise.resolve(body);
+        return body;
+    }
+    // Everything else (octet-stream, image/*, video/*, application/pdf, etc.) → File
+    const disposition = req.headers?.get('content-disposition');
+    const fileName = disposition?.match(/filename="(.+?)"/)?.[1] ?? 'file';
+    const body = await req.blob();
+    req.blob = () => Promise.resolve(body);
+    return new File([body], fileName, { type: contentType });
+}

package/dist/req/parse-form.d.ts

@@ -0,0 +1 @@
+export declare function parseForm<T>(body: FormData): Promise<T>;

package/dist/req/parse-form.js

@@ -0,0 +1,24 @@
+export async function parseForm(body) {
+    const formData = {};
+    for (const [key, value] of body.entries()) {
+        const existing = formData[key];
+        if (value instanceof File) {
+            if (existing) {
+                formData[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
+            }
+            else {
+                formData[key] = value;
+            }
+        }
+        else {
+            const str = value.toString();
+            if (existing) {
+                formData[key] = Array.isArray(existing) ? [...existing, str] : [existing, str];
+            }
+            else {
+                formData[key] = str;
+            }
+        }
+    }
+    return formData;
+}

package/dist/req/parse-query.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Deserialize a bracket-based query string into an object.
+ *
+ * Supports:
+ *   - Key/value pairs with nested brackets (e.g. "a[b][0]=value")
+ *   - Arrays with empty bracket (e.g. "arr[]=1&arr[]=2")
+ *   - Mixed arrays of objects, etc.
+ *
+ * @example
+ *   parseQuery("x=xx&y[0]=yy&y[1]=uu&z[f]=x&z[u][0]=uu&z[u][1]=xx&z[d][x]=ee")
+ *   => {
+ *        x: "xx",
+ *        y: ["yy", "uu"],
+ *        z: {
+ *          f: "x",
+ *          u: ["uu", "xx"],
+ *          d: { x: "ee" }
+ *        }
+ *      }
+ *
+ * @param queryString - The raw query string (e.g. location.search.slice(1))
+ * @returns           - A nested object representing the query params
+ */
+export declare function parseQuery(queryString: string): Record<string, unknown>;

package/dist/req/parse-query.js

@@ -0,0 +1,156 @@
+/**
+ * Parse a bracket-based key (e.g. "z[d][0][x]" or "arr[]")
+ * into an array of path segments (strings or special push-markers).
+ *
+ * Example: "z[d][0][x]" => ["z", "d", "0", "x"]
+ * Example: "arr[]"      => ["arr", "" ]  // "" indicates "push" onto array
+ */
+function parseKey(key) {
+    // The first segment is everything up to the first '[' (or the entire key if no '[')
+    const segments = [];
+    const topKeyMatch = key.match(/^([^[\]]+)/);
+    if (topKeyMatch) {
+        segments.push(topKeyMatch[1]);
+    }
+    else {
+        // If it starts with brackets, treat it as empty? (edge case)
+        segments.push('');
+    }
+    // Now capture all bracket parts: [something], [0], []
+    const bracketRegex = /\[([^[\]]*)\]/g;
+    let match;
+    while (true) {
+        match = bracketRegex.exec(key);
+        if (match === null)
+            break;
+        // match[1] is the content inside the brackets
+        segments.push(match[1]);
+    }
+    return segments;
+}
+/**
+ * Recursively set a value in a nested object/array, given a path of segments.
+ * - If segment is numeric => treat as array index
+ * - If segment is empty "" => push to array
+ * - Else => object property
+ */
+function setValue(obj, path, value) {
+    let current = obj;
+    for (let i = 0; i < path.length; i++) {
+        const segment = path[i];
+        // If we're at the last segment, set the value
+        if (i === path.length - 1) {
+            if (segment === '') {
+                // Empty bracket => push
+                if (!Array.isArray(current)) {
+                    current = [];
+                }
+                current.push(value);
+            }
+            else if (!Number.isNaN(Number(segment))) {
+                // Numeric segment => array index
+                const idx = Number(segment);
+                if (!Array.isArray(current)) {
+                    current = [];
+                }
+                current[idx] = value;
+            }
+            else {
+                // Object property
+                current[segment] = value;
+            }
+        }
+        else {
+            // Not the last segment: descend into existing structure or create it
+            const nextSegment = path[i + 1];
+            if (segment === '') {
+                // Empty bracket => push
+                if (!Array.isArray(current)) {
+                    // Convert the current node into an array, if not one
+                    current = [];
+                }
+                // If we are not at the last path, we need a placeholder object or array
+                // for the next segment. We'll push something and move current to that.
+                if (current.length === 0) {
+                    // nothing in array yet
+                    current.push(typeof nextSegment === 'string' && !Number.isNaN(Number(nextSegment)) ? [] : {});
+                }
+                else if (typeof nextSegment === 'string' && !Number.isNaN(Number(nextSegment))) {
+                    // next is numeric => we want an array
+                    if (!Array.isArray(current[current.length - 1])) {
+                        current[current.length - 1] = [];
+                    }
+                }
+                else {
+                    // next is not numeric => we want an object
+                    if (typeof current[current.length - 1] !== 'object') {
+                        current[current.length - 1] = {};
+                    }
+                }
+                current = current[current.length - 1];
+            }
+            else if (!Number.isNaN(Number(segment))) {
+                // segment is numeric => array index
+                const idx = Number(segment);
+                if (!Array.isArray(current)) {
+                    current = [];
+                }
+                if (current[idx] === undefined) {
+                    // Create placeholder for next segment
+                    current[idx] = typeof nextSegment === 'string' && !Number.isNaN(Number(nextSegment)) ? [] : {};
+                }
+                current = current[idx];
+            }
+            else {
+                // segment is an object key
+                if (current[segment] === undefined) {
+                    // Create placeholder
+                    current[segment] = typeof nextSegment === 'string' && !Number.isNaN(Number(nextSegment)) ? [] : {};
+                }
+                current = current[segment];
+            }
+        }
+    }
+}
+/**
+ * Deserialize a bracket-based query string into an object.
+ *
+ * Supports:
+ *   - Key/value pairs with nested brackets (e.g. "a[b][0]=value")
+ *   - Arrays with empty bracket (e.g. "arr[]=1&arr[]=2")
+ *   - Mixed arrays of objects, etc.
+ *
+ * @example
+ *   parseQuery("x=xx&y[0]=yy&y[1]=uu&z[f]=x&z[u][0]=uu&z[u][1]=xx&z[d][x]=ee")
+ *   => {
+ *        x: "xx",
+ *        y: ["yy", "uu"],
+ *        z: {
+ *          f: "x",
+ *          u: ["uu", "xx"],
+ *          d: { x: "ee" }
+ *        }
+ *      }
+ *
+ * @param queryString - The raw query string (e.g. location.search.slice(1))
+ * @returns           - A nested object representing the query params
+ */
+export function parseQuery(queryString) {
+    const result = {};
+    if (!queryString)
+        return result;
+    // Split into key=value pairs
+    const pairs = queryString
+        .replace(/^\?/, '') // Remove leading "?" if present
+        .split('&');
+    for (const pair of pairs) {
+        const [rawKey, rawVal = ''] = pair.split('=');
+        const decodedKey = decodeURIComponent(rawKey);
+        const decodedVal = decodeURIComponent(rawVal);
+        // Parse bracket notation
+        const pathSegments = parseKey(decodedKey);
+        // Insert into the result object
+        setValue(result, pathSegments, decodedVal);
+    }
+    return result;
+}

package/dist/req/req-meta.d.ts

@@ -0,0 +1,2 @@
+import type { VovkRequest } from '../types/request.js';
+export declare function reqMeta<T = Record<'mcpOutput' | 'xMetaHeader' | (string & {}), unknown>>(req: Partial<VovkRequest>, meta?: T | null): T;

package/dist/req/req-meta.js

@@ -0,0 +1,10 @@
+const metaMap = new WeakMap();
+export function reqMeta(req, meta) {
+    if (meta) {
+        metaMap.set(req, { ...metaMap.get(req), ...meta });
+    }
+    else if (meta === null) {
+        metaMap.delete(req);
+    }
+    return (metaMap.get(req) ?? {});
+}

package/dist/req/req-query.d.ts

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

package/dist/req/req-query.js

@@ -0,0 +1,4 @@
+import { parseQuery } from './parse-query.js';
+export function reqQuery(req) {
+    return parseQuery(req.nextUrl.search);
+}

package/dist/req/validate-content-type.d.ts

@@ -0,0 +1 @@
+export declare function validateContentType(request: Request | undefined, allowed: string[]): Response | null;

package/dist/req/validate-content-type.js

@@ -0,0 +1,32 @@
+import { HttpException } from '../core/http-exception.js';
+import { HttpStatus } from '../types/enums.js';
+export function validateContentType(request, allowed) {
+    // Wildcard — skip validation
+    if (!request?.headers || allowed.includes('*/*'))
+        return null;
+    const raw = request.headers.get('content-type');
+    if (!raw) {
+        throw new HttpException(HttpStatus.UNSUPPORTED_MEDIA_TYPE, 'Missing Content-Type header', { allowed });
+    }
+    // Handle comma-separated content types and strip parameters like charset, boundary
+    const contentTypes = raw
+        .split(',')
+        .map((part) => part.split(';')[0].trim().toLowerCase())
+        .filter(Boolean);
+    const match = contentTypes.some((contentType) => allowed.some((pattern) => {
+        const normalized = pattern.toLowerCase();
+        // Partial wildcard: image/*, text/*, etc.
+        if (normalized.endsWith('/*')) {
+            const prefix = normalized.slice(0, -1);
+            return contentType.startsWith(prefix);
+        }
+        return contentType === normalized;
+    }));
+    if (!match) {
+        throw new HttpException(HttpStatus.UNSUPPORTED_MEDIA_TYPE, `Unsupported media type: ${contentTypes.join(', ')}`, {
+            contentTypes,
+            allowed,
+        });
+    }
+    return null;
+}

package/dist/samples/create-code-samples.d.ts

@@ -0,0 +1,20 @@
+import type { VovkControllerSchema, VovkHandlerSchema } from '../types/core.js';
+import type { VovkSamplesConfig } from '../types/config.js';
+export type CodeSamplePackageJson = {
+    name?: string;
+    version?: string;
+    description?: string;
+    rs_name?: string;
+    py_name?: string;
+};
+export declare function createCodeSamples({ handlerName, handlerSchema, controllerSchema, package: packageJson, config, }: {
+    handlerName: string;
+    handlerSchema: VovkHandlerSchema;
+    controllerSchema: VovkControllerSchema;
+    package?: CodeSamplePackageJson;
+    config: VovkSamplesConfig;
+}): {
+    ts: string;
+    py: string;
+    rs: string;
+};

package/dist/samples/create-code-samples.js

@@ -0,0 +1,293 @@
+import { schemaToCode, getSampleValue } from './schema-to-code.js';
+import { objectToCode } from './object-to-code.js';
+const toSnakeCase = (str) => str
+    .replace(/-/g, '_') // Replace hyphens with underscores
+    .replace(/([a-z0-9])([A-Z])/g, '$1_$2') // Add underscore between lowercase/digit and uppercase
+    .replace(/([A-Z])([A-Z])(?=[a-z])/g, '$1_$2') // Add underscore between uppercase letters if the second one is followed by a lowercase
+    .toLowerCase()
+    .replace(/^_/, ''); // Remove leading underscore
+const getIndentSpaces = (level) => ' '.repeat(level);
+function isTextFormat(mimeType) {
+    if (!mimeType)
+        return false;
+    return (mimeType.startsWith('text/') ||
+        [
+            'application/json',
+            'application/ld+json',
+            'application/xml',
+            'application/xhtml+xml',
+            'application/javascript',
+            'application/typescript',
+            'application/yaml',
+            'application/x-yaml',
+            'application/toml',
+            'application/sql',
+            'application/graphql',
+            'application/x-www-form-urlencoded',
+        ].includes(mimeType) ||
+        mimeType.endsWith('+json') ||
+        mimeType.endsWith('+xml'));
+}
+const isForm = (schema) => {
+    const contentTypes = schema['x-contentType'] ?? [];
+    return contentTypes.some((ct) => ct === 'multipart/form-data' || ct === 'application/x-www-form-urlencoded') ?? false;
+};
+function generateTypeScriptCode({ handlerName, rpcName, packageName, queryValidation, bodyValidation, paramsValidation, outputValidation, iterationValidation, hasArg, config, }) {
+    const getTsSample = (schema, indent) => schemaToCode(schema, { stripQuotes: true, indent: indent ?? 4 });
+    const getTsFormSample = (schema) => {
+        let formSample = '\nconst formData = new FormData();';
+        for (const [key, prop] of Object.entries(schema.properties || {})) {
+            const target = prop.oneOf?.[0] || prop.anyOf?.[0] || prop.allOf?.[0] || prop;
+            const desc = target.description ?? prop.description ?? undefined;
+            if (target.type === 'array' && target.items && typeof target.items !== 'boolean') {
+                formSample += getTsFormAppend(target.items, key, desc);
+                formSample += getTsFormAppend(target.items, key, desc);
+            }
+            else {
+                formSample += getTsFormAppend(target, key, desc);
+            }
+        }
+        return formSample;
+    };
+    const getTsFormAppend = (schema, key, description) => {
+        let sampleValue;
+        if (schema.type === 'string' && schema.format === 'binary') {
+            sampleValue = `new Blob(${isTextFormat(schema.contentMediaType) ? '["text_content"]' : '[binary_data]'}${schema.contentMediaType ? `, { type: "${schema.contentMediaType}" }` : ''})`;
+        }
+        else if (schema.type === 'object') {
+            sampleValue = '"object_unknown"';
+        }
+        else {
+            sampleValue = `"${getSampleValue(schema)}"`;
+        }
+        const desc = schema.description ?? description;
+        return `\n${desc ? `// ${desc}\n` : ''}formData.append("${key}", ${sampleValue});`;
+    };
+    const tsArgs = hasArg
+        ? `{
+${[
+            bodyValidation ? `    body: ${isForm(bodyValidation) ? 'formData' : getTsSample(bodyValidation)},` : null,
+            queryValidation ? `    query: ${getTsSample(queryValidation)},` : null,
+            paramsValidation ? `    params: ${getTsSample(paramsValidation)},` : null,
+            config?.apiRoot ? `    apiRoot: '${config.apiRoot}',` : null,
+            config?.headers
+                ? `    init: {
+      headers: ${objectToCode(config.headers, { stripQuotes: true, indent: 6, nestingIndent: 4 })}
+    },`
+                : null,
+        ]
+            .filter(Boolean)
+            .join('\n')}
+}`
+        : '';
+    const TS_CODE = `import { ${rpcName} } from '${packageName}';
+${bodyValidation && isForm(bodyValidation) ? `${getTsFormSample(bodyValidation)}\n` : ''}
+${iterationValidation ? 'using' : 'const'} response = await ${rpcName}.${handlerName}(${tsArgs});
+${outputValidation
+        ? `
+console.log(response); 
+/* 
+${getTsSample(outputValidation, 0)}
+*/`
+        : ''}${iterationValidation
+        ? `
+for await (const item of response) {
+    console.log(item); 
+    /*
+    ${getTsSample(iterationValidation)}
+    */
+}`
+        : ''}`;
+    return TS_CODE.trim();
+}
+function generatePythonCode({ handlerName, rpcName, packageName, queryValidation, bodyValidation, paramsValidation, outputValidation, iterationValidation, hasArg, config, }) {
+    const getPySample = (schema, indent) => schemaToCode(schema, {
+        stripQuotes: false,
+        indent: indent ?? 4,
+        comment: '#',
+        ignoreBinary: true,
+        nestingIndent: 4,
+    });
+    const handlerNameSnake = toSnakeCase(handlerName);
+    const getFileTouple = (schema) => {
+        return `('name.ext', BytesIO(${isTextFormat(schema.contentMediaType) ? '"text_content".encode("utf-8")' : 'binary_data'})${schema.contentMediaType ? `, "${schema.contentMediaType}"` : ''})`;
+    };
+    const getPyFiles = (schema) => {
+        return Object.entries(schema.properties ?? {}).reduce((acc, [key, prop]) => {
+            const target = prop.oneOf?.[0] || prop.anyOf?.[0] || prop.allOf?.[0] || prop;
+            const desc = target.description ?? prop.description ?? undefined;
+            if (target.type === 'string' && target.format === 'binary') {
+                acc.push(`${desc ? `${getIndentSpaces(8)}# ${desc}\n` : ''}${getIndentSpaces(8)}('${key}', ${getFileTouple(target)})`);
+            }
+            else if (target.type === 'array' &&
+                target.items &&
+                typeof target.items !== 'boolean' &&
+                target.items.format === 'binary') {
+                const val = `${desc ? `${getIndentSpaces(8)}# ${desc}\n` : ''}${getIndentSpaces(8)}('${key}', ${getFileTouple(target.items)})`;
+                acc.push(val, val);
+            }
+            return acc;
+        }, []);
+    };
+    const pyFiles = bodyValidation ? getPyFiles(bodyValidation) : null;
+    const pyFilesArg = pyFiles?.length
+        ? `${getIndentSpaces(4)}files=[\n${pyFiles.join(',\n')}\n${getIndentSpaces(4)}],`
+        : null;
+    const PY_CODE = `from ${packageName} import ${rpcName}
+${bodyValidation && isForm(bodyValidation) ? 'from io import BytesIO\n' : ''}
+response = ${rpcName}.${handlerNameSnake}(${hasArg
+        ? '\n' +
+            [
+                bodyValidation ? `    body=${getPySample(bodyValidation)},` : null,
+                pyFilesArg,
+                queryValidation ? `    query=${getPySample(queryValidation)},` : null,
+                paramsValidation ? `    params=${getPySample(paramsValidation)},` : null,
+                config?.apiRoot ? `    api_root="${config.apiRoot}",` : null,
+                config?.headers
+                    ? `    headers=${objectToCode(config.headers, { stripQuotes: false, indent: 4, nestingIndent: 4 })},`
+                    : null,
+            ]
+                .filter(Boolean)
+                .join('\n') +
+            '\n'
+        : ''})
+
+${outputValidation ? `print(response)\n${getPySample(outputValidation, 0)}` : ''}${iterationValidation
+        ? `for i, item in enumerate(response):
+    print(f"iteration #{i}:\\n {item}")
+    # iteration #0:
+    ${getPySample(iterationValidation)}`
+        : ''}`;
+    return PY_CODE.trim();
+}
+function generateRustCode({ handlerName, rpcName, packageName, queryValidation, bodyValidation, paramsValidation, outputValidation, iterationValidation, config, }) {
+    const getRsJSONSample = (schema, indent) => schemaToCode(schema, { stripQuotes: false, indent: indent ?? 4 });
+    const getRsOutputSample = (schema, indent) => schemaToCode(schema, { stripQuotes: true, indent: indent ?? 4 });
+    const getRsFormSample = (schema) => {
+        let formSample = 'let form = reqwest::multipart::Form::new()';
+        for (const [key, prop] of Object.entries(schema.properties || {})) {
+            const target = prop.oneOf?.[0] || prop.anyOf?.[0] || prop.allOf?.[0] || prop;
+            const desc = target.description ?? prop.description ?? undefined;
+            if (target.type === 'array' && target.items && typeof target.items !== 'boolean') {
+                formSample += getRsFormPart(target.items, key, desc);
+                formSample += getRsFormPart(target.items, key, desc);
+            }
+            else {
+                formSample += getRsFormPart(target, key, desc);
+            }
+        }
+        return formSample;
+    };
+    const getRsFormPart = (schema, key, description) => {
+        let sampleValue;
+        if (schema.type === 'string' && schema.format === 'binary') {
+            sampleValue = isTextFormat(schema.contentMediaType)
+                ? 'reqwest::multipart::Part::text("text_content")'
+                : 'reqwest::multipart::Part::bytes(binary_data)';
+            if (schema.contentMediaType) {
+                sampleValue += `.mime_str("${schema.contentMediaType}").unwrap()`;
+            }
+        }
+        else if (schema.type === 'object') {
+            sampleValue = '"object_unknown"';
+        }
+        else {
+            sampleValue = `"${getSampleValue(schema)}"`;
+        }
+        const desc = schema.description ?? description;
+        return `\n${getIndentSpaces(4)}${desc ? `// ${desc}\n` : ''}${getIndentSpaces(4)}.part("${key}", ${sampleValue});`;
+    };
+    const getHashMapSample = (map, indent = 4) => {
+        const entries = Object.entries(map)
+            .map(([key, value]) => {
+            return `${getIndentSpaces(indent + 2)}("${key}".to_string(), "${value}".to_string())`;
+        })
+            .join(',\n');
+        return `Some(&HashMap::from([\n${entries}\n${getIndentSpaces(4)}]))`;
+    };
+    const getBody = (schema) => {
+        if (isForm(schema)) {
+            return 'form';
+        }
+        return serdeUnwrap(getRsJSONSample(schema));
+    };
+    const handlerNameSnake = toSnakeCase(handlerName);
+    const rpcNameSnake = toSnakeCase(rpcName);
+    const serdeUnwrap = (fake) => `from_value(json!(${fake})).unwrap()`;
+    const RS_CODE = `use ${packageName}::${rpcNameSnake};
+use serde_json::{ 
+  from_value, 
+  json 
+};
+${iterationValidation ? 'use futures_util::StreamExt;\n' : ''}${bodyValidation && isForm(bodyValidation) ? `use reqwest::multipart;\n` : ''}#[tokio::main]
+async fn main() {${bodyValidation && isForm(bodyValidation) ? `\n  ${getRsFormSample(bodyValidation)}\n` : ''}
+  let response = ${rpcNameSnake}::${handlerNameSnake}(
+    ${bodyValidation ? getBody(bodyValidation) : '()'}, /* body */ 
+    ${queryValidation ? serdeUnwrap(getRsJSONSample(queryValidation)) : '()'}, /* query */ 
+    ${paramsValidation ? serdeUnwrap(getRsJSONSample(paramsValidation)) : '()'}, /* params */ 
+    ${config?.headers ? `${getHashMapSample(config.headers)}, /* headers */` : 'None, /* headers (HashMap) */ '}
+    ${config?.apiRoot ? `Some("${config.apiRoot}"), /* api_root */` : 'None, /* api_root */'}
+    false, /* disable_client_validation */
+  ).await;${outputValidation
+        ? `\n\nmatch response {
+    Ok(output) => println!("{:?}", output),
+    /* 
+    output ${getRsOutputSample(outputValidation)} 
+    */
+    Err(e) => println!("error: {:?}", e),
+  }`
+        : ''}${iterationValidation
+        ? `\n\nmatch response {
+    Ok(mut stream) => {
+      let mut i = 0;
+      while let Some(item) = stream.next().await {
+        match item {
+          Ok(value) => {
+            println!("#{}: {:?}", i, value);
+            /*
+            #0: iteration ${getRsOutputSample(iterationValidation, 8)}
+            */
+            i += 1;
+          }
+          Err(e) => {
+            eprintln!("stream error: {:?}", e);
+            break;
+          }
+        }
+      }
+    },
+    Err(e) => println!("Error initiating stream: {:?}", e),
+  }`
+        : ''}
+}`;
+    return RS_CODE.trim();
+}
+export function createCodeSamples({ handlerName, handlerSchema, controllerSchema, package: packageJson, config, }) {
+    const queryValidation = handlerSchema?.validation?.query;
+    const bodyValidation = handlerSchema?.validation?.body;
+    const paramsValidation = handlerSchema?.validation?.params;
+    const outputValidation = handlerSchema?.validation?.output;
+    const iterationValidation = handlerSchema?.validation?.iteration;
+    const hasArg = !!queryValidation || !!bodyValidation || !!paramsValidation || !!config?.apiRoot || !!config?.headers;
+    const rpcName = controllerSchema.rpcModuleName;
+    const packageName = packageJson?.name || 'vovk-client';
+    const packageNameSnake = toSnakeCase(packageName);
+    const pyPackageName = packageJson?.py_name ?? packageNameSnake;
+    const rsPackageName = packageJson?.rs_name ?? packageNameSnake;
+    const commonParams = {
+        handlerName,
+        rpcName,
+        packageName,
+        queryValidation,
+        bodyValidation,
+        paramsValidation,
+        outputValidation,
+        iterationValidation,
+        hasArg,
+        config,
+    };
+    const ts = generateTypeScriptCode(commonParams);
+    const py = generatePythonCode({ ...commonParams, packageName: pyPackageName });
+    const rs = generateRustCode({ ...commonParams, packageName: rsPackageName });
+    return { ts, py, rs };
+}

package/dist/samples/object-to-code.d.ts

@@ -0,0 +1,8 @@
+interface SamplerOptions {
+    stripQuotes?: boolean;
+    indent?: number;
+    nestingIndent?: number;
+    quote?: '"' | "'";
+}
+export declare function objectToCode(obj: unknown, options?: SamplerOptions): string;
+export {};