@nestjs/workflows 0.0.1

package/dist/sql/workflow-rows.js

@@ -0,0 +1,102 @@
+// What the first-party SQL stores share, free of either dialect: the columns they read, and how a row they read (every
+// column cast to text) becomes an instance or a schedule. PostgresWorkflowStore and MySqlWorkflowStore name the same
+// columns, and the kit's readers (`toText()`, `toInt()`, `toBool()`, `toJson()`) read both dialects' text.
+import { toBool, toInt, toJson } from '@nestjs/store-kit';
+/** The statuses a claim takes: an instance that hasn't finished. */
+export const RUNNABLE_STATUSES = ['pending', 'running', 'suspended', 'compensating'];
+/** The statuses a cancel applies to (a terminate: `RUNNABLE_STATUSES`). */
+export const CANCELLABLE_STATUSES = ['pending', 'running', 'suspended'];
+/** An instance's columns, as `toInstance()` reads them. */
+export const INSTANCE_COLUMNS = [
+    'id',
+    'workflow',
+    'version',
+    'parent_id',
+    'parent_close',
+    'concurrency_key',
+    'rate_limit_key',
+    'priority',
+    'schedule_id',
+    'scheduled_at',
+    'status',
+    'input',
+    'output',
+    'error',
+    'wake_at',
+    'lease_owner',
+    'lease_until',
+    'cancel_requested',
+    'terminate_requested',
+    'cancel_reason',
+    'deadline',
+    'custom_status',
+    'signal_cursor',
+    'runs',
+    'created_at',
+    'updated_at',
+];
+/** A schedule's columns, as `toSchedule()` reads them. */
+export const SCHEDULE_COLUMNS = [
+    'id',
+    'workflow',
+    'declared',
+    'spec',
+    'input',
+    'paused',
+    'wake_at',
+    'state',
+    'revision',
+    'lease_owner',
+    'lease_until',
+    'created_at',
+    'updated_at',
+];
+/** The columns of a signal as `WorkflowStore.signals()` returns it. */
+export const SIGNAL_COLUMNS = ['id', 'name', 'key', 'payload', 'created_at'];
+export function toInstance(row) {
+    return {
+        id: row.id,
+        workflow: row.workflow,
+        version: toInt(row.version),
+        parentId: row.parent_id,
+        parentClose: row.parent_close,
+        concurrencyKey: row.concurrency_key,
+        rateLimitKey: row.rate_limit_key,
+        priority: toInt(row.priority),
+        scheduleId: row.schedule_id,
+        scheduledAt: toInt(row.scheduled_at),
+        status: row.status,
+        input: toJson(row.input),
+        output: toJson(row.output),
+        error: toJson(row.error),
+        wakeAt: toInt(row.wake_at),
+        leaseOwner: row.lease_owner,
+        leaseUntil: toInt(row.lease_until),
+        cancelRequested: toBool(row.cancel_requested),
+        terminateRequested: toBool(row.terminate_requested),
+        cancelReason: row.cancel_reason,
+        deadline: toInt(row.deadline),
+        customStatus: toJson(row.custom_status),
+        signalCursor: toInt(row.signal_cursor),
+        runs: toInt(row.runs),
+        createdAt: toInt(row.created_at),
+        updatedAt: toInt(row.updated_at),
+    };
+}
+export function toSchedule(row) {
+    return {
+        id: row.id,
+        workflow: row.workflow,
+        declared: toBool(row.declared),
+        spec: toJson(row.spec),
+        input: toJson(row.input),
+        paused: toBool(row.paused),
+        wakeAt: toInt(row.wake_at),
+        state: toJson(row.state),
+        revision: toInt(row.revision),
+        leaseOwner: row.lease_owner,
+        leaseUntil: toInt(row.lease_until),
+        createdAt: toInt(row.created_at),
+        updatedAt: toInt(row.updated_at),
+    };
+}

package/dist/sql/workflow-schema.error.d.ts

@@ -0,0 +1,21 @@
+import { WorkflowError } from '../errors/workflow.error.js';
+/**
+ * A first-party SQL store's schema can't serve this version of the package (`PostgresWorkflowStore`,
+ * `MySqlWorkflowStore`): it is behind the store's migrations (and `migrate` is off), or applying them failed (`cause`).
+ * The store refuses every call until it's fixed.
+ */
+export declare class WorkflowSchemaError extends WorkflowError {
+    name: string;
+    /** The store's schema: a PostgreSQL schema, or on MySQL the prefix of its tables' names. */
+    readonly schema: string;
+    /** The schema's version: the last migration applied to it, `0` for none. */
+    readonly version: number;
+    /** The version this version of the package needs: its last migration. */
+    readonly requiredVersion: number;
+    constructor(message: string, details: {
+        schema: string;
+        version: number;
+        requiredVersion: number;
+        cause?: unknown;
+    });
+}

