@event-nest/core 4.0.2 → 5.0.0

package/src/lib/aggregate-root/snapshot-aware.d.ts

@@ -0,0 +1,47 @@
+import type { SnapshotAwareAggregateRoot } from "../storage/event-store";
+import { AggregateRoot } from "./aggregate-root";
+/**
+ * Interface that defines methods that should be implemented by an aggregate root to support snapshots.
+ * Snapshots allow for faster reconstitution of aggregate roots by storing their current state
+ * at specific points in time, rather than replaying all events from the beginning.
+ *
+ * @template Snapshot The type of the snapshot data structure
+ */
+export interface SnapshotAware<Snapshot = unknown> {
+    /**
+     * Applies a snapshot to restore the aggregate root's state from a previously saved snapshot.
+     * @param snapshot The snapshot data to apply
+     */
+    applySnapshot(snapshot: Snapshot): void;
+    /**
+     * Should return a snapshot of the current state of the aggregate root.
+     * @returns The snapshot data representing the current state of the aggregate root.
+     */
+    toSnapshot(): Promise<Snapshot> | Snapshot;
+}
+/**
+ * Type guard that checks if an aggregate root instance implements the SnapshotAware interface.
+ *
+ * @param aggregate The aggregate root instance to check
+ * @returns true if the aggregate root instance implements SnapshotAware, false otherwise
+ */
+export declare const isAggregateInstanceSnapshotAware: (aggregate: AggregateRoot) => aggregate is AggregateRoot & SnapshotAware;
+/**
+ * Checks if an aggregate root class supports snapshots by validating
+ * aggregateRootSnapshotRevision metadata value.
+ *
+ * @see {@link AggregateRootConfig} for metadata attachment details
+ * @param aggregateRoot The aggregate root instance to check
+ * @returns true if the aggregate root's class has correct numeric `snapshotRevision` attached, false otherwise
+ */
+export declare const isAggregateClassSnapshotAware: (aggregateRoot: AggregateRoot) => boolean;
+/**
+ * Asserts that the given aggregate root instance implements the SnapshotAware interface.
+ * Throws an error if the instance does not implement the interface.
+ *
+ * @param aggregateRoot The aggregate root instance to check
+ * @throws {AggregateInstanceNotSnapshotAwareException} if the instance does not implement SnapshotAware
+ * @throws {AggregateClassNotSnapshotAwareException} if the class does not have a valid snapshot revision
+ * @throws {MissingAggregateRootNameException} if the aggregate root name is missing
+ */
+export declare function assertIsSnapshotAwareAggregateRoot(aggregateRoot: AggregateRoot): asserts aggregateRoot is SnapshotAwareAggregateRoot;

package/src/lib/aggregate-root/snapshot-aware.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAggregateClassSnapshotAware = exports.isAggregateInstanceSnapshotAware = void 0;
+exports.assertIsSnapshotAwareAggregateRoot = assertIsSnapshotAwareAggregateRoot;
+const es_toolkit_1 = require("es-toolkit");
+const aggregate_class_not_snapshot_aware_exception_1 = require("../exceptions/aggregate-class-not-snapshot-aware-exception");
+const aggregate_instance_not_snapshot_aware_exception_1 = require("../exceptions/aggregate-instance-not-snapshot-aware-exception");
+const missing_aggregate_root_name_exception_1 = require("../exceptions/missing-aggregate-root-name-exception");
+const aggregate_root_config_1 = require("./aggregate-root-config");
+/**
+ * Type guard that checks if an aggregate root instance implements the SnapshotAware interface.
+ *
+ * @param aggregate The aggregate root instance to check
+ * @returns true if the aggregate root instance implements SnapshotAware, false otherwise
+ */
+const isAggregateInstanceSnapshotAware = (aggregate) => "toSnapshot" in aggregate &&
+    (0, es_toolkit_1.isFunction)(aggregate.toSnapshot) &&
+    "applySnapshot" in aggregate &&
+    (0, es_toolkit_1.isFunction)(aggregate.applySnapshot);
+exports.isAggregateInstanceSnapshotAware = isAggregateInstanceSnapshotAware;
+/**
+ * Checks if an aggregate root class supports snapshots by validating
+ * aggregateRootSnapshotRevision metadata value.
+ *
+ * @see {@link AggregateRootConfig} for metadata attachment details
+ * @param aggregateRoot The aggregate root instance to check
+ * @returns true if the aggregate root's class has correct numeric `snapshotRevision` attached, false otherwise
+ */
+const isAggregateClassSnapshotAware = (aggregateRoot) => typeof (0, aggregate_root_config_1.getAggregateRootSnapshotRevision)(aggregateRoot.constructor) === "number";
+exports.isAggregateClassSnapshotAware = isAggregateClassSnapshotAware;
+/**
+ * Asserts that the given aggregate root instance implements the SnapshotAware interface.
+ * Throws an error if the instance does not implement the interface.
+ *
+ * @param aggregateRoot The aggregate root instance to check
+ * @throws {AggregateInstanceNotSnapshotAwareException} if the instance does not implement SnapshotAware
+ * @throws {AggregateClassNotSnapshotAwareException} if the class does not have a valid snapshot revision
+ * @throws {MissingAggregateRootNameException} if the aggregate root name is missing
+ */
+function assertIsSnapshotAwareAggregateRoot(aggregateRoot) {
+    const aggregateRootName = (0, aggregate_root_config_1.getAggregateRootName)(aggregateRoot.constructor);
+    if (!aggregateRootName) {
+        throw new missing_aggregate_root_name_exception_1.MissingAggregateRootNameException(aggregateRoot.constructor.name);
+    }
+    if (!(0, exports.isAggregateInstanceSnapshotAware)(aggregateRoot)) {
+        throw new aggregate_instance_not_snapshot_aware_exception_1.AggregateInstanceNotSnapshotAwareException(aggregateRoot.constructor.name);
+    }
+    if (!(0, exports.isAggregateClassSnapshotAware)(aggregateRoot)) {
+        throw new aggregate_class_not_snapshot_aware_exception_1.AggregateClassNotSnapshotAwareException(aggregateRoot.constructor.name);
+    }
+}
+//# sourceMappingURL=snapshot-aware.js.map

