@adonis-agora/durable 0.49.0 → 0.50.0

package/dist/src/transports/db.d.ts

@@ -1,8 +1,16 @@
 import type { Database } from '@adonisjs/lucid/database';
 import type { WorkerDescriptor } from '../handshake/descriptor.js';
-import { type ControlMessage, type ControlPlane, type Heartbeat, type RemoteTask, type StepResult, type Transport } from '../interfaces.js';
+import { type ControlMessage, type ControlPlane, type GroupHealth, type Heartbeat, type RemoteTask, type RunReply, type RunRequest, type StartRunMessage, type StepResult, type TenantEvent, type Transport, type WorkflowDecision, type WorkflowStepEvent, type WorkflowTask } from '../interfaces.js';
 import { type StepHandler } from '../protocol.js';
 import type { DescriptorRedis } from '../worker-runtime/registry.js';
+import type { WorkflowTurnHandler } from '../workflow-turn.js';
+import { type ConcurrencyOption } from './adaptive-concurrency.js';
+/**
+ * The `priority` column value for the engine's dispatch `priority` (higher = more urgent): rounded and
+ * clamped to the column's range, and `0` — "normal" — when absent, which is where the queue
+ * transport's broker mapping puts an unprioritised job too.
+ */
+export declare function toDbPriority(priority?: number): number;
 export interface DbTransportOptions {
     /**
      * The Lucid `Database` to read/write. Use the app's own `db` service (no broker, no extra
@@ -37,8 +45,57 @@ export interface DbTransportOptions {
     pollIntervalMs?: number;
     /** How long a claimed-but-unfinished row is owned before it's reclaimable (crash recovery). Default 30s. */
     leaseMs?: number;
-    /** Max rows claimed per poll. Default 20. */
+    /**
+     * Max rows claimed per poll by the results, heartbeat and control loops. Default 20. The task loop
+     * claims only as many rows as it has free {@link concurrency} slots (capped by this), so a worker
+     * never hoards tasks an idle sibling could run.
+     */
     batchSize?: number;
+    /**
+     * How many task rows this worker runs at once. Default 1. One poll loop serves every handler name and
+     * keeps up to this many rows in flight — more slots add no polling — claiming only as many rows per
+     * poll as there are free slots, and renewing every held claim.
+     *
+     * `'adaptive'`, or `{ mode: 'adaptive', min, max, start, tickMs, ramCeilingPct, cpuCeilingPct }`,
+     * lets the {@link AdaptiveController} the BullMQ and queue transports use move the limit at runtime
+     * (from step latency, errors/stalls, RSS and optionally CPU). Either way the limit, in-flight count,
+     * RSS, CPU, throughput and p95 ride this worker's liveness key (see {@link DbTransport.groupHealth}).
+     */
+    concurrency?: ConcurrencyOption;
+    /** How many step results the engine side settles at once. Default 1. */
+    resultConcurrency?: number;
+    /**
+     * Idle backoff for the task, heartbeat and control loops, as a multiple of {@link pollIntervalMs}:
+     * after consecutive empty polls the sleep doubles up to `idleBackoffMax × pollIntervalMs`, and any
+     * poll that finds a row resets it. Default 4 (an idle loop polls every 800ms instead of 200ms); `1`
+     * disables it. The results loop never backs off: a result is on the critical path of every step.
+     */
+    idleBackoffMax?: number;
+    /**
+     * How many times a task row's lapsed claim may be taken over (its worker stopped renewing — crashed,
+     * or blocked its event loop past {@link leaseMs}) before the row is treated as poison: deleted, and a
+     * RETRYABLE failed result published for its step so the engine's durable retry decides (re-dispatch
+     * while attempts remain, then fail the step). Default 3, like the queue transport. Needs the tasks
+     * table's `reclaims` column (added by `autoCreate`); without it reclaims are not counted.
+     */
+    maxStalledCount?: number;
+    /**
+     * How often (ms) a worker refreshes the liveness key of each step name it serves. Default 10000;
+     * each key lives at least 35s (three intervals when longer), so a worker that dies drops out of
+     * {@link DbTransport.groupHealth} within that.
+     */
+    workerHeartbeatIntervalMs?: number;
+    /**
+     * Where a transport failure is reported — a throwing poll, a lost claim, a failed liveness write.
+     * Default `console.error`.
+     */
+    onError?: (err: unknown) => void;
+    /**
+     * How long (ms) `close()`/`stop()` waits for in-flight work — running tasks, a result batch being
+     * settled — before handing every claim still held back to the table, uncounted, so another worker
+     * picks it up at once. Default 5000.
+     */
+    closeTimeoutMs?: number;
     /** Create the transport tables on first use if missing. Default true. */
     autoCreate?: boolean;
     /**
@@ -49,6 +106,19 @@ export interface DbTransportOptions {
     workerKeysCacheMs?: number;
     /** Stable id for this process (stamped on heartbeats / control `from` / `claimed_by`). Default random. */
     instanceId?: string;
+    /**
+     * Store-less protocol and remote workflows: TTL (ms) of the keys an instance writes to say it is
+     * consuming its addressed rows (run replies, tenant events, decisions) and which tenants' events it
+     * wants, re-written every third of it. A publisher addresses rows only to live subscribers, and the
+     * janitor deletes rows addressed to an instance whose key expired. Default 30000.
+     */
+    inboxTtlMs?: number;
+    /** How long a publisher reuses its read of a tenant's live event subscribers (ms). A subscription
+     *  made within this window of an event may miss it. Default 1000; `0` reads on every event. */
+    tenantSubscribersCacheMs?: number;
+    /** How often (ms) an instance that addressed rows deletes those whose recipient is gone (a dead pod,
+     *  an engine that crashed awaiting a decision). Default 30000; `0` disables the janitor. */
+    inboxSweepIntervalMs?: number;
 }
 /**
  * A poll-based, DB-table-backed {@link Transport} (and best-effort {@link ControlPlane}) over
@@ -67,6 +137,12 @@ export interface DbTransportOptions {
  * {@link ControlPlane} here is single-consumer (one row → one poller), correct for a single engine
  * instance but NOT a true broadcast.
  *
+ * It also carries remote workflow turns (`dispatchWorkflowTask` / `handleWorkflow` / `onDecision`,
+ * streamed step events) and the store-less tenant-pod protocol (start-run, run-request, run replies,
+ * tenant events), so a `tenant` pod can reach a `control-plane` over the database alone. Those ride the
+ * `durable_transport_messages` table: run replies go to the requester only, tenant events to every
+ * live subscriber of the tenant, decisions to the engine that dispatched the turn — see `db-remote.ts`.
+ *
  * Run one instance engine-side (`onResult` + `dispatch`) and one per worker process (`handle()` for
  * its group). Call {@link start} to begin the engine-side pollers; `handle()` auto-starts the task
  * loop. The wire payloads are the documented `RemoteTask`/`StepResult` JSON.
@@ -91,19 +167,120 @@ export declare class DbTransport implements Transport, ControlPlane {
      */
     useNamespace(namespace: string): void;
     dispatch(task: RemoteTask): Promise<void>;
