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

package/template/index.js

@@ -0,0 +1,244 @@
+const { File } = require('@asyncapi/generator-react-sdk');
+const React = require('react');
+
+module.exports = function ({ asyncapi, params }) {
+    // Extract info from AsyncAPI spec
+    let title, version, description;
+    try {
+        const info = asyncapi.info();
+        title = info.title();
+        version = info.version();
+        description = info.description();
+    } catch (error) {
+        title = 'UnknownAPI';
+        version = '1.0.0';
+        description = 'Generated NATS client';
+    }
+
+    // Helper function to check if a parameter contains unresolved template variables
+    function isTemplateVariable(value) {
+        return typeof value === 'string' && value.includes('{{') && value.includes('}}');
+    }
+
+    // Helper function to convert title to kebab-case
+    function toKebabCase(str) {
+        return str.toLowerCase().replace(/[^a-z0-9]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
+    }
+
+    // Helper function to convert title to PascalCase for struct names
+    function toPascalCase(str) {
+        return str.replace(/[^a-zA-Z0-9]/g, ' ')
+            .split(' ')
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join('');
+    }
+
+    // Helper function to convert to snake_case for Rust identifiers
+    function toSnakeCase(str) {
+        return str.toLowerCase().replace(/[^a-z0-9]/g, '_').replace(/_+/g, '_').replace(/^_|_$/g, '');
+    }
+
+    // Resolve parameters, falling back to extracted values if parameters contain template variables
+    const clientName = (params.clientName && !isTemplateVariable(params.clientName))
+        ? params.clientName
+        : `${toPascalCase(title)}Client`;
+
+    const packageName = (params.packageName && !isTemplateVariable(params.packageName))
+        ? params.packageName
+        : `${toKebabCase(title)}-client`;
+
+    const packageVersion = (params.packageVersion && !isTemplateVariable(params.packageVersion))
+        ? params.packageVersion
+        : version;
+
+    const license = (params.license && !isTemplateVariable(params.license))
+        ? params.license
+        : 'Apache-2.0';
+
+    // Import the source file generators
+    const LibRs = require('./src/lib.rs.js');
+    const ClientRs = require('./src/client.rs.js');
+    const ErrorsRs = require('./src/errors.rs.js');
+    const EnvelopeRs = require('./src/envelope.rs.js');
+    const ModelsRs = require('./src/models.rs.js');
+    const AuthRs = require('./src/auth.rs.js');
+    const CargoToml = require('./Cargo.toml.js');
+
+    // Generate all files from the main index.js
+    return [
+        // Use the separate Cargo.toml template
+        React.createElement(CargoToml, { asyncapi, params }),
+
+        // Generate Rust source files
+        React.createElement(LibRs, { asyncapi, params }),
+        React.createElement(ClientRs, { asyncapi, params }),
+        React.createElement(ErrorsRs, { asyncapi, params }),
+        React.createElement(EnvelopeRs, { asyncapi, params }),
+        React.createElement(ModelsRs, { asyncapi, params }),
+        React.createElement(AuthRs, { asyncapi, params }),
+
+        React.createElement(File, { name: 'README.md' },
+            `# ${title}
+
+${description || 'Generated Rust AsyncAPI NATS client'}
+
+## Overview
+
+This Rust client provides type-safe access to your AsyncAPI service using NATS messaging. Generated from your AsyncAPI specification, it offers seamless integration with NATS request/reply and pub/sub patterns.
+
+## Technical Requirements
+
+- Rust 1.70+
+- NATS server
+
+## Installation
+
+Add this to your \`Cargo.toml\`:
+
+\`\`\`toml
+[dependencies]
+${packageName} = "${packageVersion}"
+async-nats = "0.33"
+tokio = { version = "1.0", features = ["full"] }
+\`\`\`
+
+## Quick Start
+
+### Basic Usage
+
+\`\`\`rust
+use async_nats;
+use ${toSnakeCase(packageName)}::${clientName};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Set up your NATS client with desired configuration
+    let nats_client = async_nats::connect("nats://localhost:4222").await?;
+
+    // Create the service client
+    let client = ${clientName}::with(nats_client);
+
+    // Use the generated methods
+    // (see generated documentation for specific operations)
+
+    Ok(())
+}
+\`\`\`
+
+### With Authentication Headers
+
+\`\`\`rust
+use async_nats;
+use ${toSnakeCase(packageName)}::{${clientName}, AuthCredentials};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let nats_client = async_nats::connect("nats://localhost:4222").await?;
+
+    // Create client with JWT authentication
+    let auth = AuthCredentials::jwt("your-jwt-token");
+    let client = ${clientName}::with_auth(nats_client, auth)?;
+
+    // Or with Basic authentication
+    // let auth = AuthCredentials::basic("username", "password");
+    // let client = ${clientName}::with_auth(nats_client, auth)?;
+
+    // Or with API Key authentication
+    // let auth = AuthCredentials::apikey_header("X-API-Key", "your-api-key");
+    // let client = ${clientName}::with_auth(nats_client, auth)?;
+
+    // All operations will now include authentication headers
+    // let result = client.some_operation(payload).await?;
+
+    Ok(())
+}
+\`\`\`
+
+### With NATS-level Authentication
+
+\`\`\`rust
+use async_nats;
+use ${toSnakeCase(packageName)}::${clientName};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Set up NATS client with JWT credentials
+    let nats_client = async_nats::ConnectOptions::new()
+        .credentials_file("./service.creds").await?
+        .name("${toKebabCase(title)}-client")
+        .connect("nats://server:4222").await?;
+
+    let client = ${clientName}::with(nats_client);
+
+    // Use the client...
+
+    Ok(())
+}
+\`\`\`
+
+### Shared Client Usage
+
+\`\`\`rust
+use async_nats;
+use ${toSnakeCase(packageName)}::${clientName};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Single NATS client can be shared across multiple service clients
+    let nats_client = async_nats::connect("nats://localhost:4222").await?;
+
+    let client = ${clientName}::with(nats_client.clone());
+    // You can create other service clients with the same nats_client
+
+    Ok(())
+}
+\`\`\`
+
+## Configuration
+
+The client accepts any \`async-nats::Client\`, giving you full control over:
+
+- **Authentication**: JWT, NKey, username/password, token
+- **TLS**: Custom certificates and encryption
+- **Connection**: Timeouts, retry logic, clustering
+- **Monitoring**: Connection events and health checks
+
+See the [async-nats documentation](https://docs.rs/async-nats/) for complete configuration options.
+
+## Error Handling
+
+The client provides specific error types for different scenarios:
+
+\`\`\`rust
+use ${toSnakeCase(packageName)}::{${clientName}, ClientError};
+
+match client.some_operation(payload).await {
+    Ok(result) => println!("Success: {:?}", result),
+    Err(ClientError::Nats(e)) => eprintln!("NATS error: {}", e),
+    Err(ClientError::Serialization(e)) => eprintln!("Serialization error: {}", e),
+    Err(ClientError::InvalidEnvelope(e)) => eprintln!("Invalid message: {}", e),
+}
+\`\`\`
+
+## Generated from AsyncAPI
+
+- **AsyncAPI Version**: ${asyncapi.version()}
+- **Generated**: ${new Date().toISOString()}
+- **Title**: ${title}
+- **Version**: ${packageVersion}
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes and add tests
+4. Run the test suite: \`cargo test\`
+5. Submit a pull request
+
+## License
+
+${license}
+`
+        )
+    ];
+};

package/template/package.json

@@ -0,0 +1,48 @@
+{
+    "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"
+            }
+        }
+    }
+}

