@nestjs/workflows 0.0.1

package/dist/decorators/workflow.decorator.js

@@ -0,0 +1,52 @@
+import { applyDecorators, Injectable, SetMetadata } from '@nestjs/common';
+import { resolveConcurrency, resolveRateLimit } from '../core/limits/limits.js';
+import { runTimeoutMs } from '../utils/run-timeout.util.js';
+import { normalize } from '../utils/normalize.util.js';
+import { assertScheduleId } from '../core/scheduling/schedule-spec.js';
+import { scheduleSpec } from '../utils/schedule-spec.util.js';
+import { WORKFLOW_METADATA } from '../workflows.constants.js';
+/**
+ * Marks an injectable class with a `run(ctx, input)` method as a durable
+ * workflow. Register it as a provider in any module; constructor injection
+ * works as usual. Workflows must be singletons (default scope).
+ */
+export function Workflow(name, options = {}) {
+    if (!/^[\w.:-]+$/.test(name)) {
+        throw new TypeError(`Invalid workflow name "${name}". Use letters, digits, ".", ":", "_" or "-".`);
+    }
+    const version = options.version ?? 1;
+    if (!Number.isInteger(version) || version < 1) {
+        throw new TypeError(`Invalid version ${version} for workflow "${name}". Use a positive integer.`);
+    }
+    const timeout = options.timeout === undefined ? undefined : runTimeoutMs(options.timeout, `workflow "${name}"`);
+    const concurrency = options.concurrency === undefined ? null : resolveConcurrency(`workflow "${name}"`, options.concurrency);
+    const rateLimit = options.rateLimit === undefined ? null : resolveRateLimit(`workflow "${name}"`, options.rateLimit);
+    const schedules = options.schedules === undefined ? [] : schedulesOf(name, options.schedules);
+    return applyDecorators(Injectable(), SetMetadata(WORKFLOW_METADATA, { name, version, timeout, concurrency, rateLimit, schedules }));
+}
+function schedulesOf(name, schedules) {
+    if (!Array.isArray(schedules)) {
+        throw new TypeError(`Workflow "${name}": schedules must be an array, such as [{ id: 'weekly-digest', cron: '0 8 * * MON' }].`);
+    }
+    const ids = new Set();
+    return schedules.map((declaration) => {
+        const id = declaration?.id;
+        assertScheduleId(id, `workflow "${name}"`);
+        if (ids.has(id)) {
+            throw new TypeError(`Workflow "${name}" declares schedule "${id}" twice.`);
+        }
+        ids.add(id);
+        const owner = `Schedule "${id}" of workflow "${name}"`;
+        const inputFn = typeof declaration.input === 'function';
+        let input = declaration.input;
+        if (!inputFn) {
+            try {
+                input = normalize(declaration.input);
+            }
+            catch (error) {
+                throw new TypeError(`${owner}: its input is not JSON-serializable: ${error.message}`);
+            }
+        }
+        return { id, spec: scheduleSpec(owner, declaration, { version: null, inputFn }), input };
+    });
+}

package/dist/errors/child-workflow-failed.error.d.ts

@@ -0,0 +1,13 @@
+import type { SerializedWorkflowError } from '../interfaces/serialized-workflow-error.interface.js';
+import { WorkflowFailedError, type WorkflowFailureStatus } from './workflow-failed.error.js';
+/**
+ * A child workflow (`ctx.startChild()`) ended without completing: what its handle's `result()`
+ * and `ctx.executeChild()` throw in the parent. `status` says how it ended, `cause` is its error.
+ * Built from the journal on every replay, like `StepFailedError`, so a parent that catches it
+ * and branches sees the same error each time.
+ */
+export declare class ChildWorkflowFailedError extends WorkflowFailedError {
+    readonly workflow: string;
+    name: string;
+    constructor(workflow: string, instanceId: string, status: WorkflowFailureStatus, cause: SerializedWorkflowError);
+}

package/dist/errors/child-workflow-failed.error.js

