@adonis-agora/durable 0.45.0 → 0.46.1

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @adonis-agora/durable
 
+## 0.46.1
+
+### Patch Changes
+
+- fix(deps): update dependency @adonis-agora/filter to v0.11.0 ([#326](https://github.com/DavideCarvalho/adonis-agora-durable/issues/326))
+
+## 0.46.0
+
+### Minor Changes
+
+- [#321](https://github.com/DavideCarvalho/adonis-agora-durable/pull/321) [`1dcbdc6`](https://github.com/DavideCarvalho/adonis-agora-durable/commit/1dcbdc642ab781ed0313b890c9c30342af893118) Thanks [@DavideCarvalho](https://github.com/DavideCarvalho)! - Shutdown fixes. No unhandled "Connection is closed." when closing while pub/sub subscriptions are still connecting (BullMQ transport, Redis control plane, Redis admission backend): the rejection is ignored once closing has begun, otherwise sent to the transport's `onError` or logged. `BullMQTransport.close()` closes workers first, then queues, under one `closeTimeoutMs` deadline (default 5000, `0` skips the wait; also available on `transports.bullmq()`, which now forwards `onError` too) and always disconnects, so an in-flight step can still publish its result. New `WorkflowEngine.beginDrain()` (called by `drain()` and by the worker loop the moment a stop is requested) sets `draining`: recovery, timer, pending, schedule and timeout sweeps stop locking or starting runs mid-tick, and `runOne` refuses broker-delivered runs.
+
+- [#320](https://github.com/DavideCarvalho/adonis-agora-durable/pull/320) [`27579ca`](https://github.com/DavideCarvalho/adonis-agora-durable/commit/27579ca668c419ac0cc67686da7e7ed2400d37f1) Thanks [@DavideCarvalho](https://github.com/DavideCarvalho)! - `ctx.all` costs O(N) for a fan of N children, sends wide fans in batches, can cap how many children run at once, and folds a settled fan into one checkpoint
+  
+  Previously every settled child could wake the parent, and each wake replayed the whole fan: the parent re-registered a waiter (`putSignalWaiter`), took any buffered completion (`takeBufferedSignal`) and looked up the run (`getRun`) for every child still out. In the in-memory store, a 200-child fan whose children settle one at a time went from 22 parent replays, 1,142 `putSignalWaiter`, 1,163 `takeBufferedSignal` and 1,587 `getRun` calls to 1 replay, 0, 0 and 603. A settled 1,000-child fan now leaves the parent 1 checkpoint row instead of 1,000.
+  
+  - **Join barrier.** A settling child no longer wakes the parent while siblings in the same fan still have waiters. The last child to settle wakes it. A failed child of a `failFast` fan still wakes it immediately.
+  - **Batched dispatch.** The fan is registered 500 children at a time through the new `StateStore.registerChildWaits`, which writes the waiters and the `running` placeholders in one transaction. Its existing checkpoints are read with one prefix query instead of one lookup per child, and the first dispatch no longer looks up each child's run or buffered completion. A child that already ran to completion under its fan id is still delivered: the deferred start that finds it settled re-delivers its completion to the waiter. Sending a 1,200-child fan takes 3 store writes and 1 read from the parent.
+  - **`concurrency` option.** `ctx.all(wf, inputs, { concurrency: 1000 })` keeps at most 1,000 children running. They go out in waves of `floor(concurrency / 2)`, two waves at a time (an odd limit runs one child under it), and the parent sends the next wave as soon as one settles. Wave children carry the wave in their id (`<runId>.all.<firstSeq>.w<k>.<i>`). A limit at or above the fan size keeps the unbounded ids. A non-positive or fractional limit fails the run.
+  - **Folding settled fans.** Once a fan of 100+ children (or one wave of it) settles with every child successful, its per-child checkpoints are replaced, atomically, by one `fan:<child id base>` checkpoint holding the outputs in order, through the new `StateStore.compactCheckpoints`. Every later turn of the parent then loads one row for the fan instead of one per child. Replay expands the folded checkpoint back in memory; `getRunChildren`, cancel cascades, `deleteRun` and `purgeRuns` still reach every child; and runs written before the upgrade replay unchanged. A group with a failed child stays unfolded so `requeue` can retry it, and a fan under 100 children keeps per-child checkpoints for the dashboard.
+  - **No waiter re-registration on replay.** A child's running placeholder is only written with or after its waiter, so neither `ctx.all` nor `ctx.child` re-puts it on replay. `requeue` (the dashboard retry) now puts the waiter itself when it turns a failed child back into a `running` placeholder. If a successful `~retry~` of that child is already buffered, `requeue` settles the checkpoint with it directly.
+  - **Lost-wake re-drive.** A wake that finds the parent's lease held is dropped. If a `ctx.all` fan or wave, or a `ctx.child`, settled during such a turn, the parent re-drives itself once the turn releases the lease, instead of waiting for the `reconcileMs` sweep.
+  - **Run-scoped waiter reads.** `getRunChildren` (and the cancel, delete and purge walks built on it) and `engine.listSignalWaitersByRunIds` read through `listSignalWaitersByRunIds` in batches of 500 run ids, backed by the existing `durable_signal_waiters_run_idx` index; only a store without that method scans every waiter.
+  - **Dashboard.** A folded group renders as its child-run count (`150 child runs`), and a fan of folded waves is labelled `child runs ×N`, instead of the raw `fan:` checkpoint name.
+  - **Telescope.** The current-state gauges and the state breakdown count through the new `engine.countRuns` (a `COUNT` on the Lucid store) instead of listing up to 10,000 runs per status and reporting the length, which capped at 10,000 and read every row. Events of a child run started by `ctx.all`, `ctx.child` or `ctx.startChild` (without a caller-chosen id) carry `parentRunId` on the diagnostics bus, so every child of one parent is one filter away. `parentRunIdOf(runId)` is exported.
+  
+  New optional `StateStore` methods, implemented by the Lucid and in-memory stores and forwarded by `CodecStateStore`, and covered by the conformance kit: `hasSignalWaiter(runId, tokenPrefix)`, `registerChildWaits(entries)` and `compactCheckpoints(runId, fromSeq, toSeq, into)`. A custom store without them keeps working: without `hasSignalWaiter` the parent replays once per settled child, without `registerChildWaits` the waiters and placeholders are written one by one, and without `compactCheckpoints` settled fans are not folded. No schema change: the Lucid store's `run_id` index on `durable_signal_waiters` already exists.
+  
+  A `failFast` fan's `parallelGroup` is now `all:<seq>:failFast` (it was `all:<seq>`), which is how the barrier knows to wake on the first failure. A `failFast` run already suspended before the upgrade is treated as `waitAll` by the barrier: it still throws its `GatherError`, but only once the whole fan has settled.
+
 ## 0.45.0
 
 ### Minor Changes