@ioka-technologies/asyncapi-rust-client-template 0.0.33 → 0.0.35

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ioka-technologies/asyncapi-rust-client-template",
-    "version": "0.0.33",
+    "version": "0.0.35",
     "description": "AsyncAPI template for generating Rust NATS clients",
     "main": "template/index.js",
     "keywords": [
@@ -26,6 +26,7 @@
     },
     "files": [
         "template/**/*",
+        "!template/**/*.dev",
         "dist/common/**/*",
         "README.md"
     ],

package/template/helpers/index.js.dev

@@ -1,116 +0,0 @@
-/**
- * Template-specific helper functions for Rust client template
- *
- * Most common utilities have been moved to the shared @common package.
- * This file now only contains template-specific functions that are unique
- * to the rust-client template.
- */
-
-// Import common utilities for use in local functions
-import {
-    toRustIdentifier,
-    toRustTypeName,
-    toRustFieldName,
-    toRustEnumVariant,
-    toRustEnumVariantWithSerde,
-    getMessageTypeName,
-    getMessageRustTypeName,
-    getPayloadRustTypeName,
-    getNatsSubject,
-    isDynamicChannel,
-    extractChannelVariables,
-    getChannelParameters,
-    resolveChannelAddress,
-    channelHasParameters,
-    toPascalCase,
-    toKebabCase,
-    toSnakeCase,
-    isTemplateVariable,
-    extractAsyncApiInfo,
-    resolveTemplateParameters
-} from '../../../common/src/index.js';
-
-// Re-export common utilities for backward compatibility
-export {
-    toRustIdentifier,
-    toRustTypeName,
-    toRustFieldName,
-    toRustEnumVariant,
-    toRustEnumVariantWithSerde,
-    getMessageTypeName,
-    getMessageRustTypeName,
-    getPayloadRustTypeName,
-    getNatsSubject,
-    isDynamicChannel,
-    extractChannelVariables,
-    getChannelParameters,
-    resolveChannelAddress,
-    channelHasParameters,
-    toPascalCase,
-    toKebabCase,
-    toSnakeCase,
-    isTemplateVariable,
-    extractAsyncApiInfo,
-    resolveTemplateParameters
-};
-
-/**
- * Analyzes operations to determine client method patterns
- * For NATS clients, we need to distinguish between:
- * - Request/Reply operations (using NATS request/reply)
- * - Publish operations (fire-and-forget)
- * - Subscribe operations (message handlers)
- *
- * This function is specific to the rust-client template's operation analysis needs.
- *
- * @param {Array} operations - Array of AsyncAPI operations
- * @returns {Array} Array of client method patterns
- */
-export function analyzeClientOperations(operations) {
-    const patterns = [];
-
-    for (const operation of operations) {
-        const operationName = operation.id();
-        const action = operation.action();
-        const messages = operation.messages();
-
-        if (action === 'send') {
-            // Client sends messages - this becomes a client method
-            if (operation.reply && operation.reply()) {
-                // Request/Reply pattern
-                patterns.push({
-                    type: 'request_reply',
-                    operation,
-                    operationName,
-                    methodName: toRustFieldName(operationName),
-                    requestMessage: messages[0],
-                    responseMessage: operation.reply().messages()[0],
-                    requestType: getPayloadRustTypeName(messages[0]),
-                    responseType: getPayloadRustTypeName(operation.reply().messages()[0])
-                });
-            } else {
-                // Publish pattern (fire-and-forget)
-                patterns.push({
-                    type: 'publish',
-                    operation,
-                    operationName,
-                    methodName: toRustFieldName(operationName),
-                    message: messages[0],
-                    payloadType: getPayloadRustTypeName(messages[0])
-                });
-            }
-        } else if (action === 'receive') {
-            // Client receives messages - this becomes a subscription method
-            patterns.push({
-                type: 'subscribe',
-                operation,
-                operationName,
-                methodName: toRustFieldName(operationName.replace(/^receive/, 'subscribe_to_')),
-                message: messages[0],
-                payloadType: getPayloadRustTypeName(messages[0])
-            });
-        }
-    }
-
-    return patterns;
-}

package/template/src/envelope.rs.js.dev