@@ -0,0 +1,14 @@
+import { WorkflowFailedError } from './workflow-failed.error.js';
+/**
+ * A child workflow (`ctx.startChild()`) ended without completing: what its handle's `result()`
+ * and `ctx.executeChild()` throw in the parent. `status` says how it ended, `cause` is its error.
+ * Built from the journal on every replay, like `StepFailedError`, so a parent that catches it
+ * and branches sees the same error each time.
+ */
+export class ChildWorkflowFailedError extends WorkflowFailedError {
+    constructor(workflow, instanceId, status, cause) {
+        super(`Child workflow "${workflow}" ("${instanceId}") ${status.replace('_', ' ')}: ${cause.name}: ${cause.message}`, { instanceId, status, cause });
+        this.workflow = workflow;
+        this.name = 'ChildWorkflowFailedError';
+    }
+}

package/dist/errors/index.d.ts

@@ -0,0 +1,13 @@
+export * from './child-workflow-failed.error.js';
+export * from './non-retryable-step.error.js';
+export * from './step-failed.error.js';
+export * from './step-timeout.error.js';
+export * from './workflow-definition.error.js';
+export * from './workflow-failed.error.js';
+export * from './workflow-id-conflict.error.js';
+export * from './workflow-interrupt.error.js';
+export * from './workflow-non-determinism.error.js';
+export * from './workflow-result-timeout.error.js';
+export * from './workflow-state.error.js';
+export * from './workflow-not-found.error.js';
+export * from './workflow.error.js';

package/dist/errors/index.js

@@ -0,0 +1,13 @@
+export * from './child-workflow-failed.error.js';
+export * from './non-retryable-step.error.js';
+export * from './step-failed.error.js';
+export * from './step-timeout.error.js';
+export * from './workflow-definition.error.js';
+export * from './workflow-failed.error.js';
+export * from './workflow-id-conflict.error.js';
+export * from './workflow-interrupt.error.js';
+export * from './workflow-non-determinism.error.js';
+export * from './workflow-result-timeout.error.js';
+export * from './workflow-state.error.js';
+export * from './workflow-not-found.error.js';
+export * from './workflow.error.js';

package/dist/errors/non-retryable-step.error.d.ts

@@ -0,0 +1,4 @@
+/** Throw from a step to fail it without retrying (a declined card, a 4xx). */
+export declare class NonRetryableStepError extends Error {
+    name: string;
+}

package/dist/errors/non-retryable-step.error.js

@@ -0,0 +1,7 @@
+/** Throw from a step to fail it without retrying (a declined card, a 4xx). */
+export class NonRetryableStepError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = 'NonRetryableStepError';
+    }
+}

package/dist/errors/step-failed.error.d.ts

@@ -0,0 +1,15 @@
+import type { SerializedWorkflowError } from '../interfaces/serialized-workflow-error.interface.js';
+import { WorkflowError } from './workflow.error.js';
+/**
+ * A step gave up (retries exhausted, or a `NonRetryableStepError`). Built from the
+ * journal on both the first run and every replay, so a workflow that catches it
+ * and branches sees exactly the same error each time. The original class is not
+ * preserved; `cause` carries its name and message.
+ */
+export declare class StepFailedError extends WorkflowError {
+    readonly step: string;
+    readonly attempts: number;
+    readonly cause: SerializedWorkflowError;
+    name: string;
+    constructor(step: string, attempts: number, cause: SerializedWorkflowError);
+}

package/dist/errors/step-failed.error.js

@@ -0,0 +1,16 @@
+import { WorkflowError } from './workflow.error.js';
+/**
+ * A step gave up (retries exhausted, or a `NonRetryableStepError`). Built from the
+ * journal on both the first run and every replay, so a workflow that catches it
+ * and branches sees exactly the same error each time. The original class is not
+ * preserved; `cause` carries its name and message.
+ */
+export class StepFailedError extends WorkflowError {
+    constructor(step, attempts, cause) {
+        super(`Step "${step}" failed after ${attempts} attempt(s): ${cause.name}: ${cause.message}`);
+        this.step = step;
+        this.attempts = attempts;
+        this.cause = cause;
+        this.name = 'StepFailedError';
+    }
+}

package/dist/errors/step-timeout.error.d.ts

