Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

14.9 KB
Raw Blame
"""Transport compatibility and preflight parsing for HITL v1 node migration."""

from collections.abc import Mapping
from typing import override
from uuid import UUID

from pydantic import (
    BaseModel,
    ConfigDict,
    Field,
    GetJsonSchemaHandler,
    JsonValue,
    RootModel,
    TypeAdapter,
    ValidationError,
    model_validator,
)
from pydantic.json_schema import JsonSchemaValue
from pydantic_core import CoreSchema, PydanticCustomError

from core.workflow.human_input_adapter import (
    EmailDeliveryMethod,
    WebAppDeliveryMethod,
    adapt_human_input_node_data_for_graph,
)
from core.workflow.nodes.human_input.entities import HumanInputNodeDataFull
from core.workflow.nodes.human_input_v2.migration import (
    LegacyDeliveryParseIssue,
    LegacyNodeDataPreflight,
    MigrationBlockerCode,
)
from graphon.entities.base_node_data import DefaultValue
from graphon.entities.exc import DefaultValueTypeError


class LegacyHITLv1NodeData(RootModel[LegacyNodeDataPreflight]):
    """Refine historical wire aliases into the formal V1 model at HTTP ingress.

    Only delivery/default preflight is migration-specific. All authoring fields
    and constraints come from the same model that executes V1 workflows.
    """

    @model_validator(mode="before")
    @classmethod
    def parse_v1(cls, value: object) -> LegacyNodeDataPreflight:
        return _parse_node_data(value)

    @classmethod
    @override
    def __get_pydantic_json_schema__(
        cls,
        _core_schema: CoreSchema,
        handler: GetJsonSchemaHandler,
    ) -> JsonSchemaValue:
        return handler(TypeAdapter(HumanInputNodeDataFull).core_schema)


class _TransportDeliveryMethod(BaseModel):
    """Permissive envelope used only to classify compatibility input."""

    model_config = ConfigDict(extra="allow")

    __pydantic_extra__: dict[str, JsonValue] = Field(init=False)  # pyrefly: ignore[bad-override-mutable-attribute]

    id: str | None = None
    type: str
    enabled: bool = True
    config: JsonValue = Field(default_factory=dict)


def _json_value_is_material(value: JsonValue) -> bool:
    if value is None or value is False or value == "":
        return False
    if isinstance(value, list | dict):
        return bool(value)
    return True


def _disabled_email_config_is_historical_default(config: JsonValue) -> bool:
    if not isinstance(config, Mapping):
        return False
    if not set(config).issubset({"recipients", "subject", "body", "debug_mode"}):
        return False
    if "subject" in config and config["subject"] != "":
        return False
    if "body" in config and config["body"] != "":
        return False
    if "debug_mode" in config and config["debug_mode"] is not False:
        return False

    if "recipients" not in config:
        return True
    recipients = config["recipients"]
    if not isinstance(recipients, Mapping):
        return False
    if not set(recipients).issubset({"items", "whole_workspace", "include_bound_group"}):
        return False
    if "items" in recipients and recipients["items"] != []:
        return False
    if "whole_workspace" in recipients and recipients["whole_workspace"] is not False:
        return False
    return "include_bound_group" not in recipients or recipients["include_bound_group"] is False


def _disabled_method_is_configured(method: _TransportDeliveryMethod) -> bool:
    if method.__pydantic_extra__:
        return True
    if "config" not in method.model_fields_set:
        return False
    if method.type == "email":
        return not _disabled_email_config_is_historical_default(method.config)
    if method.type == "webapp":
        return not isinstance(method.config, Mapping) or bool(method.config)
    return _json_value_is_material(method.config)


def _transport_method_value(method: _TransportDeliveryMethod) -> dict[str, JsonValue]:
    method_value = method.model_dump(mode="python")
    if "id" not in method.model_fields_set:
        method_value.pop("id", None)
    return method_value


def _parse_default_values(
    raw_default_values: JsonValue,
) -> tuple[list[DefaultValue] | None, tuple[LegacyDeliveryParseIssue, ...]]:
    if raw_default_values is None:
        return None, ()
    if isinstance(raw_default_values, list):
        try:
            return [DefaultValue.model_validate(raw_default) for raw_default in raw_default_values], ()
        except (ValidationError, DefaultValueTypeError):
            pass
    return (
        None,
        (
            LegacyDeliveryParseIssue(
                code=MigrationBlockerCode.INVALID_DEFAULT_VALUE,
                value="default_value",
            ),
        ),
    )


