jellyflow-runtime 0.1.0

Headless store, rules, schema, profile, and change pipeline for Jellyflow.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use crate::io::NodeGraphInteractionState;
use crate::rules::ConnectPlan;
use jellyflow_core::core::{EdgeId, Graph, PortId};
use jellyflow_core::interaction::NodeGraphConnectionMode;

use super::common::{
    ConnectionEndpoints, ConnectionOpBuilder, add_existing_ports_edge_op, connection_exists,
    edge_between, resolve_policy_checked_connection,
};

/// Plans connecting two ports.
///
/// This is a rules-driven decision point used by the UI interaction loop.
/// The returned ops are intended to be applied as part of a single transaction.
pub fn plan_connect_with_mode_and_policy(
    graph: &Graph,
    a: PortId,
    b: PortId,
    mode: NodeGraphConnectionMode,
    state: &NodeGraphInteractionState,
) -> ConnectPlan {
    match plan_resolved_connect(graph, a, b, mode, state) {
        Ok(planned) => planned.into_plan(),
        Err(plan) => plan,
    }
}

pub(in crate::rules::connection) struct ResolvedConnectPlan<'a> {
    endpoints: ConnectionEndpoints<'a>,
    plan: ConnectPlan,
}

impl<'a> ResolvedConnectPlan<'a> {
    pub(in crate::rules::connection) fn endpoints(&self) -> &ConnectionEndpoints<'a> {
        &self.endpoints
    }

    pub(in crate::rules::connection) fn into_plan(self) -> ConnectPlan {
        self.plan
    }
}

pub(in crate::rules::connection) fn plan_resolved_connect<'a>(
    graph: &'a Graph,
    a: PortId,
    b: PortId,
    mode: NodeGraphConnectionMode,
    state: &NodeGraphInteractionState,
) -> Result<ResolvedConnectPlan<'a>, ConnectPlan> {
    let endpoints = match resolve_policy_checked_connection(graph, a, b, mode, state) {
        Ok(endpoints) => endpoints,
        Err(plan) => return Err(plan),
    };

    if connection_exists(
        graph,
        endpoints.edge_kind,
        endpoints.from_id,
        endpoints.to_id,
        None,
    ) {
        return Ok(ResolvedConnectPlan {
            endpoints,
            plan: ConnectPlan::accept(),
        });
    }

    let mut ops = ConnectionOpBuilder::with_endpoint_capacity_disconnects(graph, &endpoints, None);

    let add_edge = match add_existing_ports_edge_op(
        graph,
        EdgeId::new(),
        edge_between(endpoints.edge_kind, endpoints.from_id, endpoints.to_id),
    ) {
        Ok(op) => op,
        Err(plan) => return Err(plan),
    };
    ops.push(add_edge);

    Ok(ResolvedConnectPlan {
        endpoints,
        plan: ConnectPlan::from_ops(ops.into_ops()),
    })
}

/// Plans connecting two ports with default interaction policy.
pub fn plan_connect_with_mode(
    graph: &Graph,
    a: PortId,
    b: PortId,
    mode: NodeGraphConnectionMode,
) -> ConnectPlan {
    plan_connect_with_mode_and_policy(graph, a, b, mode, &NodeGraphInteractionState::default())
}

/// Plans connecting two ports (strict mode).
pub fn plan_connect(graph: &Graph, a: PortId, b: PortId) -> ConnectPlan {
    plan_connect_with_mode(graph, a, b, NodeGraphConnectionMode::Strict)
}