vovk-rust 0.0.1-draft.37 → 0.0.1-draft.40

package/index.js

@@ -1,534 +1,504 @@
 // Helper function for indentation
 export function indent(level, pad = 0) {
-    return ' '.repeat(pad + level * 2);
+  return ' '.repeat(pad + level * 2);
 }
 // Generate documentation comments from title and description
 export function generateDocComment(schema, level, pad = 0) {
-    if (!schema?.title && !schema?.description)
-        return '';
-    let comment = '';
-    if (schema.title) {
-        comment += `${indent(level, pad)}/// ${schema.title}\n`;
-        if (schema.description) {
-            comment += `${indent(level, pad)}///\n`;
-        }
-    }
+  if (!schema?.title && !schema?.description) return '';
+  let comment = '';
+  if (schema.title) {
+    comment += `${indent(level, pad)}/// ${schema.title}\n`;
     if (schema.description) {
-        // Split description into lines and add /// to each line
-        const lines = schema.description.split('\n');
-        for (const line of lines) {
-            comment += `${indent(level, pad)}/// ${line}\n`;
-        }
+      comment += `${indent(level, pad)}///\n`;
     }
-    return comment;
+  }
+  if (schema.description) {
+    // Split description into lines and add /// to each line
+    const lines = schema.description.split('\n');
+    for (const line of lines) {
+      comment += `${indent(level, pad)}/// ${line}\n`;
+    }
+  }
+  return comment;
 }
 // Track processed $refs to avoid circular references
 const processedRefs = new Set();
 // Resolve $ref paths in the schema
 export function resolveRef(ref, rootSchema) {
-    if (processedRefs.has(ref)) {
-        // Circular reference detected, return a placeholder
-        return { type: 'string' };
+  if (processedRefs.has(ref)) {
+    // Circular reference detected, return a placeholder
+    return { type: 'string' };
+  }
+  processedRefs.add(ref);
+  // Format: #/$defs/TypeName or #/components/schemas/TypeName or #/definitions/TypeName etc.
+  const parts = ref.split('/').filter((part) => part && part !== '#');
+  // Standard path traversal
+  let current = rootSchema;
+  for (const part of parts) {
+    if (!current || typeof current !== 'object') {
+      // If standard traversal fails and the path might be a definition reference
+      if (parts.includes('definitions') && rootSchema.definitions) {
+        // Try to access the definition directly using the last part as the key
+        const definitionKey = parts[parts.length - 1];
+        return rootSchema.definitions[definitionKey];
+      }
+      return undefined;
     }
-    processedRefs.add(ref);
-    // Format: #/$defs/TypeName or #/components/schemas/TypeName or #/definitions/TypeName etc.
-    const parts = ref.split('/').filter((part) => part && part !== '#');
-    // Standard path traversal
-    let current = rootSchema;
-    for (const part of parts) {
-        if (!current || typeof current !== 'object') {
-            // If standard traversal fails and the path might be a definition reference
-            if (parts.includes('definitions') && rootSchema.definitions) {
-                // Try to access the definition directly using the last part as the key
-                const definitionKey = parts[parts.length - 1];
-                return rootSchema.definitions[definitionKey];
-            }
-            return undefined;
-        }
-        current = current[part];
-    }
-    // If the resolved schema also has a $ref, resolve it recursively
-    if (current && current.$ref) {
-        return resolveRef(current.$ref, rootSchema);
-    }
-    processedRefs.delete(ref);
-    return current;
+    current = current[part];
+  }
+  // If the resolved schema also has a $ref, resolve it recursively
+  if (current && current.$ref) {
+    return resolveRef(current.$ref, rootSchema);
+  }
+  processedRefs.delete(ref);
+  return current;
 }
 // Generate module path for nested types
 export function getModulePath(path) {
-    if (path.length <= 1)
-        return path[0];
-    let result = '';
-    for (let i = 0; i < path.length - 1; i++) {
-        result += path[i] + '_::';
-    }
-    result += path[path.length - 1];
-    return result;
+  if (path.length <= 1) return path[0];
+  let result = '';
+  for (let i = 0; i < path.length - 1; i++) {
+    result += path[i] + '_::';
+  }
+  result += path[path.length - 1];
+  return result;
 }
 // Convert JSON Schema type to Rust type
 export function toRustType(schema, path, rootSchema = schema) {
-    if (!schema)
-        return 'String';
-    // Handle $ref first
-    if (schema.$ref) {
-        const resolvedSchema = resolveRef(schema.$ref, rootSchema);
-        if (resolvedSchema) {
-            // Extract type name from ref path for better type naming
-            const refName = schema.$ref.split('/').pop();
-            // Use the ref name directly if it's a definition reference
-            if (schema.$ref.includes('definitions/') || schema.$ref.includes('$defs/')) {
-                return refName || 'String';
-            }
-            return toRustType(resolvedSchema, refName ? [...path.slice(0, -1), refName] : path, rootSchema);
-        }
-        return 'serde_json::Value'; // Fallback for unresolved $ref
-    }
-    // Check for enum without type (assume string)
-    if (schema.enum) {
-        if (schema.type === 'string' || !schema.type) {
-            return `${getModulePath(path)}`;
-        }
+  if (!schema) return 'String';
+  // Handle $ref first
+  if (schema.$ref) {
+    const resolvedSchema = resolveRef(schema.$ref, rootSchema);
+    if (resolvedSchema) {
+      // Extract type name from ref path for better type naming
+      const refName = schema.$ref.split('/').pop();
+      // Use the ref name directly if it's a definition reference
+      if (schema.$ref.includes('definitions/') || schema.$ref.includes('$defs/')) {
+        return refName || 'String';
+      }
+      return toRustType(resolvedSchema, refName ? [...path.slice(0, -1), refName] : path, rootSchema);
     }
-    if (schema.type === 'string') {
-        return 'String';
+    return 'serde_json::Value'; // Fallback for unresolved $ref
+  }
+  // Check for enum without type (assume string)
+  if (schema.enum) {
+    if (schema.type === 'string' || !schema.type) {
+      return `${getModulePath(path)}`;
     }
-    else if (schema.type === 'number' || schema.type === 'integer') {
-        // Handle numeric types with constraints
-        if (schema.type === 'integer') {
-            // Determine integer type based on min/max constraints
-            const min = typeof schema.minimum === 'number'
-                ? schema.minimum
-                : typeof schema.exclusiveMinimum === 'number'
-                    ? schema.exclusiveMinimum + 1
-                    : undefined;
-            const max = typeof schema.maximum === 'number'
-                ? schema.maximum
-                : typeof schema.exclusiveMaximum === 'number'
-                    ? schema.exclusiveMaximum - 1
-                    : undefined;
-            // Check if we need unsigned (no negative values)
-            if (min !== undefined && min >= 0) {
-                // Choose appropriate unsigned int size
-                if (max !== undefined) {
-                    if (max <= 255)
-                        return 'u8';
-                    if (max <= 65535)
-                        return 'u16';
-                    if (max <= 4294967295)
-                        return 'u32';
-                }
-                return 'u64'; // Default unsigned
-            }
-            else {
-                // Choose appropriate signed int size
-                if (min !== undefined && max !== undefined) {
-                    const absMin = Math.abs(min);
-                    const absMax = Math.abs(max);
-                    const maxVal = Math.max(absMin - 1, absMax);
-                    if (maxVal <= 127)
-                        return 'i8';
-                    if (maxVal <= 32767)
-                        return 'i16';
-                    if (maxVal <= 2147483647)
-                        return 'i32';
-                }
-                return 'i64'; // Default signed
-            }
-        }
-        else {
-            // Floating point
-            const hasLowRange = (schema.minimum !== undefined &&
-                schema.maximum !== undefined &&
-                Math.abs(schema.maximum - schema.minimum) <= 3.4e38) ||
-                (schema.exclusiveMinimum !== undefined &&
-                    schema.exclusiveMaximum !== undefined &&
-                    Math.abs(schema.exclusiveMaximum - schema.exclusiveMinimum) <= 3.4e38);
-            return hasLowRange ? 'f32' : 'f64';
+  }
+  if (schema.type === 'string') {
+    return 'String';
+  } else if (schema.type === 'number' || schema.type === 'integer') {
+    // Handle numeric types with constraints
+    if (schema.type === 'integer') {
+      // Determine integer type based on min/max constraints
+      const min =
+        typeof schema.minimum === 'number'
+          ? schema.minimum
+          : typeof schema.exclusiveMinimum === 'number'
+            ? schema.exclusiveMinimum + 1
+            : undefined;
+      const max =
+        typeof schema.maximum === 'number'
+          ? schema.maximum
+          : typeof schema.exclusiveMaximum === 'number'
+            ? schema.exclusiveMaximum - 1
+            : undefined;
+      // Check if we need unsigned (no negative values)
+      if (min !== undefined && min >= 0) {
+        // Choose appropriate unsigned int size
+        if (max !== undefined) {
+          if (max <= 255) return 'u8';
+          if (max <= 65535) return 'u16';
+          if (max <= 4294967295) return 'u32';
         }
-    }
-    else if (schema.type === 'boolean') {
-        return 'bool';
-    }
-    else if (schema.type === 'null') {
-        return '()';
-    }
-    else if (schema.type === 'array') {
-        if (schema.items) {
-            // 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
-                // Find the parent module name to reference the item
-                const parentName = path[path.length - 2] || path[0];
-                return `Vec<${parentName}_::${path[path.length - 1]}Item>`;
-            }
-            const itemType = toRustType(schema.items, [...path, '_item'], rootSchema);
-            return `Vec<${itemType}>`;
+        return 'u64'; // Default unsigned
+      } else {
+        // Choose appropriate signed int size
+        if (min !== undefined && max !== undefined) {
+          const absMin = Math.abs(min);
+          const absMax = Math.abs(max);
+          const maxVal = Math.max(absMin - 1, absMax);
+          if (maxVal <= 127) return 'i8';
+          if (maxVal <= 32767) return 'i16';
+          if (maxVal <= 2147483647) return 'i32';
         }
-        return 'Vec<String>';
+        return 'i64'; // Default signed
+      }
+    } else {
+      // Floating point
+      const hasLowRange =
+        (schema.minimum !== undefined &&
+          schema.maximum !== undefined &&
+          Math.abs(schema.maximum - schema.minimum) <= 3.4e38) ||
+        (schema.exclusiveMinimum !== undefined &&
+          schema.exclusiveMaximum !== undefined &&
+          Math.abs(schema.exclusiveMaximum - schema.exclusiveMinimum) <= 3.4e38);
+      return hasLowRange ? 'f32' : 'f64';
     }
-    else if (schema.type === 'object' || schema.properties) {
-        // Handle empty objects
-        if (schema.type === 'object' && (!schema.properties || Object.keys(schema.properties).length === 0)) {
-            return 'serde_json::Value';
-        }
-        return path[path.length - 1];
+  } else if (schema.type === 'boolean') {
+    return 'bool';
+  } else if (schema.type === 'null') {
+    return '()';
+  } else if (schema.type === 'array') {
+    if (schema.items) {
+      // 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
+        // Find the parent module name to reference the item
+        const parentName = path[path.length - 2] || path[0];
+        return `Vec<${parentName}_::${path[path.length - 1]}Item>`;
+      }
+      const itemType = toRustType(schema.items, [...path, '_item'], rootSchema);
+      return `Vec<${itemType}>`;
     }
-    else if (schema.anyOf || schema.oneOf || schema.allOf) {
-        return `${getModulePath(path)}`;
+    return 'Vec<String>';
+  } else if (schema.type === 'object' || schema.properties) {
+    // Handle empty objects
+    if (schema.type === 'object' && (!schema.properties || Object.keys(schema.properties).length === 0)) {
+      return 'serde_json::Value';
     }
-    return 'String'; // Default fallback
+    return path[path.length - 1];
+  } else if (schema.anyOf || schema.oneOf || schema.allOf) {
+    return `${getModulePath(path)}`;
+  }
+  return 'String'; // Default fallback
 }
 // Generate enum for string with enum values
 export function generateEnum(schema, name, level, pad = 0) {
-    const indentFn = (level) => ' '.repeat(pad + level * 2);
-    let code = '';
-    // Add documentation comments for the enum
-    code += generateDocComment(schema, level, pad);
-    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) => {
-        // 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`;
-    });
-    code += `${indentFn(level)}}\n\n`;
-    return code;
+  const indentFn = (level) => ' '.repeat(pad + level * 2);
+  let code = '';
+  // Add documentation comments for the enum
+  code += generateDocComment(schema, level, pad);
+  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) => {
+    // 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`;
+  });
+  code += `${indentFn(level)}}\n\n`;
+  return code;
 }
 // Generate enum for anyOf/oneOf/allOf schemas
 export function generateVariantEnum(schema, name, path, level, rootSchema, pad = 0) {
-    const indentFn = (level) => ' '.repeat(pad + level * 2);
-    // Handle allOf separately - it should combine schemas rather than create variants
-    if (schema.allOf) {
-        return generateAllOfType(schema.allOf, name, path, level, rootSchema, pad);
+  const indentFn = (level) => ' '.repeat(pad + level * 2);
+  // Handle allOf separately - it should combine schemas rather than create variants
+  if (schema.allOf) {
+    return generateAllOfType(schema.allOf, name, path, level, rootSchema, pad);
+  }
+  const variants = schema.anyOf || schema.oneOf || [];
+  let code = '';
+  let nestedTypes = '';
+  // Add documentation comments for the enum
+  code += generateDocComment(schema, level, pad);
+  code += `${indentFn(level)}#[derive(Debug, Serialize, Deserialize, Clone)]\n`;
+  code += `${indentFn(level)}#[allow(non_camel_case_types)]\n`;
+  code += `${indentFn(level)}#[serde(untagged)]\n`;
+  code += `${indentFn(level)}pub enum ${name} {\n`;
+  variants.forEach((variant, index) => {
+    // Resolve $ref if present
+    if (variant.$ref) {
+      const resolved = resolveRef(variant.$ref, rootSchema);
+      if (resolved) {
+        variant = resolved;
+      }
     }
-    const variants = schema.anyOf || schema.oneOf || [];
-    let code = '';
-    let nestedTypes = '';
-    // Add documentation comments for the enum
-    code += generateDocComment(schema, level, pad);
-    code += `${indentFn(level)}#[derive(Debug, Serialize, Deserialize, Clone)]\n`;
-    code += `${indentFn(level)}#[allow(non_camel_case_types)]\n`;
-    code += `${indentFn(level)}#[serde(untagged)]\n`;
-    code += `${indentFn(level)}pub enum ${name} {\n`;
-    variants.forEach((variant, index) => {
-        // Resolve $ref if present
-        if (variant.$ref) {
-            const resolved = resolveRef(variant.$ref, rootSchema);
-            if (resolved) {
-                variant = resolved;
-            }
-        }
-        const variantName = `Variant${index}`;
-        const variantPath = [...path, name, variantName];
-        // 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);
-        }
-        else {
-            // For simple types, we can include them directly in the enum
-            const variantType = toRustType(variant, variantPath, rootSchema);
-            code += `${indentFn(level + 1)}${variantName}(${variantType}),\n`;
-        }
-    });
-    code += `${indentFn(level)}}\n\n`;
-    // Add nested type definitions if needed
-    if (nestedTypes) {
-        code += nestedTypes;
+    const variantName = `Variant${index}`;
+    const variantPath = [...path, name, variantName];
+    // 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);
+    } else {
+      // For simple types, we can include them directly in the enum
+      const variantType = toRustType(variant, variantPath, rootSchema);
+      code += `${indentFn(level + 1)}${variantName}(${variantType}),\n`;
     }
-    return code;
+  });
+  code += `${indentFn(level)}}\n\n`;
+  // Add nested type definitions if needed
+  if (nestedTypes) {
+    code += nestedTypes;
+  }
+  return code;
 }
 // Handle allOf schema by merging properties
 export function generateAllOfType(schemas, name, path, level, rootSchema, pad = 0) {
-    const mergedSchema = {
-        type: 'object',
-        properties: {},
-        required: [],
-    };
-    // Merge all schemas in allOf
-    schemas.forEach((schema) => {
-        // Resolve $ref if present
-        if (schema.$ref) {
-            const resolved = resolveRef(schema.$ref, rootSchema);
-            if (resolved) {
-                schema = resolved;
-            }
-        }
-        if (schema.properties) {
-            mergedSchema.properties = {
-                ...mergedSchema.properties,
-                ...schema.properties,
-            };
-        }
-        if (schema.required) {
-            mergedSchema.required = [...mergedSchema.required, ...schema.required];
-        }
-    });
-    // Process the merged schema as a regular object
-    return processObject(mergedSchema, [...path, name], level, rootSchema, pad);
+  const mergedSchema = {
+    type: 'object',
+    properties: {},
+    required: [],
+  };
+  // Merge all schemas in allOf
+  schemas.forEach((schema) => {
+    // Resolve $ref if present
+    if (schema.$ref) {
+      const resolved = resolveRef(schema.$ref, rootSchema);
+      if (resolved) {
+        schema = resolved;
+      }
+    }
+    if (schema.properties) {
+      mergedSchema.properties = {
+        ...mergedSchema.properties,
+        ...schema.properties,
+      };
+    }
+    if (schema.required) {
+      mergedSchema.required = [...mergedSchema.required, ...schema.required];
+    }
+  });
+  // Process the merged schema as a regular object
+  return processObject(mergedSchema, [...path, name], level, rootSchema, pad);
 }
 // Process schema objects and generate Rust code
 export function processObject(schema, path, level, rootSchema = schema, pad = 0) {
-    const indentFn = (level) => ' '.repeat(pad + level * 2);
-    if (!schema) {
-        return '';
+  const indentFn = (level) => ' '.repeat(pad + level * 2);
+  if (!schema) {
+    return '';
+  }
+  // Handle empty objects
+  if (schema.type === 'object' && (!schema.properties || Object.keys(schema.properties).length === 0)) {
+    // Empty object is handled as serde_json::Value at the field level
+    return '';
+  }
+  if (!schema.properties) {
+    return '';
+  }
+  const currentName = path[path.length - 1];
+  let code = '';
+  // Add documentation comments for the struct
+  code += generateDocComment(schema, level, pad);
+  if (schema.type === 'object' && schema['x-formData'] === true) {
+    code += `${indentFn(level)}pub use reqwest::multipart::Form as ${currentName};\n`;
+    return code;
+  }
+  // Generate struct
+  code += `${indentFn(level)}#[derive(Debug, Serialize, Deserialize, Clone)]\n`;
+  code += `${indentFn(level)}#[allow(non_snake_case, non_camel_case_types)]\n`;
+  code += `${indentFn(level)}pub struct ${currentName} {\n`;
+  // Generate struct fields
+  Object.entries(schema.properties).forEach(([propName, propSchema]) => {
+    const isRequired = schema.required && schema.required.includes(propName);
+    // Handle $ref in property
+    if (propSchema.$ref) {
+      const resolvedSchema = resolveRef(propSchema.$ref, rootSchema);
+      if (resolvedSchema) {
+        propSchema = resolvedSchema;
+      }
     }
-    // Handle empty objects
-    if (schema.type === 'object' && (!schema.properties || Object.keys(schema.properties).length === 0)) {
-        // Empty object is handled as serde_json::Value at the field level
-        return '';
+    // Add documentation comments for the field
+    code += generateDocComment(propSchema, level + 1, pad);
+    // Determine if this property is a nested type that should be accessed via module path
+    const isNestedObject = propSchema.type === 'object' || propSchema.properties;
+    const isGenericObject = propSchema.type === 'object' && !propSchema.properties;
+    // Define nested enum types
+    const isNestedEnum =
+      ((propSchema.type === 'string' || !propSchema.type) && propSchema.enum) ||
+      propSchema.anyOf ||
+      propSchema.oneOf ||
+      propSchema.allOf;
+    const propPath = [...path, propName];
+    let propType;
+    if (isGenericObject) {
+      // For generic objects, we can use serde_json::Value
+      propType = 'serde_json::Value';
+    } else if (isNestedObject || isNestedEnum) {
+      // For nested objects and enums, we need to reference them via their module path
+      propType = `${currentName}_::${propName}`;
+      // Special case for enums which have a different naming convention
+      if (isNestedEnum) {
+        propType += ''; // 'Enum';
+      }
+    } else {
+      // For other types, use the standard type resolution
+      propType = toRustType(propSchema, propPath, rootSchema);
     }
-    if (!schema.properties) {
-        return '';
+    if (!isRequired) {
+      propType = `Option<${propType}>`;
     }
-    const currentName = path[path.length - 1];
-    let code = '';
-    // Add documentation comments for the struct
-    code += generateDocComment(schema, level, pad);
-    if (schema.type === 'object' && schema['x-formData'] === true) {
-        code += `${indentFn(level)}pub use reqwest::multipart::Form as ${currentName};\n`;
-        return code;
+    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
+  const hasNestedTypes = Object.entries(schema.properties).some(([, propSchema]) => {
+    // Resolve $ref if present
+    if (propSchema.$ref) {
+      const resolved = resolveRef(propSchema.$ref, rootSchema);
+      propSchema = resolved || propSchema;
     }
-    // Generate struct
-    code += `${indentFn(level)}#[derive(Debug, Serialize, Deserialize, Clone)]\n`;
-    code += `${indentFn(level)}#[allow(non_snake_case, non_camel_case_types)]\n`;
-    code += `${indentFn(level)}pub struct ${currentName} {\n`;
-    // Generate struct fields
+    return (
+      propSchema.type === 'object' ||
+      propSchema.properties ||
+      ((propSchema.type === 'string' || !propSchema.type) && propSchema.enum) ||
+      (propSchema.type === 'array' &&
+        propSchema.items &&
+        (propSchema.items.type === 'object' || propSchema.items.properties || propSchema.items.$ref)) ||
+      propSchema.anyOf ||
+      propSchema.oneOf ||
+      propSchema.allOf
+    );
+  });
+  // Only generate sub-modules if there are nested types
+  if (hasNestedTypes && Object.keys(schema.properties).length > 0) {
+    code += `${indentFn(level)}#[allow(non_snake_case)]\n`;
+    code += `${indentFn(level)}pub mod ${currentName}_ {\n`;
+    code += `${indentFn(level + 1)}use serde::{Serialize, Deserialize};\n\n`;
     Object.entries(schema.properties).forEach(([propName, propSchema]) => {
-        const isRequired = schema.required && schema.required.includes(propName);
-        // Handle $ref in property
-        if (propSchema.$ref) {
-            const resolvedSchema = resolveRef(propSchema.$ref, rootSchema);
-            if (resolvedSchema) {
-                propSchema = resolvedSchema;
-            }
+      // Resolve $ref if present
+      if (propSchema.$ref) {
+        const resolved = resolveRef(propSchema.$ref, rootSchema);
+        if (resolved) {
+          propSchema = resolved;
         }
-        // Add documentation comments for the field
-        code += generateDocComment(propSchema, level + 1, pad);
-        // Determine if this property is a nested type that should be accessed via module path
-        const isNestedObject = propSchema.type === 'object' || propSchema.properties;
-        const isGenericObject = propSchema.type === 'object' && !propSchema.properties;
-        // Define nested enum types
-        const isNestedEnum = ((propSchema.type === 'string' || !propSchema.type) && propSchema.enum) ||
-            propSchema.anyOf ||
-            propSchema.oneOf ||
-            propSchema.allOf;
-        const propPath = [...path, propName];
-        let propType;
-        if (isGenericObject) {
-            // For generic objects, we can use serde_json::Value
-            propType = 'serde_json::Value';
+      }
+      // Generate nested object types
+      if (propSchema.type === 'object' || propSchema.properties) {
+        code += processObject(propSchema, [...path, propName], level + 1, rootSchema, pad);
+      }
+      // Generate enum types for string enums (also when type is missing but enum exists)
+      else if ((propSchema.type === 'string' || !propSchema.type) && propSchema.enum) {
+        code += generateEnum(propSchema, propName, level + 1, pad);
+      }
+      // Generate types for array items if they're objects
+      else if (propSchema.type === 'array' && propSchema.items) {
+        // Check if items has a $ref
+        if (propSchema.items.$ref) {
+          const resolved = resolveRef(propSchema.items.$ref, rootSchema);
+          if (resolved && (resolved.type === 'object' || resolved.properties)) {
+            code += processObject(resolved, [...path, propName + 'Item'], level + 1, rootSchema, pad);
+          }
+        } else if (propSchema.items.type === 'object' || propSchema.items.properties) {
+          code += processObject(propSchema.items, [...path, propName + 'Item'], level + 1, rootSchema, pad);
         }
-        else if (isNestedObject || isNestedEnum) {
-            // For nested objects and enums, we need to reference them via their module path
-            propType = `${currentName}_::${propName}`;
-            // Special case for enums which have a different naming convention
-            if (isNestedEnum) {
-                propType += ''; // 'Enum';
-            }
-        }
-        else {
-            // For other types, use the standard type resolution
-            propType = toRustType(propSchema, propPath, rootSchema);
-        }
-        if (!isRequired) {
-            propType = `Option<${propType}>`;
-        }
-        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
-    const hasNestedTypes = Object.entries(schema.properties).some(([, propSchema]) => {
-        // Resolve $ref if present
-        if (propSchema.$ref) {
-            const resolved = resolveRef(propSchema.$ref, rootSchema);
-            propSchema = resolved || propSchema;
-        }
-        return (propSchema.type === 'object' ||
-            propSchema.properties ||
-            ((propSchema.type === 'string' || !propSchema.type) && propSchema.enum) ||
-            (propSchema.type === 'array' &&
-                propSchema.items &&
-                (propSchema.items.type === 'object' || propSchema.items.properties || propSchema.items.$ref)) ||
-            propSchema.anyOf ||
-            propSchema.oneOf ||
-            propSchema.allOf);
+      }
+      // Handle anyOf/oneOf/allOf schemas
+      else if (propSchema.anyOf || propSchema.oneOf || propSchema.allOf) {
+        code += generateVariantEnum(propSchema, propName, path, level + 1, rootSchema, pad);
+      }
     });
-    // Only generate sub-modules if there are nested types
-    if (hasNestedTypes && Object.keys(schema.properties).length > 0) {
-        code += `${indentFn(level)}#[allow(non_snake_case)]\n`;
-        code += `${indentFn(level)}pub mod ${currentName}_ {\n`;
-        code += `${indentFn(level + 1)}use serde::{Serialize, Deserialize};\n\n`;
-        Object.entries(schema.properties).forEach(([propName, propSchema]) => {
-            // Resolve $ref if present
-            if (propSchema.$ref) {
-                const resolved = resolveRef(propSchema.$ref, rootSchema);
-                if (resolved) {
-                    propSchema = resolved;
-                }
-            }
-            // Generate nested object types
-            if (propSchema.type === 'object' || propSchema.properties) {
-                code += processObject(propSchema, [...path, propName], level + 1, rootSchema, pad);
-            }
-            // Generate enum types for string enums (also when type is missing but enum exists)
-            else if ((propSchema.type === 'string' || !propSchema.type) && propSchema.enum) {
-                code += generateEnum(propSchema, propName, level + 1, pad);
-            }
-            // Generate types for array items if they're objects
-            else if (propSchema.type === 'array' && propSchema.items) {
-                // Check if items has a $ref
-                if (propSchema.items.$ref) {
-                    const resolved = resolveRef(propSchema.items.$ref, rootSchema);
-                    if (resolved && (resolved.type === 'object' || resolved.properties)) {
-                        code += processObject(resolved, [...path, propName + 'Item'], level + 1, rootSchema, pad);
-                    }
-                }
-                else if (propSchema.items.type === 'object' || propSchema.items.properties) {
-                    code += processObject(propSchema.items, [...path, propName + 'Item'], level + 1, rootSchema, pad);
-                }
-            }
-            // Handle anyOf/oneOf/allOf schemas
-            else if (propSchema.anyOf || propSchema.oneOf || propSchema.allOf) {
-                code += generateVariantEnum(propSchema, propName, path, level + 1, rootSchema, pad);
-            }
-        });
-        code += `${indentFn(level)}}\n`;
-    }
-    return code;
+    code += `${indentFn(level)}}\n`;
+  }
+  return code;
 }
 // Generate code for primitive types
 export function processPrimitive(schema, name, level, pad = 0) {
-    const indentFn = (level) => ' '.repeat(pad + level * 2);
-    let code = '';
-    // Add documentation comments
-    code += generateDocComment(schema, level, pad);
-    // For primitive types, create a type alias
-    code += `${indentFn(level)}pub type ${name} = `;
-    if (schema.type === 'string') {
-        code += 'String';
-    }
-    else if (schema.type === 'number') {
-        code += 'f64';
-    }
-    else if (schema.type === 'integer') {
-        code += 'i64';
-    }
-    else if (schema.type === 'boolean') {
-        code += 'bool';
-    }
-    else if (schema.type === 'null') {
-        code += '()';
-    }
-    else if (schema.enum) {
-        // If it has enum values, we'll generate an actual enum instead of a type alias
-        return generateEnum(schema, name, level, pad);
-    }
-    else {
-        code += 'String'; // Default fallback
-    }
-    code += ';\n\n';
-    return code;
+  const indentFn = (level) => ' '.repeat(pad + level * 2);
+  let code = '';
+  // Add documentation comments
+  code += generateDocComment(schema, level, pad);
+  // For primitive types, create a type alias
+  code += `${indentFn(level)}pub type ${name} = `;
+  if (schema.type === 'string') {
+    code += 'String';
+  } else if (schema.type === 'number') {
+    code += 'f64';
+  } else if (schema.type === 'integer') {
+    code += 'i64';
+  } else if (schema.type === 'boolean') {
+    code += 'bool';
+  } else if (schema.type === 'null') {
+    code += '()';
+  } else if (schema.enum) {
+    // If it has enum values, we'll generate an actual enum instead of a type alias
+    return generateEnum(schema, name, level, pad);
+  } else {
+    code += 'String'; // Default fallback
+  }
+  code += ';\n\n';
+  return code;
 }
-export function convertJSONSchemasToRustTypes({ schemas, pad = 0, rootName, }) {
-    // Check if all schemas are undefined
-    const hasDefinedSchemas = Object.values(schemas).some((schema) => schema !== undefined);
-    if (!hasDefinedSchemas) {
-        return '';
-    }
-    const indentFn = (level) => ' '.repeat(pad + level * 2);
-    // Start code generation
-    let result = `${indentFn(0)}pub mod ${rootName}_ {\n`;
-    result += `${indentFn(1)}use serde::{Serialize, Deserialize};\n`;
-    // Process each schema in the schemas object
-    Object.entries(schemas).forEach(([schemaName, schemaObj]) => {
-        // Skip undefined schemas
-        if (!schemaObj)
-            return;
-        // Extract and process types from $defs if present
-        if (schemaObj.$defs) {
-            Object.entries(schemaObj.$defs).forEach(([defName, defSchema]) => {
-                // Create a root object for each definition
-                if (defSchema) {
-                    if (defSchema.type === 'object' || defSchema.properties) {
-                        const rootDefObject = {
-                            type: 'object',
-                            properties: defSchema.properties || {},
-                            required: defSchema.required || [],
-                            title: defSchema.title,
-                            description: defSchema.description,
-                            'x-formData': defSchema['x-formData'],
-                        };
-                        result += processObject(rootDefObject, [defName], 1, schemaObj, pad);
-                    }
-                    else if (defSchema.type === 'string' && defSchema.enum) {
-                        result += generateEnum(defSchema, defName, 1, pad);
-                    }
-                    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)) {
-                        // Handle primitive types in $defs
-                        result += processPrimitive(defSchema, defName, 1, pad);
-                    }
-                }
-            });
-        }
-        // Handle the schema based on its type
-        if (schemaObj.type === 'object' || schemaObj.properties) {
-            // Create a root object for object schema
-            const rootObject = {
-                type: 'object',
-                properties: schemaObj.properties || {},
-                required: schemaObj.required || [],
-                title: schemaObj.title,
-                description: schemaObj.description,
-                'x-formData': schemaObj['x-formData'],
+export function convertJSONSchemasToRustTypes({ schemas, pad = 0, rootName }) {
+  // Check if all schemas are undefined
+  const hasDefinedSchemas = Object.values(schemas).some((schema) => schema !== undefined);
+  if (!hasDefinedSchemas) {
+    return '';
+  }
+  const indentFn = (level) => ' '.repeat(pad + level * 2);
+  // Start code generation
+  let result = `${indentFn(0)}pub mod ${rootName}_ {\n`;
+  result += `${indentFn(1)}use serde::{Serialize, Deserialize};\n`;
+  // Process each schema in the schemas object
+  Object.entries(schemas).forEach(([schemaName, schemaObj]) => {
+    // Skip undefined schemas
+    if (!schemaObj) return;
+    // Extract and process types from $defs if present
+    if (schemaObj.$defs) {
+      Object.entries(schemaObj.$defs).forEach(([defName, defSchema]) => {
+        // Create a root object for each definition
+        if (defSchema) {
+          if (defSchema.type === 'object' || defSchema.properties) {
+            const rootDefObject = {
+              type: 'object',
+              properties: defSchema.properties || {},
+              required: defSchema.required || [],
+              title: defSchema.title,
+              description: defSchema.description,
+              'x-formData': defSchema['x-formData'],
             };
-            result += processObject(rootObject, [schemaName], 1, schemaObj, pad);
-        }
-        else if (['string', 'number', 'integer', 'boolean', 'null'].includes(schemaObj.type)) {
-            // Handle primitive schema
-            result += processPrimitive(schemaObj, schemaName, 1, pad);
-        }
-        else if (schemaObj.enum) {
-            // Handle enum schema
-            result += generateEnum(schemaObj, schemaName, 1, pad);
-        }
-        else if (schemaObj.anyOf || schemaObj.oneOf || schemaObj.allOf) {
-            // Handle variant schema
-            result += generateVariantEnum(schemaObj, schemaName, [schemaName], 1, schemaObj, pad);
+            result += processObject(rootDefObject, [defName], 1, schemaObj, pad);
+          } else if (defSchema.type === 'string' && defSchema.enum) {
+            result += generateEnum(defSchema, defName, 1, pad);
+          } 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)) {
+            // Handle primitive types in $defs
+            result += processPrimitive(defSchema, defName, 1, pad);
+          }
         }
-        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.type === 'object' || schemaObj.items.properties) {
-                    // Create the item type
-                    const itemSchema = {
-                        ...schemaObj.items,
-                        title: schemaObj.items.title || `${schemaName}Item`,
-                        description: schemaObj.items.description || `Item of ${schemaName} array`,
-                    };
-                    result += processObject(itemSchema, [`${schemaName}Item`], 1, schemaObj, pad);
-                    itemType = `${schemaName}Item`;
-                }
-                else {
-                    // For primitive array items
-                    itemType = toRustType(schemaObj.items, [`${schemaName}Item`], schemaObj);
-                }
-            }
-            result += `${indentFn(1)}pub type ${schemaName} = Vec<${itemType}>;\n\n`;
+      });
+    }
+    // Handle the schema based on its type
+    if (schemaObj.type === 'object' || schemaObj.properties) {
+      // Create a root object for object schema
+      const rootObject = {
+        type: 'object',
+        properties: schemaObj.properties || {},
+        required: schemaObj.required || [],
+        title: schemaObj.title,
+        description: schemaObj.description,
+        'x-formData': schemaObj['x-formData'],
+      };
+      result += processObject(rootObject, [schemaName], 1, schemaObj, pad);
+    } else if (['string', 'number', 'integer', 'boolean', 'null'].includes(schemaObj.type)) {
+      // Handle primitive schema
+      result += processPrimitive(schemaObj, schemaName, 1, pad);
+    } else if (schemaObj.enum) {
+      // Handle enum schema
+      result += generateEnum(schemaObj, schemaName, 1, pad);
+    } else if (schemaObj.anyOf || schemaObj.oneOf || schemaObj.allOf) {
+      // Handle variant schema
+      result += generateVariantEnum(schemaObj, schemaName, [schemaName], 1, schemaObj, pad);
+    } 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.type === 'object' || schemaObj.items.properties) {
+          // Create the item type
+          const itemSchema = {
+            ...schemaObj.items,
+            title: schemaObj.items.title || `${schemaName}Item`,
+            description: schemaObj.items.description || `Item of ${schemaName} array`,
+          };
+          result += processObject(itemSchema, [`${schemaName}Item`], 1, schemaObj, pad);
+          itemType = `${schemaName}Item`;
+        } else {
+          // For primitive array items
+          itemType = toRustType(schemaObj.items, [`${schemaName}Item`], schemaObj);
         }
-    });
-    result += `${indentFn(0)}}\n`;
-    return result;
+      }
+      result += `${indentFn(1)}pub type ${schemaName} = Vec<${itemType}>;\n\n`;
+    }
+  });
+  result += `${indentFn(0)}}\n`;
+  return result;
 }

package/package.json

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

package/template/README.md.ejs

@@ -21,7 +21,8 @@ cargo install <%= t.package.name.replace(/-/g, '_') %>
 
 <%- handlerSchema.openapi?.description ? `${handlerSchema.openapi.description}` : '' %>
 
-`<%= handlerSchema.httpMethod %>  <%= [t.apiRoot, segmentName, controllerSchema.prefix, handlerSchema.path].filter(Boolean).join('/') %>`
+<% 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.createCodeExamples({