@event-nest/core 0.0.1 → 0.0.3

package/README.md

@@ -1,11 +1,239 @@
-# core
+# Event Nest
+A collection of [nest.js](https://nestjs.com/) libraries to help you build applications based on event sourcing architecture.
 
-This library was generated with [Nx](https://nx.dev).
+## Description
+Event Nest is a collection of libraries based on nest.js that assists in implementing the core concepts of event sourcing:
+* Saving events in a persistent storage
+* Utilizing the saved events to trigger side effects, such as updating your read model
+* Replaying events to reconstruct the state of your application
 
-## Building
+Given that event sourcing is commonly used in conjunction with [CQRS](https://martinfowler.com/bliki/CQRS.html) and [Domain Driven Design](https://en.wikipedia.org/wiki/Domain-driven_design), these libraries adopt principles from these architectural patterns.
 
-Run `nx build core` to build the library.
+It would also probably help to make some distinctions about what Event Nest is not :
+* It is not a framework, it is a set of libraries which are designed to be used with nest.js.
+* It is not an ORM, if you want an ORM to define simple models, there are far better solutions out there.
+* It is not a library for establishing event-based communication between services.
+* **Although the code is covered by tests, the library is not widely tested in production. Use it at your own risk.**
 
-## Running unit tests
+## Why?
+Implementing event sourcing in an application can be challenging, particularly when combined with CQRS and DDD.
+
+Nest.js provides a [fantastic module](https://github.com/nestjs/cqrs) for CQRS but after using it for a while I thought that maybe some things could be improved.
+Furthermore, these improvements can't be added to the official module due to its lightweight and abstract nature.
+For instance, the official module lacks a specific way of persisting the events to a storage.
+
+This is where Event Nest comes into play. In fact, a significant portion of the code in Event Nest is influenced by how things are implemented in the official module.
+
+This project evolved into a library after I used the official module with my improvements in a few projects and I thought that it could be useful to other people. To make things
+simpler, the library is not depending on the official module, so you can use it without having to worry about conflicts.
+
+## Getting Started
+Depending on the storage solution you intend to use, you will need to install the corresponding packages.
+At the moment, only MongoDB is supported, hopefully soon there will be more.
+
+```bash
+npm install --save @event-nest/core @event-nest/mongodb
+```
+After installation, import the `EventNestMongoDbModule` to your nest.js application :
+```typescript
+import { Module } from "@nestjs/common";
+import { EventNestMongoDbModule } from "@event-nest/mongodb";
+
+@Module({
+    imports: [
+        EventNestMongoDbModule.register({
+            connectionUri: "mongodb://localhost:27017/example",
+            aggregatesCollection: "aggregates-collection",
+            eventsCollection: "events-collection"
+        }),
+    ],
+})
+export class AppModule {}
+```
+The collection settings define which MongoDB collections will be used to store the aggregates and the events.
+Use any collection you want but be sure to create it before running the application.
+
+
+
+## Concepts
+### Aggregate Root
+An [aggregate root](https://stackoverflow.com/questions/1958621/whats-an-aggregate-root) is a concept from Domain Driven Design. It is a domain object that is responsible for maintaining the consistency of the aggregate.
+To achieve this, the aggregate root should expose methods which encapsulate its behaviour. Any method that needs to update the state, should also append an event to the aggregate root's event stream.
+
+### Event
+An event is a representation of something that has happened in the past. It is identified by a unique name, and it may contain additional data that will be persisted with the event.
+
+Each event can be used for three purposes :
+* It will be persisted so that it can be used to reconstruct the state of an aggregate root
+* It will be passed to any internal subscribers that need to react to this event (e.g. updating the read model)
+* When it's time to recreate the aggregate root, the event will be processed by the correct method in the aggregate root
+
+Enough with the theory, let's see an example that includes all of the above.
+
+#### Example
+
+```typescript
+import { RegisteredEvent } from "@event-nest/core";
+
+@RegisteredEvent("user-created-event")
+export class UserCreatedEvent {
+    constructor(public name: string, public email: string) {}
+}
+```
+
+```typescript
+import { RegisteredEvent } from "@event-nest/core";
+
+@RegisteredEvent("user-updated-event")
+export class UserUpdatedEvent {
+    constructor(public newName: string) {}
+}
+```
+
+We start this example by defining two simple events for a user: a creation event and an update event. Each one has its own data, and they are identified by a unique name which is set with the `@RegisteredEvent` decorator.
+
+```typescript
+import { AggregateRoot, AggregateRootName, EventProcessor, StoredEvent } from "@event-nest/core";
+
+@AggregateRootName("User")
+export class User extends AggregateRoot {
+    private _name: string;
+    private _email: string;
+
+    private constructor(id: string) {
+        super(id);
+    }
+    
+    public static createNew(id: string, name: string, email: string): User {
+        const user = new User(id);
+        const event = new UserCreatedEvent(name, email);
+        user.processUserCreatedEvent(event);
+        user.append(event);
+        return user;
+    }
+
+    public static fromEvents(id: string, events: Array<StoredEvent>): User {
+        const user = new User(id);
+        user.reconstitute(events);
+        return user;
+    }
+
+    public update(newName: string) {
+        const event = new UserUpdatedEvent(newName);
+        this.processUserUpdatedEvent(event);
+        this.append(event);
+    }
+
+    @EventProcessor(UserCreatedEvent)
+    private processUserCreatedEvent = (event: UserCreatedEvent) => {
+        this._name = event.name;
+        this._email = event.email;
+    };
+
+    @EventProcessor(UserUpdatedEvent)
+    private processUserUpdatedEvent = (event: UserUpdatedEvent) => {
+        this._name = event.newName;
+    };
+    
+}
+```
+
+Next, we define the aggregate root for the user. There's a lot going on here so let's break it down.
+
+First of all, the class has to extend the `AggregateRoot` class, and it has to be decorated with the `@AggregateRootName` decorator.
+The name is required to associate persisted events with the correct aggregate root when retrieving them from storage.
+
+Now let's talk about the constructor. TypeScript doesn't allow us to define multiple constructors. So if we have two ways of creating an object, we could use static methods as factories.
+In our case, we have the following creation cases :
+* The user is new, and we need to create it from scratch. In that case, we create a new `UserCreatedEvent` event, and we `append` it to the aggregate root's event stream.
+* The user already exists. In that case we need to recreate the aggregate root from the events that have been persisted. We do that by calling the `reconstitute` method.
+
+The `reconstitute` method will initiate the event processing based on the events order.
+
+To process each event, we have defined two private methods which are decorated with the `@EventProcessor` decorator. Each method will be called when the corresponding event is retrieved, and it's ready to be processed.
+This is the place to update the object's internal state based on the event's data. **Make sure that these methods are defined as arrow functions, otherwise they won't be called.**
+
+
+Finally, we define an `update` method which is the place to run any business logic we need and append the corresponding event (`UserUpdatedEvent`) to the event stream.
+
+It's important to note that the append method is not saving the event. All the appended events can be saved by calling the `commit` method on the aggregate root.
+
+```typescript
+import { EVENT_STORE, EventStore } from "@event-nest/core";
+
+@Injectable()
+export class UserService {
+    constructor(@Inject(EVENT_STORE) private eventStore: EventStore) {}
+
+    async createUser(name: string, email: string) {
+        const user = User.createNew(new ObjectId().toHexString(), name, email);
+        const userWithPublisher = this.eventStore.addPublisher(user);
+        await userWithPublisher.commit();
+        return user.id;
+    }
+
+    async updateUser(id: string, newName: string) {
+        const events = await this.eventStore.findByAggregateRootId(User, id);
+        const user = User.fromEvents(id, events);
+        const userWithPublisher = this.eventStore.addPublisher(user);
+        user.update(newName);
+        await userWithPublisher.commit();
+    }
+}
+```
+
+The final piece of the puzzle is a nest.js service that will manage the process.
+
+We start by injecting the `EventStore`, which will be used to retrieve persisted events.
+
+Additionally, since the aggregate root classes are not managed by the nest.js dependency injection system, we need to connect them to the event store by calling the `addPublisher` method. This will allow the
+`commit` method to work as expected.
+
+### Domain Event Subscription
+When working with event sourcing, you will likely need a way of updating other parts of your system when an event is persisted. For example, you may have a read model for users that needs to be updated when a user is created or updated.
+
+To achieve this, you can implement a service decorated with the `@DomainEventSubscription` decorator. This decorator takes a list of events that the service is interested in, and it automatically subscribes to them when the service is initialized.
+
+To ensure that the method is implemented correctly, you can use the `OnDomainEvent` interface.
+
+#### Example
+```typescript
+import { AggregateRootAwareEvent, DomainEventSubscription, OnDomainEvent } from "@event-nest/core";
+
+@Injectable()
+@DomainEventSubscription(UserCreatedEvent, UserUpdatedEvent)
+export class UserEventSubscription implements OnDomainEvent<UserCreatedEvent | UserUpdatedEvent> {
+    
+    onDomainEvent(event: AggregateRootAwareEvent<UserCreatedEvent | UserUpdatedEvent>): Promise<unknown> {
+        //Here you can create/update your read model based on the event and your custom logic.
+        return Promise.resolve(undefined);
+    }
+    
+}
+```
+
+If there are multiple subscription services for the same event, they will be executed in parallel.
+However, if there are multiple events that the service is subscribed to, they will be executed sequentially based on the order they were emitted.
+
+This is the default behaviour because there are cases where the logic may depend on the completion of the previous event. If you want better performance
+and your logic doesn't depend on the order of the events, you can change this setting when you import the module.
+
+```typescript
+@Module({
+    imports: [
+        EventNestMongoDbModule.register({
+            connectionUri: "mongodb://localhost:27017/example",
+            aggregatesCollection: "aggregates-collection",
+            eventsCollection: "events-collection",
+            runParallelSubscriptions:true
+        })
+    ]
+})
+export class AppModule {}
+```
+
+
+
+## License
+Event Nest is [MIT licensed](https://github.com/nestjs/nest/blob/master/LICENSE).
 
-Run `nx test core` to execute the unit tests via [Jest](https://jestjs.io).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@event-nest/core",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "license": "MIT",
   "author": "Nick Tsitlakidis",
   "description": "Event sourcing module for NestJS. It provides a set of decorators and interfaces to help you build your event sourcing application.",
@@ -12,13 +12,14 @@
   ],
   "type": "commonjs",
   "peerDependencies": {
-    "@nestjs/common": "^10.0.2",
-    "@nestjs/core": "^10.0.2",
+    "@nestjs/common": "^9.0.0",
+    "@nestjs/core": "^9.0.0",
+    "reflect-metadata": "0.1.13",
+    "rxjs": "^7.2.0",
     "tslib": "2.5.3"
   },
   "dependencies": {
-    "class-transformer": "^0.5.1",
-    "reflect-metadata": "^0.1.13"
+    "class-transformer": "^0.5.1"
   },
   "main": "./src/index.js",
   "types": "./src/index.d.ts"

package/src/index.d.ts

@@ -1,12 +1,17 @@
-export * from "./lib/decorators/event-name-conflict-exception";
-export * from "./lib/decorators/event-processor";
-export * from "./lib/decorators/registered-event";
-export * from "./lib/domain/aggregate-root";
-export * from "./lib/domain/missing-event-processor-exception";
-export * from "./lib/storage/abstract-event-store";
-export * from "./lib/storage/event-store";
-export * from "./lib/storage/event-payload";
-export * from "./lib/storage/id-generation-exception";
+export * from "./lib/exceptions/event-name-conflict-exception";
+export * from "./lib/exceptions/unknown-event-exception";
+export * from "./lib/exceptions/missing-aggregate-root-name-exception";
+export * from "./lib/event-processor";
+export * from "./lib/registered-event";
+export * from "./lib/domain-event-subscription";
+export * from "./lib/aggregate-root";
+export * from "./lib/aggregate-root-name";
+export * from "./lib/aggregate-root-aware-event";
+export * from "./lib/on-domain-event";
+export * from "./lib/domain-event-emitter";
+export * from "./lib/core-module-options";
 export * from "./lib/storage/stored-event";
 export * from "./lib/storage/stored-aggregate-root";
+export * from "./lib/storage/abstract-event-store";
+export * from "./lib/storage/event-store";
 export * from "./lib/utils/type-utils";

package/src/index.js

@@ -1,16 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./lib/decorators/event-name-conflict-exception"), exports);
-tslib_1.__exportStar(require("./lib/decorators/event-processor"), exports);
-tslib_1.__exportStar(require("./lib/decorators/registered-event"), exports);
-tslib_1.__exportStar(require("./lib/domain/aggregate-root"), exports);
-tslib_1.__exportStar(require("./lib/domain/missing-event-processor-exception"), exports);
-tslib_1.__exportStar(require("./lib/storage/abstract-event-store"), exports);
-tslib_1.__exportStar(require("./lib/storage/event-store"), exports);
-tslib_1.__exportStar(require("./lib/storage/event-payload"), exports);
-tslib_1.__exportStar(require("./lib/storage/id-generation-exception"), exports);
+tslib_1.__exportStar(require("./lib/exceptions/event-name-conflict-exception"), exports);
+tslib_1.__exportStar(require("./lib/exceptions/unknown-event-exception"), exports);
+tslib_1.__exportStar(require("./lib/exceptions/missing-aggregate-root-name-exception"), exports);
+tslib_1.__exportStar(require("./lib/event-processor"), exports);
+tslib_1.__exportStar(require("./lib/registered-event"), exports);
+tslib_1.__exportStar(require("./lib/domain-event-subscription"), exports);
+tslib_1.__exportStar(require("./lib/aggregate-root"), exports);
+tslib_1.__exportStar(require("./lib/aggregate-root-name"), exports);
+tslib_1.__exportStar(require("./lib/aggregate-root-aware-event"), exports);
+tslib_1.__exportStar(require("./lib/on-domain-event"), exports);
+tslib_1.__exportStar(require("./lib/domain-event-emitter"), exports);
+tslib_1.__exportStar(require("./lib/core-module-options"), exports);
 tslib_1.__exportStar(require("./lib/storage/stored-event"), exports);
 tslib_1.__exportStar(require("./lib/storage/stored-aggregate-root"), exports);
+tslib_1.__exportStar(require("./lib/storage/abstract-event-store"), exports);
+tslib_1.__exportStar(require("./lib/storage/event-store"), exports);
 tslib_1.__exportStar(require("./lib/utils/type-utils"), exports);
 //# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/core/src/index.ts"],"names":[],"mappings":";;;AAAA,yFAA+D;AAC/D,2EAAiD;AACjD,4EAAkD;AAElD,sEAA4C;AAC5C,yFAA+D;AAE/D,6EAAmD;AACnD,oEAA0C;AAC1C,sEAA4C;AAC5C,gFAAsD;AACtD,qEAA2C;AAC3C,8EAAoD;AAEpD,iEAAuC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/core/src/index.ts"],"names":[],"mappings":";;;AAAA,yFAA+D;AAC/D,mFAAyD;AACzD,iGAAuE;AAEvE,gEAAsC;AACtC,iEAAuC;AACvC,0EAAgD;AAChD,+DAAqC;AACrC,oEAA0C;AAC1C,2EAAiD;AACjD,gEAAsC;AACtC,qEAA2C;AAC3C,oEAA0C;AAE1C,qEAA2C;AAC3C,8EAAoD;AACpD,6EAAmD;AACnD,oEAA0C;AAE1C,iEAAuC"}

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

@@ -0,0 +1,4 @@
+export interface AggregateRootAwareEvent<T> {
+    aggregateRootId: string;
+    payload: T;
+}

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=aggregate-root-aware-event.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate-root-aware-event.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/aggregate-root-aware-event.ts"],"names":[],"mappings":""}

package/src/lib/aggregate-root-name.d.ts

@@ -0,0 +1,2 @@
+export declare const AggregateRootName: (name: string) => ClassDecorator;
+export declare function getAggregateRootName(targetClass: Function): string | undefined;

package/src/lib/aggregate-root-name.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAggregateRootName = exports.AggregateRootName = void 0;
+const metadata_keys_1 = require("./metadata-keys");
+const AggregateRootName = (name) => {
+    return (target) => {
+        Reflect.defineMetadata(metadata_keys_1.AGGREGATE_ROOT_NAME_KEY, { aggregateRootName: name }, target);
+    };
+};
+exports.AggregateRootName = AggregateRootName;
+// eslint-disable-next-line @typescript-eslint/ban-types
+function getAggregateRootName(targetClass) {
+    return Reflect.getMetadata(metadata_keys_1.AGGREGATE_ROOT_NAME_KEY, targetClass)?.aggregateRootName;
+}
+exports.getAggregateRootName = getAggregateRootName;
+//# sourceMappingURL=aggregate-root-name.js.map

package/src/lib/aggregate-root-name.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate-root-name.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/aggregate-root-name.ts"],"names":[],"mappings":";;;AAAA,mDAA0D;AAEnD,MAAM,iBAAiB,GAAG,CAAC,IAAY,EAAkB,EAAE;IAC9D,OAAO,CAAC,MAAc,EAAE,EAAE;QACtB,OAAO,CAAC,cAAc,CAAC,uCAAuB,EAAE,EAAE,iBAAiB,EAAE,IAAI,EAAE,EAAE,MAAM,CAAC,CAAC;IACzF,CAAC,CAAC;AACN,CAAC,CAAC;AAJW,QAAA,iBAAiB,qBAI5B;AAEF,wDAAwD;AACxD,SAAgB,oBAAoB,CAAC,WAAqB;IACtD,OAAO,OAAO,CAAC,WAAW,CAAC,uCAAuB,EAAE,WAAW,CAAC,EAAE,iBAAiB,CAAC;AACxF,CAAC;AAFD,oDAEC"}

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

@@ -0,0 +1,50 @@
+import { Logger } from "@nestjs/common";
+import { StoredEvent } from "./storage/stored-event";
+import { AggregateRootAwareEvent } from "./aggregate-root-aware-event";
+export declare abstract class AggregateRoot {
+    private readonly _id;
+    private _appendedEvents;
+    private _version;
+    private readonly _logger;
+    protected constructor(_id: string, logger?: Logger);
+    get id(): string;
+    get version(): number;
+    get logger(): Logger;
+    /**
+     * Publishes all the provided events using a connected event publisher. To connect a publisher, use the
+     * {@link EventStore}. Normally this should never be called by application logic. Instead, after you append the
+     * events, you should call the commit method which will end up calling this method.
+     *
+     * If a publisher is not connected, the method will return a rejected promise.
+     * @param events The events to be published
+     */
+    publish(events: Array<AggregateRootAwareEvent<object>>): Promise<Array<StoredEvent>>;
+    /**
+     * All the events that have been previously appended will be committed once this method runs. After publishing,
+     * the appended events will be deleted so that the next commit publishes newer events.
+     * During publishing, the events will be saved and after the successful save, all the application event
+     * handlers will be called to take care of async updates.
+     * Call this once all the events you want, have been appended.
+     */
+    commit(): Promise<AggregateRoot>;
+    /**
+     * Adds an event to the currently existing events of the entity. This will not publish the event. Use the {@link commit}
+     * method once all the events you want are appended.
+     * @param event The event to be appended
+     */
+    append(event: object): void;
+    /**
+     * Returns a clone array of all the currently appended events of the entity.
+     */
+    get appendedEvents(): Array<AggregateRootAwareEvent<object>>;
+    /**
+     * Used when a set of events have been retrieved from the database. These events can be passed to the method and the
+     * method will trigger all the matching {@link EventProcessor} functions of the entity to populate the object based on
+     * application logic.
+     * @param events The events that will be sent to EventProcessor functions
+     */
+    reconstitute(events: Array<StoredEvent>): void;
+    protected resolveVersion(events: Array<StoredEvent>): void;
+    protected sortEvents(events: Array<StoredEvent>): Array<StoredEvent>;
+    private splitEvents;
+}

package/src/lib/aggregate-root.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateRoot = void 0;
+const common_1 = require("@nestjs/common");
+const registered_event_1 = require("./registered-event");
+const event_processor_1 = require("./event-processor");
+const unknown_event_exception_1 = require("./exceptions/unknown-event-exception");
+const type_utils_1 = require("./utils/type-utils");
+const unregistered_event_exception_1 = require("./exceptions/unregistered-event-exception");
+class AggregateRoot {
+    constructor(_id, logger) {
+        this._id = _id;
+        this._appendedEvents = [];
+        this._version = 0;
+        this._logger = (0, type_utils_1.isNil)(logger) ? new common_1.Logger(AggregateRoot.name) : logger;
+    }
+    get id() {
+        return this._id;
+    }
+    get version() {
+        return this._version;
+    }
+    get logger() {
+        return this._logger;
+    }
+    /**
+     * Publishes all the provided events using a connected event publisher. To connect a publisher, use the
+     * {@link EventStore}. Normally this should never be called by application logic. Instead, after you append the
+     * events, you should call the commit method which will end up calling this method.
+     *
+     * If a publisher is not connected, the method will return a rejected promise.
+     * @param events The events to be published
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    publish(events) {
+        this.logger.error("There is no event publisher assigned");
+        return Promise.reject("There is no event publisher assigned");
+    }
+    /**
+     * All the events that have been previously appended will be committed once this method runs. After publishing,
+     * the appended events will be deleted so that the next commit publishes newer events.
+     * During publishing, the events will be saved and after the successful save, all the application event
+     * handlers will be called to take care of async updates.
+     * Call this once all the events you want, have been appended.
+     */
+    commit() {
+        const toPublish = this._appendedEvents.slice(0);
+        this._appendedEvents = [];
+        if (toPublish.length > 0) {
+            return this.publish(toPublish).then(() => Promise.resolve(this));
+        }
+        return Promise.resolve(this);
+    }
+    /**
+     * Adds an event to the currently existing events of the entity. This will not publish the event. Use the {@link commit}
+     * method once all the events you want are appended.
+     * @param event The event to be appended
+     */
+    append(event) {
+        if (!(0, registered_event_1.isRegistered)(event)) {
+            this.logger.error(`Event ${event.constructor.name} is not registered.`);
+            throw new unregistered_event_exception_1.UnregisteredEventException(event.constructor.name);
+        }
+        this._appendedEvents.push({
+            aggregateRootId: this.id,
+            payload: event
+        });
+    }
+    /**
+     * Returns a clone array of all the currently appended events of the entity.
+     */
+    get appendedEvents() {
+        return this._appendedEvents.slice(0);
+    }
+    /**
+     * Used when a set of events have been retrieved from the database. These events can be passed to the method and the
+     * method will trigger all the matching {@link EventProcessor} functions of the entity to populate the object based on
+     * application logic.
+     * @param events The events that will be sent to EventProcessor functions
+     */
+    reconstitute(events) {
+        if (events.length > 0) {
+            const [unregistered, missingProcessor, known] = this.splitEvents(this.sortEvents(events));
+            if (unregistered.length > 0 || missingProcessor.length > 0) {
+                const e = new unknown_event_exception_1.UnknownEventException(unregistered, missingProcessor, this.id);
+                this.logger.error(e.message);
+                throw e;
+            }
+            known.forEach((event) => {
+                try {
+                    this[event.processorKey](event.payload);
+                }
+                catch (error) {
+                    this.logger.error(`Unable to process domain event due to error in processor function: ${error}`);
+                    throw error;
+                }
+            });
+            this.resolveVersion(events);
+        }
+    }
+    resolveVersion(events) {
+        const sorted = events.sort((e1, e2) => e1.aggregateRootVersion - e2.aggregateRootVersion);
+        this._version = sorted.slice(-1)[0].aggregateRootVersion;
+    }
+    sortEvents(events) {
+        return events.sort((e1, e2) => e1.aggregateRootVersion - e2.aggregateRootVersion);
+    }
+    splitEvents(events) {
+        const known = [];
+        const unregistered = [];
+        const missingProcessor = [];
+        events.forEach((ev) => {
+            const eventClass = (0, registered_event_1.getEventClass)(ev.eventName);
+            if ((0, type_utils_1.isNil)(eventClass)) {
+                unregistered.push(ev.eventName);
+            }
+            else {
+                const processorKey = (0, event_processor_1.getDecoratedPropertyKey)(this, eventClass);
+                if ((0, type_utils_1.isNil)(processorKey)) {
+                    missingProcessor.push(ev.eventName);
+                }
+                else {
+                    known.push({
+                        processorKey,
+                        payload: ev.getPayloadAs(eventClass)
+                    });
+                }
+            }
+        });
+        return [unregistered, missingProcessor, known];
+    }
+}
+exports.AggregateRoot = AggregateRoot;
+//# sourceMappingURL=aggregate-root.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate-root.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/aggregate-root.ts"],"names":[],"mappings":";;;AAAA,2CAAwC;AAExC,yDAAiE;AACjE,uDAA4D;AAC5D,kFAA6E;AAC7E,mDAA2C;AAC3C,4FAAuF;AAQvF,MAAsB,aAAa;IAK/B,YAAuC,GAAW,EAAE,MAAe;QAA5B,QAAG,GAAH,GAAG,CAAQ;QAC9C,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;QAC1B,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;QAClB,IAAI,CAAC,OAAO,GAAG,IAAA,kBAAK,EAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,eAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;IAC3E,CAAC;IAED,IAAI,EAAE;QACF,OAAO,IAAI,CAAC,GAAG,CAAC;IACpB,CAAC;IAED,IAAI,OAAO;QACP,OAAO,IAAI,CAAC,QAAQ,CAAC;IACzB,CAAC;IAED,IAAI,MAAM;QACN,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IAED;;;;;;;OAOG;IACH,6DAA6D;IAC7D,OAAO,CAAC,MAA8C;QAClD,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,sCAAsC,CAAC,CAAC;QAC1D,OAAO,OAAO,CAAC,MAAM,CAAC,sCAAsC,CAAC,CAAC;IAClE,CAAC;IAED;;;;;;OAMG;IACH,MAAM;QACF,MAAM,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAChD,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;QAC1B,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE;YACtB,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;SACpE;QACD,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAa;QAChB,IAAI,CAAC,IAAA,+BAAY,EAAC,KAAK,CAAC,EAAE;YACtB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,KAAK,CAAC,WAAW,CAAC,IAAI,qBAAqB,CAAC,CAAC;YACxE,MAAM,IAAI,yDAA0B,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;SAChE;QAED,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC;YACtB,eAAe,EAAE,IAAI,CAAC,EAAE;YACxB,OAAO,EAAE,KAAK;SACjB,CAAC,CAAC;IACP,CAAC;IAED;;OAEG;IACH,IAAI,cAAc;QACd,OAAO,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACzC,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAC,MAA0B;QACnC,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;YACnB,MAAM,CAAC,YAAY,EAAE,gBAAgB,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;YAE1F,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,IAAI,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE;gBACxD,MAAM,CAAC,GAAG,IAAI,+CAAqB,CAAC,YAAY,EAAE,gBAAgB,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;gBAC7E,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;gBAC7B,MAAM,CAAC,CAAC;aACX;YAED,KAAK,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;gBACpB,IAAI;oBACC,IAAY,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;iBACpD;gBAAC,OAAO,KAAK,EAAE;oBACZ,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,sEAAsE,KAAK,EAAE,CAAC,CAAC;oBACjG,MAAM,KAAK,CAAC;iBACf;YACL,CAAC,CAAC,CAAC;YACH,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;SAC/B;IACL,CAAC;IAES,cAAc,CAAC,MAA0B;QAC/C,MAAM,MAAM,GAAuB,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,oBAAoB,GAAG,EAAE,CAAC,oBAAoB,CAAC,CAAC;QAC9G,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC;IAC7D,CAAC;IAES,UAAU,CAAC,MAA0B;QAC3C,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,oBAAoB,GAAG,EAAE,CAAC,oBAAoB,CAAC,CAAC;IACtF,CAAC;IAEO,WAAW,CAAC,MAA0B;QAC1C,MAAM,KAAK,GAAsB,EAAE,CAAC;QACpC,MAAM,YAAY,GAAkB,EAAE,CAAC;QACvC,MAAM,gBAAgB,GAAkB,EAAE,CAAC;QAE3C,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE;YAClB,MAAM,UAAU,GAAG,IAAA,gCAAa,EAAC,EAAE,CAAC,SAAS,CAAC,CAAC;YAC/C,IAAI,IAAA,kBAAK,EAAC,UAAU,CAAC,EAAE;gBACnB,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC;aACnC;iBAAM;gBACH,MAAM,YAAY,GAAG,IAAA,yCAAuB,EAAC,IAAI,EAAE,UAAU,CAAC,CAAC;gBAC/D,IAAI,IAAA,kBAAK,EAAC,YAAY,CAAC,EAAE;oBACrB,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC;iBACvC;qBAAM;oBACH,KAAK,CAAC,IAAI,CAAC;wBACP,YAAY;wBACZ,OAAO,EAAE,EAAE,CAAC,YAAY,CAAC,UAAU,CAAC;qBACvC,CAAC,CAAC;iBACN;aACJ;QACL,CAAC,CAAC,CAAC;QAEH,OAAO,CAAC,YAAY,EAAE,gBAAgB,EAAE,KAAK,CAAC,CAAC;IACnD,CAAC;CACJ;AA1ID,sCA0IC"}

package/src/lib/core-module-options.d.ts

@@ -0,0 +1,11 @@
+export interface CoreModuleOptions {
+    /**
+     * Each domain event that is saved in the store will then be passed to any classes you have registered with the
+     * {@link DomainEventSubscription} decorator.
+     * By default, the events will be processed sequentially to make sure that a subscription can count on the fact that
+     * the previous event has been processed. If you don't need this functionality, and you want faster event processing,
+     * you can set this to true.
+     *
+     */
+    runParallelSubscriptions?: boolean;
+}

package/src/lib/core-module-options.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=core-module-options.js.map

package/src/lib/core-module-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-module-options.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/core-module-options.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,13 @@
+import { Module } from "@nestjs/core/injector/module";
+import { AggregateRootAwareEvent } from "./aggregate-root-aware-event";
+import { OnModuleDestroy } from "@nestjs/common";
+export declare class DomainEventEmitter implements OnModuleDestroy {
+    private _runParallelSubscriptions;
+    private _handlers;
+    private _logger;
+    constructor(_runParallelSubscriptions?: boolean);
+    onModuleDestroy(): void;
+    bindSubscriptions(injectorModules: Map<string, Module>): void;
+    emit(withAggregate: AggregateRootAwareEvent<object>): Promise<unknown>;
+    emitMultiple(withAggregate: AggregateRootAwareEvent<object>[]): Promise<unknown>;
+}