ddd-node 35.0.0 → 36.0.0

package/core/decorators/{es-aggregate/when.js → when.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.When = void 0;
-const meta_1 = require("../../meta");
+const meta_1 = require("../meta");
 const When = (eventClass) => {
     return (target, propertyKey, descriptor) => {
         if (typeof descriptor.value === "function") {

package/core/meta/enum.d.ts

@@ -3,5 +3,5 @@ export type EnumProperty<T extends Object = Object> = Extract<keyof T, string>;
 export declare class EnumPropertySet<T extends Object = Object> extends Set<EnumProperty<T>> {
 }
 export declare const markEnumProperty: <T extends Object>(target: T, key: EnumProperty<T>) => void;
-export declare const getOwnEnumPropertySet: <T extends Object>(target: T) => EnumPropertySet<T>;
-export declare const getEnumPropertySet: <T extends Object>(target: T) => EnumPropertySet<T>;
+export declare const resolveOwnEnumPropertySet: <T extends Object>(target: T) => EnumPropertySet<T>;
+export declare const resolveEnumPropertySet: <T extends Object>(target: T) => EnumPropertySet<T>;

package/core/meta/enum.js

@@ -1,28 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEnumPropertySet = exports.getOwnEnumPropertySet = exports.markEnumProperty = exports.EnumPropertySet = void 0;
+exports.resolveEnumPropertySet = exports.resolveOwnEnumPropertySet = exports.markEnumProperty = exports.EnumPropertySet = void 0;
 require("reflect-metadata");
-const ENUM_PROP_SET = Symbol.for("ENUM_PROP_SET");
+const ENUM_PROP_SET = Symbol("ENUM_PROP_SET");
 class EnumPropertySet extends Set {
 }
 exports.EnumPropertySet = EnumPropertySet;
 const markEnumProperty = (target, key) => {
-    const enumSet = (0, exports.getOwnEnumPropertySet)(target);
+    const enumSet = (0, exports.resolveOwnEnumPropertySet)(target);
     enumSet.add(key);
 };
 exports.markEnumProperty = markEnumProperty;
-const getOwnEnumPropertySet = (target) => {
+const resolveOwnEnumPropertySet = (target) => {
     if (!Reflect.getOwnMetadata(ENUM_PROP_SET, target)) {
         Reflect.defineMetadata(ENUM_PROP_SET, new EnumPropertySet(), target);
     }
     return Reflect.getOwnMetadata(ENUM_PROP_SET, target);
 };
-exports.getOwnEnumPropertySet = getOwnEnumPropertySet;
-const getEnumPropertySet = (target) => {
+exports.resolveOwnEnumPropertySet = resolveOwnEnumPropertySet;
+const resolveEnumPropertySet = (target) => {
     let _target = target;
     const result = new EnumPropertySet();
     do {
-        const ownMarkedEnumValues = (0, exports.getOwnEnumPropertySet)(_target);
+        const ownMarkedEnumValues = (0, exports.resolveOwnEnumPropertySet)(_target);
         ownMarkedEnumValues.forEach((markedEnumValue) => {
             result.add(markedEnumValue);
         });
@@ -30,4 +30,4 @@ const getEnumPropertySet = (target) => {
     } while (_target !== null);
     return result;
 };
-exports.getEnumPropertySet = getEnumPropertySet;
+exports.resolveEnumPropertySet = resolveEnumPropertySet;

package/core/meta/{es-aggregate/event-applier.d.ts → event-applier.d.ts}

@@ -1,7 +1,7 @@
 import "reflect-metadata";
-import { AnyEvent, EventApplier } from "../../model";
+import { AnyEvent, EventApplier } from "../model";
 export declare class EventApplierMap extends Map<string, EventApplier> {
 }
-export declare const getOwnEventApplierMap: (target: object) => EventApplierMap;
+export declare const resolveOwnEventApplierMap: (target: object) => EventApplierMap;
 export declare const defineOwnEventApplier: <T extends AnyEvent>(target: object, eventType: string, applier: EventApplier<T>) => void;
-export declare const getEventApplierMap: (target: object) => EventApplierMap;
+export declare const resolveEventApplierMap: (target: object) => EventApplierMap;

package/core/meta/{es-aggregate/event-applier.js → event-applier.js}

@@ -1,31 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEventApplierMap = exports.defineOwnEventApplier = exports.getOwnEventApplierMap = exports.EventApplierMap = void 0;
+exports.resolveEventApplierMap = exports.defineOwnEventApplier = exports.resolveOwnEventApplierMap = exports.EventApplierMap = void 0;
 require("reflect-metadata");
-const OWN_EVENT_APPLIER_MAP = Symbol.for("OWN_EVENT_APPLIER_MAP");
-const EVENT_APPLIER_MAP = Symbol.for("EVENT_HANDLER_MAP");
+const OWN_EVENT_APPLIER_MAP = Symbol("OWN_EVENT_APPLIER_MAP");
+const EVENT_APPLIER_MAP = Symbol("EVENT_HANDLER_MAP");
 class EventApplierMap extends Map {
 }
 exports.EventApplierMap = EventApplierMap;
-const getOwnEventApplierMap = (target) => {
+const resolveOwnEventApplierMap = (target) => {
     if (!Reflect.hasOwnMetadata(OWN_EVENT_APPLIER_MAP, target))
         Reflect.defineMetadata(OWN_EVENT_APPLIER_MAP, new EventApplierMap(), target);
     return Reflect.getMetadata(OWN_EVENT_APPLIER_MAP, target);
 };
-exports.getOwnEventApplierMap = getOwnEventApplierMap;
+exports.resolveOwnEventApplierMap = resolveOwnEventApplierMap;
 const defineOwnEventApplier = (target, eventType, applier) => {
-    const eventAppliersMap = (0, exports.getOwnEventApplierMap)(target);
+    const eventAppliersMap = (0, exports.resolveOwnEventApplierMap)(target);
     eventAppliersMap.set(eventType, applier);
 };
 exports.defineOwnEventApplier = defineOwnEventApplier;
-const getEventApplierMap = (target) => {
+const resolveEventApplierMap = (target) => {
     if (!Reflect.hasOwnMetadata(EVENT_APPLIER_MAP, target)) {
         const buildEventApplierMap = (target) => {
             let _target = target;
             const result = new EventApplierMap();
             const ownEventApplierMaps = [];
             do {
-                const ownEventApplierMap = (0, exports.getOwnEventApplierMap)(_target);
+                const ownEventApplierMap = (0, exports.resolveOwnEventApplierMap)(_target);
                 ownEventApplierMaps.unshift(ownEventApplierMap);
                 _target = Reflect.getPrototypeOf(_target);
             } while (_target !== null);
@@ -40,4 +40,4 @@ const getEventApplierMap = (target) => {
     }
     return Reflect.getOwnMetadata(EVENT_APPLIER_MAP, target);
 };
-exports.getEventApplierMap = getEventApplierMap;
+exports.resolveEventApplierMap = resolveEventApplierMap;

package/core/meta/event.d.ts

@@ -5,4 +5,4 @@ export declare class $EventType extends String {
     constructor(eventType: EventType);
 }
 export declare const defineEventType: (target: object, eventType: EventType) => void;
-export declare const getEventType: (target: object) => EventType;
+export declare const resolveEventType: (target: object) => EventType;

package/core/meta/event.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEventType = exports.defineEventType = exports.$EventType = void 0;
+exports.resolveEventType = exports.defineEventType = exports.$EventType = void 0;
 require("reflect-metadata");
-const EVENT_TYPE = Symbol.for("EVENT_TYPE");
+const EVENT_TYPE = Symbol("EVENT_TYPE");
 class $EventType extends String {
     static validate(eventType) {
         if (eventType.trim().length === 0)
@@ -18,10 +18,10 @@ const defineEventType = (target, eventType) => {
     Reflect.defineMetadata(EVENT_TYPE, new $EventType(eventType), target);
 };
 exports.defineEventType = defineEventType;
-const getEventType = (target) => {
+const resolveEventType = (target) => {
     const eventType = Reflect.getOwnMetadata(EVENT_TYPE, target);
     if (!eventType)
         throw new Error("Event's type is not defined");
     return eventType.valueOf();
 };
-exports.getEventType = getEventType;
+exports.resolveEventType = resolveEventType;

package/core/meta/index.d.ts

@@ -1,4 +1,3 @@
-export * from "./es-aggregate";
 export * from "./event";
-export * from "./command";
 export * from "./enum";
+export * from "./event-applier";

package/core/meta/index.js

@@ -14,7 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./es-aggregate"), exports);
 __exportStar(require("./event"), exports);
-__exportStar(require("./command"), exports);
 __exportStar(require("./enum"), exports);
+__exportStar(require("./event-applier"), exports);

package/core/model/aggregate/aggregate.d.ts

@@ -1,13 +1,8 @@
 import { Id, IdentifiedModel } from "../identified-model";
-import { AnyEvent, EventClassWithTypedConstructor, EventSource, NewEventOptions } from "../message";
-import { InferredProps, Props } from "./../../../base";
-import { IEventReleaser } from "./event-releaser";
+import { Props } from "./../../../base";
 export declare abstract class Aggregate<P extends Props> extends IdentifiedModel<P> {
-    protected readonly _version: number;
-    constructor(id: Id, version: number, props?: P);
+    readonly initialVersion: number;
+    constructor(id: Id, initialVersion: number, props?: P);
     abstract get version(): number;
-    protected asEventSource(): EventSource;
-    protected newEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: InferredProps<E>, options?: NewEventOptions): E;
-    abstract releaseEvents<R = any>(eventReleaser: IEventReleaser<R>): R;
 }
 export type AnyAggregate = Aggregate<Props>;

package/core/model/aggregate/aggregate.js

@@ -13,21 +13,12 @@ exports.Aggregate = void 0;
 const identified_model_1 = require("../identified-model");
 const base_1 = require("./../../../base");
 let Aggregate = class Aggregate extends identified_model_1.IdentifiedModel {
-    constructor(id, version, props) {
+    constructor(id, initialVersion, props) {
         super(id);
-        this._version = version;
+        this.initialVersion = initialVersion;
         if (props)
             this.initializeProps(props);
     }
-    asEventSource() {
-        return {
-            aggregateId: this.id,
-            aggregateVersion: this.version,
-        };
-    }
-    newEvent(eventClass, props, options) {
-        return eventClass.new(this.asEventSource(), props, options);
-    }
 };
 exports.Aggregate = Aggregate;
 exports.Aggregate = Aggregate = __decorate([

package/core/model/aggregate/es-aggregate.d.ts

@@ -1,54 +1,43 @@
-import { Id } from "src";
 import { Class } from "type-fest";
 import { InferredProps, Props } from "../../../base";
 import { ClassStatic } from "../../../types";
-import { AnyCommand, AnyEvent, EventClassWithTypedConstructor, NewEventOptions } from "../message";
+import { AnyEvent, EventClassWithTypedConstructor } from "../event";
 import { Aggregate } from "./aggregate";
-import { IEventReleaser } from "./event-releaser";
+import { Id } from "../identified-model";
 export declare class ESAggregate<P extends Props> extends Aggregate<P> {
-    static fromStream<T extends AnyESAggregate>(this: ESAggregateClassWithTypedConstructor<T>, id: Id, allPastEvents: AnyEvent[]): T;
+    static fromStream<T extends AnyESAggregate>(this: ESAggregateClassWithTypedConstructor<T>, id: Id, pastEvents: AnyEvent[]): T;
     static newStream<T extends AnyESAggregate>(this: ESAggregateClassWithTypedConstructor<T>, id?: Id): T;
     static fromSnapshot<T extends AnyESAggregate>(this: ESAggregateClassWithTypedConstructor<T>, snapshot: Snapshot<T>, pastEvents?: AnyEvent[]): T;
-    static ownEventApplierMap<T extends AnyESAggregate>(this: ESAggregateClass<T>): import("src").EventApplierMap;
-    static eventApplierMap<T extends AnyESAggregate>(this: ESAggregateClass<T>): import("src").EventApplierMap;
-    static ownCommandHandlerMap<T extends AnyESAggregate>(this: ESAggregateClass<T>): import("src").CommandHandlerMap;
-    static commandHandlerMap<T extends AnyESAggregate>(this: ESAggregateClass<T>): import("src").CommandHandlerMap;
-    private _handledCommands;
+    static ownEventAppliers<T extends AnyESAggregate>(this: ESAggregateClass<T>): import("../../meta").EventApplierMap;
+    static eventAppliers<T extends AnyESAggregate>(this: ESAggregateClass<T>): import("../../meta").EventApplierMap;
     private _pastEvents;
     private _events;
-    constructor(id: Id, version: number, props?: P);
-    _constructor(): ESAggregateClass<typeof this>;
+    typedConstructor(): ESAggregateClass<typeof this>;
     get version(): number;
     pastEvents(): AnyEvent[];
     events(): AnyEvent[];
-    handledCommands(): AnyCommand[];
     hasNewEvent(): boolean;
-    getEventApplier<E extends AnyEvent>(event: E): EventApplier<E>;
+    resolveEventApplier<E extends AnyEvent>(event: E): EventApplier<E>;
     private validateEventBeforeApply;
-    private _applyEvent;
-    private applyPastEvent;
-    applyPastEvents(pastEvents: AnyEvent[]): void;
-    applyEvent<E extends AnyEvent>(event: E): void;
-    applyEvents(events: AnyEvent[]): void;
-    applyNewEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: InferredProps<E>, options?: NewEventOptions): E;
-    getCommandHandler<C extends AnyCommand>(command: C): CommandHandler<C>;
-    handleCommand<C extends AnyCommand>(command: C): AnyEvent[];
+    private applyEvent;
+    replayPastEvent<E extends AnyEvent>(event: E): void;
+    replayPastEvents(pastEvents: AnyEvent[]): void;
+    recordEvent<E extends AnyEvent>(event: E): void;
+    recordEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: InferredProps<E>): void;
+    recordEvents(events: AnyEvent[]): void;
     takeSnapshot(): Snapshot<typeof this>;
     protected commitEvents(): void;
-    releaseEvents<R = any>(releaser: IEventReleaser<R>): R;
+    releaseEvents(): AnyEvent[];
 }
 export type AnyESAggregate = ESAggregate<Props>;
-export interface ESAggregateClass<T extends AnyESAggregate = AnyESAggregate, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof ESAggregate<InferredProps<T>>> {
-}
-export interface ESAggregateClassWithTypedConstructor<T extends AnyESAggregate = AnyESAggregate> extends ESAggregateClass<T, ConstructorParameters<typeof ESAggregate<InferredProps<T>>>> {
-}
+export type ESAggregateClass<T extends AnyESAggregate = AnyESAggregate, Arguments extends unknown[] = any[]> = Class<T, Arguments> & ClassStatic<typeof ESAggregate<InferredProps<T>>>;
+export type ESAggregateClassWithTypedConstructor<T extends AnyESAggregate = AnyESAggregate> = ESAggregateClass<T, ConstructorParameters<typeof ESAggregate<InferredProps<T>>>>;
 export type EventApplier<T extends AnyEvent = AnyEvent> = (event: T) => void;
-export type CommandHandler<T extends AnyCommand = AnyCommand, U extends AnyEvent | AnyEvent[] = AnyEvent | AnyEvent[]> = (command: T) => U;
-export interface SnapshotMetadata {
+export type SnapshotMetadata = {
     id: Id;
     version: number;
-}
-export interface Snapshot<T extends AnyESAggregate> {
+};
+export type Snapshot<T extends AnyESAggregate> = {
     metadata: SnapshotMetadata;
     props: InferredProps<T>;
-}
+};

package/core/model/aggregate/es-aggregate.js

@@ -2,13 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ESAggregate = void 0;
 const uuid_1 = require("uuid");
-const utils_1 = require("../../../utils");
 const meta_1 = require("../../meta");
 const aggregate_1 = require("./aggregate");
 class ESAggregate extends aggregate_1.Aggregate {
-    static fromStream(id, allPastEvents) {
+    constructor() {
+        super(...arguments);
+        this._pastEvents = [];
+        this._events = [];
+    }
+    static fromStream(id, pastEvents) {
         const instance = new this(id, 0);
-        instance.applyPastEvents(allPastEvents);
+        instance.replayPastEvents(pastEvents);
         return instance;
     }
     static newStream(id) {
@@ -17,32 +21,20 @@ class ESAggregate extends aggregate_1.Aggregate {
     static fromSnapshot(snapshot, pastEvents = []) {
         const { metadata: { id, version }, props, } = snapshot;
         const instance = new this(id, version, props);
-        instance.applyPastEvents(pastEvents);
+        instance.replayPastEvents(pastEvents);
         return instance;
     }
-    static ownEventApplierMap() {
-        return (0, meta_1.getOwnEventApplierMap)(this.prototype);
-    }
-    static eventApplierMap() {
-        return (0, meta_1.getEventApplierMap)(this.prototype);
-    }
-    static ownCommandHandlerMap() {
-        return (0, meta_1.getOwnCommandHandlerMap)(this.prototype);
+    static ownEventAppliers() {
+        return (0, meta_1.resolveOwnEventApplierMap)(this.prototype);
     }
-    static commandHandlerMap() {
-        return (0, meta_1.getCommandHandlerMap)(this.prototype);
+    static eventAppliers() {
+        return (0, meta_1.resolveEventApplierMap)(this.prototype);
     }
-    constructor(id, version, props) {
-        super(id, version, props);
-        this._handledCommands = [];
-        this._events = [];
-        this._pastEvents = [];
-    }
-    _constructor() {
+    typedConstructor() {
         return this.constructor;
     }
     get version() {
-        return this._version + this._pastEvents.length + this._events.length;
+        return this.initialVersion + this._pastEvents.length + this._events.length;
     }
     pastEvents() {
         return Array.from(this._pastEvents);
@@ -50,76 +42,52 @@ class ESAggregate extends aggregate_1.Aggregate {
     events() {
         return Array.from(this._events);
     }
-    handledCommands() {
-        return Array.from(this._handledCommands);
-    }
     hasNewEvent() {
         return Boolean(this._events.length);
     }
-    getEventApplier(event) {
-        const eventType = event.eventType();
-        const eventApplierMap = this._constructor().eventApplierMap();
-        const applier = eventApplierMap.get(eventType);
+    resolveEventApplier(event) {
+        const eventType = event.eventType;
+        const eventAppliers = this.typedConstructor().eventAppliers();
+        const applier = eventAppliers.get(eventType);
         if (!applier)
             throw new Error("Event applier not found");
         return applier;
     }
     validateEventBeforeApply(event) {
-        const { aggregateId, aggregateVersion } = event.source();
+        const { aggregateId, streamPosition } = event;
         if (aggregateId !== this.id)
             throw new Error("Invalid aggregate id");
-        if (aggregateVersion !== this.version)
-            throw new Error("Invalid aggregate version");
+        if (streamPosition !== this.version + 1)
+            throw new Error("Invalid stream position");
     }
-    _applyEvent(event) {
-        const applier = this.getEventApplier(event);
+    applyEvent(event) {
+        const applier = this.resolveEventApplier(event);
         this.validateEventBeforeApply(event);
         applier.call(this, event);
     }
-    applyPastEvent(event) {
+    replayPastEvent(event) {
         if (this.hasNewEvent())
             throw new Error("Cannot apply a past event when new event is recorded");
-        this._applyEvent(event);
+        this.applyEvent(event);
         this._pastEvents.push(event);
     }
-    applyPastEvents(pastEvents) {
+    replayPastEvents(pastEvents) {
         pastEvents.forEach((pastEvent) => {
-            this.applyPastEvent(pastEvent);
+            this.replayPastEvent(pastEvent);
         });
     }
-    applyEvent(event) {
-        this._applyEvent(event);
+    recordEvent(eventOrClass, props) {
+        const event = typeof eventOrClass === "function"
+            ? eventOrClass.new(this.id, this.version + 1, props)
+            : eventOrClass;
+        this.applyEvent(event);
         this._events.push(event);
     }
-    applyEvents(events) {
+    recordEvents(events) {
         events.forEach((event) => {
-            this.applyEvent(event);
+            this.recordEvent(event);
         });
     }
-    applyNewEvent(eventClass, props, options) {
-        const event = this.newEvent(eventClass, props, options);
-        this.applyEvent(event);
-        return event;
-    }
-    getCommandHandler(command) {
-        const commandType = command.commandType();
-        const commandHandlerMap = this._constructor().commandHandlerMap();
-        const handler = commandHandlerMap.get(commandType);
-        if (!handler)
-            throw new Error("Command handler not found");
-        return handler;
-    }
-    handleCommand(command) {
-        const handler = this.getCommandHandler(command);
-        const events = (0, utils_1.toArray)(handler.call(this, command));
-        events.forEach((event) => {
-            event.setCausationId(command.id);
-            event.setCorrelationIds(command.correlationIds);
-        });
-        this.applyEvents(events);
-        this._handledCommands.push(command);
-        return events;
-    }
     takeSnapshot() {
         if (!this.isPropsInitialized())
             throw new Error("Cannot create snapshot when the props is not initialized");
@@ -135,10 +103,10 @@ class ESAggregate extends aggregate_1.Aggregate {
         this._pastEvents.push(...this.events());
         this._events = [];
     }
-    releaseEvents(releaser) {
+    releaseEvents() {
         const events = this.events();
         this.commitEvents();
-        return releaser.release(events);
+        return events;
     }
 }
 exports.ESAggregate = ESAggregate;

package/core/model/aggregate/index.d.ts

@@ -1,5 +1,4 @@
 export * from "./aggregate";
 export * from "./state-aggregate";
 export * from "./es-aggregate";
-export * from "./event-releaser";
 export * from "./types";

package/core/model/aggregate/index.js

@@ -17,5 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./aggregate"), exports);
 __exportStar(require("./state-aggregate"), exports);
 __exportStar(require("./es-aggregate"), exports);
-__exportStar(require("./event-releaser"), exports);
 __exportStar(require("./types"), exports);

package/core/model/aggregate/state-aggregate.d.ts

@@ -1,25 +1,19 @@
 import { Class } from "type-fest";
 import { InferredProps, Props } from "../../../base";
 import { ClassStatic } from "../../../types";
+import { AnyEvent, EventClass } from "../event";
 import { Id } from "../identified-model";
-import { AnyEvent, EventClassWithTypedConstructor, NewEventOptions } from "../message";
 import { Aggregate } from "./aggregate";
-import { IEventReleaser } from "./event-releaser";
 export declare class StateAggregate<P extends Props> extends Aggregate<P> {
     static new<T extends AnyStateAggregate>(this: StateAggregateClassWithTypedConstructor<T>, props: InferredProps<T>, id?: Id): T;
     private _events;
-    constructor(id: Id, version: number, props: P);
-    _constructor(): StateAggregateClass<typeof this>;
+    typedConstructor(): StateAggregateClass<typeof this>;
     props(): P;
     get version(): number;
     events(): AnyEvent[];
-    protected recordEvent<E extends AnyEvent>(event: E): void;
-    protected recordEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: InferredProps<E>, options?: NewEventOptions): void;
-    clearEvents(): void;
-    releaseEvents<R = any>(eventReleaser: IEventReleaser<R>): R;
+    protected recordEvent<E extends AnyEvent>(eventClass: EventClass<E>, props: InferredProps<E>): void;
+    clearEvents(): AnyEvent[];
 }
 export type AnyStateAggregate = StateAggregate<Props>;
-export interface StateAggregateClass<T extends AnyStateAggregate = AnyStateAggregate, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof StateAggregate<InferredProps<T>>> {
-}
-export interface StateAggregateClassWithTypedConstructor<T extends AnyStateAggregate = AnyStateAggregate> extends StateAggregateClass<T, ConstructorParameters<typeof StateAggregate<InferredProps<T>>>> {
-}
+export type StateAggregateClass<T extends AnyStateAggregate = AnyStateAggregate, Arguments extends unknown[] = any[]> = Class<T, Arguments> & ClassStatic<typeof StateAggregate<InferredProps<T>>>;
+export type StateAggregateClassWithTypedConstructor<T extends AnyStateAggregate = AnyStateAggregate> = StateAggregateClass<T, ConstructorParameters<typeof StateAggregate<InferredProps<T>>>>;

package/core/model/aggregate/state-aggregate.js

@@ -4,42 +4,33 @@ exports.StateAggregate = void 0;
 const uuid_1 = require("uuid");
 const aggregate_1 = require("./aggregate");
 class StateAggregate extends aggregate_1.Aggregate {
+    constructor() {
+        super(...arguments);
+        this._events = [];
+    }
     static new(props, id) {
         return new this(id ?? (0, uuid_1.v4)(), 0, props);
     }
-    constructor(id, version, props) {
-        super(id, version, props);
-        this._events = [];
-    }
-    _constructor() {
+    typedConstructor() {
         return this.constructor;
     }
     props() {
         return super.props();
     }
     get version() {
-        return this._version;
+        return this.initialVersion + this._events.length;
     }
     events() {
         return Array.from(this._events);
     }
-    recordEvent(p1, p2, p3) {
-        let event;
-        if (typeof p1 === "function" && p2) {
-            event = this.newEvent(p1, p2, p3);
-        }
-        else {
-            event = p1;
-        }
-        this._events.push(event);
+    recordEvent(eventClass, props) {
+        const newEvent = eventClass.new(this.id, this.version + 1, props);
+        this._events.push(newEvent);
     }
     clearEvents() {
-        this._events = [];
-    }
-    releaseEvents(eventReleaser) {
         const events = this.events();
-        this.clearEvents();
-        return eventReleaser.release(events);
+        this._events = [];
+        return events;
     }
 }
 exports.StateAggregate = StateAggregate;

package/core/model/entity/entity.d.ts

@@ -5,12 +5,9 @@ import { Id, IdentifiedModel } from "../identified-model";
 export declare class Entity<P extends Props> extends IdentifiedModel<P> {
     static new<T extends AnyEntity>(this: EntityClassWithTypedConstructor<T>, props: InferredProps<T>, id?: Id): T;
     constructor(id: Id, props: P);
-    _constructor(): EntityClass<typeof this>;
+    typedConstructor(): EntityClass<typeof this>;
 }
 export type AnyEntity = Entity<Props>;
-export interface EntityClass<T extends AnyEntity = AnyEntity, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof Entity<InferredProps<T>>> {
-}
-export interface EntityClassWithTypedConstructor<T extends AnyEntity = AnyEntity> extends EntityClass<T, ConstructorParameters<typeof Entity<InferredProps<T>>>> {
-}
-export interface EntityClassWithProps<P extends Props> extends EntityClass<Entity<P>> {
-}
+export type EntityClass<T extends AnyEntity = AnyEntity, Arguments extends unknown[] = any[]> = Class<T, Arguments> & ClassStatic<typeof Entity<InferredProps<T>>>;
+export type EntityClassWithTypedConstructor<T extends AnyEntity = AnyEntity> = EntityClass<T, ConstructorParameters<typeof Entity<InferredProps<T>>>>;
+export type EntityClassWithProps<P extends Props> = EntityClass<Entity<P>>;

package/core/model/entity/entity.js

@@ -21,7 +21,7 @@ let Entity = class Entity extends identified_model_1.IdentifiedModel {
         super(id);
         this.initializeProps(props);
     }
-    _constructor() {
+    typedConstructor() {
         return this.constructor;
     }
 };

package/core/model/enum/enum.d.ts

@@ -6,7 +6,7 @@ export interface EnumProps {
     value: EnumValue;
 }
 export declare class Enum extends DomainModel<EnumProps> {
-    static enumPropertySet<T extends AnyEnum>(this: EnumClass<T>): import("../../meta").EnumPropertySet<EnumClass<T, any[]>>;
+    static enumProperties<T extends AnyEnum>(this: EnumClass<T>): import("../../meta").EnumPropertySet<EnumClass<T, any[]>>;
     static values(): Enum[];
     static from<T extends AnyEnum>(this: EnumClass<T>, value: EnumValue): T;
     constructor(value: EnumValue);
@@ -14,7 +14,5 @@ export declare class Enum extends DomainModel<EnumProps> {
     valueOf(): EnumValue;
 }
 export type AnyEnum = Enum;
-export interface EnumClass<T extends AnyEnum = AnyEnum, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof Enum> {
-}
-export interface EnumClassWithTypedConstructor<T extends AnyEnum = AnyEnum> extends EnumClass<T, ConstructorParameters<typeof Enum>> {
-}
+export type EnumClass<T extends AnyEnum = AnyEnum, Arguments extends unknown[] = any[]> = Class<T, Arguments> & ClassStatic<typeof Enum>;
+export type EnumClassWithTypedConstructor<T extends AnyEnum = AnyEnum> = EnumClass<T, ConstructorParameters<typeof Enum>>;

package/core/model/enum/enum.js

@@ -13,17 +13,17 @@ exports.Enum = void 0;
 const base_1 = require("../../../base");
 const meta_1 = require("../../meta");
 let Enum = class Enum extends base_1.DomainModel {
-    static enumPropertySet() {
-        return (0, meta_1.getEnumPropertySet)(this);
+    static enumProperties() {
+        return (0, meta_1.resolveEnumPropertySet)(this);
     }
     static values() {
-        return Array.from(this.modelDescriptor().ownModelStaticValues.values()).map((staticValue) => staticValue.value);
+        return Array.from(this.modelDescriptor().ownStaticEntries.values()).map((staticEntry) => staticEntry.value);
     }
     static from(value) {
         if (!value)
             throw new Error("Cannot parse enum without value");
         let result;
-        this.enumPropertySet().forEach((enumProperty) => {
+        this.enumProperties().forEach((enumProperty) => {
             const enumValue = this?.[enumProperty];
             if (!enumValue)
                 return;