Separate messages for definition and execution

build/ruby/lib/tucana/shared/shared.data_type.rb

@@ -5,7 +5,7 @@ module Shared
     UnexpectedRuleType = Class.new(Tucana::Error)
     UnexpectedType = Class.new(Tucana::Error)
 
-    DataTypeRule.class_eval do
+    DefinitionDataTypeRule.class_eval do
       def variant
         self.config
       end
@@ -34,19 +34,19 @@ def rule_config
       def create(variant, config)
         case variant
         when :contains_key
-          self.contains_key = DataTypeContainsKeyRuleConfig.new(config)
+          self.contains_key = DefinitionDataTypeContainsKeyRuleConfig.new(config)
         when :contains_type
-          self.contains_type = DataTypeContainsTypeRuleConfig.new(config)
+          self.contains_type = DefinitionDataTypeContainsTypeRuleConfig.new(config)
         when :item_of_collection
           self.item_of_collection = DataTypeItemOfCollectionRuleConfig.from_hash(config)
         when :number_range
           self.number_range = DataTypeNumberRangeRuleConfig.new(config)
         when :regex
           self.regex = DataTypeRegexRuleConfig.new(config)
         when :input_types
-          self.input_types = DataTypeInputTypesRuleConfig.new(config)
+          self.input_types = DefinitionDataTypeInputTypesRuleConfig.new(config)
         when :return_type
-          self.return_type = DataTypeReturnTypeRuleConfig.new(config)
+          self.return_type = DefinitionDataTypeReturnTypeRuleConfig.new(config)
         else
           raise UnexpectedRuleType, "Unknown rule type #{variant}"
         end
@@ -59,7 +59,7 @@ def self.create(variant, config)
       end
     end
 