package/src/lib/aggregate-root/snapshot-aware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-aware.js","sourceRoot":"","sources":["../../../../../../libs/core/src/lib/aggregate-root/snapshot-aware.ts"],"names":[],"mappings":";;;AAgEA,gFAgBC;AAhFD,2CAAwC;AAIxC,6HAAqH;AACrH,mIAA2H;AAC3H,+GAAwG;AAExG,mEAAiG;AAsBjG;;;;;GAKG;AACI,MAAM,gCAAgC,GAAG,CAC5C,SAAwB,EACkB,EAAE,CAC5C,YAAY,IAAI,SAAS;IACzB,IAAA,uBAAU,EAAC,SAAS,CAAC,UAAU,CAAC;IAChC,eAAe,IAAI,SAAS;IAC5B,IAAA,uBAAU,EAAC,SAAS,CAAC,aAAa,CAAC,CAAC;AAN3B,QAAA,gCAAgC,oCAML;AAExC;;;;;;;GAOG;AACI,MAAM,6BAA6B,GAAG,CAAC,aAA4B,EAAW,EAAE,CACnF,OAAO,IAAA,wDAAgC,EAAC,aAAa,CAAC,WAAW,CAAC,KAAK,QAAQ,CAAC;AADvE,QAAA,6BAA6B,iCAC0C;AAEpF;;;;;;;;GAQG;AACH,SAAgB,kCAAkC,CAC9C,aAA4B;IAE5B,MAAM,iBAAiB,GAAG,IAAA,4CAAoB,EAAC,aAAa,CAAC,WAAW,CAAC,CAAC;IAE1E,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACrB,MAAM,IAAI,yEAAiC,CAAC,aAAa,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAChF,CAAC;IAED,IAAI,CAAC,IAAA,wCAAgC,EAAC,aAAa,CAAC,EAAE,CAAC;QACnD,MAAM,IAAI,4FAA0C,CAAC,aAAa,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IACzF,CAAC;IAED,IAAI,CAAC,IAAA,qCAA6B,EAAC,aAAa,CAAC,EAAE,CAAC;QAChD,MAAM,IAAI,sFAAuC,CAAC,aAAa,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IACtF,CAAC;AACL,CAAC"}

package/src/lib/domain-event-registrations.d.ts

@@ -1,4 +1,4 @@
-import { Class } from "type-fest";
+import { Class } from "./utils/type-utils";
 type Registration = {
     eventClass: unknown;
     eventName: string;

package/src/lib/domain-event-registrations.js.map

@@ -1 +1 @@
-{"version":3,"file":"domain-event-registrations.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/domain-event-registrations.ts"],"names":[],"mappings":";;AAgBA,sCAGC;AAMD,oCAGC;AAED,oCAEC;AAED,sCAMC;AAxCD,2CAAmC;AAGnC,8FAAwF;AAOxF,MAAM,aAAa,GAAwB,EAAE,CAAC;AAE9C;;;GAGG;AACH,SAAgB,aAAa,CAAI,IAAY;IACzC,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,YAAY,CAAC,SAAS,KAAK,IAAI,CAAC,CAAC;IACpF,OAAO,IAAA,kBAAK,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAE,KAAK,CAAC,UAAuB,CAAC;AACrE,CAAC;AAED;;;GAGG;AACH,SAAgB,YAAY,CAAC,MAAc;IACvC,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,YAAY,CAAC,UAAU,KAAK,MAAM,CAAC,WAAW,CAAC,CAAC;IACnG,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;AAC/C,CAAC;AAED,SAAgB,YAAY,CAAC,KAAa;IACtC,OAAO,CAAC,IAAA,kBAAK,EAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;AACvC,CAAC;AAED,SAAgB,aAAa,CAAC,eAA6B;IACvD,IAAI,aAAa,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,YAAY,CAAC,SAAS,KAAK,eAAe,CAAC,SAAS,CAAC,EAAE,CAAC;QAC7F,MAAM,IAAI,0DAA0B,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;IACpE,CAAC;IAED,aAAa,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;AACxC,CAAC"}
+{"version":3,"file":"domain-event-registrations.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/domain-event-registrations.ts"],"names":[],"mappings":";;AAgBA,sCAGC;AAMD,oCAGC;AAED,oCAEC;AAED,sCAMC;AAxCD,2CAAmC;AAEnC,8FAAwF;AAQxF,MAAM,aAAa,GAAwB,EAAE,CAAC;AAE9C;;;GAGG;AACH,SAAgB,aAAa,CAAI,IAAY;IACzC,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,YAAY,CAAC,SAAS,KAAK,IAAI,CAAC,CAAC;IACpF,OAAO,IAAA,kBAAK,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAE,KAAK,CAAC,UAAuB,CAAC;AACrE,CAAC;AAED;;;GAGG;AACH,SAAgB,YAAY,CAAC,MAAc;IACvC,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,YAAY,CAAC,UAAU,KAAK,MAAM,CAAC,WAAW,CAAC,CAAC;IACnG,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;AAC/C,CAAC;AAED,SAAgB,YAAY,CAAC,KAAa;IACtC,OAAO,CAAC,IAAA,kBAAK,EAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;AACvC,CAAC;AAED,SAAgB,aAAa,CAAC,eAA6B;IACvD,IAAI,aAAa,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,YAAY,CAAC,SAAS,KAAK,eAAe,CAAC,SAAS,CAAC,EAAE,CAAC;QAC7F,MAAM,IAAI,0DAA0B,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;IACpE,CAAC;IAED,aAAa,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;AACxC,CAAC"}

package/src/lib/domain-event-subscription.d.ts

@@ -1,5 +1,5 @@
-import { Class } from "type-fest";
 import { OnDomainEvent } from "./on-domain-event";
