@cqrs-ddd/mikro-orm 0.2.0

package/dist/cache/mikro-orm.cache.js

@@ -0,0 +1,209 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MikroOrmCache = void 0;
+const node_crypto_1 = require("node:crypto");
+const persistence_1 = require("@cqrs-ddd/core/persistence");
+const cache_entry_1 = require("./cache-entry");
+/**
+ * Reads the committed row inside a CAS transaction, bypassing the identity map
+ * so a concurrent writer's revision is always observed.
+ */
+function readCommittedEntry(em, key) {
+    return em.findOne(cache_entry_1.CacheEntry, { key }, { refresh: true, disableIdentityMap: true });
+}
+/**
+ * Upper bound on compare-and-set re-reads. Each iteration only repeats after a
+ * competing writer won the row, so the bound exists to guarantee termination if
+ * the underlying store never reflects a write, not to limit real contention.
+ */
+const MAX_CAS_ATTEMPTS = 16;
+/** Raised when a compare-and-set loop cannot converge. */
+class CacheCasExhaustedError extends Error {
+    constructor(operation, key) {
+        super(`MikroOrmCache.${operation} could not settle key "${key}" after ${MAX_CAS_ATTEMPTS} attempts.`);
+        this.name = 'CacheCasExhaustedError';
+    }
+}
+/**
+ * MikroORM-backed {@link IVersionedCache}: one row per key in the table mapped by
+ * {@link CacheEntrySchema} (or {@link createCacheEntrySchema}).
+ *
+ * Implements {@link IVersionedCache} with revision-fenced atomic coordination,
+ * bypassing the identity map across all read and mutation operations. Reads use
+ * `store.em`; every write runs in `store.transactional(...)`.
+ *
+ * A plain class with no framework dependency. In a NestJS application, register
+ * it with a factory:
+ *
+ * @example
+ * ```ts
+ * {
+ *   provide: CACHE_TOKEN,
+ *   useFactory: (store: AppStore) =>
+ *     new MikroOrmCache(store, { logger: new Logger('MikroOrmCache') }),
+ *   inject: [STORE],
+ * }
+ * ```
+ */
+class MikroOrmCache {
+    store;
+    isVersioned = true;
+    logger;
+    defaultTtlMs;
+    constructor(store, options) {
+        this.store = store;
+        this.defaultTtlMs = options?.defaultTtlMs ?? 60_000;
+        this.logger = options?.logger ?? (0, persistence_1.consoleCacheLogger)('MikroOrmCache');
+    }
+    /**
+     * Observes the current key state and its revision token.
+     * Reads bypass the identity map to guarantee authoritative persistence visibility.
+     */
+    async readState(key) {
+        const entry = await this.store.em.findOne(cache_entry_1.CacheEntry, { key }, { disableIdentityMap: true });
+        if (!entry) {
+            return { status: 'miss', revision: '0' };
+        }
+        const revision = (entry.revision ?? '0').toString();
+        if (!entry.value) {
+            return { status: 'miss', revision };
+        }
+        if (entry.expiresAt !== null && entry.expiresAt < Date.now()) {
+            return { status: 'expired', revision };
+        }
+        return {
+            status: 'hit',
+            value: JSON.parse(entry.value),
+            revision,
+        };
+    }
+    /**
+     * Atomically advances the revision for `key` and evicts the payload value.
+     * Retains the entry to prevent ABA races during concurrent fills.
+     */
+    async invalidate(key) {
+        return this.store.transactional(async (em) => {
+            for (let attempt = 0; attempt < MAX_CAS_ATTEMPTS; attempt++) {
+                const existing = await readCommittedEntry(em, key);
+                if (!existing) {
+                    // `onConflictAction: 'ignore'` keeps a lost insert race from aborting
+                    // the surrounding transaction, so the loop can re-read and retry.
+                    await em.upsert(cache_entry_1.CacheEntry, { key, value: '', expiresAt: null, revision: '1' }, { onConflictAction: 'ignore' });
+                    const inserted = await readCommittedEntry(em, key);
+                    if (inserted && (inserted.revision ?? '0').toString() === '1') {
+                        return '1';
+                    }
+                    continue;
+                }
+                const currentRev = (existing.revision ?? '0').toString();
+                const nextRevision = (BigInt(currentRev) + 1n).toString();
+                const affected = await em.nativeUpdate(cache_entry_1.CacheEntry, { key, revision: existing.revision }, {
+                    value: '',
+                    expiresAt: null,
+                    revision: nextRevision,
+                });
+                if (affected > 0) {
+                    return nextRevision;
+                }
+            }
+            throw new CacheCasExhaustedError('invalidate', key);
+        });
+    }
+    /**
+     * Atomically checks that current revision matches `observedRevision`, writes
+     * value, and advances revision on match.
+     */
+    async tryFill(key, observedRevision, value, options) {
+        const ttl = options?.ttl ?? this.defaultTtlMs;
+        const expiresAt = ttl > 0 ? Date.now() + ttl : null;
+        const serialized = JSON.stringify(value);
+        return this.store.transactional(async (em) => {
+            const nextRevision = (BigInt(observedRevision) + 1n).toString();
+            if (observedRevision === '0') {
+                const existing = await readCommittedEntry(em, key);
+                if (!existing) {
+                    await em.upsert(cache_entry_1.CacheEntry, { key, value: serialized, expiresAt, revision: '1' }, { onConflictAction: 'ignore' });
+                    const inserted = await readCommittedEntry(em, key);
+                    // A competing writer won the insert; this fill observed revision 0
+                    // and must not overwrite it.
+                    return inserted !== null && inserted.value === serialized;
+                }
+                if ((existing.revision ?? '0').toString() === '0') {
+                    const affected = await em.nativeUpdate(cache_entry_1.CacheEntry, { key, revision: existing.revision }, {
+                        value: serialized,
+                        expiresAt,
+                        revision: '1',
+                    });
+                    return affected > 0;
+                }
+                return false;
+            }
+            const affected = await em.nativeUpdate(cache_entry_1.CacheEntry, { key, revision: observedRevision }, {
+                value: serialized,
+                expiresAt,
+                revision: nextRevision,
+            });
+            return affected > 0;
+        });
+    }
+    /**
+     * Get a value from the cache by key. Handles TTL expiry and returns detached clone.
+     */
+    async get(key) {
+        const state = await this.readState(key);
+        return state.status === 'hit' ? state.value : undefined;
+    }
+    /**
+     * Stores a value in the relational cache table with transactional CAS concurrency safety.
+     */
+    async set(key, value, options) {
+        const ttl = options?.ttl ?? this.defaultTtlMs;
+        const expiresAt = ttl > 0 ? Date.now() + ttl : null;
+        const isNewer = options?.isNewer;
+        const serialized = JSON.stringify(value);
+        await this.store.transactional(async (em) => {
+            for (let attempt = 0; attempt < MAX_CAS_ATTEMPTS; attempt++) {
+                const existing = await readCommittedEntry(em, key);
+                if (!existing) {
+                    await em.upsert(cache_entry_1.CacheEntry, { key, value: serialized, expiresAt, revision: '1' }, { onConflictAction: 'ignore' });
+                    continue;
+                }
+                if (isNewer && existing.value) {
+                    if (existing.expiresAt === null || existing.expiresAt >= Date.now()) {
+                        let parsed;
+                        try {
+                            parsed = JSON.parse(existing.value);
+                        }
+                        catch {
+                            // An unparsable entry is treated as absent so the CAS update can heal corrupted data.
+                            (0, persistence_1.safeWarn)(this.logger, `Failed to parse cached value (key digest: ${(0, node_crypto_1.createHash)('sha256').update(key).digest('hex')}); treating as absent.`);
+                        }
+                        if (parsed !== undefined && isNewer(parsed, value)) {
+                            return;
+                        }
+                    }
+                }
+                const currentRev = (existing.revision ?? '0').toString();
+                const nextRevision = (BigInt(currentRev) + 1n).toString();
+                const affected = await em.nativeUpdate(cache_entry_1.CacheEntry, { key, revision: existing.revision }, {
+                    value: serialized,
+                    expiresAt,
+                    revision: nextRevision,
+                });
+                if (affected > 0)
+                    return;
+            }
+            throw new CacheCasExhaustedError('set', key);
+        });
+    }
+    /**
+     * Removes the value and advances the key's revision, as invalidate() does; the
+     * row is kept.
+     */
+    async delete(key) {
+        await this.invalidate(key);
+    }
+}
+exports.MikroOrmCache = MikroOrmCache;
+//# sourceMappingURL=mikro-orm.cache.js.map

