changed parsing to use a simplified operation model so we can access types on each message separately (#44)

* changed parsing to use a simplified operation model so we can access types on each message separately

* fix fmt

---------

Co-authored-by: Stanislav Kosorin <stanislav.kosorin@cresta.ai>

Author: doepnern

example/specs/basic.yaml

@@ -22,13 +22,24 @@ channels:
       operationId: userSignedUp
       summary: send welcome email to user
       message:
-        payload:
-          type: string
+         payload:
+          type: object
+          properties:
+            username:
+              type: string
+            password:
+              type: string
+            age: 
+              type: number
   user/buy:
     subscribe:
-      operationId: userBought
       summary: User bought something
       message:
         payload:
-          type: string
+          type: object
+          properties:
+            item_id:
+              type: string
+            amount: 
+              type: number
 

src/asyncapi_model/api.rs

@@ -1,10 +1,9 @@
 use indexmap::IndexMap;
 use serde::{Deserialize, Serialize};
 
-use super::{
-    Channel, Components, ExternalDocumentation, Info, Operation, Payload, ReferenceOr, Schema,
-    Server, Tag,
-};
+use crate::template_model::{simplify_operation, SimplifiedOperation};
+
+use super::{Channel, Components, ExternalDocumentation, Info, ReferenceOr, Server, Tag};
 
 /// This is the root document object for the API specification.
 /// It combines resource listing and API declaration together into one document.
@@ -170,62 +169,26 @@ pub struct AsyncAPI {
     pub extensions: IndexMap<String, serde_json::Value>,
 }
 impl AsyncAPI {
-    pub fn get_all_channels_operations(&self) -> Vec<(&String, &Operation)> {
-        self.channels
-            .iter()
-            .flat_map(|(channel_name, channel)| {
-                vec![
-                    channel
-                        .publish
-                        .as_ref()
-                        .map(|operation| (channel_name, operation)),
-                    channel
-                        .subscribe
-                        .as_ref()
-                        .map(|operation| (channel_name, operation)),
-                ]
-            })
-            .flatten()
-            .collect()
-    }
-    pub fn get_subscribe_channels_operations(&self) -> Vec<(&String, &Operation)> {
+    pub fn get_subscribe_channels_operations(&self) -> Vec<(&String, SimplifiedOperation)> {
         self.channels
             .iter()
             .filter_map(|(channel_name, channel)| {
                 channel
                     .subscribe
                     .as_ref()
-                    .map(|operation| (channel_name, operation))
+                    .map(|operation| (channel_name, simplify_operation(operation, channel_name)))
             })
             .collect()
     }
-    pub fn get_publish_channels_operations(&self) -> Vec<(&String, &Operation)> {
+    pub fn get_publish_channels_operations(&self) -> Vec<(&String, SimplifiedOperation)> {
         self.channels
             .iter()
             .filter_map(|(channel_name, channel)| {
                 channel
                     .publish
                     .as_ref()
-                    .map(|operation| (channel_name, operation))
+                    .map(|operation| (channel_name, simplify_operation(operation, channel_name)))
             })
             .collect()
     }
-    pub fn get_components(&self) -> Option<&Components> {
-        self.components.as_ref()
-    }
-    pub fn get_schema_from_reference(&self, message_name: &str) -> &Schema {
-        self.get_components()
-            .and_then(|components| {
-                let message_or_ref = components.messages.get(message_name).unwrap();
-                let payload = match message_or_ref {
-                    ReferenceOr::Item(message) => message.payload.as_ref().unwrap(),
-                    ReferenceOr::Reference { .. } => return None, // or handle the reference case
-                };
-                Some(match payload {
-                    Payload::Schema(schema) => schema,
-                    Payload::Any(_) => return None,
-                })
-            })
-            .unwrap()
-    }
 }

src/main.rs

@@ -48,6 +48,8 @@ fn main() {
         &async_config,
         &output_path.join("Readme.md"),
     );
+    println!("file generation finished, adding dependencies...");
+
     // make output a compilable project
     cargo_init_project(output_path);
     cargo_fmt(&output_path.join("src/main.rs"));
@@ -56,8 +58,5 @@ fn main() {
     cargo_add(output_path, "futures", None);
     cargo_add(output_path, "serde", None);
     println!("generating docs...");
-    println!(
-        "this may take a while, you can already use the generated project in the output directory"
-    );
     cargo_generate_rustdoc(output_path);
 }

src/parser/mod.rs

@@ -1,7 +1,8 @@
 mod common;
+mod parse_template_context;
 mod preprocessor;
-mod pubsub;
 mod schema_parser;
 mod validator;
-pub use common::parse_spec_to_model;
-pub use pubsub::spec_to_pubsub_template_type;
+pub use common::{parse_spec_to_model, validate_identifier_string};
+pub use parse_template_context::spec_to_pubsub_template_type;
+pub use schema_parser::schema_parser_mapper;

src/parser/parse_template_context.rs

@@ -0,0 +1,27 @@
+use crate::{
+    asyncapi_model::{AsyncAPI, ReferenceOr},
+    template_model::TemplateContext,
+};
+use std::io;
+
+pub fn spec_to_pubsub_template_type<'a>(
+    spec: &'a AsyncAPI,
+) -> Result<TemplateContext<'a>, io::Error> {
+    let item = spec.servers.first().unwrap().1;
+    let server = match item {
+        ReferenceOr::Item(it) => it,
+        ReferenceOr::Reference { reference: _ } => None.unwrap(),
+    };
+
+    let publish_channels = spec.get_publish_channels_operations();
+    let subscribe_channels = spec.get_subscribe_channels_operations();
+
+    let pubsub_template: TemplateContext<'a> = TemplateContext {
+        server,
+        subscribe_channels,
+        publish_channels,
+        title: &spec.info.title,
+        description: &spec.info.description,
+    };
+    Ok(pubsub_template)
+}

src/parser/preprocessor.rs

@@ -1,6 +1,6 @@
 use crate::parser::common::validate_identifier_string;
 use serde_json::json;
-use std::collections::HashSet;
+use std::{collections::HashSet, panic};
 
 pub fn resolve_json_path(json: serde_json::Value, path: &str) -> serde_json::Value {
     let parts = path.split('/').collect::<Vec<&str>>();

src/parser/pubsub.rs

@@ -36,7 +36,7 @@ fn object_schema_to_string(
     property_name: &str,
     all_structs: &mut HashMap<String, String>,
 ) -> Result<String, SchemaParserError> {
-    let before_string = format!(
+    let before_string: String = format!(
         "#[derive(Clone, Debug, Deserialize, Serialize)]\npub struct {} {{\n",
         validate_identifier_string(property_name)
     );

src/parser/schema_parser.rs

@@ -1,2 +1,7 @@
-mod pubsub_template;
-pub use pubsub_template::PubsubTemplate;
+mod simplified_operation;
+mod template_context;
+pub use simplified_operation::{
+    simplify_message, simplify_operation, simplify_schema, SimplifiedMessage, SimplifiedOperation,
+    SimplifiedSchema,
+};
+pub use template_context::TemplateContext;