+import { Class } from "./utils/type-utils";
 type SubscriptionConfiguration = {
     /**
      * The event classes that the subscription listens to.

package/src/lib/domain-event-subscription.js.map

@@ -1 +1 @@
-{"version":3,"file":"domain-event-subscription.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/domain-event-subscription.ts"],"names":[],"mappings":";;AAqBA,0DA2BC;AAGD,gCAEC;AAED,oFAGC;AAED,4DAGC;AAED,8DAGC;AApED,2CAAwD;AACxD,6CAAyC;AAGzC,mDAAkF;AAiBlF,SAAgB,uBAAuB,CACnC,kBAA8D,EAC9D,GAAG,YAA8B;IAEjC,MAAM,kBAAkB,GAAG,IAAA,0BAAa,EAAC,kBAAkB,CAAC;QACxD,CAAC,CAAE,kBAAgD,CAAC,YAAY;QAChE,CAAC,CAAC,CAAC,kBAAkB,EAAE,GAAG,YAAY,CAAC,CAAC;IAE5C,IAAI,OAAO,GAAG,IAAI,CAAC;IACnB,IAAI,IAAA,0BAAa,EAAC,kBAAkB,CAAC,EAAE,CAAC;QACpC,OAAO,GAAI,kBAAgD,CAAC,OAAO,IAAI,IAAI,CAAC;IAChF,CAAC;IAED,MAAM,kBAAkB,GAAG,IAAA,iBAAI,EAAC,kBAAkB,CAAC,CAAC;IACpD,OAAO,CAAC,MAAc,EAAE,EAAE;QACtB,KAAK,MAAM,KAAK,IAAI,kBAAkB,EAAE,CAAC;YACrC,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,gCAAgB,EAAE,KAAK,CAAC,EAAE,CAAC;gBACnD,OAAO,CAAC,cAAc,CAClB,gCAAgB,EAChB,EAAE,mBAAmB,EAAE,GAAG,KAAK,CAAC,IAAI,IAAI,IAAA,wBAAU,GAAE,EAAE,EAAE,EACxD,KAAK,CACR,CAAC;YACN,CAAC;QACL,CAAC;QAED,OAAO,CAAC,cAAc,CAAC,6CAA6B,EAAE,EAAE,MAAM,EAAE,kBAAkB,EAAE,OAAO,EAAE,EAAE,MAAM,CAAC,CAAC;IAC3G,CAAC,CAAC;AACN,CAAC;AAED,sEAAsE;AACtE,SAAgB,UAAU,CAAC,gBAA0B;IACjD,OAAO,OAAO,CAAC,WAAW,CAAC,gCAAgB,EAAE,gBAAgB,CAAC,EAAE,mBAAmB,CAAC;AACxF,CAAC;AAED,SAAgB,oCAAoC,CAAC,oBAA4C;IAC7F,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC,6CAA6B,EAAE,oBAAoB,CAAC,WAAW,CAAC,CAAC;IACtG,OAAO,IAAA,kBAAK,EAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC;AAClD,CAAC;AAED,SAAgB,wBAAwB,CAAC,oBAA4C;IACjF,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC,6CAA6B,EAAE,oBAAoB,CAAC,WAAW,CAAC,CAAC;IACtG,OAAO,IAAA,kBAAK,EAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC;AACrD,CAAC;AAED,SAAgB,yBAAyB,CAAC,cAAsB;IAC5D,MAAM,WAAW,GAAG,OAAO,CAAC,cAAc,CAAC,6CAA6B,EAAE,cAAc,CAAC,WAAW,CAAC,CAAC;IACtG,OAAO,WAAW,IAAI,OAAQ,cAAyC,CAAC,aAAa,KAAK,UAAU,CAAC;AACzG,CAAC"}
+{"version":3,"file":"domain-event-subscription.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/domain-event-subscription.ts"],"names":[],"mappings":";;AAqBA,0DA2BC;AAGD,gCAEC;AAED,oFAGC;AAED,4DAGC;AAED,8DAGC;AApED,2CAAwD;AACxD,6CAAyC;AAEzC,mDAAkF;AAkBlF,SAAgB,uBAAuB,CACnC,kBAA8D,EAC9D,GAAG,YAA8B;IAEjC,MAAM,kBAAkB,GAAG,IAAA,0BAAa,EAAC,kBAAkB,CAAC;QACxD,CAAC,CAAE,kBAAgD,CAAC,YAAY;QAChE,CAAC,CAAC,CAAC,kBAAkB,EAAE,GAAG,YAAY,CAAC,CAAC;IAE5C,IAAI,OAAO,GAAG,IAAI,CAAC;IACnB,IAAI,IAAA,0BAAa,EAAC,kBAAkB,CAAC,EAAE,CAAC;QACpC,OAAO,GAAI,kBAAgD,CAAC,OAAO,IAAI,IAAI,CAAC;IAChF,CAAC;IAED,MAAM,kBAAkB,GAAG,IAAA,iBAAI,EAAC,kBAAkB,CAAC,CAAC;IACpD,OAAO,CAAC,MAAc,EAAE,EAAE;QACtB,KAAK,MAAM,KAAK,IAAI,kBAAkB,EAAE,CAAC;YACrC,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,gCAAgB,EAAE,KAAK,CAAC,EAAE,CAAC;gBACnD,OAAO,CAAC,cAAc,CAClB,gCAAgB,EAChB,EAAE,mBAAmB,EAAE,GAAG,KAAK,CAAC,IAAI,IAAI,IAAA,wBAAU,GAAE,EAAE,EAAE,EACxD,KAAK,CACR,CAAC;YACN,CAAC;QACL,CAAC;QAED,OAAO,CAAC,cAAc,CAAC,6CAA6B,EAAE,EAAE,MAAM,EAAE,kBAAkB,EAAE,OAAO,EAAE,EAAE,MAAM,CAAC,CAAC;IAC3G,CAAC,CAAC;AACN,CAAC;AAED,sEAAsE;AACtE,SAAgB,UAAU,CAAC,gBAA0B;IACjD,OAAO,OAAO,CAAC,WAAW,CAAC,gCAAgB,EAAE,gBAAgB,CAAC,EAAE,mBAAmB,CAAC;AACxF,CAAC;AAED,SAAgB,oCAAoC,CAAC,oBAA4C;IAC7F,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC,6CAA6B,EAAE,oBAAoB,CAAC,WAAW,CAAC,CAAC;IACtG,OAAO,IAAA,kBAAK,EAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC;AAClD,CAAC;AAED,SAAgB,wBAAwB,CAAC,oBAA4C;IACjF,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC,6CAA6B,EAAE,oBAAoB,CAAC,WAAW,CAAC,CAAC;IACtG,OAAO,IAAA,kBAAK,EAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC;AACrD,CAAC;AAED,SAAgB,yBAAyB,CAAC,cAAsB;IAC5D,MAAM,WAAW,GAAG,OAAO,CAAC,cAAc,CAAC,6CAA6B,EAAE,cAAc,CAAC,WAAW,CAAC,CAAC;IACtG,OAAO,WAAW,IAAI,OAAQ,cAAyC,CAAC,aAAa,KAAK,UAAU,CAAC;AACzG,CAAC"}

package/src/lib/exceptions/aggregate-class-not-snapshot-aware-exception.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Exception thrown whenever AggregateRoot doesn't have snapshotRevision value attached, but it's needed either for snapshot creation or restoration.
+ */
+export declare class AggregateClassNotSnapshotAwareException extends Error {
+    constructor(aggregateRootName?: string);
+}

package/src/lib/exceptions/aggregate-class-not-snapshot-aware-exception.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateClassNotSnapshotAwareException = void 0;
+/**
+ * Exception thrown whenever AggregateRoot doesn't have snapshotRevision value attached, but it's needed either for snapshot creation or restoration.
+ */
+class AggregateClassNotSnapshotAwareException extends Error {
+    constructor(aggregateRootName) {
+        super(`Missing snapshot revision for aggregate root: ${aggregateRootName}\n. Did you forget to add snapshotRevision in AggregateRootConfig?`);
+    }
+}
+exports.AggregateClassNotSnapshotAwareException = AggregateClassNotSnapshotAwareException;
+//# sourceMappingURL=aggregate-class-not-snapshot-aware-exception.js.map

package/src/lib/exceptions/aggregate-class-not-snapshot-aware-exception.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate-class-not-snapshot-aware-exception.js","sourceRoot":"","sources":["../../../../../../libs/core/src/lib/exceptions/aggregate-class-not-snapshot-aware-exception.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACH,MAAa,uCAAwC,SAAQ,KAAK;IAC9D,YAAY,iBAA0B;QAClC,KAAK,CACD,iDAAiD,iBAAiB,oEAAoE,CACzI,CAAC;IACN,CAAC;CACJ;AAND,0FAMC"}

package/src/lib/exceptions/aggregate-instance-not-snapshot-aware-exception.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Exception thrown whenever Strategy matches to create a snapshot for a specified AggregateRoot, but AggregateRoot doesn't implement the SnapshotAware interface correctly
+ */
+export declare class AggregateInstanceNotSnapshotAwareException extends Error {
+    constructor(aggregateRootName?: string);
+}

package/src/lib/exceptions/aggregate-instance-not-snapshot-aware-exception.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateInstanceNotSnapshotAwareException = void 0;
+/**
+ * Exception thrown whenever Strategy matches to create a snapshot for a specified AggregateRoot, but AggregateRoot doesn't implement the SnapshotAware interface correctly
+ */
+class AggregateInstanceNotSnapshotAwareException extends Error {
+    constructor(aggregateRootName) {
+        super(`The snasphot should be created, but ${aggregateRootName} doesn't implement SnapshotAware interface correctly\n. Did you forget to implement .toSnapshot() or .applySnapshot()?`);
+    }
+}
+exports.AggregateInstanceNotSnapshotAwareException = AggregateInstanceNotSnapshotAwareException;
+//# sourceMappingURL=aggregate-instance-not-snapshot-aware-exception.js.map

package/src/lib/exceptions/aggregate-instance-not-snapshot-aware-exception.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate-instance-not-snapshot-aware-exception.js","sourceRoot":"","sources":["../../../../../../libs/core/src/lib/exceptions/aggregate-instance-not-snapshot-aware-exception.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACH,MAAa,0CAA2C,SAAQ,KAAK;IACjE,YAAY,iBAA0B;QAClC,KAAK,CACD,uCAAuC,iBAAiB,wHAAwH,CACnL,CAAC;IACN,CAAC;CACJ;AAND,gGAMC"}

package/src/lib/exceptions/snapshot-revision-mismatch-exception.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Exception thrown whenever there's a mismatch between a snapshot record revision and a revision on an aggregate root class.
+ */
+export declare class SnapshotRevisionMismatchException extends Error {
+    constructor(aggregateRootName: string);
+}

package/src/lib/exceptions/snapshot-revision-mismatch-exception.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnapshotRevisionMismatchException = void 0;
+/**
+ * Exception thrown whenever there's a mismatch between a snapshot record revision and a revision on an aggregate root class.
+ */
+class SnapshotRevisionMismatchException extends Error {
+    constructor(aggregateRootName) {
+        super(`The snapshotRevision on ${aggregateRootName} doesn't match the latest stored snapshot.
+             Please, check that the snapshotRevision defined in AggregateRootConfig is correclty configured.`);
+    }
+}
+exports.SnapshotRevisionMismatchException = SnapshotRevisionMismatchException;
+//# sourceMappingURL=snapshot-revision-mismatch-exception.js.map

package/src/lib/exceptions/snapshot-revision-mismatch-exception.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-revision-mismatch-exception.js","sourceRoot":"","sources":["../../../../../../libs/core/src/lib/exceptions/snapshot-revision-mismatch-exception.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACH,MAAa,iCAAkC,SAAQ,KAAK;IACxD,YAAY,iBAAyB;QACjC,KAAK,CACD,2BAA2B,iBAAiB;6GACqD,CACpG,CAAC;IACN,CAAC;CACJ;AAPD,8EAOC"}

package/src/lib/metadata-keys.d.ts

@@ -2,3 +2,4 @@ export declare const APPLY_EVENT_DECORATOR_KEY = "event-nest-process-event-meta"
 export declare const DOMAIN_EVENT_SUBSCRIPTION_KEY = "event-nest-domain-event-subscription-meta";
 export declare const DOMAIN_EVENT_KEY = "event-nest-domain-event-meta";
 export declare const AGGREGATE_ROOT_NAME_KEY = "event-nest-aggregate-root-name-meta";
+export declare const AGGREGATE_ROOT_SNAPSHOT_REVISION_KEY = "event-nest-aggregate-root-config-key";

package/src/lib/metadata-keys.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AGGREGATE_ROOT_NAME_KEY = exports.DOMAIN_EVENT_KEY = exports.DOMAIN_EVENT_SUBSCRIPTION_KEY = exports.APPLY_EVENT_DECORATOR_KEY = void 0;
+exports.AGGREGATE_ROOT_SNAPSHOT_REVISION_KEY = exports.AGGREGATE_ROOT_NAME_KEY = exports.DOMAIN_EVENT_KEY = exports.DOMAIN_EVENT_SUBSCRIPTION_KEY = exports.APPLY_EVENT_DECORATOR_KEY = void 0;
 exports.APPLY_EVENT_DECORATOR_KEY = "event-nest-process-event-meta";
 exports.DOMAIN_EVENT_SUBSCRIPTION_KEY = "event-nest-domain-event-subscription-meta";
 exports.DOMAIN_EVENT_KEY = "event-nest-domain-event-meta";
 exports.AGGREGATE_ROOT_NAME_KEY = "event-nest-aggregate-root-name-meta";
+exports.AGGREGATE_ROOT_SNAPSHOT_REVISION_KEY = "event-nest-aggregate-root-config-key";
 //# sourceMappingURL=metadata-keys.js.map

package/src/lib/metadata-keys.js.map

@@ -1 +1 @@
-{"version":3,"file":"metadata-keys.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/metadata-keys.ts"],"names":[],"mappings":";;;AAAa,QAAA,yBAAyB,GAAG,+BAA+B,CAAC;AAC5D,QAAA,6BAA6B,GAAG,2CAA2C,CAAC;AAC5E,QAAA,gBAAgB,GAAG,8BAA8B,CAAC;AAClD,QAAA,uBAAuB,GAAG,qCAAqC,CAAC"}
+{"version":3,"file":"metadata-keys.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/metadata-keys.ts"],"names":[],"mappings":";;;AAAa,QAAA,yBAAyB,GAAG,+BAA+B,CAAC;AAC5D,QAAA,6BAA6B,GAAG,2CAA2C,CAAC;AAC5E,QAAA,gBAAgB,GAAG,8BAA8B,CAAC;AAClD,QAAA,uBAAuB,GAAG,qCAAqC,CAAC;AAChE,QAAA,oCAAoC,GAAG,sCAAsC,CAAC"}