package/dist/sql/workflow-schema.error.js

@@ -0,0 +1,15 @@
+import { WorkflowError } from '../errors/workflow.error.js';
+/**
+ * A first-party SQL store's schema can't serve this version of the package (`PostgresWorkflowStore`,
+ * `MySqlWorkflowStore`): it is behind the store's migrations (and `migrate` is off), or applying them failed (`cause`).
+ * The store refuses every call until it's fixed.
+ */
+export class WorkflowSchemaError extends WorkflowError {
+    constructor(message, details) {
+        super(message, details.cause === undefined ? undefined : { cause: details.cause });
+        this.name = 'WorkflowSchemaError';
+        this.schema = details.schema;
+        this.version = details.version;
+        this.requiredVersion = details.requiredVersion;
+    }
+}

package/dist/storage/encoded-workflow.store.d.ts

@@ -0,0 +1,71 @@
+import type { WorkflowPayloadContext } from '../interfaces/workflow-payload-codec.interface.js';
+import { type PayloadCodecs } from '../core/codecs/payload-codecs.js';
+import type { WorkflowScheduleMethods } from '../utils/schedule-store.util.js';
+import type { WorkflowInstance, WorkflowStatus } from '../interfaces/workflow-instance.interface.js';
+import type { NewWorkflowInstance, NewWorkflowSignal, WorkflowCancelRequest, WorkflowClaim, WorkflowClaimRequest, WorkflowInstanceDetails, WorkflowListQuery, WorkflowPurgeQuery, WorkflowPurgeResult, WorkflowReopen, WorkflowSignalQuery, WorkflowSignalRecord, WorkflowSignalResult, WorkflowStore, WorkflowWrite } from '../interfaces/workflow-store.interface.js';
+/** @internal A `WorkflowStore` without its schedules, which the engine reaches through the core's `Scheduler`. */
+export type WorkflowInstanceStore = Omit<WorkflowStore, WorkflowScheduleMethods>;
+/**
+ * @internal The store as the engine sees it with a codec: payloads encoded on the way in, decoded on the way out, so
+ * the store sees only what the codec returns, and the engine only plain values. Ids, names, keys, statuses and
+ * times pass as they are: the store matches on them. Schedules aren't here: the `Scheduler` encodes their inputs.
+ */
+export declare class EncodedWorkflowStore implements WorkflowInstanceStore {
+    /** The store itself: what it holds, undecoded. */
+    readonly inner: WorkflowStore;
+    readonly codecs: PayloadCodecs<WorkflowPayloadContext>;
+    private static readonly logger;
+    private readonly unreadable;
+    readonly createInTransaction?: WorkflowStore['createInTransaction'];
+    readonly signalInTransaction?: WorkflowStore['signalInTransaction'];
+    constructor(
+    /** The store itself: what it holds, undecoded. */
+    inner: WorkflowStore, codecs: PayloadCodecs<WorkflowPayloadContext>);
+    /** Whether a codec encodes what is written. */
+    get encodes(): boolean;
+    create(instance: NewWorkflowInstance): Promise<{
+        instance: WorkflowInstance;
+        created: boolean;
+    }>;
+    get(id: string, options?: {
+        journal?: boolean;
+    }): Promise<WorkflowInstanceDetails | null>;
+    list(query: WorkflowListQuery): Promise<WorkflowInstance[]>;
+    requestCancel(id: string, request: WorkflowCancelRequest): Promise<boolean>;
+    reopen(id: string, reopen: WorkflowReopen): Promise<boolean>;
+    delete(id: string, statuses: WorkflowStatus[]): Promise<boolean>;
+    signal(signal: NewWorkflowSignal): Promise<WorkflowSignalResult>;
+    signals(query: WorkflowSignalQuery): Promise<WorkflowSignalRecord[]>;
+    purge(query: WorkflowPurgeQuery): Promise<WorkflowPurgeResult>;
+    claim(request: WorkflowClaimRequest): Promise<WorkflowClaim>;
+    /**
+     * Hands a leased instance back untouched, with its waits, due when its lease would have ended: its concurrency slot
+     * is free at once, and the instances due before then go first, instead of this one taking the slot at every claim.
+     */
+    handBack(id: string, token: string, lease: {
+        now: number;
+        leaseUntil: number;
+        signalCursor: number;
+    }): Promise<void>;
+    renew(id: string, token: string, leaseUntil: number): Promise<{
+        cancelRequested: boolean;
+        terminateRequested: boolean;
+    } | null>;
+    write(id: string, token: string, write: WorkflowWrite): Promise<boolean>;
+    private encodeNew;
+    private encodeSignal;
+    private encodeEntries;
+    private decodeEntry;
+    /**
+     * An instance as stored, decoded; one no listed codec can decode any more, without its payloads (its error's name
+     * kept), logged once: a listing shows it instead of failing whole.
+     */
+    readableInstance<T extends WorkflowInstance>(instance: T): Promise<T>;
+    private decodeInstance;
+    private instanceOf;
+    /**
+     * What a claim leased, decoded. One that can't be (a codec that is gone) is left out, logged, and handed back to
+     * be claimed again later, and read once the codec is back, while the others run.
+     */
+    private readable;
+}