+    /**
+     * Park every consumer loop registered from now on ({@link handle}, {@link onResult},
+     * {@link onHeartbeat}, {@link onControl}) until {@link startConsumers}. Task, result, heartbeat and
+     * control rows are claimed by ONE consumer each, so a process not built to be a worker — a
+     * `node ace` command, a REPL — would otherwise claim rows it then dies holding (re-delivered only
+     * after the lease expires) and steal results addressed to the long-lived engine. The same gate as
+     * the `queue` and `bullmq` transports; the provider calls it per the `consumers` config.
+     */
+    deferConsumers(): void;
+    /** Start every loop parked by {@link deferConsumers} and stop deferring (`durable:work` calls it via
+     *  `engine.startConsumers()`). Idempotent; a no-op when consumption was never deferred. */
+    startConsumers(): void;
     /**
      * Register a step handler (worker side). Records this name's routing token
      * (`tenantGroup(sanitizeQueueToken(name), partition)`) as served and starts the shared task poll
      * loop on the first call — it claims task rows for EVERY served token (matching the token the
-     * engine dispatches by), runs each through {@link runStepHandler}, and writes the result.
+     * engine dispatches by), runs each through {@link runStepHandler}, and writes the result. The loop
+     * keeps up to {@link DbTransportOptions.concurrency} rows in flight, and each served token gets a
+     * liveness key once the loop consumes (a deferred, producer-only process advertises nothing).
      */
     handle(name: string, fn: StepHandler): void;