package/dist/cache/mikro-orm.cache.js.map

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

package/dist/concurrency/assert-autocommit.d.ts

@@ -0,0 +1,21 @@
+import type { EntityManager } from '@mikro-orm/core';
+/**
+ * Rejects an externally active transaction before a write that reports durable
+ * success.
+ *
+ * The lifecycle decorators treat a resolved `save()` as durable: `@AcknowledgePersisted`
+ * advances the aggregate's persisted version baseline and `@Cache` synchronises or
+ * invalidates cache entries. Inside a caller's transaction neither is true yet — the
+ * statement is buffered until a commit this code does not observe, so a later rollback
+ * would leave an acknowledged aggregate and a cache reflecting a write that never
+ * landed. Participating in an outer transaction needs commit callbacks or unit-of-work
+ * semantics; it must not be emulated by acknowledging early.
+ *
+ * Call it **before** issuing the statement, so a rejected operation mutates nothing.
+ *
+ * @param em The entity manager the operation will execute on.
+ * @param operation Name used in the error message, e.g. `'optimisticDelete'`.
+ * @throws {Error} When `em` is inside an active transaction.
+ */
+export declare function assertAutocommit(em: EntityManager, operation: string): void;
+//# sourceMappingURL=assert-autocommit.d.ts.map

package/dist/concurrency/assert-autocommit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert-autocommit.d.ts","sourceRoot":"","sources":["../../src/concurrency/assert-autocommit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAM3E"}

