vovk-rust 0.0.1-beta.3 → 0.0.1-beta.6

package/README.md

@@ -7,7 +7,13 @@
     </picture>
   </a>
   <br>
-  <strong>Back-end for Next.js</strong>
+  <strong>Back-end for Next.js (beta)</strong>
+  <br />
+  <a href="https://vovk.dev/about">About Vovk.ts</a>
+  &nbsp;
+  <a href="https://vovk.dev/quick-install">Quick Start</a>
+  &nbsp;
+  <a href="https://github.com/finom/vovk">Github Repo</a>
 </p>
 
 ---

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)]
@@ -49,7 +51,7 @@ fn prepare_request<B, Q, 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,
@@ -230,7 +232,7 @@ 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,
@@ -249,7 +251,6 @@ where
     Q: Serialize + ?Sized,
     P: Serialize + ?Sized,
 {
-    // Prepare the request using the helper function
     let (request, _) = prepare_request(
         default_api_root,
         segment_name,
@@ -267,67 +268,76 @@ 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,
@@ -339,14 +349,13 @@ pub fn http_request_stream<T, B, Q, 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,
@@ -364,43 +373,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 +494,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

@@ -15,7 +15,11 @@ pub use crate::http_request::HttpException;
 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,14 +46,14 @@ 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`): '()' %>,
+    pub async fn <%= handlerName %>( 
+        body: <%- validation?.body ? (validation?.body?.['x-isForm'] ?'reqwest::multipart::Form' : `${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',
@@ -69,7 +73,7 @@ vars.convertJSONSchemasToRustTypes({
             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

@@ -187,14 +187,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`;
     });
@@ -269,7 +264,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-rust",
-  "version": "0.0.1-beta.3",
+  "version": "0.0.1-beta.6",
   "description": "Vovk.ts Rust client",
   "scripts": {
     "build": "tsc",