package/src/lib/snapshot-strategy/all-of-snapshot-strategy.d.ts

@@ -0,0 +1,29 @@
+import { AggregateRoot } from "../aggregate-root/aggregate-root";
+import { SnapshotStrategy } from "./snapshot-strategy";
+/**
+ * A composite snapshot strategy that creates a snapshot only when ALL underlying strategies
+ * return true. This implements an AND logic - all conditions must be satisfied.
+ *
+ * This strategy is useful when you need to combine multiple conditions. For example, you might
+ * want to create snapshots only for specific aggregate types AND only after a certain number
+ * of events have been processed.
+ *
+ * @example
+ * ```typescript
+ * new AllOfSnapshotStrategy([
+ *     new ForAggregateRootsStrategy({ aggregates: [User] }),
+ *     new ForCountSnapshotStrategy({ count: 10 })
+ * ])
+ * ```
+ *
+ * In this example, a snapshot will be created only if:
+ * - The aggregate root is of type User, AND
+ * - At least 10 events have been processed since the last snapshot
+ *
+ * If any of the underlying strategies returns false, no snapshot will be created.
+ */
+export declare class AllOfSnapshotStrategy extends SnapshotStrategy {
+    private readonly strategies;
+    constructor(strategies: SnapshotStrategy[]);
+    shouldCreateSnapshot(aggregateRoot: AggregateRoot): boolean;
+}

