Added constructor-based DI for VariableAssigner v2 and wired the node factory to pass the ConversationVariableUpdater factory (the only non-VariablePool dependency), plus a unit test to verify the injection path.

- `api/core/workflow/nodes/variable_assigner/v2/node.py` adds a kw-only `conv_var_updater_factory` dependency (defaulting to `conversation_variable_updater_factory`) and stores it for use in `_run`.
- `api/core/workflow/nodes/node_factory.py` now injects the factory when creating VariableAssigner v2 nodes.
- `api/tests/unit_tests/core/workflow/nodes/variable_assigner/v2/test_variable_assigner_v2.py` adds a test asserting the factory is injected.

Tests not run.

Next steps (optional):
1) `make lint`
2) `make type-check`
3) `uv run --project api --dev dev/pytest/pytest_unit_tests.sh`

Author: laipz8200

api/core/workflow/nodes/node_factory.py

@@ -1,16 +1,19 @@
-from collections.abc import Sequence
-from typing import TYPE_CHECKING, final
+from collections.abc import Callable, Sequence
+from typing import TYPE_CHECKING, TypeAlias, final
 
 from typing_extensions import override
 
 from configs import dify_config
 from core.helper.code_executor.code_executor import CodeExecutor
 from core.helper.code_executor.code_node_provider import CodeNodeProvider
+from core.workflow.conversation_variable_updater import ConversationVariableUpdater
 from core.workflow.enums import NodeType
 from core.workflow.graph import NodeFactory
 from core.workflow.nodes.base.node import Node
 from core.workflow.nodes.code.code_node import CodeNode
 from core.workflow.nodes.code.limits import CodeNodeLimits
+from core.workflow.nodes.variable_assigner.common.impl import conversation_variable_updater_factory
+from core.workflow.nodes.variable_assigner.v2 import VariableAssignerNode
 from libs.typing import is_str, is_str_dict
 
 from .node_mapping import LATEST_VERSION, NODE_TYPE_CLASSES_MAPPING
@@ -19,6 +22,8 @@
     from core.workflow.entities import GraphInitParams
     from core.workflow.runtime import GraphRuntimeState
 
+_CONV_VAR_UPDATER_FACTORY: TypeAlias = Callable[[], ConversationVariableUpdater]
+
 
 @final
 class DifyNodeFactory(NodeFactory):
@@ -37,6 +42,7 @@ def __init__(
         code_executor: type[CodeExecutor] | None = None,
         code_providers: Sequence[type[CodeNodeProvider]] | None = None,
         code_limits: CodeNodeLimits | None = None,
+        conv_var_updater_factory: _CONV_VAR_UPDATER_FACTORY = conversation_variable_updater_factory,
     ) -> None:
         self.graph_init_params = graph_init_params
         self.graph_runtime_state = graph_runtime_state
@@ -54,6 +60,7 @@ def __init__(
             max_string_array_length=dify_config.CODE_MAX_STRING_ARRAY_LENGTH,
             max_object_array_length=dify_config.CODE_MAX_OBJECT_ARRAY_LENGTH,
         )
+        self._conv_var_updater_factory = conv_var_updater_factory
 
     @override
     def create_node(self, node_config: dict[str, object]) -> Node:
@@ -107,6 +114,15 @@ def create_node(self, node_config: dict[str, object]) -> Node:
                 code_limits=self._code_limits,
             )
 
+        if node_class is VariableAssignerNode:
+            return VariableAssignerNode(
+                id=node_id,
+                config=node_config,
+                graph_init_params=self.graph_init_params,
+                graph_runtime_state=self.graph_runtime_state,
+                conv_var_updater_factory=self._conv_var_updater_factory,
+            )
+
         return node_class(
             id=node_id,
             config=node_config,

api/core/workflow/nodes/variable_assigner/v2/node.py

@@ -1,6 +1,6 @@
 import json
-from collections.abc import Mapping, MutableMapping, Sequence
-from typing import Any, cast
+from collections.abc import Callable, Mapping, MutableMapping, Sequence
+from typing import TYPE_CHECKING, Any, TypeAlias, cast
 
 from core.app.entities.app_invoke_entities import InvokeFrom
 from core.variables import SegmentType, Variable
@@ -26,6 +26,12 @@
     VariableNotFoundError,
 )
 