@@ -1,31 +0,0 @@
-/* eslint-disable no-unused-vars */
-import { File } from '@asyncapi/generator-react-sdk';
-import { generateMessageEnvelope } from '../../../common/src/index.js';
-
-export default function ({ asyncapi, params }) {
-    // Generate the unified message envelope with error support
-    const envelopeCode = generateMessageEnvelope();
-
-    return (
-        <File name="envelope.rs">
-            {`//! Message envelope for consistent NATS message format
-
-use crate::auth::{AuthCredentials, generate_auth_headers};
-${envelopeCode}
-
-// Client-specific extensions for auth integration
-impl MessageEnvelope {
-    /// Create a new message envelope with authentication headers
-    pub fn new_with_auth<T: Serialize>(
-        operation: &str,
-        payload: T,
-        auth: &AuthCredentials,
-    ) -> Result<Self, serde_json::Error> {
-        let auth_headers = generate_auth_headers(auth);
-        Self::new(operation, payload).map(|envelope| envelope.with_auth_headers(auth_headers))
-    }
-}
-`}
-        </File>
-    );
-};

package/template/src/models.rs.js.dev

@@ -1,110 +0,0 @@
-/* eslint-disable no-unused-vars */
-import { File } from '@asyncapi/generator-react-sdk';
-import {
-    toRustIdentifier,
-    toRustTypeName,
-    toRustFieldName,
-    toRustEnumVariant,
-    toRustEnumVariantWithSerde,
-    generateRustModels,
-    generateMessageEnvelope
-} from '../../../common/src/index.js';
-
-export default function ModelsRs({ asyncapi }) {
-    // 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 the unified message envelope
-    const envelopeCode = generateMessageEnvelope();
-
-    return (
-        <File name="models.rs">
-            {`//! Generated data models from AsyncAPI specification
-
-${envelopeCode}
-${models.generateComponentSchemas()}
-${models.generateNestedTypes()}
-${(() => {
-                    // Track which types have already had implementations generated
-                    const implementedTypes = new Set();
-                    const implementations = [];
-
-                    models.messageSchemas.forEach(schema => {
-                        const doc = schema.description ? `/// ${schema.description}` : `/// ${schema.name} message`;
-
-                        // Check if the message payload references a component schema
-                        let payloadRustName = null;
-                        let isComponentMessage = false;
-
-                        if (schema.rawPayload && schema.rawPayload.$ref) {
-                            const refName = schema.rawPayload.$ref.split('/').pop();
-                            payloadRustName = toRustTypeName(refName);
-                            isComponentMessage = true;
-                        } else if (schema.payload && schema.payload.$ref) {
-                            const refName = schema.payload.$ref.split('/').pop();
-                            payloadRustName = toRustTypeName(refName);
-                            isComponentMessage = true;
-                        } else if (schema.payload && schema.payload['x-parser-schema-id']) {
-                            // Handle resolved $ref references
-                            const schemaId = schema.payload['x-parser-schema-id'];
-                            if (models.schemaRegistry.has(schemaId)) {
-                                payloadRustName = toRustTypeName(schemaId);
-                                isComponentMessage = true;
-                            }
-                        }
-
-                        // For component messages, always generate the message wrapper type
-                        // even if the payload schema already exists
-                        if (isComponentMessage && payloadRustName && !implementedTypes.has(schema.rustName)) {
-                            implementedTypes.add(schema.rustName);
-                            implementations.push(`
-${doc}
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ${schema.rustName} {
-    #[serde(flatten)]
-    pub payload: ${payloadRustName},
-}`);
-                        } 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} {
-${models.generateMessageStruct(schema.payload, schema.rustName)}
-}`);
-                        }
-                    });
-
-                    return implementations.join('');
-                })()}
-
-${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 {
-    pub id: String,
-    pub content: String,
-    pub timestamp: chrono::DateTime<chrono::Utc>,
-}
-
-impl ExampleMessage {
-    /// Create a new instance with required fields
-    pub fn new(id: String, content: String, timestamp: chrono::DateTime<chrono::Utc>) -> Self {
-        Self {
-            id,
-            content,
-            timestamp,
-        }
-    }
-}` : ''}
-`}
-        </File>
-    );
-}