@ioka-technologies/asyncapi-rust-client-template 0.0.20

package/template/src/envelope.rs.js

@@ -0,0 +1,199 @@
+/* eslint-disable no-unused-vars */
+import { File } from '@asyncapi/generator-react-sdk';
+
+module.exports = function ({ asyncapi, params }) {
+    return (
+        <File name="envelope.rs">
+            {`//! Message envelope for consistent NATS message format
+
+use crate::auth::{AuthCredentials, generate_auth_headers};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use uuid::Uuid;
+
+/// MessageEnvelope for consistent message format across NATS operations
+/// This matches the format expected by the server implementation
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MessageEnvelope {
+    /// Unique message identifier
+    pub id: String,
+    /// Operation name from AsyncAPI spec
+    pub operation: String,
+    /// Message payload as JSON value
+    pub payload: serde_json::Value,
+    /// ISO 8601 timestamp when message was created
+    pub timestamp: String,
+    /// Optional correlation ID for request/reply patterns
+    pub correlation_id: Option<String>,
+    /// Optional headers for additional metadata
+    pub headers: Option<HashMap<String, String>>,
+}
+
+impl MessageEnvelope {
+    /// Create a new message envelope with generated ID and current timestamp
+    pub fn new<T: Serialize>(operation: &str, payload: T) -> Result<Self, serde_json::Error> {
+        Ok(Self {
+            id: Uuid::new_v4().to_string(),
+            operation: operation.to_string(),
+            payload: serde_json::to_value(payload)?,
+            timestamp: chrono::Utc::now().to_rfc3339(),
+            correlation_id: None,
+            headers: None,
+        })
+    }
+
+    /// Create a new message envelope with a specific correlation ID
+    pub fn new_with_correlation_id<T: Serialize>(
+        operation: &str,
+        payload: T,
+        correlation_id: String,
+    ) -> Result<Self, serde_json::Error> {
+        Ok(Self {
+            id: Uuid::new_v4().to_string(),
+            operation: operation.to_string(),
+            payload: serde_json::to_value(payload)?,
+            timestamp: chrono::Utc::now().to_rfc3339(),
+            correlation_id: Some(correlation_id),
+            headers: None,
+        })
+    }
+
+    /// Add headers to the envelope
+    pub fn with_headers(mut self, headers: HashMap<String, String>) -> Self {
+        self.headers = Some(headers);
+        self
+    }
+
+    /// Add a single header to the envelope
+    pub fn with_header(mut self, key: String, value: String) -> Self {
+        if let Some(ref mut headers) = self.headers {
+            headers.insert(key, value);
+        } else {
+            let mut headers = HashMap::new();
+            headers.insert(key, value);
+            self.headers = Some(headers);
+        }
+        self
+    }
+
+    /// Add authentication headers to the envelope
+    pub fn with_auth_headers(mut self, auth: &AuthCredentials) -> Self {
+        let auth_headers = generate_auth_headers(auth);
+        if !auth_headers.is_empty() {
+            if let Some(ref mut headers) = self.headers {
+                headers.extend(auth_headers);
+            } else {
+                self.headers = Some(auth_headers);
+            }
+        }
+        self
+    }
+
+    /// 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 envelope = Self::new(operation, payload)?;
+        Ok(envelope.with_auth_headers(auth))
+    }
+
+    /// Create a new message envelope with correlation ID and authentication headers
+    pub fn new_with_correlation_id_and_auth<T: Serialize>(
+        operation: &str,
+        payload: T,
+        correlation_id: String,
+        auth: &AuthCredentials,
+    ) -> Result<Self, serde_json::Error> {
+        let envelope = Self::new_with_correlation_id(operation, payload, correlation_id)?;
+        Ok(envelope.with_auth_headers(auth))
+    }
+
+    /// Convert the envelope to bytes for NATS transmission
+    pub fn to_bytes(&self) -> Result<Vec<u8>, serde_json::Error> {
+        serde_json::to_vec(self)
+    }
+
+    /// Parse envelope from bytes received from NATS
+    pub fn from_bytes(bytes: &[u8]) -> Result<Self, serde_json::Error> {
+        serde_json::from_slice(bytes)
+    }
+
+    /// Extract the payload as a specific type
+    pub fn extract_payload<T: for<'de> Deserialize<'de>>(&self) -> Result<T, serde_json::Error> {
+        serde_json::from_value(self.payload.clone())
+    }
+
+    /// Get the correlation ID if present
+    pub fn correlation_id(&self) -> Option<&str> {
+        self.correlation_id.as_deref()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde::{Deserialize, Serialize};
+
+    #[derive(Debug, Serialize, Deserialize, PartialEq)]
+    struct TestPayload {
+        message: String,
+        count: u32,
+    }
+
+    #[test]
+    fn test_envelope_creation() {
+        let payload = TestPayload {
+            message: "test".to_string(),
+            count: 42,
+        };
+
+        let envelope = MessageEnvelope::new("test_operation", &payload).unwrap();
+
+        assert_eq!(envelope.operation, "test_operation");
+        assert!(!envelope.id.is_empty());
+        assert!(!envelope.timestamp.is_empty());
+        assert_eq!(envelope.correlation_id, None);
+
+        let extracted: TestPayload = envelope.extract_payload().unwrap();
+        assert_eq!(extracted, payload);
+    }
+
+    #[test]
+    fn test_envelope_with_correlation_id() {
+        let payload = TestPayload {
+            message: "test".to_string(),
+            count: 42,
+        };
+
+        let correlation_id = "test-correlation-id".to_string();
+        let envelope = MessageEnvelope::new_with_correlation_id(
+            "test_operation",
+            &payload,
+            correlation_id.clone(),
+        ).unwrap();
+
+        assert_eq!(envelope.correlation_id(), Some(correlation_id.as_str()));
+    }
+
+    #[test]
+    fn test_envelope_serialization() {
+        let payload = TestPayload {
+            message: "test".to_string(),
+            count: 42,
+        };
+
+        let envelope = MessageEnvelope::new("test_operation", &payload).unwrap();
+        let bytes = envelope.to_bytes().unwrap();
+        let deserialized = MessageEnvelope::from_bytes(&bytes).unwrap();
+
+        assert_eq!(envelope.id, deserialized.id);
+        assert_eq!(envelope.operation, deserialized.operation);
+        assert_eq!(envelope.timestamp, deserialized.timestamp);
+    }
+}
+`}
+        </File>
+    );
+};

