Fix workflow editor node compatibility

Author: Y1fe1Zh0u

src/backend/bisheng/api/services/external_workflow.py

@@ -37,6 +37,8 @@ class ExternalWorkflowService:
     _DEFAULT_TARGET_HANDLE = 'left_handle'
     _DEFAULT_HORIZONTAL_NODE_GAP = 320
     _NOTE_NODE_TYPE = NodeType.NOTE.value
+    _EDITOR_FLOW_NODE_TYPE = 'flowNode'
+    _EDITOR_NOTE_NODE_TYPE = 'noteNode'
     _START_NODE_TYPE = NodeType.START.value
     _END_NODE_TYPE = NodeType.END.value
     _SENSITIVE_KEY_PATTERNS = (
@@ -682,6 +684,20 @@ def _build_scaffold_node(cls,
             raise NotFoundError(msg=f'Workflow node template not found: {node_type}')
         return node_payload
 
+    @classmethod
+    def _normalize_editor_node_types(cls, graph_data: dict) -> dict:
+        for node in graph_data.get('nodes', []):
+            if not isinstance(node, dict):
+                continue
+            node_data = node.get('data')
+            if not isinstance(node_data, dict):
+                continue
+            node_type = node_data.get('type')
+            if not node_type:
+                continue
+            node['type'] = cls._EDITOR_NOTE_NODE_TYPE if node_type == cls._NOTE_NODE_TYPE else cls._EDITOR_FLOW_NODE_TYPE
+        return graph_data
+
     @classmethod
     def _ensure_create_graph_scaffold(cls, graph_data: dict) -> dict:
         if not isinstance(graph_data, dict):
@@ -692,6 +708,7 @@ def _ensure_create_graph_scaffold(cls, graph_data: dict) -> dict:
             return graph_data
 
         updated_graph = copy.deepcopy(graph_data)
+        cls._normalize_editor_node_types(updated_graph)
         start_nodes = cls._find_nodes_by_type(updated_graph, cls._START_NODE_TYPE)
         end_nodes = cls._find_nodes_by_type(updated_graph, cls._END_NODE_TYPE)
 
@@ -1042,6 +1059,7 @@ async def update_workflow_draft(cls,
         if name is not None and name != flow.name:
             cls._assert_workflow_name_available(login_user, name, exclude_flow_id=flow.id)
 
+        graph_data = cls._normalize_editor_node_types(copy.deepcopy(graph_data))
         if has_flow_updates:
             if name is not None:
                 flow.name = name

src/backend/bisheng/api/services/flow.py

@@ -37,6 +37,31 @@
 
 class FlowService(BaseService):
 
+    @staticmethod
+    def _normalize_workflow_editor_graph(graph_data: Optional[dict]) -> Optional[dict]:
+        if not isinstance(graph_data, dict):
+            return graph_data
+
+        nodes = graph_data.get('nodes')
+        if not isinstance(nodes, list):
+            return graph_data
+
+        normalized_graph = copy.deepcopy(graph_data)
+        for node in normalized_graph.get('nodes', []):
+            if not isinstance(node, dict):
+                continue
+            node_data = node.get('data')
+            if not isinstance(node_data, dict):
+                continue
+            node_type = node_data.get('type')
+            if not node_type:
+                continue
+            if node.get('type') in {'flowNode', 'noteNode'}:
+                continue
+            node['type'] = 'noteNode' if node_type == 'note' else 'flowNode'
+
+        return normalized_graph
+
     @classmethod
     def get_version_list_by_flow(cls, user: UserPayload, flow_id: str) -> UnifiedResponseModel[List[FlowVersionRead]]:
         """
@@ -233,6 +258,8 @@ async def get_one_flow(cls, login_user: UserPayload, flow_id: str, share_link: U
                 raise UnAuthorizedError()
 
         flow_info.logo = await cls.get_logo_share_link_async(flow_info.logo)
+        if flow_info.flow_type == FlowType.WORKFLOW.value:
+            flow_info.data = cls._normalize_workflow_editor_graph(flow_info.data)
 
         return resp_200(data=flow_info)
 

src/backend/bisheng/workflow/authoring/registry.py

@@ -1012,7 +1012,7 @@ def create_graph_node_payload(node_type: str,
 
     return {
         'id': node_id,
-        'type': node_type,
+        'type': 'noteNode' if node_type == 'note' else 'flowNode',
         'position': {
             'x': position_x,
             'y': position_y,

src/backend/test/test_external_workflow_service.py

@@ -198,6 +198,7 @@ def test_ensure_create_graph_scaffold_builds_minimal_start_end_graph(self):
         graph = ExternalWorkflowService._ensure_create_graph_scaffold({'nodes': [], 'edges': []})
 
         self.assertEqual([node['data']['type'] for node in graph['nodes']], ['start', 'end'])
+        self.assertEqual([node['type'] for node in graph['nodes']], ['flowNode', 'flowNode'])
         self.assertEqual(len(graph['edges']), 1)
         self.assertEqual(graph['edges'][0]['source'], graph['nodes'][0]['id'])
         self.assertEqual(graph['edges'][0]['target'], graph['nodes'][1]['id'])
@@ -224,6 +225,7 @@ def test_ensure_create_graph_scaffold_wraps_initial_node_with_start_and_end(self
         end_id = next(node_id for node_id, node_type in node_types.items() if node_type == 'end')
 
         self.assertEqual(len(graph['nodes']), 3)
+        self.assertEqual([node['type'] for node in graph['nodes']], ['flowNode', 'flowNode', 'flowNode'])
         self.assertEqual(len(graph['edges']), 2)
         self.assertTrue(any(edge['source'] == start_id and edge['target'] == 'input-1' for edge in graph['edges']))
         self.assertTrue(any(edge['source'] == 'input-1' and edge['target'] == end_id for edge in graph['edges']))
@@ -258,6 +260,7 @@ def test_ensure_create_graph_scaffold_adds_condition_routes_to_end(self):
         start_id = next(node_id for node_id, node_type in node_types.items() if node_type == 'start')
         end_id = next(node_id for node_id, node_type in node_types.items() if node_type == 'end')
 
+        self.assertEqual([node['type'] for node in graph['nodes']], ['flowNode', 'flowNode', 'flowNode'])
         self.assertTrue(any(edge['source'] == start_id and edge['target'] == 'condition-1' for edge in graph['edges']))
         self.assertTrue(
             any(
@@ -319,8 +322,41 @@ def fake_get_current_version(flow_id):
         self.assertEqual(version.id, 11)
         scaffold_types = [node['data']['type'] for node in captured['graph_data']['nodes']]
         self.assertEqual(scaffold_types, ['start', 'end'])
+        self.assertEqual([node['type'] for node in captured['graph_data']['nodes']], ['flowNode', 'flowNode'])
         self.assertEqual(len(captured['graph_data']['edges']), 1)
 
+    def test_normalize_workflow_editor_graph_rewrites_legacy_node_types(self):
+        graph = {
+            'nodes': [{
+                'id': 'start-1',
+                'type': 'start',
+                'position': {'x': 0, 'y': 0},
+                'data': {
+                    'id': 'start-1',
+                    'type': 'start',
+                    'name': 'Start',
+                    'group_params': [],
+                },
+            }, {
+                'id': 'end-1',
+                'type': 'end',
+                'position': {'x': 320, 'y': 0},
+                'data': {
+                    'id': 'end-1',
+                    'type': 'end',
+                    'name': 'End',
+                    'group_params': [],
+                },
+            }],
+            'edges': [],
+        }
+
+        normalized = FlowService._normalize_workflow_editor_graph(graph)
+
+        self.assertEqual([node['type'] for node in normalized['nodes']], ['flowNode', 'flowNode'])
+        self.assertEqual([node['data']['type'] for node in normalized['nodes']], ['start', 'end'])
+        self.assertEqual([node['type'] for node in graph['nodes']], ['start', 'end'])
+
     def test_get_existing_external_draft_version_limits_recent_versions(self):
         captured = {'statements': []}
 
@@ -554,6 +590,7 @@ def fake_update_version(version_info):
         self.assertEqual(len(persisted), 1)
         self.assertEqual(len(persisted[0]['nodes']), 2)
         self.assertEqual(persisted[0]['nodes'][1]['id'], node_id)
+        self.assertEqual(persisted[0]['nodes'][1]['type'], 'flowNode')
         self.assertEqual(persisted[0]['nodes'][1]['position'], {'x': 120, 'y': 260})
         self.assertEqual(persisted[0]['nodes'][1]['data']['type'], 'code')
         self.assertEqual(persisted[0]['nodes'][1]['data']['name'], 'Code Node')