+    /**
+     * Register a WORKFLOW turn consumer (worker side). Shares the task loop — and the routing token —
+     * of a step of the same name: {@link dispatchWorkflowTask} writes a task row of kind `workflow`, which
+     * runs `turn(task)` in a slot like any step, and its {@link WorkflowDecision} is written to the
+     * messages table, addressed to the engine instance that dispatched the turn. Re-registering swaps
+     * the turn fn.
+     */
+    handleWorkflow(name: string, turn: WorkflowTurnHandler): void;
     /** Worker side: publish a liveness heartbeat for an in-flight long step. */
     heartbeat(beat: Heartbeat): Promise<void>;
+    /** Engine side: settle step results, up to {@link DbTransportOptions.resultConcurrency} at once. The
+     *  results loop never backs off when idle — a result is on the critical path of every step. */
     onResult(handler: (result: StepResult) => Promise<void>): void;
     onHeartbeat(handler: (beat: Heartbeat) => Promise<void>): void;
     publishControl(msg: ControlMessage): Promise<void>;
     onControl(handler: (msg: ControlMessage) => void): void;
+    /**
+     * One janitor round: delete the addressed rows older than the inbox TTL whose recipient has no live
+     * inbox key — a requester or subscriber that died, an engine that crashed awaiting a decision. Rows
+     * younger than the TTL are never touched, so an instance that is just starting (or whose key write is
+     * a refresh late) keeps its rows. Reads everything from the database, so it needs no memory of what
+     * was addressed — any instance that addressed a row runs it, and a restart forgets nothing.
+     */
+    sweepInboxes(): Promise<void>;
+    /**
+     * engine → workflow worker: a {@link WorkflowTask} as a task row of kind `workflow` on the workflow's
+     * routing token, where a {@link handleWorkflow} consumer claims it (with the token's steps, by
+     * priority). Stamped with this instance as the decision's recipient when it consumes decisions, so
+     * the decision comes back to the engine that dispatched the turn (any replica could apply it — the
+     * engine applies decisions durably by run id — but the dispatcher is the one known to be live).
+     * Idempotent per `taskId`. Throws when the schema lacks the tasks `kind` column or the messages table.
+     */
+    dispatchWorkflowTask(task: WorkflowTask): Promise<void>;
+    /**
+     * engine ← workflow worker: consume {@link WorkflowDecision}s. ONE loop per transport; every handler
+     * sees every decision (the engine applies one by run id, dropping any its run no longer awaits). It claims the
+     * decisions addressed to this instance — consumed even while consumers are deferred, as nobody else
+     * may take them — and, once consuming, the unaddressed ones (a worker that did not know whom to
+     * reply to). Never backs off: a decision is on the critical path of every remote workflow turn.
+     */
+    onDecision(handler: (decision: WorkflowDecision) => Promise<void>): void;
+    /** workflow worker → engine: a local step's lifecycle, for ONE engine instance to checkpoint. A
+     *  deployment without the messages table drops it (reported once): it is observability only. */
+    dispatchStepEvent(event: WorkflowStepEvent): Promise<void>;
+    /** engine ← workflow worker: consume streamed step events. Idempotent — a second call is a no-op. */
+    onStepEvent(handler: (event: WorkflowStepEvent) => Promise<void>): void;
+    /** tenant → control plane: a {@link StartRunMessage} for any control plane, with this instance as
+     *  the reply's recipient. Throws when the messages table is missing. */
+    dispatchStartRun(msg: StartRunMessage): Promise<void>;
+    /** control plane ← tenant: consume {@link StartRunMessage}s. Idempotent — a second call is a no-op. */
+    onStartRun(handler: (msg: StartRunMessage) => Promise<void>): void;
+    /** tenant → control plane: a {@link RunRequest} for any control plane, with this instance as the
+     *  reply's recipient. Throws when the messages table is missing. */
+    dispatchRunRequest(msg: RunRequest): Promise<void>;
+    /** control plane ← tenant: consume {@link RunRequest}s. Idempotent — a second call is a no-op. */
+    onRunRequest(handler: (msg: RunRequest) => Promise<void>): void;
+    /**
+     * control plane → tenant: a correlated {@link RunReply}, addressed to the instance that sent the
+     * request. Only the instance handling that request knows the requester, so this must run while it
+     * is handled — which is what the responder does. A reply with no known requester is dropped and
+     * reported, never broadcast.
+     */
+    publishRunReply(reply: RunReply): Promise<void>;
+    /**
+     * tenant ← control plane: consume the replies addressed to this instance. Idempotent — a second call
+     * is a no-op (one gateway per transport matches every reply by id). Consumed even while consumers are
+     * deferred: nobody else may take them.
+     */
+    onRunReply(handler: (reply: RunReply) => void): void;
+    /**
+     * control plane → tenant: one row of the {@link TenantEvent} per instance with a live subscription to
+     * `evt.tenant` (none: nothing is written), in one INSERT. Publishes are serialized, so each subscriber
+     * receives one publisher's events in publish order.
+     */
+    publishTenantEvent(evt: TenantEvent): Promise<void>;
+    /**
+     * tenant ← control plane: subscribe to `tenant`'s events. Writes this instance's subscriber key
+     * (kept live every third of {@link DbTransportOptions.inboxTtlMs}) and consumes the events addressed
+     * to it — never deferred, nobody else may take them. Returns an unsubscribe fn that detaches only
+     * this handler; the last one removes the subscription.
+     */
+    onTenantEvent(tenant: string, handler: (evt: TenantEvent) => void): () => void;
+    /**
+     * Per-group worker health, for `engine.workerHealth()` and the dashboard/Telescope worker panels.
+     *
+     * - `depth` is every task row of `group` in this namespace — pending AND claimed (running, or held
+     *   by a worker that died and not yet reclaimed): the DB can count both, so it is closer to BullMQ's
+     *   waiting+active than the queue transport's pending-only count.
+     * - `liveWorkers` are the unexpired `${P}-worker-heartbeat:<group>:<instance>` keys in the
+     *   worker-key table, each with the worker's {@link WorkerStatus} when it carries one (this
+     *   transport's own beats do; a `WorkerRuntime`'s compact beat reads as liveness only).
+     */
+    groupHealth(group: string): Promise<GroupHealth>;
     /** The writer a worker runtime's registry advertises its descriptor and heartbeat through. */
     createDescriptorRedis(): DescriptorRedis;
     /** The live worker descriptors advertised on `token`. */
