@cqrs-ddd/core 0.2.0

package/dist/persistence/decorators/persisted-write.decorator.d.ts

@@ -0,0 +1,61 @@
+import type { IPersistenceDialect } from '../persistence-dialect';
+import { type PersistedAggregate } from './acknowledge-persisted.decorator';
+import { type CacheOptions } from './cache.decorator';
+import { type UniqueErrors } from './map-persistence-errors.decorator';
+/**
+ * Options for {@link PersistedWrite}. The aggregate is always the method's
+ * first argument.
+ */
+export interface PersistedWriteOptions<TEntity, TConstraint extends string = never> {
+    /**
+     * Write-through, eviction and barrier/CAS settings, as accepted by
+     * `@Cache({...})`. Omit for a repository without a cache.
+     */
+    cache?: CacheOptions<TEntity>;
+    /**
+     * Domain errors per violated unique constraint, keyed by entity property, as
+     * accepted by `@MapPersistenceErrors({ unique })`.
+     */
+    unique?: UniqueErrors<TEntity, TConstraint>;
+    /** Dialect overriding the registered one, for a repository on another store. */
+    dialect?: IPersistenceDialect;
+    /**
+     * Translator for errors that match no unique mapping, as accepted by
+     * `@MapPersistenceErrors({ otherwise })`.
+     */
+    otherwise?: (error: unknown, entity: TEntity) => unknown;
+}
+/**
+ * Applies the canonical persistence write lifecycle to a repository method
+ * whose first argument is the aggregate being written.
+ *
+ * Equivalent to stacking, outermost to innermost:
+ * `@Cache(options.cache)` → `@AcknowledgePersisted(...)` →
+ * `@MapPersistenceErrors(...)`, each selecting the first argument.
+ *
+ * - A rejected write translates known constraint errors, leaves the persisted
+ *   version baseline unchanged and performs no cache maintenance.
+ * - A resolved write acknowledges the persisted version first, then runs
+ *   best-effort cache maintenance.
+ *
+ * It provides no transaction or event-delivery guarantee beyond those
+ * decorators: promise resolution must mean a durable autocommitted write.
+ * Use the individual decorators for other signatures, for writes that must not
+ * acknowledge (such as deletes), or for caller-owned ordering.
+ *
+ * @example
+ * ```typescript
+ * @PersistedWrite<User>({
+ *   cache: {
+ *     setKey: (user) => cacheKey(User.aggregateName, { id: user.id }),
+ *     invalidateKeys: (user) => [
+ *       cacheKey(User.aggregateName, { email: user.email }),
+ *     ],
+ *   },
+ *   unique: { email: (user) => new UniqueEmailException(user) },
+ * })
+ * async save(user: User): Promise<UserSnapshot> { ... }
+ * ```
+ */
+export declare function PersistedWrite<TEntity extends PersistedAggregate, TConstraint extends string = never>(options?: PersistedWriteOptions<TEntity, TConstraint>): <TResult>(target: object, key: string | symbol, descriptor: TypedPropertyDescriptor<(entity: TEntity) => Promise<TResult>>) => void;
+//# sourceMappingURL=persisted-write.decorator.d.ts.map

package/dist/persistence/decorators/persisted-write.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persisted-write.decorator.d.ts","sourceRoot":"","sources":["../../../persistence/decorators/persisted-write.decorator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAS,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,EAEL,KAAK,YAAY,EAClB,MAAM,oCAAoC,CAAC;AAE5C;;;GAGG;AACH,MAAM,WAAW,qBAAqB,CACpC,OAAO,EACP,WAAW,SAAS,MAAM,GAAG,KAAK;IAElC;;;OAGG;IACH,KAAK,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;IAE9B;;;OAGG;IACH,MAAM,CAAC,EAAE,YAAY,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;IAE5C,gFAAgF;IAChF,OAAO,CAAC,EAAE,mBAAmB,CAAC;IAE9B;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC;CAC1D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,cAAc,CAC5B,OAAO,SAAS,kBAAkB,EAClC,WAAW,SAAS,MAAM,GAAG,KAAK,EAClC,OAAO,GAAE,qBAAqB,CAAC,OAAO,EAAE,WAAW,CAAM,IAYjD,OAAO,EACb,QAAQ,MAAM,EACd,KAAK,MAAM,GAAG,MAAM,EACpB,YAAY,uBAAuB,CAAC,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,KACzE,IAAI,CAKR"}

