Add validation for service methods

Signed-off-by: Lee Smet <lee.smet@hotmail.com>

src/storage/redis.rs

@@ -6,7 +6,9 @@ use serde::de::DeserializeOwned;
 use serde_json::{Map as JsonMap, Value};
 use tokio::sync::Mutex;
 
-use crate::models::{Actor, Context, Flow, Job, JobStatus, Message, Runner};
+use crate::models::{
+    Actor, Context, Flow, FlowStatus, Job, JobStatus, Message, MessageStatus, Runner,
+};
 
 type Result<T> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;
 
@@ -303,4 +305,232 @@ impl RedisDriver {
         let key = Self::message_key(caller_id, id);
         self.hget_model(db, &key).await
     }
+
+    // -----------------------------
+    // Partial update helpers
+    // -----------------------------
+
+    /// Flow: update only status and updated_at
+    pub async fn update_flow_status(&self, db: u32, id: u32, status: FlowStatus) -> Result<()> {
+        let mut cm = self.manager_for_db(db).await?;
+        let key = Self::flow_key(id);
+
+        let status_str = match serde_json::to_value(&status)? {
+            Value::String(s) => s,
+            v => v.to_string(),
+        };
+        let ts = crate::time::current_timestamp();
+
+        let pairs = vec![
+            ("status".to_string(), status_str),
+            ("updated_at".to_string(), ts.to_string()),
+        ];
+        let _: usize = cm.hset_multiple(key, &pairs).await?;
+        Ok(())
+    }
+
+    /// Message: update only status and updated_at
+    pub async fn update_message_status(
+        &self,
+        db: u32,
+        caller_id: u32,
+        id: u32,
+        status: MessageStatus,
+    ) -> Result<()> {
+        let mut cm = self.manager_for_db(db).await?;
+        let key = Self::message_key(caller_id, id);
+
+        let status_str = match serde_json::to_value(&status)? {
+            Value::String(s) => s,
+            v => v.to_string(),
+        };
+        let ts = crate::time::current_timestamp();
+
+        let pairs = vec![
+            ("status".to_string(), status_str),
+            ("updated_at".to_string(), ts.to_string()),
+        ];
+        let _: usize = cm.hset_multiple(key, &pairs).await?;
+        Ok(())
+    }
+
+    /// Flow: merge env_vars map and bump updated_at
+    pub async fn update_flow_env_vars_merge(
+        &self,
+        db: u32,
+        id: u32,
+        patch: StdHashMap<String, String>,
+    ) -> Result<()> {
+        let mut cm = self.manager_for_db(db).await?;
+        let key = Self::flow_key(id);
+
+        let current: Option<String> = cm.hget(&key, "env_vars").await.ok();
+        let mut obj = match current
+            .and_then(|s| serde_json::from_str::<Value>(&s).ok())
+            .and_then(|v| v.as_object().cloned())
+        {
+            Some(m) => m,
+            None => JsonMap::new(),
+        };
+
+        for (k, v) in patch {
+            obj.insert(k, Value::String(v));
+        }
+
+        let env_vars_str = Value::Object(obj).to_string();
+        let ts = crate::time::current_timestamp();
+        let pairs = vec![
+            ("env_vars".to_string(), env_vars_str),
+            ("updated_at".to_string(), ts.to_string()),
+        ];
+        let _: usize = cm.hset_multiple(key, &pairs).await?;
+        Ok(())
+    }
+
+    /// Flow: merge result map and bump updated_at
+    pub async fn update_flow_result_merge(
+        &self,
+        db: u32,
+        id: u32,
+        patch: StdHashMap<String, String>,
+    ) -> Result<()> {
+        let mut cm = self.manager_for_db(db).await?;
+        let key = Self::flow_key(id);
+
+        let current: Option<String> = cm.hget(&key, "result").await.ok();
+        let mut obj = match current
+            .and_then(|s| serde_json::from_str::<Value>(&s).ok())
+            .and_then(|v| v.as_object().cloned())
+        {
+            Some(m) => m,
+            None => JsonMap::new(),
+        };
+
+        for (k, v) in patch {
+            obj.insert(k, Value::String(v));
+        }
+
+        let result_str = Value::Object(obj).to_string();
+        let ts = crate::time::current_timestamp();
+        let pairs = vec![
+            ("result".to_string(), result_str),
+            ("updated_at".to_string(), ts.to_string()),
+        ];
+        let _: usize = cm.hset_multiple(key, &pairs).await?;
+        Ok(())
+    }
+
+    /// Job: merge env_vars map and bump updated_at
+    pub async fn update_job_env_vars_merge(
+        &self,
+        db: u32,
+        caller_id: u32,
+        id: u32,
+        patch: StdHashMap<String, String>,
+    ) -> Result<()> {
+        let mut cm = self.manager_for_db(db).await?;
+        let key = Self::job_key(caller_id, id);
+
+        let current: Option<String> = cm.hget(&key, "env_vars").await.ok();
+        let mut obj = match current
+            .and_then(|s| serde_json::from_str::<Value>(&s).ok())
+            .and_then(|v| v.as_object().cloned())
+        {
+            Some(m) => m,
+            None => JsonMap::new(),
+        };
+
+        for (k, v) in patch {
+            obj.insert(k, Value::String(v));
+        }
+
+        let env_vars_str = Value::Object(obj).to_string();
+        let ts = crate::time::current_timestamp();
+        let pairs = vec![
+            ("env_vars".to_string(), env_vars_str),
+            ("updated_at".to_string(), ts.to_string()),
+        ];
+        let _: usize = cm.hset_multiple(key, &pairs).await?;
+        Ok(())
+    }
+
+    /// Job: merge result map and bump updated_at
+    pub async fn update_job_result_merge(
+        &self,
+        db: u32,
+        caller_id: u32,
+        id: u32,
+        patch: StdHashMap<String, String>,
+    ) -> Result<()> {
+        let mut cm = self.manager_for_db(db).await?;
+        let key = Self::job_key(caller_id, id);
+
+        let current: Option<String> = cm.hget(&key, "result").await.ok();
+        let mut obj = match current
+            .and_then(|s| serde_json::from_str::<Value>(&s).ok())
+            .and_then(|v| v.as_object().cloned())
+        {
+            Some(m) => m,
+            None => JsonMap::new(),
+        };
+
+        for (k, v) in patch {
+            obj.insert(k, Value::String(v));
+        }
+
+        let result_str = Value::Object(obj).to_string();
+        let ts = crate::time::current_timestamp();
+        let pairs = vec![
+            ("result".to_string(), result_str),
+            ("updated_at".to_string(), ts.to_string()),
+        ];
+        let _: usize = cm.hset_multiple(key, &pairs).await?;
+        Ok(())
+    }
+
+    /// Flow: set jobs list and bump updated_at
+    pub async fn update_flow_jobs_set(&self, db: u32, id: u32, new_jobs: Vec<u32>) -> Result<()> {
+        let mut cm = self.manager_for_db(db).await?;
+        let key = Self::flow_key(id);
+
+        let jobs_str = serde_json::to_string(&new_jobs)?;
+        let ts = crate::time::current_timestamp();
+        let pairs = vec![
+            ("jobs".to_string(), jobs_str),
+            ("updated_at".to_string(), ts.to_string()),
+        ];
+        let _: usize = cm.hset_multiple(key, &pairs).await?;
+        Ok(())
+    }
+
+    /// Message: append logs (no dedup) and bump updated_at
+    pub async fn append_message_logs(
+        &self,
+        db: u32,
+        caller_id: u32,
+        id: u32,
+        new_logs: Vec<String>,
+    ) -> Result<()> {
+        let mut cm = self.manager_for_db(db).await?;
+        let key = Self::message_key(caller_id, id);
+
+        let current: Option<String> = cm.hget(&key, "logs").await.ok();
+        let mut arr: Vec<Value> = current
+            .and_then(|s| serde_json::from_str::<Value>(&s).ok())
+            .and_then(|v| v.as_array().cloned())
+            .unwrap_or_default();
+
+        for l in new_logs {
+            arr.push(Value::String(l));
+        }
+
+        let logs_str = Value::Array(arr).to_string();
+        let ts = crate::time::current_timestamp();
+        let pairs = vec![
+            ("logs".to_string(), logs_str),
+            ("updated_at".to_string(), ts.to_string()),
+        ];
+        let _: usize = cm.hset_multiple(key, &pairs).await?;
+        Ok(())
+    }
 }