-    DataTypeContainsKeyRuleConfig.class_eval do
+    DefinitionDataTypeContainsKeyRuleConfig.class_eval do
       def to_h
         {
           key: self.key,
@@ -75,7 +75,7 @@ def self.from_hash(config)
       end
     end
 
-    DataTypeContainsTypeRuleConfig.class_eval do
+    DefinitionDataTypeContainsTypeRuleConfig.class_eval do
       def to_h
         {
           data_type_identifier: self.data_type_identifier.to_h,
@@ -117,7 +117,7 @@ def to_h
       end
     end
 
-    DataTypeInputTypesRuleConfig.class_eval do
+    DefinitionDataTypeInputTypesRuleConfig.class_eval do
       def to_h
         {
           input_types: self.input_types.map { |input_type| input_type.to_h }
@@ -131,7 +131,7 @@ def self.from_hash(hash)
       end
     end
 
-    DataTypeInputTypesRuleConfig::DataTypeInputType.class_eval do
+    DefinitionDataTypeInputTypesRuleConfig::DataTypeInputType.class_eval do
       def to_h
         {
           data_type_identifier: self.data_type_identifier,
@@ -147,7 +147,7 @@ def self.from_hash(config)
       end
     end
 
-    DataTypeReturnTypeRuleConfig.class_eval do
+    DefinitionDataTypeReturnTypeRuleConfig.class_eval do
       def to_h
         {
           data_type_identifier: self.data_type_identifier,

build/ruby/spec/tucana/shared/shared.data_type_spec.rb

@@ -2,21 +2,21 @@
 
 Tucana.load_protocol(:shared)
 
-RSpec.describe Tucana::Shared::DataTypeRule do
+RSpec.describe Tucana::Shared::DefinitionDataTypeRule do
   describe "#create" do
     context "with :contains_key variant" do
       it "sets the contains_key field" do
         config = { key: "test_key", data_type_identifier: { data_type_identifier: "test_type" } }
         rule = described_class.create(:contains_key, config)
-        expect(rule.contains_key).to be_a(Tucana::Shared::DataTypeContainsKeyRuleConfig)
+        expect(rule.contains_key).to be_a(Tucana::Shared::DefinitionDataTypeContainsKeyRuleConfig)
       end
     end
 
     context "with :contains_type variant" do
       it "sets the contains_type field" do
         config = { data_type_identifier: { data_type_identifier: "test_type" } }
         rule = described_class.create(:contains_type, config)
-        expect(rule.contains_type).to be_a(Tucana::Shared::DataTypeContainsTypeRuleConfig)
+        expect(rule.contains_type).to be_a(Tucana::Shared::DefinitionDataTypeContainsTypeRuleConfig)
       end
     end
 
@@ -48,15 +48,15 @@
       it "sets the input_types field" do
         config = { input_types: [{ data_type_identifier: { data_type_identifier: "test_type" }, input_identifier: "test_input" }] }
         rule = described_class.create(:input_types, config)
-        expect(rule.input_types).to be_a(Tucana::Shared::DataTypeInputTypesRuleConfig)
+        expect(rule.input_types).to be_a(Tucana::Shared::DefinitionDataTypeInputTypesRuleConfig)
       end
     end
 
     context "with :return_type variant" do
       it "sets the return_type field" do
         config = { data_type_identifier: { data_type_identifier: "test_type" } }
         rule = described_class.create(:return_type, config)
-        expect(rule.return_type).to be_a(Tucana::Shared::DataTypeReturnTypeRuleConfig)
+        expect(rule.return_type).to be_a(Tucana::Shared::DefinitionDataTypeReturnTypeRuleConfig)
       end
     end
 

build/rust/src/lib.rs

@@ -5,12 +5,12 @@ pub mod shared {
 
     #[cfg(test)]
     pub mod tests {
-        use crate::shared::Flow;
+        use crate::shared::ValidationFlow;
         use serde_json;
 
         #[test]
         fn test_serialize() {
-            let flow = Flow {
+            let flow = ValidationFlow {
                 flow_id: 0,
                 project_id: 0,
                 data_types: vec![],
@@ -52,10 +52,10 @@ pub mod shared {
             "starting_node": null
         }"#;
 
-            let deserialized: Result<Flow, _> = serde_json::from_str(json_data);
+            let deserialized: Result<ValidationFlow, _> = serde_json::from_str(json_data);
             assert!(deserialized.is_ok());
 
-            let expected_flow = Flow {
+            let expected_flow = ValidationFlow {
                 flow_id: 0,
                 project_id: 0,
                 r#type: "no".to_string(),

build/rust/src/shared/helper/rule.rs

@@ -1,45 +1,43 @@
-use crate::shared::DataTypeIdentifier;
-use crate::shared::data_type_input_types_rule_config::DataTypeInputType;
 use crate::shared::{
-    DataTypeContainsKeyRuleConfig, DataTypeContainsTypeRuleConfig, DataTypeInputTypesRuleConfig,
     DataTypeItemOfCollectionRuleConfig, DataTypeNumberRangeRuleConfig, DataTypeRegexRuleConfig,
-    DataTypeReturnTypeRuleConfig, DataTypeRule, Value, data_type_rule::Config,
+    ExecutionDataTypeContainsKeyRuleConfig, ExecutionDataTypeContainsTypeRuleConfig,
+    ExecutionDataTypeRule, Value, execution_data_type_rule::Config,
 };
 
 pub struct RuleBuilder {
-    rules: Vec<DataTypeRule>,
+    rules: Vec<ExecutionDataTypeRule>,
 }
 
 impl RuleBuilder {
     pub fn new() -> Self {
         Self { rules: Vec::new() }
     }
 
-    pub fn add_contains_key(
-        mut self,
-        key: String,
-        data_type_identifier: DataTypeIdentifier,
-    ) -> Self {
-        self.rules.push(DataTypeRule {
-            config: Some(Config::ContainsKey(DataTypeContainsKeyRuleConfig {
-                key,
-                data_type_identifier: Some(data_type_identifier),
-            })),
+    pub fn add_contains_key(mut self, key: String, data_type_identifier: &str) -> Self {
+        self.rules.push(ExecutionDataTypeRule {
+            config: Some(Config::ContainsKey(
+                ExecutionDataTypeContainsKeyRuleConfig {
+                    key,
+                    data_type_identifier: data_type_identifier.to_string(),
+                },
+            )),
         });
         self
     }
 
-    pub fn add_contains_type(mut self, data_type_identifier: DataTypeIdentifier) -> Self {
-        self.rules.push(DataTypeRule {
-            config: Some(Config::ContainsType(DataTypeContainsTypeRuleConfig {
-                data_type_identifier: Some(data_type_identifier),
-            })),
+    pub fn add_contains_type(mut self, data_type_identifier: &str) -> Self {
+        self.rules.push(ExecutionDataTypeRule {
+            config: Some(Config::ContainsType(
+                ExecutionDataTypeContainsTypeRuleConfig {
+                    data_type_identifier: data_type_identifier.to_string(),
+                },
+            )),
         });
         self
     }
 
     pub fn add_item_of_collection(mut self, items: Vec<Value>) -> Self {
-        self.rules.push(DataTypeRule {
+        self.rules.push(ExecutionDataTypeRule {
             config: Some(Config::ItemOfCollection(
                 DataTypeItemOfCollectionRuleConfig { items },
             )),
@@ -48,7 +46,7 @@ impl RuleBuilder {
     }
 
     pub fn add_number_range(mut self, from: i64, to: i64, steps: Option<i64>) -> Self {
-        self.rules.push(DataTypeRule {
+        self.rules.push(ExecutionDataTypeRule {
             config: Some(Config::NumberRange(DataTypeNumberRangeRuleConfig {
                 from,
                 to,
@@ -59,73 +57,45 @@ impl RuleBuilder {
     }
 
     pub fn add_regex(mut self, pattern: String) -> Self {
-        self.rules.push(DataTypeRule {
+        self.rules.push(ExecutionDataTypeRule {
             config: Some(Config::Regex(DataTypeRegexRuleConfig { pattern })),
         });
         self
     }
 
-    pub fn add_input_types(mut self, input_types: Vec<DataTypeInputType>) -> Self {
-        self.rules.push(DataTypeRule {
-            config: Some(Config::InputTypes(DataTypeInputTypesRuleConfig {
-                input_types,
-            })),
-        });
-        self
-    }
-
-    pub fn add_return_type(mut self, data_type_identifier: DataTypeIdentifier) -> Self {
-        self.rules.push(DataTypeRule {
-            config: Some(Config::ReturnType(DataTypeReturnTypeRuleConfig {
-                data_type_identifier: Some(data_type_identifier),
-            })),
-        });
-        self
-    }
-
-    pub fn build(self) -> Vec<DataTypeRule> {
+    pub fn build(self) -> Vec<ExecutionDataTypeRule> {
         self.rules
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use crate::shared::helper::value::ToValue;
+
     use super::*;
-    use crate::shared::{
-        data_type_identifier::Type, data_type_input_types_rule_config::DataTypeInputType,
-        data_type_rule::Config, helper::value::ToValue,
-    };
-
-    fn to_data_type(str: &str) -> DataTypeIdentifier {
-        DataTypeIdentifier {
-            r#type: Some(Type::DataTypeIdentifier(str.into())),
-        }
-    }
 
     #[test]
     fn test_add_contains_key() {
         let rules = RuleBuilder::new()
-            .add_contains_key("id".into(), to_data_type("User"))
+            .add_contains_key("id".into(), "User")
             .build();
 
         match &rules[0].config {
             Some(Config::ContainsKey(cfg)) => {
                 assert_eq!(cfg.key, "id");
-                assert_eq!(cfg.data_type_identifier, Some(to_data_type("User")));
+                assert_eq!(cfg.data_type_identifier, String::from("User"));
             }
             _ => panic!("Expected ContainsKey config"),
         }
     }
 
     #[test]
     fn test_add_contains_type() {
-        let rules = RuleBuilder::new()
-            .add_contains_type(to_data_type("User"))
-            .build();
+        let rules = RuleBuilder::new().add_contains_type("User").build();
 
         match &rules[0].config {
             Some(Config::ContainsType(cfg)) => {
-                assert_eq!(cfg.data_type_identifier, Some(to_data_type("User")));
+                assert_eq!(cfg.data_type_identifier, String::from("User"));
             }
             _ => panic!("Expected ContainsType config"),
         }
@@ -172,80 +142,33 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_add_input_types() {
-        let input_types = vec![
-            DataTypeInputType {
-                data_type_identifier: Some(to_data_type("Type1")),
-                input_identifier: "input1".into(),
-            },
-            DataTypeInputType {
-                data_type_identifier: Some(to_data_type("Type2")),
-                input_identifier: "input2".into(),
-            },
-        ];
-
-        let rules = RuleBuilder::new()
-            .add_input_types(input_types.clone())
-            .build();
-
-        match &rules[0].config {
-            Some(Config::InputTypes(cfg)) => {
-                assert_eq!(cfg.input_types, input_types);
-            }
-            _ => panic!("Expected InputTypes config"),
-        }
-    }
-
-    #[test]
-    fn test_add_return_type() {
-        let rules = RuleBuilder::new()
-            .add_return_type(to_data_type("Result"))
-            .build();
-
-        match &rules[0].config {
-            Some(Config::ReturnType(cfg)) => {
-                assert_eq!(cfg.data_type_identifier, Some(to_data_type("Result")));
-            }
-            _ => panic!("Expected ReturnType config"),
-        }
-    }
-
     #[test]
     fn test_add_many_rules() {
         let rules = RuleBuilder::new()
-            .add_contains_key("id".into(), to_data_type("User"))
-            .add_return_type(to_data_type("Result"))
+            .add_contains_key("id".into(), "User")
             .add_regex(r"^\d+$".into())
-            .add_contains_key("id".into(), to_data_type("User"))
+            .add_contains_key("id".into(), "User")
             .build();
 
         match &rules[0].config {
             Some(Config::ContainsKey(cfg)) => {
                 assert_eq!(cfg.key, "id");
-                assert_eq!(cfg.data_type_identifier, Some(to_data_type("User")));
+                assert_eq!(cfg.data_type_identifier, String::from("User"));
             }
             _ => panic!("Expected ContainsKey config"),
         }
 
         match &rules[1].config {
-            Some(Config::ReturnType(cfg)) => {
-                assert_eq!(cfg.data_type_identifier, Some(to_data_type("Result")));
-            }
-            _ => panic!("Expected ReturnType config"),
-        }
-
-        match &rules[2].config {
             Some(Config::Regex(cfg)) => {
                 assert_eq!(cfg.pattern, r"^\d+$");
             }
             _ => panic!("Expected Regex config"),
         }
 
-        match &rules[3].config {
+        match &rules[2].config {
             Some(Config::ContainsKey(cfg)) => {
                 assert_eq!(cfg.key, "id");
-                assert_eq!(cfg.data_type_identifier, Some(to_data_type("User")));
+                assert_eq!(cfg.data_type_identifier, String::from("User"));
             }
             _ => panic!("Expected ContainsKey config"),
         }

proto/aquila/aquila.action.proto

@@ -33,7 +33,7 @@ message Configuration {
 message ActionConfiguration {
   repeated shared.Translation name = 1;
   repeated shared.Translation description = 2;
-  shared.DataType type = 3;
+  shared.DefinitionDataType type = 3;
   optional shared.Value default_value = 4;
 }