feat(engine): dot notation resolution for state paths

mohebifar · mohebifar · commit 52fbb40416de · 2025-09-10T12:07:05.000-07:00
diff --git a/crates/core/src/engine.rs b/crates/core/src/engine.rs
@@ -1817,7 +1817,8 @@ impl Engine {
             .save_task(&current_task)
             .await?;
 
-        debug!("Command output: {output}");
+        info!("Step output:");
+        info!("{output}");
 
         let outputs = read_to_string(&state_outputs_path).await?;
 
diff --git a/crates/models/src/variable.rs b/crates/models/src/variable.rs
@@ -5,6 +5,44 @@ use std::collections::HashMap;
 use crate::error::Error;
 use crate::Result;
 
+/// Resolve a dot notation path in a HashMap<String, Value>
+/// For example: resolve_state_path(state, "x.y.0.z") gets state["x"]["y"][0]["z"]
+pub fn resolve_state_path<'a>(state: &'a HashMap<String, Value>, path: &str) -> Result<&'a Value> {
+    let parts: Vec<&str> = path.split('.').collect();
+
+    if parts.is_empty() {
+        return Err(Error::VariableResolution("Empty path".to_string()));
+    }
+
+    let root_key = parts[0];
+    let mut current_value = state
+        .get(root_key)
+        .ok_or_else(|| Error::VariableResolution(format!("State key not found: {root_key}")))?;
+
+    for part in &parts[1..] {
+        current_value = match current_value {
+            Value::Object(obj) => obj.get(*part).ok_or_else(|| {
+                Error::VariableResolution(format!("Object key not found: {part}"))
+            })?,
+            Value::Array(arr) => {
+                let index: usize = part.parse().map_err(|_| {
+                    Error::VariableResolution(format!("Invalid array index: {part}"))
+                })?;
+                arr.get(index).ok_or_else(|| {
+                    Error::VariableResolution(format!("Array index out of bounds: {index}"))
+                })?
+            }
+            _ => {
+                return Err(Error::VariableResolution(format!(
+                    "Cannot traverse path '{part}' - value is not an object or array"
+                )));
+            }
+        };
+    }
+
+    Ok(current_value)
+}
+
 /// Resolve variables in a string
 pub fn resolve_variables(
     input: &str,
@@ -28,9 +66,7 @@ pub fn resolve_variables(
                     Error::VariableResolution(format!("Parameter not found: {name}"))
                 })?
             } else if let Some(name) = inner.strip_prefix("state.") {
-                let value = state.get(name).ok_or_else(|| {
-                    Error::VariableResolution(format!("State value not found: {name}"))
-                })?;
+                let value = resolve_state_path(state, name)?;
                 serde_json::to_string(value).unwrap()
             } else {
                 return Err(Error::VariableResolution(format!(
diff --git a/crates/scheduler/src/lib.rs b/crates/scheduler/src/lib.rs
@@ -1,5 +1,6 @@
 use std::collections::{HashMap, HashSet};
 
+use butterflow_models::variable::resolve_state_path;
 use log::{debug, warn};
 #[cfg(feature = "wasm")]
 use serde::Serialize;
@@ -202,7 +203,7 @@ impl Scheduler {
             if let Some(Strategy {
                 r#type: StrategyType::Matrix,
                 values,
-                from_state: _, // Corrected variable name
+                from_state: _,
             }) = &node.strategy
             {
                 // Create a master task for the matrix
@@ -276,27 +277,30 @@ impl Scheduler {
                 }
 
                 // Get the current value from the state
-                let state_value = state.get(state_key);
+                let state_value = resolve_state_path(state, state_key);
 
                 // --- Calculate Values for Current State Items ---
                 let mut current_item_values = Vec::new();
 
                 match state_value {
-                    Some(serde_json::Value::Array(items)) => {
+                    Ok(serde_json::Value::Array(items)) => {
                         for item in items {
                             current_item_values.push(item.clone());
                         }
                         debug!("Found {} items in state array '{}'", items.len(), state_key);
                     }
-                    Some(serde_json::Value::Object(_obj)) => {
+                    Ok(serde_json::Value::Object(_obj)) => {
                         // Object mapping not fully supported yet
                         warn!("Matrix from_state for object key '{state_key}' is not yet fully supported, skipping.");
-                        continue; // Skip this node
+                        continue;
                     }
-                    _ => {
+                    Ok(_) => {
                         // State key not found or not an array/object
                         debug!("State key '{}' for matrix node '{}' is missing or not an array/object.", state_key, node.id);
                     }
+                    Err(_) => {
+                        debug!("Could not resolve state path '{state_key}'");
+                    }
                 }
 
                 // --- Compare with Existing Tasks ---
