Macros

CEL has no loops; it has comprehension macros. Each one takes an iteration variable and a sub-expression, and expands at compile time into a bounded comprehension over a list or a map — so iteration stays terminating and side-effect free. On a map, the iteration variable is bound to each key.

Every standalone example on this page was verified with octo eval; results are shown as it prints them.

filter

list.filter(x, predicate) returns the elements for which the predicate is true, in order.

In a flow — keep only the orders worth acting on, as the new body:

- type: set-payload
  name: keep-large-orders
  settings:
    value: 'body.orders.filter(o, o.amount >= 100)'

bin/octo eval --expr 'body.orders.filter(o, o.amount >= 100)' \
  --data '{"orders": [{"id": 1, "amount": 50}, {"id": 2, "amount": 250}, {"id": 3, "amount": 120}]}'
# {"ok":true,"result":[{"amount":250,"id":2},{"amount":120,"id":3}]}

map

list.map(x, transform) applies the transform to every element. The three-argument form list.map(x, predicate, transform) filters and transforms in one pass.

In a flow — pull the page titles out of a Notion query result (the shape notion-query-datasource leaves in its results, where each page's title lives deep inside properties):

- type: set-payload
  name: extract-titles
  settings:
    value: 'body.results.map(p, p.properties.Name.title[0].plain_text)'

bin/octo eval --expr 'body.results.map(p, p.properties.Name.title[0].plain_text)' \
  --data '{"results": [
    {"properties": {"Name": {"title": [{"plain_text": "Ship the docs"}]}}},
    {"properties": {"Name": {"title": [{"plain_text": "Fix the build"}]}}}]}'
# {"ok":true,"result":["Ship the docs","Fix the build"]}

all

list.all(x, predicate) is true when the predicate holds for every element (and true for an empty list).

In a flow — a validate rule asserting that no order is free:

- type: validate
  name: check-orders
  rules:
    - expr: 'body.orders.all(o, o.amount > 0)'
      message: every order must have a positive amount

exists

list.exists(x, predicate) is true when the predicate holds for at least one element (and false for an empty list).

In a flow — branch when any order needs escalation:

- type: if
  name: any-big-order
  condition: 'body.orders.exists(o, o.amount > 200)'
  then:
    process:
      - type: log
        settings:
          message: '"large order detected"'

exists_one

list.exists_one(x, predicate) is true when the predicate holds for exactly one element.

Chaining

Macros return ordinary values, so they chain:

In a flow — the ids of the orders worth acting on, in one expression:

bin/octo eval --expr 'body.orders.filter(o, o.amount >= 100).map(o, o.id)' \
  --data '{"orders": [{"id": 1, "amount": 50}, {"id": 2, "amount": 250}, {"id": 3, "amount": 120}]}'
# {"ok":true,"result":[2,3]}