@nestjs/workflows 0.0.1 → 0.0.3

package/dist/core/results/result-waiter.d.ts

@@ -49,6 +49,11 @@ export declare class ResultWaiter<T = unknown> {
      * connections idle at that moment, and one that answers later stays open until its keep-alive timeout.
      */
     close(): Promise<void>;
+    /**
+     * Reads `id`, unless the wait settles first. It races a promise of its own, not one the whole wait shares: each
+     * race leaves a reaction on its inputs until they settle, so a shared one would keep one per poll.
+     */
+    private read;
     private add;
     private remove;
 }

package/dist/core/results/result-waiter.js

@@ -47,13 +47,11 @@ export class ResultWaiter {
         const timeoutMs = options.timeout === undefined ? Infinity : parseDuration(options.timeout);
         const deadline = performance.now() + timeoutMs;
         options.signal?.throwIfAborted();
-        let settle;
-        const settled = new Promise((resolve) => (settle = () => resolve(SETTLED)));
-        const wait = { closed: this.closed, settle };
+        const wait = { closed: this.closed };
         const nudge = () => wait.wake?.();
         const close = () => {
             wait.closed = true;
-            settle();
+            wait.settle?.();
             nudge();
         };
         this.add(id, wait);
@@ -61,7 +59,7 @@ export class ResultWaiter {
         options.signal?.addEventListener('abort', nudge);
         try {
             for (let delay = 25;; delay = Math.min(delay * 2, 1_000)) {
-                const read = wait.outcome || wait.closed ? SETTLED : await Promise.race([this.options.read(id), settled]);
+                const read = wait.outcome || wait.closed ? SETTLED : await this.read(id, wait);
                 if (wait.outcome) {
                     return unwrap(wait.outcome);
                 }
@@ -104,7 +102,7 @@ export class ResultWaiter {
         const settled = typeof outcome === 'function' ? outcome() : outcome;
         for (const wait of waits) {
             wait.outcome ??= settled;
-            wait.settle();
+            wait.settle?.();
             wait.wake?.();
         }
     }
@@ -117,6 +115,19 @@ export class ResultWaiter {
         this.closing.abort();
         await nextMacrotask();
     }
+    /**
+     * Reads `id`, unless the wait settles first. It races a promise of its own, not one the whole wait shares: each
+     * race leaves a reaction on its inputs until they settle, so a shared one would keep one per poll.
+     */
+    async read(id, wait) {
+        const settled = new Promise((resolve) => (wait.settle = () => resolve(SETTLED)));
+        try {
+            return await Promise.race([this.options.read(id), settled]);
+        }
+        finally {
+            wait.settle = undefined;
+        }
+    }
     add(id, wait) {
         let waits = this.waits.get(id);
         if (!waits) {

package/dist/core/workers/leased-worker.d.ts

@@ -49,8 +49,8 @@ export declare class LeasedWorker<T> {
     /** Claims in flight: shutdown waits for them, so nothing they claim starts unobserved. */
     private readonly claiming;
     private stopped;
-    private stop;
-    private readonly stoppedPromise;
+    /** Ends the `drain()` rounds waiting now, at shutdown. */
+    private readonly stopping;
     private wake?;
     private kicked;
     private loop?;
@@ -76,6 +76,11 @@ export declare class LeasedWorker<T> {
      * `shutdownTimeout` spent waiting for them before the rest are detached. Call it from `onModuleDestroy`.
      */
     shutdown(): Promise<void>;
+    /**
+     * Waits for `work`, or until shutdown. It races a promise of its own, not one the worker keeps: each race leaves a
+     * reaction on its inputs until they settle, so a long-lived one would keep one per round.
+     */
+    private untilStopped;
     private poll;
     private idle;
     /** Claims due items and starts executing them (before any caller sees them). */

package/dist/core/workers/leased-worker.js

@@ -43,7 +43,8 @@ export class LeasedWorker {
         /** Claims in flight: shutdown waits for them, so nothing they claim starts unobserved. */
         this.claiming = new Set();
         this.stopped = false;
-        this.stoppedPromise = new Promise((resolve) => (this.stop = resolve));
+        /** Ends the `drain()` rounds waiting now, at shutdown. */
+        this.stopping = new Set();
         this.kicked = false;
         /** When the loop next calls `produce()` (`performance.now()`). */
         this.produceAt = 0;
@@ -96,7 +97,7 @@ export class LeasedWorker {
                 break;
             }
             total += executions.length;
-            await Promise.race([Promise.all(executions), this.stoppedPromise]);
+            await this.untilStopped(Promise.all(executions));
         }
         return total;
     }
@@ -109,7 +110,9 @@ export class LeasedWorker {
             return;
         }
         this.stopped = true;
-        this.stop();
+        for (const stop of this.stopping) {
+            stop();
+        }
         this.wake?.();
         // What a claim in flight claims starts now, told to stop at once, so it is handed back before the store closes.
         await Promise.allSettled(this.claiming);
@@ -127,6 +130,24 @@ export class LeasedWorker {
         }
         await this.loop;
     }
+    /**
+     * Waits for `work`, or until shutdown. It races a promise of its own, not one the worker keeps: each race leaves a
+     * reaction on its inputs until they settle, so a long-lived one would keep one per round.
+     */
+    async untilStopped(work) {
+        let stop;
+        const stopped = new Promise((resolve) => (stop = resolve));
+        if (this.stopped) {
+            stop();
+        }
+        this.stopping.add(stop);
+        try {
+            await Promise.race([work, stopped]);
+        }
+        finally {
+            this.stopping.delete(stop);
+        }
+    }
     async poll() {
         while (!this.stopped) {
             if (this.options.produce && performance.now() >= this.produceAt) {

package/dist/index.d.ts

@@ -11,7 +11,7 @@ export { ChildWorkflowFailedError, isWorkflowInterrupt, NonRetryableStepError, S
 export type { SerializedWorkflowError } from './interfaces/index.js';
 export { WorkflowEvents, type WorkflowCancelledEvent, type WorkflowChildStartedEvent, type WorkflowCompensatingEvent, type WorkflowCompensationFailedEvent, type WorkflowCompletedEvent, type WorkflowCustomStatusEvent, type WorkflowDeletedEvent, type WorkflowEvent, type WorkflowFailedEvent, type WorkflowJournalLargeEvent, type WorkflowResumedEvent, type WorkflowRetriedEvent, type WorkflowScheduleSkippedEvent, type WorkflowSignalReceivedEvent, type WorkflowSignalTimedOutEvent, type WorkflowStartedEvent, type WorkflowStepCompensatedEvent, type WorkflowStepCompletedEvent, type WorkflowStepFailedEvent, type WorkflowSuspendedEvent, } from './events/index.js';
 export { WorkflowStorage } from './storage/index.js';
-export type { NewWorkflowInstance, NewWorkflowSignal, WorkflowCancelRequest, WorkflowClaim, WorkflowClaimRequest, WorkflowConcurrencyLimit, WorkflowInstanceDetails, WorkflowListQuery, WorkflowPurgeQuery, WorkflowPurgeResult, WorkflowRateLimitRule, WorkflowRateWindow, WorkflowRelease, WorkflowReopen, WorkflowScheduleClaimRequest, WorkflowScheduleQuery, WorkflowScheduleRecord, WorkflowScheduleSave, WorkflowScheduleWrite, WorkflowSignalQuery, WorkflowSignalRecord, WorkflowSignalResult, WorkflowStorageRegisterOptions, WorkflowStore, WorkflowWrite, } from './interfaces/index.js';
+export type { NewWorkflowInstance, NewWorkflowSignal, WorkflowCancelRequest, WorkflowClaim, WorkflowClaimRequest, WorkflowConcurrencyLimit, WorkflowInstanceDetails, WorkflowKeyKind, WorkflowListQuery, WorkflowPurgeQuery, WorkflowPurgeResult, WorkflowRateLimitRule, WorkflowRateWindow, WorkflowRelease, WorkflowReopen, WorkflowScheduleClaimRequest, WorkflowScheduleQuery, WorkflowScheduleRecord, WorkflowScheduleSave, WorkflowScheduleWrite, WorkflowSignalQuery, WorkflowSignalRecord, WorkflowSignalResult, WorkflowStorageRegisterOptions, WorkflowStore, WorkflowWrite, } from './interfaces/index.js';
 export * from './stores/index.js';
 export { AesGcmPayloadCodec, type AesGcmPayloadCodecOptions } from './core/codecs/index.js';
 export type { WorkflowPayloadCodec, WorkflowPayloadContext } from './interfaces/index.js';

package/dist/interfaces/workflow-store.interface.d.ts

@@ -204,7 +204,18 @@ export interface WorkflowStore {
      * See `WorkflowWrite` for what each field does.
      */
     write(id: string, token: string, write: WorkflowWrite): Promise<boolean>;
+    /**
+     * Optional, for a store whose ids, names or keys are bounded (columns of a fixed length): throws, synchronously, an
+     * error that names the key (a `RangeError`) when the store can't hold `value` as a `kind`. The engine calls it for
+     * what a run makes up as it goes (a step's or a wait's name, `$compensate:<step>`, a child's id and keys, a wait's
+     * signal and key) before it journals or starts anything with it, so the error fails the run at the call that made
+     * the key, and the instance compensates, instead of failing every write that carries it. Without this method, the
+     * store's own check in `write()` or `create()` is all there is, and the instance is retried as after any store error.
+     */
+    checkKey?(kind: WorkflowKeyKind, value: string): void;
 }
+/** The ids, names and keys `WorkflowStore.checkKey()` checks. */
+export type WorkflowKeyKind = 'instanceId' | 'workflow' | 'concurrencyKey' | 'rateLimitKey' | 'journalName' | 'signal' | 'signalKey';
 /** `WorkflowStore.get()`'s result, and `WorkflowClient.getStatus()`'s. */
 export interface WorkflowInstanceDetails extends WorkflowInstance {
     /** Signals the instance waits for, if suspended in `waitForSignal()`. */

package/dist/mysql/mysql-workflow.store.d.ts

@@ -1,7 +1,7 @@
 import { type OnModuleInit } from '@nestjs/common';
 import { type MigrationSqlOptions, type MigrationStatementsOptions } from '@nestjs/store-kit/mysql';
 import type { WorkflowInstance, WorkflowStatus } from '../interfaces/workflow-instance.interface.js';
-import type { NewWorkflowInstance, NewWorkflowSignal, WorkflowCancelRequest, WorkflowClaim, WorkflowClaimRequest, WorkflowInstanceDetails, WorkflowListQuery, WorkflowPurgeQuery, WorkflowPurgeResult, WorkflowReopen, WorkflowScheduleClaimRequest, WorkflowScheduleQuery, WorkflowScheduleRecord, WorkflowScheduleSave, WorkflowScheduleWrite, WorkflowSignalQuery, WorkflowSignalRecord, WorkflowSignalResult, WorkflowStore, WorkflowWrite } from '../interfaces/workflow-store.interface.js';
+import type { NewWorkflowInstance, NewWorkflowSignal, WorkflowCancelRequest, WorkflowClaim, WorkflowClaimRequest, WorkflowInstanceDetails, WorkflowKeyKind, WorkflowListQuery, WorkflowPurgeQuery, WorkflowPurgeResult, WorkflowReopen, WorkflowScheduleClaimRequest, WorkflowScheduleQuery, WorkflowScheduleRecord, WorkflowScheduleSave, WorkflowScheduleWrite, WorkflowSignalQuery, WorkflowSignalRecord, WorkflowSignalResult, WorkflowStore, WorkflowWrite } from '../interfaces/workflow-store.interface.js';
 import type { WorkflowStorage } from '../storage/workflow.storage.js';
 import type { MySqlWorkflowStoreOptions } from './interfaces/mysql-workflow-store-options.interface.js';
 /**
@@ -31,7 +31,9 @@ import type { MySqlWorkflowStoreOptions } from './interfaces/mysql-workflow-stor
  * On MySQL:
  * - Ids, names and keys are case- and accent-sensitive, and bounded: an instance id, a workflow's or a signal's name,
  *   a signal's key or id, a concurrency or rate-limit key hold at most 255 characters, a schedule's id 230, a
- *   journal entry's name 512. A longer one fails with a `RangeError` that names it, before any SQL.
+ *   journal entry's name 512. A longer one fails with a `RangeError` that names it, before any SQL. One a run makes up
+ *   (a step's or a wait's name, `$compensate:<step>`, a child's id or keys) is thrown where the run makes it
+ *   (`checkKey()`), so the run fails and compensates, as any error it throws.
  * - The application's transactions may be REPEATABLE READ, MySQL's default. `signal(..., { transaction })` finds the
  *   instances to wake with a locking read of their waits, which sees the latest committed ones whatever the level; the
  *   signal lock is held until the application's transaction ends, as on PostgreSQL. `start(..., { transaction })`
@@ -164,6 +166,8 @@ export declare class MySqlWorkflowStore implements WorkflowStore, OnModuleInit {
         terminateRequested: boolean;
     } | null>;
     write(id: string, token: string, write: WorkflowWrite): Promise<boolean>;
+    /** What a run makes up (a step's name, a child's id...), checked by the engine before it writes or starts anything with it. */
+    checkKey(kind: WorkflowKeyKind, value: string): void;
     /** The store's readiness (the server and the schema), then the signal lock's row: before its own first statement. */
     private ready;
     /**

package/dist/mysql/mysql-workflow.store.js

@@ -47,7 +47,9 @@ const ROWS_PER_INSERT = 1_000;
  * On MySQL:
  * - Ids, names and keys are case- and accent-sensitive, and bounded: an instance id, a workflow's or a signal's name,
  *   a signal's key or id, a concurrency or rate-limit key hold at most 255 characters, a schedule's id 230, a
- *   journal entry's name 512. A longer one fails with a `RangeError` that names it, before any SQL.
+ *   journal entry's name 512. A longer one fails with a `RangeError` that names it, before any SQL. One a run makes up
+ *   (a step's or a wait's name, `$compensate:<step>`, a child's id or keys) is thrown where the run makes it
+ *   (`checkKey()`), so the run fails and compensates, as any error it throws.
  * - The application's transactions may be REPEATABLE READ, MySQL's default. `signal(..., { transaction })` finds the
  *   instances to wake with a locking read of their waits, which sees the latest committed ones whatever the level; the
  *   signal lock is held until the application's transaction ends, as on PostgreSQL. `start(..., { transaction })`
@@ -604,8 +606,8 @@ WHERE ${p.in('id', ids)}`, p.values);
             checkSignal(write.signal);
         }
         for (const wait of write.release?.waits ?? []) {
-            checkKey("a wait's signal name", wait.signal, L.signal);
-            checkKey("a wait's signal key", wait.key, L.signalKey);
+            checkKey(KEYS.signal, wait.signal, L.signal);
+            checkKey(KEYS.signalKey, wait.key, L.signalKey);
         }
         return retryOnDeadlock(this.executor, async (tx) => {
             const release = write.release;
@@ -650,6 +652,10 @@ WHERE ${p.in('id', ids)}`, p.values);
             return true;
         });
     }
+    /** What a run makes up (a step's name, a child's id...), checked by the engine before it writes or starts anything with it. */
+    checkKey(kind, value) {
+        checkKey(KEYS[kind], value, L[kind]);
+    }
     // ---------------------------------------------------------------- internals
     /** The store's readiness (the server and the schema), then the signal lock's row: before its own first statement. */
     async ready() {
@@ -823,6 +829,16 @@ function checkSignal(s) {
 }
 function checkEntries(entries) {
     for (const entry of entries) {
-        checkKey("a journal entry's name (a step's, a wait's, or the engine's, such as $child: and a child's id)", entry.name, L.journalName);
+        checkKey(KEYS.journalName, entry.name, L.journalName);
     }
 }
+/** How the errors of `checkKey()`, and of `write()`'s own checks, name each key. */
+const KEYS = {
+    instanceId: 'an instance id',
+    workflow: "a workflow's name",
+    concurrencyKey: 'a concurrency key',
+    rateLimitKey: 'a rate-limit key',
+    journalName: "a journal entry's name (a step's, a wait's, or the engine's, such as $child: and a child's id)",
+    signal: "a wait's signal name",
+    signalKey: "a wait's signal key",
+};

package/dist/services/workflow-execution.service.d.ts

@@ -151,8 +151,6 @@ export declare class WorkflowExecution {
     private readonly childCounters;
     /** The first interrupt that stops this execution (not a suspension). */
     private stoppedBy;
-    /** The step whose function is running, in that function's async context. */
-    private readonly insideStep;
     /** Each journal entry's size in bytes, by name, and their sum. */
     private readonly entrySizes;
     private journalBytes;
@@ -255,6 +253,14 @@ export declare class WorkflowExecution {
      * compensates (compensations may still record their entries) and fails.
      */
     private assertJournalRoom;
+    /**
+     * Throws the store's error for a key it can't hold (`WorkflowStore.checkKey()`), where the run makes the key: the
+     * run fails with it and compensates. Reaching the store, it would fail every write that carries it, and the instance
+     * would be retried at every lease, forever.
+     */
+    private checkKey;
+    /** A wait's signal and key, registered when the instance suspends. */
+    private checkWait;
     /** Fenced write of staged entries plus `entries`. */
     private write;
     private loseLease;

package/dist/services/workflow-execution.service.js

@@ -132,8 +132,6 @@ export class WorkflowExecution {
         this.childCounters = new Map();
         /** The first interrupt that stops this execution (not a suspension). */
         this.stoppedBy = null;
-        /** The step whose function is running, in that function's async context. */
-        this.insideStep = new AsyncLocalStorage();
         /** Each journal entry's size in bytes, by name, and their sum. */
         this.entrySizes = new Map();
         this.journalBytes = 0;
@@ -256,6 +254,7 @@ export class WorkflowExecution {
                 return { state: 'failed', error: entry.error };
             }
             try {
+                this.checkKey('journalName', name);
                 const attempt = await this.attempt(name, 'compensation', 
                 // Whatever the undo returns (a provider's response, say) is discarded: nothing
                 // reads it, so it can't fail the undo by being unserializable.
@@ -299,6 +298,10 @@ export class WorkflowExecution {
             throw this.interrupt('halt');
         }
         this.assertCanStart();
+        if (options.compensate) {
+            // Checked before the step runs: a side effect whose undo the store couldn't journal never happens.
+            this.checkKey('journalName', `${COMPENSATE}${name}`);
+        }
         const plan = this.plan(name, options);
         // Reserved in call order, so parallel steps compensate in the same order
         // on the first run and on a replay, whichever finished first.
@@ -343,6 +346,7 @@ export class WorkflowExecution {
             throw this.interrupt('halt');
         }
         this.assertAlive();
+        this.checkWait(wait);
         const deadline = entry
             ? (entry.wakeAt ?? null)
             : options.timeout !== undefined
@@ -426,6 +430,10 @@ export class WorkflowExecution {
             parentId: this.instance.id,
             parentClose,
         });
+        this.checkKey('instanceId', child.id);
+        this.checkKey('workflow', child.workflow);
+        this.checkKey('concurrencyKey', child.concurrencyKey);
+        this.checkKey('rateLimitKey', child.rateLimitKey);
         await this.reachFrontier(name);
         this.assertCanStart();
         // Recorded before the child exists, so a parent that crashes right after creating it still
@@ -477,6 +485,11 @@ export class WorkflowExecution {
             throw this.interrupt('halt');
         }
         this.assertAlive();
+        for (const branch of branches.values()) {
+            if (branch.wait) {
+                this.checkWait(branch.wait);
+            }
+        }
         // Timers count from when the wait was first reached: a replay keeps their deadlines.
         const now = this.deps.clock.now();
         const reached = entry?.data;
@@ -776,7 +789,7 @@ export class WorkflowExecution {
                 await this.write([current]);
             },
         };
-        const run = Promise.resolve().then(() => runInStepScope(ctx.idempotencyKey, () => this.insideStep.run(name, () => fn(ctx))));
+        const run = Promise.resolve().then(() => runInStepScope(ctx.idempotencyKey, () => insideStep.run({ execution: this, name, outer: insideStep.getStore() }, () => fn(ctx))));
         return Promise.race([run, watchdog]).finally(() => {
             settled = true;
             clearTimeout(overall);
@@ -805,10 +818,14 @@ export class WorkflowExecution {
      * replay, so it is a definition error, reported where it happens.
      */
     assertNotInStep(call, advice = 'Call ctx methods from run() and pass the values the step needs into it.') {
-        const step = this.insideStep.getStore();
-        if (step === undefined) {
+        let frame = insideStep.getStore();
+        while (frame && frame.execution !== this) {
+            frame = frame.outer;
+        }
+        if (!frame) {
             return;
         }
+        const step = frame.name;
         const where = step.startsWith(COMPENSATE) ? `the compensation of step "${step.slice(COMPENSATE.length)}"` : `step "${step}"`;
         throw this.setFatal(new WorkflowDefinitionError(`${this.describe()}: ${where} called ctx.${call}. A step's function runs once and replays return its ` +
             `result, so it can't use ctx. ${advice}`));
@@ -829,6 +846,7 @@ export class WorkflowExecution {
         const entry = this.journal.get(name);
         if (!entry && this.mode === 'run') {
             this.assertJournalRoom(name);
+            this.checkKey('journalName', name);
         }
         if (entry && entry.kind !== kind) {
             throw this.setFatal(new WorkflowNonDeterminismError(`${this.describe()} does not match its journal: "${name}" was recorded as a ${entry.kind}, but the code now calls it as a ${kind}. ${ADVICE}`));
@@ -956,6 +974,21 @@ export class WorkflowExecution {
         };
         throw this.interrupt('journal-limit');
     }
+    /**
+     * Throws the store's error for a key it can't hold (`WorkflowStore.checkKey()`), where the run makes the key: the
+     * run fails with it and compensates. Reaching the store, it would fail every write that carries it, and the instance
+     * would be retried at every lease, forever.
+     */
+    checkKey(kind, value) {
+        if (typeof value === 'string') {
+            this.deps.store.checkKey?.(kind, value);
+        }
+    }
+    /** A wait's signal and key, registered when the instance suspends. */
+    checkWait(wait) {
+        this.checkKey('signal', wait.signal);
+        this.checkKey('signalKey', wait.key);
+    }
     /** Fenced write of staged entries plus `entries`. */
     async write(entries) {
         if (this.detached) {
@@ -1069,6 +1102,11 @@ function conditionsOf(name, conditions) {
     return branches;
 }
 const COMPENSATE = '$compensate:';
+/**
+ * The steps whose functions are running, in their async context. One store for every execution, not one each: on
+ * Node 20 and 22, a store that ran stays in a process-wide list every async resource walks, until `disable()`.
+ */
+const insideStep = new AsyncLocalStorage();
 const PARENT_CLOSE = ['cancel', 'terminate', 'abandon'];
 /** The most a custom status (`ctx.setStatus()`) may take as JSON. */
 const MAX_CUSTOM_STATUS_BYTES = 16_384;

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

@@ -18,6 +18,7 @@ export declare class EncodedWorkflowStore implements WorkflowInstanceStore {
     private readonly unreadable;
     readonly createInTransaction?: WorkflowStore['createInTransaction'];
     readonly signalInTransaction?: WorkflowStore['signalInTransaction'];
+    readonly checkKey?: WorkflowStore['checkKey'];
     constructor(
     /** The store itself: what it holds, undecoded. */
     inner: WorkflowStore, codecs: PayloadCodecs<WorkflowPayloadContext>);

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

@@ -21,6 +21,10 @@ export class EncodedWorkflowStore {
         if (typeof inner.signalInTransaction === 'function') {
             this.signalInTransaction = (transaction, signal) => toPromise(andThen(this.encodeSignal(signal), (encoded) => inner.signalInTransaction(transaction, encoded)));
         }
+        // Keys aren't encoded: the store checks them as they are.
+        if (typeof inner.checkKey === 'function') {
+            this.checkKey = (kind, value) => inner.checkKey(kind, value);
+        }
     }
     /** Whether a codec encodes what is written. */
     get encodes() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/workflows",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Nest - modern, fast, powerful node.js web framework (@workflows)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",
@@ -69,37 +69,37 @@
     "@commitlint/cli": "21.2.3",
     "@commitlint/config-angular": "21.2.3",
     "@electric-sql/pglite": "0.5.8",
-    "@nestjs/common": "12.1.0",
-    "@nestjs/core": "12.1.0",
+    "@nestjs/common": "12.1.2",
+    "@nestjs/core": "12.1.2",
     "@nestjs/cqrs": "12.1.0",
     "@nestjs/drizzle": "0.0.1",
-    "@nestjs/locks": "0.0.1",
+    "@nestjs/locks": "0.0.2",
     "@nestjs/mail": "0.0.1",
-    "@nestjs/outbox": "0.0.1",
-    "@nestjs/platform-express": "12.1.0",
-    "@nestjs/platform-fastify": "12.1.0",
-    "@nestjs/testing": "12.1.0",
+    "@nestjs/outbox": "0.1.1",
+    "@nestjs/platform-express": "12.1.2",
+    "@nestjs/platform-fastify": "12.1.2",
+    "@nestjs/testing": "12.1.2",
     "@prisma/adapter-mariadb": "7.10.0",
     "@prisma/adapter-pg": "7.10.0",
     "@prisma/client": "7.10.0",
-    "@types/node": "24.13.6",
+    "@types/node": "24.19.2",
     "@types/pg": "8.23.1",
-    "drizzle-orm": "0.45.3",
+    "drizzle-orm": "0.45.4",
     "husky": "9.1.7",
     "kysely": "0.29.6",
-    "lint-staged": "17.5.1",
+    "lint-staged": "17.6.0",
     "mysql2": "3.24.5",
-    "oxlint": "1.85.0",
-    "pg": "8.23.0",
-    "prettier": "3.9.8",
+    "oxlint": "1.87.0",
+    "pg": "8.23.1",
+    "prettier": "3.9.10",
     "prisma": "7.10.0",
     "reflect-metadata": "0.2.2",
-    "release-it": "21.1.0",
+    "release-it": "21.1.1",
     "rxjs": "7.8.2",
-    "typeorm": "1.1.1",
+    "typeorm": "1.1.2",
     "typescript": "7.0.2",
-    "vite": "8.3.0",
-    "vitest": "5.0.1"
+    "vite": "8.3.4",
+    "vitest": "5.0.3"
   },
   "peerDependencies": {
     "@nestjs/common": "^11.0.0 || ^12.0.0",