package/dist/persistence/decorators/persisted-write.decorator.js

@@ -0,0 +1,57 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersistedWrite = PersistedWrite;
+const acknowledge_persisted_decorator_1 = require("./acknowledge-persisted.decorator");
+const cache_decorator_1 = require("./cache.decorator");
+const map_persistence_errors_decorator_1 = require("./map-persistence-errors.decorator");
+/**
+ * Applies the canonical persistence write lifecycle to a repository method
+ * whose first argument is the aggregate being written.
+ *
+ * Equivalent to stacking, outermost to innermost:
+ * `@Cache(options.cache)` → `@AcknowledgePersisted(...)` →
+ * `@MapPersistenceErrors(...)`, each selecting the first argument.
+ *
+ * - A rejected write translates known constraint errors, leaves the persisted
+ *   version baseline unchanged and performs no cache maintenance.
+ * - A resolved write acknowledges the persisted version first, then runs
+ *   best-effort cache maintenance.
+ *
+ * It provides no transaction or event-delivery guarantee beyond those
+ * decorators: promise resolution must mean a durable autocommitted write.
+ * Use the individual decorators for other signatures, for writes that must not
+ * acknowledge (such as deletes), or for caller-owned ordering.
+ *
+ * @example
+ * ```typescript
+ * @PersistedWrite<User>({
+ *   cache: {
+ *     setKey: (user) => cacheKey(User.aggregateName, { id: user.id }),
+ *     invalidateKeys: (user) => [
+ *       cacheKey(User.aggregateName, { email: user.email }),
+ *     ],
+ *   },
+ *   unique: { email: (user) => new UniqueEmailException(user) },
+ * })
+ * async save(user: User): Promise<UserSnapshot> { ... }
+ * ```
+ */
+function PersistedWrite(options = {}) {
+    const cache = options.cache ? (0, cache_decorator_1.Cache)(options.cache) : undefined;
+    const acknowledge = (0, acknowledge_persisted_decorator_1.AcknowledgePersisted)({
+        entity: ([entity]) => entity,
+    });
+    const mapErrors = (0, map_persistence_errors_decorator_1.MapPersistenceErrors)({
+        entity: ([entity]) => entity,
+        unique: options.unique,
+        dialect: options.dialect,
+        otherwise: options.otherwise,
+    });
+    return (target, key, descriptor) => {
+        mapErrors(target, key, descriptor);
+        acknowledge(target, key, descriptor);
+        cache?.(target, key, descriptor);
+    };
+}
+//# sourceMappingURL=persisted-write.decorator.js.map

package/dist/persistence/decorators/persisted-write.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persisted-write.decorator.js","sourceRoot":"","sources":["../../../persistence/decorators/persisted-write.decorator.ts"],"names":[],"mappings":";AAAA,sEAAsE;;AA2EtE,wCAwBC;AAhGD,uFAG2C;AAC3C,uDAA6D;AAC7D,yFAG4C;AAgC5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,SAAgB,cAAc,CAG5B,UAAuD,EAAE;IACzD,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,IAAA,uBAAK,EAAU,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACxE,MAAM,WAAW,GAAG,IAAA,sDAAoB,EAAY;QAClD,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC,MAAM;KAC7B,CAAC,CAAC;IACH,MAAM,SAAS,GAAG,IAAA,uDAAoB,EAAkC;QACtE,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC,MAAM;QAC5B,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,OAAO,EAAE,OAAO,CAAC,OAAO;QACxB,SAAS,EAAE,OAAO,CAAC,SAAS;KAC7B,CAAC,CAAC;IAEH,OAAO,CACL,MAAc,EACd,GAAoB,EACpB,UAA0E,EACpE,EAAE;QACR,SAAS,CAAC,MAAM,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC;QACnC,WAAW,CAAC,MAAM,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC;QACrC,KAAK,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC;IACnC,CAAC,CAAC;AACJ,CAAC"}