package/src/lib/snapshot-strategy/all-of-snapshot-strategy.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AllOfSnapshotStrategy = void 0;
+const snapshot_strategy_1 = require("./snapshot-strategy");
+/**
+ * A composite snapshot strategy that creates a snapshot only when ALL underlying strategies
+ * return true. This implements an AND logic - all conditions must be satisfied.
+ *
+ * This strategy is useful when you need to combine multiple conditions. For example, you might
+ * want to create snapshots only for specific aggregate types AND only after a certain number
+ * of events have been processed.
+ *
+ * @example
+ * ```typescript
+ * new AllOfSnapshotStrategy([
+ *     new ForAggregateRootsStrategy({ aggregates: [User] }),
+ *     new ForCountSnapshotStrategy({ count: 10 })
+ * ])
+ * ```
+ *
+ * In this example, a snapshot will be created only if:
+ * - The aggregate root is of type User, AND
+ * - At least 10 events have been processed since the last snapshot
+ *
+ * If any of the underlying strategies returns false, no snapshot will be created.
+ */
+class AllOfSnapshotStrategy extends snapshot_strategy_1.SnapshotStrategy {
+    constructor(strategies) {
+        super();
+        this.strategies = strategies;
+        if (strategies.length === 0) {
+            throw new Error("AllOfSnapshotStrategy requires at least one strategy");
+        }
+    }
+    shouldCreateSnapshot(aggregateRoot) {
+        return this.strategies.every((strategy) => strategy.shouldCreateSnapshot(aggregateRoot));
+    }
+}
+exports.AllOfSnapshotStrategy = AllOfSnapshotStrategy;
+//# sourceMappingURL=all-of-snapshot-strategy.js.map

