@cqrs-ddd/core 0.2.0

package/dist/persistence/helpers/cache-version.helper.js

@@ -0,0 +1,71 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCacheNewer = isCacheNewer;
+const cache_barrier_helper_1 = require("./cache-barrier.helper");
+/**
+ * Checks whether a cached snapshot or record is strictly newer than an incoming
+ * record based on explicit version numbers, generation counters, or updatedAt timestamps.
+ *
+ * Returns `true` only if `cached` is strictly newer than `incoming`.
+ * Returns `false` if `incoming` is newer, equal, or if no meaningful ordering can be determined.
+ *
+ * Comparison precedence:
+ * 1. {@link CacheMutationBarrier}: a barrier outranks any snapshot. A cached
+ *    barrier is newer than an incoming snapshot, an incoming barrier always
+ *    replaces a cached snapshot, and between two barriers the cached one is
+ *    newer unless the incoming one has a later `createdAt`.
+ * 2. Numeric `version` (optimistic concurrency version)
+ * 3. Numeric `__gen` (generation sequence counter)
+ * 4. `updatedAt` (Date instance or ISO 8601 string / timestamp)
+ *
+ * @example Comparing versioned aggregate snapshots
+ * ```typescript
+ * isCacheNewer({ id: '1', version: 3 }, { id: '1', version: 2 }); // true
+ * isCacheNewer({ id: '1', version: 2 }, { id: '1', version: 3 }); // false
+ * isCacheNewer({ id: '1', version: 2 }, { id: '1', version: 2 }); // false
+ * ```
+ *
+ * @param cached - The existing data in cache.
+ * @param incoming - The incoming data being written or compared.
+ * @returns `true` if `cached` is strictly newer than `incoming`, `false` otherwise.
+ */
+function isCacheNewer(cached, incoming) {
+    if (!cached ||
+        typeof cached !== 'object' ||
+        !incoming ||
+        typeof incoming !== 'object') {
+        return false;
+    }
+    // A barrier records a mutation that has already been durably applied, so it
+    // outranks any snapshot: a write-through that started before a concurrent
+    // delete must not overwrite it, or the deleted aggregate would reappear in the
+    // cache as an ordinary hit.
+    if ((0, cache_barrier_helper_1.isCacheMutationBarrier)(cached)) {
+        if (!(0, cache_barrier_helper_1.isCacheMutationBarrier)(incoming))
+            return true;
+        // Between two barriers the later one wins, so a fresh mutation can still
+        // supersede an older one.
+        return incoming.createdAt <= cached.createdAt;
+    }
+    // A barrier arriving over a snapshot must always be applied.
+    if ((0, cache_barrier_helper_1.isCacheMutationBarrier)(incoming))
+        return false;
+    const c = cached;
+    const inc = incoming;
+    if (typeof c.version === 'number' && typeof inc.version === 'number') {
+        return c.version > inc.version;
+    }
+    if (typeof c.__gen === 'number' && typeof inc.__gen === 'number') {
+        return c.__gen > inc.__gen;
+    }
+    if (c.updatedAt !== undefined && inc.updatedAt !== undefined) {
+        const cTime = new Date(c.updatedAt).getTime();
+        const incTime = new Date(inc.updatedAt).getTime();
+        if (!Number.isNaN(cTime) && !Number.isNaN(incTime)) {
+            return cTime > incTime;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=cache-version.helper.js.map

package/dist/persistence/helpers/cache-version.helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-version.helper.js","sourceRoot":"","sources":["../../../persistence/helpers/cache-version.helper.ts"],"names":[],"mappings":";AAAA,sEAAsE;;AA+BtE,oCA4CC;AAzED,iEAAgE;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,SAAgB,YAAY,CAAC,MAAe,EAAE,QAAiB;IAC7D,IACE,CAAC,MAAM;QACP,OAAO,MAAM,KAAK,QAAQ;QAC1B,CAAC,QAAQ;QACT,OAAO,QAAQ,KAAK,QAAQ,EAC5B,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,4EAA4E;IAC5E,0EAA0E;IAC1E,+EAA+E;IAC/E,4BAA4B;IAC5B,IAAI,IAAA,6CAAsB,EAAC,MAAM,CAAC,EAAE,CAAC;QACnC,IAAI,CAAC,IAAA,6CAAsB,EAAC,QAAQ,CAAC;YAAE,OAAO,IAAI,CAAC;QACnD,yEAAyE;QACzE,0BAA0B;QAC1B,OAAO,QAAQ,CAAC,SAAS,IAAI,MAAM,CAAC,SAAS,CAAC;IAChD,CAAC;IAED,6DAA6D;IAC7D,IAAI,IAAA,6CAAsB,EAAC,QAAQ,CAAC;QAAE,OAAO,KAAK,CAAC;IAEnD,MAAM,CAAC,GAAG,MAAiC,CAAC;IAC5C,MAAM,GAAG,GAAG,QAAmC,CAAC;IAEhD,IAAI,OAAO,CAAC,CAAC,OAAO,KAAK,QAAQ,IAAI,OAAO,GAAG,CAAC,OAAO,KAAK,QAAQ,EAAE,CAAC;QACrE,OAAO,CAAC,CAAC,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC;IACjC,CAAC;IAED,IAAI,OAAO,CAAC,CAAC,KAAK,KAAK,QAAQ,IAAI,OAAO,GAAG,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;QACjE,OAAO,CAAC,CAAC,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC;IAC7B,CAAC;IAED,IAAI,CAAC,CAAC,SAAS,KAAK,SAAS,IAAI,GAAG,CAAC,SAAS,KAAK,SAAS,EAAE,CAAC;QAC7D,MAAM,KAAK,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,SAAmC,CAAC,CAAC,OAAO,EAAE,CAAC;QACxE,MAAM,OAAO,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC,SAAmC,CAAC,CAAC,OAAO,EAAE,CAAC;QAC5E,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;YACnD,OAAO,KAAK,GAAG,OAAO,CAAC;QACzB,CAAC;IACH,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/persistence/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ORM-neutral persistence building blocks: the repository base classes, the
+ * lifecycle decorators, the cache protocol and its in-memory adapter.
+ *
+ * Repository *ports* are exported from `@cqrs-ddd/core/application`; handlers
+ * should import those and leave this entry point to the adapters. ORM adapters
+ * live in their own packages, such as `@cqrs-ddd/mikro-orm`.
+ */
+export * from './cache/cache-logger';
+export * from './cache/memory.cache';
+export * from './command-repository.abstract';
+export * from './decorators/acknowledge-persisted.decorator';
+export * from './decorators/cache.decorator';
+export * from './decorators/from-cache.decorator';
+export * from './decorators/map-persistence-errors.decorator';
+export * from './decorators/persisted-write.decorator';
+export * from './helpers/cache-barrier.helper';
+export * from './helpers/cache-key.helper';
+export * from './helpers/cache-snapshot.helper';
+export * from './helpers/cache-version.helper';
+export * from './persistence-dialect';
+export * from './query-repository.abstract';
+//# sourceMappingURL=index.d.ts.map

package/dist/persistence/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../persistence/index.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AAEH,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,8CAA8C,CAAC;AAC7D,cAAc,8BAA8B,CAAC;AAC7C,cAAc,mCAAmC,CAAC;AAClD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,wCAAwC,CAAC;AACvD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC"}

package/dist/persistence/index.js

@@ -0,0 +1,40 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * ORM-neutral persistence building blocks: the repository base classes, the
+ * lifecycle decorators, the cache protocol and its in-memory adapter.
+ *
+ * Repository *ports* are exported from `@cqrs-ddd/core/application`; handlers
+ * should import those and leave this entry point to the adapters. ORM adapters
+ * live in their own packages, such as `@cqrs-ddd/mikro-orm`.
+ */
+__exportStar(require("./cache/cache-logger"), exports);
+__exportStar(require("./cache/memory.cache"), exports);
+__exportStar(require("./command-repository.abstract"), exports);
+__exportStar(require("./decorators/acknowledge-persisted.decorator"), exports);
+__exportStar(require("./decorators/cache.decorator"), exports);
+__exportStar(require("./decorators/from-cache.decorator"), exports);
+__exportStar(require("./decorators/map-persistence-errors.decorator"), exports);
+__exportStar(require("./decorators/persisted-write.decorator"), exports);
+__exportStar(require("./helpers/cache-barrier.helper"), exports);
+__exportStar(require("./helpers/cache-key.helper"), exports);
+__exportStar(require("./helpers/cache-snapshot.helper"), exports);
+__exportStar(require("./helpers/cache-version.helper"), exports);
+__exportStar(require("./persistence-dialect"), exports);
+__exportStar(require("./query-repository.abstract"), exports);
+//# sourceMappingURL=index.js.map

package/dist/persistence/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../persistence/index.ts"],"names":[],"mappings":";AAAA,sEAAsE;;;;;;;;;;;;;;;;AAEtE;;;;;;;GAOG;AAEH,uDAAqC;AACrC,uDAAqC;AACrC,gEAA8C;AAC9C,+EAA6D;AAC7D,+DAA6C;AAC7C,oEAAkD;AAClD,gFAA8D;AAC9D,yEAAuD;AACvD,iEAA+C;AAC/C,6DAA2C;AAC3C,kEAAgD;AAChD,iEAA+C;AAC/C,wDAAsC;AACtC,8DAA4C"}

package/dist/persistence/persistence-dialect.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Reads which unique constraint a persistence error violated. Core declares the
+ * contract and knows no database; an adapter package implements it, such as
+ * `MikroOrmDialect` of `@cqrs-ddd/mikro-orm`.
+ */
+export interface IPersistenceDialect {
+    /**
+     * The key of the unique constraint `error` violated while writing `entity`:
+     * the entity property it covers, or the declared name of a multi-column
+     * constraint. `undefined` when `error` is not a unique violation, or names a
+     * constraint the dialect does not know.
+     */
+    uniqueViolation(error: unknown, entity: object): string | undefined;
+}
+/**
+ * Registers the dialect that `@MapPersistenceErrors` and `@PersistedWrite` use
+ * when their options name none. Call it once at the composition root, after
+ * the ORM is initialized; `undefined` removes it.
+ *
+ * @example
+ * ```ts
+ * setPersistenceDialect(new MikroOrmDialect(orm));
+ * ```
+ */
+export declare function setPersistenceDialect(dialect: IPersistenceDialect | undefined): void;
+/**
+ * The registered dialect, or `undefined`.
+ *
+ * @example
+ * ```ts
+ * const dialect = options.dialect ?? persistenceDialect();
+ * ```
+ */
+export declare function persistenceDialect(): IPersistenceDialect | undefined;
+//# sourceMappingURL=persistence-dialect.d.ts.map

package/dist/persistence/persistence-dialect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence-dialect.d.ts","sourceRoot":"","sources":["../../persistence/persistence-dialect.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;OAKG;IACH,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CACrE;AAID;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,mBAAmB,GAAG,SAAS,GACvC,IAAI,CAEN;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,IAAI,mBAAmB,GAAG,SAAS,CAEpE"}

package/dist/persistence/persistence-dialect.js

@@ -0,0 +1,31 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setPersistenceDialect = setPersistenceDialect;
+exports.persistenceDialect = persistenceDialect;
+let registered;
+/**
+ * Registers the dialect that `@MapPersistenceErrors` and `@PersistedWrite` use
+ * when their options name none. Call it once at the composition root, after
+ * the ORM is initialized; `undefined` removes it.
+ *
+ * @example
+ * ```ts
+ * setPersistenceDialect(new MikroOrmDialect(orm));
+ * ```
+ */
+function setPersistenceDialect(dialect) {
+    registered = dialect;
+}
+/**
+ * The registered dialect, or `undefined`.
+ *
+ * @example
+ * ```ts
+ * const dialect = options.dialect ?? persistenceDialect();
+ * ```
+ */
+function persistenceDialect() {
+    return registered;
+}
+//# sourceMappingURL=persistence-dialect.js.map

package/dist/persistence/persistence-dialect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence-dialect.js","sourceRoot":"","sources":["../../persistence/persistence-dialect.ts"],"names":[],"mappings":";AAAA,sEAAsE;;AA6BtE,sDAIC;AAUD,gDAEC;AA5BD,IAAI,UAA2C,CAAC;AAEhD;;;;;;;;;GASG;AACH,SAAgB,qBAAqB,CACnC,OAAwC;IAExC,UAAU,GAAG,OAAO,CAAC;AACvB,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,kBAAkB;IAChC,OAAO,UAAU,CAAC;AACpB,CAAC"}

package/dist/persistence/query-repository.abstract.d.ts

@@ -0,0 +1,76 @@
+import { ICache } from '../application/ports/cache.port';
+import { IQueryRepository } from '../application/ports/query-repository.port';
+import { IQueryOptions } from '../application/query.options';
+/**
+ * Repository-wide snapshot policy applied by {@link FromCache} to methods that
+ * do not declare their own `hydrateFn` / `serializeFn`.
+ */
+export interface QueryRepositoryHydration<TResult> {
+    /**
+     * Rehydrates a cached snapshot. Every cache hit of a method relying on this
+     * default is rehydrated, as with `alwaysHydrate: true`.
+     */
+    hydrateFn: (cached: unknown) => TResult;
+    /** Converts a result into the snapshot stored on a miss. */
+    serializeFn?: (result: TResult) => unknown;
+}
+/**
+ * Base class for read-side (query) repositories.
+ *
+ * Resolves a query via the abstract {@link find} method and receives an
+ * {@link ICache} instance. Subclasses annotate `find()` with the `@FromCache` decorator
+ * to serve cached results, bypass cache, or rehydrate snapshots into domain entities.
+ *
+ * @typeParam TQuery - The query/options type accepted by {@link find}.
+ * @typeParam TResult - The result type returned by {@link find}.
+ *
+ * @example Creating a query repository with @FromCache
+ * ```typescript
+ * @Injectable()
+ * export class GetUserQueryRepository extends QueryRepository<GetUserQuery, User | null> {
+ *   constructor(
+ *     @Inject(CACHE_TOKEN) protected readonly cache: ICache<UserSnapshot>,
+ *     @Inject(MIKRO_ORM_CLIENT) private readonly store: MikroOrmStore,
+ *   ) {
+ *     super(cache);
+ *   }
+ *
+ *   @FromCache<GetUserQuery, User | null>({
+ *     keyFn: (query) => cacheKey('user', { id: query.userId }),
+ *     hydrateFn: (cached) => User.fromJSON(cached as UserSnapshot),
+ *     alwaysHydrate: true,
+ *   })
+ *   async find(query: GetUserQuery): Promise<User | null> {
+ *     return this.store.em.findOne(User, { id: query.userId });
+ *   }
+ * }
+ * ```
+ *
+ * @example Declaring rehydration once for the whole repository
+ * ```typescript
+ * @Injectable()
+ * export class GetRoleQueryRepository extends QueryRepository<GetRoleQuery, Role | null> {
+ *   constructor(
+ *     @Inject(CACHE_TOKEN) cache: ICache<RoleSnapshot>,
+ *     @Inject(MIKRO_ORM_CLIENT) private readonly store: MikroOrmStore,
+ *   ) {
+ *     super(cache, { hydrateFn: (cached) => Role.fromJSON(cached as RoleSnapshot) });
+ *   }
+ *
+ *   @FromCache<GetRoleQuery, Role | null>({
+ *     keyFn: (query) => cacheKey(Role.aggregateName, { id: query.roleId }),
+ *   })
+ *   async find(query: GetRoleQuery): Promise<Role | null> { ... }
+ * }
+ * ```
+ *
+ * A method that declares `hydrateFn` (including `null`) or `serializeFn`
+ * uses its own value instead of the repository default.
+ */
+export declare abstract class QueryRepository<TQuery = IQueryOptions, TResult = unknown> implements IQueryRepository<TQuery, TResult> {
+    protected readonly cache: ICache<unknown>;
+    protected readonly hydration?: QueryRepositoryHydration<TResult> | undefined;
+    constructor(cache: ICache<unknown>, hydration?: QueryRepositoryHydration<TResult> | undefined);
+    abstract find(query: TQuery): Promise<TResult>;
+}
+//# sourceMappingURL=query-repository.abstract.d.ts.map

package/dist/persistence/query-repository.abstract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-repository.abstract.d.ts","sourceRoot":"","sources":["../../persistence/query-repository.abstract.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,iCAAiC,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAE7D;;;GAGG;AACH,MAAM,WAAW,wBAAwB,CAAC,OAAO;IAC/C;;;OAGG;IACH,SAAS,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC;IAExC,4DAA4D;IAC5D,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC;CAC5C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,8BAAsB,eAAe,CAAC,MAAM,GAAG,aAAa,EAAE,OAAO,GAAG,OAAO,CAC7E,YAAW,gBAAgB,CAAC,MAAM,EAAE,OAAO,CAAC;IAG1C,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,OAAO,CAAC;IACzC,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,wBAAwB,CAAC,OAAO,CAAC;gBAD7C,KAAK,EAAE,MAAM,CAAC,OAAO,CAAC,EACtB,SAAS,CAAC,EAAE,wBAAwB,CAAC,OAAO,CAAC,YAAA;IAGlE,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAC/C"}

package/dist/persistence/query-repository.abstract.js

@@ -0,0 +1,67 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryRepository = void 0;
+/**
+ * Base class for read-side (query) repositories.
+ *
+ * Resolves a query via the abstract {@link find} method and receives an
+ * {@link ICache} instance. Subclasses annotate `find()` with the `@FromCache` decorator
+ * to serve cached results, bypass cache, or rehydrate snapshots into domain entities.
+ *
+ * @typeParam TQuery - The query/options type accepted by {@link find}.
+ * @typeParam TResult - The result type returned by {@link find}.
+ *
+ * @example Creating a query repository with @FromCache
+ * ```typescript
+ * @Injectable()
+ * export class GetUserQueryRepository extends QueryRepository<GetUserQuery, User | null> {
+ *   constructor(
+ *     @Inject(CACHE_TOKEN) protected readonly cache: ICache<UserSnapshot>,
+ *     @Inject(MIKRO_ORM_CLIENT) private readonly store: MikroOrmStore,
+ *   ) {
+ *     super(cache);
+ *   }
+ *
+ *   @FromCache<GetUserQuery, User | null>({
+ *     keyFn: (query) => cacheKey('user', { id: query.userId }),
+ *     hydrateFn: (cached) => User.fromJSON(cached as UserSnapshot),
+ *     alwaysHydrate: true,
+ *   })
+ *   async find(query: GetUserQuery): Promise<User | null> {
+ *     return this.store.em.findOne(User, { id: query.userId });
+ *   }
+ * }
+ * ```
+ *
+ * @example Declaring rehydration once for the whole repository
+ * ```typescript
+ * @Injectable()
+ * export class GetRoleQueryRepository extends QueryRepository<GetRoleQuery, Role | null> {
+ *   constructor(
+ *     @Inject(CACHE_TOKEN) cache: ICache<RoleSnapshot>,
+ *     @Inject(MIKRO_ORM_CLIENT) private readonly store: MikroOrmStore,
+ *   ) {
+ *     super(cache, { hydrateFn: (cached) => Role.fromJSON(cached as RoleSnapshot) });
+ *   }
+ *
+ *   @FromCache<GetRoleQuery, Role | null>({
+ *     keyFn: (query) => cacheKey(Role.aggregateName, { id: query.roleId }),
+ *   })
+ *   async find(query: GetRoleQuery): Promise<Role | null> { ... }
+ * }
+ * ```
+ *
+ * A method that declares `hydrateFn` (including `null`) or `serializeFn`
+ * uses its own value instead of the repository default.
+ */
+class QueryRepository {
+    cache;
+    hydration;
+    constructor(cache, hydration) {
+        this.cache = cache;
+        this.hydration = hydration;
+    }
+}
+exports.QueryRepository = QueryRepository;
+//# sourceMappingURL=query-repository.abstract.js.map

package/dist/persistence/query-repository.abstract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-repository.abstract.js","sourceRoot":"","sources":["../../persistence/query-repository.abstract.ts"],"names":[],"mappings":";AAAA,sEAAsE;;;AAqBtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,MAAsB,eAAe;IAId;IACA;IAFrB,YACqB,KAAsB,EACtB,SAA6C;QAD7C,UAAK,GAAL,KAAK,CAAiB;QACtB,cAAS,GAAT,SAAS,CAAoC;IAC/D,CAAC;CAGL;AATD,0CASC"}

package/dist/types/Method.type.d.ts

@@ -0,0 +1,2 @@
+export type Method = (...args: unknown[]) => unknown;
+//# sourceMappingURL=Method.type.d.ts.map

package/dist/types/Method.type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Method.type.d.ts","sourceRoot":"","sources":["../../types/Method.type.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,MAAM,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC"}

package/dist/types/Method.type.js

@@ -0,0 +1,4 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Method.type.js.map

package/dist/types/Method.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Method.type.js","sourceRoot":"","sources":["../../types/Method.type.ts"],"names":[],"mappings":";AAAA,sEAAsE"}

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@cqrs-ddd/core",
+  "version": "0.2.0",
+  "description": "Framework- and ORM-neutral DDD building blocks for TypeScript: aggregates and domain events, CQRS base classes and repository ports, and a revision-fenced repository cache, as separate entry points.",
+  "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-core"
+  },
+  "homepage": "https://github.com/aristoteliss/nestjs-pipeline/tree/master/packages/ddd-core#readme",
+  "bugs": {
+    "url": "https://github.com/aristoteliss/nestjs-pipeline/issues"
+  },
+  "keywords": [
+    "ddd",
+    "domain-driven-design",
+    "cqrs",
+    "aggregate",
+    "domain-events",
+    "repository",
+    "cache"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./domain": {
+      "types": "./dist/domain/index.d.ts",
+      "default": "./dist/domain/index.js"
+    },
+    "./application": {
+      "types": "./dist/application/index.d.ts",
+      "default": "./dist/application/index.js"
+    },
+    "./persistence": {
+      "types": "./dist/persistence/index.d.ts",
+      "default": "./dist/persistence/index.js"
+    },
+    "./http": {
+      "types": "./dist/http/index.d.ts",
+      "default": "./dist/http/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "COMMERCIAL_LICENSE.txt"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@cqrs-ddd/safe-stringify": "^0.2.0",
+    "@cqrs-ddd/uuidv7": "^0.2.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.5.14",
+    "@vitest/coverage-v8": "^4.1.11",
+    "tsx": "^4.23.15",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.11"
+  },
+  "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"
+  }
+}