@@ -116,9 +293,15 @@ export declare class DbTransport implements Transport, ControlPlane {
      * if you prefer an explicit start. Returns once the schema is ready.
      */
     start(): Promise<void>;
-    /** Stop every poll loop and wait (bounded) for in-flight ticks — a claimed task mid-handler gets
-     *  to finish + write its result instead of being abandoned to the lease expiry. Does not close
-     *  the shared `Database`. */
+    /**
+     * Stop every poll loop and wait — bounded by {@link DbTransportOptions.closeTimeoutMs}, 5s by
+     * default — for in-flight work: the tasks in a handler get to finish and write their result, and a
+     * result batch being settled gets to finish. Whatever is still unfinished then is HANDED BACK: its
+     * claims are cleared (only where still ours) so another worker picks the rows up at once, instead of
+     * after the lease — and uncounted, so a deploy never pushes a long step toward the poison bound. A
+     * handler still running here may finish after another worker re-ran its step; its result is
+     * dropped. Does not close the shared `Database`.
+     */
     stop(): Promise<void>;
     /** Stop the pollers (alias of {@link stop} for the `Transport.close` contract). */
     close(): Promise<void>;

package/dist/src/transports/db.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../../src/transports/db.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAKzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,SAAS,EACf,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAkB,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AA6ErE,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,EAAE,EAAE,QAAQ,CAAC;IACb;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mFAAmF;IACnF,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,qFAAqF;IACrF,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,4GAA4G;IAC5G,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,6CAA6C;IAC7C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yEAAyE;IACzE,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,0GAA0G;IAC1G,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,WAAY,YAAW,SAAS,EAAE,YAAY;;IA0BzD,YAAY,OAAO,EAAE,kBAAkB,EAatC;IAED,yEAAyE;IACzE,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED;;;;OAIG;IACH,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAGpC;IA0BK,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CA0B9C;IAMD;;;;;OAKG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,WAAW,GAAG,IAAI,CAM1C;IAED,4EAA4E;IACtE,SAAS,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAY9C;IA6ED,QAAQ,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAE7D;IAED,WAAW,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAE7D;IAuDK,cAAc,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAYvD;IAED,SAAS,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,cAAc,KAAK,IAAI,GAAG,IAAI,CAEtD;IAqGD,8FAA8F;IAC9F,qBAAqB,IAAI,eAAe,CAEvC;IAUD,yDAAyD;IACnD,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAEtE;IAED,iDAAiD;IAC3C,gBAAgB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAE1C;IAOD;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAG3B;IAED;;iCAE6B;IACvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAI1B;IAED,mFAAmF;IAC7E,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAE3B;CACF"}
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../../src/transports/db.ts"],"names":[],"mappings":"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"}