vovk-rust 0.0.1-beta.14 → 0.0.1-beta.16

package/client-templates/rsSrc/http_request.rs

@@ -46,6 +46,8 @@ 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>>,
@@ -111,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 =
@@ -189,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
@@ -220,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);
     }
@@ -239,6 +249,8 @@ pub async fn http_request<T, 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>>,
@@ -258,6 +270,8 @@ where
         handler_name,
         body,
         form,
+        text_body,
+        binary_body,
         query,
         params,
         headers,
@@ -344,6 +358,8 @@ pub async fn http_request_stream<T, 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>>,
@@ -363,6 +379,8 @@ where
         handler_name,
         body,
         form,
+        text_body,
+        binary_body,
         query,
         params,
         headers,

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

@@ -45,8 +45,20 @@ 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') %>
+<%
+    // 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: <%- validation?.body ? (validation?.body?.['x-isForm'] ?'reqwest::multipart::Form' : `${handlerName}_::body`): '()' %>,
+        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>>,
@@ -56,7 +68,7 @@ vars.convertJSONSchemasToRustTypes({
         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') %>
@@ -65,8 +77,10 @@ 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,

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
@@ -225,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
@@ -235,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;
 }
@@ -288,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;
     }
@@ -337,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
@@ -352,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 ||
@@ -379,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);
@@ -409,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';
@@ -441,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]) => {
@@ -460,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);
                     }
@@ -470,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);
                     }
@@ -486,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);
         }
@@ -505,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,6 +1,6 @@
 {
   "name": "vovk-rust",
-  "version": "0.0.1-beta.14",
+  "version": "0.0.1-beta.16",
   "description": "Codegen templates for Rust client library for Vovk.ts",
   "files": [
     "client-templates",