@@ -0,0 +1,5 @@
+import { WorkflowError } from './workflow.error.js';
+/** A step attempt ran past its `timeout` or `heartbeatTimeout`. Retryable. */
+export declare class StepTimeoutError extends WorkflowError {
+    name: string;
+}

package/dist/errors/step-timeout.error.js

@@ -0,0 +1,8 @@
+import { WorkflowError } from './workflow.error.js';
+/** A step attempt ran past its `timeout` or `heartbeatTimeout`. Retryable. */
+export class StepTimeoutError extends WorkflowError {
+    constructor() {
+        super(...arguments);
+        this.name = 'StepTimeoutError';
+    }
+}

package/dist/errors/workflow-definition.error.d.ts

@@ -0,0 +1,10 @@
+import { WorkflowError } from './workflow.error.js';
+/**
+ * The workflow code cannot run against this instance's journal: a name is used
+ * twice, a `ctx` method is called inside a step, or a deployed change renamed,
+ * removed or reordered steps. The instance fails without compensation, because
+ * the compensations are defined by the same code that no longer matches.
+ */
+export declare class WorkflowDefinitionError extends WorkflowError {
+    name: string;
+}

package/dist/errors/workflow-definition.error.js

@@ -0,0 +1,13 @@
+import { WorkflowError } from './workflow.error.js';
+/**
+ * The workflow code cannot run against this instance's journal: a name is used
+ * twice, a `ctx` method is called inside a step, or a deployed change renamed,
+ * removed or reordered steps. The instance fails without compensation, because
+ * the compensations are defined by the same code that no longer matches.
+ */
+export class WorkflowDefinitionError extends WorkflowError {
+    constructor() {
+        super(...arguments);
+        this.name = 'WorkflowDefinitionError';
+    }
+}

package/dist/errors/workflow-failed.error.d.ts

@@ -0,0 +1,20 @@
+import type { SerializedWorkflowError } from '../interfaces/serialized-workflow-error.interface.js';
+import { WorkflowError } from './workflow.error.js';
+/** How an instance ended when it didn't complete. */
+export type WorkflowFailureStatus = 'failed' | 'cancelled' | 'compensation_failed';
+/**
+ * Thrown by `ctx.fail()`: fails the instance and runs its compensations. Also what
+ * `WorkflowClient.result()` and `startAndWait()` reject with when the instance ended without
+ * completing: then `instanceId`, `status` and `cause` (the instance's error) are set.
+ */
+export declare class WorkflowFailedError extends WorkflowError {
+    name: string;
+    readonly instanceId?: string;
+    readonly status?: WorkflowFailureStatus;
+    readonly cause?: SerializedWorkflowError;
+    constructor(message: string, details?: {
+        instanceId: string;
+        status: WorkflowFailureStatus;
+        cause: SerializedWorkflowError;
+    });
+}

package/dist/errors/workflow-failed.error.js

@@ -0,0 +1,17 @@
+import { WorkflowError } from './workflow.error.js';
+/**
+ * Thrown by `ctx.fail()`: fails the instance and runs its compensations. Also what
+ * `WorkflowClient.result()` and `startAndWait()` reject with when the instance ended without
+ * completing: then `instanceId`, `status` and `cause` (the instance's error) are set.
+ */
+export class WorkflowFailedError extends WorkflowError {
+    constructor(message, details) {
+        super(message);
+        this.name = 'WorkflowFailedError';
+        if (details) {
+            this.instanceId = details.instanceId;
+            this.status = details.status;
+            this.cause = details.cause;
+        }
+    }
+}

package/dist/errors/workflow-id-conflict.error.d.ts

@@ -0,0 +1,6 @@
+import { WorkflowError } from './workflow.error.js';
+/** `start()` with an existing id but a different workflow or input. `status` 409. */
+export declare class WorkflowIdConflictError extends WorkflowError {
+    name: string;
+    readonly status = 409;
+}

package/dist/errors/workflow-id-conflict.error.js