package/src/lib/snapshot-strategy/all-of-snapshot-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"all-of-snapshot-strategy.js","sourceRoot":"","sources":["../../../../../../libs/core/src/lib/snapshot-strategy/all-of-snapshot-strategy.ts"],"names":[],"mappings":";;;AACA,2DAAuD;AAEvD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAa,qBAAsB,SAAQ,oCAAgB;IACvD,YAA6B,UAA8B;QACvD,KAAK,EAAE,CAAC;QADiB,eAAU,GAAV,UAAU,CAAoB;QAEvD,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;QAC5E,CAAC;IACL,CAAC;IAED,oBAAoB,CAAC,aAA4B;QAC7C,OAAO,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,oBAAoB,CAAC,aAAa,CAAC,CAAC,CAAC;IAC7F,CAAC;CACJ;AAXD,sDAWC"}

package/src/lib/snapshot-strategy/any-of-snapshot-strategy.d.ts

@@ -0,0 +1,30 @@
+import { AggregateRoot } from "../aggregate-root/aggregate-root";
+import { SnapshotStrategy } from "./snapshot-strategy";
+/**
+ * A composite snapshot strategy that creates a snapshot when at least ONE underlying strategy
+ * returns true. This implements an OR logic - any condition can be satisfied.
+ *
+ * This strategy is useful when you want to create snapshots under multiple different conditions.
+ * For example, you might want to create snapshots either when a specific event occurs OR when
+ * certain aggregate types reach a certain event count.
+ *
+ * @example
+ * ```typescript
+ * new AnyOfSnapshotStrategy([
+ *     new AllOfSnapshotStrategy([
+ *         new ForAggregateRootsStrategy({ aggregates: [User] }),
+ *         new ForCountSnapshotStrategy({ count: 10 })
+ *     ]),
+ *     new ForEventsSnapshotStrategy({ eventClasses: [UserIdentityChangedEvent] })
+ * ])
+ * ```
+ *
+ * In this example, a snapshot will be created if any of the following conditions are met:
+ * - The aggregate root is of type User AND at least 10 events have been processed since the last snapshot, OR
+ * - A UserIdentityChangedEvent event is present
+ */
+export declare class AnyOfSnapshotStrategy extends SnapshotStrategy {
+    private readonly strategies;
+    constructor(strategies: SnapshotStrategy[]);
+    shouldCreateSnapshot(aggregateRoot: AggregateRoot): boolean;
+}

package/src/lib/snapshot-strategy/any-of-snapshot-strategy.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnyOfSnapshotStrategy = void 0;
+const snapshot_strategy_1 = require("./snapshot-strategy");
+/**
+ * A composite snapshot strategy that creates a snapshot when at least ONE underlying strategy
+ * returns true. This implements an OR logic - any condition can be satisfied.
+ *
+ * This strategy is useful when you want to create snapshots under multiple different conditions.
+ * For example, you might want to create snapshots either when a specific event occurs OR when
+ * certain aggregate types reach a certain event count.
+ *
+ * @example
+ * ```typescript
+ * new AnyOfSnapshotStrategy([
+ *     new AllOfSnapshotStrategy([
+ *         new ForAggregateRootsStrategy({ aggregates: [User] }),
+ *         new ForCountSnapshotStrategy({ count: 10 })
+ *     ]),
+ *     new ForEventsSnapshotStrategy({ eventClasses: [UserIdentityChangedEvent] })
+ * ])
+ * ```
+ *
+ * In this example, a snapshot will be created if any of the following conditions are met:
+ * - The aggregate root is of type User AND at least 10 events have been processed since the last snapshot, OR
+ * - A UserIdentityChangedEvent event is present
+ */
+class AnyOfSnapshotStrategy extends snapshot_strategy_1.SnapshotStrategy {
+    constructor(strategies) {
+        super();
+        this.strategies = strategies;
+        if (strategies.length === 0) {
+            throw new Error("AnyOfSnapshotStrategy requires at least one strategy");
+        }
+    }
+    shouldCreateSnapshot(aggregateRoot) {
+        return this.strategies.some((strategy) => strategy.shouldCreateSnapshot(aggregateRoot));
+    }
+}
+exports.AnyOfSnapshotStrategy = AnyOfSnapshotStrategy;
+//# sourceMappingURL=any-of-snapshot-strategy.js.map

package/src/lib/snapshot-strategy/any-of-snapshot-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"any-of-snapshot-strategy.js","sourceRoot":"","sources":["../../../../../../libs/core/src/lib/snapshot-strategy/any-of-snapshot-strategy.ts"],"names":[],"mappings":";;;AACA,2DAAuD;AAEvD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAa,qBAAsB,SAAQ,oCAAgB;IACvD,YAA6B,UAA8B;QACvD,KAAK,EAAE,CAAC;QADiB,eAAU,GAAV,UAAU,CAAoB;QAEvD,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;QAC5E,CAAC;IACL,CAAC;IAED,oBAAoB,CAAC,aAA4B;QAC7C,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,oBAAoB,CAAC,aAAa,CAAC,CAAC,CAAC;IAC5F,CAAC;CACJ;AAXD,sDAWC"}

package/src/lib/snapshot-strategy/for-aggregate-roots-strategy.d.ts

@@ -0,0 +1,30 @@
+import { AggregateRoot } from "../aggregate-root/aggregate-root";
+import { AggregateRootClass } from "../storage/event-store";
+import { SnapshotStrategy } from "./snapshot-strategy";
+export interface ForAggregateRootsStrategyConfig {
+    aggregates: AggregateRootClass<unknown>[];
+}
+/**
+ * A snapshot strategy that creates snapshots only for a specific list of aggregate root types.
+ * This strategy is useful when you want to enable snapshotting for certain aggregates while
+ * excluding others.
+ * It is meant to be used alongside with the {@link AllOfSnapshotStrategy} to filter out snapshot creation for specific aggregate root types.
+ *
+ * @example
+ * ```typescript
+ * // Create snapshots only for User aggregates
+ * new ForAggregateRootsStrategy({ aggregates: [User] })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Create snapshots for multiple aggregate types
+ * new ForAggregateRootsStrategy({ aggregates: [User, Order, Product] })
+ * ```
+ */
+export declare class ForAggregateRootsStrategy extends SnapshotStrategy {
+    private aggregateRootNames;
+    private logger;
+    constructor(config: ForAggregateRootsStrategyConfig);
+    shouldCreateSnapshot(aggregateRoot: AggregateRoot): boolean;
+}