package/dist/storage/encoded-workflow.store.js

@@ -0,0 +1,201 @@
+import { Logger } from '@nestjs/common';
+import { isEncodedPayload as encoded } from '../core/codecs/payload-codecs.js';
+import { andThen, toPromise } from '../core/utils/maybe.util.js';
+/**
+ * @internal The store as the engine sees it with a codec: payloads encoded on the way in, decoded on the way out, so
+ * the store sees only what the codec returns, and the engine only plain values. Ids, names, keys, statuses and
+ * times pass as they are: the store matches on them. Schedules aren't here: the `Scheduler` encodes their inputs.
+ */
+export class EncodedWorkflowStore {
+    constructor(
+    /** The store itself: what it holds, undecoded. */
+    inner, codecs) {
+        this.inner = inner;
+        this.codecs = codecs;
+        this.unreadable = new Set();
+        // Only when the store has them: the client tells a store that can't join transactions by their absence.
+        // Nothing is awaited before the store's call when the codec is synchronous (see WorkflowClient.start()).
+        if (typeof inner.createInTransaction === 'function') {
+            this.createInTransaction = (transaction, instance) => this.instanceOf(andThen(this.encodeNew(instance), (encoded) => inner.createInTransaction(transaction, encoded)));
+        }
+        if (typeof inner.signalInTransaction === 'function') {
+            this.signalInTransaction = (transaction, signal) => toPromise(andThen(this.encodeSignal(signal), (encoded) => inner.signalInTransaction(transaction, encoded)));
+        }
+    }
+    /** Whether a codec encodes what is written. */
+    get encodes() {
+        return this.codecs.encodes;
+    }
+    create(instance) {
+        return this.instanceOf(andThen(this.encodeNew(instance), (encoded) => this.inner.create(encoded)));
+    }
+    async get(id, options) {
+        const details = await this.inner.get(id, options);
+        if (!details) {
+            return null;
+        }
+        const decoded = await this.decodeInstance(details);
+        if (details.journal?.some(entryEncoded)) {
+            decoded.journal = await Promise.all(details.journal.map((entry) => this.decodeEntry(entry, id)));
+        }
+        return decoded;
+    }
+    async list(query) {
+        return Promise.all((await this.inner.list(query)).map((instance) => this.decodeInstance(instance)));
+    }
+    async requestCancel(id, request) {
+        const reason = (await this.codecs.encode(request.reason, { field: 'cancelReason', instanceId: id }));
+        return this.inner.requestCancel(id, { ...request, reason });
+    }
+    async reopen(id, reopen) {
+        const [error, entries] = await Promise.all([this.codecs.encodeError(reopen.error, { field: 'error', instanceId: id }), this.encodeEntries(reopen.entries, id)]);
+        return this.inner.reopen(id, { ...reopen, error, entries });
+    }
+    delete(id, statuses) {
+        return this.inner.delete(id, statuses);
+    }
+    signal(signal) {
+        return toPromise(andThen(this.encodeSignal(signal), (encoded) => this.inner.signal(encoded)));
+    }
+    async signals(query) {
+        const records = await this.inner.signals(query);
+        return Promise.all(records.map(async (record) => (encoded(record.payload) ? { ...record, payload: await this.codecs.decode(record.payload, { field: 'payload', signal: record.name }) } : record)));
+    }
+    purge(query) {
+        return this.inner.purge(query);
+    }
+    async claim(request) {
+        const claim = await this.inner.claim(request);
+        const instances = await this.readable(claim.instances, (instance) => this.decodeInstance(instance), 'Instance', (instance) => this.handBack(instance.id, request.token, { now: request.now, leaseUntil: request.leaseUntil, signalCursor: claim.lastSignalId }));
+        return { ...claim, instances };
+    }
+    /**
+     * Hands a leased instance back untouched, with its waits, due when its lease would have ended: its concurrency slot
+     * is free at once, and the instances due before then go first, instead of this one taking the slot at every claim.
+     */
+    async handBack(id, token, lease) {
+        const waits = (await this.inner.get(id))?.waits ?? [];
+        await this.inner.write(id, token, {
+            now: lease.now,
+            entries: [],
+            release: { wakeAt: lease.leaseUntil, waits, signalCursor: lease.signalCursor },
+        });
+    }
+    renew(id, token, leaseUntil) {
+        return this.inner.renew(id, token, leaseUntil);
+    }
+    async write(id, token, write) {
+        const context = (field) => ({ field, instanceId: id });
+        const [entries, output, error, customStatus, signal] = await Promise.all([
+            this.encodeEntries(write.entries, id),
+            this.codecs.encode(write.output, context('output')),
+            this.codecs.encodeError(write.error, context('error')),
+            this.codecs.encode(write.customStatus, context('customStatus')),
+            write.signal ? this.encodeSignal(write.signal) : undefined,
+        ]);
+        return this.inner.write(id, token, {
+            ...write,
+            entries,
+            ...(write.output === undefined ? {} : { output }),
+            ...(write.error === undefined ? {} : { error }),
+            ...(write.customStatus === undefined ? {} : { customStatus }),
+            ...(signal ? { signal } : {}),
+        });
+    }
+    // ---------------------------------------------------------------- payloads
+    encodeNew(instance) {
+        return andThen(this.codecs.encode(instance.input, { field: 'input', instanceId: instance.id }), (input) => ({ ...instance, input }));
+    }
+    encodeSignal(signal) {
+        return andThen(this.codecs.encode(signal.payload, { field: 'payload', signal: signal.name }), (payload) => ({ ...signal, payload }));
+    }
+    encodeEntries(entries, instanceId) {
+        return Promise.all(entries.map(async (entry) => {
+            const context = (field) => ({ field, instanceId, entry: entry.name });
+            const [result, progress, data, error] = await Promise.all([
+                this.codecs.encode(entry.result, context('result')),
+                this.codecs.encode(entry.progress, context('progress')),
+                this.codecs.encode(entry.data, context('data')),
+                this.codecs.encodeError(entry.error, context('error')),
+            ]);
+            return { ...entry, result, progress, data, error };
+        }));
+    }
+    async decodeEntry(entry, instanceId) {
+        if (!entryEncoded(entry)) {
+            return entry;
+        }
+        const context = (field) => ({ field, instanceId, entry: entry.name });
+        const [result, progress, data, error] = await Promise.all([
+            this.codecs.decode(entry.result, context('result')),
+            this.codecs.decode(entry.progress, context('progress')),
+            this.codecs.decode(entry.data, context('data')),
+            this.codecs.decodeError(entry.error, context('error')),
+        ]);
+        // Only the fields the entry has: a store keeps `null` and `undefined` apart, and so does the engine.
+        return {
+            ...entry,
+            ...('result' in entry ? { result } : {}),
+            ...('progress' in entry ? { progress } : {}),
+            ...('data' in entry ? { data } : {}),
+            ...('error' in entry ? { error } : {}),
+        };
+    }
+    /**
+     * An instance as stored, decoded; one no listed codec can decode any more, without its payloads (its error's name
+     * kept), logged once: a listing shows it instead of failing whole.
+     */
+    async readableInstance(instance) {
+        try {
+            return await this.decodeInstance(instance);
+        }
+        catch (error) {
+            if (!this.unreadable.has(instance.id)) {
+                this.unreadable.add(instance.id);
+                EncodedWorkflowStore.logger.warn(`Instance "${instance.id}" is listed without its payloads, which can't be read: ${error.message}`);
+            }
+            const { name } = instance.error ?? {};
+            return { ...instance, input: undefined, output: undefined, customStatus: null, cancelReason: null, error: name === undefined ? null : { name, message: '(unreadable)' } };
+        }
+    }
+    async decodeInstance(instance) {
+        if (![instance.input, instance.output, instance.error?.message, instance.customStatus, instance.cancelReason].some(encoded)) {
+            return instance;
+        }
+        const context = (field) => ({ field, instanceId: instance.id });
+        const [input, output, error, customStatus, cancelReason] = await Promise.all([
+            this.codecs.decode(instance.input, context('input')),
+            this.codecs.decode(instance.output, context('output')),
+            this.codecs.decodeError(instance.error, context('error')),
+            this.codecs.decode(instance.customStatus, context('customStatus')),
+            this.codecs.decode(instance.cancelReason, context('cancelReason')),
+        ]);
+        return { ...instance, input, ...('output' in instance ? { output } : {}), error, customStatus, cancelReason: cancelReason };
+    }
+    async instanceOf(stored) {
+        const { instance, created } = await stored;
+        return { instance: await this.decodeInstance(instance), created };
+    }
+    /**
+     * What a claim leased, decoded. One that can't be (a codec that is gone) is left out, logged, and handed back to
+     * be claimed again later, and read once the codec is back, while the others run.
+     */
+    async readable(claimed, decode, kind, handBack) {
+        const decoded = [];
+        for (const item of claimed) {
+            try {
+                decoded.push(await decode(item));
+            }
+            catch (error) {
+                EncodedWorkflowStore.logger.error(`${kind} "${item.id}" can't be read, so it isn't run; it is claimed again later. ${error.message}`);
+                // At worst its lease expires, as if its worker had died.
+                await handBack(item).catch(() => undefined);
+            }
+        }
+        return decoded;
+    }
+}
+EncodedWorkflowStore.logger = new Logger('Workflows');
+function entryEncoded(entry) {
+    return encoded(entry.result) || encoded(entry.progress) || encoded(entry.data) || encoded(entry.error?.message);
+}

