Docs / Strand / nodes/logic

Logic Node

The Logic node provides conditional and iterative control flow in workflows.

Mode is an explicit choice, not a default. If/Else routes on the if and else handles; Filter passes or drops the event; Foreach iterates on each and done.

Overview

The Logic node combines multiple control flow operations in one configurable node:

• Filter - Allow or block events based on conditions
• If/Else - Branch execution into two paths
• Foreach - Iterate over arrays with batched execution

Modes

Filter Mode

Evaluates a condition and only allows events through if true.

Configuration:

Both styles work: return True/False or assigning result = True/False:

# Style 1: return the condition
return payload.get('value', 0) > 25

# Style 2: assign result
result = payload.get('value', 0) > 25

Handles:

• Input (top)
• Output (bottom) - only fires when condition is true

If/Else Mode

Branches execution into two paths based on a Jinja2 condition.

Configuration:

Example:

payload.temperature > 25

Handles:

• Input (top)
• if (bottom-left, blue) - fires when condition is true
• else (bottom-right, purple) - fires when condition is false

Foreach Mode

Iterates over an array, calling a connected node for each item, then aggregating results.

Configuration:

Handles:

• Input (top)
• each (bottom-left, orange) - connect to node to call per item
• done (bottom-right, green) - fires with aggregated results after all items processed

Foreach Execution Flow

┌─────────────────────┐
│   Foreach Node      │
│   (array of 100)    │
└─────────┬───────────┘
          │
    ┌─────┴─────┐
    │           │
  [each]     [done]
    │           │
    ▼           │
┌─────────┐     │
│ HTTP    │     │
│ Request │     │
└────┬────┘     │
     │          │
     └──────────┤  (results aggregated)
                │
                ▼
        ┌───────────────┐
        │ Process       │
        │ All Results   │
        └───────────────┘

How It Works

1. The foreach node receives an event with an array
2. For each item in the array:

• Creates an event that adds the current item and its index to the payload, under the keys named by item_var (default item) and index_var (default index)
• Executes the node connected to the "each" handle
• Collects the result

1. After all items are processed:

• Aggregates results into _foreach_results array
• Emits a single event from the "done" handle

Batched Execution

Items are processed in batches to control rate and memory:

• batch_size: How many items per batch
• batch_delay_ms: Wait time between batches (useful for rate-limited APIs)

Example: Processing 100 items with batch_size=10 and batch_delay_ms=1000:

• Processes items 0-9, waits 1 second
• Processes items 10-19, waits 1 second
• ... continues until all items processed

Output Format

The "done" output contains:

{
  "payload": {
    "...original payload...",
    "_foreach_results": [
      { "index": 0, "input": "item1", "output": {...}, "success": true },
      { "index": 1, "input": "item2", "output": {...}, "success": true }
    ],
    "_foreach_failed": [
      { "index": 5, "input": "item6", "error": "Timeout", "success": false }
    ]
  },
  "meta": {
    "_foreach_complete": true,
    "_foreach_total": 100,
    "_foreach_processed": 100,
    "_foreach_success_count": 99,
    "_foreach_failed_count": 1
  }
}

Progress Tracking

During execution, progress is tracked in the step run metadata:

• foreach_total - Total items
• foreach_processed - Items completed
• foreach_batch_current - Current batch number
• foreach_batch_total - Total batches
• foreach_failed_count - Number of failures

This is visible in the Node Execution Details panel.

Examples

Foreach: Process User List

Scenario: Fetch details for each user ID in an array.

1. Add Logic node, set mode to "Foreach"
2. Set array_path to payload.user_ids
3. Connect "each" handle to HTTP Request node
4. Configure HTTP Request: GET /api/users/{{ payload.item }}
5. Connect "done" handle to next processing step

If/Else: Route by Priority

Scenario: High priority items go one way, others go another.

1. Add Logic node, set mode to "If/Else"
2. Set condition: payload.priority == 'high'
3. Connect "if" handle to urgent processing
4. Connect "else" handle to normal processing

Filter: Validate Data

Scenario: Only process events with required fields.

1. Add Logic node, set mode to "Filter"
2. Set filter code:

   # Simple: return the condition
   return payload.get('email') and payload.get('name')

1. Connect output to processing node

Best Practices

Related

• Conditional Logic - Branching, filtering, and iteration
• Python Snippet - Custom code execution
• Function Call - Reusable functions

← Back to Strand docs