package/src/lib/snapshot-strategy/for-aggregate-roots-strategy.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForAggregateRootsStrategy = void 0;
+const common_1 = require("@nestjs/common");
+const es_toolkit_1 = require("es-toolkit");
+const aggregate_root_config_1 = require("../aggregate-root/aggregate-root-config");
+const snapshot_strategy_1 = require("./snapshot-strategy");
+/**
+ * A snapshot strategy that creates snapshots only for a specific list of aggregate root types.
+ * This strategy is useful when you want to enable snapshotting for certain aggregates while
+ * excluding others.
+ * It is meant to be used alongside with the {@link AllOfSnapshotStrategy} to filter out snapshot creation for specific aggregate root types.
+ *
+ * @example
+ * ```typescript
+ * // Create snapshots only for User aggregates
+ * new ForAggregateRootsStrategy({ aggregates: [User] })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Create snapshots for multiple aggregate types
+ * new ForAggregateRootsStrategy({ aggregates: [User, Order, Product] })
+ * ```
+ */
+class ForAggregateRootsStrategy extends snapshot_strategy_1.SnapshotStrategy {
+    constructor(config) {
+        super();
+        this.logger = new common_1.Logger(ForAggregateRootsStrategy.name);
+        this.aggregateRootNames = config.aggregates
+            .map((aggregateRootClass) => {
+            const aggregateRootName = (0, aggregate_root_config_1.getAggregateRootName)(aggregateRootClass);
+            if ((0, es_toolkit_1.isNil)(aggregateRootName)) {
+                this.logger.error(`Missing aggregate root name for class: ${aggregateRootClass.name}. Use the @AggregateRootName decorator.`);
+                return;
+            }
+            return aggregateRootName;
+        })
+            .filter((name) => typeof name === "string");
+    }
+    shouldCreateSnapshot(aggregateRoot) {
+        const aggregateRootName = (0, aggregate_root_config_1.getAggregateRootName)(aggregateRoot.constructor);
+        if (!aggregateRootName) {
+            this.logger.error(`Missing aggregate root name for class: ${aggregateRoot.constructor}. Use the @AggregateRootName decorator.`);
+            return false;
+        }
+        return this.aggregateRootNames.includes(aggregateRootName);
+    }
+}
+exports.ForAggregateRootsStrategy = ForAggregateRootsStrategy;
+//# sourceMappingURL=for-aggregate-roots-strategy.js.map

package/src/lib/snapshot-strategy/for-aggregate-roots-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"for-aggregate-roots-strategy.js","sourceRoot":"","sources":["../../../../../../libs/core/src/lib/snapshot-strategy/for-aggregate-roots-strategy.ts"],"names":[],"mappings":";;;AAAA,2CAAwC;AACxC,2CAAmC;AAGnC,mFAA+E;AAE/E,2DAAuD;AAMvD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAa,yBAA0B,SAAQ,oCAAgB;IAI3D,YAAY,MAAuC;QAC/C,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,MAAM,GAAG,IAAI,eAAM,CAAC,yBAAyB,CAAC,IAAI,CAAC,CAAC;QACzD,IAAI,CAAC,kBAAkB,GAAG,MAAM,CAAC,UAAU;aACtC,GAAG,CAAC,CAAC,kBAAkB,EAAE,EAAE;YACxB,MAAM,iBAAiB,GAAG,IAAA,4CAAoB,EAAC,kBAAkB,CAAC,CAAC;YACnE,IAAI,IAAA,kBAAK,EAAC,iBAAiB,CAAC,EAAE,CAAC;gBAC3B,IAAI,CAAC,MAAM,CAAC,KAAK,CACb,0CAA0C,kBAAkB,CAAC,IAAI,yCAAyC,CAC7G,CAAC;gBAEF,OAAO;YACX,CAAC;YAED,OAAO,iBAAiB,CAAC;QAC7B,CAAC,CAAC;aACD,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC;IACpD,CAAC;IAEQ,oBAAoB,CAAC,aAA4B;QACtD,MAAM,iBAAiB,GAAG,IAAA,4CAAoB,EAAC,aAAa,CAAC,WAAW,CAAC,CAAC;QAC1E,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACrB,IAAI,CAAC,MAAM,CAAC,KAAK,CACb,0CAA0C,aAAa,CAAC,WAAW,yCAAyC,CAC/G,CAAC;YAEF,OAAO,KAAK,CAAC;QACjB,CAAC;QAED,OAAO,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAC;IAC/D,CAAC;CACJ;AAnCD,8DAmCC"}

package/src/lib/snapshot-strategy/for-count-snapshot-strategy.d.ts

@@ -0,0 +1,28 @@
+import { AggregateRoot } from "../aggregate-root/aggregate-root";
+import { SnapshotStrategy } from "./snapshot-strategy";
+export interface ForCountSnapshotStrategyConfig {
+    count: number;
+}
+/**
+ * A snapshot strategy that creates snapshots based on the number of events processed.
+ * A snapshot will be created when the aggregate root has processed at least the specified
+ * number of events since the last snapshot.
+ *
+ * If you append more than `count` events in a single batch (before calling commit), only one
+ * snapshot will be created for the entire batch, not multiple snapshots. This ensures that
+ * even if you append many events at once, you get a single snapshot representing the state
+ * after all those events are applied.
+ *
+ * @example
+ * ```typescript
+ * // Create a snapshot after at least 10 events
+ * new ForCountSnapshotStrategy({ count: 10 })
+ * ```
+ *
+ * @throws {Error} If count is less than 1
+ */
+export declare class ForCountSnapshotStrategy extends SnapshotStrategy {
+    private readonly config;
+    constructor(config: ForCountSnapshotStrategyConfig);
+    shouldCreateSnapshot(aggregateRoot: AggregateRoot): boolean;
+}

