@adonis-agora/durable 0.58.2 → 0.59.0

package/dist/src/lifecycle-events.d.ts

@@ -0,0 +1,372 @@
+import type { RunStatus, SearchAttributes, StepError, WorkflowRun } from './interfaces.js';
+import { type WorkflowInputOf, type WorkflowOutputOf, type WorkflowRef } from './workflow-ref.js';
+/**
+ * Lifecycle events: when a run settles, the engine publishes `run.completed:<workflow>` or
+ * `run.failed:<workflow>` on the same bus as `publishEvent`, so another workflow can start on it
+ * through `onEvent` (or `@OnWorkflowCompleted` / `@OnWorkflowFailed`)
+ * without the settling workflow knowing it exists.
+ *
+ * Delivery is exactly once per subscriber and settled run. The terminal status write also tags the
+ * run {@link LIFECYCLE_PENDING_TAG}, so a process that dies before publishing leaves a marker the
+ * timer poller's lifecycle sweep picks up; the subscriber's run id is deterministic
+ * ({@link lifecycleRunId}), so publishing twice starts it once.
+ */
+/** The event published when a run of `workflow` completes. */
+export declare function runCompletedEvent(workflow: WorkflowRef): string;
+/** The event published when a run of `workflow` ends failed, cancelled or dead. */
+export declare function runFailedEvent(workflow: WorkflowRef): string;
+/**
+ * Tag written with a run's terminal status when some workflow subscribes to its lifecycle event,
+ * and removed once the event is published. A settled run still carrying it was never published.
+ *
+ * Without any {@link LIFECYCLE_OWED_TAG_PREFIX} tag beside it, the run's owed set is unresolved: the
+ * terminal write happened before this instance could read the subscriptions the fleet announces
+ * (no read yet, or the last one failed). The publish that next reads them successfully resolves it
+ * into owed tags; until then, the subscribers registered on an instance are started by it.
+ */
+export declare const LIFECYCLE_PENDING_TAG = "durable:lifecycle:pending";
+/**
+ * How long after a run settled the lifecycle sweep still looks for subscribers the run owes its
+ * event to but was never marked for: one announced by an instance that came up just after the
+ * run settled, before the settling instance's snapshot of the fleet's subscriptions saw it. A
+ * subscriber that appears later than this is a backfill, done with
+ * `WorkflowEngine.republishLifecycle`.
+ */
+export declare const LIFECYCLE_HEAL_WINDOW_MS: number;
+/** Prefix of the tags naming the subscribers a settled run started (`durable:triggered:<workflow>`). */
+export declare const LIFECYCLE_TRIGGERED_TAG_PREFIX = "durable:triggered:";
+/**
+ * Prefix of the tags naming each subscriber a settled run still owes its lifecycle event to
+ * (`durable:lifecycle:owed:<workflow>`). Written with the terminal status, beside
+ * {@link LIFECYCLE_PENDING_TAG}, for every subscriber registered locally or announced by a live
+ * worker. An instance removes the owed tags of the subscribers it starts; the pending tag goes with
+ * the last owed tag.
+ */
+export declare const LIFECYCLE_OWED_TAG_PREFIX = "durable:lifecycle:owed:";
+/**
+ * How long after a run settled the lifecycle sweep keeps an owed subscriber that no live worker
+ * announces and this instance does not register. Past it, the owed tag is dropped and the engine
+ * emits `run.trigger_failed`, so a removed subscriber does not keep the run from retention forever.
+ */
+export declare const LIFECYCLE_ORPHAN_MS: number;
+/**
+ * Prefix of the tags naming each subscriber a settled run could not start
+ * (`durable:trigger_failed:<workflow>`): its `where` threw, its input was rejected, its start failed,
+ * or the sweep dropped it as an orphan (see {@link LIFECYCLE_ORPHAN_MS}). Written by the same tag
+ * write that drops the subscriber's owed tag, and removed by the write that records a later start of
+ * it. The reason is not stored: it is in the `run.trigger_failed` event the failure emits.
+ */
+export declare const LIFECYCLE_TRIGGER_FAILED_TAG_PREFIX = "durable:trigger_failed:";
+/** The trigger-failed tag of `subscriber` (see {@link LIFECYCLE_TRIGGER_FAILED_TAG_PREFIX}). */
+export declare function lifecycleTriggerFailedTag(subscriber: string): string;
+/** The owed tag of `subscriber` (see {@link LIFECYCLE_OWED_TAG_PREFIX}). */
+export declare function lifecycleOwedTag(subscriber: string): string;
+/** The subscribers a run still owes its lifecycle event to, read from its owed tags. */
+export declare function owedSubscribersOf(run: Pick<WorkflowRun, 'tags'>): string[];
+/**
+ * Prefix of the tags naming each debounce/batch subscriber a settled run's event was routed to
+ * (`durable:coalesced:<workflow>`). Such a subscriber starts no run of the source's id, so it gets no
+ * {@link LIFECYCLE_TRIGGERED_TAG_PREFIX} tag; this one records the delivery instead, written by the
+ * same tag write that drops its owed tag.
+ */
+export declare const LIFECYCLE_COALESCED_TAG_PREFIX = "durable:coalesced:";
+/** The coalesced tag of `subscriber` (see {@link LIFECYCLE_COALESCED_TAG_PREFIX}). */
+export declare function lifecycleCoalescedTag(subscriber: string): string;
+/** The subscribers whose {@link LIFECYCLE_COALESCED_TAG_PREFIX} tag is in `tags`. */
+export declare function coalescedSubscribersOf(tags: readonly string[] | undefined): string[];
+/**
+ * The subscribers a settled run's tags record as done with its event: started (a
+ * {@link LIFECYCLE_TRIGGERED_TAG_PREFIX} tag), routed into an accumulator (a
+ * {@link LIFECYCLE_COALESCED_TAG_PREFIX} tag) or failed (a {@link LIFECYCLE_TRIGGER_FAILED_TAG_PREFIX}
+ * tag).
+ */
+export declare function deliveredSubscribersOf(run: Pick<WorkflowRun, 'tags'>): Set<string>;
+/**
+ * Prefix of the tag holding the W3C `traceparent` of a settled run's own span
+ * (`durable:lifecycle:trace:<traceparent>`). Written with the lifecycle marker, when some workflow
+ * subscribes to the run's ending and the engine has a run trace provider (see
+ * `WorkflowEngine.setRunTraceparent`), so a subscriber's trace can link to its source run from any
+ * process.
+ */
+export declare const LIFECYCLE_TRACE_TAG_PREFIX = "durable:lifecycle:trace:";
+/** The traceparent a settled run recorded in its {@link LIFECYCLE_TRACE_TAG_PREFIX} tag, if any. */
+export declare function lifecycleTraceparentOf(tags: readonly string[] | undefined): string | undefined;
+/** Whether `tag` is one of the engine's lifecycle bookkeeping tags rather than a user tag. */
+export declare function isLifecycleTag(tag: string): boolean;
+/** The payload of a lifecycle event, read from the store after the run settled. */
+export interface WorkflowLifecycleEvent<TInput = unknown, TOutput = unknown> {
+    runId: string;
+    workflow: string;
+    workflowVersion: string;
+    /** `completed` on `run.completed:*`; `failed`, `cancelled` or `dead` on `run.failed:*`. */
+    status: RunStatus;
+    namespace?: string | undefined;
+    input: TInput;
+    /** Present on a completed run. */
+    output?: TOutput | undefined;
+    /** Present on a run that did not complete. */
+    error?: StepError | undefined;
+    tags?: string[] | undefined;
+    searchAttributes?: SearchAttributes | undefined;
+}
+/** The lifecycle event a run of workflow class `C` publishes, typed by its input and output. */
+export type LifecycleEventOf<C> = WorkflowLifecycleEvent<WorkflowInputOf<C>, WorkflowOutputOf<C>>;
+/** Which lifecycle event a settled run publishes: `completed`, or `failed` for any other ending. */
+export type LifecycleKind = 'completed' | 'failed';
+/**
+ * The id of the run a lifecycle event starts for `subscriber`. Deterministic, so the same settled
+ * run never starts the same subscriber twice, and either side of the link can be found from the other.
+ */
+export declare function lifecycleRunId(sourceRunId: string, kind: LifecycleKind, subscriber: string): string;
+/** The lifecycle event a run in `status` published, or undefined while it has not settled. */
+export declare function lifecycleKindOf(status: RunStatus | undefined): LifecycleKind | undefined;
+/** The event name a run of `workflow` publishes when it settles as `kind`. */
+export declare function lifecycleEventName(workflow: string, kind: LifecycleKind): string;
+/** The workflow and ending a lifecycle event name stands for, or undefined for any other event. */
+export declare function parseLifecycleEvent(event: string): {
+    workflow: string;
+    kind: LifecycleKind;
+} | undefined;
+/**
+ * One workflow that starts when another settles, as the dashboard's workflow page lists it. `local`
+ * is what the answering instance has registered, with what its subscription does to the payload;
+ * an entry only live workers announce (a Python subscriber, or a TypeScript one served elsewhere)
+ * states none of that, since the announcement carries only the event name.
+ */
+export interface LifecycleSubscriptionLink {
+    /** The other end: the subscriber on `startsOnSettle`, the settling workflow on `startedBy`. */
+    workflow: string;
+    kind: LifecycleKind;
+    /** Registered on the answering instance (true) or only announced by live workers (false). */
+    local: boolean;
+    /** Announced by at least one live worker. */
+    announced: boolean;
+    /** The subscription filters payloads with `where`. */
+    where: boolean;
+    /** The subscription maps the payload to the run's input with `input`. */
+    input: boolean;
+    /** The subscriber coalesces events: debounced or batched, and whether per `key`. */
+    coalesce?: {
+        mode: 'debounce' | 'batch';
+        keyed: boolean;
+    } | undefined;
+}
+/**
+ * Who starts whom through lifecycle events, for one workflow: the subscribers of its
+ * `run.completed:<workflow>` / `run.failed:<workflow>` events, and the workflows whose settling
+ * starts it. Built from the answering instance's registry and the subscriptions live workers
+ * announce.
+ */
+export interface WorkflowLifecycleLinks {
+    workflow: string;
+    /** Workflows that start when this one settles, sorted by workflow then kind. */
+    startsOnSettle: LifecycleSubscriptionLink[];
+    /** Workflows whose settling starts this one, sorted by workflow then kind. */
+    startedBy: LifecycleSubscriptionLink[];
+}
+/**
+ * The run whose settling started `run`, when a lifecycle event started it. Read from the run's id,
+ * which ends in `:<kind>:<its own workflow>`, so it holds whatever input the subscriber was given.
+ */
+export declare function lifecycleSourceOf(run: {
+    id: string;
+    workflow: string;
+}): {
+    runId: string;
+    kind: LifecycleKind;
+} | undefined;
+/**
+ * The runs `run`'s settling started, read from its {@link LIFECYCLE_TRIGGERED_TAG_PREFIX} tags.
+ * Empty for a run that has not settled or started nobody. Needs no subscriber registry, so any
+ * process holding the run row can answer it.
+ */
+export declare function triggeredRunsOf(run: Pick<WorkflowRun, 'id' | 'status' | 'tags'>): string[];
+/** The {@link WorkflowLifecycleEvent} a settled run publishes. */
+export declare function lifecycleEventOf(run: WorkflowRun): WorkflowLifecycleEvent;
+/**
+ * What `engine.republishLifecycle` publishes again: one settled run, or the settled runs of a
+ * workflow (by ending and settle time). `subscriber` restricts it to one subscribing workflow.
+ */
+export type RepublishLifecycleTarget = {
+    runId: string;
+    subscriber?: string | undefined;
+} | {
+    workflow: string;
+    /** Only runs that settled this way. Both when absent. */
+    kind?: LifecycleKind | undefined;
+    /** Only runs that settled at or after this instant. */
+    since?: Date | undefined;
+    /** Only runs that settled at or before this instant. */
+    until?: Date | undefined;
+    subscriber?: string | undefined;
+    /** At most this many runs. Default 1000. */
+    limit?: number | undefined;
+    /**
+     * Only runs of this namespace. Defaults to the engine's own namespace (every namespace on an
+     * engine without one). The run gateway's tenant proxy forces it to the tenant's.
+     */
+    namespace?: string | undefined;
+};
+/** What `engine.republishLifecycle` did. */
+export interface RepublishLifecycleResult {
+    /** Settled runs it published. */
+    runs: number;
+    /** Subscriber runs it started. A subscriber run that already existed is not counted. */
+    started: number;
+    /** Subscribers it could not start, with why. */
+    failed: {
+        runId: string;
+        subscriber: string;
+        error: string;
+    }[];
+}
+/** The literal prefix of every `ctx.waitForRun` waiter token. */
+export declare const RUN_WAIT_TOKEN_PREFIX = "runwait:";
+/** Token prefix of every `ctx.waitForRun` waiter on `targetRunId`. */
+export declare function runWaitPrefix(targetRunId: string): string;
+/** The waiter token of one `ctx.waitForRun(targetRunId)` call, unique by the waiting run's `runId#seq`. */
+export declare function runWaitToken(targetRunId: string, runId: string, seq: number): string;
+/**
+ * The run a `ctx.waitForRun` waiter waits for, read from its token, or undefined for any other
+ * waiter. The token ends in the waiter's own `#<runId>#<seq>`, so a target id holding `#` still
+ * parses.
+ */
+export declare function runWaitTargetOf(waiter: {
+    token: string;
+    runId: string;
+    seq: number;
+}): string | undefined;
+/**
+ * One end of a `ctx.waitForRun` wait, as a run detail lists it: the run waited for (`waitsFor`) or
+ * the waiting run (`awaitedBy`), the waiting run's `seq` of the call, and the other run's status and
+ * namespace when it was read.
+ */
+export interface RunWaitLink {
+    runId: string;
+    seq: number;
+    status?: RunStatus | undefined;
+    namespace?: string | undefined;
+}
+/**
+ * Where a settled run's lifecycle event stands for one subscriber:
+ * - `started`: its run exists (`runId`, a `durable:triggered:<subscriber>` tag);
+ * - `owed`: still pending (a `durable:lifecycle:owed:<subscriber>` tag);
+ * - `failed`: its last delivery failed (a `durable:trigger_failed:<subscriber>` tag): its `where`
+ *   threw, its input was rejected, its start failed, or the sweep dropped it as an orphan. A
+ *   republish retries it;
+ * - `coalesced`: routed into a debounce/batch accumulator (a `durable:coalesced:<subscriber>` tag;
+ *   `runId` is the accumulator's, when it can be derived);
+ * - `not-started`: no run and nothing owed: its `where` declined the event, or it subscribed after
+ *   the run settled.
+ */
+export type LifecycleDeliveryState = 'started' | 'owed' | 'failed' | 'coalesced' | 'not-started';
+/** One subscriber of a settled run's lifecycle event, as the run detail lists it. */
+export interface LifecycleDelivery {
+    subscriber: string;
+    state: LifecycleDeliveryState;
+    /** The subscriber's run when `started`; the accumulator run when `coalesced` and derivable. */
+    runId?: string | undefined;
+    /** The status of a `started` subscriber's run, when it was read. */
+    status?: RunStatus | undefined;
+    /** The namespace of a `started` subscriber's run, when it was read. */
+    namespace?: string | undefined;
+    /** When an `owed` subscriber became owed: the settled run's last update (epoch ms). */
+    owedSince?: number | undefined;
+    /**
+     * When the lifecycle sweep drops an `owed` subscriber that no live instance registers or
+     * announces for the run's namespace (epoch ms; see {@link LIFECYCLE_ORPHAN_MS}). Absent while one
+     * does.
+     */
+    orphanAt?: number | undefined;
+    /**
+     * Why a `failed` subscriber could not be started, when the caller knows it (the `run.trigger_failed`
+     * event carries it). Not stored with the run, so {@link lifecycleDeliveriesOf} leaves it unset.
+     */
+    error?: string | undefined;
+}
+/**
+ * The {@link LifecycleDelivery} of each subscriber of a settled run, sorted by subscriber: the
+ * union of `subscribers` (the ones the run's event goes to now), the owed, triggered, coalesced and
+ * trigger-failed tags. A started or coalesced subscriber wins over the others, then an owed one over
+ * a failed one. `live` names the subscribers a live instance registers or announces; an owed
+ * subscriber outside it gets `orphanAt`. `coalesced` maps each subscriber that coalesces its events
+ * to its accumulator run id (undefined when it cannot be derived), the link of a coalesced one; a
+ * subscriber in it with no tag at all (a run settled before coalesced deliveries were tagged) is
+ * `coalesced` too. Empty for a run that has not settled.
+ */
+export declare function lifecycleDeliveriesOf(run: Pick<WorkflowRun, 'id' | 'status' | 'tags' | 'updatedAt'>, opts: {
+    subscribers: readonly string[];
+    live: ReadonlySet<string>;
+    coalesced?: ReadonlyMap<string, string | undefined> | undefined;
+}): LifecycleDelivery[];
+/** The id of the run a continue-as-new of `runId` hands off to: `r` → `r~1` → `r~2` … */
+export declare function nextContinuationId(runId: string): string;
+/** How many continue-as-new hops `ctx.waitForRun` follows to the run that ends a chain. */
+export declare const RUN_WAIT_MAX_HOPS = 100;
+/**
+ * The run that ends `runId`'s continue-as-new chain: `runId` itself, or the last continuation it
+ * handed off to, following at most {@link RUN_WAIT_MAX_HOPS} hops. A completed run whose
+ * continuation exists was a handoff, not the end. Null when `runId` is unknown.
+ */
+export declare function lastRunOfChain(getRun: (runId: string) => Promise<WorkflowRun | null>, runId: string): Promise<WorkflowRun | null>;
+/**
+ * The runs whose continue-as-new chain `runId` may end (`r~3` → `r`, `r~1`, `r~2`, at most
+ * {@link RUN_WAIT_MAX_HOPS}), so a `ctx.waitForRun` on an earlier run of the chain is found when the
+ * last one settles. Empty for a run that is no continuation.
+ */
+export declare function chainPredecessorsOf(runId: string): string[];
+/**
+ * The internal workflow whose runs make up the lifecycle subscription registry: one completed run
+ * per engine that registers `onEvent` subscriptions (lifecycle ones included), id
+ * {@link lifecycleRegistryRunId}, tagged {@link LIFECYCLE_REGISTRY_TAG}, its subscriptions in
+ * `input` ({@link LifecycleRegistryEntry}) and its `updatedAt` the heartbeat. Each heartbeat also
+ * sets `createdAt`, so a read of the live runs is a range over the store's `created_at` index. Kept
+ * in the state store, so an engine learns what the others subscribe to over any transport.
+ * Retention, run lists and the dashboard skip these runs.
+ */
+export declare const LIFECYCLE_REGISTRY_WORKFLOW = "__lifecycle_registry";
+/** Tag every registry run carries. Retention never prunes a run that has it. */
+export declare const LIFECYCLE_REGISTRY_TAG = "durable:lifecycle:registry";
+/** How often an engine's worker tick rewrites its registry run. */
+export declare const LIFECYCLE_REGISTRY_HEARTBEAT_MS = 10000;
+/** How long after its last heartbeat a registry run still counts as a live engine's. */
+export declare const LIFECYCLE_REGISTRY_TTL_MS = 35000;
+/** How long after its last heartbeat a registry run is deleted, by the tick of an engine with one. */
+export declare const LIFECYCLE_REGISTRY_STALE_MS: number;
+/** The id of the registry run of engine instance `instanceId`. */
+export declare function lifecycleRegistryRunId(instanceId: string): string;
+/** What a registry run holds in `input`: the `onEvent` subscriptions of one engine instance. */
+export interface LifecycleRegistryEntry {
+    instanceId: string;
+    runtime: 'node';
+    /**
+     * The namespace of the engine that writes the row, or `null` for an engine with no namespace. The
+     * row's own `namespace` cannot tell the two apart: the stores write both as `default`. An engine
+     * with no namespace sweeps and starts its subscribers for the runs of every namespace, so its
+     * subscriptions are owed by settled runs of any namespace; an engine with one, only by its own.
+     */
+    engineNamespace: string | null;
+    /** Each subscribing workflow with the event names it starts on, lifecycle ones included. */
+    subscriptions: {
+        workflow: string;
+        events: string[];
+    }[];
+}
+/**
+ * The namespace whose settled runs owe their lifecycle events to the subscriptions of a registry
+ * run, or `null` for every namespace: the entry's `engineNamespace`, or for a row written without it,
+ * the row's `namespace`, read as every namespace when that is `default` (an engine with no namespace
+ * wrote it, as far as the row can tell).
+ */
+export declare function lifecycleRegistryNamespace(input: unknown, rowNamespace: string | undefined): string | null;
+/** The subscriptions a registry run's `input` holds; malformed entries are skipped. */
+export declare function lifecycleRegistrySubscriptions(input: unknown): {
+    workflow: string;
+    events: string[];
+}[];
+/**
+ * Whether retention must keep a run with these `tags`: its lifecycle event is still owed
+ * ({@link LIFECYCLE_PENDING_TAG}), or it is a lifecycle registry run ({@link LIFECYCLE_REGISTRY_TAG}).
+ */
+export declare function retentionKeeps(tags: unknown): boolean;
+//# sourceMappingURL=lifecycle-events.d.ts.map

package/dist/src/lifecycle-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle-events.d.ts","sourceRoot":"","sources":["../../src/lifecycle-events.ts"],"names":[],"mappings":"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"}