@qingflow-tech/qingflow-cli 1.1.49 → 1.1.50-beta.1

package/src/qingflow_mcp/builder_facade/flow_validation.py

@@ -0,0 +1,569 @@
+"""Offline WorkflowSpec validation (product module).
+
+从 ``skills/qingflow-workflow-builder/scripts/validate_flow_spec.py`` 提炼为产品模块，
+skill 脚本改为薄壳引用本模块，防止双源漂移。
+
+校验口径（镜像后端 SpecGraphValidator 与评测结构检查 ``_structural_issues``）：
+
+- JSON Schema 校验：schema 由调用方动态拉取（``/api/workflow/spec/schema``），
+  ``NodeAttrsDTO`` 与 ``WorkflowNodeDTO.attrs`` 的 oneOf 多态判别放宽为 anyOf
+  （判别字段缺失导致误匹配，类型专属校验由自定义 check 完成）；
+- 必要字段、单 applicant、>1 节点须非空边；
+- gateway 条件 / approval / filling / automation / cc / 孤立节点 /
+  入口出边与 sync 深度检查（与 skill 现有实现一致）；
+- **不做 DAG 无环**：驳回边 / 回退边是合法业务语义（eval r2 复盘已固化），
+  检测到环时仅产出 warning，不算 issue。
+
+红线：本模块是纯函数集合，不做任何网络调用；唯一网络调用（schema 拉取）
+由 facade ``flow_validate`` 完成，绝无 POST / 写。
+"""
+
+from __future__ import annotations
+
+from collections import deque
+from copy import deepcopy
+from dataclasses import dataclass, field
+from typing import Any
+
+import jsonschema
+
+
+VALID_RESPONSIBLE_TYPES = {
+    "user",
+    "dept",
+    "role",
+    "applicant",
+    "leader",
+    "formEmail",
+    "formMember",
+    "formDept",
+    "nodeLeader",
+}
+
+
+@dataclass(slots=True)
+class FlowValidationResult:
+    """离线校验结果：issues 非空即失败，warnings 不影响结论。"""
+
+    issues: list[str] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+    node_count: int = 0
+    edge_count: int = 0
+
+    @property
+    def ok(self) -> bool:
+        return not self.issues
+
+
+# ---------------------------------------------------------------------------
+# 预处理
+# ---------------------------------------------------------------------------
+
+
+def strip_nulls(obj: Any) -> Any:
+    """递归删除对象中的 null 值字段，但保留必要字段（如 name）并给默认值。"""
+    if isinstance(obj, dict):
+        result: dict[str, Any] = {}
+        for key, value in obj.items():
+            if value is None:
+                if key == "name":
+                    # name 是必要字段，使用 id 作为默认名称
+                    result[key] = obj.get("id", "unnamed")
+                # role 等可选字段为 null 时直接跳过
+                continue
+            result[key] = strip_nulls(value)
+        return result
+    if isinstance(obj, list):
+        return [strip_nulls(item) for item in obj]
+    return obj
+
+
+def normalize_auto_judges(spec: dict[str, Any]) -> dict[str, Any]:
+    """后端 get 返回的 autoJudges 可能是 [{"rules": [...]}] 格式。
+
+    将其规范化为 OR-of-AND 二维数组 [[{...}]] 格式。
+    """
+    edges = spec.get("edges", {})
+    edge_list = edges.get("edges", []) if isinstance(edges, dict) else edges
+    if isinstance(edge_list, list):
+        for edge in edge_list:
+            condition = edge.get("condition") if isinstance(edge, dict) else None
+            if not isinstance(condition, dict):
+                continue
+            judges = condition.get("autoJudges")
+            if not judges or not isinstance(judges, list):
+                continue
+            normalized: list[Any] = []
+            for item in judges:
+                if isinstance(item, dict) and "rules" in item:
+                    # 格式: {"rules": [...]} → 展开为 [...]
+                    normalized.append(item["rules"])
+                elif isinstance(item, list):
+                    normalized.append(item)
+            if normalized:
+                condition["autoJudges"] = normalized
+    return spec
+
+
+def inject_attrs_type(spec: dict[str, Any]) -> dict[str, Any]:
+    """Schema 中 attrs 的多态判别依赖 type 字段，但实际数据中 type 在父节点。
+
+    为满足 schema 校验，将 node.type 注入到 node.attrs.type 中（仅校验用，不改原数据）。
+    """
+    mutated = deepcopy(spec)
+    for node in mutated.get("nodes", []) or []:
+        if isinstance(node, dict) and isinstance(node.get("attrs"), dict) and "type" not in node["attrs"]:
+            node["attrs"]["type"] = node.get("type", "")
+    return mutated
+
+
+def normalize_spec(spec: dict[str, Any]) -> tuple[list[Any], list[Any]]:
+    """提取 (nodes, edges)：edges 可能是 {"edges": [...]} 容器或直接数组。"""
+    edges = spec.get("edges")
+    if isinstance(edges, dict) and isinstance(edges.get("edges"), list):
+        return list(spec.get("nodes") or []), list(edges["edges"])
+    if isinstance(edges, list):
+        return list(spec.get("nodes") or []), edges
+    return list(spec.get("nodes") or []), []
+
+
+def relax_schema(schema: dict[str, Any]) -> dict[str, Any]:
+    """放宽 NodeAttrsDTO / WorkflowNodeDTO.attrs 的 oneOf → anyOf。
+
+    官方 schema 的 oneOf 多态判别过于严格（GatewayAttrsDTO 和 ApplicantAttrsDTO
+    缺少 required 导致误匹配），类型专属校验由自定义 check 函数完成。
+    """
+    relaxed = deepcopy(schema)
+    defs = relaxed.get("$defs")
+    if isinstance(defs, dict):
+        node_attrs = defs.get("NodeAttrsDTO")
+        if isinstance(node_attrs, dict) and "oneOf" in node_attrs:
+            node_attrs["anyOf"] = node_attrs.pop("oneOf")
+        workflow_node = defs.get("WorkflowNodeDTO")
+        if isinstance(workflow_node, dict):
+            properties = workflow_node.get("properties")
+            attrs = properties.get("attrs") if isinstance(properties, dict) else None
+            if isinstance(attrs, dict) and "oneOf" in attrs:
+                attrs["anyOf"] = attrs.pop("oneOf")
+    return relaxed
+
+
+# ---------------------------------------------------------------------------
+# 校验检查
+# ---------------------------------------------------------------------------
+
+
+def schema_issues(spec: dict[str, Any], schema: dict[str, Any]) -> list[str]:
+    """JSON Schema 校验（先注入 attrs.type 以匹配多态判别）。"""
+    validator = jsonschema.Draft202012Validator(relax_schema(schema))
+    errors = sorted(validator.iter_errors(spec), key=lambda error: error.path)
+    return [
+        f"[Schema] {'.'.join(str(part) for part in error.path) if error.path else '(root)'}: {error.message}"
+        for error in errors
+    ]
+
+
+def check_required_fields(nodes: list[Any], edges: list[Any]) -> list[str]:
+    issues: list[str] = []
+    for node in nodes:
+        if not isinstance(node, dict):
+            issues.append(f"nodes[] 含非对象项: {node!r}")
+            continue
+        for field_name in ("id", "type", "name", "attrs"):
+            if field_name not in node:
+                issues.append(f"节点缺少必要字段 {field_name}: {node.get('id', '?')}")
+    for edge in edges:
+        if not isinstance(edge, dict):
+            issues.append(f"edges[] 含非对象项: {edge!r}")
+            continue
+        for field_name in ("from", "to"):
+            if field_name not in edge:
+                issues.append(f"边缺少必要字段 {field_name}: {edge}")
+    return issues
+
+
+def check_nonempty_graph(nodes: list[Any], edges: list[Any]) -> list[str]:
+    """>1 节点的图必须有非空边（镜像后端 SpecGraphValidator / eval 结构口径）。"""
+    if len(nodes) > 1 and not edges:
+        return [f"[结构] 节点数 {len(nodes)} > 1 但 edges 为空：多节点流程必须显式声明边"]
+    return []
+
+
+def check_cycle_warnings(nodes: list[Any], edges: list[Any]) -> list[str]:
+    """环仅作为 warning（驳回边 / 回退边是合法业务语义，不作为错误）。"""
+    node_ids = {str(node.get("id")) for node in nodes if isinstance(node, dict) and node.get("id") is not None}
+    adjacency: dict[str, list[str]] = {node_id: [] for node_id in node_ids}
+    for edge in edges:
+        if not isinstance(edge, dict):
+            continue
+        source = str(edge.get("from"))
+        target = str(edge.get("to"))
+        if source in node_ids and target in node_ids:
+            adjacency[source].append(target)
+    indegree = {node_id: 0 for node_id in node_ids}
+    for edge in edges:
+        if isinstance(edge, dict) and str(edge.get("to")) in node_ids:
+            indegree[str(edge.get("to"))] += 1
+    queue = deque(node_id for node_id, degree in indegree.items() if degree == 0)
+    visited = 0
+    while queue:
+        current = queue.popleft()
+        visited += 1
+        for target in adjacency[current]:
+            indegree[target] -= 1
+            if indegree[target] == 0:
+                queue.append(target)
+    if visited != len(node_ids):
+        return ["检测到环路：可能由回退边（如审批驳回、gateway 回退）引起，通常是合法的业务需求"]
+    return []
+
+
+def check_applicant(nodes: list[Any]) -> list[str]:
+    """检查有且仅有一个 applicant 节点。"""
+    applicants = [node for node in nodes if isinstance(node, dict) and node.get("type") == "applicant"]
+    if not applicants:
+        return ["缺少 applicant 节点：工作流必须包含一个申请人节点作为入口"]
+    if len(applicants) > 1:
+        ids = [str(applicant.get("id")) for applicant in applicants]
+        return [f"存在多个 applicant 节点: {ids}，只允许一个"]
+    return []
+
+
+def check_gateway_conditions(nodes: list[Any], edges: list[Any]) -> list[str]:
+    """检查 gateway 出边条件。"""
+    issues: list[str] = []
+    gateway_ids = {str(node.get("id")) for node in nodes if isinstance(node, dict) and node.get("type") == "gateway"}
+    nodes_by_id = {
+        str(node.get("id")): node
+        for node in nodes
+        if isinstance(node, dict) and node.get("id") is not None
+    }
+
+    for gateway_id in sorted(gateway_ids):
+        out_edges = [edge for edge in edges if isinstance(edge, dict) and str(edge.get("from")) == gateway_id]
+        gateway_node = nodes_by_id.get(gateway_id) or {}
+        attrs = gateway_node.get("attrs") if isinstance(gateway_node.get("attrs"), dict) else {}
+        gateway_mode = str(attrs.get("mode") or "")
+        # join gateway 允许 0 或 1 条出边（流程终点或汇合后继续）
+        if gateway_mode != "join" and len(out_edges) < 2:
+            issues.append(f"Gateway {gateway_id} 出边数={len(out_edges)}，需要至少 2 条出边")
+            continue
+
+        for edge in out_edges:
+            condition = edge.get("condition")
+            if not isinstance(condition, dict):
+                continue
+            if str(condition.get("kind") or "") != "rules":
+                continue
+            target = str(edge.get("to"))
+            auto_judges = condition.get("autoJudges")
+            if not isinstance(auto_judges, list) or not auto_judges:
+                issues.append(f"Gateway {gateway_id} → {target} 边 kind=rules 但 autoJudges 为空")
+                continue
+            for group_index, group in enumerate(auto_judges):
+                if not isinstance(group, list):
+                    issues.append(f"Gateway {gateway_id} → {target} autoJudges[{group_index}] 不是数组（应为 OR 组）")
+                    continue
+                for rule_index, rule in enumerate(group):
+                    if not isinstance(rule, dict):
+                        issues.append(f"Gateway {gateway_id} → {target} autoJudges[{group_index}][{rule_index}] 不是对象")
+                        continue
+                    if "fieldId" not in rule or "judgeType" not in rule:
+                        issues.append(
+                            f"Gateway {gateway_id} → {target} autoJudges[{group_index}][{rule_index}] 缺少 fieldId 或 judgeType"
+                        )
+    return issues
+
+
+def _check_responsible_item(item: Any, node_label: str) -> list[str]:
+    issues: list[str] = []
+    if not isinstance(item, dict):
+        issues.append(f"{node_label} responsible 中包含非对象项")
+        return issues
+    if "type" not in item:
+        issues.append(f"{node_label} responsible 项缺少 type")
+        return issues
+    responsible_type = item.get("type")
+    if responsible_type not in VALID_RESPONSIBLE_TYPES:
+        issues.append(
+            f"{node_label} responsible type='{responsible_type}' 不合法，可选: {sorted(VALID_RESPONSIBLE_TYPES)}"
+        )
+        return issues
+    if responsible_type == "user" and "uid" not in item:
+        issues.append(f"{node_label} responsible type='user' 缺少 uid（整数）")
+    if responsible_type == "dept" and "deptId" not in item:
+        issues.append(f"{node_label} responsible type='dept' 缺少 deptId（整数）")
+    if responsible_type == "role" and "roleId" not in item:
+        issues.append(f"{node_label} responsible type='role' 缺少 roleId（整数）")
+    if responsible_type in ("leader", "formEmail", "formMember", "formDept") and "queId" not in item:
+        issues.append(f"{node_label} responsible type='{responsible_type}' 缺少 queId（整数）")
+    return issues
+
+
+def _check_responsible_array(attrs: dict[str, Any], node_label: str) -> list[str]:
+    issues: list[str] = []
+    responsible = attrs.get("responsible")
+    if responsible is None:
+        return issues  # 外层已报缺字段
+    if not isinstance(responsible, list):
+        issues.append(f"{node_label} responsible 必须是数组，当前为 {type(responsible).__name__}")
+        return issues
+    if not responsible:
+        issues.append(f"{node_label} responsible 数组至少包含 1 个元素")
+        return issues
+    for item in responsible:
+        issues.extend(_check_responsible_item(item, node_label))
+    return issues
+
+
+def check_approval_nodes(nodes: list[Any]) -> list[str]:
+    """检查审批节点必要字段。"""
+    issues: list[str] = []
+    for node in nodes:
+        if not isinstance(node, dict) or node.get("type") != "approval":
+            continue
+        attrs = node.get("attrs") if isinstance(node.get("attrs"), dict) else {}
+        node_label = f"审批节点 {node.get('id')} ({node.get('name', '')})"
+        if "responsible" not in attrs:
+            issues.append(f"{node_label} 缺少 responsible（审批人）")
+        else:
+            issues.extend(_check_responsible_array(attrs, node_label))
+        if "approveType" not in attrs:
+            issues.append(f"{node_label} 缺少 approveType")
+        if "auditUserType" not in attrs:
+            issues.append(f"{node_label} 缺少 auditUserType")
+    return issues
+
+
+def check_filling_nodes(nodes: list[Any]) -> list[str]:
+    """检查填写节点必要字段。"""
+    issues: list[str] = []
+    for node in nodes:
+        if not isinstance(node, dict) or node.get("type") != "filling":
+            continue
+        attrs = node.get("attrs") if isinstance(node.get("attrs"), dict) else {}
+        node_label = f"填写节点 {node.get('id')} ({node.get('name', '')})"
+        if "responsible" not in attrs:
+            issues.append(f"{node_label} 缺少 responsible（处理人）")
+        else:
+            issues.extend(_check_responsible_array(attrs, node_label))
+    return issues
+
+
+def check_automation_nodes(nodes: list[Any]) -> list[str]:
+    """检查自动化节点配置。"""
+    issues: list[str] = []
+    for node in nodes:
+        if not isinstance(node, dict) or node.get("type") != "automation":
+            continue
+        attrs = node.get("attrs") if isinstance(node.get("attrs"), dict) else {}
+        node_label = f"自动化节点 {node.get('id')} ({node.get('name', '')})"
+        sub_type = str(attrs.get("subType") or "")
+        if not sub_type:
+            issues.append(f"{node_label} 缺少 subType")
+            continue
+        if sub_type == "update":
+            if "appKey" not in attrs:
+                issues.append(f"{node_label} update 缺少 appKey")
+            if "targetFilterRules" not in attrs:
+                issues.append(f"{node_label} update 缺少 targetFilterRules")
+            if "fieldMappings" not in attrs:
+                issues.append(f"{node_label} update 缺少 fieldMappings")
+        elif sub_type == "add":
+            if "appKey" not in attrs:
+                issues.append(f"{node_label} add 缺少 appKey")
+            if "fieldMappings" not in attrs:
+                issues.append(f"{node_label} add 缺少 fieldMappings")
+        elif sub_type == "send_email":
+            if "mailConfig" not in attrs:
+                issues.append(f"{node_label} send_email 缺少 mailConfig")
+            if "mailReceivers" not in attrs:
+                issues.append(f"{node_label} send_email 缺少 mailReceivers")
+        elif sub_type == "http_request":
+            if "remoteRequestConfig" not in attrs:
+                issues.append(f"{node_label} http_request 缺少 remoteRequestConfig")
+        elif sub_type == "ai_":
+            if "aiConfig" not in attrs:
+                issues.append(f"{node_label} AI 节点缺少 aiConfig")
+    return issues
+
+
+def check_cc_nodes(nodes: list[Any]) -> list[str]:
+    """检查抄送节点必要字段。"""
+    issues: list[str] = []
+    for node in nodes:
+        if not isinstance(node, dict) or node.get("type") != "cc":
+            continue
+        attrs = node.get("attrs") if isinstance(node.get("attrs"), dict) else {}
+        if "receivers" not in attrs:
+            issues.append(f"抄送节点 {node.get('id')} 缺少 receivers")
+    return issues
+
+
+def check_orphan_nodes(nodes: list[Any], edges: list[Any]) -> list[str]:
+    """检查孤立节点（无入边且非 applicant）；applicant 节点不应有入边。"""
+    has_incoming = {str(edge.get("to")) for edge in edges if isinstance(edge, dict)}
+    applicants = {
+        str(node.get("id"))
+        for node in nodes
+        if isinstance(node, dict) and node.get("type") == "applicant"
+    }
+    issues: list[str] = []
+    for node in nodes:
+        if not isinstance(node, dict):
+            continue
+        node_id = str(node.get("id"))
+        if node_id in applicants:
+            if node_id in has_incoming:
+                issues.append(f"申请人节点 {node_id} 不应有入边")
+            continue
+        if node_id not in has_incoming:
+            issues.append(f"节点 {node_id} ({node.get('name', '')}) 缺少入边（孤立节点）")
+    return issues
+
+
+def check_routing_entry_and_sync(nodes: list[Any], edges: list[Any]) -> list[str]:
+    """检查入口出边和需要继续流转节点的 sync 标记。"""
+    outgoing: dict[str, list[str]] = {}
+    for edge in edges:
+        if isinstance(edge, dict):
+            outgoing.setdefault(str(edge.get("from")), []).append(str(edge.get("to")))
+    issues: list[str] = []
+    for node in nodes:
+        if not isinstance(node, dict):
+            continue
+        node_id = str(node.get("id"))
+        node_type = node.get("type")
+        node_label = f"节点 {node_id} ({node.get('name', '')})"
+        has_outgoing = bool(outgoing.get(node_id))
+        if node_type == "applicant" and not has_outgoing:
+            issues.append(f"申请人入口节点 {node_id} 没有出边，提交后流程不会进入下一节点")
+        if has_outgoing and node.get("sync") is not True:
+            issues.append(f"{node_label} 存在出边但未显式 sync=true，后端可能停止继续路由")
+    return issues
+
+
+# ---------------------------------------------------------------------------
+# 更新模式：最小修改原则（skill --previous 检查）
+# ---------------------------------------------------------------------------
+
+
+def _minimal_spec_edges(spec: dict[str, Any]) -> list[tuple[Any, Any]]:
+    edges = spec.get("edges")
+    if isinstance(edges, dict) and isinstance(edges.get("edges"), list):
+        return [(edge.get("from"), edge.get("to")) for edge in edges["edges"] if isinstance(edge, dict)]
+    if isinstance(edges, list):
+        return [(edge.get("from"), edge.get("to")) for edge in edges if isinstance(edge, dict)]
+    return []
+
+
+def _node_identity(node: dict[str, Any]) -> str:
+    import json
+
+    return json.dumps(
+        {"type": node.get("type", ""), "name": node.get("name", ""), "attrs": node.get("attrs", {})},
+        sort_keys=True,
+        ensure_ascii=False,
+    )
+
+
+def check_minimal_modification(
+    old_spec: dict[str, Any],
+    new_spec: dict[str, Any],
+) -> tuple[list[str], list[str]]:
+    """更新模式下检查最小修改原则：ID 稳定性、无冗余删建、修改范围合理。"""
+    issues: list[str] = []
+    warnings: list[str] = []
+
+    old_nodes = [node for node in (old_spec.get("nodes") or []) if isinstance(node, dict)]
+    new_nodes = [node for node in (new_spec.get("nodes") or []) if isinstance(node, dict)]
+    old_by_id = {str(node.get("id")): node for node in old_nodes}
+    new_by_id = {str(node.get("id")): node for node in new_nodes}
+    old_ids = set(old_by_id)
+    new_ids = set(new_by_id)
+    deleted_ids = old_ids - new_ids
+    added_ids = new_ids - old_ids
+
+    # 1. 节点 ID 变更（内容相同但 ID 不同 —— 可能是不必要的重建）
+    old_identities: dict[str, list[str]] = {}
+    for node in old_nodes:
+        old_identities.setdefault(_node_identity(node), []).append(str(node.get("id")))
+    for node in new_nodes:
+        node_id = str(node.get("id"))
+        if node_id in added_ids:
+            identity = _node_identity(node)
+            if old_identities.get(identity):
+                old_id = old_identities[identity][0]
+                if old_id in deleted_ids:
+                    issues.append(
+                        f"[最小修改] 节点 {old_id} → {node_id} ({node.get('name', '')})："
+                        f"内容未变但 ID 已变更，可能导致后端不支持配置丢失"
+                    )
+
+    # 2. 类型变更（type 不同视为破坏性修改）
+    for node_id in old_ids & new_ids:
+        if old_by_id[node_id].get("type") != new_by_id[node_id].get("type"):
+            warnings.append(
+                f"[最小修改] 节点 {node_id} type 从 {old_by_id[node_id].get('type')} 变为 "
+                f"{new_by_id[node_id].get('type')}，可能丢失原类型专属配置"
+            )
+
+    # 3. 边删建（from/to 相同但 condition 不同 → 应该是修改而非删建）
+    old_edge_keys = set(_minimal_spec_edges(old_spec))
+    new_edge_keys = set(_minimal_spec_edges(new_spec))
+    deleted_edges = old_edge_keys - new_edge_keys
+    added_edges = new_edge_keys - old_edge_keys
+    if deleted_edges:
+        warnings.append(f"[最小修改] 删除了 {len(deleted_edges)} 条边，请确认是否为业务需要")
+    if added_edges:
+        warnings.append(f"[最小修改] 新增了 {len(added_edges)} 条边，请确认是否按预期新增")
+
+    # 4. 节点删除
+    if deleted_ids:
+        warnings.append(f"[最小修改] 删除了 {len(deleted_ids)} 个节点: {sorted(deleted_ids)}，请确认是否为业务需要")
+
+    return issues, warnings
+
+
+# ---------------------------------------------------------------------------
+# 汇总入口
+# ---------------------------------------------------------------------------
+
+
+def validate_spec(spec: dict[str, Any], schema: dict[str, Any]) -> FlowValidationResult:
+    """对单个 WorkflowSpec 执行全量离线校验。
+
+    ``schema`` 须为 ``/api/workflow/spec/schema`` 的动态拉取结果（relaxed 由本函数内部处理）。
+    """
+    result = FlowValidationResult()
+    if not isinstance(spec, dict):
+        result.issues.append("[结构] spec 必须是 JSON 对象（WorkflowSpecDTO）")
+        return result
+
+    # 预处理：null 值清理 + autoJudges 格式规范化（不改调用方原数据）
+    normalized = normalize_auto_judges(strip_nulls(deepcopy(spec)))
+    nodes, edges = normalize_spec(normalized)
+    result.node_count = len(nodes)
+    result.edge_count = len(edges)
+
+    result.issues.extend(schema_issues(inject_attrs_type(normalized), schema))
+
+    if not nodes:
+        result.issues.append("[结构] spec 中未找到 nodes 数组")
+    if not edges:
+        # 单节点（applicant-only）流程允许无边；多节点必须显式声明边。
+        result.issues.extend(check_nonempty_graph(nodes, edges))
+
+    if nodes:
+        result.issues.extend(check_required_fields(nodes, edges))
+        result.issues.extend(check_applicant(nodes))
+        result.issues.extend(check_gateway_conditions(nodes, edges))
+        result.issues.extend(check_approval_nodes(nodes))
+        result.issues.extend(check_filling_nodes(nodes))
+        result.issues.extend(check_automation_nodes(nodes))
+        result.issues.extend(check_cc_nodes(nodes))
+        result.issues.extend(check_orphan_nodes(nodes, edges))
+        result.issues.extend(check_routing_entry_and_sync(nodes, edges))
+    if nodes and edges:
+        result.warnings.extend(check_cycle_warnings(nodes, edges))
+    return result