package/dist/concurrency/assert-autocommit.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertAutocommit = assertAutocommit;
+/**
+ * Rejects an externally active transaction before a write that reports durable
+ * success.
+ *
+ * The lifecycle decorators treat a resolved `save()` as durable: `@AcknowledgePersisted`
+ * advances the aggregate's persisted version baseline and `@Cache` synchronises or
+ * invalidates cache entries. Inside a caller's transaction neither is true yet — the
+ * statement is buffered until a commit this code does not observe, so a later rollback
+ * would leave an acknowledged aggregate and a cache reflecting a write that never
+ * landed. Participating in an outer transaction needs commit callbacks or unit-of-work
+ * semantics; it must not be emulated by acknowledging early.
+ *
+ * Call it **before** issuing the statement, so a rejected operation mutates nothing.
+ *
+ * @param em The entity manager the operation will execute on.
+ * @param operation Name used in the error message, e.g. `'optimisticDelete'`.
+ * @throws {Error} When `em` is inside an active transaction.
+ */
+function assertAutocommit(em, operation) {
+    if (em.isInTransaction()) {
+        throw new Error(`${operation} requires autocommit; external transactions need commit hooks.`);
+    }
+}
+//# sourceMappingURL=assert-autocommit.js.map

package/dist/concurrency/assert-autocommit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert-autocommit.js","sourceRoot":"","sources":["../../src/concurrency/assert-autocommit.ts"],"names":[],"mappings":";;AAqBA,4CAMC;AAxBD;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,gBAAgB,CAAC,EAAiB,EAAE,SAAiB;IACnE,IAAI,EAAE,CAAC,eAAe,EAAE,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CACb,GAAG,SAAS,gEAAgE,CAC7E,CAAC;IACJ,CAAC;AACH,CAAC"}

package/dist/concurrency/conditioned-write.d.ts

@@ -0,0 +1,23 @@
+import type { EntityManager, EntityName } from '@mikro-orm/core';
+/** An aggregate written with version checks, such as a `RootEntity`. */
+export interface VersionedAggregate {
+    readonly id: string;
+    readonly version: number;
+    getExpectedVersion(): number;
+}
+/** The row a version-conditioned write targets, captured before it runs. */
+export interface ConditionedRow {
+    readonly id: string;
+    readonly expectedVersion: number;
+}
+/**
+ * Checks the row count of a write filtered on `{ id, version }`: one row is
+ * success; none is diagnosed with one refreshed read on the same manager as
+ * a missing row or a version conflict; more breaks the primary key invariant.
+ *
+ * @throws {EntityNotFoundException} No row matched and the row is gone.
+ * @throws {ConcurrencyConflictError} No row matched because the version diverged.
+ * @throws {Error} More than one row was affected.
+ */
+export declare function expectOneRow<TEntity extends VersionedAggregate>(affected: number, em: EntityManager, entityType: EntityName<TEntity>, { id, expectedVersion }: ConditionedRow, entityName: string, verb: 'updated' | 'deleted'): Promise<void>;
+//# sourceMappingURL=conditioned-write.d.ts.map

