vovk-rust 0.0.1-beta.2

package/index.js

@@ -0,0 +1,534 @@
+// Helper function for indentation
+export function indent(level, pad = 0) {
+    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.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' };
+    }
+    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;
+}
+// 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;
+}
+// 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.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';
+                }
+                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';
+        }
+    }
+    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 '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 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;
+}
+// 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 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;
+    }
+    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);
+}
+// 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 '';
+    }
+    // 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-isForm'] === 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;
+            }
+        }
+        // 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 (!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);
+    });
+    // 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;
+}
+// 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;
+}
+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-isForm': defSchema['x-isForm'],
+                        };
+                        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-isForm': schemaObj['x-isForm'],
+            };
+            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(1)}pub type ${schemaName} = Vec<${itemType}>;\n\n`;
+        }
+    });
+    result += `${indentFn(0)}}\n`;
+    return result;
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "vovk-rust",
+  "version": "0.0.1-beta.2",
+  "description": "Vovk.ts Rust client",
+  "scripts": {
+    "build": "tsc",
+    "npm-publish": "npm publish",
+    "tsc": "tsc --noEmit",
+    "ncu": "npm-check-updates -u",
+    "pre-test": "npm run build",
+    "test-only": "npm run pre-test && node --experimental-strip-types --test --test-only test/test/**/*.mts",
+    "unit": "npm run pre-test && node --experimental-strip-types --test --test-concurrency=1 test/*.mts",
+    "unit:rs": "RUST_BACKTRACE=full cargo test --manifest-path ./test_rust/Cargo.toml -- --show-output",
+    "unit:ts": "npm run pre-test && node --experimental-strip-types --test --test-concurrency=1 test_ts/*.mts",
+    "generate": "npm run generate --prefix ../../test -- --config=../packages/vovk-rust/vovk.config.test.mjs",
+    "test": "npm run unit:ts && PORT=3210 concurrently 'sleep 60 && npm run unit:rs' 'npm run generate && npm run build --prefix ../../test && npm run start --prefix ../../test' --kill-others --success first"
+  },
+  "main": "./index.js",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/finom/vovk.git"
+  },
+  "keywords": [
+    "Vovk"
+  ],
+  "author": "Andrey Gubanov",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/finom/vovk/issues"
+  },
+  "homepage": "https://github.com/finom/vovk#readme"
+}