Flow inputs and outputs are visible and editable in the UI

A flow's inputs are the messages it takes from outside — a dashboard control,
a run, the API — and its outputs are what a batch run reports. Both existed in
the document and in the engine, and neither had any UI: the values looked
hard-coded on the canvas and the Run button always used the declared defaults.

The canvas now draws each as a labelled endpoint, the way it already draws a
dashboard tile or another flow, skipping an input something else already
accounts for. The flow panel edits them — mode, name, type, starting value,
and for a live flow the value it currently holds with a way to put a new one
in. Pressing Run on a batch flow asks for its parameters first.
This commit is contained in:
2026-08-20 18:10:16 +02:00
parent 508172ad79
commit bec8e89459
10 changed files with 644 additions and 22 deletions
+139
View File
@@ -0,0 +1,139 @@
import { useEffect, useState } from "react"
import type { FlowDef_Input } from "@/client"
import { Button } from "@/components/ui/button"
import {
Dialog,
DialogContent,
DialogDescription,
DialogFooter,
DialogHeader,
DialogTitle,
} from "@/components/ui/dialog"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import {
Select,
SelectContent,
SelectItem,
SelectTrigger,
SelectValue,
} from "@/components/ui/select"
import { asText, parseByDtype } from "./FlowBoundary"
/**
* The parameters of one run, taken from the flow's inputs.
*
* A batch flow's inputs *are* its parameters — a run supplies values for them
* and keeps whatever it does not name — so this is a form over the same
* declarations the flow panel edits, prefilled with what they start from.
*/
export function RunDialog({
open,
definition,
pending,
onOpenChange,
onRun,
}: {
open: boolean
definition: FlowDef_Input
pending: boolean
onOpenChange: (open: boolean) => void
onRun: (params: Record<string, unknown>) => void
}) {
const inputs = (definition.inputs ?? []).filter((one) => one.spec?.name)
const [values, setValues] = useState<Record<string, unknown>>({})
// Opening is what fills the form: an edit to the flow between two runs
// should show up, and the last run's values should not linger. The inputs
// are read then rather than watched, so typing over one is not undone.
// biome-ignore lint/correctness/useExhaustiveDependencies: opening is the dependency.
useEffect(() => {
if (!open) return
setValues(
Object.fromEntries(
inputs.map((one) => [one.spec?.name ?? "", one.initial ?? null]),
),
)
}, [open])
return (
<Dialog open={open} onOpenChange={onOpenChange}>
<DialogContent data-testid="run-dialog">
<DialogHeader>
<DialogTitle>Run {definition.title || definition.name}</DialogTitle>
<DialogDescription>
{inputs.length === 0
? "This flow declares no parameters, so there is nothing to choose."
: "The run starts from these. Everything it computes is dropped afterwards except its result."}
</DialogDescription>
</DialogHeader>
<div className="grid gap-3">
{inputs.map((declared) => {
const name = declared.spec?.name ?? ""
const dtype = declared.spec?.dtype
return (
<div key={name} className="grid gap-1.5">
<Label htmlFor={`param-${name}`} className="font-mono text-xs">
{name}
</Label>
{dtype === "bool" ? (
<Select
value={values[name] === true ? "true" : "false"}
onValueChange={(next) =>
setValues({ ...values, [name]: next === "true" })
}
>
<SelectTrigger id={`param-${name}`} className="text-sm">
<SelectValue />
</SelectTrigger>
<SelectContent>
<SelectItem value="true">true</SelectItem>
<SelectItem value="false">false</SelectItem>
</SelectContent>
</Select>
) : (
<Input
id={`param-${name}`}
value={asText(values[name])}
placeholder={dtype ?? "float"}
className="text-sm"
onChange={(event) =>
setValues({
...values,
[name]: parseByDtype(dtype, event.target.value),
})
}
/>
)}
</div>
)
})}
</div>
<DialogFooter>
<Button variant="outline" onClick={() => onOpenChange(false)}>
Cancel
</Button>
<Button
variant="brand"
disabled={pending}
data-testid="submit-run"
onClick={() =>
// A parameter nobody filled in keeps its declared value, which is
// what leaving it out means.
onRun(
Object.fromEntries(
Object.entries(values).filter(([, value]) => value !== null),
),
)
}
>
Run
</Button>
</DialogFooter>
</DialogContent>
</Dialog>
)
}