Struct DagBuilder 

pub struct DagBuilder { /* private fields */ }

Fluent builder for constructing StreamingDag topologies.

Constructed in Ring 2. Once build() is called, the topology is immutable and can be executed in Ring 0.

Example

use laminar_core::dag::DagBuilder;

let dag = DagBuilder::new()
    .source("trades", schema.clone())
    .operator("dedup", schema.clone())
    .operator("normalize", schema.clone())
    .connect("trades", "dedup")
    .connect("dedup", "normalize")
    .fan_out("normalize", |b| {
        b.branch("vwap", schema.clone())
         .branch("anomaly", schema.clone())
         .branch("position", schema.clone())
    })
    .sink_for("vwap", "analytics_sink", schema.clone())
    .sink_for("anomaly", "alert_sink", schema.clone())
    .sink_for("position", "risk_sink", schema.clone())
    .build()?;

Implementations

impl DagBuilder

pub fn new() -> Self

Creates a new DAG builder.

pub fn source(self, name: &str, schema: SchemaRef) -> Self

Adds a source node to the DAG.

Source nodes are entry points that receive data from external systems via the Connector SDK.

pub fn operator(self, name: &str, schema: SchemaRef) -> Self

Adds a stateful operator node to the DAG.

pub fn stateless_operator(self, name: &str, schema: SchemaRef) -> Self

Adds a stateless operator node to the DAG.

pub fn materialized_view(self, name: &str, schema: SchemaRef) -> Self

Adds a materialized view node to the DAG.

pub fn connect(self, from: &str, to: &str) -> Self

Connects two nodes with an edge.

pub fn fan_out<F>(self, shared_node: &str, branches: F) -> Self

where F: FnOnce(FanOutBuilder) -> FanOutBuilder,

Creates a fan-out from a shared stage to multiple branches.

The branches closure receives a FanOutBuilder that allows adding multiple downstream branches from the shared node. Each branch is automatically connected to the shared node.

pub fn sink_for( self, upstream: &str, sink_name: &str, schema: SchemaRef, ) -> Self

Adds a sink node and connects it to an upstream node.

pub fn sink(self, name: &str, schema: SchemaRef) -> Self

Adds a sink node to the DAG (without auto-connecting).

Use connect() to manually wire upstream nodes.

pub fn build(self) -> Result<StreamingDag, DagError>

Builds the immutable DAG topology.

Validates the topology (acyclic, connected, schema-compatible), computes topological order, derives channel types, and identifies shared stages.

Errors

Returns DagError::CycleDetected if the graph contains cycles. Returns DagError::DisconnectedNode if a node has no connections. Returns DagError::NodeNotFound if an edge references a missing node. Returns DagError::DuplicateNode if nodes have duplicate names. Returns DagError::EmptyDag if no nodes were added.

Trait Implementations

impl Default for DagBuilder

fn default() -> Self

Returns the “default value” for a type.