package/dist/concurrency/conditioned-write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditioned-write.d.ts","sourceRoot":"","sources":["../../src/concurrency/conditioned-write.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAe,MAAM,iBAAiB,CAAC;AAE9E,wEAAwE;AACxE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,kBAAkB,IAAI,MAAM,CAAC;CAC9B;AAED,4EAA4E;AAC5E,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAED;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAAC,OAAO,SAAS,kBAAkB,EACnE,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,aAAa,EACjB,UAAU,EAAE,UAAU,CAAC,OAAO,CAAC,EAC/B,EAAE,EAAE,EAAE,eAAe,EAAE,EAAE,cAAc,EACvC,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,SAAS,GAAG,SAAS,GAC1B,OAAO,CAAC,IAAI,CAAC,CAiBf"}

package/dist/concurrency/conditioned-write.js

@@ -0,0 +1,26 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectOneRow = expectOneRow;
+const domain_1 = require("@cqrs-ddd/core/domain");
+/**
+ * Checks the row count of a write filtered on `{ id, version }`: one row is
+ * success; none is diagnosed with one refreshed read on the same manager as
+ * a missing row or a version conflict; more breaks the primary key invariant.
+ *
+ * @throws {EntityNotFoundException} No row matched and the row is gone.
+ * @throws {ConcurrencyConflictError} No row matched because the version diverged.
+ * @throws {Error} More than one row was affected.
+ */
+async function expectOneRow(affected, em, entityType, { id, expectedVersion }, entityName, verb) {
+    if (affected === 1)
+        return;
+    if (affected === 0) {
+        const existing = await em.findOne(entityType, { id }, { refresh: true });
+        if (!existing)
+            throw new domain_1.EntityNotFoundException(entityName, id);
+        throw new domain_1.ConcurrencyConflictError(entityName, id, expectedVersion, existing.version);
+    }
+    throw new Error(`Expected one ${verb} ${entityName}, received ${affected}.`);
+}
+//# sourceMappingURL=conditioned-write.js.map

package/dist/concurrency/conditioned-write.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditioned-write.js","sourceRoot":"","sources":["../../src/concurrency/conditioned-write.ts"],"names":[],"mappings":";AAAA,sEAAsE;;AA8BtE,oCAwBC;AApDD,kDAG+B;AAgB/B;;;;;;;;GAQG;AACI,KAAK,UAAU,YAAY,CAChC,QAAgB,EAChB,EAAiB,EACjB,UAA+B,EAC/B,EAAE,EAAE,EAAE,eAAe,EAAkB,EACvC,UAAkB,EAClB,IAA2B;IAE3B,IAAI,QAAQ,KAAK,CAAC;QAAE,OAAO;IAC3B,IAAI,QAAQ,KAAK,CAAC,EAAE,CAAC;QACnB,MAAM,QAAQ,GAAG,MAAM,EAAE,CAAC,OAAO,CAC/B,UAAU,EACV,EAAE,EAAE,EAA0B,EAC9B,EAAE,OAAO,EAAE,IAAI,EAAE,CAClB,CAAC;QACF,IAAI,CAAC,QAAQ;YAAE,MAAM,IAAI,gCAAuB,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;QACjE,MAAM,IAAI,iCAAwB,CAChC,UAAU,EACV,EAAE,EACF,eAAe,EACf,QAAQ,CAAC,OAAO,CACjB,CAAC;IACJ,CAAC;IACD,MAAM,IAAI,KAAK,CAAC,gBAAgB,IAAI,IAAI,UAAU,cAAc,QAAQ,GAAG,CAAC,CAAC;AAC/E,CAAC"}

package/dist/concurrency/optimistic-delete.d.ts

