Struct PipelineDefinition 

pub struct PipelineDefinition {
    pub services: Vec<ServiceDecl>,
    pub nodes: Vec<NodeDecl>,
}

Top-level pipeline definition

Parsed from a TOML document. Use PipelineParser::from_str or PipelineParser::from_file to obtain an instance, then call PipelineDefinition::validate to check structural correctness.

Fields

services: Vec<ServiceDecl>

Service adapter declarations

nodes: Vec<NodeDecl>

Node declarations that form the DAG

Implementations

impl PipelineDefinition

pub fn validate(&self) -> Result<(), PipelineError>

Validate the pipeline definition.

Checks:

1. All node service references exist in services (or known external names).
2. All depends_on entries refer to existing nodes.
3. The dependency graph is acyclic.

Example

use stygian_graph::application::pipeline_parser::PipelineParser;

let toml = r#"
[[nodes]]
name = "a"
service = "http"

[[nodes]]
name = "b"
service = "http"
depends_on = ["a"]
"#;

let def = PipelineParser::from_str(toml).unwrap();
assert!(def.validate().is_ok());

pub fn validate_against_registry<S: AsRef<str>>( &self, registered_services: &[S], ) -> Result<(), PipelineError>

Validate that all referenced services exist in the given registry names.

Useful for runtime validation after the registry has been populated.

Example

use stygian_graph::application::pipeline_parser::PipelineParser;

let toml = r#"
[[nodes]]
name = "fetch"
service = "http"
"#;

let def = PipelineParser::from_str(toml).unwrap();
let registered = vec!["http".to_string(), "claude".to_string()];
assert!(def.validate_against_registry(&registered).is_ok());

pub fn expand_templates(&mut self)

Expand template variables in string values across all nodes and services.

Supports:

• ${env:VAR_NAME} — replaced with std::env::var("VAR_NAME") or left as-is

Modifies the definition in-place and returns self for chaining.

Example

use stygian_graph::application::pipeline_parser::PipelineParser;

// Use HOME which is always available on Unix
let home = std::env::var("HOME").unwrap_or_else(|_| "/tmp".to_string());
let toml = format!(r#"
[[nodes]]
name = "fetch"
service = "http"
url = "${{env:HOME}}"
"#);

let mut def = PipelineParser::from_str(&toml).unwrap();
def.expand_templates();

assert_eq!(def.nodes[0].url.as_deref(), Some(home.as_str()));

pub fn topological_order(&self) -> Result<Vec<String>, PipelineError>

Compute a topological ordering of the nodes (dependencies first).

Returns Err if the graph contains a cycle.

Example

use stygian_graph::application::pipeline_parser::PipelineParser;

let toml = r#"
[[nodes]]
name = "c"
service = "http"
depends_on = ["b"]

[[nodes]]
name = "a"
service = "http"

[[nodes]]
name = "b"
service = "http"
depends_on = ["a"]
"#;

let def = PipelineParser::from_str(toml).unwrap();
let order = def.topological_order().unwrap();
assert_eq!(order[0], "a");
assert_eq!(order[2], "c");

pub fn to_dot(&self) -> String

Export the pipeline DAG as a Graphviz DOT string.

Example

use stygian_graph::application::pipeline_parser::PipelineParser;

let toml = r#"
[[nodes]]
name = "a"
service = "http"

[[nodes]]
name = "b"
service = "http"
depends_on = ["a"]
"#;

let def = PipelineParser::from_str(toml).unwrap();
let dot = def.to_dot();
assert!(dot.contains("digraph"));
assert!(dot.contains(r#""a" -> "b""#));

pub fn to_mermaid(&self) -> String

Export the pipeline DAG as a Mermaid flowchart string.

Example

use stygian_graph::application::pipeline_parser::PipelineParser;

let toml = r#"
[[nodes]]
name = "fetch"
service = "http"

[[nodes]]
name = "parse"
service = "claude"
depends_on = ["fetch"]
"#;

let def = PipelineParser::from_str(toml).unwrap();
let mermaid = def.to_mermaid();
assert!(mermaid.contains("flowchart LR"));
assert!(mermaid.contains("fetch --> parse"));

Trait Implementations

impl Clone for PipelineDefinition

fn clone(&self) -> PipelineDefinition

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PipelineDefinition

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PipelineDefinition

fn default() -> PipelineDefinition

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PipelineDefinition

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for PipelineDefinition

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

where __S: Serializer,

Serialize this value into the given Serde serializer.