package/dist/persistence/helpers/cache-barrier.helper.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Mutation reason associated with a {@link CacheMutationBarrier}.
+ */
+export type CacheBarrierReason = 'deleted' | 'invalidated';
+/**
+ * Sentinel marker installed in cache during mutations (deletion or invalidation)
+ * to record that a cache key changed while a concurrent read may have been in flight.
+ *
+ * {@link FromCache} treats a barrier as a miss, never as a snapshot. The
+ * protection against stale data comes from {@link isCacheNewer}, the default
+ * `isNewer` of the {@link Cache} write-through: it ranks a barrier above any
+ * snapshot, so a write-through that started before the mutation cannot
+ * overwrite it.
+ */
+export interface CacheMutationBarrier {
+    readonly __cacheBarrier: true;
+    /**
+     * Unique per barrier (UUIDv7); diagnostic only.
+     */
+    readonly token: string;
+    /**
+     * Reason for the barrier installation.
+     */
+    readonly reason: CacheBarrierReason;
+    /**
+     * Epoch timestamp when the barrier was installed.
+     */
+    readonly createdAt: number;
+    /**
+     * Diagnostic aggregate identifier if available on the mutated entity.
+     */
+    readonly aggregateId?: string;
+    /**
+     * Diagnostic version number if available on the mutated entity.
+     */
+    readonly version?: number;
+}
+/**
+ * Union representing values persisted in the cache infrastructure layer.
+ */
+export type CacheStoredValue<TSnapshot> = TSnapshot | CacheMutationBarrier;
+/**
+ * Factory creating a new {@link CacheMutationBarrier} with a unique token.
+ *
+ * @param reason - Whether the barrier represents an entity deletion or secondary invalidation.
+ * @param entity - Optional entity or snapshot providing diagnostic id or version metadata.
+ * @returns Pure serializable {@link CacheMutationBarrier}.
+ *
+ * @example
+ * ```typescript
+ * const barrier = createCacheMutationBarrier('deleted', user);
+ * await cache.set(key, barrier, { ttl: DEFAULT_BARRIER_TTL_MS });
+ * ```
+ */
+export declare function createCacheMutationBarrier(reason: CacheBarrierReason, entity?: unknown): CacheMutationBarrier;
+/**
+ * Type guard verifying whether an arbitrary value is a {@link CacheMutationBarrier}.
+ *
+ * @param value - Candidate value retrieved from cache.
+ * @returns `true` if value is a {@link CacheMutationBarrier}, `false` otherwise.
+ *
+ * @example
+ * ```typescript
+ * if (isCacheMutationBarrier(cached)) {
+ *   // Barrier encountered; treat as a miss
+ * }
+ * ```
+ */
+export declare function isCacheMutationBarrier(value: unknown): value is CacheMutationBarrier;
+//# sourceMappingURL=cache-barrier.helper.d.ts.map

package/dist/persistence/helpers/cache-barrier.helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-barrier.helper.d.ts","sourceRoot":"","sources":["../../../persistence/helpers/cache-barrier.helper.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,aAAa,CAAC;AAE3D;;;;;;;;;GASG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,cAAc,EAAE,IAAI,CAAC;IAE9B;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAAC;IAEpC;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAE3B;;OAEG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAE9B;;OAEG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAAC,SAAS,IAAI,SAAS,GAAG,oBAAoB,CAAC;AAE3E;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,kBAAkB,EAC1B,MAAM,CAAC,EAAE,OAAO,GACf,oBAAoB,CAsBtB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,oBAAoB,CAM/B"}

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

