Enum ValueExpr 

pub enum ValueExpr {
    Step {
        step: String,
        path: JsonPath,
    },
    Input {
        input: JsonPath,
    },
    Variable {
        variable: JsonPath,
        default: Option<Box<ValueExpr>>,
    },
    EscapedLiteral {
        literal: Value,
    },
    If {
        condition: Box<ValueExpr>,
        then: Box<ValueExpr>,
        else_expr: Option<Box<ValueExpr>>,
    },
    Coalesce {
        values: Vec<ValueExpr>,
    },
    Array(Vec<ValueExpr>),
    Object(Vec<(String, ValueExpr)>),
    Literal(Value),
}

A value expression that can contain literal data or references to other values.

This is the unified type for all workflow inputs, outputs, and data flow. Expressions can be:

• References to other values ($step, $input, $variable)
• Composable structures (arrays and objects containing expressions)
• Literal values (null, bool, number, string - any primitive JSON value)
• Escaped literals ($literal) to prevent expansion

Variants

Step

Step reference: { $step: "step_id", path: "optional.path" }

Fields

step: String

path: JsonPath

Input

Workflow input: { $input: "path" } where path can be “$” for root

Fields

input: JsonPath

Variable

Variable: { $variable: "$.var.path", default: ... }

Fields

variable: JsonPath

default: Option<Box<ValueExpr>>

EscapedLiteral

Escape hatch: { $literal: {...} } - prevents recursive parsing

Fields

literal: Value

If

Conditional expression: { $if: <condition>, then: <expr>, else?: <expr> } Returns then value if condition is truthy, otherwise else value (defaults to null)

Fields

condition: Box<ValueExpr>

then: Box<ValueExpr>

else_expr: Option<Box<ValueExpr>>

Coalesce

Coalesce: { $coalesce: [<expr1>, <expr2>, ...] } Returns first non-skipped, non-null value from the list

Fields

values: Vec<ValueExpr>

Array(Vec<ValueExpr>)

JSON array where each element can be an expression

Object(Vec<(String, ValueExpr)>)

JSON object where each value can be an expression Uses Vec instead of Map for efficiency and to enable hashability

Literal(Value)

Literal JSON value (null, bool, number, string) Note: Literal objects and arrays are parsed as Object/Array variants

Implementations

impl ValueExpr

pub fn step(step_id: impl Into<String>, path: JsonPath) -> Self

Create a step reference expression

pub fn step_output(step_id: impl Into<String>) -> Self

Create a step reference without a path (for compatibility with old code)

pub fn workflow_input(path: JsonPath) -> Self

Create a workflow input reference expression

pub fn variable( name: impl Into<String>, default: Option<Box<ValueExpr>>, ) -> Self

Create a variable reference expression

pub fn literal(value: Value) -> Self

Create a literal value expression from a serde_json::Value

Arrays and objects are recursively converted to composable ValueExpr structures. Primitives (null, bool, number, string) become Literal variants.

pub fn array(values: Vec<ValueExpr>) -> Self

Create an array value expression

pub fn object(values: Vec<(String, ValueExpr)>) -> Self

Create an object value expression from key-value pairs

pub fn escaped_literal(value: Value) -> Self

Create an escaped literal expression

pub fn if_expr( condition: ValueExpr, then: ValueExpr, else_expr: Option<ValueExpr>, ) -> Self

Create a conditional expression

pub fn coalesce(values: Vec<ValueExpr>) -> Self

Create a coalesce expression

pub fn null() -> Self

Create a null literal expression

pub fn is_null(&self) -> bool

Check if this expression is a null literal

pub fn needed_steps(&self, ctx: &impl StepContext) -> BitSet

Returns the set of step indices needed to evaluate this expression.

An empty set means the expression is ready to be fully resolved. This method evaluates lazily - for conditional expressions like $if, it only returns the condition’s dependencies until the condition can be evaluated, then returns the appropriate branch’s dependencies.

Arguments

• ctx - Context providing step completion state and results

Example

For { $if: { $step: foo }, then: { $step: bar }, else: { $step: baz } }:

1. First call (foo not complete): returns {foo_index}
2. After foo completes (truthy): returns {bar_index}
3. After bar completes: returns {} (ready!)

pub fn resolve(&self, ctx: &impl StepContext) -> FlowResult

Resolve this expression using the provided context.

This should only be called when needed_steps() returns an empty set, meaning all required step results are available in the context.

The context provides access to:

• Step results ($step references)
• Workflow input ($input references)
• Variables ($variable references)

Trait Implementations

impl Clone for ValueExpr

fn clone(&self) -> ValueExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ValueExpr

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

Formats the value using the given formatter.

impl Default for ValueExpr

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ValueExpr

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for ValueExpr

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl JsonSchema for ValueExpr

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn json_schema(_generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

impl PartialEq for ValueExpr

fn eq(&self, other: &ValueExpr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ValueExpr

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ValueExpr

impl StructuralPartialEq for ValueExpr