Skip to content

Releases

v2.42.1

Choose a tag to compare

@miguelperezcolom miguelperezcolom released this 15 Nov 10:48
8a7389b

Patch release with the fixes shown in the new video series, EventConductor in N minutes.

Fixed

  • Console: the Operations tab appears with the first manual operation on a running process — no reload needed.
  • Console: a process page redrawn after an operation keeps its header (back arrow, button order) exactly as on a fresh load.
  • Console: a styled 403 page for browsers the console refuses (API endpoints keep their plain 401/403).
  • Console: truthful audit copy — the operation dialogs say the reason is recorded "together with who did it" (it reads anonymous without a login), not "with your name".
  • Examples: an unpaid balance is never released automatically (examples/video-series balance-reminder): the deadline sends a final notice, then a grace period, then the front desk decides.
  • Docs: deadlines route to a person, not to a cancellation in the scheduling examples.

v2.42.0

Choose a tag to compare

@miguelperezcolom miguelperezcolom released this 14 Nov 23:04
4b8cd97

Changed

  • Breaking for custom webhook providers: io.mateu.workflow.webhook.WebhookProvider is now WebhookDeliveryProvider, so the webhook gateway can be embedded beside the engine. Rename the interface in your own providers.

Added

  • compensate: true on an END — compensation on a business decision. An END with compensate: true cancels whatever is still running and undoes every completed compensable step, newest first (a forEach's completed iterations once each), and the process ends COMPENSATED. Compensation is the mechanism; who decides to trigger it is your business rule. Checked by the engine, eventconductor:validate, the JSON schema and the editor.
  • The hotel booking tells a realistic story: the guest decides. In the workshop, the examples and the docs, a sold-out room no longer cancels the rest: the process keeps what was booked, offers alternatives, waits for the guest (reminder, then front desk) and compensates only if the guest — or the front desk — cancels.
  • examples/video-series — every step type running (timers, messages, FORK/JOIN, CHOICE, PUBLISH_EVENT, REPLY, schedules, triggers, webhook, AGENT on a demo runtime), a scripted MCP client and an observability profile (Prometheus, Grafana, Jaeger).
  • Docs: Secure by default.
  • Diagram minimap folds away; the workshop console has the forms task inbox.

Fixed

  • Engine: an XOR join fed from a CHOICE's default branch now goes on; an XOR join with compensateLosers has exactly one winner; no false "2 outgoing flows" warning for onTimeoutStepId; definitions are imported before the web server starts (no 404 right after boot); eventconductor:validate no longer warns about $defs/deprecated.
  • Console: labelled compensation rows (Room 101, not item 0), an Attempts column, timeout routes drawn as such, loop passes, USER_TASK cards without internal variables, click-to-pin cards, the minimap no longer covers nodes, the task inbox's Run button is visible, the graph re-fits when its container resizes.
  • Mateu 3.0-beta.67: cached page layouts are kept per app and build (no "not allowed" toast after another app ran on the same port).
  • IDE plugins (0.2.5): graph edits no longer rewrite the whole file (comments and quoting are kept); Run Workflow is offered for *.ec.yaml.

Docs

  • *.ec.yaml is the recommended name for a workflow definition (.ec and plain YAML/JSON stay supported).

v2.41.0

Choose a tag to compare

@miguelperezcolom miguelperezcolom released this 14 Nov 10:09
5d3fa74

Added — test kit

  • Workflow coverage. Every @EventConductorTest records which steps ran and which routes were taken (CHOICE branches, guarded links, timeout routes, compensations, loop-backs) and writes target/eventconductor-coverage/coverage.txt + coverage.json. (#653)
  • Scenarios as data. Describe a test case in YAML/JSON — variables, stubbed tasks/HTTP/LLM/agents, follow-up actions, expected end state — and run a directory of them with @ParameterizedTest @ScenarioSource("src/test/scenarios"). (#653)
  • eventconductor:verify. One Maven goal: validate + check-migration + optional coverage floors (minStepCoverage, minBranchCoverage), all problems reported at once. CI becomes mvn -B verify -Deventconductor.migration.from=origin/main. (#653)
  • Compensation, iteration and escalation assertions: hasCompensatedInOrder(...), iterations("rooms").hasOnlyFailed("Room 102"), iteration(ref).wasCompensated() … — iterations are named by index, forEach.label or item in failure messages. (#652)
  • Per-iteration HTTP stubs: whenHttpCall("book").whenItemHas("number", "102"), .whenIteration(1), .whenRequest(...). (#652)
  • LLM stubs are checked against the step's responseSchema (LLM_STUB_INVALID); thenInvalidAnswer(text) stubs a bad model answer on purpose. (#652)

Fixed

  • Every classpath workflows/ directory is read — a src/test/resources/workflows no longer hides src/main/resources/workflows. When the same id is in two roots the first on the classpath wins (test before main), with a warning if they differ. (#651)
  • Re-importing an identical definition (e.g. from Git after the classpath import) no longer records a new version. (#651)
  • LLM base-url and /v1: openai accepts a URL with or without /v1 (and a pasted …/chat/completions); anthropic tolerates a trailing /v1. Documented per provider. (#651)
  • whenTask(stepId) matches USER_TASKs and other built-in steps by step id — whenTask("approve") used to match nothing. (#652)
  • Console: consistently English (workflow.ui.locale to change it); the process list hides forEach child runs by default and has a Business key column; the parent's Errors tab shows why a child failed; the toolbar refreshes after Complete step; kebab-case page URLs (/workflow/batch-operations) redirect to the real pages; the forEach badge on the graph is no longer clipped. (#654)

Docs

  • Workshop pages are now schema-checked like the rest of the docs; the workshop's CI uses eventconductor:verify and ships coverage-driven scenarios.

v2.40.0

Choose a tag to compare

@miguelperezcolom miguelperezcolom released this 13 Nov 21:56
4b49057

Fixed

  • forms-engine next to an embedded engine. Adding forms-engine to a @WorkflowEmbeddedApplication (or under the workflow-test kit) no longer fails with "HumanTaskEvents required a bean of type StreamBridge". In embedded mode USER_TASKs with a formId are now served by the forms engine in process — fetch, claim and complete through /forms/api/tasks — and the reply goes straight to the engine. Kafka mode is unchanged. New switch: forms.embedded.serve-user-tasks (#648)
  • forms.directory-import.* / forms.git-import.* were silently ignored when the workflow engine shared the application (embedded apps and orchestrator-standalone-app): both engines shipped a class with the same name. (#648)
  • Inline PROCESS bodies under forEach lost the item and the business key. ${room.number} rendered as null and ${businessKey} was the child's own parent:<id> key. Templates and guards now see the item and index as objects, and ${businessKey} inside an inline body is the business key of the process that owns it. The child's real key (search, correlation, locks) is unchanged. Adds migration V62 (two nullable columns). (#649)

Docs

Full changelog: v2.39.0...v2.40.0

v2.39.0

Choose a tag to compare

@miguelperezcolom miguelperezcolom released this 13 Nov 16:27
879d493

Upgrading

  • Database migration V60 adds step_execution.item_label (Flyway applies it on start).
  • Behaviour changes in compensation, both fixing work that was left undone:
    • a compensable step (or forEach iteration) that completes after the engine cancelled it is now compensated instead of ignored;
    • a child process the engine cuts short (parent rollback, failFast, compensateLosers, compensateAbandoned) now rolls back its completed steps. Cancelling a process by hand still does not roll back.
  • New definition fields are omitted when unset, so existing definitions keep their version hash.

Added

  • Edit inline PROCESS bodies in the graph editor. Double-click an inline PROCESS (or Edit ▸ in its panel) and its body becomes the graph being edited, with every tool — palette, links, panel, delete; a breadcrumb shows the path and Esc / ↩ Back returns to the level above, at the arrangement and zoom it was left. Bodies nest. Edits are written back into the step's steps, so the host still receives the whole definition. A PROCESS panel switches between naming a child (childWorkflowDefinitionId) and writing it in line (a fresh body is a START and an END; the side switched away from is kept for the session).

  • Panel fields for the new flags: forEach.onIterationFailure and forEach.label, Compensate losers on an XOR join and Compensate abandoned on an END — each with the message eventconductor:validate would give when the combination is refused. The Mateu step form shows compensateLosers only on an XOR join.

  • VS Code execution view: double-click opens child runs. The view links the child processes on its current page into the graph, so a double-click on a PROCESS node, an iteration card or a lane header (ec-open-process) navigates to that run.

  • A forEach opens into its iterations on the process graph. In a process view, double-click a forEach node: it expands into one card per iteration (item index, coloured by state, the error and attempt on hover), fanning out of the same incoming and outgoing edges; double-click again to collapse. Up to 20 cards are drawn, the rest as "+N more"; the overlay lists up to 100 (iterations.items, also on GET /workflow/api/processes/{id}/graph).

  • Double-click a PROCESS node to open its child run. The graph fires ec-open-process with {processId, stepId, itemIndex?}, and the admin console navigates to that process; in an expanded forEach over PROCESS, each iteration opens its own child. The definition editor and the definition view are unchanged.

  • Inline PROCESS bodies open into lanes on the graph. Double-click a PROCESS step written in line (steps:): in a process view it opens into one lane per run — per forEach iteration, headed by its forEach.label ("Hab. 101") and state, or the one child run — with the body's steps inside coloured by how they stand in that run; double-click a lane's header to open its child process. In a read-only definition view the body opens once, as declared. Up to 20 lanes are drawn, the rest as "+N more"; the body states of those child runs are read in one batched query (StepExecutionRepository.findByProcessIds). Expanded forEach iteration cards show the iteration's label too. In the editor the node reads ⚙ inline · N steps.

  • Inline PROCESS bodies. A PROCESS step can write its child workflow in line, under steps:, instead of naming one with childWorkflowDefinitionId (exactly one of the two). It runs exactly as a named child — with a forEach, one child process per item: a dynamic fork whose branches are written where they are used. The body becomes the definition <workflow>.<step>, built from the parent's snapshot when a child starts: versioned with the parent, inheriting its sensitive variables, required scopes/roles and tags, and impossible to start on its own. It is validated as a workflow of its own, at load and by eventconductor:validate, with its problems located (booking.rooms: …).

  • forEach.onIterationFailure: failFast (the default, as before), continue (the other iterations run on and the step completes, output elements becoming {status, value | error}) or compensateAll (all run, then any failure fails the step and compensates every completed iteration; needs completion: all). A completion condition can read failedIterations.

  • forEach.label: a JEXL expression, evaluated once per iteration over its item, that names it — reserve · Hab. 101 in the Steps tab instead of item 2, and itemLabel in the REST and MCP step views (migration V60). A label that fails to evaluate leaves the iteration unnamed; it never fails it.

  • compensateLosers: true on an XOR join abandons the branches it does not go on with: their waiting or running steps are cancelled and their completed compensable steps compensated, newest first. Without it the other branches run on, as before.

  • compensateAbandoned: true on an END also compensates what the branches it cuts short completed in time.

  • Both are cleanup compensations: they do not move the process status or trigger a rollback, and one that fails is an incident in the Errors tab, not a failure of the process. Validated by the engine and eventconductor:validate (compensateLosers only on an XOR join, compensateAbandoned only on an END); absent or false they are left out of the JSON, so existing definitions keep their version hash.

Fixed

  • Memory mode: a worker answering inline inside a fan-out could leave a sibling branch open in a completed process. In memory mode a save acts on its events at once, so an embedded worker that answers on the dispatching thread drove the process on in the middle of the step-over that started it. When that branch ran to END — an XOR winner, a CHOICE routing to END — the END cancelled the sibling branch the FORK had not saved yet, and the step-over then saved its own stale copy of that branch over the cancellation: it stayed PENDING in a COMPLETED process. A step-over's writes now all land before any of their consequences run, the ordering the outbox already gives JPA mode (DeferredEvents). JPA and Kafka modes are unchanged.

  • Dark theme: the forEach/repeat/loop/timeout chips no longer glare as pastel pills, and the step panel's text follows the theme in hosts that do not set a body colour (IDE webviews).

  • A forEach iteration whose work finished after the engine cancelled it was never compensated. When a forEach failed fast (or stopped because the process failed), the iterations still at a worker, or running a child process, were cancelled. But cancelling races with the work: a worker that had already made the booking, or a child process that had already completed, reported COMPLETED after the cancellation, and that report was dropped as stale. The iteration stayed CANCELLED, the saga never undid it, and the booking was left behind in the target system.

    • That late COMPLETED is now kept as a completed run, with what it reported, when its step declares a compensation. Late answers for steps without a compensation are still ignored.
    • The rollback undoes it whenever it lands. Before the rollback reaches its step, it is included as usual. While that step's compensation is running, it waits for that run and then gets a new one. After the process was already COMPENSATED, the process goes back to ERROR, runs a new pass of the compensation over just that iteration, and ends COMPENSATED again.
    • A compensation container now records the iterations it undoes (units in its scope), so a later run covers only what is still to undo. A run started by an earlier engine counts as covering every iteration that had completed when it started.
  • A step on a parallel branch whose work finished after the engine cancelled it was never compensated either. The same race outside a forEach: the rollback, once done, cancels what is still running on the other branches, and an END cancels the branches it cuts short. A worker that had already booked, or a child process that had already completed, reported COMPLETED afterwards and the report was dropped.

    • That late COMPLETED is now kept (with what it reported, on the run) when the step declares a compensation, and undone: by the rollback in a failed process (a new pass if it had already finished), and by a cleanup compensation in one that completed. Late answers for steps without a compensation, or for a process an operator cancelled, are still ignored.
  • A child process the engine cut short was cancelled, not undone. When a PROCESS step's child was still running and the engine cancelled the step — the parent rolling back, a forEach over PROCESS failing fast, an XOR join with compensateLosers or an END with compensateAbandoned abandoning the branch — the child was only cancelled (or, during a rollback, left running until the rollback ended). Whatever it had already done (a room held, not yet confirmed) stayed in the target system.

    • Such a child is now rolled back: its in-flight work is cancelled, its completed compensable steps are compensated newest first (including steps that complete after being cancelled), and it ends COMPENSATED — or COMPENSATION_FAILED — also when it had nothing to undo. Its own running children follow, recursively.
    • The parent's rollback waits for those children: it ends COMPENSATED once they have, COMPENSATION_FAILED if one could not finish undoing. A rolling-back parent now stops a running child as soon as its rollback starts, rather than at its end.
    • Undone once: a child still running undoes its own steps (the parent's PROCESS step stays CANCELLED, so its compensationStepId does not run); a child that already completed is undone by that compensationStepId, and left alone.
    • Unchanged: an operator's cancel (console, REST, MCP) cancels the children without rolling anything...
Read more

v2.38.1

Choose a tag to compare

@miguelperezcolom miguelperezcolom released this 09 Nov 07:02
bef6073

The Docker images of 2.38.0 were never published: the release's image scan stopped them. Use this version.

Security

v2.38.0

Choose a tag to compare

@miguelperezcolom miguelperezcolom released this 08 Nov 22:31
cfc2431

Debounce gets a ceiling, what happened to one flow-control key can be looked up, and Mateu moves to 3.0-beta.52.

Added

  • startPolicy.maxWait. A ceiling on a debounce: however often a key keeps changing, its start waits at most this long after the first one. Equal to debounce, the window is fixed and counted from the first start.
  • Following a flow-control key. Receipts record the rendered key: GET /workflow/api/events/received?flowKey=, listReceivedEvents and a filter on Received events list what happened to one key (migration V59).
  • What a debounce folded, on the process. A process started by a debounce gets flowControlFoldedStarts and flowControlFirstStartAt.

Fixed

  • A flow-control key that could not be released stopped every other key's release, since the pass stopped at the first failure and always began with the oldest.
  • With memory persistence, a failed release lost the waiting start. The store now undoes a failed key as the database does.

Changed

  • Mateu 3.0-beta.52, on the engine, apps and testbenches (from 3.0-alpha.411). demo/shell stays on 3.0-beta.51, since its sign-in uses @KeycloakSecured, which beta.52 removes. (#613)
  • The Forms and Rules consoles no longer redirect the browser to a Keycloak host of their own. Their @KeycloakSecured named a host that was not the deployment's and is gone with the annotation. Access is enforced by each app's SecurityConfig, or by whatever sits in front of it. (#613)

Documentation

  • The flow-control guide said a crash could lose a start. With jpa and a broker it cannot: it stays waiting, or is sent twice and collapses. It also gains a recipe for keeping an entity's changes without losing any.

v2.37.0

Choose a tag to compare

@miguelperezcolom miguelperezcolom released this 26 Oct 12:51
a44f7c5

A gauge of the open incidents, so an integration can be watched and alerted on from a dashboard.

Added

  • eventconductor.incidents.open gauge. How many processes are stopped on an incident right now, per definition. It is the backlog of the incidents view, for dashboards and alerts.
    • eventconductor.process.errored only counts failures as they happen.
    • Counted every workflow.incidents.gauge-interval-ms (60 s by default; 0 turns it off).
    • Cluster-wide: every pod reports the same figure, so alert on max() across replicas.
    • The observability reference now suggests four alerts for an event-driven integration: dead-lettered events, open incidents, a degraded destination, and a silent producer. (#588)

Helm chart 0.2.10 (appVersion 2.37.0).

v2.36.0

Choose a tag to compare

@miguelperezcolom miguelperezcolom released this 24 Oct 16:19
7108944

The graph editor's Step Properties panel now covers every property of a step: what is a scalar or a list can be edited in place, and what is a structured block gets a read-only summary ("Edit … in the YAML") (#484, #585). The panel is the same component in the console and in the VS Code and IntelliJ plugins.

Added

  • Every step property in the panel (#484).
    • Topic can be set on every step dispatched to a worker (ACTION, DYNAMIC, USER_TASK, RULE, HTTP_CALL, LLM_CALL, PUBLISH_EVENT), with its default topic as the placeholder.
    • Per-type fields:
      • ACTION: task contract.
      • WAIT_FOR_MESSAGE and SEND_MESSAGE: correlation expression.
      • SEND_MESSAGE: message variables.
      • TIMER: duration and until variable.
      • PROCESS: output variables.
      • LOCK and UNLOCK: lock name and key.
      • REPLY: reply template (read-only).
    • A collapsible Advanced section, open when something in it is set, with the run cap, the required scopes and roles, and any deprecated fields the definition still carries.
    • Node captions describe every step type.
  • USER_TASK assignment and escalation (#585).
    • Assignee, candidate users and groups, priority, due and follow-up dates; each value may be a ${...} template.
    • The escalation list as a read-only summary in firing order, e.g. PT48H reassign → ops · P3D escalate → manual-review.
  • Sensitive outputs (#585): any step that writes variables can declare its outputVariables and mark them sensitiveOutputs under Advanced.

Upgrade notes

  • None: editor-only changes, with no engine, schema or API change.

v2.35.0

Choose a tag to compare

@miguelperezcolom miguelperezcolom released this 24 Oct 12:30
86d24d9

The orchestration core no longer performs actions. HTTP_CALL, LLM_CALL and now PUBLISH_EVENT are tasks served by built-in workers, and those workers ship inside the orchestrator. A definition that calls an API, asks a model or publishes an event no longer needs a worker deployment (#581, #582).

Upgrade notes

  • Hand-written EmbeddedTaskExecutor? It must now serve publish-event@1 as well. Otherwise PUBLISH_EVENT steps stay PENDING. Apps that use worker-embedded, and the test kit, need nothing: worker-embedded brings worker-events.
  • Already running http-worker / llm-worker on Kafka?
    • With the Helm chart, nothing to do: an enabled httpWorker / llmWorker keeps its topic and the orchestrator's own worker is switched off.
    • Elsewhere, keep one consumer per topic: take the topic out of the orchestrator's BUILTIN_WORKER_TOPICS and set workflow.http.enabled=false / workflow.llm.enabled=false on it, or retire the standalone worker.
    • To move a topic onto the orchestrator, roll out once with BUILTIN_WORKERS_START_OFFSET=latest, or the retained tasks run again.
  • New topic event-publications. It is auto-created where auto-create-topics is on; otherwise provision it.

Changed

  • PUBLISH_EVENT is a task (publish-event@1).
    • The engine still renders and validates the event when the step starts: a bad destination or template still fails the step at once.
    • The task is dispatched through the outbox, and the worker sends the event:
      • Kafka: a CloudEvent on the destination's topic, carrying the trace headers.
      • Embedded: the application's ExternalEventPublisher, then the loopback.
    • Delivery is still at-least-once, with the same stable ce_id.
    • The step completes after the send, with the retries, timeouts and incidents of any worker step. workflow.default-step-timeout-ms now applies to it.
    • __event is sealed like __http when the process has sensitive variables.
  • The standalone http-worker / llm-worker images are optional. Use them to keep egress and its secrets out of the orchestrator's pods. apps/docker-compose.yml no longer starts an http-worker.
  • check-migration: PUBLISH_EVENT is no longer counted as instantaneous.

Added

  • Built-in workers in the orchestrator image.
    • Serves http-calls, llm-calls and event-publications in consumer group orchestrator-builtin-workers.
    • Configured under workflow.http.* / workflow.llm.* (Anthropic and OpenAI providers included) and workflow.events.destinations.
    • Helm: orchestrator.builtinWorkers.{httpAllowedHosts, existingSecret, startOffset}.
  • worker-events: the publish-event task, with workflow.events.worker.enabled / .topic.
  • builtin-workers (pom): every built-in worker in one dependency next to an embedded engine.
  • DIST-39: the orchestrator alone runs HTTP_CALL and PUBLISH_EVENT over Kafka.

Design: BUILTIN-WORKERS-PLAN.md (#580).