package/dist/storage/index.d.ts

@@ -0,0 +1 @@
+export * from './workflow.storage.js';

package/dist/storage/index.js

@@ -0,0 +1 @@
+export * from './workflow.storage.js';

package/dist/storage/workflow.storage.d.ts

@@ -0,0 +1,55 @@
+import type { WorkflowPayloadCodec, WorkflowPayloadContext } from '../interfaces/workflow-payload-codec.interface.js';
+import type { WorkflowStore } from '../interfaces/workflow-store.interface.js';
+import { EncodedWorkflowStore } from './encoded-workflow.store.js';
+import { PayloadCodecs } from '../core/codecs/payload-codecs.js';
+import type { WorkflowsModuleOptions } from '../interfaces/workflows-module-options.interface.js';
+import type { WorkflowStorageRegisterOptions } from '../interfaces/workflow-storage.interface.js';
+/** Internal: locks the registry. `WorkflowsModule.onModuleInit()` and the first read call it. */
+export declare const LOCK_STORAGE: unique symbol;
+/** Internal: the store the engine uses, `source` with the module's codecs applied to the payloads. */
+export declare const ENGINE_STORE: unique symbol;
+/** Internal: the module's codecs, for the schedules, which the engine encodes apart from the instances. */
+export declare const PAYLOAD_CODECS: unique symbol;
+/**
+ * Where the application tells the package which `WorkflowStore` to use. A provider that
+ * implements `WorkflowStore` injects it and registers itself in its constructor:
+ *
+ * ```ts
+ * @Injectable()
+ * export class DrizzleWorkflowStore implements WorkflowStore {
+ *   constructor(@InjectDrizzle() private readonly db: Database, storage: WorkflowStorage) {
+ *     storage.registerSource(this);
+ *   }
+ *   // ...
+ * }
+ * ```
+ *
+ * With no source registered, the package uses an `InMemoryWorkflowStore`. The registry locks
+ * in `WorkflowsModule`'s `onModuleInit`, when every provider constructor has run and before
+ * the worker starts, or at the first read of the store if that is earlier (another module's
+ * `onModuleInit`). In production, it refuses the in-memory default unless
+ * `allowInMemoryStorage` is set.
+ */
+export declare class WorkflowStorage {
+    private readonly options?;
+    private readonly logger;
+    private registered?;
+    private active?;
+    private engine?;
+    private readonly codecs;
+    constructor(options?: WorkflowsModuleOptions | undefined, codecs?: WorkflowPayloadCodec[]);
+    /**
+     * Makes `source` the store. Call it from the constructor of a singleton provider. Throws
+     * when `source` lacks a method of `WorkflowStore`, when another source is registered
+     * (unless `replace`: tests, wrappers), and once the registry has locked.
+     */
+    registerSource(source: WorkflowStore, options?: WorkflowStorageRegisterOptions): void;
+    /** The store in use: the registered one, or the in-memory default. Reading it locks the registry. */
+    get source(): WorkflowStore;
+    /** @internal The module's codecs. */
+    get [PAYLOAD_CODECS](): PayloadCodecs<WorkflowPayloadContext>;
+    /** @internal `source`, as the engine uses it: payloads encoded with the module's codecs on the way in, and decoded on the way out. */
+    get [ENGINE_STORE](): EncodedWorkflowStore;
+    /** Fixes the source, logs it, and enforces the production guard (which leaves the registry open). */
+    [LOCK_STORAGE](): void;
+}

