@ioka-technologies/asyncapi-rust-client-template 0.0.21 → 0.0.23

package/template/src/models.rs.js

@@ -5,552 +5,37 @@ import {
     toRustTypeName,
     toRustFieldName,
     toRustEnumVariant,
-    toRustEnumVariantWithSerde
-} from '../helpers/index.js';
+    toRustEnumVariantWithSerde,
+    generateRustModels,
+    generateMessageEnvelope
+} from '../../../common/src/index.js';
 
 export default function ModelsRs({ asyncapi }) {
-
-    // Extract message schemas and build channel mapping
-    const components = asyncapi.components();
-    const messageSchemas = [];
-    const componentSchemas = [];
-    const messageToChannels = new Map();
-    const generatedTypes = new Set();
-    const nestedSchemas = new Map();
-    const schemaRegistry = new Map();
-
-    // First, build channel to message mapping and extract inline message schemas
-    if (asyncapi.channels) {
-        const channels = asyncapi.channels();
-        if (channels) {
-            // Use proper iteration for AsyncAPI collection
-            for (const channel of channels) {
-                try {
-                    const channelName = channel.id();
-
-                    // Handle AsyncAPI 3.x format - extract inline messages from channels
-                    if (channel.messages) {
-                        const messages = channel.messages();
-                        if (messages) {
-                            // Check if messages is an object with message names as keys
-                            if (typeof messages === 'object' && !Array.isArray(messages)) {
-                                // Iterate through message entries (messageName -> messageObject)
-                                Object.entries(messages).forEach(([messageName, message]) => {
-                                    if (message && messageName) {
-                                        let payload = null;
-                                        let description = null;
-
-                                        // Get payload schema
-                                        if (message.payload && typeof message.payload === 'function') {
-                                            payload = message.payload();
-                                            if (payload && payload.json && typeof payload.json === 'function') {
-                                                payload = payload.json();
-                                            }
-                                        } else if (message.payload) {
-                                            payload = message.payload;
-                                        }
-
-                                        // Get description
-                                        if (message.description && typeof message.description === 'function') {
-                                            description = message.description();
-                                        } else if (message.description) {
-                                            description = message.description;
-                                        }
-
-                                        // Add to channel mapping
-                                        if (!messageToChannels.has(messageName)) {
-                                            messageToChannels.set(messageName, []);
-                                        }
-                                        messageToChannels.get(messageName).push(channelName);
-
-                                        // Add to message schemas for inline messages
-                                        messageSchemas.push({
-                                            name: messageName,
-                                            rustName: toRustTypeName(messageName),
-                                            payload,
-                                            rawPayload: payload,
-                                            description,
-                                            channels: [channelName]
-                                        });
-                                    }
-                                });
-                            } else {
-                                // Try iterating as a collection
-                                for (const message of messages) {
-                                    if (message) {
-                                        let messageName = null;
-                                        let payload = null;
-                                        let description = null;
-
-                                        // Get message name - try multiple approaches
-                                        if (message._meta && message._meta.id) {
-                                            messageName = message._meta.id;
-                                        } else if (message._json && message._json['x-parser-message-name']) {
-                                            messageName = message._json['x-parser-message-name'];
-                                        } else if (message._json && message._json['x-parser-unique-object-id']) {
-                                            messageName = message._json['x-parser-unique-object-id'];
-                                        } else if (message.name && typeof message.name === 'function') {
-                                            messageName = message.name();
-                                        } else if (message.name) {
-                                            messageName = message.name;
-                                        } else if (message.$ref) {
-                                            messageName = message.$ref.split('/').pop();
-                                        }
-
-                                        // Get payload schema
-                                        if (message.payload && typeof message.payload === 'function') {
-                                            payload = message.payload();
-                                            if (payload && payload.json && typeof payload.json === 'function') {
-                                                payload = payload.json();
-                                            }
-                                        } else if (message.payload) {
-                                            payload = message.payload;
-                                        }
-
-                                        // Get description
-                                        if (message.description && typeof message.description === 'function') {
-                                            description = message.description();
-                                        } else if (message.description) {
-                                            description = message.description;
-                                        }
-
-                                        if (messageName) {
-                                            // Add to channel mapping
-                                            if (!messageToChannels.has(messageName)) {
-                                                messageToChannels.set(messageName, []);
-                                            }
-                                            messageToChannels.get(messageName).push(channelName);
-
-                                            // Add to message schemas for inline messages
-                                            messageSchemas.push({
-                                                name: messageName,
-                                                rustName: toRustTypeName(messageName),
-                                                payload,
-                                                rawPayload: payload,
-                                                description,
-                                                channels: [channelName]
-                                            });
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                } catch (e) {
-                    // Ignore channel processing errors
-                    console.warn(`Error processing channel: ${e.message}`);
-                }
-            }
-        }
-    }
-
-    // Build schema registry from components.schemas
-    // Try to access the raw AsyncAPI document
-    let rawDoc = null;
-    try {
-        if (asyncapi.json && typeof asyncapi.json === 'function') {
-            rawDoc = asyncapi.json();
-        } else if (asyncapi._json) {
-            rawDoc = asyncapi._json;
-        }
-    } catch (e) {
-        // Ignore
-    }
-
-    // Extract schemas from raw document if available
-    if (rawDoc && rawDoc.components && rawDoc.components.schemas) {
-        Object.entries(rawDoc.components.schemas).forEach(([name, schema]) => {
-            if (name && typeof name === 'string' && schema && typeof schema === 'object') {
-                schemaRegistry.set(name, schema);
-                componentSchemas.push({
-                    name,
-                    rustName: toRustTypeName(name),
-                    schema: schema,
-                    description: schema.description
-                });
-            }
-        });
-    }
-
-    // Fallback: try the components.schemas() method
-    if (componentSchemas.length === 0 && components && components.schemas) {
-        try {
-            const schemas = components.schemas();
-            if (schemas) {
-                // Try different ways to access schemas
-                let schemaEntries = [];
-
-                if (schemas instanceof Map) {
-                    schemaEntries = Array.from(schemas.entries());
-                } else if (typeof schemas === 'object') {
-                    schemaEntries = Object.entries(schemas);
-                } else if (schemas.all && typeof schemas.all === 'function') {
-                    // AsyncAPI parser might have an all() method
-                    const allSchemas = schemas.all();
-                    if (Array.isArray(allSchemas)) {
-                        schemaEntries = allSchemas.map(schema => {
-                            const name = schema.uid ? schema.uid() : (schema.id ? schema.id() : null);
-                            return [name, schema];
-                        }).filter(([name]) => name);
-                    }
-                }
-
-                schemaEntries.forEach(([name, schema]) => {
-                    // Skip internal AsyncAPI parser objects and numeric keys
-                    if (!name || name === 'collections' || name === '_meta' || name.startsWith('_') || /^\d+$/.test(name)) {
-                        return;
-                    }
-
-                    let schemaData = null;
-                    let description = null;
-
-                    try {
-                        // Handle different schema object types
-                        if (schema && typeof schema.json === 'function') {
-                            schemaData = schema.json();
-                        } else if (schema && typeof schema === 'object') {
-                            schemaData = schema;
-                        }
-
-                        if (schema && typeof schema.description === 'function') {
-                            description = schema.description();
-                        } else if (schema && schema.description) {
-                            description = schema.description;
-                        }
-                    } catch (e) {
-                        // Ignore schema extraction errors
-                        console.warn(`Failed to extract schema for ${name}:`, e.message);
-                    }
-
-                    if (schemaData && typeof name === 'string' && name.length > 0) {
-                        schemaRegistry.set(name, schemaData);
-                        componentSchemas.push({
-                            name,
-                            rustName: toRustTypeName(name),
-                            schema: schemaData,
-                            description
-                        });
-                    }
-                });
-            }
-        } catch (e) {
-            console.warn('Failed to extract component schemas:', e.message);
-        }
-    }
-
-    // Extract messages from components
-    if (components && components.messages) {
-        const messages = components.messages();
-        if (messages) {
-            Object.entries(messages).forEach(([name, message]) => {
-                let payload = null;
-                let description = null;
-                let title = null;
-                let messageName = name;
-
-                try {
-                    let rawPayload = null;
-                    if (message.payload && typeof message.payload === 'function') {
-                        const payloadSchema = message.payload();
-                        payload = payloadSchema && payloadSchema.json ? payloadSchema.json() : payloadSchema;
-                        // Try to get the raw payload reference from the message
-                        if (message._json && message._json.payload) {
-                            rawPayload = message._json.payload;
-                        }
-                    }
-                    description = message.description && typeof message.description === 'function' ? message.description() : null;
-                    title = message.title && typeof message.title === 'function' ? message.title() : null;
-
-                    // Try to get the actual message name
-                    if (message.name && typeof message.name === 'function') {
-                        messageName = message.name();
-                    } else if (message.name) {
-                        messageName = message.name;
-                    }
-
-                    // If we have raw document access, try to get the payload reference from there
-                    if (!rawPayload && rawDoc && rawDoc.components && rawDoc.components.messages && rawDoc.components.messages[name]) {
-                        rawPayload = rawDoc.components.messages[name].payload;
-                    }
-
-                    const channels = messageToChannels.get(messageName) || messageToChannels.get(name) || [];
-                    messageSchemas.push({
-                        name: messageName,
-                        rustName: toRustTypeName(messageName),
-                        payload,
-                        rawPayload,
-                        description: description || title,
-                        channels
-                    });
-                } catch (e) {
-                    // Ignore payload extraction errors
-                    const channels = messageToChannels.get(messageName) || messageToChannels.get(name) || [];
-                    messageSchemas.push({
-                        name: messageName,
-                        rustName: toRustTypeName(messageName),
-                        payload,
-                        rawPayload: null,
-                        description: description || title,
-                        channels
-                    });
-                }
-            });
-        }
-    }
-
-    // Helper function to convert JSON schema to Rust type
-    function jsonSchemaToRustType(schema, typeName = null) {
-        if (!schema) return 'serde_json::Value';
-
-        // Handle $ref
-        if (schema.$ref) {
-            const refName = schema.$ref.split('/').pop();
-            const rustTypeName = toRustTypeName(refName);
-
-            // Generate the referenced schema if we have access to components
-            if (components && components.schemas) {
-                const schemas = components.schemas();
-                if (schemas && schemas[refName] && !generatedTypes.has(rustTypeName)) {
-                    generatedTypes.add(rustTypeName);
-                    const referencedSchema = schemas[refName];
-                    const schemaJson = referencedSchema.json ? referencedSchema.json() : referencedSchema;
-                    nestedSchemas.set(rustTypeName, {
-                        type: 'struct',
-                        schema: schemaJson,
-                        description: referencedSchema.description && typeof referencedSchema.description === 'function' ? referencedSchema.description() : null
-                    });
-                }
-            }
-
-            return rustTypeName;
-        }
-
-        // Handle resolved $ref - check for x-parser-schema-id which indicates original schema name
-        if (schema['x-parser-schema-id'] && typeof schema['x-parser-schema-id'] === 'string') {
-            const schemaId = schema['x-parser-schema-id'];
-            // Check if this matches a known component schema
-            if (schemaRegistry.has(schemaId)) {
-                const rustTypeName = toRustTypeName(schemaId);
-                return rustTypeName;
-            }
-        }
-
-        if (!schema.type) {
-            // If no type specified, check for properties (object) or items (array)
-            if (schema.properties) {
-                schema.type = 'object';
-            } else if (schema.items) {
-                schema.type = 'array';
-            } else {
-                return 'serde_json::Value';
-            }
-        }
-
-        switch (schema.type) {
-            case 'string':
-                if (schema.enum && schema.enum.length > 0) {
-                    // Generate enum type
-                    if (typeName) {
-                        const enumName = `${typeName}Enum`;
-                        if (!generatedTypes.has(enumName)) {
-                            generatedTypes.add(enumName);
-                            nestedSchemas.set(enumName, {
-                                type: 'enum',
-                                variants: schema.enum,
-                                description: schema.description
-                            });
-                        }
-                        return enumName;
-                    }
-                    return 'String'; // Fallback if no type name provided
-                }
-                if (schema.format === 'date-time') return 'chrono::DateTime<chrono::Utc>';
-                if (schema.format === 'uuid') return 'uuid::Uuid';
-                if (schema.format === 'email') return 'String';
-                if (schema.format === 'uri') return 'String';
-                return 'String';
-            case 'integer':
-                switch (schema.format) {
-                    case 'int32':
-                        return 'i32';
-                    case 'int64':
-                        return 'i64';
-                    case 'uint32':
-                        return 'u32';
-                    case 'uint64':
-                        return 'u64';
-                    default:
-                        // Default to i32 for unspecified format (maintains backward compatibility)
-                        return 'i32';
-                }
-            case 'number':
-                return 'f64';
-            case 'boolean':
-                return 'bool';
-            case 'array': {
-                const itemType = jsonSchemaToRustType(schema.items);
-                return `Vec<${itemType}>`;
-            }
-            case 'object':
-                if (schema.properties && Object.keys(schema.properties).length > 0) {
-                    // Generate nested struct
-                    if (typeName) {
-                        const structName = toRustTypeName(typeName);
-                        if (!generatedTypes.has(structName)) {
-                            generatedTypes.add(structName);
-                            nestedSchemas.set(structName, {
-                                type: 'struct',
-                                schema: schema,
-                                description: schema.description
-                            });
-                        }
-                        return structName;
-                    }
-                }
-                return 'serde_json::Value';
-            default:
-                return 'serde_json::Value';
-        }
-    }
-
-    // Generate message structs
-    function generateMessageStruct(schema, messageName) {
-        if (!schema || !schema.properties) {
-            return '    pub data: serde_json::Value,';
-        }
-
-        const fields = Object.entries(schema.properties).map(([fieldName, fieldSchema]) => {
-            const rustFieldName = toRustFieldName(fieldName);
-            const fieldTypeName = `${messageName}${toRustTypeName(fieldName)}`;
-            const rustType = jsonSchemaToRustType(fieldSchema, fieldTypeName);
-            const requiredFields = schema.required;
-            const optional = !requiredFields || !Array.isArray(requiredFields) || requiredFields.indexOf(fieldName) === -1;
-            const finalType = optional ? `Option<${rustType}>` : rustType;
-
-            let fieldDoc = '';
-            if (fieldSchema.description) {
-                fieldDoc = `    /// ${fieldSchema.description}\n`;
-            }
-
-            let serdeRename = '';
-            if (rustFieldName !== fieldName) {
-                serdeRename = `    #[serde(rename = "${fieldName}")]\n`;
-            }
-
-            let skipSerializing = '';
-            if (optional) {
-                skipSerializing = '    #[serde(skip_serializing_if = "Option::is_none")]\n';
-            }
-
-            return `${fieldDoc}${serdeRename}${skipSerializing}    pub ${rustFieldName}: ${finalType},`;
-        }).join('\n');
-
-        return fields;
-    }
-
-    // Process all component schemas first to ensure they are available for references
-    componentSchemas.forEach(schema => {
-        jsonSchemaToRustType(schema.schema, schema.rustName);
-        generatedTypes.add(schema.rustName);
-    });
-
-    // Process all message schemas to ensure all referenced types are generated
-    messageSchemas.forEach(schema => {
-        if (schema.payload) {
-            jsonSchemaToRustType(schema.payload, schema.rustName);
-        }
+    // Generate models using the common helper
+    const models = generateRustModels(asyncapi, {
+        toRustTypeName,
+        toRustFieldName,
+        toRustEnumVariantWithSerde,
+        includeAsyncApiTrait: false, // Client doesn't need the AsyncApiMessage trait
+        includeEnvelope: false // We'll generate the envelope separately
     });
 
-    // Generate component schema definitions
-    function generateComponentSchemas() {
-        let result = '';
-
-        componentSchemas.forEach(schema => {
-            const doc = schema.description ? `/// ${schema.description}\n` : `/// ${schema.name}\n`;
-
-            // Check if this is a standalone enum schema
-            if (schema.schema.type === 'string' && schema.schema.enum && Array.isArray(schema.schema.enum)) {
-                // Generate enum definition with serde rename attributes for lowercase serialization
-                const variants = schema.schema.enum.map(variant => {
-                    const { rustName, serializedName } = toRustEnumVariantWithSerde(variant);
-                    return `    #[serde(rename = "${serializedName}")]\n    ${rustName}`;
-                }).join(',\n');
-                result += `
-${doc}#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub enum ${schema.rustName} {
-${variants},
-}
-`;
-            } else {
-                // Generate struct definition
-                const fields = generateMessageStruct(schema.schema, schema.rustName);
-                result += `
-${doc}#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ${schema.rustName} {
-${fields}
-}
-`;
-            }
-        });
-
-        return result;
-    }
-
-    // Generate nested type definitions
-    function generateNestedTypes() {
-        let result = '';
-
-        for (const [typeName, typeInfo] of nestedSchemas.entries()) {
-            // Don't skip enums - they need to be generated even if the parent type exists
-            const isEnum = typeInfo.type === 'enum';
-            const isComponentSchema = componentSchemas.some(cs => cs.rustName === typeName);
-
-            // Skip if this type was already generated as a component schema (but not enums)
-            if (!isEnum && isComponentSchema) {
-                continue;
-            }
-
-            if (typeInfo.type === 'enum') {
-                const variants = typeInfo.variants.map(variant => {
-                    const { rustName, serializedName } = toRustEnumVariantWithSerde(variant);
-                    return `    #[serde(rename = "${serializedName}")]\n    ${rustName}`;
-                }).join(',\n');
-                const doc = typeInfo.description ? `/// ${typeInfo.description}\n` : '';
-                result += `
-${doc}#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub enum ${typeName} {
-${variants},
-}
-`;
-            } else if (typeInfo.type === 'struct') {
-                const fields = generateMessageStruct(typeInfo.schema, typeName);
-                const doc = typeInfo.description ? `/// ${typeInfo.description}\n` : '';
-                result += `
-${doc}#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ${typeName} {
-${fields}
-}
-`;
-            }
-        }
-
-        return result;
-    }
+    // Generate the unified message envelope
+    const envelopeCode = generateMessageEnvelope();
 
     return (
         <File name="models.rs">
             {`//! Generated data models from AsyncAPI specification
 
-use serde::{Deserialize, Serialize};
-
-${generateComponentSchemas()}
-${generateNestedTypes()}
+${envelopeCode}
+${models.generateComponentSchemas()}
+${models.generateNestedTypes()}
 ${(() => {
                     // Track which types have already had implementations generated
                     const implementedTypes = new Set();
                     const implementations = [];
 
-                    messageSchemas.forEach(schema => {
+                    models.messageSchemas.forEach(schema => {
                         const doc = schema.description ? `/// ${schema.description}` : `/// ${schema.name} message`;
 
                         // Check if the message payload references a component schema
@@ -568,7 +53,7 @@ ${(() => {
                         } else if (schema.payload && schema.payload['x-parser-schema-id']) {
                             // Handle resolved $ref references
                             const schemaId = schema.payload['x-parser-schema-id'];
-                            if (schemaRegistry.has(schemaId)) {
+                            if (models.schemaRegistry.has(schemaId)) {
                                 payloadRustName = toRustTypeName(schemaId);
                                 isComponentMessage = true;
                             }
@@ -585,14 +70,14 @@ pub struct ${schema.rustName} {
     #[serde(flatten)]
     pub payload: ${payloadRustName},
 }`);
-                        } else if (!generatedTypes.has(schema.rustName) && !implementedTypes.has(schema.rustName)) {
+                        } else if (!models.generatedTypes.has(schema.rustName) && !implementedTypes.has(schema.rustName)) {
                             // Generate both struct for inline message schemas
                             implementedTypes.add(schema.rustName);
                             implementations.push(`
 ${doc}
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ${schema.rustName} {
-${generateMessageStruct(schema.payload, schema.rustName)}
+${models.generateMessageStruct(schema.payload, schema.rustName)}
 }`);
                         }
                     });
@@ -600,7 +85,7 @@ ${generateMessageStruct(schema.payload, schema.rustName)}
                     return implementations.join('');
                 })()}
 
-${messageSchemas.length === 0 && componentSchemas.length === 0 ? `
+${models.messageSchemas.length === 0 && models.componentSchemas.length === 0 ? `
 /// Example message structure when no messages are defined in the spec
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ExampleMessage {

package/template/package.json

@@ -1,48 +0,0 @@
-{
-    "name": "@asyncapi/rust-client-template",
-    "version": "0.0.0",
-    "description": "AsyncAPI template for generating Rust NATS clients",
-    "main": "index.js",
-    "keywords": [
-        "asyncapi",
-        "template",
-        "rust",
-        "nats",
-        "client",
-        "generator"
-    ],
-    "author": "AsyncAPI Generator",
-    "license": "Apache-2.0",
-    "dependencies": {
-        "@asyncapi/generator-react-sdk": "^1.0.0"
-    },
-    "generator": {
-        "renderer": "react",
-        "apiVersion": "v3",
-        "supportedProtocols": [
-            "nats"
-        ],
-        "parameters": {
-            "clientName": {
-                "description": "Name of the generated client struct",
-                "default": "{{asyncapi.info().title() | replace(/[^a-zA-Z0-9]/g, '') }}Client"
-            },
-            "packageName": {
-                "description": "Name of the generated Rust crate",
-                "default": "{{asyncapi.info().title() | kebabCase}}-client"
-            },
-            "packageVersion": {
-                "description": "Version of the generated crate",
-                "default": "{{asyncapi.info().version()}}"
-            },
-            "author": {
-                "description": "Author of the generated crate",
-                "default": "AsyncAPI Generator"
-            },
-            "license": {
-                "description": "License of the generated crate",
-                "default": "Apache-2.0"
-            }
-        }
-    }
-}