Raxol.Workflow.Node behaviour (Raxol v2.6.0)

Node descriptors for Raxol.Workflow.Graph.

A node is one of three shapes:

FunctionNode -- a 1-arity function (state -> result)
BehaviourNode -- a module implementing this module's behaviour
TypedNode -- a struct with a Raxol.Workflow.Node.Executor protocol implementation. Mirrors the Raxol.Core.Runtime.Directive pattern: lets external packages register typed nodes (e.g. %Raxol.ACP.Workflow.Node.CreateMemo{...}) with custom telemetry and validation.

Node functions return one of:

{:ok, state} -- proceed with the new state
{:effects, [directive], state} -- emit directives and proceed
{:interrupt, value} -- pause the run for human-in-the-loop resume
{:error, reason} -- fail (handled by the workflow's failure policy)

FunctionNodes also accept an optional 1-arity compensation function that runs in reverse order under failure_policy: :compensate.

Summary

Called by the runtime's failure policy when failure_policy: :compensate is set and the run errors after this node already succeeded. Receives the current state (potentially modified by later compensations) and returns either an updated state via {:ok, new_state} or an error via {:error, reason}. Compensation errors are surfaced through node.compensated telemetry but do not displace the run's original failure reason. Default is a no-op that leaves the state untouched.

init(opts)

Called once at run start to set up node-private state.

run(state, opts)

Called once per visit to the node. Returns the next state, an interrupt, an error, or a state plus a list of Raxol.Core.Runtime.Directive structs to dispatch through the runtime's existing effect pipeline.

Functions

behaviour(id, module, opts \\ [])

Construct a BehaviourNode.

function(id, fun)

Construct a FunctionNode.

function(id, fun, compensate_fun)

Construct a FunctionNode with an optional compensation function.

id(arg1)

Return the node's id.

typed(id, struct)

Construct a TypedNode.

Types

id()

@type id() :: atom() | binary()

result()

@type result() ::
  {:ok, state()}
  | {:effects, [struct()], state()}
  | {:interrupt, any()}
  | {:error, any()}

state()

@type state() :: any()

t()

@type t() ::
  Raxol.Workflow.Node.FunctionNode.t()
  | Raxol.Workflow.Node.BehaviourNode.t()
  | Raxol.Workflow.Node.TypedNode.t()

Callbacks

compensate(state, opts)

(optional)

@callback compensate(state :: state(), opts :: keyword()) ::
  {:ok, state()} | {:error, any()}