package/src/lib/snapshot-strategy/for-count-snapshot-strategy.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForCountSnapshotStrategy = void 0;
+const snapshot_strategy_1 = require("./snapshot-strategy");
+/**
+ * A snapshot strategy that creates snapshots based on the number of events processed.
+ * A snapshot will be created when the aggregate root has processed at least the specified
+ * number of events since the last snapshot.
+ *
+ * If you append more than `count` events in a single batch (before calling commit), only one
+ * snapshot will be created for the entire batch, not multiple snapshots. This ensures that
+ * even if you append many events at once, you get a single snapshot representing the state
+ * after all those events are applied.
+ *
+ * @example
+ * ```typescript
+ * // Create a snapshot after at least 10 events
+ * new ForCountSnapshotStrategy({ count: 10 })
+ * ```
+ *
+ * @throws {Error} If count is less than 1
+ */
+class ForCountSnapshotStrategy extends snapshot_strategy_1.SnapshotStrategy {
+    constructor(config) {
+        super();
+        this.config = config;
+        if (config.count < 1) {
+            throw new Error("PerCountSnapshotStrategy: config.count may not be less than 1");
+        }
+    }
+    shouldCreateSnapshot(aggregateRoot) {
+        const currentVersion = aggregateRoot.version;
+        const newEventsCount = aggregateRoot.uncommittedEvents.length;
+        const projectedVersion = currentVersion + newEventsCount;
+        const currentBlock = Math.floor(currentVersion / this.config.count);
+        const projectedBlock = Math.floor(projectedVersion / this.config.count);
+        return projectedBlock - currentBlock > 0;
+    }
+}
+exports.ForCountSnapshotStrategy = ForCountSnapshotStrategy;
+//# sourceMappingURL=for-count-snapshot-strategy.js.map

package/src/lib/snapshot-strategy/for-count-snapshot-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"for-count-snapshot-strategy.js","sourceRoot":"","sources":["../../../../../../libs/core/src/lib/snapshot-strategy/for-count-snapshot-strategy.ts"],"names":[],"mappings":";;;AACA,2DAAuD;AAMvD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAa,wBAAyB,SAAQ,oCAAgB;IAC1D,YAA6B,MAAsC;QAC/D,KAAK,EAAE,CAAC;QADiB,WAAM,GAAN,MAAM,CAAgC;QAE/D,IAAI,MAAM,CAAC,KAAK,GAAG,CAAC,EAAE,CAAC;YACnB,MAAM,IAAI,KAAK,CAAC,+DAA+D,CAAC,CAAC;QACrF,CAAC;IACL,CAAC;IAED,oBAAoB,CAAC,aAA4B;QAC7C,MAAM,cAAc,GAAG,aAAa,CAAC,OAAO,CAAC;QAC7C,MAAM,cAAc,GAAG,aAAa,CAAC,iBAAiB,CAAC,MAAM,CAAC;QAC9D,MAAM,gBAAgB,GAAG,cAAc,GAAG,cAAc,CAAC;QAEzD,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACpE,MAAM,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,gBAAgB,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAExE,OAAO,cAAc,GAAG,YAAY,GAAG,CAAC,CAAC;IAC7C,CAAC;CACJ;AAlBD,4DAkBC"}

package/src/lib/snapshot-strategy/for-events-snapshot-strategy.d.ts

@@ -0,0 +1,33 @@
+import { AggregateRoot } from "../aggregate-root/aggregate-root";
+import { Class } from "../utils/type-utils";
+import { SnapshotStrategy } from "./snapshot-strategy";
+export interface ForEventsSnapshotStrategyConfig {
+    eventClasses: Class<unknown>[];
+}
+/**
+ * A snapshot strategy that creates snapshots when specific event types are present in the
+ * aggregate root's uncommitted events.
+ *
+ * This is useful when you want to create snapshots for specific important events, such as
+ * events that significantly change the aggregate's state or events that are expensive to
+ * replay.
+ *
+ * @example
+ * ```typescript
+ * // Create a snapshot whenever a UserIdentityChangedEvent is present
+ * new ForEventsSnapshotStrategy({ eventClasses: [UserIdentityChangedEvent] })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Create a snapshot for multiple event types
+ * new ForEventsSnapshotStrategy({
+ *     eventClasses: [UserIdentityChangedEvent, UserOrderUpdatedEvent]
+ * })
+ * ```
+ */
+export declare class ForEventsSnapshotStrategy extends SnapshotStrategy {
+    private readonly config;
+    constructor(config: ForEventsSnapshotStrategyConfig);
+    shouldCreateSnapshot(aggregateRoot: AggregateRoot): boolean;
+}

package/src/lib/snapshot-strategy/for-events-snapshot-strategy.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForEventsSnapshotStrategy = void 0;
+const snapshot_strategy_1 = require("./snapshot-strategy");
+/**
+ * A snapshot strategy that creates snapshots when specific event types are present in the
+ * aggregate root's uncommitted events.
+ *
+ * This is useful when you want to create snapshots for specific important events, such as
+ * events that significantly change the aggregate's state or events that are expensive to
+ * replay.
+ *
+ * @example
+ * ```typescript
+ * // Create a snapshot whenever a UserIdentityChangedEvent is present
+ * new ForEventsSnapshotStrategy({ eventClasses: [UserIdentityChangedEvent] })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Create a snapshot for multiple event types
+ * new ForEventsSnapshotStrategy({
+ *     eventClasses: [UserIdentityChangedEvent, UserOrderUpdatedEvent]
+ * })
+ * ```
+ */
+class ForEventsSnapshotStrategy extends snapshot_strategy_1.SnapshotStrategy {
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    shouldCreateSnapshot(aggregateRoot) {
+        return aggregateRoot.uncommittedEvents.some((event_) => this.config.eventClasses.some((class_) => event_.payload instanceof class_));
+    }
+}
+exports.ForEventsSnapshotStrategy = ForEventsSnapshotStrategy;
+//# sourceMappingURL=for-events-snapshot-strategy.js.map