@@ -0,0 +1,57 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCacheMutationBarrier = createCacheMutationBarrier;
+exports.isCacheMutationBarrier = isCacheMutationBarrier;
+const uuidv7_1 = require("@cqrs-ddd/uuidv7");
+/**
+ * Factory creating a new {@link CacheMutationBarrier} with a unique token.
+ *
+ * @param reason - Whether the barrier represents an entity deletion or secondary invalidation.
+ * @param entity - Optional entity or snapshot providing diagnostic id or version metadata.
+ * @returns Pure serializable {@link CacheMutationBarrier}.
+ *
+ * @example
+ * ```typescript
+ * const barrier = createCacheMutationBarrier('deleted', user);
+ * await cache.set(key, barrier, { ttl: DEFAULT_BARRIER_TTL_MS });
+ * ```
+ */
+function createCacheMutationBarrier(reason, entity) {
+    const e = typeof entity === 'object' && entity !== null
+        ? entity
+        : undefined;
+    const aggregateId = typeof e?.id === 'string' ? e.id : undefined;
+    const version = typeof e?.version === 'number'
+        ? e.version
+        : typeof e?._version === 'number'
+            ? e._version
+            : undefined;
+    return {
+        __cacheBarrier: true,
+        token: (0, uuidv7_1.uuidv7)(),
+        reason,
+        createdAt: Date.now(),
+        ...(aggregateId !== undefined ? { aggregateId } : {}),
+        ...(version !== undefined ? { version } : {}),
+    };
+}
+/**
+ * Type guard verifying whether an arbitrary value is a {@link CacheMutationBarrier}.
+ *
+ * @param value - Candidate value retrieved from cache.
+ * @returns `true` if value is a {@link CacheMutationBarrier}, `false` otherwise.
+ *
+ * @example
+ * ```typescript
+ * if (isCacheMutationBarrier(cached)) {
+ *   // Barrier encountered; treat as a miss
+ * }
+ * ```
+ */
+function isCacheMutationBarrier(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value.__cacheBarrier === true);
+}
+//# sourceMappingURL=cache-barrier.helper.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cache-barrier.helper.js","sourceRoot":"","sources":["../../../persistence/helpers/cache-barrier.helper.ts"],"names":[],"mappings":";AAAA,sEAAsE;;AAkEtE,gEAyBC;AAeD,wDAQC;AAhHD,6CAA0C;AAmD1C;;;;;;;;;;;;GAYG;AACH,SAAgB,0BAA0B,CACxC,MAA0B,EAC1B,MAAgB;IAEhB,MAAM,CAAC,GACL,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,IAAI;QAC3C,CAAC,CAAE,MAAkC;QACrC,CAAC,CAAC,SAAS,CAAC;IAEhB,MAAM,WAAW,GAAG,OAAO,CAAC,EAAE,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;IACjE,MAAM,OAAO,GACX,OAAO,CAAC,EAAE,OAAO,KAAK,QAAQ;QAC5B,CAAC,CAAC,CAAC,CAAC,OAAO;QACX,CAAC,CAAC,OAAQ,CAA4B,EAAE,QAAQ,KAAK,QAAQ;YAC3D,CAAC,CAAG,CAA0B,CAAC,QAAmB;YAClD,CAAC,CAAC,SAAS,CAAC;IAElB,OAAO;QACL,cAAc,EAAE,IAAI;QACpB,KAAK,EAAE,IAAA,eAAM,GAAE;QACf,MAAM;QACN,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;QACrB,GAAG,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACrD,GAAG,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC9C,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,sBAAsB,CACpC,KAAc;IAEd,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACb,KAAiC,CAAC,cAAc,KAAK,IAAI,CAC3D,CAAC;AACJ,CAAC"}

package/dist/persistence/helpers/cache-key.helper.d.ts