package/template/src/errors.rs.js

@@ -0,0 +1,49 @@
+/* eslint-disable no-unused-vars */
+import { File } from '@asyncapi/generator-react-sdk';
+
+module.exports = function ({ asyncapi, params }) {
+    return (
+        <File name="errors.rs">
+            {`//! Error types for the NATS client
+
+use crate::auth::AuthError;
+use thiserror::Error;
+
+/// Errors that can occur when using the NATS client
+#[derive(Debug, Error)]
+pub enum ClientError {
+    /// NATS operation failed
+    #[error("NATS operation failed: {0}")]
+    Nats(Box<dyn std::error::Error + Send + Sync>),
+
+    /// Serialization or deserialization failed
+    #[error("Serialization failed: {0}")]
+    Serialization(#[from] serde_json::Error),
+
+    /// Invalid message envelope format
+    #[error("Invalid message envelope: {0}")]
+    InvalidEnvelope(String),
+
+    /// Operation timeout
+    #[error("Operation timed out")]
+    Timeout,
+
+    /// No response received for request
+    #[error("No response received")]
+    NoResponse,
+
+    /// Authentication error
+    #[error("Authentication error: {0}")]
+    Auth(#[from] AuthError),
+
+    /// Unauthorized access
+    #[error("Unauthorized: {0}")]
+    Unauthorized(String),
+}
+
+/// Result type alias for client operations
+pub type ClientResult<T> = Result<T, ClientError>;
+`}
+        </File>
+    );
+};