def _normalize_email_compatibility_aliases(method: _TransportDeliveryMethod) -> dict[str, JsonValue]:
    # Reuse the runtime's historical user_id/whole_workspace normalization.
    normalized = adapt_human_input_node_data_for_graph({"delivery_methods": [_transport_method_value(method)]})
    return TypeAdapter(list[dict[str, JsonValue]]).validate_python(normalized["delivery_methods"])[0]


def _email_configuration_error_field(method: _TransportDeliveryMethod) -> str:
    config = method.config
    if not isinstance(config, Mapping) or not isinstance(config.get("recipients"), Mapping):
        return "recipients"
    if not isinstance(config.get("subject"), str):
        return "subject"
    if not isinstance(config.get("body"), str):
        return "body"
    return "recipients"


def _parse_method(
    raw_method: JsonValue,
    method_position: int,
) -> tuple[
    EmailDeliveryMethod | WebAppDeliveryMethod | None,
    tuple[LegacyDeliveryParseIssue, ...],
    tuple[int, ...],
]:
    try:
        transport_method = _TransportDeliveryMethod.model_validate(raw_method)
    except ValidationError:
        return (
            None,
            (
                LegacyDeliveryParseIssue(
                    code=MigrationBlockerCode.UNSUPPORTED_DELIVERY_METHOD,
                    method_position=method_position,
                ),
            ),
            (),
        )

    if "id" in transport_method.model_fields_set and transport_method.id is None:
        return (
            None,
            (
                LegacyDeliveryParseIssue(
                    code=MigrationBlockerCode.UNSUPPORTED_DELIVERY_METHOD,
                    method_position=method_position,
                    value=transport_method.type,
                ),
            ),
            (),
        )

    if transport_method.id is not None:
        try:
            UUID(transport_method.id)
        except ValueError:
            return (
                None,
                (
                    LegacyDeliveryParseIssue(
                        code=MigrationBlockerCode.UNSUPPORTED_DELIVERY_METHOD,
                        method_position=method_position,
                        method_id=transport_method.id,
                        value=transport_method.type,
                    ),
                ),
                (),
            )

    if transport_method.type not in {"email", "webapp"}:
        return (
            None,
            (
                LegacyDeliveryParseIssue(
                    code=MigrationBlockerCode.UNSUPPORTED_DELIVERY_METHOD,
                    method_position=method_position,
                    method_id=transport_method.id,
                    value=transport_method.type,
                ),
            ),
            (),
        )

    if not transport_method.enabled:
        if _disabled_method_is_configured(transport_method):
            return (
                None,
                (
                    LegacyDeliveryParseIssue(
                        code=MigrationBlockerCode.CONFIGURED_DISABLED_METHOD,
                        method_position=method_position,
                        method_id=transport_method.id,
                        value=transport_method.type,
                    ),
                ),
                (),
            )
        return None, (), ()

    if transport_method.type == "webapp":
        try:
            return WebAppDeliveryMethod.model_validate(_transport_method_value(transport_method)), (), ()
        except ValidationError:
            return (
                None,
                (
                    LegacyDeliveryParseIssue(
                        code=MigrationBlockerCode.UNSUPPORTED_DELIVERY_METHOD,
                        method_position=method_position,
                        method_id=transport_method.id,
                        value=transport_method.type,
                    ),
                ),
                (),
            )

    method_value = _normalize_email_compatibility_aliases(transport_method)
    config = method_value.get("config")
    if not isinstance(config, Mapping):
        return (
            None,
            (
                LegacyDeliveryParseIssue(
                    code=MigrationBlockerCode.INVALID_EMAIL_CONFIGURATION,
                    method_position=method_position,
                    method_id=transport_method.id,
                    value="recipients",
                ),
            ),
            (),
        )
    recipients = config.get("recipients")
    if not isinstance(recipients, Mapping):
        return (
            None,
            (
                LegacyDeliveryParseIssue(
                    code=MigrationBlockerCode.INVALID_EMAIL_CONFIGURATION,
                    method_position=method_position,
                    method_id=transport_method.id,
                    value="recipients",
                ),
            ),
            (),
        )
    raw_items = recipients.get("items", [])
    if not isinstance(raw_items, list):
        return (
            None,
            (
                LegacyDeliveryParseIssue(
                    code=MigrationBlockerCode.INVALID_EMAIL_CONFIGURATION,
                    method_position=method_position,
                    method_id=transport_method.id,
                    value="recipients",
                ),
            ),
            (),
        )

    valid_items: list[JsonValue] = []
    valid_item_positions: list[int] = []
    issues: list[LegacyDeliveryParseIssue] = []
    for recipient_position, raw_recipient in enumerate(raw_items):
        if not isinstance(raw_recipient, Mapping):
            issues.append(
                LegacyDeliveryParseIssue(
                    code=MigrationBlockerCode.INVALID_EMAIL_CONFIGURATION,
                    method_position=method_position,
                    method_id=transport_method.id,
                    value="recipients",
                    recipient_position=recipient_position,
                )
            )
            continue
        recipient_type = raw_recipient.get("type")
        if recipient_type == "external":
            if not isinstance(raw_recipient.get("email"), str):
                issues.append(
                    LegacyDeliveryParseIssue(
                        code=MigrationBlockerCode.INVALID_EMAIL,
                        method_position=method_position,
                        method_id=transport_method.id,
                        recipient_position=recipient_position,
                    )
                )
                continue
        elif recipient_type == "member":
            if not isinstance(raw_recipient.get("reference_id"), str):
                issues.append(
                    LegacyDeliveryParseIssue(
                        code=MigrationBlockerCode.UNRESOLVED_MEMBER,
                        method_position=method_position,
                        method_id=transport_method.id,
                        recipient_position=recipient_position,
                    )
                )
                continue
        else:
            issues.append(
                LegacyDeliveryParseIssue(
                    code=MigrationBlockerCode.INVALID_EMAIL_CONFIGURATION,
                    method_position=method_position,
                    method_id=transport_method.id,
                    value="recipients",
                    recipient_position=recipient_position,
                )
            )
            continue
        valid_items.append(dict(raw_recipient))
        valid_item_positions.append(recipient_position)

    normalized_method_value = {
        **method_value,
        "config": {
            **config,
            "recipients": {
                **recipients,
                "items": valid_items,
            },
        },
    }
    try:
        return (
            EmailDeliveryMethod.model_validate(normalized_method_value),
            tuple(issues),
            tuple(valid_item_positions),
        )
    except ValidationError:
        issues.append(
            LegacyDeliveryParseIssue(
                code=MigrationBlockerCode.INVALID_EMAIL_CONFIGURATION,
                method_position=method_position,
                method_id=transport_method.id,
                value=_email_configuration_error_field(transport_method),
            )
        )
        return None, tuple(issues), ()