@@ -0,0 +1,73 @@
+import { type TenantSource } from '../../application/tenant-resolver';
+/**
+ * Types supported as cache key resource specifiers:
+ * - A raw resource string (e.g., `'user'` or `'user:'`)
+ * - An entity constructor declaring `static readonly aggregateName = 'user'`
+ */
+export type CacheResourceSpecifier = string | {
+    aggregateName?: string;
+};
+/**
+ * An explicit tenant for a cache key: a tenant id string, or an object carrying
+ * `tenantId`, such as a request or job context.
+ *
+ * When it is omitted, or an object carries no `tenantId`, the tenant of the
+ * registered {@link setTenantResolver} resolver applies. A missing or empty tenant always throws
+ * {@link MissingTenantContextError}; there is no shared fallback namespace.
+ */
+export type CacheKeyTenantSource = TenantSource;
+/**
+ * A request-bearing source accepted by the factories of {@link cacheKeyTemplate},
+ * such as a request or job context.
+ */
+export interface CacheKeyRequestContext {
+    readonly request: unknown;
+    readonly tenantId?: string | undefined;
+}
+/**
+ * Derives a deterministic, collision-safe cache key from a canonical structured
+ * tuple `[tenant, resource, normalizedFilter]`, versioned and hashed with SHA-256.
+ *
+ * Guarantees:
+ * - **Deterministic ordering**: object keys are sorted recursively.
+ * - **Type preservation**: numbers, booleans, strings, and nulls produce distinct representations.
+ * - **Null retention**: explicit `null` conditions are preserved, distinct from omitted/undefined keys.
+ * - **Fail-safe boundaries**: non-serializable types and cyclic structures are rejected.
+ * - **Versioned namespace**: keys are namespaced as `${tenant}:${resource}:v1:${hash}`.
+ *
+ * @param resourceOrEntity - Logical resource name or object exposing `aggregateName`.
+ * @param conditions - Filter values that identify the cached record/query.
+ * @param tenantOrContext - An explicit tenant id, or an object carrying `tenantId` (such
+ *   as a request or job context). When omitted, the tenant of the registered
+ *   {@link setTenantResolver} resolver is used. See {@link CacheKeyTenantSource}.
+ * @returns A versioned, hashed deterministic cache key.
+ * @throws {MissingTenantContextError} When tenant identity cannot be resolved.
+ * @throws {TypeError} When conditions contain non-serializable values.
+ */
+export declare function cacheKey(resourceOrEntity: CacheResourceSpecifier, conditions: Record<string, unknown>, tenantOrContext?: CacheKeyTenantSource): string;
+/**
+ * Resolves a template string (e.g. `user:{userId}`) against a query/command payload,
+ * namespaced by the active tenant schema.
+ *
+ * Required placeholders throw when absent; optional `{prop?}` placeholders resolve
+ * to an empty string. Object placeholder values use the same canonical serializer
+ * as `cacheKey`.
+ *
+ * @param template - Key template containing required `{prop}` or optional `{prop?}` placeholders.
+ * @param tenantOrContext - An explicit tenant used to namespace produced keys. When
+ *   omitted, a context source's `tenantId` is used, and otherwise the tenant of the
+ *   registered {@link setTenantResolver} resolver.
+ * @returns A key factory accepting either a request object or a
+ *   {@link CacheKeyRequestContext} (such as a request or job context).
+ * @throws {MissingTenantContextError} When tenant identity cannot be resolved.
+ * @throws {Error} When a required placeholder is absent.
+ *
+ * @example
+ * ```ts
+ * const byId = cacheKeyTemplate<{ userId: string }>('user:{userId}');
+ * const key = byId({ userId: '019...' });
+ * // tenant-a:user:019...
+ * ```
+ */
+export declare function cacheKeyTemplate<T = Record<string, unknown>>(template: string, tenantOrContext?: CacheKeyTenantSource): (source: T | CacheKeyRequestContext) => string;
+//# sourceMappingURL=cache-key.helper.d.ts.map

package/dist/persistence/helpers/cache-key.helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-key.helper.d.ts","sourceRoot":"","sources":["../../../persistence/helpers/cache-key.helper.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,KAAK,YAAY,EAClB,MAAM,mCAAmC,CAAC;AAE3C;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG,MAAM,GAAG;IAAE,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzE;;;;;;;GAOG;AACH,MAAM,MAAM,oBAAoB,GAAG,YAAY,CAAC;AAEhD;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACxC;AAmCD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,QAAQ,CACtB,gBAAgB,EAAE,sBAAsB,EACxC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,eAAe,CAAC,EAAE,oBAAoB,GACrC,MAAM,CA0BR;AAiBD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1D,QAAQ,EAAE,MAAM,EAChB,eAAe,CAAC,EAAE,oBAAoB,GACrC,CAAC,MAAM,EAAE,CAAC,GAAG,sBAAsB,KAAK,MAAM,CA8BhD"}

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