@@ -0,0 +1,52 @@
+import type { EntityManager, EntityName } from '@mikro-orm/core';
+import { type VersionedAggregate } from './conditioned-write';
+/**
+ * Executes a single version-conditioned, autocommitted `DELETE` on an aggregate.
+ *
+ * The delete counterpart of `optimisticUpdate`, with the same contract:
+ *
+ * - rejects an externally active transaction before touching the database
+ *   ({@link assertAutocommit});
+ * - deletes on `{ id, version: aggregate.getExpectedVersion() }`, so a row
+ *   modified since the aggregate was loaded is not removed;
+ * - one affected row is success;
+ * - zero rows runs one refreshed diagnostic read: an absent row is
+ *   {@link EntityNotFoundException}, a present row is
+ *   {@link ConcurrencyConflictError};
+ * - any other count is an invariant violation, since the filter includes a
+ *   primary key.
+ *
+ * The caller passes `em` once and this helper uses exactly that instance for both
+ * the delete and the diagnostic read, so the two cannot observe different
+ * transactional state.
+ *
+ * Caching, aggregate acknowledgment and event publication stay with `@Cache`,
+ * `@AcknowledgePersisted` and `CommandBaseHandler`. A delete repository resolves
+ * to `null`: there is no new persisted snapshot to acknowledge.
+ *
+ * Rows without a version column are out of scope; delete them by primary key.
+ *
+ * @param em Entity manager in autocommit mode.
+ * @param entityType Entity class or registered name.
+ * @param aggregate Aggregate providing `id` and `getExpectedVersion()`.
+ * @param entityName Friendly name for diagnostics, e.g. `'User'`.
+ *
+ * @throws {Error} Inside an active transaction, or on an unexpected row count.
+ * @throws {EntityNotFoundException} No row matched and the entity is gone.
+ * @throws {ConcurrencyConflictError} No row matched because the version diverged.
+ *
+ * @example Delete command repository
+ * ```typescript
+ * @Cache<User, null>({ deleteKeys: (user) => [cacheKey(User.aggregateName, { id: user.id })] })
+ * @MapPersistenceErrors<[User], User>({
+ *   entity: ([user]) => user,
+ *   otherwise: (error, user) => mapPersistenceError(error, `deleting User ${user.id}`),
+ * })
+ * async save(user: User): Promise<null> {
+ *   await optimisticDelete(this.store.em, User, user, 'User');
+ *   return null;
+ * }
+ * ```
+ */
+export declare function optimisticDelete<TEntity extends VersionedAggregate>(em: EntityManager, entityType: EntityName<TEntity>, aggregate: TEntity, entityName: string): Promise<void>;
+//# sourceMappingURL=optimistic-delete.d.ts.map

package/dist/concurrency/optimistic-delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimistic-delete.d.ts","sourceRoot":"","sources":["../../src/concurrency/optimistic-delete.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAe,MAAM,iBAAiB,CAAC;AAE9E,OAAO,EAAgB,KAAK,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,SAAS,kBAAkB,EACvE,EAAE,EAAE,aAAa,EACjB,UAAU,EAAE,UAAU,CAAC,OAAO,CAAC,EAC/B,SAAS,EAAE,OAAO,EAClB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC,CAWf"}

package/dist/concurrency/optimistic-delete.js

@@ -0,0 +1,67 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optimisticDelete = optimisticDelete;
+const assert_autocommit_1 = require("./assert-autocommit");
+const conditioned_write_1 = require("./conditioned-write");
+/**
+ * Executes a single version-conditioned, autocommitted `DELETE` on an aggregate.
+ *
+ * The delete counterpart of `optimisticUpdate`, with the same contract:
+ *
+ * - rejects an externally active transaction before touching the database
+ *   ({@link assertAutocommit});
+ * - deletes on `{ id, version: aggregate.getExpectedVersion() }`, so a row
+ *   modified since the aggregate was loaded is not removed;
+ * - one affected row is success;
+ * - zero rows runs one refreshed diagnostic read: an absent row is
+ *   {@link EntityNotFoundException}, a present row is
+ *   {@link ConcurrencyConflictError};
+ * - any other count is an invariant violation, since the filter includes a
+ *   primary key.
+ *
+ * The caller passes `em` once and this helper uses exactly that instance for both
+ * the delete and the diagnostic read, so the two cannot observe different
+ * transactional state.
+ *
+ * Caching, aggregate acknowledgment and event publication stay with `@Cache`,
+ * `@AcknowledgePersisted` and `CommandBaseHandler`. A delete repository resolves
+ * to `null`: there is no new persisted snapshot to acknowledge.
+ *
+ * Rows without a version column are out of scope; delete them by primary key.
+ *
+ * @param em Entity manager in autocommit mode.
+ * @param entityType Entity class or registered name.
+ * @param aggregate Aggregate providing `id` and `getExpectedVersion()`.
+ * @param entityName Friendly name for diagnostics, e.g. `'User'`.
+ *
+ * @throws {Error} Inside an active transaction, or on an unexpected row count.
+ * @throws {EntityNotFoundException} No row matched and the entity is gone.
+ * @throws {ConcurrencyConflictError} No row matched because the version diverged.
+ *
+ * @example Delete command repository
+ * ```typescript
+ * @Cache<User, null>({ deleteKeys: (user) => [cacheKey(User.aggregateName, { id: user.id })] })
+ * @MapPersistenceErrors<[User], User>({
+ *   entity: ([user]) => user,
+ *   otherwise: (error, user) => mapPersistenceError(error, `deleting User ${user.id}`),
+ * })
+ * async save(user: User): Promise<null> {
+ *   await optimisticDelete(this.store.em, User, user, 'User');
+ *   return null;
+ * }
+ * ```
+ */
+async function optimisticDelete(em, entityType, aggregate, entityName) {
+    (0, assert_autocommit_1.assertAutocommit)(em, 'optimisticDelete');
+    const row = {
+        id: aggregate.id,
+        expectedVersion: aggregate.getExpectedVersion(),
+    };
+    const affected = await em.nativeDelete(entityType, {
+        id: row.id,
+        version: row.expectedVersion,
+    });
+    await (0, conditioned_write_1.expectOneRow)(affected, em, entityType, row, entityName, 'deleted');
+}
+//# sourceMappingURL=optimistic-delete.js.map