package/template/src/lib.rs.js

@@ -0,0 +1,112 @@
+/* eslint-disable no-unused-vars */
+import { File } from '@asyncapi/generator-react-sdk';
+
+module.exports = function ({ asyncapi, params }) {
+    // Helper function to convert title to PascalCase
+    function toPascalCase(str) {
+        return str.replace(/[^a-zA-Z0-9]/g, ' ')
+            .split(' ')
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join('');
+    }
+
+    const title = asyncapi.info().title();
+    const description = asyncapi.info().description();
+    const version = asyncapi.info().version();
+
+    const clientName = (params.clientName && !params.clientName.includes('{{'))
+        ? params.clientName
+        : `${toPascalCase(title)}Client`;
+
+    // Helper function to format description for Rust doc comments
+    function formatDescription(desc) {
+        if (!desc) return 'Generated Rust AsyncAPI NATS client';
+        return desc.split('\n').map(line => line.trim()).filter(line => line).join('\n//! ');
+    }
+
+    return (
+        <File name="lib.rs">
+            {`//! ${title}
+//!
+//! ${formatDescription(description)}
+//!
+//! This crate provides a type-safe NATS client generated from an AsyncAPI specification.
+//! It supports both request/reply and pub/sub messaging patterns using the NATS protocol.
+//!
+//! # Features
+//!
+//! - **Type Safety**: All message types are generated from AsyncAPI schemas
+//! - **NATS Integration**: Uses the official async-nats client library
+//! - **Request/Reply**: Supports NATS request/reply patterns for synchronous operations
+//! - **Pub/Sub**: Supports NATS publish/subscribe patterns for asynchronous messaging
+//! - **Message Envelope**: Consistent message format with metadata and correlation IDs
+//! - **Error Handling**: Comprehensive error types for different failure scenarios
+//!
+//! # Quick Start
+//!
+//! \`\`\`ignore
+//! use async_nats;
+//! use ${params.packageName?.replace(/-/g, '_') || 'your_crate'}::${clientName};
+//!
+//! #[tokio::main]
+//! async fn main() -> Result<(), Box<dyn std::error::Error>> {
+//!     // Connect to NATS server
+//!     let nats_client = async_nats::connect("nats://localhost:4222").await?;
+//!
+//!     // Create the generated client
+//!     let client = ${clientName}::with(nats_client);
+//!
+//!     // Use the client for operations...
+//!
+//!     Ok(())
+//! }
+//! \`\`\`
+//!
+//! # Authentication
+//!
+//! The client accepts any configured \`async-nats::Client\`, allowing you to handle
+//! authentication at the NATS level:
+//!
+//! \`\`\`ignore
+//! // JWT authentication
+//! let nats_client = async_nats::ConnectOptions::new()
+//!     .credentials_file("./service.creds").await?
+//!     .connect("nats://server:4222").await?;
+//!
+//! let client = ${clientName}::with(nats_client);
+//! \`\`\`
+//!
+//! # Generated from AsyncAPI
+//!
+//! - **AsyncAPI Version**: ${asyncapi.version()}
+//! - **Generated**: ${new Date().toISOString()}
+//! - **Title**: ${title}
+//! - **Version**: ${version}
+
+pub mod auth;
+pub mod client;
+pub mod envelope;
+pub mod errors;
+pub mod models;
+
+// Re-export main types for convenience
+pub use auth::{AuthCredentials, generate_auth_headers};
+pub use client::${clientName};
+pub use envelope::MessageEnvelope;
+pub use errors::{ClientError, ClientResult};
+
+// Re-export all models
+pub use models::*;
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_client_creation() {
+        // This test requires a NATS client, so we'll just test compilation
+        // In real usage, you would create an async-nats::Client first
+    }
+}
+`}
+        </File>
+    );
+};