vovk-rust 0.0.1-beta.10

package/README.md

@@ -0,0 +1,40 @@
+<p align="center">
+  <a href="https://vovk.dev">
+    <picture>
+      <source width="300" media="(prefers-color-scheme: dark)" srcset="https://vovk.dev/vovk-logo-white.svg">
+      <source width="300" media="(prefers-color-scheme: light)" srcset="https://vovk.dev/vovk-logo.svg">
+      <img width="300" alt="vovk" src="https://vovk.dev/vovk-logo.svg">
+    </picture>
+  </a>
+  <br>
+  <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>
+
+---
+
+## 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

@@ -0,0 +1,87 @@
+<%- t.getFirstLineBanner('sh') %>
+<%
+const data = {
+  package: {
+    name: t.package.name.replace(/-/g, '_'),
+    version: t.package.version,
+    edition: "2021"
+  },
+  dependencies: {
+    serde: { version: "1.0", features: ["derive"] },
+    serde_json: "1.0",
+    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"
+  }
+};
+
+// Add optional fields to package section
+if (t.package.description) {
+  data.package.description = t.package.description;
+}
+
+if (t.package.license) {
+  data.package.license = t.package.license || 'UNLICENSED';
+}
+
+if (t.package.repository) {
+  data.package.repository = typeof t.package.repository === 'string' 
+    ? t.package.repository 
+    : t.package.repository.url;
+}
+
+if (t.package.homepage) {
+  data.package.homepage = t.package.homepage;
+}
+
+// Build authors array
+const authors = [];
+if (t.package.author) {
+  if (typeof t.package.author === 'string') {
+    authors.push(t.package.author);
+  } else {
+    let author = t.package.author.name;
+    if (t.package.author.email) author += ` <${t.package.author.email}>`;
+    authors.push(author);
+  }
+}
+
+if (t.package.contributors && t.package.contributors.length) {
+  t.package.contributors.forEach(contributor => {
+    if (typeof contributor === 'string') {
+      authors.push(contributor);
+    } else {
+      let contribStr = contributor.name;
+      if (contributor.email) contribStr += ` <${contributor.email}>`;
+      authors.push(contribStr);
+    }
+  });
+}
+
+if (authors.length) {
+  data.package.authors = authors;
+}
+
+// Add keywords if they exist
+if (t.package.keywords && t.package.keywords.length) {
+  data.package.keywords = t.package.keywords;
+}
+
+// Add bugs if they exist
+if (t.package.bugs) {
+  if (!data.package.metadata) {
+    data.package.metadata = {};
+  }
+  
+  data.package.metadata.package = {
+    bugs: typeof t.package.bugs === 'string' 
+      ? t.package.bugs 
+      : t.package.bugs.url
+  };
+}
+%>
+<%- t.TOML.stringify(data) %>

package/client-templates/rsReadme/README.md.ejs

@@ -0,0 +1,37 @@
+<%- t.getFirstLineBanner('html') %>
+# <%= t.package.name.replace(/-/g, '_') %> v<%= t.package.version %> [![Rust](https://img.shields.io/badge/Rust-lang-000000.svg?style=flat&logo=rust)](https://www.rust-lang.org) [![Vovk.ts](https://badgen.net/badge/Built%20with/Vovk.ts/333333?icon=https://vovk.dev/icon-white.svg)](https://vovk.dev)
+
+<%- t.readme.description ?? (`${t.package.description ? `> ${t.package.description}` : ''}`) %>
+
+<%- t.package.license ? `License: **${t.package.license}**` : '' %>
+
+```bash
+# Install the package
+<%= t.readme.installCommand ?? `cargo install ${t.package.name.replace(/-/g, '_')}` %>
+```
+
+<% Object.entries(t.schema.segments).forEach(([segmentName, segment]) => {
+    Object.values(segment.controllers).forEach((controllerSchema) => { %>
+
+## mod <%= t._.snakeCase(controllerSchema.rpcModuleName) %>
+        <% Object.entries(controllerSchema.handlers).forEach(([handlerName, handlerSchema]) => { %>
+### <%= t._.snakeCase(controllerSchema.rpcModuleName) %>::<%= t._.snakeCase(handlerName) %>
+<%- handlerSchema.operationObject?.summary ? `> ${handlerSchema.operationObject.summary}` : '' %>
+
+<%- handlerSchema.operationObject?.description ? `${handlerSchema.operationObject.description}` : '' %>
+
+<% const forceApiRoot = t.segmentMeta[segment.segmentName].forceApiRoot ?? controllerSchema.forceApiRoot; %>
+`<%= handlerSchema.httpMethod %> <%= [...(forceApiRoot ? [forceApiRoot] : [t.apiRoot, segmentName]), controllerSchema.prefix, handlerSchema.path].map((part, i) => i > 0 ? t._.trim(part, '/') : part).filter(Boolean).join('/') %>`
+
+```rust
+<%- t.createCodeSamples({
+    handlerSchema,
+    handlerName,
+    controllerSchema,
+    package: t.package,
+    config: t.samples,
+}).rs %>
+```
+        <% }) %>
+    <% }) %>
+<% }) %>

