Struct Task 

pub struct Task {
    pub id: String,
    pub name: String,
    pub description: Option<String>,
    pub condition: Value,
    pub function: FunctionConfig,
    pub continue_on_error: bool,
    pub terminal: bool,
    /* private fields */
}

A single processing unit within a workflow (also known as an Action in rules-engine terminology).

Tasks execute functions with optional conditions and error handling. They are processed sequentially within a workflow, allowing later tasks to depend on results from earlier ones.

Example JSON Definition

{
    "id": "validate_user",
    "name": "Validate User Data",
    "description": "Ensures user data meets requirements",
    "condition": {">=": [{"var": "data.order.total"}, 1000]},
    "function": {
        "name": "validation",
        "input": { "rules": [...] }
    },
    "continue_on_error": false,
    "terminal": false
}

Fields

id: String

Unique identifier for the task within the workflow.

name: String

Human-readable name for the task.

description: Option<String>

Optional description explaining what the task does.

condition: Value

JSONLogic condition that determines if the task should execute. Conditions can access any context field (data, metadata, temp_data). Defaults to true (always execute).

function: FunctionConfig

The function configuration specifying what operation to perform. Can be a built-in function (map, validation) or a custom function.

continue_on_error: bool

Whether to continue workflow execution if this task fails. When true, errors are recorded but don’t stop the workflow. Defaults to false.

terminal: bool

Whether running this task ends the workflow. Defaults to false.

terminal is a statement about position — “nothing after this runs” — not about outcome:

• a false condition means the task never ran, so nothing halts;
• TaskOutcome::Skip does not halt, for the same reason;
• a task that failed under continue_on_error: true still halts, and its error is still recorded on message.errors().

Halting stops this workflow only; later workflows registered on the same engine still process the message. Inside a workflow carrying a LoopConfig it breaks the whole loop, not one sweep — the same scope as TaskOutcome::Halt.

The audit-trail entry keeps the task’s own status (200, 404, …) rather than HALT_STATUS_CODE: the task did its job, and a map that wrote a 404 response body should not report “a filter halted here”.

Implementations

impl Task

pub fn action(id: &str, name: &str, function: FunctionConfig) -> Self

Create a task (action) with default settings.

This is a convenience constructor for the IFTTT-style rules engine pattern, creating an action that always executes (condition defaults to true).

Arguments

• id - Unique identifier for the action
• name - Human-readable name
• function - The function configuration to execute

Trait Implementations

impl Clone for Task

fn clone(&self) -> Task

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Task

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Task

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.