2026-07-04 23:31:29 +08:00
|
|
|
"""Repository for profile_workflows and workflow_nodes."""
|
|
|
|
|
|
|
|
|
|
from __future__ import annotations
|
|
|
|
|
|
|
|
|
|
import json
|
|
|
|
|
from typing import Any
|
|
|
|
|
|
2026-07-05 09:43:16 +08:00
|
|
|
from backend.dto.workflow_dto import ProfileWorkflow, WorkflowBranch, WorkflowHistoryEntry, WorkflowNode
|
2026-07-04 23:31:29 +08:00
|
|
|
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
|
|
|
|
|
"""
|
|
|
|
|
|
2026-07-05 09:39:17 +08:00
|
|
|
HISTORY_COLUMNS = """
|
|
|
|
|
history_id,
|
|
|
|
|
profile_id,
|
|
|
|
|
workflow_id,
|
|
|
|
|
node_id,
|
|
|
|
|
image_id,
|
|
|
|
|
branch_name,
|
|
|
|
|
action,
|
|
|
|
|
title,
|
|
|
|
|
prompt,
|
|
|
|
|
metadata_json,
|
|
|
|
|
created_at
|
|
|
|
|
"""
|
|
|
|
|
|
2026-07-05 09:43:16 +08:00
|
|
|
BRANCH_COLUMNS = """
|
|
|
|
|
branch_id,
|
|
|
|
|
workflow_id,
|
|
|
|
|
branch_name,
|
|
|
|
|
base_branch_name,
|
|
|
|
|
base_node_id,
|
|
|
|
|
status,
|
|
|
|
|
metadata_json,
|
|
|
|
|
created_at,
|
|
|
|
|
updated_at
|
|
|
|
|
"""
|
|
|
|
|
|
2026-07-04 23:31:29 +08:00
|
|
|
|
|
|
|
|
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:
|
2026-07-11 21:50:34 +08:00
|
|
|
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]]:
|
2026-07-04 23:31:29 +08:00
|
|
|
placeholder = self.placeholder
|
|
|
|
|
conn = self.database.connect()
|
|
|
|
|
try:
|
2026-07-11 21:50:34 +08:00
|
|
|
_insert_workflow(conn, placeholder, payload)
|
|
|
|
|
for node_payload in node_payloads:
|
|
|
|
|
_insert_node(conn, placeholder, node_payload)
|
2026-07-04 23:31:29 +08:00
|
|
|
conn.commit()
|
2026-07-11 21:50:34 +08:00
|
|
|
except Exception:
|
|
|
|
|
conn.rollback()
|
|
|
|
|
raise
|
2026-07-04 23:31:29 +08:00
|
|
|
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")
|
2026-07-11 21:50:34 +08:00
|
|
|
return workflow, self.list_nodes(workflow.workflow_id)
|
2026-07-04 23:31:29 +08:00
|
|
|
|
|
|
|
|
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)
|
|
|
|
|
|
2026-07-11 21:50:34 +08:00
|
|
|
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] = []
|
2026-07-04 23:31:29 +08:00
|
|
|
placeholder = self.placeholder
|
2026-07-11 21:50:34 +08:00
|
|
|
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])
|
2026-07-04 23:31:29 +08:00
|
|
|
conn = self.database.connect()
|
|
|
|
|
try:
|
2026-07-11 21:50:34 +08:00
|
|
|
cursor = conn.execute(
|
2026-07-04 23:31:29 +08:00
|
|
|
f"""
|
2026-07-11 21:50:34 +08:00
|
|
|
UPDATE profile_workflows
|
|
|
|
|
SET {", ".join(assignments)}
|
|
|
|
|
WHERE workflow_id = {placeholder}
|
|
|
|
|
AND status IN ({status_placeholders})
|
2026-07-04 23:31:29 +08:00
|
|
|
""",
|
2026-07-11 21:50:34 +08:00
|
|
|
tuple(params),
|
2026-07-04 23:31:29 +08:00
|
|
|
)
|
2026-07-11 21:50:34 +08:00
|
|
|
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)
|
2026-07-04 23:31:29 +08:00
|
|
|
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
|
|
|
|
|
|
2026-07-05 09:43:16 +08:00
|
|
|
def list_nodes(self, workflow_id: str, branch_name: str | None = None) -> list[WorkflowNode]:
|
2026-07-04 23:31:29 +08:00
|
|
|
placeholder = self.placeholder
|
2026-07-05 09:43:16 +08:00
|
|
|
where = [f"workflow_id = {placeholder}"]
|
|
|
|
|
params: list[Any] = [workflow_id]
|
|
|
|
|
if branch_name:
|
|
|
|
|
where.append(f"branch_name = {placeholder}")
|
|
|
|
|
params.append(branch_name)
|
2026-07-04 23:31:29 +08:00
|
|
|
conn = self.database.connect()
|
|
|
|
|
try:
|
|
|
|
|
rows = conn.execute(
|
|
|
|
|
f"""
|
|
|
|
|
SELECT {NODE_COLUMNS}
|
|
|
|
|
FROM workflow_nodes
|
2026-07-05 09:43:16 +08:00
|
|
|
WHERE {" AND ".join(where)}
|
2026-07-04 23:31:29 +08:00
|
|
|
ORDER BY sort_order ASC, created_at ASC
|
|
|
|
|
""",
|
2026-07-05 09:43:16 +08:00
|
|
|
tuple(params),
|
2026-07-04 23:31:29 +08:00
|
|
|
).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)
|
|
|
|
|
|
2026-07-11 21:50:34 +08:00
|
|
|
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
|
|
|
|
|
|
2026-07-05 09:39:17 +08:00
|
|
|
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]
|
|
|
|
|
|
2026-07-05 09:43:16 +08:00
|
|
|
def create_branch(self, payload: dict[str, Any]) -> WorkflowBranch:
|
2026-07-15 23:01:07 +08:00
|
|
|
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."""
|
|
|
|
|
|
2026-07-05 09:43:16 +08:00
|
|
|
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")),
|
|
|
|
|
),
|
|
|
|
|
)
|
2026-07-15 23:01:07 +08:00
|
|
|
for node_payload in node_payloads:
|
|
|
|
|
_insert_node(conn, placeholder, node_payload)
|
2026-07-05 09:43:16 +08:00
|
|
|
conn.commit()
|
2026-07-15 23:01:07 +08:00
|
|
|
except Exception:
|
|
|
|
|
conn.rollback()
|
|
|
|
|
raise
|
2026-07-05 09:43:16 +08:00
|
|
|
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")
|
2026-07-15 23:01:07 +08:00
|
|
|
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
|
2026-07-05 09:43:16 +08:00
|
|
|
|
|
|
|
|
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]
|
|
|
|
|
|
2026-07-04 23:31:29 +08:00
|
|
|
|
2026-07-11 21:50:34 +08:00
|
|
|
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")),
|
|
|
|
|
),
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
|
2026-07-04 23:31:29 +08:00
|
|
|
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"]),
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
|
2026-07-05 09:39:17 +08:00
|
|
|
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"]),
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
|
2026-07-05 09:43:16 +08:00
|
|
|
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"]),
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
|
2026-07-04 23:31:29 +08:00
|
|
|
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)
|