new module structure

Cargo.toml

@@ -8,7 +8,7 @@ edition = "2024"
 [workspace.dependencies]
 serde = "1.0.219"
 serde_json = "1.0.140"
-tucana = "0.0.68"
+tucana = "0.0.69"
 clap = "4.5.41"
 colored = "3.0"
 tabled = "0.20"
@@ -21,3 +21,4 @@ bytes = "1.10.1"
 prost = "0.14.1"
 walkdir = "2.5.0"
 log = "0.4.28"
+tonic = "0.14.2"

crates/cli/Cargo.toml

@@ -2,7 +2,7 @@
 name = "code0-cli"
 version = "0.0.0"
 edition = "2024"
-description = "The cli for managing the Code0-Definitions"
+description = "The CLI for managing the CodeZero's definitions"
 repository = "https://github.com/code0-tech/code0-definitions"
 homepage = "https://code0.tech"
 license = "Apache-2.0"
@@ -22,5 +22,6 @@ futures = { workspace = true }
 zip = { workspace = true }
 bytes = { workspace = true }
 prost = { workspace = true }
-tonic = "0.14.2"
-log = "0.4.28"
+tonic  = { workspace = true }
+log = { workspace = true }
+

crates/cli/src/analyser/core.rs

@@ -1,9 +1,12 @@
-use crate::analyser::index_identifier::IdentifierIndex;
 use crate::diagnostics::diagnose::Diagnose;
 use crate::diagnostics::kinds::DiagnosticKind;
 use crate::diagnostics::reporter::Reporter;
-use crate::parser::Meta;
-use tucana::shared::{DefinitionDataType, FlowType, RuntimeFunctionDefinition};
+use crate::parser::ModuleConfiguration;
+use crate::{analyser::index_identifier::IdentifierIndex, reader::Meta};
+use tucana::shared::{
+    DefinitionDataType, FlowType, FunctionDefinition, ModuleConfigurationDefinition,
+    RuntimeFlowType, RuntimeFunctionDefinition,
+};
 
 #[derive(Clone)]
 pub struct AnalysableDataType {
@@ -26,12 +29,44 @@ pub struct AnalysableFunction {
     pub id: i16,
 }
 
+#[derive(Clone)]
+pub struct AnalysableRuntimeFlowType {
+    pub original_definition: Meta,
+    pub runtime_flow_type: RuntimeFlowType,
+    pub id: i16,
+}
+
+#[derive(Clone)]
+pub struct AnalysableFunctionDefinition {
+    pub original_definition: Meta,
+    pub function_definition: FunctionDefinition,
+    pub id: i16,
+}
+
+#[derive(Clone)]
+pub struct AnalysableModuleConfigurationDefinition {
+    pub original_definition: Meta,
+    pub module_configuration_definition: ModuleConfigurationDefinition,
+    pub id: i16,
+}
+
+#[derive(Clone)]
+pub struct AnalysableModuleDefinition {
+    pub original_definition: Meta,
+    pub module_definition: ModuleConfiguration,
+    pub id: i16,
+}
+
 pub struct Analyser {
     pub reporter: Reporter,
     pub(crate) index: IdentifierIndex,
     pub data_types: Vec<AnalysableDataType>,
     pub flow_types: Vec<AnalysableFlowType>,
     pub functions: Vec<AnalysableFunction>,
+    pub runtime_flow_types: Vec<AnalysableRuntimeFlowType>,
+    pub function_definitions: Vec<AnalysableFunctionDefinition>,
+    pub module_configuration_definitions: Vec<AnalysableModuleConfigurationDefinition>,
+    pub module_definitions: Vec<AnalysableModuleDefinition>,
 }
 
 impl Analyser {
@@ -50,6 +85,18 @@ impl Analyser {
         for f in self.functions.clone() {
             self.analyse_runtime_function(&f);
         }
+        for rft in self.runtime_flow_types.clone() {
+            self.analyse_runtime_flow_type(&rft);
+        }
+        for f in self.function_definitions.clone() {
+            self.analyse_function_definition(&f);
+        }
+        for config in self.module_configuration_definitions.clone() {
+            self.analyse_module_configuration_definition(&config);
+        }
+        for module in self.module_definitions.clone() {
+            self.analyse_module_definition(&module);
+        }
         self.reporter.print(will_exit, true, with_warning);
     }
 

crates/cli/src/analyser/data_type.rs

@@ -47,7 +47,7 @@ impl Analyser {
             ));
         }
 
