refactor(workflow): remove code node helper imports (#32759)

Co-authored-by: -LAN- <laipz8200@outlook.com>

api/core/workflow/nodes/code/code_node.py

@@ -1,10 +1,8 @@
 from collections.abc import Mapping, Sequence
 from decimal import Decimal
-from typing import TYPE_CHECKING, Any, ClassVar, Protocol, cast
+from textwrap import dedent
+from typing import TYPE_CHECKING, Any, Protocol, cast
 
-from core.helper.code_executor.code_node_provider import CodeNodeProvider
-from core.helper.code_executor.javascript.javascript_code_provider import JavascriptCodeProvider
-from core.helper.code_executor.python3.python3_code_provider import Python3CodeProvider
 from core.workflow.enums import NodeType, WorkflowNodeExecutionStatus
 from core.workflow.node_events import NodeRunResult
 from core.workflow.nodes.base.node import Node
@@ -36,12 +34,44 @@ class WorkflowCodeExecutor(Protocol):
     def is_execution_error(self, error: Exception) -> bool: ...
 
 
+def _build_default_config(*, language: CodeLanguage, code: str) -> Mapping[str, object]:
+    return {
+        "type": "code",
+        "config": {
+            "variables": [
+                {"variable": "arg1", "value_selector": []},
+                {"variable": "arg2", "value_selector": []},
+            ],
+            "code_language": language,
+            "code": code,
+            "outputs": {"result": {"type": "string", "children": None}},
+        },
+    }
+
+
+_DEFAULT_CODE_BY_LANGUAGE: Mapping[CodeLanguage, str] = {
+    CodeLanguage.PYTHON3: dedent(
+        """
+        def main(arg1: str, arg2: str):
+            return {
+                "result": arg1 + arg2,
+            }
+        """
+    ),
+    CodeLanguage.JAVASCRIPT: dedent(
+        """
+        function main({arg1, arg2}) {
+            return {
+                result: arg1 + arg2
+            }
+        }
+        """
+    ),
+}
+
+
 class CodeNode(Node[CodeNodeData]):
     node_type = NodeType.CODE
-    _DEFAULT_CODE_PROVIDERS: ClassVar[tuple[type[CodeNodeProvider], ...]] = (
-        Python3CodeProvider,
-        JavascriptCodeProvider,
-    )
     _limits: CodeNodeLimits
 
     def __init__(
@@ -52,7 +82,6 @@ class CodeNode(Node[CodeNodeData]):
         graph_runtime_state: "GraphRuntimeState",
         *,
         code_executor: WorkflowCodeExecutor,
-        code_providers: Sequence[type[CodeNodeProvider]] | None = None,
         code_limits: CodeNodeLimits,
     ) -> None:
         super().__init__(
@@ -62,9 +91,6 @@ class CodeNode(Node[CodeNodeData]):
             graph_runtime_state=graph_runtime_state,
         )
         self._code_executor: WorkflowCodeExecutor = code_executor
-        self._code_providers: tuple[type[CodeNodeProvider], ...] = (
-            tuple(code_providers) if code_providers else self._DEFAULT_CODE_PROVIDERS
-        )
         self._limits = code_limits
 
     @classmethod
@@ -78,15 +104,10 @@ class CodeNode(Node[CodeNodeData]):
         if filters:
             code_language = cast(CodeLanguage, filters.get("code_language", CodeLanguage.PYTHON3))
 
-        code_provider: type[CodeNodeProvider] = next(
-            provider for provider in cls._DEFAULT_CODE_PROVIDERS if provider.is_accept_language(code_language)
-        )
-
-        return code_provider.get_default_config()
-
-    @classmethod
-    def default_code_providers(cls) -> tuple[type[CodeNodeProvider], ...]:
-        return cls._DEFAULT_CODE_PROVIDERS
+        default_code = _DEFAULT_CODE_BY_LANGUAGE.get(code_language)
+        if default_code is None:
+            raise CodeNodeError(f"Unsupported code language: {code_language}")
+        return _build_default_config(language=code_language, code=default_code)
 
     @classmethod
     def version(cls) -> str:
@@ -108,7 +129,6 @@ class CodeNode(Node[CodeNodeData]):
                 variables[variable_name] = variable.to_object() if variable else None
         # Run code
         try:
-            _ = self._select_code_provider(code_language)
             result = self._code_executor.execute(
                 language=code_language,
                 code=code,
@@ -130,12 +150,6 @@ class CodeNode(Node[CodeNodeData]):
 
         return NodeRunResult(status=WorkflowNodeExecutionStatus.SUCCEEDED, inputs=variables, outputs=result)
 
-    def _select_code_provider(self, code_language: CodeLanguage) -> type[CodeNodeProvider]:
-        for provider in self._code_providers:
-            if provider.is_accept_language(code_language):
-                return provider
-        raise CodeNodeError(f"Unsupported code language: {code_language}")
-
     def _check_string(self, value: str | None, variable: str) -> str | None:
         """
         Check string

api/core/workflow/nodes/code/entities.py

@@ -1,12 +1,19 @@
+from enum import StrEnum
 from typing import Annotated, Literal
 
 from pydantic import AfterValidator, BaseModel
 
-from core.helper.code_executor.code_executor import CodeLanguage
 from core.workflow.nodes.base import BaseNodeData
 from core.workflow.nodes.base.entities import VariableSelector
 from core.workflow.variables.types import SegmentType
 
+
+class CodeLanguage(StrEnum):
+    PYTHON3 = "python3"
+    JINJA2 = "jinja2"
+    JAVASCRIPT = "javascript"
+
+
 _ALLOWED_OUTPUT_FROM_CODE = frozenset(
     [
         SegmentType.STRING,