Skip to content

refactor(workflow): add Jinja2 renderer abstraction for template transform #29

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
tomerqodo wants to merge 6 commits into
base: coderabbit_full_base_refactorworkflow_add_jinja2_renderer_abstraction_for_template_transform_pr3
Choose a base branch
from
+849 −33
Open

refactor(workflow): add Jinja2 renderer abstraction for template transform #29

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
2bf031d
Added constructor-based CodeExecutor injection to TemplateTransformNo…
laipz8200 Jan 4, 2026
46b7145
Introduced a Jinja2-specific rendering abstraction and wired Template…
laipz8200 Jan 4, 2026
2a616d8
Updated TemplateRenderError to inherit from ValueError and switched n…
laipz8200 Jan 4, 2026
64a46c1
chore(lint): ran `make lint` (ruff format updated `api/tests/unit_tes…
laipz8200 Jan 4, 2026
3977898
Update api/core/workflow/nodes/template_transform/template_renderer.py
laipz8200 Jan 4, 2026
24297d2
update pr
tomerqodo Jan 25, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
16 changes: 16 additions & 0 deletions api/core/workflow/nodes/node_factory.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,6 +11,11 @@
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.template_transform.template_renderer import (
CodeExecutorJinja2TemplateRenderer,
Jinja2TemplateRenderer,
)
from core.workflow.nodes.template_transform.template_transform_node import TemplateTransformNode
from libs.typing import is_str, is_str_dict

from .node_mapping import LATEST_VERSION, NODE_TYPE_CLASSES_MAPPING
Expand All @@ -37,6 +42,7 @@ def __init__(
code_executor: type[CodeExecutor] | None = None,
code_providers: Sequence[type[CodeNodeProvider]] | None = None,
code_limits: CodeNodeLimits | None = None,
template_renderer: Jinja2TemplateRenderer | None = None,
) -> None:
self.graph_init_params = graph_init_params
self.graph_runtime_state = graph_runtime_state
Expand All @@ -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._template_renderer = template_renderer or CodeExecutorJinja2TemplateRenderer(code_executor)

@override
def create_node(self, node_config: dict[str, object]) -> Node:
Expand Down Expand Up @@ -107,6 +114,15 @@ def create_node(self, node_config: dict[str, object]) -> Node:
code_limits=self._code_limits,
)

if node_type == NodeType.TEMPLATE_TRANSFORM:
return TemplateTransformNode(
id=node_id,
config=node_config,
graph_init_params=self.graph_init_params,
graph_runtime_state=self.graph_runtime_state,
template_renderer=self._template_renderer,
)

return node_class(
id=node_id,
config=node_config,
Expand Down
40 changes: 40 additions & 0 deletions api/core/workflow/nodes/template_transform/template_renderer.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,40 @@
from __future__ import annotations

from collections.abc import Mapping
from typing import Any, Protocol

from core.helper.code_executor.code_executor import CodeExecutionError, CodeExecutor, CodeLanguage


class TemplateRenderError(ValueError):
"""Raised when rendering a Jinja2 template fails."""


class Jinja2TemplateRenderer(Protocol):
"""Render Jinja2 templates for template transform nodes."""

def render_template(self, template: str, variables: Mapping[str, Any]) -> str:
"""Render a Jinja2 template with provided variables."""
raise NotImplementedError


class CodeExecutorJinja2TemplateRenderer(Jinja2TemplateRenderer):
"""Adapter that renders Jinja2 templates via CodeExecutor."""

_code_executor: type[CodeExecutor]

def __init__(self, code_executor: type[CodeExecutor] | None = None) -> None:
self._code_executor = code_executor or CodeExecutor

def render_template(self, template: str, variables: Mapping[str, Any]) -> str:
try:
result = self._code_executor.execute_workflow_code_template(
language=CodeLanguage.JINJA2, code=template, inputs=variables
)
except CodeExecutionError as exc:
raise TemplateRenderError(str(exc)) from exc

rendered = result.get("result")
if rendered is not None and not isinstance(rendered, str):
raise TemplateRenderError("Template render result must be a string.")
return rendered
Comment on lines +29 to +40
Copy link

@coderabbitai coderabbitai bot Jan 29, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

⚠️ Potential issue | 🔴 Critical

Return type mismatch: method can return None but signature declares str.

The method signature declares -> str, but result.get("result") on line 37 can return None when the key is absent. Line 40 then returns this potentially None value.

This causes downstream issues in template_transform_node.py where len(rendered) (line 69) would raise TypeError if rendered is None.

Either:

  1. Update the return type to str | None and handle None in callers, or
  2. Raise TemplateRenderError when the result is missing/None
🐛 Proposed fix (option 2 - enforce non-None return) 
         rendered = result.get("result")
         if rendered is not None and not isinstance(rendered, str):
             raise TemplateRenderError("Template render result must be a string.")
+        if rendered is None:
+            raise TemplateRenderError("Template render returned no result.")
         return rendered
📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change
def render_template(self, template: str, variables: Mapping[str, Any]) -> str:
try:
result = self._code_executor.execute_workflow_code_template(
language=CodeLanguage.JINJA2, code=template, inputs=variables
)
except CodeExecutionError as exc:
raise TemplateRenderError(str(exc)) from exc
rendered = result.get("result")
if rendered is not None and not isinstance(rendered, str):
raise TemplateRenderError("Template render result must be a string.")
return rendered
def render_template(self, template: str, variables: Mapping[str, Any]) -> str:
try:
result = self._code_executor.execute_workflow_code_template(
language=CodeLanguage.JINJA2, code=template, inputs=variables
)
except CodeExecutionError as exc:
raise TemplateRenderError(str(exc)) from exc
rendered = result.get("result")
if rendered is not None and not isinstance(rendered, str):
raise TemplateRenderError("Template render result must be a string.")
if rendered is None:
raise TemplateRenderError("Template render returned no result.")
return rendered
🤖 Prompt for AI Agents 
In `@api/core/workflow/nodes/template_transform/template_renderer.py` around lines
29 - 40, The render_template method (render_template) currently returns
result.get("result") which can be None, contradicting the declared return type
str; change the implementation to treat a missing/None result as an error: after
calling self._code_executor.execute_workflow_code_template
(CodeLanguage.JINJA2), validate that result.get("result") is a non-None string
and if it is None (or not a str) raise TemplateRenderError with a clear message
instead of returning None so callers expecting a str won't receive None; keep
the signature as -> str and ensure TemplateRenderError is raised for
missing/None results.

51 changes: 37 additions & 14 deletions api/core/workflow/nodes/template_transform/template_transform_node.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,18 +1,44 @@
from collections.abc import Mapping, Sequence
from typing import Any
from typing import TYPE_CHECKING, Any

from configs import dify_config
from core.helper.code_executor.code_executor import CodeExecutionError, CodeExecutor, CodeLanguage
from core.workflow.enums import NodeType, WorkflowNodeExecutionStatus
from core.workflow.node_events import NodeRunResult
from core.workflow.nodes.base.node import Node
from core.workflow.nodes.template_transform.entities import TemplateTransformNodeData
from core.workflow.nodes.template_transform.template_renderer import (
CodeExecutorJinja2TemplateRenderer,
Jinja2TemplateRenderer,
TemplateRenderError,
)

if TYPE_CHECKING:
from core.workflow.entities import GraphInitParams
from core.workflow.runtime import GraphRuntimeState

MAX_TEMPLATE_TRANSFORM_OUTPUT_LENGTH = dify_config.TEMPLATE_TRANSFORM_MAX_LENGTH


class TemplateTransformNode(Node[TemplateTransformNodeData]):
node_type = NodeType.TEMPLATE_TRANSFORM
_template_renderer: Jinja2TemplateRenderer

def __init__(
self,
id: str,
config: Mapping[str, Any],
graph_init_params: "GraphInitParams",
graph_runtime_state: "GraphRuntimeState",
*,
template_renderer: Jinja2TemplateRenderer | None = None,
) -> None:
super().__init__(
id=id,
config=config,
graph_init_params=graph_init_params,
graph_runtime_state=graph_runtime_state,
)
self._template_renderer = template_renderer or CodeExecutorJinja2TemplateRenderer()

@classmethod
def get_default_config(cls, filters: Mapping[str, object] | None = None) -> Mapping[str, object]:
Expand All @@ -39,21 +65,18 @@ def _run(self) -> NodeRunResult:
variables[variable_name] = value.to_object() if value else None
# Run code
try:
result = CodeExecutor.execute_workflow_code_template(
language=CodeLanguage.JINJA2, code=self.node_data.template, inputs=variables
)
except CodeExecutionError as e:
rendered = self._template_renderer.render_template(self.node_data.template, variables)
if len(rendered) > MAX_TEMPLATE_TRANSFORM_OUTPUT_LENGTH:
return NodeRunResult(
inputs=variables,
status=WorkflowNodeExecutionStatus.FAILED,
error=f"Output length exceeds {MAX_TEMPLATE_TRANSFORM_OUTPUT_LENGTH} characters",
)
except TemplateRenderError as e:
return NodeRunResult(inputs=variables, status=WorkflowNodeExecutionStatus.FAILED, error=str(e))

if len(result["result"]) > MAX_TEMPLATE_TRANSFORM_OUTPUT_LENGTH:
return NodeRunResult(
inputs=variables,
status=WorkflowNodeExecutionStatus.FAILED,
error=f"Output length exceeds {MAX_TEMPLATE_TRANSFORM_OUTPUT_LENGTH} characters",
)

return NodeRunResult(
status=WorkflowNodeExecutionStatus.SUCCEEDED, inputs=variables, outputs={"output": result["result"]}
status=WorkflowNodeExecutionStatus.SUCCEEDED, inputs=variables, outputs={"output": rendered}
)

@classmethod
Expand Down
Loading