@@ -0,0 +1,9 @@
+import { WorkflowError } from './workflow.error.js';
+/** `start()` with an existing id but a different workflow or input. `status` 409. */
+export class WorkflowIdConflictError extends WorkflowError {
+    constructor() {
+        super(...arguments);
+        this.name = 'WorkflowIdConflictError';
+        this.status = 409;
+    }
+}

package/dist/errors/workflow-interrupt.error.d.ts

@@ -0,0 +1,32 @@
+export type InterruptReason = 
+/** A sleep, wait or retry backoff is pending: the run is parked until later. */
+'suspend'
+/** A replay for compensation reached code that has not run yet. */
+ | 'halt'
+/** `WorkflowClient.cancel()` was accepted while the run was executing. */
+ | 'cancel'
+/** The instance's run timeout passed. */
+ | 'timeout'
+/** The instance's journal reached the module's `journal.maxEntries` or `journal.maxBytes`. */
+ | 'journal-limit'
+/** Another worker took over the instance; nothing this run does is recorded. */
+ | 'lease-lost'
+/** The application is shutting down; the instance is handed back. */
+ | 'shutdown'
+/** The store failed; the instance is retried once the lease expires. */
+ | 'store-error';
+/**
+ * Thrown by `ctx` operations to unwind the workflow function. It is control
+ * flow, not a failure: code that catches errors inside `run()` must rethrow it
+ * (`if (isWorkflowInterrupt(e)) throw e`). The engine does not depend on seeing
+ * it, though. Once an execution is parking, no step starts and nothing passes a
+ * `commit()`; a cancel, shutdown, lost lease or store failure decides the
+ * outcome however `run()` ends. A swallowed interrupt only wastes the code that
+ * runs after it.
+ */
+export declare class WorkflowInterrupt extends Error {
+    readonly reason: InterruptReason;
+    name: string;
+    constructor(reason: InterruptReason);
+}
+export declare function isWorkflowInterrupt(error: unknown): error is WorkflowInterrupt;

package/dist/errors/workflow-interrupt.error.js

@@ -0,0 +1,19 @@
+/**
+ * Thrown by `ctx` operations to unwind the workflow function. It is control
+ * flow, not a failure: code that catches errors inside `run()` must rethrow it
+ * (`if (isWorkflowInterrupt(e)) throw e`). The engine does not depend on seeing
+ * it, though. Once an execution is parking, no step starts and nothing passes a
+ * `commit()`; a cancel, shutdown, lost lease or store failure decides the
+ * outcome however `run()` ends. A swallowed interrupt only wastes the code that
+ * runs after it.
+ */
+export class WorkflowInterrupt extends Error {
+    constructor(reason) {
+        super(`Workflow execution interrupted (${reason}). Rethrow this error if you catch it.`);
+        this.reason = reason;
+        this.name = 'WorkflowInterrupt';
+    }
+}
+export function isWorkflowInterrupt(error) {
+    return error instanceof WorkflowInterrupt;
+}

package/dist/errors/workflow-non-determinism.error.d.ts

@@ -0,0 +1,4 @@
+import { WorkflowDefinitionError } from './workflow-definition.error.js';
+export declare class WorkflowNonDeterminismError extends WorkflowDefinitionError {
+    name: string;
+}

package/dist/errors/workflow-non-determinism.error.js

@@ -0,0 +1,7 @@
+import { WorkflowDefinitionError } from './workflow-definition.error.js';
+export class WorkflowNonDeterminismError extends WorkflowDefinitionError {
+    constructor() {
+        super(...arguments);
+        this.name = 'WorkflowNonDeterminismError';
+    }
+}

package/dist/errors/workflow-not-found.error.d.ts

@@ -0,0 +1,10 @@
+import { WorkflowError } from './workflow.error.js';
+/**
+ * `cancel()` of an unknown instance id, or `start()` of a workflow this
+ * application cannot resolve. `status` 404: the caller asked for something
+ * that doesn't exist, so retrying won't help.
+ */
+export declare class WorkflowNotFoundError extends WorkflowError {
+    name: string;
+    readonly status = 404;
+}

package/dist/errors/workflow-not-found.error.js