package/dist/concurrency/optimistic-delete.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimistic-delete.js","sourceRoot":"","sources":["../../src/concurrency/optimistic-delete.ts"],"names":[],"mappings":";AAAA,sEAAsE;;AAsDtE,4CAgBC;AAnED,2DAAuD;AACvD,2DAA4E;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACI,KAAK,UAAU,gBAAgB,CACpC,EAAiB,EACjB,UAA+B,EAC/B,SAAkB,EAClB,UAAkB;IAElB,IAAA,oCAAgB,EAAC,EAAE,EAAE,kBAAkB,CAAC,CAAC;IACzC,MAAM,GAAG,GAAG;QACV,EAAE,EAAE,SAAS,CAAC,EAAE;QAChB,eAAe,EAAE,SAAS,CAAC,kBAAkB,EAAE;KAChD,CAAC;IACF,MAAM,QAAQ,GAAG,MAAM,EAAE,CAAC,YAAY,CAAC,UAAU,EAAE;QACjD,EAAE,EAAE,GAAG,CAAC,EAAE;QACV,OAAO,EAAE,GAAG,CAAC,eAAe;KACL,CAAC,CAAC;IAC3B,MAAM,IAAA,gCAAY,EAAC,QAAQ,EAAE,EAAE,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;AAC3E,CAAC"}

package/dist/concurrency/optimistic-update.d.ts

@@ -0,0 +1,51 @@
+import type { EntityData, EntityManager, EntityName } from '@mikro-orm/core';
+import { type VersionedAggregate } from './conditioned-write';
+/**
+ * Executes a single, version-conditioned, autocommitted SQL `UPDATE` statement on an aggregate entity.
+ *
+ * This function handles low-level optimistic locking mechanics for update command repositories:
+ * - **Autocommit Enforcement**: Rejects an externally active transaction via
+ *   {@link assertAutocommit}, because multi-statement transactions require commit hooks
+ *   rather than standalone method decorators to guarantee atomic acknowledgment.
+ * - **Version-Conditioned Write**: Issues `em.nativeUpdate` with filter `{ id: entity.id, version: entity.getExpectedVersion() }`
+ *   and updates fields including `{ version: entity.version }`.
+ * - **Affected Row Verification**:
+ *   - Exactly `1` row affected: Write succeeded; completes cleanly.
+ *   - `0` rows affected: Performs a refreshed diagnostic read (`findOne` with `refresh: true`):
+ *     - If the entity is absent, throws {@link EntityNotFoundException}.
+ *     - If the entity is present, throws {@link ConcurrencyConflictError}.
+ *   - More than `1` row affected: Throws an `Error` indicating primary-key uniqueness invariant violation.
+ *
+ * > [!NOTE]
+ * > This helper does not perform caching, aggregate acknowledgment, or domain event publication.
+ * > Those concerns are owned by `@Cache`, `@AcknowledgePersisted`, and `CommandBaseHandler` respectively.
+ *
+ * @param em The MikroORM {@link EntityManager} instance (must be in autocommit mode).
+ * @param entityType The entity class or registered name (e.g. `User`, `Role`).
+ * @param entity The aggregate instance providing `id`, `version`, and `getExpectedVersion()`.
+ * @param data Field payload to update (the `version` field is automatically injected from `entity.version`).
+ * @param entityName Friendly name of the entity for error diagnostics (e.g. `'User'`).
+ *
+ * @throws {Error} If called within an active transaction (`em.isInTransaction() === true`).
+ * @throws {EntityNotFoundException} If 0 rows were updated and the entity cannot be found.
+ * @throws {ConcurrencyConflictError} If 0 rows were updated and the entity version has diverged.
+ * @throws {Error} If unexpected row count (> 1) was affected.
+ *
+ * @example Usage in an update command repository
+ * ```typescript
+ * @PersistedWrite<User>({ cache: { setKey: (user) => cacheKey(User.aggregateName, { id: user.id }) } })
+ * async save(user: User): Promise<UserSnapshot> {
+ *   const snapshot = user.toJSON();
+ *   await optimisticUpdate(
+ *     this.store.em,
+ *     User,
+ *     user,
+ *     { username: snapshot.username, updatedAt: snapshot.updatedAt },
+ *     'User',
+ *   );
+ *   return snapshot;
+ * }
+ * ```
+ */
+export declare function optimisticUpdate<TEntity extends VersionedAggregate>(em: EntityManager, entityType: EntityName<TEntity>, entity: TEntity, data: EntityData<TEntity>, entityName: string): Promise<void>;
+//# sourceMappingURL=optimistic-update.d.ts.map

