Support for array types, format (#41)

* rebase

* remove pubsub file

Author: stano45

example/specs/rpc-client.yml

@@ -1,4 +1,4 @@
-asyncapi: '2.6.0'
+asyncapi: '2.1.0'
 id: 'urn:example:rpcclient'
 defaultContentType: application/json
 

example/specs/rpc-server.yml

@@ -1,4 +1,4 @@
-asyncapi: '2.6.0'
+asyncapi: '2.1.0'
 id: 'urn:example:rpcserver'
 defaultContentType: application/json
 

src/main.rs

@@ -34,12 +34,12 @@ fn main() {
 
     // render template and write
     template_render_write(
-        &template_path.join("main.rs"),
+        &template_path.join("main.rstmpl"),
         &async_config,
         &output_path.join("src/main.rs"),
     );
     template_render_write(
-        &template_path.join("handler.rs"),
+        &template_path.join("handler.rstmpl"),
         &async_config,
         &output_path.join("src/handler.rs"),
     );

src/parser/common.rs

@@ -1,7 +1,5 @@
 use std::{collections::HashSet, fs, path::Path};
 
-use inflector::Inflector;
-use proc_macro2::Ident;
 use regex::Regex;
 
 use crate::asyncapi_model::AsyncAPI;
@@ -54,24 +52,27 @@ fn parse_string_to_serde_json_value(file_path: &Path) -> serde_json::Value {
     parsed_value
 }
 
-fn capitalize_first_char(s: &str) -> String {
-    let mut c = s.chars();
-    match c.next() {
-        None => String::new(),
-        Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
+pub fn validate_identifier_string(s: &str, camel_case: bool) -> String {
+    let re = Regex::new(r"[^\w\s]").unwrap();
+    let mut sanitized = re.replace_all(s, "").to_string();
+
+    // split into words and process each word
+    let words: Vec<&str> = sanitized.split_whitespace().collect();
+
+    if camel_case {
+        sanitized = words
+            .into_iter()
+            .map(|word| {
+                let mut chars = word.chars();
+                match chars.next() {
+                    None => String::new(),
+                    Some(f) => f.to_uppercase().chain(chars).collect(),
+                }
+            })
+            .collect();
+    } else {
+        sanitized = words.join("_").to_lowercase();
     }
-}
 
-pub fn validate_identifier_string(s: &str) -> String {
-    // Remove special chars, capitalize words, remove spaces
-    let re = Regex::new(r"[^\w\s]").unwrap();
-    let sanitized_identifier = re.replace_all(s, " ").to_title_case().replace(' ', "");
-    let capitalized_sanitized_identifier = capitalize_first_char(sanitized_identifier.as_str());
-    // Create a new identifier
-    // This acts as validation for the message name, panics when the name is invalid
-    Ident::new(
-        &capitalized_sanitized_identifier,
-        proc_macro2::Span::call_site(),
-    );
-    capitalized_sanitized_identifier
+    sanitized
 }

src/parser/preprocessor.rs

@@ -22,7 +22,7 @@ pub fn sanitize_operation_ids_and_check_duplicate(
             for (key, value) in map {
                 if key == "operationId" {
                     if let serde_json::Value::String(string_val) = &value {
-                        let sanitized_val = validate_identifier_string(string_val.as_str());
+                        let sanitized_val = validate_identifier_string(string_val.as_str(), false);
                         if seen_operation_ids.contains(&sanitized_val) {
                             panic!("Duplicate operationId found: {}", sanitized_val);
                         } else {

src/parser/schema_parser.rs

@@ -1,9 +1,9 @@
 use crate::asyncapi_model::{
-    schema::{ObjectType, SchemaKind, Type},
-    ReferenceOr, Schema,
+    schema::{ArrayType, IntegerFormat, NumberFormat, ObjectType, SchemaKind, StringFormat, Type},
+    ReferenceOr, Schema, VariantOrUnknownOrEmpty,
 };
 use core::fmt;
-use std::{collections::HashMap, format};
+use std::{collections::HashMap, format, panic};
 
 use super::common::validate_identifier_string;
 
@@ -38,7 +38,7 @@ fn object_schema_to_string(
 ) -> Result<String, SchemaParserError> {
     let before_string: String = format!(
         "#[derive(Clone, Debug, Deserialize, Serialize)]\npub struct {} {{\n",
-        validate_identifier_string(property_name)
+        validate_identifier_string(property_name, true)
     );
     let after_string = String::from("\n}\n");
     let property_string_iterator: Vec<Result<String, SchemaParserError>> = schema
@@ -68,18 +68,122 @@ fn object_schema_to_string(
     Ok(property_name.to_string())
 }
 
+fn format_to_rust_type(schema_type: &Type) -> String {
+    match schema_type {
+        //TODO: Add suggested validators for each string format
+        Type::String(_var) => {
+            match &_var.format {
+                VariantOrUnknownOrEmpty::Item(item) => {
+                    match item {
+                        StringFormat::Date => {
+                            // Date format is usually "yyyy-mm-dd"
+                            // You could validate it with a regex
+                            // if date_regex.is_match(_var) {
+                            //     return "String".to_string();
+                            // }
+                            // panic!("Invalid Date format for string");
+                            "String".to_string()
+                        },
+                        StringFormat::DateTime => {
+                            // DateTime format could be ISO 8601: "2023-01-16T23:28:56.782Z"
+                            // You could validate it using chrono's parse function
+                            // if let Ok(_dt) = chrono::DateTime::parse_from_rfc3339(_var) {
+                            //     return "String".to_string();
+                            // }
+                            // panic!("Invalid DateTime format for string");
+                            "String".to_string()
+                        },
+                        StringFormat::Password => {
+                            // Password might not need specific validation, just keep as String
+                            "String".to_string()
+                        },
+                        StringFormat::Byte => {
+                            // Bytes could be base64 encoded string
+                            // if base64::decode(_var).is_ok() {
+                            //     return "String".to_string();
+                            // }
+                            // panic!("Invalid Byte format for string");
+                            "String".to_string()
+                        },
+                        StringFormat::Binary => {
+                            // Binary data might be just represented as a String
+                            "String".to_string()
+                        },
+                    }
+                },
+                VariantOrUnknownOrEmpty::Unknown(_unknown) => "String".to_string(),
+                VariantOrUnknownOrEmpty::Empty => "String".to_string(),
+            }
+        },
+        Type::Number(_var) => {
+            match &_var.format {
+                VariantOrUnknownOrEmpty::Item(item) => {
+                    match item {
+                        NumberFormat::Float => "f32".to_string(),
+                        NumberFormat::Double => "f64".to_string(),
+                    }
+                }
+                VariantOrUnknownOrEmpty::Unknown(_unknown) => "f64".to_string(),
+                VariantOrUnknownOrEmpty::Empty => "f64".to_string(),
+            }
+        },
+        Type::Integer(_var) => {
+            match &_var.format {
+                VariantOrUnknownOrEmpty::Item(item) => {
+                    match item {
+                        IntegerFormat::Int32 => "i32".to_string(),
+                        IntegerFormat::Int64 => "i64".to_string(),
+                    }
+                }
+                VariantOrUnknownOrEmpty::Unknown(_unknown) => "i64".to_string(),
+                VariantOrUnknownOrEmpty::Empty => "i64".to_string(),
+            }
+        },
+        Type::Boolean{} => "bool".to_string(),
+        _type => panic!("Unsupported primitive type: Currently only supports string, number, integer and boolean types"),
+    }
+}
+
 fn primitive_type_to_string(
     schema_type: Type,
     property_name: &str,
 ) -> Result<String, SchemaParserError> {
-    // TODO: Add support for arrays
-    match schema_type {
-        Type::String(_var) => Ok(format!("pub {}: String", validate_identifier_string(property_name))),
-        Type::Number(_var) => Ok(format!("pub {}: f64", validate_identifier_string(property_name))),
-        Type::Integer(_var) => Ok(format!("pub {}: int64", validate_identifier_string(property_name)) ),
-        Type::Boolean{} => Ok(format!("pub {}: bool", validate_identifier_string(property_name))),
-        _type => Err(SchemaParserError::GenericError("Unsupported primitive type: Currently only supports string, number, integer and boolean types".to_string(), Some(property_name.into()))),
-    }
+    Ok(format!(
+        "pub {}: {}",
+        validate_identifier_string(property_name, false),
+        format_to_rust_type(&schema_type)
+    ))
+}
+
+fn array_type_to_string(
+    array_type: &ArrayType,
+    property_name: &str,
+) -> Result<String, SchemaParserError> {
+    let item_type = match &array_type.items {
+        Some(type_box) => match type_box {
+            ReferenceOr::Item(schema) => match &schema.schema_kind {
+                SchemaKind::Type(schema_type) => format_to_rust_type(schema_type),
+                _ => panic!("Unsupported schema kind"),
+            },
+            ReferenceOr::Reference { reference: _ } => {
+                return Err(SchemaParserError::GenericError(
+                    "References are not supported yet".to_string(),
+                    property_name.to_string().into(),
+                ))
+            }
+        },
+        None => {
+            return Err(SchemaParserError::GenericError(
+                "Array type without item type".into(),
+                None,
+            ))
+        }
+    };
+    Ok(format!(
+        "pub {}: Vec<{}>",
+        validate_identifier_string(property_name, false),
+        item_type
+    ))
 }
 
 pub fn schema_parser_mapper(
@@ -95,9 +199,10 @@ pub fn schema_parser_mapper(
                 Ok(format!(
                     "pub {}: {}",
                     struct_name,
-                    validate_identifier_string(struct_name.as_str()).as_str()
+                    validate_identifier_string(struct_name.as_str(), false).as_str()
                 ))
             }
+            Type::Array(array_type) => array_type_to_string(array_type, property_name),
             _primitive_type => primitive_type_to_string(_primitive_type.clone(), property_name),
         },
         _other_schema_kind => {

src/template_model/simplified_operation.rs

@@ -34,7 +34,7 @@ pub fn simplify_operation(operation: &Operation, channel_name: &str) -> Simplifi
     let unique_id = operation
         .operation_id
         .clone()
-        .unwrap_or_else(|| validate_identifier_string(channel_name));
+        .unwrap_or_else(|| validate_identifier_string(channel_name, false));
 
     let messages: Vec<SimplifiedMessage> = match &operation.message {
         Some(operation_message) => match operation_message {