package/client-templates/rsSrc/http_request.rs

@@ -0,0 +1,496 @@
+use serde::{Serialize, de::DeserializeOwned};
+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)]
+pub struct HttpException {
+    message: String,
+    status_code: i32,
+    #[allow(dead_code)]
+    cause: Option<Value>,
+}
+
+impl fmt::Display for HttpException {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "[Status: {}] {}", self.status_code, self.message)
+    }
+}
+
+impl Error for HttpException {}
+
+// Load the full schema only once using lazy initialization
+static FULL_SCHEMA: Lazy<Result<Value, String>> = Lazy::new(|| {
+    read_full_schema::read_full_schema()
+        .map(|schema| serde_json::to_value(schema).expect("Failed to convert schema to Value"))
+        .map_err(|e| format!("Failed to read schema: {}", e))
+});
+
+// Private helper function for request preparation
+fn prepare_request<B, Q, P>(
+    default_api_root: &str,
+    segment_name: &str,
+    controller_name: &str,
+    handler_name: &str,
+    body: Option<&B>,
+    form: Option<multipart::Form>,
+    query: Option<&Q>,
+    params: Option<&P>,
+    headers: Option<&HashMap<String, String>>,
+    api_root: Option<&str>,
+    disable_client_validation: bool,
+) -> Result<(reqwest::RequestBuilder, String), Box<dyn Error + Send + Sync>>
+where
+    B: Serialize + ?Sized,
+    Q: Serialize + ?Sized,
+    P: Serialize + ?Sized,
+{
+    // Extract schema information
+    let schema = match &*FULL_SCHEMA {
+        Ok(schema) => schema,
+        Err(e) => return Err(format!("Failed to load schema: {}", e).into()),
+    };
+    
+    let segment = schema.get("segments")
+        .and_then(|s| s.get(segment_name))
+        .ok_or("Segment not found")?;
+    
+    let controller = segment.get("controllers")
+        .and_then(|c| c.get(controller_name))
+        .ok_or("Controller not found")?;
+    
+    let handlers = controller.get("handlers")
+        .and_then(|h| h.as_object())
+        .ok_or("Handlers not found")?;
+    
+    let handler = handlers.get(handler_name).ok_or("Handler not found")?;
+    let prefix = controller.get("prefix")
+        .and_then(|p| p.as_str())
+        .ok_or("Prefix not found")?;
+    let handler_path = handler.get("path")
+        .and_then(|p| p.as_str())
+        .ok_or("Path not found")?;
+    let http_method = handler.get("httpMethod")
+        .ok_or("HTTP method not found")?
+        .as_str()
+        .ok_or("HTTP method is not a string")?;
+    let default_validation = Value::Object(serde_json::Map::new());
+    let validation = handler
+        .get("validation")
+        .unwrap_or(&default_validation);
+
+    // Construct the base URL
+    let url_parts: Vec<&str> = vec![api_root.unwrap_or(default_api_root), segment_name, prefix, handler_path]
+        .into_iter()
+        .filter(|s| !s.is_empty())
+        .collect();
+    let mut url = url_parts.join("/");
+
+    // Convert generic types to Value for validation if needed
+    let body_value = body.map(|b| serde_json::to_value(b))
+        .transpose()
+        .map_err(|e| format!("Failed to serialize body: {}", e))?;
+        
+    let query_value = query.map(|q| serde_json::to_value(q))
+        .transpose()
+        .map_err(|e| format!("Failed to serialize query: {}", e))?;
+        
+    let params_value = params.map(|p| serde_json::to_value(p))
+        .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() {
+        if let Some(body_schema) = validation.get("body") {
+            if let Some(ref body_val) = body_value {
+                let schema =
+                    JSONSchema::compile(body_schema).map_err(|e| format!("Invalid body schema: {}", e))?;
+                schema
+                    .validate(body_val)
+                    .map_err(|e| {
+                        let error_msgs: Vec<String> = e.map(|err| format!("{}: {}", err.instance_path, err.to_string())).collect();
+                        format!("Body validation failed: {}", error_msgs.join(", "))
+                    })?;
+            } else if http_method != "GET" {
+                return Err("Body is required for validation but not provided".into());
+            }
+        }
+        
+        if let Some(query_schema) = validation.get("query") {
+            if let Some(ref query_val) = query_value {
+                let schema =
+                    JSONSchema::compile(query_schema).map_err(|e| format!("Invalid query schema: {}", e))?;
+                schema
+                    .validate(query_val)
+                    .map_err(|e| {
+                        let error_msgs: Vec<String> = e.map(|err| format!("{}: {}", err.instance_path, err.to_string())).collect();
+                        format!("Query validation failed: {}", error_msgs.join(", "))
+                    })?;
+            } else {
+                return Err("Query is required for validation but not provided".into());
+            }
+        }
+        
+        if let Some(params_schema) = validation.get("params") {
+            if let Some(ref params_val) = params_value {
+                let schema = JSONSchema::compile(params_schema)
+                    .map_err(|e| format!("Invalid params schema: {}", e))?;
+                schema
+                    .validate(params_val)
+                    .map_err(|e| {
+                        let error_msgs: Vec<String> = e.map(|err| format!("{}: {}", err.instance_path, err.to_string())).collect();
+                        format!("Params validation failed: {}", error_msgs.join(", "))
+                    })?;
+            } else {
+                return Err("Params are required for validation but not provided".into());
+            }
+        }
+    }
+
+    // Substitute path parameters in the URL
+    if let Some(ref params_val) = params_value {
+        if let Value::Object(map) = params_val {
+            for (key, value) in map {
+                let pattern = format!("{{{}}}", key);
+                if let Value::String(s) = value {
+                    url = url.replace(&pattern, s);
+                } else {
+                    return Err(format!("Param {} must be a string", key).into());
+                }
+            }
+        }
+    }
+
+    // Append query string if query parameters are provided
+    if let Some(ref query_val) = query_value {
+        let query_string = build_query_string(query_val, "");
+        if !query_string.is_empty() {
+            if url.contains('?') {
+                url += "&";
+            } else {
+                url += "?";
+            }
+            url += &query_string;
+        }
+    }
+
+    // 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() {
+        headers_map.insert("Content-Type", "application/json".parse().unwrap());
+    }
+
+    // Merge with user-provided headers if any
+    if let Some(provided_headers) = headers {
+        for (key, value) in provided_headers {
+            if let Ok(header_name) = reqwest::header::HeaderName::from_bytes(key.as_bytes()) {
+                if let Ok(header_value) = reqwest::header::HeaderValue::from_str(value) {
+                    headers_map.insert(header_name, header_value);
+                }
+            }
+        }
+    }
+
+    // Map HTTP method string to reqwest::Method
+    let method = match http_method.to_uppercase().as_str() {
+        "GET" => Method::GET,
+        "POST" => Method::POST,
+        "PUT" => Method::PUT,
+        "DELETE" => Method::DELETE,
+        "PATCH" => Method::PATCH,
+        "OPTIONS" => Method::OPTIONS,
+        "HEAD" => Method::HEAD,
+        _ => return Err("Invalid HTTP method".into()),
+    };
+
+    // Build the HTTP request
+    let client = Client::new();
+    let mut request = client.request(method, &url).headers(headers_map);
+    
+    // Apply form data or JSON body to the request
+    if let Some(form_data) = form {
+        request = request.multipart(form_data);
+    } else if let Some(body_val) = body_value {
+        request = request.json(&body_val);
+    }
+    
+    Ok((request, http_method.to_string()))
+}
+
+// Main request function for regular (non-streaming) responses
+#[allow(dead_code)]
+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>,
+    query: Option<&Q>,
+    params: Option<&P>,
+    headers: Option<&HashMap<String, String>>,
+    api_root: Option<&str>,
+    disable_client_validation: bool,
+) -> Result<T, HttpException> 
+where 
+    T: DeserializeOwned + 'static,
+    B: Serialize + ?Sized,
+    Q: Serialize + ?Sized,
+    P: Serialize + ?Sized,
+{
+    let (request, _) = prepare_request(
+        default_api_root,
+        segment_name,
+        controller_name,
+        handler_name,
+        body,
+        form,
+        query,
+        params,
+        headers,
+        api_root,
+        disable_client_validation,
+    ).map_err(|e| HttpException {
+        message: e.to_string(),
+        status_code: 0,
+        cause: None,
+    })?;
+
+    let response = request.send().await.map_err(|e| HttpException {
+        message: e.to_string(),
+        status_code: 0,
+        cause: None,
+    })?;
+
+    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())
+        .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,
+            });
+        }
+
+        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,
+            });
+        }
+
+        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 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>,
+    query: Option<&Q>,
+    params: Option<&P>,
+    headers: Option<&HashMap<String, String>>,
+    api_root: Option<&str>,
+    disable_client_validation: bool,
+) -> Result<Pin<Box<dyn Stream<Item = Result<T, HttpException>> + Send>>, HttpException> 
+where 
+    T: DeserializeOwned + 'static,
+    B: Serialize + ?Sized,
+    Q: Serialize + ?Sized,
+    P: Serialize + ?Sized,
+{
+    let (request, _) = prepare_request(
+        default_api_root,
+        segment_name,
+        controller_name,
+        handler_name,
+        body,
+        form,
+        query,
+        params,
+        headers,
+        api_root,
+        disable_client_validation,
+    ).map_err(|e| HttpException {
+        message: e.to_string(),
+        status_code: 0,
+        cause: None,
+    })?;
+
+    let response = request.send().await.map_err(|e| HttpException {
+        message: e.to_string(),
+        status_code: 0,
+        cause: None,
+    })?;
+
+    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) => Some(Err(HttpException {
+                message: e.to_string(),
+                status_code,
+                cause: None,
+            })),
+        }
+    });
+
+    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
+fn build_query_string(data: &Value, prefix: &str) -> String {
+    match data {
+        Value::Object(map) => {
+            let parts: Vec<String> = map
+                .iter()
+                .map(|(k, v)| {
+                    let new_prefix = if prefix.is_empty() {
+                        k.to_string()
+                    } else {
+                        format!("{}[{}]", prefix, k)
+                    };
+                    build_query_string(v, &new_prefix)
+                })
+                .collect();
+            parts.join("&")
+        }
+        Value::Array(arr) => {
+            let parts: Vec<String> = arr
+                .iter()
+                .enumerate()
+                .map(|(i, v)| {
+                    let new_prefix = format!("{}[{}]", prefix, i);
+                    build_query_string(v, &new_prefix)
+                })
+                .collect();
+            parts.join("&")
+        }
+        Value::Null => String::new(),
+        _ => {
+            let value_str = match data {
+                Value::String(s) => s.clone(),
+                _ => data.to_string(),
+            };
+            format!("{}={}", prefix, urlencoding::encode(&value_str))
+        }
+    }
+}
+