feat: evaluation reference map trace; (#28)

* feat: evaluation reference map trace;

* fix: cargo fmt

* reduce performance penalty;

core/engine/src/handler/table/zen.rs

@@ -12,6 +12,7 @@ use zen_expression::isolate::Isolate;
 #[derive(Debug, Serialize)]
 struct RowResult {
     rule: Option<HashMap<String, String>>,
+    reference_map: Option<HashMap<String, Value>>,
     index: usize,
     #[serde(skip)]
     output: RowOutput,
@@ -134,6 +135,7 @@ impl<'a> DecisionTableHandler<'a> {
             return Some(RowResult {
                 output: outputs,
                 rule: None,
+                reference_map: None,
                 index,
             });
         }
@@ -144,16 +146,22 @@ impl<'a> DecisionTableHandler<'a> {
         };
 
         let mut expressions: HashMap<String, String> = Default::default();
+        let mut reference_map: HashMap<String, Value> = Default::default();
         expressions.insert("_id".to_string(), rule_id.clone());
 
         for input in &content.inputs {
             let rule_value = rule.get(input.id.as_str())?;
             expressions.insert(input.field.clone(), rule_value.clone());
+
+            if let Some(reference) = self.isolate.get_reference(input.field.as_str()) {
+                reference_map.insert(input.field.clone(), reference);
+            }
         }
 
         Some(RowResult {
             output: outputs,
             rule: Some(expressions),
+            reference_map: Some(reference_map),
             index,
         })
     }

core/expression/src/isolate.rs

@@ -118,6 +118,13 @@ impl<'a> Isolate<'a> {
         Ok(())
     }
 
+    pub fn get_reference(&self, reference: &'a str) -> Option<Value> {
+        let refs = self.references.borrow();
+        let var = refs.get(reference)?;
+
+        (*var).try_into().ok()
+    }
+
     pub fn run_standard(&self, source: &'a str) -> Result<Value, IsolateError> {
         self.clear();