Logic Nodes

type: condition
mode: simple
condition: "{{trigger.data.total}} > 100"
label: "Order > 100€?"

Output: true o false

type: condition
mode: switch
switchValue: "{{trigger.data.orderType}}"
cases:
  - value: "digital"
    label: "Digital Product"
  - value: "physical"
    label: "Physical Product"
  - value: "subscription"
    label: "Subscription"
  - default: true
    label: "Unknown"
label: "Order Type Router"

type: condition
mode: multiple
conditions:
  - expression: "{{data.status}} === 'urgent' && {{data.priority}} > 8"
    label: "Critical"
  - expression: "{{data.status}} === 'urgent'"
    label: "Urgent"
  - expression: "{{data.priority}} > 5"
    label: "High Priority"
  - default: true
    label: "Normal"
label: "Priority Router"

type: transform
operation: map
mappings:
  - source: "{{api.data.user.id}}"
    target: "userId"
  - source: "{{api.data.user.email}}"
    target: "email"
  - source: "{{api.data.created_at}}"
    target: "createdAt"
    transform: "new Date(value).toISOString()"
  - static: "active"
    target: "status"
label: "Map User Data"

type: transform
operation: filter
input: "{{api.data.orders}}"
condition: "item.status === 'completed' && item.total > 50"
label: "Filter Large Orders"

Output:

{
  "filtered": [...],
  "originalCount": 100,
  "filteredCount": 25
}

type: transform
operation: group
input: "{{api.data.transactions}}"
groupBy: "category"
aggregations:
  - field: "amount"
    operation: "sum"
    as: "totalAmount"
  - field: "id"
    operation: "count"
    as: "transactionCount"
label: "Group by Category"

Output:

{
  "groups": {
    "food": { "totalAmount": 1500, "transactionCount": 45 },
    "transport": { "totalAmount": 800, "transactionCount": 20 }
  }
}

type: transform
operation: custom
expression: |
  const orders = {{api.data.orders}};
  
  return {
    totalOrders: orders.length,
    totalRevenue: orders.reduce((sum, o) => sum + o.total, 0),
    averageOrder: orders.reduce((sum, o) => sum + o.total, 0) / orders.length,
    byStatus: orders.reduce((acc, o) => {
      acc[o.status] = (acc[o.status] || 0) + 1;
      return acc;
    }, {}),
    topCustomer: orders
      .reduce((acc, o) => {
        acc[o.customerId] = (acc[o.customerId] || 0) + o.total;
        return acc;
      }, {})
      |> Object.entries
      |> (arr => arr.sort((a,b) => b[1] - a[1])[0])
  };
label: "Calculate Order Stats"

type: merge
mode: waitAll
waitFor:
  - nodeId: "fetchUsers"
  - nodeId: "fetchOrders"
  - nodeId: "fetchProducts"
label: "Wait All APIs"

Output:

{
  "fetchUsers": { "data": [...] },
  "fetchOrders": { "data": [...] },
  "fetchProducts": { "data": [...] }
}

type: merge
mode: combine
inputs:
  - "{{apiA.output.items}}"
  - "{{apiB.output.items}}"
  - "{{apiC.output.items}}"
flatten: true
label: "Combine All Items"

type: split
input: "{{database.output.users}}"
batchSize: 50
parallelism: 5
label: "Split Users into Batches"

Output (per ogni iterazione):

{
  "batch": [...],  // 50 elementi
  "batchIndex": 0,
  "totalBatches": 20,
  "isFirst": true,
  "isLast": false
}

type: delay
duration: "{{Math.pow(2, set.output.retryCount) * 1000}}"
maxDuration: 60000  # Max 60 secondi
label: "Exponential Backoff"

type: set
variables:
  - name: "counter"
    value: "{{(set.output.counter || 0) + 1}}"
  - name: "items"
    value: "{{[...set.output.items, api.output.data]}}"
  - name: "lastRun"
    value: "{{new Date().toISOString()}}"
label: "Update State"

Output:

{
  "counter": 5,
  "items": [...],
  "lastRun": "2024-01-15T10:30:00Z"
}

type: logger
level: info
message: "Order processed successfully"
data:
  orderId: "{{trigger.data.orderId}}"
  total: "{{api.output.total}}"
  processingTime: "{{Date.now() - trigger.timestamp}}"
label: "Log Order Processed"

1. Nomina chiaramente ogni branch
2. Usa switch per più di 3 casi
3. Gestisci sempre il caso default
4. Evita condizioni troppo complesse - splitta in più nodi

1. Preferisci operazioni built-in a custom
2. Valida sempre l’input
3. Gestisci null/undefined
4. Documenta trasformazioni complesse

1. Limita parallelism per non sovraccaricare
2. Usa batch per grandi volumi
3. Implementa backoff per rate limiting
4. Monitora memoria e performance