Add runnable graph spec

src/filter.rs

@@ -1,6 +1,6 @@
 use std::{collections::HashMap, io::Read, str::FromStr};
 
-use crate::io::RecordSerializer;
+use crate::{graph::RunnableNode, io::RecordSerializer};
 
 pub enum Comparator<T: PartialOrd> {
     Equal(T),
@@ -77,3 +77,9 @@ pub fn filter_file(
     }
     Ok(())
 }
+
+pub struct FilterNodeRunner {}
+
+impl RunnableNode for FilterNodeRunner {
+    fn run(&self) {}
+}

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(),
+        }
+    }
+}

src/lib.rs

@@ -4,25 +4,19 @@ pub use self::move_money::*;
 use std::ffi::c_char;
 use std::ffi::CStr;
 use std::ffi::CString;
-
 mod overhead_allocation;
 pub use self::overhead_allocation::*;
-
 mod products;
 pub use self::products::create_products;
 pub use self::products::csv::SourceType;
-
 mod shared_models;
 pub use self::shared_models::*;
-
+pub mod code_rule;
-pub mod link;
-
 pub mod filter;
-
-pub mod upload_to_db;
-
-mod io;
 mod graph;
+mod io;
+pub mod link;
+pub mod upload_to_db;
 
 #[no_mangle]
 pub extern "C" fn move_money_from_text(
@@ -74,7 +68,7 @@ pub extern "C" fn move_money_from_file(
     let safe_lines = unwrap_c_char(lines);
     let safe_accounts = unwrap_c_char(accounts);
     let safe_cost_centres = unwrap_c_char(cost_centres);
-    move_money_2()
+    // move_money_2()
     // move_money(
     //     ,
     //     &mut csv::Reader::from_reader(safe_lines.to_str().unwrap()),