@@ -0,0 +1,132 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheKey = cacheKey;
+exports.cacheKeyTemplate = cacheKeyTemplate;
+const node_crypto_1 = require("node:crypto");
+const safe_stringify_1 = require("@cqrs-ddd/safe-stringify");
+const tenant_resolver_1 = require("../../application/tenant-resolver");
+/**
+ * Normalizes filter conditions for canonical tuple construction:
+ * - Omits undefined properties.
+ * - Retains null values.
+ * - Preserves scalar and structured types.
+ * - Rejects non-serializable types (functions, symbols, BigInt).
+ */
+function normalizeFilterConditions(conditions) {
+    const sortedKeys = Object.keys(conditions).sort();
+    const normalized = {};
+    for (const key of sortedKeys) {
+        const val = conditions[key];
+        if (val === undefined) {
+            continue;
+        }
+        if (typeof val === 'function' ||
+            typeof val === 'symbol' ||
+            typeof val === 'bigint') {
+            throw new TypeError(`cacheKey does not support values of type ${typeof val}.`);
+        }
+        normalized[key] = val;
+    }
+    return normalized;
+}
+/**
+ * Derives a deterministic, collision-safe cache key from a canonical structured
+ * tuple `[tenant, resource, normalizedFilter]`, versioned and hashed with SHA-256.
+ *
+ * Guarantees:
+ * - **Deterministic ordering**: object keys are sorted recursively.
+ * - **Type preservation**: numbers, booleans, strings, and nulls produce distinct representations.
+ * - **Null retention**: explicit `null` conditions are preserved, distinct from omitted/undefined keys.
+ * - **Fail-safe boundaries**: non-serializable types and cyclic structures are rejected.
+ * - **Versioned namespace**: keys are namespaced as `${tenant}:${resource}:v1:${hash}`.
+ *
+ * @param resourceOrEntity - Logical resource name or object exposing `aggregateName`.
+ * @param conditions - Filter values that identify the cached record/query.
+ * @param tenantOrContext - An explicit tenant id, or an object carrying `tenantId` (such
+ *   as a request or job context). When omitted, the tenant of the registered
+ *   {@link setTenantResolver} resolver is used. See {@link CacheKeyTenantSource}.
+ * @returns A versioned, hashed deterministic cache key.
+ * @throws {MissingTenantContextError} When tenant identity cannot be resolved.
+ * @throws {TypeError} When conditions contain non-serializable values.
+ */
+function cacheKey(resourceOrEntity, conditions, tenantOrContext) {
+    const schema = (0, tenant_resolver_1.requireTenantId)(tenantOrContext, 'cache key derivation');
+    let resource;
+    if (typeof resourceOrEntity === 'string') {
+        resource = resourceOrEntity;
+    }
+    else if (resourceOrEntity &&
+        (typeof resourceOrEntity === 'object' ||
+            typeof resourceOrEntity === 'function')) {
+        resource = resourceOrEntity.aggregateName || undefined;
+    }
+    if (resource === undefined) {
+        throw new Error('Cannot resolve cache key prefix: resourceOrEntity must be a string or declare a static aggregateName.');
+    }
+    resource = resource.replace(/:+$/, '');
+    const normalizedFilter = normalizeFilterConditions(conditions);
+    const tuple = [schema, resource, normalizedFilter];
+    const serializedTuple = (0, safe_stringify_1.stableStringify)(tuple);
+    const hash = (0, node_crypto_1.createHash)('sha256').update(serializedTuple).digest('hex');
+    return `${schema}:${resource}:v1:${hash}`;
+}
+/**
+ * Serializes one template placeholder value into a key segment.
+ *
+ * Template keys stay human-readable rather than hashed, so `:` and `\\` remain
+ * structural characters here and are escaped with {@link escapeKeySegment};
+ * nested values delegate to the shared {@link stableStringify} for deterministic
+ * recursive ordering.
+ */
+function canonicalizeValue(val) {
+    if (typeof val === 'object') {
+        return (0, safe_stringify_1.stableStringify)(val);
+    }
+    return (0, safe_stringify_1.escapeKeySegment)(String(val));
+}
+/**
+ * Resolves a template string (e.g. `user:{userId}`) against a query/command payload,
+ * namespaced by the active tenant schema.
+ *
+ * Required placeholders throw when absent; optional `{prop?}` placeholders resolve
+ * to an empty string. Object placeholder values use the same canonical serializer
+ * as `cacheKey`.
+ *
+ * @param template - Key template containing required `{prop}` or optional `{prop?}` placeholders.
+ * @param tenantOrContext - An explicit tenant used to namespace produced keys. When
+ *   omitted, a context source's `tenantId` is used, and otherwise the tenant of the
+ *   registered {@link setTenantResolver} resolver.
+ * @returns A key factory accepting either a request object or a
+ *   {@link CacheKeyRequestContext} (such as a request or job context).
+ * @throws {MissingTenantContextError} When tenant identity cannot be resolved.
+ * @throws {Error} When a required placeholder is absent.
+ *
+ * @example
+ * ```ts
+ * const byId = cacheKeyTemplate<{ userId: string }>('user:{userId}');
+ * const key = byId({ userId: '019...' });
+ * // tenant-a:user:019...
+ * ```
+ */
+function cacheKeyTemplate(template, tenantOrContext) {
+    return (source) => {
+        const ctx = source && typeof source === 'object' && 'request' in source
+            ? source
+            : undefined;
+        const data = (ctx ? ctx.request : source);
+        const schema = (0, tenant_resolver_1.requireTenantId)(tenantOrContext ?? ctx, 'cache key derivation');
+        const resolved = template.replace(/\{(\w+)(\?)?\}/g, (_, prop, optional) => {
+            const val = data?.[prop];
+            if (val !== undefined && val !== null) {
+                return canonicalizeValue(val);
+            }
+            if (optional) {
+                return '';
+            }
+            throw new Error(`Cannot resolve cache key template: missing required placeholder "${prop}".`);
+        });
+        return `${schema}:${resolved}`;
+    };
+}
+//# sourceMappingURL=cache-key.helper.js.map

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

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