package/dist/concurrency/optimistic-update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimistic-update.d.ts","sourceRoot":"","sources":["../../src/concurrency/optimistic-update.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,UAAU,EACV,aAAa,EACb,UAAU,EAEX,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAgB,KAAK,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,SAAS,kBAAkB,EACvE,EAAE,EAAE,aAAa,EACjB,UAAU,EAAE,UAAU,CAAC,OAAO,CAAC,EAC/B,MAAM,EAAE,OAAO,EACf,IAAI,EAAE,UAAU,CAAC,OAAO,CAAC,EACzB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC,CASf"}

package/dist/concurrency/optimistic-update.js

@@ -0,0 +1,60 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optimisticUpdate = optimisticUpdate;
+const assert_autocommit_1 = require("./assert-autocommit");
+const conditioned_write_1 = require("./conditioned-write");
+/**
+ * Executes a single, version-conditioned, autocommitted SQL `UPDATE` statement on an aggregate entity.
+ *
+ * This function handles low-level optimistic locking mechanics for update command repositories:
+ * - **Autocommit Enforcement**: Rejects an externally active transaction via
+ *   {@link assertAutocommit}, because multi-statement transactions require commit hooks
+ *   rather than standalone method decorators to guarantee atomic acknowledgment.
+ * - **Version-Conditioned Write**: Issues `em.nativeUpdate` with filter `{ id: entity.id, version: entity.getExpectedVersion() }`
+ *   and updates fields including `{ version: entity.version }`.
+ * - **Affected Row Verification**:
+ *   - Exactly `1` row affected: Write succeeded; completes cleanly.
+ *   - `0` rows affected: Performs a refreshed diagnostic read (`findOne` with `refresh: true`):
+ *     - If the entity is absent, throws {@link EntityNotFoundException}.
+ *     - If the entity is present, throws {@link ConcurrencyConflictError}.
+ *   - More than `1` row affected: Throws an `Error` indicating primary-key uniqueness invariant violation.
+ *
+ * > [!NOTE]
+ * > This helper does not perform caching, aggregate acknowledgment, or domain event publication.
+ * > Those concerns are owned by `@Cache`, `@AcknowledgePersisted`, and `CommandBaseHandler` respectively.
+ *
+ * @param em The MikroORM {@link EntityManager} instance (must be in autocommit mode).
+ * @param entityType The entity class or registered name (e.g. `User`, `Role`).
+ * @param entity The aggregate instance providing `id`, `version`, and `getExpectedVersion()`.
+ * @param data Field payload to update (the `version` field is automatically injected from `entity.version`).
+ * @param entityName Friendly name of the entity for error diagnostics (e.g. `'User'`).
+ *
+ * @throws {Error} If called within an active transaction (`em.isInTransaction() === true`).
+ * @throws {EntityNotFoundException} If 0 rows were updated and the entity cannot be found.
+ * @throws {ConcurrencyConflictError} If 0 rows were updated and the entity version has diverged.
+ * @throws {Error} If unexpected row count (> 1) was affected.
+ *
+ * @example Usage in an update command repository
+ * ```typescript
+ * @PersistedWrite<User>({ cache: { setKey: (user) => cacheKey(User.aggregateName, { id: user.id }) } })
+ * async save(user: User): Promise<UserSnapshot> {
+ *   const snapshot = user.toJSON();
+ *   await optimisticUpdate(
+ *     this.store.em,
+ *     User,
+ *     user,
+ *     { username: snapshot.username, updatedAt: snapshot.updatedAt },
+ *     'User',
+ *   );
+ *   return snapshot;
+ * }
+ * ```
+ */
+async function optimisticUpdate(em, entityType, entity, data, entityName) {
+    (0, assert_autocommit_1.assertAutocommit)(em, 'optimisticUpdate');
+    const row = { id: entity.id, expectedVersion: entity.getExpectedVersion() };
+    const affected = await em.nativeUpdate(entityType, { id: row.id, version: row.expectedVersion }, { ...data, version: entity.version });
+    await (0, conditioned_write_1.expectOneRow)(affected, em, entityType, row, entityName, 'updated');
+}
+//# sourceMappingURL=optimistic-update.js.map

