@ioka-technologies/asyncapi-rust-client-template 0.0.27 → 0.0.28

package/dist/common/index.js

@@ -2414,6 +2414,119 @@ ${doc}#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub enum ${schema.rustName} {
 ${variants},
 }
+`;
+        } else if (schema.schema.type && !schema.schema.properties) {
+          // Handle primitive types and arrays without properties
+          // Don't use jsonSchemaToRustType here as it might return the type name itself
+          let primitiveType = 'serde_json::Value';
+          switch (schema.schema.type) {
+            case 'string':
+              if (schema.schema.format === 'date-time') primitiveType = 'chrono::DateTime<chrono::Utc>';else if (schema.schema.format === 'uuid') primitiveType = 'uuid::Uuid';else primitiveType = 'String';
+              break;
+            case 'integer':
+              switch (schema.schema.format) {
+                case 'int32':
+                  primitiveType = 'i32';
+                  break;
+                case 'int64':
+                  primitiveType = 'i64';
+                  break;
+                case 'uint32':
+                  primitiveType = 'u32';
+                  break;
+                case 'uint64':
+                  primitiveType = 'u64';
+                  break;
+                default:
+                  primitiveType = 'i32';
+                  break;
+              }
+              break;
+            case 'number':
+              primitiveType = 'f64';
+              break;
+            case 'boolean':
+              primitiveType = 'bool';
+              break;
+            case 'array':
+              if (schema.schema.items) {
+                // Handle array items
+                let itemType = 'serde_json::Value';
+                if (schema.schema.items.type === 'integer') {
+                  switch (schema.schema.items.format) {
+                    case 'int32':
+                      itemType = 'i32';
+                      break;
+                    case 'int64':
+                      itemType = 'i64';
+                      break;
+                    case 'uint32':
+                      itemType = 'u32';
+                      break;
+                    case 'uint64':
+                      itemType = 'u64';
+                      break;
+                    case 'uint8':
+                      itemType = 'u8';
+                      break;
+                    case 'int8':
+                      itemType = 'i8';
+                      break;
+                    case 'uint16':
+                      itemType = 'u16';
+                      break;
+                    case 'int16':
+                      itemType = 'i16';
+                      break;
+                    default:
+                      itemType = 'i32';
+                      break;
+                  }
+                } else if (schema.schema.items.type === 'string') {
+                  if (schema.schema.items.format === 'date-time') itemType = 'chrono::DateTime<chrono::Utc>';else if (schema.schema.items.format === 'uuid') itemType = 'uuid::Uuid';else itemType = 'String';
+                } else if (schema.schema.items.type === 'number') {
+                  itemType = 'f64';
+                } else if (schema.schema.items.type === 'boolean') {
+                  itemType = 'bool';
+                }
+                primitiveType = `Vec<${itemType}>`;
+              } else {
+                primitiveType = 'Vec<serde_json::Value>';
+              }
+              break;
+          }
+
+          // Generate a newtype wrapper for primitive types and arrays
+          result += `
+${doc}#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ${schema.rustName}(pub ${primitiveType});
+
+impl From<${primitiveType}> for ${schema.rustName} {
+    fn from(value: ${primitiveType}) -> Self {
+        Self(value)
+    }
+}
+
+impl From<${schema.rustName}> for ${primitiveType} {
+    fn from(value: ${schema.rustName}) -> Self {
+        value.0
+    }
+}
+
+impl std::fmt::Display for ${schema.rustName} {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        ${(() => {
+            // Generate appropriate Display implementation based on the primitive type
+            if (primitiveType.startsWith('Vec<u8>')) {
+              return `self.0.iter().try_for_each(|byte| write!(f, "{:02x}", byte))`;
+            } else if (primitiveType.startsWith('Vec<')) {
+              return 'write!(f, "{:?}", self.0)';
+            } else {
+              return 'write!(f, "{}", self.0)';
+            }
+          })()}
+    }
+}
 `;
         } else {
           // Generate struct definition

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ioka-technologies/asyncapi-rust-client-template",
-    "version": "0.0.27",
+    "version": "0.0.28",
     "description": "AsyncAPI template for generating Rust NATS clients",
     "main": "template/index.js",
     "keywords": [