+if TYPE_CHECKING:
+    from core.workflow.entities import GraphInitParams
+    from core.workflow.runtime import GraphRuntimeState
+
+_CONV_VAR_UPDATER_FACTORY: TypeAlias = Callable[[], ConversationVariableUpdater]
+
 
 def _target_mapping_from_item(mapping: MutableMapping[str, Sequence[str]], node_id: str, item: VariableOperationItem):
     selector_node_id = item.variable_selector[0]
@@ -52,6 +58,24 @@ def _source_mapping_from_item(mapping: MutableMapping[str, Sequence[str]], node_
 
 class VariableAssignerNode(Node[VariableAssignerNodeData]):
     node_type = NodeType.VARIABLE_ASSIGNER
+    _conv_var_updater_factory: _CONV_VAR_UPDATER_FACTORY
+
+    def __init__(
+        self,
+        id: str,
+        config: Mapping[str, Any],
+        graph_init_params: "GraphInitParams",
+        graph_runtime_state: "GraphRuntimeState",
+        *,
+        conv_var_updater_factory: _CONV_VAR_UPDATER_FACTORY = conversation_variable_updater_factory,
+    ):
+        super().__init__(
+            id=id,
+            config=config,
+            graph_init_params=graph_init_params,
+            graph_runtime_state=graph_runtime_state,
+        )
+        self._conv_var_updater_factory = conv_var_updater_factory
 
     def blocks_variable_output(self, variable_selectors: set[tuple[str, ...]]) -> bool:
         """
@@ -70,9 +94,6 @@ def blocks_variable_output(self, variable_selectors: set[tuple[str, ...]]) -> bo
 
         return False
 
-    def _conv_var_updater_factory(self) -> ConversationVariableUpdater:
-        return conversation_variable_updater_factory()
-
     @classmethod
     def version(cls) -> str:
         return "2"

api/tests/unit_tests/core/workflow/nodes/variable_assigner/v2/test_variable_assigner_v2.py

@@ -1,5 +1,6 @@
 import time
 import uuid
+from unittest import mock
 from uuid import uuid4
 
 from core.app.entities.app_invoke_entities import InvokeFrom
@@ -390,3 +391,45 @@ def test_remove_last_from_empty_array():
     got = variable_pool.get(["conversation", conversation_variable.name])
     assert got is not None
     assert got.to_object() == []
+
+
+def test_node_factory_injects_conv_var_updater_factory():
+    graph_config = {
+        "edges": [],
+        "nodes": [
+            {
+                "data": {"type": "assigner", "version": "2", "title": "Variable Assigner", "items": []},
+                "id": "assigner",
+            },
+        ],
+    }
+
+    init_params = GraphInitParams(
+        tenant_id="1",
+        app_id="1",
+        workflow_id="1",
+        graph_config=graph_config,
+        user_id="1",
+        user_from=UserFrom.ACCOUNT,
+        invoke_from=InvokeFrom.DEBUGGER,
+        call_depth=0,
+    )
+    variable_pool = VariablePool(
+        system_variables=SystemVariable(conversation_id="conversation_id"),
+        user_inputs={},
+        environment_variables=[],
+        conversation_variables=[],
+    )
+    graph_runtime_state = GraphRuntimeState(variable_pool=variable_pool, start_at=time.perf_counter())
+
+    mock_conv_var_updater_factory = mock.Mock()
+    node_factory = DifyNodeFactory(
+        graph_init_params=init_params,
+        graph_runtime_state=graph_runtime_state,
+        conv_var_updater_factory=mock_conv_var_updater_factory,
+    )
+
+    node = node_factory.create_node(graph_config["nodes"][0])
+
+    assert isinstance(node, VariableAssignerNode)
+    assert node._conv_var_updater_factory is mock_conv_var_updater_factory