@cqrs-ddd/mikro-orm 0.2.0

package/dist/repository/aggregate.repository.d.ts

@@ -0,0 +1,68 @@
+import type { ICache, IWriteSideAggregateRepository } from '@cqrs-ddd/core/application';
+import type { RootEntity, RootEntitySnapshot } from '@cqrs-ddd/core/domain';
+import { CommandRepository } from '@cqrs-ddd/core/persistence';
+import type { EntityName } from '@mikro-orm/core';
+import type { IEntityManagerSource } from '../interfaces/entity-manager-source';
+/**
+ * Base class for the command repositories that load and save an existing aggregate.
+ *
+ * Provides authoritative aggregate hydration via {@link findById}:
+ * - Bypasses read-side caches (`@FromCache`) to prevent stale reads on mutation paths.
+ * - Forces MikroORM `{ refresh: true }` to avoid returning stale Unit-of-Work identity-map entities.
+ * - Translates low-level driver failures through {@link mapPersistenceError} into application-neutral transient signals.
+ *
+ * Concrete repositories extend this class, inject dependencies into `super(...)`, and provide their
+ * decorated `save()` method, usually through `@PersistedWrite`.
+ * The `store` is any {@link IEntityManagerSource}, typically the application's own
+ * store; its `em` is also what `save()` passes to `optimisticUpdate` or `optimisticDelete`.
+ *
+ * @typeParam TSnapshot - Snapshot structure of the aggregate.
+ * @typeParam TEntity - Domain aggregate class extending {@link RootEntity}.
+ * @typeParam TResult - Persisted result type returned by `save()`.
+ *
+ * @example
+ * ```typescript
+ * // A NestJS provider; STORE is the application's IEntityManagerSource token.
+ * @Injectable()
+ * export class UpdateUserCommandRepository extends AggregateRepository<
+ *   UserSnapshot,
+ *   User,
+ *   UserSnapshot
+ * > {
+ *   constructor(
+ *     @Inject(CACHE_TOKEN) cache: ICache<UserSnapshot>,
+ *     @Inject(STORE) store: IEntityManagerSource,
+ *   ) {
+ *     super(cache, store, User, User.aggregateName, User.fromJSON);
+ *   }
+ *
+ *   @PersistedWrite<User>({
+ *     unique: { email: (user) => new UniqueEmailException(user) },
+ *   })
+ *   async save(user: User): Promise<UserSnapshot> {
+ *     ...
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class AggregateRepository<TSnapshot extends Partial<RootEntitySnapshot>, TEntity extends RootEntity<TSnapshot>, TResult = unknown> extends CommandRepository<TEntity, TResult, TSnapshot> implements IWriteSideAggregateRepository<TEntity> {
+    protected readonly store: IEntityManagerSource;
+    protected readonly entityClass: EntityName<TEntity>;
+    protected readonly aggregateName: string;
+    protected readonly hydrateFn: (snapshot: TSnapshot) => TEntity;
+    constructor(cache: ICache<TSnapshot>, store: IEntityManagerSource, entityClass: EntityName<TEntity>, aggregateName: string, hydrateFn: (snapshot: TSnapshot) => TEntity);
+    /**
+     * Loads the authoritative aggregate directly from persistence.
+     *
+     * Enforces `{ refresh: true }` so that if the entity was already loaded in the active
+     * EntityManager's identity map, its columns are re-fetched from the database before
+     * domain mutations and optimistic concurrency checks take place. The manager comes
+     * from `store.em`, read for this call.
+     *
+     * @param id - The aggregate identifier.
+     * @returns Rehydrated aggregate instance, or `null` if not found.
+     * @throws {TransientOperationError} If a retryable database connection or driver error occurs.
+     */
+    findById(id: string): Promise<TEntity | null>;
+}
+//# sourceMappingURL=aggregate.repository.d.ts.map