@@ -0,0 +1,13 @@
+import { WorkflowError } from './workflow.error.js';
+/**
+ * `cancel()` of an unknown instance id, or `start()` of a workflow this
+ * application cannot resolve. `status` 404: the caller asked for something
+ * that doesn't exist, so retrying won't help.
+ */
+export class WorkflowNotFoundError extends WorkflowError {
+    constructor() {
+        super(...arguments);
+        this.name = 'WorkflowNotFoundError';
+        this.status = 404;
+    }
+}

package/dist/errors/workflow-result-timeout.error.d.ts

@@ -0,0 +1,11 @@
+import { WorkflowError } from './workflow.error.js';
+/**
+ * `WorkflowClient.result()` (or `startAndWait()`) waited for its `timeout` and the instance
+ * hadn't ended. The instance keeps running: wait again, or read it with `getStatus()`.
+ */
+export declare class WorkflowResultTimeoutError extends WorkflowError {
+    readonly instanceId: string;
+    readonly timeoutMs: number;
+    name: string;
+    constructor(instanceId: string, timeoutMs: number);
+}

package/dist/errors/workflow-result-timeout.error.js

@@ -0,0 +1,13 @@
+import { WorkflowError } from './workflow.error.js';
+/**
+ * `WorkflowClient.result()` (or `startAndWait()`) waited for its `timeout` and the instance
+ * hadn't ended. The instance keeps running: wait again, or read it with `getStatus()`.
+ */
+export class WorkflowResultTimeoutError extends WorkflowError {
+    constructor(instanceId, timeoutMs) {
+        super(`Instance "${instanceId}" didn't end within ${timeoutMs}ms. It keeps running; wait for it again or read it with getStatus().`);
+        this.instanceId = instanceId;
+        this.timeoutMs = timeoutMs;
+        this.name = 'WorkflowResultTimeoutError';
+    }
+}

package/dist/errors/workflow-state.error.d.ts

@@ -0,0 +1,11 @@
+import { WorkflowError } from './workflow.error.js';
+/**
+ * An operator action that the instance's status rules out: `retry()` of an instance that isn't
+ * `failed` or `compensation_failed` (or whose compensations already undid its steps),
+ * `delete()` of an unfinished one without `force`, or either racing another change to the same
+ * instance. `status` 409.
+ */
+export declare class WorkflowStateError extends WorkflowError {
+    name: string;
+    readonly status = 409;
+}

package/dist/errors/workflow-state.error.js

@@ -0,0 +1,14 @@
+import { WorkflowError } from './workflow.error.js';
+/**
+ * An operator action that the instance's status rules out: `retry()` of an instance that isn't
+ * `failed` or `compensation_failed` (or whose compensations already undid its steps),
+ * `delete()` of an unfinished one without `force`, or either racing another change to the same
+ * instance. `status` 409.
+ */
+export class WorkflowStateError extends WorkflowError {
+    constructor() {
+        super(...arguments);
+        this.name = 'WorkflowStateError';
+        this.status = 409;
+    }
+}

package/dist/errors/workflow.error.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Base class of the errors the package throws for an app to catch or inspect.
+ * Not of `WorkflowInterrupt` (control flow, never to be kept) or
+ * `NonRetryableStepError` (thrown by the app).
+ */
+export declare abstract class WorkflowError extends Error {
+}

package/dist/errors/workflow.error.js

@@ -0,0 +1,7 @@
+/**
+ * Base class of the errors the package throws for an app to catch or inspect.
+ * Not of `WorkflowInterrupt` (control flow, never to be kept) or
+ * `NonRetryableStepError` (thrown by the app).
+ */
+export class WorkflowError extends Error {
+}

package/dist/events/index.d.ts

@@ -0,0 +1,3 @@
+export * from './workflow-events.interface.js';
+export * from './workflow-events.service.js';
+export * from './workflows.channels.js';

package/dist/events/index.js

@@ -0,0 +1,3 @@
+export * from './workflow-events.interface.js';
+export * from './workflow-events.service.js';
+export * from './workflows.channels.js';

package/dist/events/workflow-events.interface.d.ts

