feat: push command will use module service instead of old service structure

Author: raphael-goetz

crates/cli/src/command/push/mod.rs

@@ -1,6 +1,34 @@
-use crate::analyser::core::Analyser;
+use tucana::shared::Module;
+
+use crate::{
+    analyser::core::Analyser, command::parse_errors::fail_on_parser_errors,
+    command::push::module_service_client_impl::SagittariusModuleServiceClient, parser::Parser,
+};
 
 mod auth;
+mod module_service_client_impl;
+
+fn apply_version_to_module(mut module: Module, version: String) -> Module {
+    module.version = version.clone();
+
+    for data_type in &mut module.definition_data_types {
+        data_type.version = version.clone();
+    }
+    for flow_type in &mut module.flow_types {
+        flow_type.version = version.clone();
+    }
+    for runtime_flow_type in &mut module.runtime_flow_types {
+        runtime_flow_type.version = version.clone();
+    }
+    for function in &mut module.function_definitions {
+        function.version = version.clone();
+    }
+    for runtime_function in &mut module.runtime_function_definitions {
+        runtime_function.version = version.clone();
+    }
+
+    module
+}
 
 pub async fn push(
     token: String,
@@ -17,5 +45,24 @@ pub async fn push(
 
     let mut analyzer = Analyser::new(dir_path.as_str());
     analyzer.report(false, true);
-    todo!("Implement Sagittarius Module Service Client Endpoint!")
+
+    let parser = match Parser::from_path(dir_path.as_str()) {
+        Some(parser) => parser,
+        None => {
+            panic!("Error reading definitions");
+        }
+    };
+    fail_on_parser_errors(&parser);
+
+    let mods = parser
+        .modules
+        .into_iter()
+        .map(|definition_module| {
+            let module = definition_module.into_module();
+            apply_version_to_module(module, version.clone())
+        })
+        .collect::<Vec<_>>();
+
+    let mut client = SagittariusModuleServiceClient::new(url, token).await;
+    client.update(mods).await;
 }

crates/cli/src/command/push/module_service_client_impl.rs

@@ -0,0 +1,49 @@
+use crate::command::push::auth::get_authorization_metadata;
+use crate::formatter::{error_without_trace, info};
+use tonic::{Extensions, Request, transport::Channel};
+use tucana::sagittarius::ModuleUpdateRequest;
+use tucana::sagittarius::module_service_client::ModuleServiceClient;
+use tucana::shared::Module;
+
+pub struct SagittariusModuleServiceClient {
+    client: ModuleServiceClient<Channel>,
+    token: String,
+}
+
+impl SagittariusModuleServiceClient {
+    pub async fn new(sagittarius_url: String, token: String) -> Self {
+        let client = match ModuleServiceClient::connect(sagittarius_url).await {
+            Ok(client) => {
+                info(String::from(
+                    "Successfully connected to Sagittarius Module Service Endpoint!",
+                ));
+                client
+            }
+            Err(err) => panic!(
+                "Failed to connect to Sagittarius (Module Service Endpoint): {:?}",
+                err
+            ),
+        };
+        Self { client, token }
+    }
+
+    pub async fn update(&mut self, modules: Vec<Module>) {
+        let request = Request::from_parts(
+            get_authorization_metadata(&self.token),
+            Extensions::new(),
+            ModuleUpdateRequest { modules },
+        );
+
+        match self.client.update(request).await {
+            Ok(response) => {
+                info(format!(
+                    "Successfully transferred data types. Did Sagittarius updated them? {:?}",
+                    &response.into_inner().success
+                ));
+            }
+            Err(err) => {
+                error_without_trace(format!("Failed to update DataTypes: {:?}", err));
+            }
+        };
+    }
+}