package/dist/repository/aggregate.repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate.repository.d.ts","sourceRoot":"","sources":["../../src/repository/aggregate.repository.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,MAAM,EACN,6BAA6B,EAC9B,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC5E,OAAO,EACL,iBAAiB,EAElB,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,UAAU,EAAe,MAAM,iBAAiB,CAAC;AAE/D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAEhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,8BAAsB,mBAAmB,CACrC,SAAS,SAAS,OAAO,CAAC,kBAAkB,CAAC,EAC7C,OAAO,SAAS,UAAU,CAAC,SAAS,CAAC,EACrC,OAAO,GAAG,OAAO,CAEnB,SAAQ,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,CACrD,YAAW,6BAA6B,CAAC,OAAO,CAAC;IAI/C,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,oBAAoB;IAC9C,SAAS,CAAC,QAAQ,CAAC,WAAW,EAAE,UAAU,CAAC,OAAO,CAAC;IACnD,SAAS,CAAC,QAAQ,CAAC,aAAa,EAAE,MAAM;IACxC,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,OAAO;gBAJ9D,KAAK,EAAE,MAAM,CAAC,SAAS,CAAC,EACL,KAAK,EAAE,oBAAoB,EAC3B,WAAW,EAAE,UAAU,CAAC,OAAO,CAAC,EAChC,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,OAAO;IAKhE;;;;;;;;;;;OAWG;IAYG,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;CAcpD"}

package/dist/repository/aggregate.repository.js

