Flows

A Flow is the same thing you build in Studio’s flow editor, written as a graph. You add blocks and link them.

from pawabase_iac import Flow, P, blocks, ctx

invoice = Flow("issue_invoice", description="Invoice a student")

start = invoice.add(blocks.trigger.http(method="POST", policy="finance_staff").named("start"))
student = invoice.add(blocks.resource.get(resource="students", id=ctx.input.student_id).named("student"))
missing = invoice.add(blocks.error.raise_(status=404, message="No such student").named("missing"))
fees = invoice.add(blocks.resource.list(resource="fee_structures", filters={"grade": ctx.steps.student.output.grade}, limit=1).named("fees"))
total = invoice.add(blocks.transform.summarize(value=ctx.steps.fees.output.data[0].items, operation="sum", field="amount").named("total"))
big = invoice.add(blocks.control.if_(P.steps.total.output > 100000).named("big"))
review = invoice.add(blocks.event.emit(event="invoice.needs_review", payload={"total": ctx.steps.total.output}).named("review"))
done = invoice.add(blocks.response.return_(status=201, body={"total": ctx.steps.total.output}).named("done"))

start >> student
student.missing >> missing
student >> fees >> total >> big
big.true >> review >> done
big.false >> done

The pieces

Piece	Use
`Flow(name, description, enabled, timeout, record_runs)`	The flow. `timeout` is in seconds (default 60); `record_runs` keeps a trace for Activity → Flow runs
`flow.add(block)`	Adds a block and returns a handle
`block.named("id")`	Gives a block a readable id you use in templates and links
`a >> b`	Link `a` to `b` along the normal next path
`a.true >> b`, `a.false >> b`	Branch handles (for `control.if_`)
`a.error >> b`	The error path of a block that can fail
`a.on("done") >> b`	Any other named handle (loops use `item` and `done`)
`flow.chain(a, b, c)`	Add and link several in one call
`flow["id"]`	A block you already added

Using values: `ctx` and `P`

Block settings are templates over what has happened so far:

In settings	Reads
`ctx.input.x`	The flow’s input
`ctx.steps.<id>.output.y`	An earlier block’s output
`ctx.vars.z`	A variable you set
`ctx.item`, `ctx.index`	The current element in a loop

Conditions (control.if_, control.while_, transform.filter) use P over the same values: P.input.x, P.steps.total.output > 100000, P.vars.z, P.item.w.

Rules the server enforces (and `validate` checks)

Templates are lookups. {{ steps.load.output.id }} plus the filters default, upper, lower, length, int, float, str, bool, first, last, keys and a few more. They don’t run code.
What input holds depends on how the flow starts: an HTTP trigger with no path gets the body; one with a path gets {params, query, body, headers}.
Loops. ctx.item and ctx.index are the current element; a nested loop shadows the outer item, so keep what you need with blocks.control.set(values={...}).
validate.schema is strict: declare every optional input too, or it is refused.
The graph is checked: every block exists, every link points to a real block and handle, nothing is unreachable, and each block’s settings are valid.

Test a deployed flow

Open it in Studio’s flow editor and use Test run, or call it from your app (Server logic: flows). See The flow editor.

Flow blocks

All 69 blocks by family.

Routes

Give a flow a URL.

Overview

Infrastructure as code

Define your backend

Logic and events

Files and mail

Ship it

Reference

SDK clients

The pieces

Using values: `ctx` and `P`

Rules the server enforces (and `validate` checks)

Test a deployed flow

Flow blocks

Routes

​The pieces

​Using values: ctx and P

​Rules the server enforces (and validate checks)

​Test a deployed flow

Flow blocks

Routes

The pieces

Using values: `ctx` and `P`

Rules the server enforces (and `validate` checks)

Test a deployed flow