-        if dt.r#type == "" {
+        if dt.r#type.is_empty() {
             self.reporter.add(Diagnose::new(
                 dt.identifier.clone(),
                 adt.original_definition.clone(),

crates/cli/src/analyser/flow_type.rs

@@ -77,7 +77,7 @@ impl Analyser {
             ));
         }
 
-        if &flow.signature == "" {
+        if flow.signature.is_empty() {
             self.reporter.add(Diagnose::new(
                 name.clone(),
                 original.clone(),

crates/cli/src/analyser/function.rs

@@ -78,7 +78,7 @@ impl Analyser {
             ));
         }
 
-        if function.signature == "" {
+        if function.signature.is_empty() {
             self.reporter.add(Diagnose::new(
                 name.clone(),
                 original.clone(),

crates/cli/src/analyser/function_definition.rs

@@ -0,0 +1,141 @@
+use crate::analyser::core::{AnalysableFunctionDefinition, Analyser};
+use crate::diagnostics::diagnose::Diagnose;
+use crate::diagnostics::kinds::DiagnosticKind;
+
+impl Analyser {
+    pub fn analyse_function_definition(&mut self, afd: &AnalysableFunctionDefinition) {
+        let name = afd.function_definition.runtime_name.clone();
+        let function = &afd.function_definition;
+        let original = afd.original_definition.clone();
+
+        for linked in function.linked_data_type_identifiers.clone() {
+            if !self.data_type_identifier_exists(linked.as_str(), None) {
+                self.reporter.add(Diagnose::new(
+                    name.clone(),
+                    original.clone(),
+                    DiagnosticKind::UndefinedDataTypeIdentifier {
+                        identifier: linked.clone(),
+                    },
+                ));
+            }
+        }
+
+        if function.display_icon.is_empty() {
+            self.reporter.add(Diagnose::new(
+                name.clone(),
+                original.clone(),
+                DiagnosticKind::NullField {
+                    field_name: "displayIcon".into(),
+                },
+            ))
+        }
+
+        if function.alias.is_empty() {
+            self.reporter.add(Diagnose::new(
+                name.clone(),
+                original.clone(),
+                DiagnosticKind::MissingTranslation {
+                    translation_field: "alias".into(),
+                },
+            ));
+        }
+
+        if function.display_message.is_empty() {
+            self.reporter.add(Diagnose::new(
+                name.clone(),
+                original.clone(),
+                DiagnosticKind::MissingTranslation {
+                    translation_field: "displayMessage".into(),
+                },
+            ));
+        }
+
+        if function.name.is_empty() {
+            self.reporter.add(Diagnose::new(
+                name.clone(),
+                original.clone(),
+                DiagnosticKind::UndefinedTranslation {
+                    translation_field: "name".into(),
+                },
+            ));
+        }
+        if function.description.is_empty() {
+            self.reporter.add(Diagnose::new(
+                name.clone(),
+                original.clone(),
+                DiagnosticKind::UndefinedTranslation {
+                    translation_field: "description".into(),
+                },
+            ));
+        }
+        if function.documentation.is_empty() {
+            self.reporter.add(Diagnose::new(
+                name.clone(),
+                original.clone(),
+                DiagnosticKind::UndefinedTranslation {
+                    translation_field: "documentation".into(),
+                },
+            ));
+        }
+
+        if function.signature.is_empty() {
+            self.reporter.add(Diagnose::new(
+                name.clone(),
+                original.clone(),
+                DiagnosticKind::NullField {
+                    field_name: "signature".into(),
+                },
+            ));
+        }
+
+        let mut param_names: Vec<String> = vec![];
+        for parameter in &function.parameter_definitions {
+            if parameter.name.is_empty() {
+                self.reporter.add(Diagnose::new(
+                    name.clone(),
+                    original.clone(),
+                    DiagnosticKind::UndefinedTranslation {
+                        translation_field: "name".into(),
+                    },
+                ));
+            }
+            if parameter.description.is_empty() {
+                self.reporter.add(Diagnose::new(
+                    name.clone(),
+                    original.clone(),
+                    DiagnosticKind::UndefinedTranslation {
+                        translation_field: "description".into(),
+                    },
+                ));
+            }
+            if parameter.documentation.is_empty() {
+                self.reporter.add(Diagnose::new(
+                    name.clone(),
+                    original.clone(),
+                    DiagnosticKind::UndefinedTranslation {
+                        translation_field: "documentation".into(),
+                    },
+                ));
+            }
+
+            if param_names.contains(&parameter.runtime_name) {
+                self.reporter.add(Diagnose::new(
+                    name.clone(),
+                    original.clone(),
+                    DiagnosticKind::DuplicateRuntimeParameterIdentifier {
+                        identifier: parameter.runtime_name.clone(),
+                    },
+                ));
+            }
+            param_names.push(parameter.runtime_name.clone());
+        }
+
+        if self.index.has_function_definition(&name, Some(afd.id)) {
+            self.reporter.add(Diagnose::new(
+                name.clone(),
+                original.clone(),
+                DiagnosticKind::DuplicateFunctionIdentifier { identifier: name },
+            ));
+        }
+    }
+}

crates/cli/src/analyser/index_identifier.rs

@@ -4,7 +4,10 @@ use std::collections::HashMap;
 pub struct IdentifierIndex {
     data_types: HashMap<String, i16>,
     flow_types: HashMap<String, i16>,
+    runtime_flow_types: HashMap<String, i16>,
     functions: HashMap<String, i16>,
+    function_definitions: HashMap<String, i16>,
+    module_configuration_definitions: HashMap<String, i16>,
 }
 
 fn normalize(s: &str) -> String {
@@ -18,9 +21,19 @@ impl IdentifierIndex {
     pub fn insert_flow_type(&mut self, name: &str, id: i16) -> Option<i16> {
         self.flow_types.insert(normalize(name), id)
     }
+    pub fn insert_runtime_flow_type(&mut self, name: &str, id: i16) -> Option<i16> {
+        self.runtime_flow_types.insert(normalize(name), id)
+    }
     pub fn insert_function(&mut self, name: &str, id: i16) -> Option<i16> {
         self.functions.insert(normalize(name), id)
     }
+    pub fn insert_function_definition(&mut self, name: &str, id: i16) -> Option<i16> {
+        self.function_definitions.insert(normalize(name), id)
+    }
+    pub fn insert_module_configuration_definition(&mut self, name: &str, id: i16) -> Option<i16> {
+        self.module_configuration_definitions
+            .insert(normalize(name), id)
+    }
 
     pub fn has_data_type(&self, name: &str, except: Option<i16>) -> bool {
         self.data_types
@@ -35,4 +48,25 @@ impl IdentifierIndex {
             .map(|found| except.map(|e| *found != e).unwrap_or(true))
             .unwrap_or(false)
     }
+
+    pub fn has_runtime_flow_type(&self, name: &str, except: Option<i16>) -> bool {
+        self.runtime_flow_types
+            .get(&normalize(name))
+            .map(|found| except.map(|e| *found != e).unwrap_or(true))
+            .unwrap_or(false)
+    }
+
+    pub fn has_function_definition(&self, name: &str, except: Option<i16>) -> bool {
+        self.function_definitions
+            .get(&normalize(name))
+            .map(|found| except.map(|e| *found != e).unwrap_or(true))
+            .unwrap_or(false)
+    }
+
+    pub fn has_module_configuration_definition(&self, name: &str, except: Option<i16>) -> bool {
+        self.module_configuration_definitions
+            .get(&normalize(name))
+            .map(|found| except.map(|e| *found != e).unwrap_or(true))
+            .unwrap_or(false)
+    }
 }