package/template/src/auth.rs.js

@@ -0,0 +1,221 @@
+/* eslint-disable no-unused-vars */
+import { File } from '@asyncapi/generator-react-sdk';
+
+module.exports = function ({ asyncapi, params }) {
+    return (
+        <File name="auth.rs">
+            {`//! Authentication support for the NATS client
+
+use base64::Engine;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use thiserror::Error;
+
+/// Authentication credentials for different auth types
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AuthCredentials {
+    /// JWT Bearer token
+    pub jwt: Option<String>,
+    /// Basic authentication credentials
+    pub basic: Option<BasicAuth>,
+    /// API Key authentication
+    pub apikey: Option<ApiKeyAuth>,
+}
+
+/// Basic authentication credentials
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BasicAuth {
+    pub username: String,
+    pub password: String,
+}
+
+/// API Key authentication configuration
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ApiKeyAuth {
+    pub key: String,
+    pub name: String,
+}
+
+/// Auth-related error types
+#[derive(Debug, Error)]
+pub enum AuthError {
+    #[error("JWT token must be a non-empty string")]
+    InvalidJwt,
+
+    #[error("Basic auth requires both username and password")]
+    InvalidBasicAuth,
+
+    #[error("API key auth requires both key and name")]
+    InvalidApiKey,
+
+    #[error("Token has expired")]
+    TokenExpired,
+
+    #[error("Unauthorized access")]
+    Unauthorized,
+
+    #[error("Authentication failed: {0}")]
+    AuthenticationFailed(String),
+}
+
+impl AuthCredentials {
+    /// Create new JWT credentials
+    pub fn jwt(token: impl Into<String>) -> Self {
+        Self {
+            jwt: Some(token.into()),
+            basic: None,
+            apikey: None,
+        }
+    }
+
+    /// Create new Basic auth credentials
+    pub fn basic(username: impl Into<String>, password: impl Into<String>) -> Self {
+        Self {
+            jwt: None,
+            basic: Some(BasicAuth {
+                username: username.into(),
+                password: password.into(),
+            }),
+            apikey: None,
+        }
+    }
+
+    /// Create new API key credentials for header
+    pub fn apikey_header(name: impl Into<String>, key: impl Into<String>) -> Self {
+        Self {
+            jwt: None,
+            basic: None,
+            apikey: Some(ApiKeyAuth {
+                key: key.into(),
+                name: name.into(),
+            }),
+        }
+    }
+
+    /// Check if any credentials are provided
+    pub fn has_credentials(&self) -> bool {
+        self.jwt.is_some() || self.basic.is_some() || self.apikey.is_some()
+    }
+
+    /// Get the auth type as a string
+    pub fn auth_type(&self) -> Option<&'static str> {
+        if self.jwt.is_some() {
+            Some("jwt")
+        } else if self.basic.is_some() {
+            Some("basic")
+        } else if self.apikey.is_some() {
+            Some("apikey")
+        } else {
+            None
+        }
+    }
+
+    /// Validate the credentials
+    pub fn validate(&self) -> Result<(), AuthError> {
+        if let Some(ref jwt) = self.jwt {
+            if jwt.trim().is_empty() {
+                return Err(AuthError::InvalidJwt);
+            }
+        }
+
+        if let Some(ref basic) = self.basic {
+            if basic.username.is_empty() || basic.password.is_empty() {
+                return Err(AuthError::InvalidBasicAuth);
+            }
+        }
+
+        if let Some(ref apikey) = self.apikey {
+            if apikey.key.is_empty() || apikey.name.is_empty() {
+                return Err(AuthError::InvalidApiKey);
+            }
+        }
+
+        Ok(())
+    }
+}
+
+/// Generate authentication headers based on credentials
+pub fn generate_auth_headers(auth: &AuthCredentials) -> HashMap<String, String> {
+    let mut headers = HashMap::new();
+
+    if let Some(ref jwt) = auth.jwt {
+        headers.insert("Authorization".to_string(), format!("Bearer {}", jwt));
+    } else if let Some(ref basic) = auth.basic {
+        let credentials = base64::engine::general_purpose::STANDARD.encode(format!("{}:{}", basic.username, basic.password));
+        headers.insert("Authorization".to_string(), format!("Basic {}", credentials));
+    } else if let Some(ref apikey) = auth.apikey {
+        headers.insert(apikey.name.clone(), apikey.key.clone());
+    }
+
+    headers
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_jwt_credentials() {
+        let auth = AuthCredentials::jwt("test-token");
+        assert!(auth.has_credentials());
+        assert_eq!(auth.auth_type(), Some("jwt"));
+        assert!(auth.validate().is_ok());
+
+        let headers = generate_auth_headers(&auth);
+        assert_eq!(headers.get("Authorization"), Some(&"Bearer test-token".to_string()));
+    }
+
+    #[test]
+    fn test_basic_credentials() {
+        let auth = AuthCredentials::basic("user", "pass");
+        assert!(auth.has_credentials());
+        assert_eq!(auth.auth_type(), Some("basic"));
+        assert!(auth.validate().is_ok());
+
+        let headers = generate_auth_headers(&auth);
+        let expected = format!("Basic {}", base64::engine::general_purpose::STANDARD.encode("user:pass"));
+        assert_eq!(headers.get("Authorization"), Some(&expected));
+    }
+
+    #[test]
+    fn test_apikey_header_credentials() {
+        let auth = AuthCredentials::apikey_header("X-API-Key", "secret");
+        assert!(auth.has_credentials());
+        assert_eq!(auth.auth_type(), Some("apikey"));
+        assert!(auth.validate().is_ok());
+
+        let headers = generate_auth_headers(&auth);
+        assert_eq!(headers.get("X-API-Key"), Some(&"secret".to_string()));
+    }
+
+    #[test]
+    fn test_empty_credentials() {
+        let auth = AuthCredentials {
+            jwt: None,
+            basic: None,
+            apikey: None,
+        };
+        assert!(!auth.has_credentials());
+        assert_eq!(auth.auth_type(), None);
+        assert!(auth.validate().is_ok());
+    }
+
+    #[test]
+    fn test_invalid_jwt() {
+        let auth = AuthCredentials::jwt("");
+        assert!(auth.validate().is_err());
+    }
+
+    #[test]
+    fn test_invalid_basic() {
+        let auth = AuthCredentials::basic("", "pass");
+        assert!(auth.validate().is_err());
+
+        let auth = AuthCredentials::basic("user", "");
+        assert!(auth.validate().is_err());
+    }
+}
+`}
+        </File>
+    );
+};