package/dist/persistence/helpers/cache-owner.helper.d.ts

@@ -0,0 +1,9 @@
+import type { ICacheLogger } from '../cache/cache-logger';
+/**
+ * Reports, once per repository class, a cache decorator running on an instance
+ * that has no `cache` property. Such a repository is miswired: cache
+ * maintenance and read-through are skipped. An instance that declares `cache`
+ * and leaves it unset is intentionally uncached and is not reported.
+ */
+export declare function reportMissingCacheProperty(instance: object, decorator: '@Cache' | '@FromCache', logger?: ICacheLogger): void;
+//# sourceMappingURL=cache-owner.helper.d.ts.map

package/dist/persistence/helpers/cache-owner.helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-owner.helper.d.ts","sourceRoot":"","sources":["../../../persistence/helpers/cache-owner.helper.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAM1D;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,QAAQ,GAAG,YAAY,EAClC,MAAM,GAAE,YAA4B,GACnC,IAAI,CASN"}

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

@@ -0,0 +1,22 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportMissingCacheProperty = reportMissingCacheProperty;
+const cache_logger_1 = require("../cache/cache-logger");
+const defaultLogger = (0, cache_logger_1.consoleCacheLogger)('CacheDecorators');
+const reportedOwners = new WeakSet();
+/**
+ * Reports, once per repository class, a cache decorator running on an instance
+ * that has no `cache` property. Such a repository is miswired: cache
+ * maintenance and read-through are skipped. An instance that declares `cache`
+ * and leaves it unset is intentionally uncached and is not reported.
+ */
+function reportMissingCacheProperty(instance, decorator, logger = defaultLogger) {
+    const owner = instance.constructor;
+    if ('cache' in instance || reportedOwners.has(owner))
+        return;
+    reportedOwners.add(owner);
+    (0, cache_logger_1.safeWarn)(logger, `${owner.name} uses ${decorator} but has no \`cache\` property, so caching is skipped. ` +
+        'Extend CommandRepository/QueryRepository or declare a `cache` property.');
+}
+//# sourceMappingURL=cache-owner.helper.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cache-owner.helper.js","sourceRoot":"","sources":["../../../persistence/helpers/cache-owner.helper.ts"],"names":[],"mappings":";AAAA,sEAAsE;;AActE,gEAaC;AAxBD,wDAAqE;AAErE,MAAM,aAAa,GAAG,IAAA,iCAAkB,EAAC,iBAAiB,CAAC,CAAC;AAC5D,MAAM,cAAc,GAAG,IAAI,OAAO,EAAU,CAAC;AAE7C;;;;;GAKG;AACH,SAAgB,0BAA0B,CACxC,QAAgB,EAChB,SAAkC,EAClC,SAAuB,aAAa;IAEpC,MAAM,KAAK,GAAG,QAAQ,CAAC,WAAW,CAAC;IACnC,IAAI,OAAO,IAAI,QAAQ,IAAI,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC;QAAE,OAAO;IAC7D,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAC1B,IAAA,uBAAQ,EACN,MAAM,EACN,GAAG,KAAK,CAAC,IAAI,SAAS,SAAS,yDAAyD;QACtF,yEAAyE,CAC5E,CAAC;AACJ,CAAC"}

