Add runnable graph spec

src/graph.rs

@@ -1,27 +1,33 @@
+use itertools::Itertools;
 use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Deserialize)]
+use crate::filter::FilterNodeRunner;
+
+// TODO: Break all this up into separate files in the graph module
+#[derive(Serialize, Deserialize, Clone)]
 pub enum NodeConfiguration {
     FileNode,
     MoveMoneyNode(MoveMoneyNode),
     MergeNode(MergeNode),
     DeriveNode(DeriveNode),
+    CodeRuleNode(CodeRuleNode),
+    FilterNode(FilterNode),
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct NodeInfo {
     pub name: String,
     pub output_files: Vec<String>,
     pub configuration: NodeConfiguration,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
 pub enum MoveMoneyAmountType {
     Percent,
     Amount,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct MoveMoneyRule {
     pub from_account: String,
     pub from_cc: String,
@@ -31,7 +37,7 @@ pub struct MoveMoneyRule {
     pub amount_type: MoveMoneyAmountType,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct MoveMoneyNode {
     pub departments_path: String,
     pub accounts_path: String,
@@ -39,38 +45,38 @@ pub struct MoveMoneyNode {
     pub rules: Vec<MoveMoneyRule>,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
 pub enum JoinType {
     Left,
     Inner,
     Right,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct MergeJoin {
     pub join_type: JoinType,
     pub left_column_name: String,
     pub right_column_name: String,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct MergeNode {
     pub input_files: Vec<String>,
     pub joins: Vec<MergeJoin>,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
 pub enum DeriveColumnType {
     Column(String),
     Constant(String),
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct MapOperation {
     pub mapped_value: String,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
 pub enum DatePart {
     Year,
     Month,
@@ -81,20 +87,20 @@ pub enum DatePart {
     Second,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
 pub enum SplitType {
     DateTime(String, DatePart),
     Numeric(String, isize),
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
 pub enum MatchComparisonType {
     Equal,
     GreaterThan,
     LessThan,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
 pub enum DeriveOperation {
     Concat(Vec<DeriveColumnType>),
     Add(Vec<DeriveColumnType>),
@@ -105,25 +111,43 @@ pub enum DeriveOperation {
     Split(String, SplitType),
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct DeriveFilter {
     pub column_name: String,
     pub comparator: MatchComparisonType,
     pub match_value: String,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct DeriveRule {
     pub operations: Vec<DeriveOperation>,
     pub filters: Vec<DeriveFilter>,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct DeriveNode {
     pub rules: Vec<DeriveRule>,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
+pub enum CodeRuleLanguage {
+    Javascript,
+    Rust,
+    Go,
+}
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct CodeRuleNode {
+    pub language: CodeRuleLanguage,
+    pub text: String,
+}
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct FilterNode {
+    pub filters: Vec<DeriveFilter>,
+}
+
+#[derive(Serialize, Deserialize, Clone)]
 pub struct Node {
     pub id: i64,
     pub info: NodeInfo,
@@ -136,7 +160,56 @@ impl Node {
     }
 }
 
+impl Into<RunnableGraphNode> for Node {
+    fn into(self) -> RunnableGraphNode {
+        RunnableGraphNode {
+            runnable_node: Box::new(FilterNodeRunner {}),
+            // TODO: Construct node objects
+            // runnable_node: match &self.info.configuration {
+            //     NodeConfiguration::FileNode => todo!(),
+            //     NodeConfiguration::MoveMoneyNode(_) => todo!(),
+            //     NodeConfiguration::MergeNode(_) => todo!(),
+            //     NodeConfiguration::DeriveNode(_) => todo!(),
+            //     NodeConfiguration::CodeRuleNode(_) => todo!(),
+            //     NodeConfiguration::FilterNode(_) => todo!(),
+            // },
+            node: self,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone)]
 pub struct Graph {
     pub name: String,
     pub nodes: Vec<Node>,
 }
+
+pub trait RunnableNode {
+    fn run(&self);
+}
+
+pub struct RunnableGraphNode {
+    pub runnable_node: Box<dyn RunnableNode>,
+    pub node: Node,
+}
+
+pub struct RunnableGraph {
+    pub name: String,
+    pub nodes: Vec<RunnableGraphNode>,
+}
+
+impl RunnableGraph {
+    pub fn from_graph(graph: &Graph) -> RunnableGraph {
+        RunnableGraph {
+            name: graph.name.clone(),
+            nodes: graph
+                .nodes
+                .iter()
+                .map(|node| {
+                    let runnable_graph_node: RunnableGraphNode = node.clone().into();
+                    runnable_graph_node
+                })
+                .collect_vec(),
+        }
+    }
+}