@@ -0,0 +1,145 @@
+import type { SerializedWorkflowError } from '../interfaces/serialized-workflow-error.interface.js';
+import type { WorkflowStatus, WorkflowWait } from '../interfaces/workflow-instance.interface.js';
+/** Fields every lifecycle event carries. */
+export interface WorkflowEventBase {
+    /** Instance id (a schedule's id for `schedule-skipped`). */
+    id: string;
+    workflow: string;
+    version: number;
+    /** Engine clock time (ms). */
+    at: number;
+}
+/** Channel `nestjs:workflows:workflow-started`: the first execution of an instance began. */
+export interface WorkflowStartedEvent extends WorkflowEventBase {
+    type: 'workflow-started';
+}
+/** Channel `nestjs:workflows:workflow-resumed`: a later execution began (after a wait, a sleep, a retry or a crash). */
+export interface WorkflowResumedEvent extends WorkflowEventBase {
+    type: 'workflow-resumed';
+    /** The execution's number, 2 or more. */
+    run: number;
+}
+/** Channel `nestjs:workflows:workflow-suspended`: an execution parked the instance. */
+export interface WorkflowSuspendedEvent extends WorkflowEventBase {
+    type: 'workflow-suspended';
+    wakeAt: number | null;
+    waits: WorkflowWait[];
+}
+/** Channel `nestjs:workflows:workflow-compensating`: the instance failed or was cancelled, and starts undoing. */
+export interface WorkflowCompensatingEvent extends WorkflowEventBase {
+    type: 'workflow-compensating';
+    error: SerializedWorkflowError;
+}
+/** Channel `nestjs:workflows:workflow-completed`. */
+export interface WorkflowCompletedEvent extends WorkflowEventBase {
+    type: 'workflow-completed';
+    output: unknown;
+}
+/** Channel `nestjs:workflows:workflow-failed`: failed, after its compensations ran (none for a definition error). */
+export interface WorkflowFailedEvent extends WorkflowEventBase {
+    type: 'workflow-failed';
+    error: SerializedWorkflowError;
+}
+/** Channel `nestjs:workflows:workflow-cancelled`: cancelled, after its compensations ran. `error.message` is the reason. */
+export interface WorkflowCancelledEvent extends WorkflowEventBase {
+    type: 'workflow-cancelled';
+    error: SerializedWorkflowError;
+}
+/** Channel `nestjs:workflows:workflow-compensation-failed`: an undo gave up halfway. Needs a person. */
+export interface WorkflowCompensationFailedEvent extends WorkflowEventBase {
+    type: 'workflow-compensation-failed';
+    /** The original failure, with the compensation's own error as `compensation`. */
+    error: SerializedWorkflowError;
+}
+/** Channel `nestjs:workflows:step-completed`. */
+export interface WorkflowStepCompletedEvent extends WorkflowEventBase {
+    type: 'step-completed';
+    step: string;
+    attempt: number;
+    durationMs: number;
+}
+/** Channel `nestjs:workflows:step-failed`: an attempt failed. `retryAt` is `null` when the step gave up. */
+export interface WorkflowStepFailedEvent extends WorkflowEventBase {
+    type: 'step-failed';
+    step: string;
+    /** The attempt that failed (1-based). */
+    attempt: number;
+    error: SerializedWorkflowError;
+    retryAt: number | null;
+}
+/** Channel `nestjs:workflows:step-compensated`: a step's compensation completed. */
+export interface WorkflowStepCompensatedEvent extends WorkflowEventBase {
+    type: 'step-compensated';
+    step: string;
+    attempt: number;
+}
+/** Channel `nestjs:workflows:child-started`: the instance started a child (`ctx.startChild()`). */
+export interface WorkflowChildStartedEvent extends WorkflowEventBase {
+    type: 'child-started';
+    /** The child's id. */
+    child: string;
+    childWorkflow: string;
+    childVersion: number;
+}
+/** Channel `nestjs:workflows:signal-received`: a wait took a signal. */
+export interface WorkflowSignalReceivedEvent extends WorkflowEventBase {
+    type: 'signal-received';
+    /** The wait's name. */
+    wait: string;
+    signal: string;
+    signalId: number;
+}
+/** Channel `nestjs:workflows:signal-timed-out`: a wait's deadline passed without a matching signal. */
+export interface WorkflowSignalTimedOutEvent extends WorkflowEventBase {
+    type: 'signal-timed-out';
+    wait: string;
+    signal: string;
+}
+/**
+ * Channel `nestjs:workflows:journal-large`: the instance's journal reached the module's
+ * `journal.warnEntries` or `journal.warnBytes`. Emitted once, when it crosses the line.
+ */
+export interface WorkflowJournalLargeEvent extends WorkflowEventBase {
+    type: 'journal-large';
+    entries: number;
+    bytes: number;
+}
+/**
+ * Channel `nestjs:workflows:custom-status`: the instance's custom status (`ctx.setStatus()`)
+ * changed, and was written.
+ */
+export interface WorkflowCustomStatusEvent extends WorkflowEventBase {
+    type: 'custom-status';
+    status: unknown;
+}
+/**
+ * Channel `nestjs:workflows:workflow-retried`: an operator's `WorkflowClient.retry()` reopened a
+ * `failed` instance (it runs again from its journal) or a `compensation_failed` one (its
+ * compensations run again).
+ */
+export interface WorkflowRetriedEvent extends WorkflowEventBase {
+    type: 'workflow-retried';
+    from: 'failed' | 'compensation_failed';
+    /** The error the instance had. */
+    error: SerializedWorkflowError | null;
+}
+/** Channel `nestjs:workflows:workflow-deleted`: `WorkflowClient.delete()` removed an instance. */
+export interface WorkflowDeletedEvent extends WorkflowEventBase {
+    type: 'workflow-deleted';
+    /** The status it had. */
+    status: WorkflowStatus;
+}
+/**
+ * Channel `nestjs:workflows:schedule-skipped`: a schedule passed over occurrences, missed while no worker was up
+ * (`reason: 'missed'`, see its `missed` option) or due while an instance it started still ran (`'overlap'`). `id`
+ * is the schedule's id, `workflow` and `version` what it starts.
+ */
+export interface WorkflowScheduleSkippedEvent extends WorkflowEventBase {
+    type: 'schedule-skipped';
+    reason: 'missed' | 'overlap';
+    /** The first occurrence it passed over (epoch milliseconds). */
+    from: number;
+    /** The last one. */
+    to: number;
+}
+export type WorkflowEvent = WorkflowStartedEvent | WorkflowResumedEvent | WorkflowSuspendedEvent | WorkflowCompensatingEvent | WorkflowCompletedEvent | WorkflowFailedEvent | WorkflowCancelledEvent | WorkflowCompensationFailedEvent | WorkflowStepCompletedEvent | WorkflowStepFailedEvent | WorkflowStepCompensatedEvent | WorkflowChildStartedEvent | WorkflowSignalReceivedEvent | WorkflowSignalTimedOutEvent | WorkflowJournalLargeEvent | WorkflowCustomStatusEvent | WorkflowRetriedEvent | WorkflowDeletedEvent | WorkflowScheduleSkippedEvent;

package/dist/events/workflow-events.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/events/workflow-events.service.d.ts

@@ -0,0 +1,17 @@
+import { type OnApplicationShutdown } from '@nestjs/common';
+import { type Observable } from 'rxjs';
+import type { WorkflowEvent } from './workflow-events.interface.js';
+/**
+ * This application's lifecycle events, for logs, metrics and alerts. Every event
+ * is also published on its `node:diagnostics_channel` channel
+ * (`nestjs:workflows:<type>`), process-wide, where tracing tools (NestJS Observe,
+ * OpenTelemetry) subscribe without Nest. An instance maps onto one trace: the
+ * instance is the root span, each execution a child span, each step attempt a
+ * span inside it (https://docs.nestjs.com/reliability/workflows#events).
+ */
+export declare class WorkflowEvents implements OnApplicationShutdown {
+    private readonly subject;
+    readonly events$: Observable<WorkflowEvent>;
+    emit(event: WorkflowEvent): void;
+    onApplicationShutdown(): void;
+}