@@ -0,0 +1,103 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateRepository = void 0;
+const persistence_1 = require("@cqrs-ddd/core/persistence");
+const transient_error_1 = require("../errors/transient-error");
+/**
+ * Base class for the command repositories that load and save an existing aggregate.
+ *
+ * Provides authoritative aggregate hydration via {@link findById}:
+ * - Bypasses read-side caches (`@FromCache`) to prevent stale reads on mutation paths.
+ * - Forces MikroORM `{ refresh: true }` to avoid returning stale Unit-of-Work identity-map entities.
+ * - Translates low-level driver failures through {@link mapPersistenceError} into application-neutral transient signals.
+ *
+ * Concrete repositories extend this class, inject dependencies into `super(...)`, and provide their
+ * decorated `save()` method, usually through `@PersistedWrite`.
+ * The `store` is any {@link IEntityManagerSource}, typically the application's own
+ * store; its `em` is also what `save()` passes to `optimisticUpdate` or `optimisticDelete`.
+ *
+ * @typeParam TSnapshot - Snapshot structure of the aggregate.
+ * @typeParam TEntity - Domain aggregate class extending {@link RootEntity}.
+ * @typeParam TResult - Persisted result type returned by `save()`.
+ *
+ * @example
+ * ```typescript
+ * // A NestJS provider; STORE is the application's IEntityManagerSource token.
+ * @Injectable()
+ * export class UpdateUserCommandRepository extends AggregateRepository<
+ *   UserSnapshot,
+ *   User,
+ *   UserSnapshot
+ * > {
+ *   constructor(
+ *     @Inject(CACHE_TOKEN) cache: ICache<UserSnapshot>,
+ *     @Inject(STORE) store: IEntityManagerSource,
+ *   ) {
+ *     super(cache, store, User, User.aggregateName, User.fromJSON);
+ *   }
+ *
+ *   @PersistedWrite<User>({
+ *     unique: { email: (user) => new UniqueEmailException(user) },
+ *   })
+ *   async save(user: User): Promise<UserSnapshot> {
+ *     ...
+ *   }
+ * }
+ * ```
+ */
+class AggregateRepository extends persistence_1.CommandRepository {
+    store;
+    entityClass;
+    aggregateName;
+    hydrateFn;
+    constructor(cache, store, entityClass, aggregateName, hydrateFn) {
+        super(cache);
+        this.store = store;
+        this.entityClass = entityClass;
+        this.aggregateName = aggregateName;
+        this.hydrateFn = hydrateFn;
+    }
+    /**
+     * Loads the authoritative aggregate directly from persistence.
+     *
+     * Enforces `{ refresh: true }` so that if the entity was already loaded in the active
+     * EntityManager's identity map, its columns are re-fetched from the database before
+     * domain mutations and optimistic concurrency checks take place. The manager comes
+     * from `store.em`, read for this call.
+     *
+     * @param id - The aggregate identifier.
+     * @returns Rehydrated aggregate instance, or `null` if not found.
+     * @throws {TransientOperationError} If a retryable database connection or driver error occurs.
+     */
+    async findById(id) {
+        const entity = await this.store.em.findOne(this.entityClass, { id }, { refresh: true });
+        if (!entity) {
+            return null;
+        }
+        const snapshot = entity.toJSON();
+        return this.hydrateFn(snapshot);
+    }
+}
+exports.AggregateRepository = AggregateRepository;
+__decorate([
+    (0, persistence_1.MapPersistenceErrors)({
+        entity: ([id]) => id,
+        otherwise(error, id) {
+            return (0, transient_error_1.mapPersistenceError)(error, `loading ${this.aggregateName} ${id}`);
+        },
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], AggregateRepository.prototype, "findById", null);
+//# sourceMappingURL=aggregate.repository.js.map

package/dist/repository/aggregate.repository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate.repository.js","sourceRoot":"","sources":["../../src/repository/aggregate.repository.ts"],"names":[],"mappings":";AAAA,sEAAsE;;;;;;;;;;;;AAOtE,4DAGoC;AAEpC,+DAAgE;AAGhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAsB,mBAKpB,SAAQ,+BAA8C;IAKjC;IACA;IACA;IACA;IALrB,YACE,KAAwB,EACL,KAA2B,EAC3B,WAAgC,EAChC,aAAqB,EACrB,SAA2C;QAE9D,KAAK,CAAC,KAAK,CAAC,CAAC;QALM,UAAK,GAAL,KAAK,CAAsB;QAC3B,gBAAW,GAAX,WAAW,CAAqB;QAChC,kBAAa,GAAb,aAAa,CAAQ;QACrB,cAAS,GAAT,SAAS,CAAkC;IAGhE,CAAC;IAED;;;;;;;;;;;OAWG;IAYG,AAAN,KAAK,CAAC,QAAQ,CAAC,EAAU;QACvB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,OAAO,CACxC,IAAI,CAAC,WAAW,EAChB,EAAE,EAAE,EAA0B,EAC9B,EAAE,OAAO,EAAE,IAAI,EAAE,CAClB,CAAC;QAEF,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAe,CAAC;QAC9C,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;IAClC,CAAC;CACF;AAvDD,kDAuDC;AAdO;IAXL,IAAA,kCAAoB,EAKnB;QACA,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE;QACpB,SAAS,CAAC,KAAK,EAAE,EAAE;YACjB,OAAO,IAAA,qCAAmB,EAAC,KAAK,EAAE,WAAW,IAAI,CAAC,aAAa,IAAI,EAAE,EAAE,CAAC,CAAC;QAC3E,CAAC;KACF,CAAC;;;;mDAcD"}

package/dist/tenancy/tenant-store.d.ts

@@ -0,0 +1,63 @@
+import type { EntityManager, MikroORM } from '@mikro-orm/core';
+import type { IEntityManagerSource } from '../interfaces/entity-manager-source';
+/**
+ * How tenants are kept apart: `'database'` — one ORM per tenant, each on its own
+ * database; `'schema'` — one ORM, each tenant a schema of its database.
+ */
+export type TenantIsolation = 'database' | 'schema';
+/** Options of {@link TenantStore}. */
+export interface TenantStoreOptions {
+    /** The active tenant. Throw when there is none: the store never picks one. */
+    tenant(): string;
+    /** The initialized ORM that owns `tenant`'s data. Throw for an unknown tenant. */
+    orm(tenant: string): MikroORM;
+    isolation: TenantIsolation;
+}
+/**
+ * The `EntityManager` source of a multi-tenant application: `em` and
+ * `transactional()` always act on the active tenant's database or schema, for
+ * `AggregateRepository`, `MikroOrmCache` and the application's own repositories.
+ *
+ * `em` reuses a contextual manager (a MikroORM `RequestContext` or an active
+ * transaction) only when it belongs to the tenant's ORM, configuration, driver
+ * and schema and no other tenant claimed it first; otherwise it forks one.
+ * `transactional()` always runs on a fresh fork. Every manager it hands out is
+ * recorded to its tenant outside the manager (a `WeakMap`), so a later request
+ * for another tenant cannot reuse it; MikroORM objects are never modified.
+ *
+ * @example
+ * ```ts
+ * const store = new TenantStore({
+ *   tenant: () => currentTenantId() ?? fail(),
+ *   orm: (tenant) => orms.get(tenant) ?? fail(),
+ *   isolation: 'database',
+ * });
+ * const repository = new UpdateUserRepository(cache, store);
+ * ```
+ */
+export declare class TenantStore<TManager extends EntityManager = EntityManager> implements IEntityManagerSource {
+    private readonly options;
+    private readonly owners;
+    constructor(options: TenantStoreOptions);
+    /**
+     * The active tenant's manager: its contextual one when that may be reused,
+     * otherwise a new fork. Read it per operation, never keep it.
+     *
+     * @throws What `options.tenant` or `options.orm` throws.
+     */
+    get em(): TManager;
+    /**
+     * Runs `work` in a transaction on a fork dedicated to this call, for the
+     * active tenant; commits when it resolves and rolls back when it rejects.
+     * What `options.tenant` or `options.orm` throws becomes its rejection.
+     *
+     * @example
+     * ```ts
+     * await store.transactional((em) => em.nativeDelete(CacheEntry, { key }));
+     * ```
+     */
+    transactional<T>(work: (em: TManager) => Promise<T>): Promise<T>;
+    private fork;
+    private canReuse;
+}
+//# sourceMappingURL=tenant-store.d.ts.map

package/dist/tenancy/tenant-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tenant-store.d.ts","sourceRoot":"","sources":["../../src/tenancy/tenant-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC/D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAEhF;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,UAAU,GAAG,QAAQ,CAAC;AAEpD,sCAAsC;AACtC,MAAM,WAAW,kBAAkB;IACjC,8EAA8E;IAC9E,MAAM,IAAI,MAAM,CAAC;IACjB,kFAAkF;IAClF,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,CAAC;IAC9B,SAAS,EAAE,eAAe,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,WAAW,CAAC,QAAQ,SAAS,aAAa,GAAG,aAAa,CACrE,YAAW,oBAAoB;IAInB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAFpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiC;gBAE3B,OAAO,EAAE,kBAAkB;IAExD;;;;;OAKG;IACH,IAAI,EAAE,IAAI,QAAQ,CASjB;IAED;;;;;;;;;OASG;IACG,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAMtE,OAAO,CAAC,IAAI;IASZ,OAAO,CAAC,QAAQ;CAcjB"}

package/dist/tenancy/tenant-store.js

@@ -0,0 +1,91 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TenantStore = void 0;
+/**
+ * The `EntityManager` source of a multi-tenant application: `em` and
+ * `transactional()` always act on the active tenant's database or schema, for
+ * `AggregateRepository`, `MikroOrmCache` and the application's own repositories.
+ *
+ * `em` reuses a contextual manager (a MikroORM `RequestContext` or an active
+ * transaction) only when it belongs to the tenant's ORM, configuration, driver
+ * and schema and no other tenant claimed it first; otherwise it forks one.
+ * `transactional()` always runs on a fresh fork. Every manager it hands out is
+ * recorded to its tenant outside the manager (a `WeakMap`), so a later request
+ * for another tenant cannot reuse it; MikroORM objects are never modified.
+ *
+ * @example
+ * ```ts
+ * const store = new TenantStore({
+ *   tenant: () => currentTenantId() ?? fail(),
+ *   orm: (tenant) => orms.get(tenant) ?? fail(),
+ *   isolation: 'database',
+ * });
+ * const repository = new UpdateUserRepository(cache, store);
+ * ```
+ */
+class TenantStore {
+    options;
+    owners = new WeakMap();
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * The active tenant's manager: its contextual one when that may be reused,
+     * otherwise a new fork. Read it per operation, never keep it.
+     *
+     * @throws What `options.tenant` or `options.orm` throws.
+     */
+    get em() {
+        const tenant = this.options.tenant();
+        const orm = this.options.orm(tenant);
+        const context = contextOf(orm);
+        if (context && this.canReuse(context, orm, tenant)) {
+            if (!this.owners.has(context))
+                this.owners.set(context, tenant);
+            return context;
+        }
+        return this.fork(orm, tenant);
+    }
+    /**
+     * Runs `work` in a transaction on a fork dedicated to this call, for the
+     * active tenant; commits when it resolves and rolls back when it rejects.
+     * What `options.tenant` or `options.orm` throws becomes its rejection.
+     *
+     * @example
+     * ```ts
+     * await store.transactional((em) => em.nativeDelete(CacheEntry, { key }));
+     * ```
+     */
+    async transactional(work) {
+        const tenant = this.options.tenant();
+        const fork = this.fork(this.options.orm(tenant), tenant);
+        return fork.transactional((em) => work(em));
+    }
+    fork(orm, tenant) {
+        const em = orm.em.fork({
+            disableContextResolution: true,
+            ...(this.options.isolation === 'schema' ? { schema: tenant } : {}),
+        });
+        this.owners.set(em, tenant);
+        return em;
+    }
+    canReuse(context, orm, tenant) {
+        const owner = this.owners.get(context);
+        return (context !== orm.em &&
+            (owner === undefined || owner === tenant) &&
+            (context.schema === undefined || context.schema === tenant) &&
+            context.config === orm.config &&
+            context.getDriver() === orm.em.getDriver());
+    }
+}
+exports.TenantStore = TenantStore;
+function contextOf(orm) {
+    try {
+        return orm.em.getContext(false);
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=tenant-store.js.map

package/dist/tenancy/tenant-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tenant-store.js","sourceRoot":"","sources":["../../src/tenancy/tenant-store.ts"],"names":[],"mappings":";AAAA,sEAAsE;;;AAoBtE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAa,WAAW;IAKO;IAFZ,MAAM,GAAG,IAAI,OAAO,EAAkB,CAAC;IAExD,YAA6B,OAA2B;QAA3B,YAAO,GAAP,OAAO,CAAoB;IAAG,CAAC;IAE5D;;;;;OAKG;IACH,IAAI,EAAE;QACJ,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;QACrC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACrC,MAAM,OAAO,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC;QAC/B,IAAI,OAAO,IAAI,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,CAAC;YACnD,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC;gBAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YAChE,OAAO,OAAmB,CAAC;QAC7B,CAAC;QACD,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IAChC,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,aAAa,CAAI,IAAkC;QACvD,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;QACrC,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC;QACzD,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,EAAc,CAAC,CAAC,CAAC;IAC1D,CAAC;IAEO,IAAI,CAAC,GAAa,EAAE,MAAc;QACxC,MAAM,EAAE,GAAG,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC;YACrB,wBAAwB,EAAE,IAAI;YAC9B,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACnE,CAAa,CAAC;QACf,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;QAC5B,OAAO,EAAE,CAAC;IACZ,CAAC;IAEO,QAAQ,CACd,OAAsB,EACtB,GAAa,EACb,MAAc;QAEd,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QACvC,OAAO,CACL,OAAO,KAAK,GAAG,CAAC,EAAE;YAClB,CAAC,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,MAAM,CAAC;YACzC,CAAC,OAAO,CAAC,MAAM,KAAK,SAAS,IAAI,OAAO,CAAC,MAAM,KAAK,MAAM,CAAC;YAC3D,OAAO,CAAC,MAAM,KAAK,GAAG,CAAC,MAAM;YAC7B,OAAO,CAAC,SAAS,EAAE,KAAK,GAAG,CAAC,EAAE,CAAC,SAAS,EAAE,CAC3C,CAAC;IACJ,CAAC;CACF;AA/DD,kCA+DC;AAED,SAAS,SAAS,CAAC,GAAa;IAC9B,IAAI,CAAC;QACH,OAAO,GAAG,CAAC,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC"}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@cqrs-ddd/mikro-orm",
+  "version": "0.2.0",
+  "description": "MikroORM persistence adapters for @cqrs-ddd/core: authoritative aggregate loading, version-conditioned writes, a revision-fenced cache and root-entity schema mapping.",
+  "author": "Aristotelis",
+  "license": "SEE LICENSE IN LICENSE",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aristoteliss/nestjs-pipeline.git",
+    "directory": "packages/ddd-mikro-orm"
+  },
+  "homepage": "https://github.com/aristoteliss/nestjs-pipeline/tree/master/packages/ddd-mikro-orm#readme",
+  "bugs": {
+    "url": "https://github.com/aristoteliss/nestjs-pipeline/issues"
+  },
+  "keywords": [
+    "ddd",
+    "cqrs",
+    "mikro-orm",
+    "repository",
+    "optimistic-concurrency",
+    "cache"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "COMMERCIAL_LICENSE.txt"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@mikro-orm/core": "^7.2.1",
+    "@cqrs-ddd/core": "^0.2.0"
+  },
+  "devDependencies": {
+    "@mikro-orm/core": "^7.2.1",
+    "@vitest/coverage-v8": "^4.1.11",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.11",
+    "@cqrs-ddd/core": "^0.2.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo",
+    "rebuild": "pnpm run clean && pnpm run build",
+    "lint": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}