Struct GraphDescription 

pub struct GraphDescription {
    pub id: WorkflowId,
    pub revision: String,
    pub entry: String,
    pub nodes: Vec<GraphNode>,
    pub edges: Vec<GraphEdge>,
}

Passive graph metadata in authored node and transition order.

Example

use app_kit::workflow::WorkflowDefinition;

let definition = WorkflowDefinition::parse(r#"{
    "schema":"app-kit.workflow/v2", "id":"counter", "revision":"r1",
    "state":{"count":0}, "required":["count"],
    "reducers":{"count":"reject_concurrent"}, "entry":"increment",
    "nodes":[{"id":"increment","step":{"kind":"state","mutations":[
        {"kind":"increment","target":"count","value":{"kind":"literal","value":1}}
    ]}}], "routes":{}
}"#)?;
let graph = definition.graph();
assert_eq!(graph.entry, "increment");
assert_eq!(graph.nodes.len(), 1);

Fields

id: WorkflowId

Logical workflow identity.

revision: String

Caller-selected definition revision.

entry: String

First node’s logical identity.

nodes: Vec<GraphNode>

Authored node metadata, without executable bindings.

edges: Vec<GraphEdge>

Ordered outgoing transitions, grouped by authored source-node order.

Implementations

impl GraphDescription

pub fn tracking_record(&self) -> Result<Value, AppError>

Produces the pinned rurr application-graph tracking object.

Every node must carry actual source metadata. Missing source is an error; no placeholder code is invented. Explicit end edges do not create a synthetic action or transition. The caller owns transport and JSONL framing.

Errors

Returns InvalidInput if a node lacks actual source metadata or the tracking record exceeds JSON bounds. Unbound caller actions may have no source metadata; the method does not invent callback source.

Example

use app_kit::workflow::WorkflowDefinition;

let definition = WorkflowDefinition::parse(r#"{
    "schema":"app-kit.workflow/v2", "id":"counter", "revision":"r1",
    "state":{"count":0}, "required":["count"],
    "reducers":{"count":"reject_concurrent"}, "entry":"increment",
    "nodes":[{"id":"increment","step":{"kind":"state","mutations":[
        {"kind":"increment","target":"count","value":{"kind":"literal","value":1}}
    ]}}], "routes":{}
}"#)?;
let record = definition.graph().tracking_record()?;
assert_eq!(record["type"], "application");
assert_eq!(record["entrypoint"], "increment");

Examples found in repository

examples/graph.rs (line 64)

fn main() -> Result<(), AppError> {
    let mut imports = Vec::new();
    for (id, prefix) in [("first-counter", "first_"), ("second-counter", "second_")] {
        let definition = WorkflowDefinition::parse(
            &json!({
                "schema":"app-kit.workflow/v2", "id":id, "revision":"r1",
                "state":{"count":0}, "required":["count"],
                "reducers":{"count":"reject_concurrent"}, "entry":"add",
                "nodes":[{"id":"add", "name":"Add one", "step":{
                    "kind":"state", "mutations":[{
                        "kind":"increment", "target":"count",
                        "value":{"kind":"literal", "value":1}
                    }]
                }}],
                "routes":{}
            })
            .to_string(),
        )?;
        imports.push(GraphImport {
            definition,
            prefix: prefix.into(),
        });
    }
    let definition = WorkflowDefinition::compose(GraphComposition {
        id: "two-counters".parse()?,
        revision: "r1".into(),
        entry: "first_add".into(),
        imports,
        connections: vec![GraphConnection {
            from: "first_add".into(),
            to: "second_add".into(),
        }],
    })?;
    let graph = definition.graph();
    assert_eq!(graph.entry, "first_add");
    assert_eq!(graph.nodes.len(), 2);
    assert_eq!(graph.nodes[0].id, "first_add");
    assert_eq!(graph.nodes[1].id, "second_add");
    assert!(
        graph
            .edges
            .iter()
            .any(|edge| { edge.from == "first_add" && edge.to.as_deref() == Some("second_add") })
    );

    let inspection = definition.export(GraphFormat::Json)?;
    let inspection: serde_json::Value = serde_json::from_str(&inspection)
        .map_err(|_| AppError::Integration("example graph JSON was invalid".into()))?;
    assert_eq!(inspection["nodes"].as_array().map(Vec::len), Some(2));
    assert!(definition.export(GraphFormat::Dot)?.starts_with("digraph "));
    println!("{}", definition.export(GraphFormat::Mermaid)?);

    // Built-in nodes retain their canonical authored source. Tracking requires
    // actual source for every node and is a separate content-export format.
    let tracking = graph.tracking_record()?;
    assert_eq!(tracking["type"], "application");
    assert_eq!(tracking["actions"].as_array().map(Vec::len), Some(2));
    Ok(())
}

Trait Implementations

impl Serialize for GraphDescription

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.