"""Repository for profile_workflows and workflow_nodes.""" from __future__ import annotations import json from typing import Any from backend.dto.workflow_dto import ProfileWorkflow, WorkflowBranch, WorkflowHistoryEntry, WorkflowNode from database.db_helper import Database WORKFLOW_COLUMNS = """ workflow_id, profile_id, workflow_type, display_name, mode, status, current_node_id, current_branch, session_key, metadata_json, created_at, updated_at """ NODE_COLUMNS = """ node_id, workflow_id, node_key, title, description, step_name, node_type, status, branch_name, prompt, negative_prompt, model_route, selected_image_id, sort_order, metadata_json, created_at, updated_at """ HISTORY_COLUMNS = """ history_id, profile_id, workflow_id, node_id, image_id, branch_name, action, title, prompt, metadata_json, created_at """ BRANCH_COLUMNS = """ branch_id, workflow_id, branch_name, base_branch_name, base_node_id, status, metadata_json, created_at, updated_at """ class WorkflowRepository: def __init__(self, database: Database): self.database = database @property def placeholder(self) -> str: return self.database._placeholder def create_workflow(self, payload: dict[str, Any]) -> ProfileWorkflow: workflow, _ = self.create_workflow_with_nodes(payload, []) return workflow def create_workflow_with_nodes( self, payload: dict[str, Any], node_payloads: list[dict[str, Any]], ) -> tuple[ProfileWorkflow, list[WorkflowNode]]: placeholder = self.placeholder conn = self.database.connect() try: _insert_workflow(conn, placeholder, payload) for node_payload in node_payloads: _insert_node(conn, placeholder, node_payload) conn.commit() except Exception: conn.rollback() raise finally: conn.close() workflow = self.get_workflow(payload["workflow_id"]) if workflow is None: raise RuntimeError("workflow was inserted but could not be read back") return workflow, self.list_nodes(workflow.workflow_id) def get_workflow(self, workflow_id: str) -> ProfileWorkflow | None: placeholder = self.placeholder conn = self.database.connect() try: row = conn.execute( f"SELECT {WORKFLOW_COLUMNS} FROM profile_workflows WHERE workflow_id = {placeholder}", (workflow_id,), ).fetchone() finally: conn.close() return _row_to_workflow(row) if row else None def list_workflows(self, profile_id: str, status: str | None = None) -> list[ProfileWorkflow]: where = [f"profile_id = {self.placeholder}"] params: list[Any] = [profile_id] if status: where.append(f"status = {self.placeholder}") params.append(status) conn = self.database.connect() try: rows = conn.execute( f""" SELECT {WORKFLOW_COLUMNS} FROM profile_workflows WHERE {" AND ".join(where)} ORDER BY updated_at DESC, created_at DESC """, tuple(params), ).fetchall() finally: conn.close() return [_row_to_workflow(row) for row in rows] def update_workflow(self, workflow_id: str, payload: dict[str, Any]) -> ProfileWorkflow | None: allowed = { "display_name", "mode", "status", "current_node_id", "current_branch", "session_key", "metadata", } assignments: list[str] = [] params: list[Any] = [] placeholder = self.placeholder for key in allowed: if key not in payload: continue column = "metadata_json" if key == "metadata" else key value = _json_or_none(payload[key]) if key == "metadata" else payload[key] assignments.append(f"{column} = {placeholder}") params.append(value) if not assignments: return self.get_workflow(workflow_id) assignments.append("updated_at = CURRENT_TIMESTAMP") params.append(workflow_id) conn = self.database.connect() try: conn.execute( f""" UPDATE profile_workflows SET {", ".join(assignments)} WHERE workflow_id = {placeholder} """, tuple(params), ) conn.commit() finally: conn.close() return self.get_workflow(workflow_id) def update_workflow_if_status( self, workflow_id: str, expected_statuses: set[str] | tuple[str, ...] | list[str], payload: dict[str, Any], ) -> ProfileWorkflow | None: normalized_statuses = tuple( sorted({str(status).strip() for status in expected_statuses if str(status).strip()}) ) if not normalized_statuses: return None allowed = { "display_name", "mode", "status", "current_node_id", "current_branch", "session_key", "metadata", } assignments: list[str] = [] params: list[Any] = [] placeholder = self.placeholder for key in allowed: if key not in payload: continue column = "metadata_json" if key == "metadata" else key value = _json_or_none(payload[key]) if key == "metadata" else payload[key] assignments.append(f"{column} = {placeholder}") params.append(value) if not assignments: workflow = self.get_workflow(workflow_id) return workflow if workflow and workflow.status in normalized_statuses else None assignments.append("updated_at = CURRENT_TIMESTAMP") status_placeholders = ", ".join(placeholder for _ in normalized_statuses) params.extend([workflow_id, *normalized_statuses]) conn = self.database.connect() try: cursor = conn.execute( f""" UPDATE profile_workflows SET {", ".join(assignments)} WHERE workflow_id = {placeholder} AND status IN ({status_placeholders}) """, tuple(params), ) changed = int(cursor.rowcount or 0) > 0 conn.commit() finally: conn.close() return self.get_workflow(workflow_id) if changed else None def create_node(self, payload: dict[str, Any]) -> WorkflowNode: placeholder = self.placeholder conn = self.database.connect() try: _insert_node(conn, placeholder, payload) conn.commit() finally: conn.close() node = self.get_node(payload["node_id"]) if node is None: raise RuntimeError("node was inserted but could not be read back") return node def get_node(self, node_id: str) -> WorkflowNode | None: placeholder = self.placeholder conn = self.database.connect() try: row = conn.execute( f"SELECT {NODE_COLUMNS} FROM workflow_nodes WHERE node_id = {placeholder}", (node_id,), ).fetchone() finally: conn.close() return _row_to_node(row) if row else None def list_nodes(self, workflow_id: str, branch_name: str | None = None) -> list[WorkflowNode]: placeholder = self.placeholder where = [f"workflow_id = {placeholder}"] params: list[Any] = [workflow_id] if branch_name: where.append(f"branch_name = {placeholder}") params.append(branch_name) conn = self.database.connect() try: rows = conn.execute( f""" SELECT {NODE_COLUMNS} FROM workflow_nodes WHERE {" AND ".join(where)} ORDER BY sort_order ASC, created_at ASC """, tuple(params), ).fetchall() finally: conn.close() return [_row_to_node(row) for row in rows] def update_node(self, node_id: str, payload: dict[str, Any]) -> WorkflowNode | None: allowed = { "title", "description", "step_name", "node_type", "status", "branch_name", "prompt", "negative_prompt", "model_route", "selected_image_id", "sort_order", "metadata", } assignments: list[str] = [] params: list[Any] = [] placeholder = self.placeholder for key in allowed: if key not in payload: continue column = "metadata_json" if key == "metadata" else key value = _json_or_none(payload[key]) if key == "metadata" else payload[key] assignments.append(f"{column} = {placeholder}") params.append(value) if not assignments: return self.get_node(node_id) assignments.append("updated_at = CURRENT_TIMESTAMP") params.append(node_id) conn = self.database.connect() try: conn.execute( f""" UPDATE workflow_nodes SET {", ".join(assignments)} WHERE node_id = {placeholder} """, tuple(params), ) conn.commit() finally: conn.close() return self.get_node(node_id) def update_node_if_status( self, node_id: str, expected_statuses: set[str] | tuple[str, ...] | list[str], payload: dict[str, Any], ) -> WorkflowNode | None: normalized_statuses = tuple( sorted({str(status).strip() for status in expected_statuses if str(status).strip()}) ) if not normalized_statuses: return None allowed = { "title", "description", "step_name", "node_type", "status", "branch_name", "prompt", "negative_prompt", "model_route", "selected_image_id", "sort_order", "metadata", } assignments: list[str] = [] params: list[Any] = [] placeholder = self.placeholder for key in allowed: if key not in payload: continue column = "metadata_json" if key == "metadata" else key value = _json_or_none(payload[key]) if key == "metadata" else payload[key] assignments.append(f"{column} = {placeholder}") params.append(value) if not assignments: node = self.get_node(node_id) return node if node and node.status in normalized_statuses else None assignments.append("updated_at = CURRENT_TIMESTAMP") status_placeholders = ", ".join(placeholder for _ in normalized_statuses) params.extend([node_id, *normalized_statuses]) conn = self.database.connect() try: cursor = conn.execute( f""" UPDATE workflow_nodes SET {", ".join(assignments)} WHERE node_id = {placeholder} AND status IN ({status_placeholders}) """, tuple(params), ) changed = int(cursor.rowcount or 0) > 0 conn.commit() finally: conn.close() return self.get_node(node_id) if changed else None def create_history(self, payload: dict[str, Any]) -> WorkflowHistoryEntry: placeholder = self.placeholder conn = self.database.connect() try: conn.execute( f""" INSERT INTO workflow_history ( history_id, profile_id, workflow_id, node_id, image_id, branch_name, action, title, prompt, metadata_json ) VALUES ( {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder} ) """, ( payload["history_id"], payload.get("profile_id"), payload["workflow_id"], payload.get("node_id"), payload.get("image_id"), payload.get("branch_name", "main"), payload["action"], payload.get("title"), payload.get("prompt"), _json_or_none(payload.get("metadata")), ), ) conn.commit() finally: conn.close() history = self.get_history(payload["history_id"]) if history is None: raise RuntimeError("workflow history was inserted but could not be read back") return history def get_history(self, history_id: str) -> WorkflowHistoryEntry | None: placeholder = self.placeholder conn = self.database.connect() try: row = conn.execute( f"SELECT {HISTORY_COLUMNS} FROM workflow_history WHERE history_id = {placeholder}", (history_id,), ).fetchone() finally: conn.close() return _row_to_history(row) if row else None def list_history(self, workflow_id: str, node_id: str | None = None) -> list[WorkflowHistoryEntry]: placeholder = self.placeholder where = [f"workflow_id = {placeholder}"] params: list[Any] = [workflow_id] if node_id: where.append(f"node_id = {placeholder}") params.append(node_id) conn = self.database.connect() try: rows = conn.execute( f""" SELECT {HISTORY_COLUMNS} FROM workflow_history WHERE {" AND ".join(where)} ORDER BY created_at DESC """, tuple(params), ).fetchall() finally: conn.close() return [_row_to_history(row) for row in rows] def create_branch(self, payload: dict[str, Any]) -> WorkflowBranch: branch, _ = self.create_branch_with_nodes(payload, []) return branch def create_branch_with_nodes( self, payload: dict[str, Any], node_payloads: list[dict[str, Any]], ) -> tuple[WorkflowBranch, list[WorkflowNode]]: """Create a branch and all physical node copies in one transaction.""" placeholder = self.placeholder conn = self.database.connect() try: conn.execute( f""" INSERT INTO workflow_branches ( branch_id, workflow_id, branch_name, base_branch_name, base_node_id, status, metadata_json ) VALUES ( {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder} ) """, ( payload["branch_id"], payload["workflow_id"], payload["branch_name"], payload.get("base_branch_name"), payload.get("base_node_id"), payload.get("status", "active"), _json_or_none(payload.get("metadata")), ), ) for node_payload in node_payloads: _insert_node(conn, placeholder, node_payload) conn.commit() except Exception: conn.rollback() raise finally: conn.close() branch = self.get_branch(payload["workflow_id"], payload["branch_name"]) if branch is None: raise RuntimeError("workflow branch was inserted but could not be read back") copied_nodes = [ node for node_payload in node_payloads if (node := self.get_node(node_payload["node_id"])) is not None ] if len(copied_nodes) != len(node_payloads): raise RuntimeError("workflow branch nodes were inserted but could not be read back") return branch, copied_nodes def get_branch(self, workflow_id: str, branch_name: str) -> WorkflowBranch | None: placeholder = self.placeholder conn = self.database.connect() try: row = conn.execute( f""" SELECT {BRANCH_COLUMNS} FROM workflow_branches WHERE workflow_id = {placeholder} AND branch_name = {placeholder} """, (workflow_id, branch_name), ).fetchone() finally: conn.close() return _row_to_branch(row) if row else None def list_branches(self, workflow_id: str) -> list[WorkflowBranch]: placeholder = self.placeholder conn = self.database.connect() try: rows = conn.execute( f""" SELECT {BRANCH_COLUMNS} FROM workflow_branches WHERE workflow_id = {placeholder} ORDER BY created_at ASC """, (workflow_id,), ).fetchall() finally: conn.close() return [_row_to_branch(row) for row in rows] def _insert_workflow(conn, placeholder: str, payload: dict[str, Any]) -> None: conn.execute( f""" INSERT INTO profile_workflows ( workflow_id, profile_id, workflow_type, display_name, mode, status, current_node_id, current_branch, session_key, metadata_json ) VALUES ( {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder} ) """, ( payload["workflow_id"], payload["profile_id"], payload["workflow_type"], payload["display_name"], payload.get("mode"), payload.get("status", "draft"), payload.get("current_node_id"), payload.get("current_branch", "main"), payload.get("session_key"), _json_or_none(payload.get("metadata")), ), ) def _insert_node(conn, placeholder: str, payload: dict[str, Any]) -> None: conn.execute( f""" INSERT INTO workflow_nodes ( node_id, workflow_id, node_key, title, description, step_name, node_type, status, branch_name, prompt, negative_prompt, model_route, selected_image_id, sort_order, metadata_json ) VALUES ( {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder} ) """, ( payload["node_id"], payload["workflow_id"], payload["node_key"], payload["title"], payload.get("description"), payload.get("step_name"), payload.get("node_type", "generation"), payload.get("status", "draft"), payload.get("branch_name", "main"), payload.get("prompt"), payload.get("negative_prompt"), payload.get("model_route"), payload.get("selected_image_id"), int(payload.get("sort_order", 0)), _json_or_none(payload.get("metadata")), ), ) def _row_to_workflow(row) -> ProfileWorkflow: return ProfileWorkflow( workflow_id=row["workflow_id"], profile_id=row["profile_id"], workflow_type=row["workflow_type"], display_name=row["display_name"], mode=row["mode"], status=row["status"], current_node_id=row["current_node_id"], current_branch=row["current_branch"] or "main", session_key=row["session_key"], metadata=_json_loads(row["metadata_json"]), created_at=str(row["created_at"]), updated_at=str(row["updated_at"]), ) def _row_to_node(row) -> WorkflowNode: return WorkflowNode( node_id=row["node_id"], workflow_id=row["workflow_id"], node_key=row["node_key"], title=row["title"], description=row["description"], step_name=row["step_name"], node_type=row["node_type"], status=row["status"], branch_name=row["branch_name"] or "main", prompt=row["prompt"], negative_prompt=row["negative_prompt"], model_route=row["model_route"], selected_image_id=row["selected_image_id"], sort_order=int(row["sort_order"] or 0), metadata=_json_loads(row["metadata_json"]), created_at=str(row["created_at"]), updated_at=str(row["updated_at"]), ) def _row_to_history(row) -> WorkflowHistoryEntry: return WorkflowHistoryEntry( history_id=row["history_id"], profile_id=row["profile_id"], workflow_id=row["workflow_id"], node_id=row["node_id"], image_id=row["image_id"], branch_name=row["branch_name"] or "main", action=row["action"], title=row["title"], prompt=row["prompt"], metadata=_json_loads(row["metadata_json"]), created_at=str(row["created_at"]), ) def _row_to_branch(row) -> WorkflowBranch: return WorkflowBranch( branch_id=row["branch_id"], workflow_id=row["workflow_id"], branch_name=row["branch_name"], base_branch_name=row["base_branch_name"], base_node_id=row["base_node_id"], status=row["status"], metadata=_json_loads(row["metadata_json"]), created_at=str(row["created_at"]), updated_at=str(row["updated_at"]), ) def _json_or_none(value: Any | None) -> str | None: if value is None: return None return json.dumps(value, ensure_ascii=False, sort_keys=True) def _json_loads(value: str | None) -> dict[str, Any]: if not value: return {} return json.loads(value)