package/dist/persistence/helpers/cache-snapshot.helper.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Extracts a detached, serializable snapshot from a domain entity, aggregate root,
+ * or arbitrary value before storing in cache or performing version comparisons.
+ *
+ * Serialization precedence:
+ * 1. Explicit `serializeFn`: Custom transformer passed by caller/decorator.
+ * 2. `value.toJSON()`: If the object provides a `toJSON()` method (e.g. `RootEntity.toJSON()`).
+ * 3. Deep JSON clone (`JSON.parse(JSON.stringify(value))`): Clones plain objects and strips
+ *    live class references/methods if no `toJSON` exists, guaranteeing isolation parity.
+ * 4. Primitive / nullish pass-through: Returns primitives and null/undefined as-is.
+ *
+ * @example Extracting snapshot from domain entity with toJSON
+ * ```typescript
+ * const snapshot = toCacheSnapshot(user);
+ * // Returns plain UserSnapshot object
+ * ```
+ *
+ * @example Custom serializer function
+ * ```typescript
+ * const snapshot = toCacheSnapshot(user, (u) => ({ id: u.id, custom: true }));
+ * ```
+ *
+ * @param value - The entity or value to snapshot.
+ * @param serializeFn - Optional custom serialization function.
+ * @returns Pure, detached serializable snapshot.
+ */
+export declare function toCacheSnapshot<T>(value: T, serializeFn?: ((value: T) => unknown) | null): unknown;
+//# sourceMappingURL=cache-snapshot.helper.d.ts.map

package/dist/persistence/helpers/cache-snapshot.helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-snapshot.helper.d.ts","sourceRoot":"","sources":["../../../persistence/helpers/cache-snapshot.helper.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,KAAK,EAAE,CAAC,EACR,WAAW,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,GAAG,IAAI,GAC3C,OAAO,CAYT"}

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

@@ -0,0 +1,42 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCacheSnapshot = toCacheSnapshot;
+/**
+ * Extracts a detached, serializable snapshot from a domain entity, aggregate root,
+ * or arbitrary value before storing in cache or performing version comparisons.
+ *
+ * Serialization precedence:
+ * 1. Explicit `serializeFn`: Custom transformer passed by caller/decorator.
+ * 2. `value.toJSON()`: If the object provides a `toJSON()` method (e.g. `RootEntity.toJSON()`).
+ * 3. Deep JSON clone (`JSON.parse(JSON.stringify(value))`): Clones plain objects and strips
+ *    live class references/methods if no `toJSON` exists, guaranteeing isolation parity.
+ * 4. Primitive / nullish pass-through: Returns primitives and null/undefined as-is.
+ *
+ * @example Extracting snapshot from domain entity with toJSON
+ * ```typescript
+ * const snapshot = toCacheSnapshot(user);
+ * // Returns plain UserSnapshot object
+ * ```
+ *
+ * @example Custom serializer function
+ * ```typescript
+ * const snapshot = toCacheSnapshot(user, (u) => ({ id: u.id, custom: true }));
+ * ```
+ *
+ * @param value - The entity or value to snapshot.
+ * @param serializeFn - Optional custom serialization function.
+ * @returns Pure, detached serializable snapshot.
+ */
+function toCacheSnapshot(value, serializeFn) {
+    if (serializeFn) {
+        return serializeFn(value);
+    }
+    if (value === null || typeof value !== 'object') {
+        return value;
+    }
+    return typeof value.toJSON === 'function'
+        ? value.toJSON()
+        : JSON.parse(JSON.stringify(value));
+}
+//# sourceMappingURL=cache-snapshot.helper.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cache-snapshot.helper.js","sourceRoot":"","sources":["../../../persistence/helpers/cache-snapshot.helper.ts"],"names":[],"mappings":";AAAA,sEAAsE;;AA4BtE,0CAeC;AAzCD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,SAAgB,eAAe,CAC7B,KAAQ,EACR,WAA4C;IAE5C,IAAI,WAAW,EAAE,CAAC;QAChB,OAAO,WAAW,CAAC,KAAK,CAAC,CAAC;IAC5B,CAAC;IAED,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAChD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO,OAAQ,KAA8B,CAAC,MAAM,KAAK,UAAU;QACjE,CAAC,CAAE,KAA0C,CAAC,MAAM,EAAE;QACtD,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;AACxC,CAAC"}

package/dist/persistence/helpers/cache-version.helper.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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.
+ */
+export declare function isCacheNewer(cached: unknown, incoming: unknown): boolean;
+//# sourceMappingURL=cache-version.helper.d.ts.map

package/dist/persistence/helpers/cache-version.helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-version.helper.d.ts","sourceRoot":"","sources":["../../../persistence/helpers/cache-version.helper.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO,CA4CxE"}