def _parse_node_data(raw_node_data: object) -> LegacyNodeDataPreflight:
    node_value = TypeAdapter(dict[str, JsonValue]).validate_python(raw_node_data)
    if node_value.get("version", "1") != "1":
        raise PydanticCustomError("unsupported_version", 'version must be "1"')
    default_value, default_value_issues = _parse_default_values(node_value.get("default_value"))
    raw_methods = TypeAdapter(list[JsonValue]).validate_python(node_value.get("delivery_methods", []))
    delivery_methods: list[EmailDeliveryMethod | WebAppDeliveryMethod] = []
    method_positions: list[int] = []
    recipient_positions: list[tuple[int, ...]] = []
    issues = list(default_value_issues)
    for method_position, raw_method in enumerate(raw_methods):
        method, method_issues, method_recipient_positions = _parse_method(raw_method, method_position)
        if method is not None:
            delivery_methods.append(method)
            method_positions.append(method_position)
            recipient_positions.append(method_recipient_positions)
        issues.extend(method_issues)

    # text_input predates the shared paragraph model. Normalize only this alias;
    # the formal discriminated union owns every current input and field constraint.
    raw_inputs = node_value.get("inputs")
    if isinstance(raw_inputs, list):
        node_value["inputs"] = [
            {**input_value, "type": "paragraph"}
            if isinstance(input_value, dict) and input_value.get("type") == "text_input"
            else input_value
            for input_value in raw_inputs
        ]
    canonical_node_data = HumanInputNodeDataFull.model_validate(
        {
            **node_value,
            "default_value": default_value,
            "delivery_methods": delivery_methods,
        }
    )
    return LegacyNodeDataPreflight(
        node_data=canonical_node_data,
        method_positions=tuple(method_positions),
        recipient_positions=tuple(recipient_positions),
        issues=tuple(issues),
    )


def preflight_legacy_human_input_node_data(
    transport_node_data: LegacyHITLv1NodeData,
) -> LegacyNodeDataPreflight:
    return transport_node_data.root