package/dist/concurrency/optimistic-update.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimistic-update.js","sourceRoot":"","sources":["../../src/concurrency/optimistic-update.ts"],"names":[],"mappings":";AAAA,sEAAsE;;AA0DtE,4CAeC;AAjED,2DAAuD;AACvD,2DAA4E;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACI,KAAK,UAAU,gBAAgB,CACpC,EAAiB,EACjB,UAA+B,EAC/B,MAAe,EACf,IAAyB,EACzB,UAAkB;IAElB,IAAA,oCAAgB,EAAC,EAAE,EAAE,kBAAkB,CAAC,CAAC;IACzC,MAAM,GAAG,GAAG,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,EAAE,eAAe,EAAE,MAAM,CAAC,kBAAkB,EAAE,EAAE,CAAC;IAC5E,MAAM,QAAQ,GAAG,MAAM,EAAE,CAAC,YAAY,CACpC,UAAU,EACV,EAAE,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,OAAO,EAAE,GAAG,CAAC,eAAe,EAA0B,EACpE,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAyB,CAC5D,CAAC;IACF,MAAM,IAAA,gCAAY,EAAC,QAAQ,EAAE,EAAE,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;AAC3E,CAAC"}

package/dist/errors/mikro-orm.dialect.d.ts

@@ -0,0 +1,32 @@
+import type { IPersistenceDialect } from '@cqrs-ddd/core/persistence';
+import { type MikroORM } from '@mikro-orm/core';
+/**
+ * The MikroORM persistence dialect: it reads the violated unique constraint of a
+ * `UniqueConstraintViolationException` through the ORM's entity metadata, so a
+ * repository maps it by entity property and never names a constraint or column.
+ *
+ * - PostgreSQL reports the constraint name; it is matched against the names in
+ *   the mapping (`unique: 'name'` on a property, `uniques[].name`) or, when none
+ *   is declared, the naming strategy's `indexName`.
+ * - SQLite and libSQL report the `table.column` list; it is matched against the
+ *   columns of each constraint.
+ *
+ * Any other error, an entity without metadata, or an unknown constraint yields
+ * `undefined`, so the decorator rethrows the original error.
+ *
+ * @throws {TypeError} On construction, when a multi-property unique constraint
+ *   has no name, or two constraints of one entity cover the same columns.
+ *
+ * @example
+ * ```ts
+ * const orm = await MikroORM.init(options);
+ * setPersistenceDialect(new MikroOrmDialect(orm));
+ * ```
+ */
+export declare class MikroOrmDialect implements IPersistenceDialect {
+    private readonly constraints;
+    private readonly metadata;
+    constructor(orm: Pick<MikroORM, 'getMetadata' | 'config'>);
+    uniqueViolation(error: unknown, entity: object): string | undefined;
+}
+//# sourceMappingURL=mikro-orm.dialect.d.ts.map

package/dist/errors/mikro-orm.dialect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mikro-orm.dialect.d.ts","sourceRoot":"","sources":["../../src/errors/mikro-orm.dialect.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAGL,KAAK,QAAQ,EAGd,MAAM,iBAAiB,CAAC;AA0EzB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,eAAgB,YAAW,mBAAmB;IACzD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAGxB;IACJ,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkB;gBAE/B,GAAG,EAAE,IAAI,CAAC,QAAQ,EAAE,aAAa,GAAG,QAAQ,CAAC;IAWzD,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;CAapE"}