vovk-rust 0.0.1-draft.68 → 0.0.1

package/README.md

@@ -7,7 +7,13 @@
     </picture>
   </a>
   <br>
-  <strong>Back-end for Next.js</strong>
+  <strong>Back-end Framework for Next.js App Router</strong>
+  <br />
+  <a href="https://vovk.dev/">Documentation</a>
+  &nbsp;&nbsp;
+  <a href="https://vovk.dev/quick-install">Quick Start</a>
+  &nbsp;&nbsp;
+  <a href="https://vovk.dev/performance">Performance</a>
 </p>
 
 ---
@@ -15,3 +21,21 @@
 ## vovk-python [![npm version](https://badge.fury.io/js/vovk-python.svg)](https://www.npmjs.com/package/vovk-python)
 
 Provides template files and necessary utilities to generate [Rust](https://vovk.dev/rust) client.
+
+Install:
+
+```sh
+npm i vovk-rust -D
+```
+
+Generate:
+
+```sh
+npx vovk generate --from rs --out ./rust_package
+```
+
+Publish:
+
+```sh
+cargo publish --manifest-path rust_package/Cargo.toml
+```

package/client-templates/rsPkg/Cargo.toml.ejs

@@ -9,7 +9,10 @@ const data = {
   dependencies: {
     serde: { version: "1.0", features: ["derive"] },
     serde_json: "1.0",
-    reqwest: { version: "0.12", features: ["blocking", "json", "multipart"] },
+    reqwest: { version: "0.12", features: ["json", "multipart", "stream"] },
+    tokio: { version: "1", features: ["macros", "rt-multi-thread", "io-util"] },
+    "futures-util": "0.3",
+    "tokio-util": { version: "0.7", features: ["codec"] },
     jsonschema: "0.17",
     urlencoding: "2.1",
     once_cell: "1.17"

package/client-templates/rsSrc/http_request.rs

@@ -1,16 +1,18 @@
 use serde::{Serialize, de::DeserializeOwned};
-use reqwest::blocking::Client;
-use reqwest::Method;
-use reqwest::blocking::multipart;
-use core::panic;
+use reqwest::{Client, Method};
+use reqwest::multipart;
 use std::collections::HashMap;
 use std::error::Error;
 use std::fmt;
+use std::pin::Pin;
 use jsonschema::JSONSchema;
 use serde_json::Value;
 use urlencoding;
 use crate::read_full_schema;
 use once_cell::sync::Lazy;
+use futures_util::{Stream, StreamExt, TryStreamExt};
+use tokio_util::codec::{FramedRead, LinesCodec};
+use tokio_util::io::StreamReader;
 
 // Custom error type for HTTP exceptions
 #[derive(Debug, Serialize)]
@@ -44,12 +46,14 @@ fn prepare_request<B, Q, P>(
     handler_name: &str,
     body: Option<&B>,
     form: Option<multipart::Form>,
+    text_body: Option<String>,
+    binary_body: Option<(Vec<u8>, String)>,
     query: Option<&Q>,
     params: Option<&P>,
     headers: Option<&HashMap<String, String>>,
     api_root: Option<&str>,
     disable_client_validation: bool,
-) -> Result<(reqwest::blocking::RequestBuilder, String), Box<dyn Error>>
+) -> Result<(reqwest::RequestBuilder, String), Box<dyn Error + Send + Sync>>
 where
     B: Serialize + ?Sized,
     Q: Serialize + ?Sized,
@@ -109,8 +113,8 @@ where
         .transpose()
         .map_err(|e| format!("Failed to serialize params: {}", e))?;
 
-    // Perform JSON validation if not disabled and no form data is provided
-    if !disable_client_validation && form.is_none() {
+    // Perform JSON validation if not disabled and no form/text/binary data is provided
+    if !disable_client_validation && form.is_none() && text_body.is_none() && binary_body.is_none() {
         if let Some(body_schema) = validation.get("body") {
             if let Some(ref body_val) = body_value {
                 let schema =
@@ -187,8 +191,12 @@ where
     // Set up request headers
     let mut headers_map = reqwest::header::HeaderMap::new();
     headers_map.insert("Accept", "application/jsonl, application/json".parse().unwrap());
-    if body_value.is_some() && form.is_none() {
+    if body_value.is_some() && form.is_none() && text_body.is_none() && binary_body.is_none() {
         headers_map.insert("Content-Type", "application/json".parse().unwrap());
+    } else if text_body.is_some() {
+        headers_map.insert("Content-Type", "text/plain".parse().unwrap());
+    } else if let Some((_, ref content_type)) = binary_body {
+        headers_map.insert("Content-Type", content_type.parse().unwrap());
     }
 
     // Merge with user-provided headers if any
@@ -218,9 +226,13 @@ where
     let client = Client::new();
     let mut request = client.request(method, &url).headers(headers_map);
     
-    // Apply form data or JSON body to the request
+    // Apply form data, text body, binary body, or JSON body to the request
     if let Some(form_data) = form {
         request = request.multipart(form_data);
+    } else if let Some(text) = text_body {
+        request = request.body(text);
+    } else if let Some((bytes, _)) = binary_body {
+        request = request.body(bytes);
     } else if let Some(body_val) = body_value {
         request = request.json(&body_val);
     }
@@ -230,13 +242,15 @@ where
 
 // Main request function for regular (non-streaming) responses
 #[allow(dead_code)]
-pub fn http_request<T, B, Q, P>(
+pub async fn http_request<T, B, Q, P>(
     default_api_root: &str,
     segment_name: &str,
     controller_name: &str,
     handler_name: &str,
     body: Option<&B>,
     form: Option<multipart::Form>,
+    text_body: Option<String>,
+    binary_body: Option<(Vec<u8>, String)>,
     query: Option<&Q>,
     params: Option<&P>,
     headers: Option<&HashMap<String, String>>,
@@ -249,7 +263,6 @@ where
     Q: Serialize + ?Sized,
     P: Serialize + ?Sized,
 {
-    // Prepare the request using the helper function
     let (request, _) = prepare_request(
         default_api_root,
         segment_name,
@@ -257,6 +270,8 @@ where
         handler_name,
         body,
         form,
+        text_body,
+        binary_body,
         query,
         params,
         headers,
@@ -267,86 +282,96 @@ where
         status_code: 0,
         cause: None,
     })?;
-    
-    // Send the request
-    let response = request.send().map_err(|e| HttpException {
+
+    let response = request.send().await.map_err(|e| HttpException {
         message: e.to_string(),
         status_code: 0,
         cause: None,
     })?;
-    
-    // Handle the response based on Content-Type
+
+    let status = response.status();
+    let status_code = status.as_u16() as i32;
+
     let content_type = response
         .headers()
         .get("Content-Type")
-        .and_then(|v| v.to_str().ok());
-    
-    match content_type {
-        Some(ct) if ct.contains("application/json") => {
-            let value: Value = response.json().map_err(|e| HttpException {
-                message: e.to_string(),
-                status_code: 0,
-                cause: None,
-            })?;
-            if value.get("isError").is_some() {
-                let message = value["message"]
-                    .as_str()
-                    .unwrap_or("Unknown error")
-                    .to_string();
-                let status_code = value["statusCode"].as_i64().unwrap_or(0) as i32;
-                let cause = value.get("cause").cloned();
-                return Err(HttpException {
-                    message,
-                    status_code,
-                    cause,
-                });
-            }
-            
-            let typed_value = serde_json::from_value::<T>(value).map_err(|e| HttpException {
-                message: e.to_string(),
-                status_code: 0,
-                cause: None,
-            })?;
-            Ok(typed_value)
+        .and_then(|v| v.to_str().ok())
+        .unwrap_or("")
+        .to_string();
+
+    if content_type.contains("application/json") {
+        let value: Value = response.json().await.map_err(|e| HttpException {
+            message: e.to_string(),
+            status_code,
+            cause: None,
+        })?;
+
+        if status.is_client_error() || status.is_server_error() || value.get("isError").is_some() {
+            let message = value
+                .get("message")
+                .and_then(|m| m.as_str())
+                .unwrap_or("Unknown error")
+                .to_string();
+            let cause = value.get("cause").cloned();
+
+            return Err(HttpException {
+                message,
+                status_code,
+                cause,
+            });
         }
-        _ => {
-            let text = response.text().map_err(|e| HttpException {
-                message: e.to_string(),
-                status_code: 0,
-                cause: None,
-            })?;
-            let typed_value = serde_json::from_str::<T>(&text).map_err(|e| HttpException {
-                message: e.to_string(),
-                status_code: 0,
+
+        serde_json::from_value::<T>(value).map_err(|e| HttpException {
+            message: e.to_string(),
+            status_code,
+            cause: None,
+        })
+    } else {
+        let text = response.text().await.map_err(|e| HttpException {
+            message: e.to_string(),
+            status_code,
+            cause: None,
+        })?;
+
+        if status.is_client_error() || status.is_server_error() {
+            return Err(HttpException {
+                message: text.clone(),
+                status_code,
                 cause: None,
-            })?;
-            Ok(typed_value)
+            });
         }
+
+        serde_json::from_str::<T>(&text).map_err(|e| HttpException {
+            message: e.to_string(),
+            status_code,
+            cause: None,
+        })
     }
 }
 
 // Request function specifically for streaming responses
 #[allow(dead_code)]
-pub fn http_request_stream<T, B, Q, P>(
+pub async fn http_request_stream<T, B, Q, P>(
     default_api_root: &str,
     segment_name: &str,
     controller_name: &str,
     handler_name: &str,
     body: Option<&B>,
     form: Option<multipart::Form>,
+    text_body: Option<String>,
+    binary_body: Option<(Vec<u8>, String)>,
     query: Option<&Q>,
     params: Option<&P>,
     headers: Option<&HashMap<String, String>>,
     api_root: Option<&str>,
     disable_client_validation: bool,
-) -> Result<Box<dyn Iterator<Item = T>>, HttpException> 
+) -> Result<Pin<Box<dyn Stream<Item = Result<T, HttpException>> + Send>>, HttpException> 
 where 
     T: DeserializeOwned + 'static,
     B: Serialize + ?Sized,
     Q: Serialize + ?Sized,
     P: Serialize + ?Sized,
 {
-    // Prepare the request using the helper function
     let (request, _) = prepare_request(
         default_api_root,
         segment_name,
@@ -354,6 +379,8 @@ where
         handler_name,
         body,
         form,
+        text_body,
+        binary_body,
         query,
         params,
         headers,
@@ -364,43 +391,86 @@ where
         status_code: 0,
         cause: None,
     })?;
-    
-    // Send the request
-    let response = request.send().map_err(|e| HttpException {
+
+    let response = request.send().await.map_err(|e| HttpException {
         message: e.to_string(),
         status_code: 0,
         cause: None,
     })?;
-    
-    // Create the streaming iterator
-    let json_stream = JsonlStream {
-        reader: std::io::BufReader::new(response),
-        buffer: String::new(),
-    };
-    
-    let typed_stream = json_stream.map(|result| {
-        match result {
-            Ok(value) => {
-                if value.get("isError").is_some() {
-                    let message = value["message"]
-                        .as_str()
-                        .unwrap_or("Unknown error")
-                        .to_string();
-                    panic!("Error from server: {}", message);
-                } else {
-                    match serde_json::from_value::<T>(value) {
-                        Ok(typed_value) => typed_value,
-                        Err(e) => panic!("Failed to deserialize value: {}", e),
-                    }
+
+    let status = response.status();
+    let status_code = status.as_u16() as i32;
+
+    if !status.is_success() {
+        let message = response
+            .text()
+            .await
+            .unwrap_or_else(|_| "Streaming request failed".to_string());
+
+        return Err(HttpException {
+            message,
+            status_code,
+            cause: None,
+        });
+    }
+
+    let byte_stream = response
+        .bytes_stream()
+        .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e));
+
+    let reader = StreamReader::new(byte_stream);
+    let lines = FramedRead::new(reader, LinesCodec::new());
+
+    let json_stream = lines.filter_map(move |line| async move {
+        match line {
+            Ok(content) => {
+                let trimmed = content.trim();
+                if trimmed.is_empty() {
+                    return None;
+                }
+
+                match serde_json::from_str::<Value>(trimmed) {
+                    Ok(value) => Some(Ok(value)),
+                    Err(e) => Some(Err(HttpException {
+                        message: e.to_string(),
+                        status_code,
+                        cause: None,
+                    })),
                 }
-            },
-            Err(e) => {
-                panic!("Error reading from stream: {}", e);
             }
+            Err(e) => Some(Err(HttpException {
+                message: e.to_string(),
+                status_code,
+                cause: None,
+            })),
         }
     });
-    
-    Ok(Box::new(typed_stream))
+
+    let typed_stream = json_stream.map(move |result| {
+        result.and_then(|value| {
+            if value.get("isError").is_some() {
+                let message = value["message"]
+                    .as_str()
+                    .unwrap_or("Unknown error")
+                    .to_string();
+                let cause = value.get("cause").cloned();
+
+                Err(HttpException {
+                    message,
+                    status_code,
+                    cause,
+                })
+            } else {
+                serde_json::from_value::<T>(value).map_err(|e| HttpException {
+                    message: e.to_string(),
+                    status_code,
+                    cause: None,
+                })
+            }
+        })
+    });
+
+    Ok(Box::pin(typed_stream))
 }
 
 // Helper function to build query strings from nested JSON
@@ -442,47 +512,3 @@ fn build_query_string(data: &Value, prefix: &str) -> String {
     }
 }
 
-// Struct and Iterator implementation for streaming JSONL responses
-struct JsonlStream {
-    reader: std::io::BufReader<reqwest::blocking::Response>,
-    buffer: String,
-}
-
-impl Iterator for JsonlStream {
-    type Item = Result<Value, Box<dyn Error>>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        use std::io::BufRead;
-        
-        self.buffer.clear();
-        match self.reader.read_line(&mut self.buffer) {
-            Ok(0) => None, // End of stream
-            Ok(_) => {
-                let line = self.buffer.trim();
-                if line.is_empty() {
-                    return self.next(); // Skip empty lines
-                }
-                
-                match serde_json::from_str::<Value>(line) {
-                    Ok(value) => {
-                        if value.get("isError").is_some() {
-                            let message = value["message"]
-                                .as_str()
-                                .unwrap_or("Unknown error")
-                                .to_string();
-                            Some(Err(Box::new(HttpException {
-                                message,
-                                status_code: 0,
-                                cause: None,
-                            })))
-                        } else {
-                            Some(Ok(value))
-                        }
-                    },
-                    Err(e) => Some(Err(Box::new(e))),
-                }
-            },
-            Err(e) => Some(Err(Box::new(e))),
-        }
-    }
-}

package/client-templates/rsSrc/lib.rs.ejs

@@ -1,21 +1,24 @@
 ---
 imports: ['vovk-rust']
 ---
+<%- t.getFirstLineBanner() %>
 <% const vars = {
     convertJSONSchemasToRustTypes: t.imports['vovk-rust'].convertJSONSchemasToRustTypes,
 }; %>
-<%- t.getFirstLineBanner() %>
 mod http_request;
 mod read_full_schema;
 
 pub use crate::http_request::HttpException;
-
 <% Object.entries(t.schema.segments).forEach(([segmentName, segment]) => {
     Object.values(segment.controllers).forEach((controllerSchema) => { %>
 pub mod <%= t._.snakeCase(controllerSchema.rpcModuleName) %> {
     #[allow(unused_imports)]
     use crate::http_request::{HttpException, http_request, http_request_stream};
+    #[allow(unused_imports)]
+    use futures_util::Stream;
     use std::collections::HashMap;
+    #[allow(unused_imports)]
+    use std::pin::Pin;
 <% Object.entries(controllerSchema.handlers).forEach(([handlerNameOriginal, handlerSchema]) => { 
     const { validation, openapi, path, httpMethod } = handlerSchema;
     const handlerName = t._.snakeCase(handlerNameOriginal);
@@ -42,18 +45,30 @@ vars.convertJSONSchemasToRustTypes({
     validation?.query?.description ? `Query: ${validation?.query?.description}`: '',
     validation?.output?.description ? `Returns: ${validation?.output?.description}`: ''
 ]).filter(Boolean).map((s) => s.split('\n')).flat().map((s) => ' '.repeat(4) + '/// ' + s).join('\n') %>
-    pub fn <%= handlerName %>( 
-        body: <%- validation?.body ? (validation?.body?.['x-isForm'] ?'reqwest::blocking::multipart::Form' : `${handlerName}_::body`): '()' %>,
+<%
+    // Determine body kind: 'none', 'form', 'binary', 'text', or 'json'
+    const bodyKind = (() => {
+        if (!validation?.body) return 'none';
+        const ct = validation.body['x-contentType'];
+        if (ct?.includes('multipart/form-data') || ct?.includes('application/x-www-form-urlencoded')) return 'form';
+        if (validation.body.format === 'binary' || validation.body.contentEncoding === 'binary') return 'binary';
+        if (ct?.some(c => c.startsWith('text/'))) return 'text';
+        return 'json';
+    })();
+    const firstContentType = validation?.body?.['x-contentType']?.[0] || 'application/octet-stream';
+%>
+    pub async fn <%= handlerName %>( 
+        body: <%- bodyKind === 'form' ? 'reqwest::multipart::Form' : bodyKind !== 'none' ? `${handlerName}_::body` : '()' %>,
         query: <%- validation?.query ? `${handlerName}_::query` : '()' %>,
         params: <%- validation?.params ? `${handlerName}_::params` : '()' %>,
         headers: Option<&HashMap<String, String>>,
         api_root: Option<&str>,
         disable_client_validation: bool,
-    ) -> <%- validation?.output ? `Result<${handlerName}_::output, HttpException>` : validation?.iteration ? `Result<Box<dyn Iterator<Item = ${handlerName}_::iteration>>, HttpException>` : 'Result<serde_json::Value, HttpException>' %>{
+    ) -> <%- validation?.output ? `Result<${handlerName}_::output, HttpException>` : validation?.iteration ? `Result<Pin<Box<dyn Stream<Item = Result<${handlerName}_::iteration, HttpException>> + Send>>, HttpException>` : 'Result<serde_json::Value, HttpException>' %>{
         let result = <%= validation?.iteration ? 'http_request_stream' : 'http_request' %>::<
 <%- [
                 validation?.output ? `${handlerName}_::output` : validation?.iteration ? `${handlerName}_::iteration` : 'serde_json::Value',
-                validation?.body && !validation?.body?.['x-isForm'] ? `${handlerName}_::body` : '()',
+                bodyKind === 'json' ? `${handlerName}_::body` : '()',
                 validation?.query ? `${handlerName}_::query` : '()',
                 validation?.params ? `${handlerName}_::params` : '()'
             ].filter(Boolean).map((s) => ' '.repeat(12) + s).join(',\n') %>
@@ -62,14 +77,16 @@ vars.convertJSONSchemasToRustTypes({
             "<%= segmentName %>",
             "<%= controllerSchema.rpcModuleName %>",
             "<%= handlerNameOriginal %>",
-            <%- !validation?.body || !validation?.body?.['x-isForm'] ? `Some(&body)` : 'None' %>,
-            <%- validation?.body && validation?.body?.['x-isForm'] ? `Some(body)` : 'None' %>,
+            <%- bodyKind === 'json' ? 'Some(&body)' : 'None' %>,
+            <%- bodyKind === 'form' ? 'Some(body)' : 'None' %>,
+            <%- bodyKind === 'text' ? 'Some(body)' : 'None' %>,
+            <%- bodyKind === 'binary' ? `Some((body, "${firstContentType}".to_string()))` : 'None' %>,
             Some(&query),
             Some(&params),
             headers,
             api_root,
             disable_client_validation,
-        );
+        ).await;
 
         result
     }

package/index.d.ts

@@ -1,16 +1,16 @@
-import type { KnownAny } from 'vovk';
+import type { VovkJSONSchemaBase } from 'vovk';
 export declare function indent(level: number, pad?: number): string;
-export declare function generateDocComment(schema: KnownAny, level: number, pad?: number): string;
-export declare function resolveRef(ref: string, rootSchema: KnownAny): KnownAny | undefined;
+export declare function generateDocComment(schema: VovkJSONSchemaBase, level: number, pad?: number): string;
+export declare function resolveRef(ref: string, rootSchema: VovkJSONSchemaBase): VovkJSONSchemaBase | undefined;
 export declare function getModulePath(path: string[]): string;
-export declare function toRustType(schema: KnownAny, path: string[], rootSchema?: KnownAny): string;
-export declare function generateEnum(schema: KnownAny, name: string, level: number, pad?: number): string;
-export declare function generateVariantEnum(schema: KnownAny, name: string, path: string[], level: number, rootSchema: KnownAny, pad?: number): string;
-export declare function generateAllOfType(schemas: KnownAny[], name: string, path: string[], level: number, rootSchema: KnownAny, pad?: number): string;
-export declare function processObject(schema: KnownAny, path: string[], level: number, rootSchema?: KnownAny, pad?: number): string;
-export declare function processPrimitive(schema: KnownAny, name: string, level: number, pad?: number): string;
+export declare function toRustType(schema: VovkJSONSchemaBase, path: string[], rootSchema?: VovkJSONSchemaBase): string;
+export declare function generateEnum(schema: VovkJSONSchemaBase, name: string, level: number, pad?: number): string;
+export declare function generateVariantEnum(schema: VovkJSONSchemaBase, name: string, path: string[], level: number, rootSchema: VovkJSONSchemaBase, pad?: number): string;
+export declare function generateAllOfType(schemas: VovkJSONSchemaBase[], name: string, path: string[], level: number, rootSchema: VovkJSONSchemaBase, pad?: number): string;
+export declare function processObject(schema: VovkJSONSchemaBase, path: string[], level: number, rootSchema?: VovkJSONSchemaBase, pad?: number): string;
+export declare function processPrimitive(schema: VovkJSONSchemaBase, name: string, level: number, pad?: number): string;
 export declare function convertJSONSchemasToRustTypes({ schemas, pad, rootName, }: {
-    schemas: Record<string, KnownAny | undefined>;
+    schemas: Record<string, VovkJSONSchemaBase | undefined>;
     pad?: number;
     rootName: string;
 }): string;

package/index.js

@@ -1,3 +1,58 @@
+// Rust reserved keywords that cannot be used as identifiers
+const RUST_KEYWORDS = new Set([
+    'as',
+    'break',
+    'const',
+    'continue',
+    'crate',
+    'else',
+    'enum',
+    'extern',
+    'false',
+    'fn',
+    'for',
+    'if',
+    'impl',
+    'in',
+    'let',
+    'loop',
+    'match',
+    'mod',
+    'move',
+    'mut',
+    'pub',
+    'ref',
+    'return',
+    'self',
+    'Self',
+    'static',
+    'struct',
+    'super',
+    'trait',
+    'true',
+    'type',
+    'unsafe',
+    'use',
+    'where',
+    'while',
+    'async',
+    'await',
+    'dyn',
+    'abstract',
+    'become',
+    'box',
+    'do',
+    'final',
+    'macro',
+    'override',
+    'priv',
+    'typeof',
+    'unsized',
+    'virtual',
+    'yield',
+    'try',
+    'union',
+]);
 // Helper function for indentation
 export function indent(level, pad = 0) {
     return ' '.repeat(pad + level * 2);
@@ -90,6 +145,10 @@ export function toRustType(schema, path, rootSchema = schema) {
         }
     }
     if (schema.type === 'string') {
+        // Binary format maps to Vec<u8>
+        if (schema.format === 'binary' || schema.contentEncoding === 'binary') {
+            return 'Vec<u8>';
+        }
         return 'String';
     }
     else if (schema.type === 'number' || schema.type === 'integer') {
@@ -153,7 +212,7 @@ export function toRustType(schema, path, rootSchema = schema) {
         return '()';
     }
     else if (schema.type === 'array') {
-        if (schema.items) {
+        if (schema.items && typeof schema.items !== 'boolean') {
             // Check if array items are objects that need special handling
             if (schema.items.type === 'object' || schema.items.properties || schema.items.$ref) {
                 // For array of objects, reference the item type with proper module path
@@ -187,14 +246,9 @@ export function generateEnum(schema, name, level, pad = 0) {
     code += `${indentFn(level)}#[derive(Debug, Serialize, Deserialize, Clone)]\n`;
     code += `${indentFn(level)}#[allow(non_camel_case_types)]\n`;
     code += `${indentFn(level)}pub enum ${name} {\n`;
-    schema.enum.forEach((value, index) => {
+    schema.enum?.forEach((value) => {
         // Create valid Rust enum variant
         const variant = value?.replace(/[^a-zA-Z0-9_]/g, '_');
-        // Add documentation if available in enumDescriptions
-        if (schema.enumDescriptions && schema.enumDescriptions[index]) {
-            const description = schema.enumDescriptions[index];
-            code += `${indentFn(level + 1)}/// ${description}\n`;
-        }
         code += `${indentFn(level + 1)}#[serde(rename = "${value}")]\n`;
         code += `${indentFn(level + 1)}${variant},\n`;
     });
@@ -230,8 +284,8 @@ export function generateVariantEnum(schema, name, path, level, rootSchema, pad =
         // If it's an object type, we need to create a separate struct
         if (variant.type === 'object' || variant.properties) {
             code += `${indentFn(level + 1)}${variantName}(${name}_::${variantName}),\n`;
-            // Create a nested type definition to be added outside the enum
-            nestedTypes += processObject(variant, variantPath, level, rootSchema, pad);
+            // Create a nested type definition to be added inside a sub-module
+            nestedTypes += processObject(variant, variantPath, level + 1, rootSchema, pad);
         }
         else {
             // For simple types, we can include them directly in the enum
@@ -240,9 +294,13 @@ export function generateVariantEnum(schema, name, path, level, rootSchema, pad =
         }
     });
     code += `${indentFn(level)}}\n\n`;
-    // Add nested type definitions if needed
+    // Add nested type definitions wrapped in a sub-module
     if (nestedTypes) {
+        code += `${indentFn(level)}#[allow(non_snake_case)]\n`;
+        code += `${indentFn(level)}pub mod ${name}_ {\n`;
+        code += `${indentFn(level + 1)}use serde::{Serialize, Deserialize};\n\n`;
         code += nestedTypes;
+        code += `${indentFn(level)}}\n`;
     }
     return code;
 }
@@ -269,7 +327,7 @@ export function generateAllOfType(schemas, name, path, level, rootSchema, pad =
             };
         }
         if (schema.required) {
-            mergedSchema.required = [...mergedSchema.required, ...schema.required];
+            mergedSchema.required = [...(mergedSchema.required ?? []), ...schema.required];
         }
     });
     // Process the merged schema as a regular object
@@ -293,7 +351,9 @@ export function processObject(schema, path, level, rootSchema = schema, pad = 0)
     let code = '';
     // Add documentation comments for the struct
     code += generateDocComment(schema, level, pad);
-    if (schema.type === 'object' && schema['x-isForm'] === true) {
+    if (schema.type === 'object' &&
+        (schema['x-contentType']?.includes('multipart/form-data') ||
+            schema['x-contentType']?.includes('application/x-www-form-urlencoded'))) {
         code += `${indentFn(level)}pub use reqwest::multipart::Form as ${currentName};\n`;
         return code;
     }
@@ -342,7 +402,13 @@ export function processObject(schema, path, level, rootSchema = schema, pad = 0)
         if (!isRequired) {
             propType = `Option<${propType}>`;
         }
-        code += `${indentFn(level + 1)}pub ${propName}: ${propType},\n`;
+        if (RUST_KEYWORDS.has(propName)) {
+            code += `${indentFn(level + 1)}#[serde(rename = "${propName}")]\n`;
+            code += `${indentFn(level + 1)}pub r#${propName}: ${propType},\n`;
+        }
+        else {
+            code += `${indentFn(level + 1)}pub ${propName}: ${propType},\n`;
+        }
     });
     code += `${indentFn(level)}}\n\n`;
     // Check if any properties require nested types before generating the sub-module
@@ -357,6 +423,7 @@ export function processObject(schema, path, level, rootSchema = schema, pad = 0)
             ((propSchema.type === 'string' || !propSchema.type) && propSchema.enum) ||
             (propSchema.type === 'array' &&
                 propSchema.items &&
+                typeof propSchema.items !== 'boolean' &&
                 (propSchema.items.type === 'object' || propSchema.items.properties || propSchema.items.$ref)) ||
             propSchema.anyOf ||
             propSchema.oneOf ||
@@ -384,7 +451,7 @@ export function processObject(schema, path, level, rootSchema = schema, pad = 0)
                 code += generateEnum(propSchema, propName, level + 1, pad);
             }
             // Generate types for array items if they're objects
-            else if (propSchema.type === 'array' && propSchema.items) {
+            else if (propSchema.type === 'array' && propSchema.items && typeof propSchema.items !== 'boolean') {
                 // Check if items has a $ref
                 if (propSchema.items.$ref) {
                     const resolved = resolveRef(propSchema.items.$ref, rootSchema);
@@ -414,7 +481,13 @@ export function processPrimitive(schema, name, level, pad = 0) {
     // For primitive types, create a type alias
     code += `${indentFn(level)}pub type ${name} = `;
     if (schema.type === 'string') {
-        code += 'String';
+        // Binary format maps to Vec<u8>
+        if (schema.format === 'binary' || schema.contentEncoding === 'binary') {
+            code += 'Vec<u8>';
+        }
+        else {
+            code += 'String';
+        }
     }
     else if (schema.type === 'number') {
         code += 'f64';
@@ -446,7 +519,9 @@ export function convertJSONSchemasToRustTypes({ schemas, pad = 0, rootName, }) {
     }
     const indentFn = (level) => ' '.repeat(pad + level * 2);
     // Start code generation
-    let result = `${indentFn(0)}pub mod ${rootName}_ {\n`;
+    let result = `${indentFn(0)}#[allow(non_camel_case_types)]\n`;
+    result += `${indentFn(0)}pub mod ${rootName}_ {\n`;
+    result += `${indentFn(1)}#[allow(unused_imports)]\n`;
     result += `${indentFn(1)}use serde::{Serialize, Deserialize};\n`;
     // Process each schema in the schemas object
     Object.entries(schemas).forEach(([schemaName, schemaObj]) => {
@@ -465,7 +540,7 @@ export function convertJSONSchemasToRustTypes({ schemas, pad = 0, rootName, }) {
                             required: defSchema.required || [],
                             title: defSchema.title,
                             description: defSchema.description,
-                            'x-isForm': defSchema['x-isForm'],
+                            'x-contentType': defSchema['x-contentType'],
                         };
                         result += processObject(rootDefObject, [defName], 1, schemaObj, pad);
                     }
@@ -475,7 +550,8 @@ export function convertJSONSchemasToRustTypes({ schemas, pad = 0, rootName, }) {
                     else if (defSchema.anyOf || defSchema.oneOf || defSchema.allOf) {
                         result += generateVariantEnum(defSchema, defName, [defName], 1, schemaObj, pad);
                     }
-                    else if (defSchema.type && ['string', 'number', 'integer', 'boolean', 'null'].includes(defSchema.type)) {
+                    else if (typeof defSchema.type === 'string' &&
+                        ['string', 'number', 'integer', 'boolean', 'null'].includes(defSchema.type)) {
                         // Handle primitive types in $defs
                         result += processPrimitive(defSchema, defName, 1, pad);
                     }
@@ -491,11 +567,12 @@ export function convertJSONSchemasToRustTypes({ schemas, pad = 0, rootName, }) {
                 required: schemaObj.required || [],
                 title: schemaObj.title,
                 description: schemaObj.description,
-                'x-isForm': schemaObj['x-isForm'],
+                'x-contentType': schemaObj['x-contentType'],
             };
             result += processObject(rootObject, [schemaName], 1, schemaObj, pad);
         }
-        else if (['string', 'number', 'integer', 'boolean', 'null'].includes(schemaObj.type)) {
+        else if (typeof schemaObj.type === 'string' &&
+            ['string', 'number', 'integer', 'boolean', 'null'].includes(schemaObj.type)) {
             // Handle primitive schema
             result += processPrimitive(schemaObj, schemaName, 1, pad);
         }
@@ -510,7 +587,7 @@ export function convertJSONSchemasToRustTypes({ schemas, pad = 0, rootName, }) {
         else if (schemaObj.type === 'array') {
             // For array as root type, create a type alias to Vec<ItemType>
             let itemType = 'String'; // Default if no items specified
-            if (schemaObj.items) {
+            if (schemaObj.items && typeof schemaObj.items !== 'boolean') {
                 if (schemaObj.items.type === 'object' || schemaObj.items.properties) {
                     // Create the item type
                     const itemSchema = {

package/package.json

@@ -1,7 +1,12 @@
 {
   "name": "vovk-rust",
-  "version": "0.0.1-draft.68",
-  "description": "Vovk.ts Rust client",
+  "version": "0.0.1",
+  "description": "Codegen templates for Rust client library for Vovk.ts",
+  "files": [
+    "client-templates",
+    "index.js",
+    "index.d.ts"
+  ],
   "scripts": {
     "build": "tsc",
     "npm-publish": "npm publish",
@@ -13,7 +18,7 @@
     "unit:rs": "RUST_BACKTRACE=full cargo test --manifest-path ./test_rust/Cargo.toml -- --show-output",
     "unit:ts": "npm run pre-test && node --experimental-strip-types --test --test-concurrency=1 test_ts/*.mts",
     "generate": "npm run generate --prefix ../../test -- --config=../packages/vovk-rust/vovk.config.test.mjs",
-    "test": "npm run unit:ts && PORT=3210 concurrently 'sleep 60 && npm run unit:rs' 'npm run generate && npm run build --prefix ../../test && npm run start --prefix ../../test' --kill-others --success first"
+    "test": "npm run unit:ts && PORT=3210 npm run generate && npm run build --prefix ../../test && PORT=3210 concurrently 'sleep 15 && npm run unit:rs' 'npm run start --prefix ../../test' --kill-others --success first"
   },
   "main": "./index.js",
   "type": "module",
@@ -22,12 +27,14 @@
     "url": "git+https://github.com/finom/vovk.git"
   },
   "keywords": [
-    "Vovk"
+    "vovk",
+    "rust",
+    "codegen"
   ],
   "author": "Andrey Gubanov",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/finom/vovk/issues"
   },
-  "homepage": "https://github.com/finom/vovk#readme"
+  "homepage": "https://vovk.dev/rust"
 }