package/dist/storage/workflow.storage.js

@@ -0,0 +1,159 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable, Logger, Optional } from '@nestjs/common';
+import { InMemoryWorkflowStore } from '../stores/in-memory-workflow.store.js';
+import { WORKFLOWS_MODULE_OPTIONS } from '../workflows.module-definition.js';
+import { WORKFLOW_PAYLOAD_CODECS } from '../workflows.constants.js';
+import { EncodedWorkflowStore } from './encoded-workflow.store.js';
+import { PayloadCodecs } from '../core/codecs/payload-codecs.js';
+/** Internal: locks the registry. `WorkflowsModule.onModuleInit()` and the first read call it. */
+export const LOCK_STORAGE = Symbol('WorkflowStorage.lock');
+/** Internal: the store the engine uses, `source` with the module's codecs applied to the payloads. */
+export const ENGINE_STORE = Symbol('WorkflowStorage.engineStore');
+/** Internal: the module's codecs, for the schedules, which the engine encodes apart from the instances. */
+export const PAYLOAD_CODECS = Symbol('WorkflowStorage.payloadCodecs');
+const REQUIRED = [
+    'create',
+    'get',
+    'list',
+    'requestCancel',
+    'reopen',
+    'delete',
+    'signal',
+    'signals',
+    'purge',
+    'saveSchedule',
+    'getSchedule',
+    'listSchedules',
+    'deleteSchedule',
+    'claimSchedules',
+    'writeSchedule',
+    'claim',
+    'renew',
+    'write',
+];
+const OPTIONAL = ['createInTransaction', 'signalInTransaction'];
+const DEFAULT = 'InMemoryWorkflowStore (the default: state is lost on restart and not shared between instances)';
+/**
+ * Where the application tells the package which `WorkflowStore` to use. A provider that
+ * implements `WorkflowStore` injects it and registers itself in its constructor:
+ *
+ * ```ts
+ * @Injectable()
+ * export class DrizzleWorkflowStore implements WorkflowStore {
+ *   constructor(@InjectDrizzle() private readonly db: Database, storage: WorkflowStorage) {
+ *     storage.registerSource(this);
+ *   }
+ *   // ...
+ * }
+ * ```
+ *
+ * With no source registered, the package uses an `InMemoryWorkflowStore`. The registry locks
+ * in `WorkflowsModule`'s `onModuleInit`, when every provider constructor has run and before
+ * the worker starts, or at the first read of the store if that is earlier (another module's
+ * `onModuleInit`). In production, it refuses the in-memory default unless
+ * `allowInMemoryStorage` is set.
+ */
+let WorkflowStorage = class WorkflowStorage {
+    constructor(options, codecs) {
+        this.options = options;
+        this.logger = new Logger('WorkflowsModule');
+        this.codecs = new PayloadCodecs(codecs ?? [], { name: "WorkflowsModule's codec", type: 'WorkflowPayloadCodec' });
+    }
+    /**
+     * Makes `source` the store. Call it from the constructor of a singleton provider. Throws
+     * when `source` lacks a method of `WorkflowStore`, when another source is registered
+     * (unless `replace`: tests, wrappers), and once the registry has locked.
+     */
+    registerSource(source, options = {}) {
+        validate(source);
+        if (this.active) {
+            throw new Error(`WorkflowStorage.registerSource(): ${nameOf(source)} registered after WorkflowsModule initialized (or after ` +
+                `its storage was first read), which already uses ${this.registered ? nameOf(this.active) : DEFAULT}. ` +
+                'Register from the constructor of a singleton provider: providers of lazy-loaded modules, request-scoped ' +
+                'and transient providers, and lifecycle hooks run too late.');
+        }
+        if (this.registered && !options.replace) {
+            throw new Error(`WorkflowStorage.registerSource(): ${nameOf(source)} can't register, ` +
+                `${this.registered === source ? 'it already did (the same instance, twice)' : `${nameOf(this.registered)} already did`}. ` +
+                'Register one store, or pass { replace: true } to replace it on purpose (tests, wrappers).');
+        }
+        this.registered = source;
+    }
+    /** The store in use: the registered one, or the in-memory default. Reading it locks the registry. */
+    get source() {
+        if (!this.active) {
+            this[LOCK_STORAGE]();
+        }
+        return this.active;
+    }
+    /** @internal The module's codecs. */
+    get [PAYLOAD_CODECS]() {
+        return this.codecs;
+    }
+    /** @internal `source`, as the engine uses it: payloads encoded with the module's codecs on the way in, and decoded on the way out. */
+    get [ENGINE_STORE]() {
+        return (this.engine ??= new EncodedWorkflowStore(this.source, this.codecs));
+    }
+    /** Fixes the source, logs it, and enforces the production guard (which leaves the registry open). */
+    [LOCK_STORAGE]() {
+        if (this.active) {
+            return;
+        }
+        if (!this.registered && process.env.NODE_ENV === 'production' && !this.options?.allowInMemoryStorage) {
+            throw new Error('WorkflowStorage: no WorkflowStore is registered, and NODE_ENV is "production": in memory, running workflows ' +
+                'would be lost on restart and not shared between instances. Register a store on your database: ' +
+                'PostgresWorkflowStore (@nestjs/workflows/postgres), MySqlWorkflowStore (@nestjs/workflows/mysql), or your own ' +
+                'WorkflowStore in a provider that injects WorkflowStorage and calls `storage.registerSource(this)` in its ' +
+                'constructor. Or set `allowInMemoryStorage: true` in the WorkflowsModule options to run in memory anyway.');
+        }
+        this.active = this.registered ?? new InMemoryWorkflowStore();
+        this.logger.log(`WorkflowStorage: ${this.registered ? nameOf(this.registered) : DEFAULT}`);
+    }
+};
+WorkflowStorage = __decorate([
+    Injectable(),
+    __param(0, Optional()),
+    __param(0, Inject(WORKFLOWS_MODULE_OPTIONS)),
+    __param(1, Optional()),
+    __param(1, Inject(WORKFLOW_PAYLOAD_CODECS)),
+    __metadata("design:paramtypes", [Object, Array])
+], WorkflowStorage);
+export { WorkflowStorage };
+/** Throws unless `source` has every method of `WorkflowStore` (the optional ones may be absent). */
+function validate(source) {
+    if (source === null || typeof source !== 'object') {
+        throw new TypeError(`WorkflowStorage.registerSource(): expected an object implementing WorkflowStore, got ${nameOf(source)}.`);
+    }
+    const candidate = source;
+    const missing = REQUIRED.filter((method) => typeof candidate[method] !== 'function');
+    const invalid = OPTIONAL.filter((method) => candidate[method] !== undefined && typeof candidate[method] !== 'function');
+    if (missing.length > 0 || invalid.length > 0) {
+        const problems = [
+            ...(missing.length ? [`${missing.map((m) => `${m}()`).join(', ')} ${missing.length === 1 ? 'is' : 'are'} missing`] : []),
+            ...(invalid.length ? [`${invalid.join(', ')} ${invalid.length === 1 ? 'is' : 'are'} set but not a method`] : []),
+        ];
+        throw new TypeError(`WorkflowStorage.registerSource(): ${nameOf(source)} doesn't implement WorkflowStore: ${problems.join('; ')}.`);
+    }
+}
+/** How a message names a value: its class, or what it is instead of an instance. */
+function nameOf(value) {
+    if (typeof value === 'function') {
+        return `the class ${value.name || '(anonymous)'} (pass an instance)`;
+    }
+    if (value === null || typeof value !== 'object') {
+        return String(value);
+    }
+    const name = value.constructor?.name;
+    return name && name !== 'Object' ? name : 'an object';
+}