ddd-node 34.2.0 → 35.0.0

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

@@ -2,11 +2,11 @@ import { Id } from "src";
 import { Class } from "type-fest";
 import { InferredProps, Props } from "../../../base";
 import { ClassStatic } from "../../../types";
-import { AnyCommand, AnyEvent, EventClassWithTypedConstructor } from "../message";
-import { Aggregate, AggregateMetadata } from "./aggregate";
-import { IAggregateEventPublisher } from "./types";
+import { AnyCommand, AnyEvent, EventClassWithTypedConstructor, NewEventOptions } from "../message";
+import { Aggregate } from "./aggregate";
+import { IEventReleaser } from "./event-releaser";
 export declare class ESAggregate<P extends Props> extends Aggregate<P> {
-    static fromStream<T extends AnyESAggregate>(this: ESAggregateClassWithTypedConstructor<T>, pastEvents: AnyEvent[], id?: Id): T;
+    static fromStream<T extends AnyESAggregate>(this: ESAggregateClassWithTypedConstructor<T>, id: Id, allPastEvents: 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;
@@ -16,9 +16,9 @@ export declare class ESAggregate<P extends Props> extends Aggregate<P> {
     private _handledCommands;
     private _pastEvents;
     private _events;
-    constructor(metadata: AggregateMetadata, props?: P);
+    constructor(id: Id, version: number, props?: P);
     _constructor(): ESAggregateClass<typeof this>;
-    version(): number;
+    get version(): number;
     pastEvents(): AnyEvent[];
     events(): AnyEvent[];
     handledCommands(): AnyCommand[];
@@ -30,12 +30,12 @@ export declare class ESAggregate<P extends Props> extends Aggregate<P> {
     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>): 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[];
     takeSnapshot(): Snapshot<typeof this>;
     protected commitEvents(): void;
-    publishEvents<R = any>(publisher: IAggregateEventPublisher<R>): R;
+    releaseEvents<R = any>(releaser: IEventReleaser<R>): R;
 }
 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>>> {
@@ -44,7 +44,11 @@ export interface ESAggregateClassWithTypedConstructor<T extends AnyESAggregate =
 }
 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 {
+    id: Id;
+    version: number;
+}
 export interface Snapshot<T extends AnyESAggregate> {
-    metadata: AggregateMetadata;
+    metadata: SnapshotMetadata;
     props: InferredProps<T>;
 }

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

@@ -1,25 +1,22 @@
 "use strict";
 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(pastEvents, id) {
-        const instance = new this(this.createMetadata({ id }));
-        instance.applyPastEvents(pastEvents);
+    static fromStream(id, allPastEvents) {
+        const instance = new this(id, 0);
+        instance.applyPastEvents(allPastEvents);
         return instance;
     }
     static newStream(id) {
-        return this.fromStream([], id);
+        return this.fromStream(id ?? (0, uuid_1.v4)(), []);
     }
     static fromSnapshot(snapshot, pastEvents = []) {
-        const { id, version } = snapshot.metadata;
-        const { props } = snapshot;
-        const instance = new this({
-            id,
-            version,
-        }, props);
+        const { metadata: { id, version }, props, } = snapshot;
+        const instance = new this(id, version, props);
         instance.applyPastEvents(pastEvents);
         return instance;
     }
@@ -35,8 +32,8 @@ class ESAggregate extends aggregate_1.Aggregate {
     static commandHandlerMap() {
         return (0, meta_1.getCommandHandlerMap)(this.prototype);
     }
-    constructor(metadata, props) {
-        super(metadata, props);
+    constructor(id, version, props) {
+        super(id, version, props);
         this._handledCommands = [];
         this._events = [];
         this._pastEvents = [];
@@ -44,7 +41,7 @@ class ESAggregate extends aggregate_1.Aggregate {
     _constructor() {
         return this.constructor;
     }
-    version() {
+    get version() {
         return this._version + this._pastEvents.length + this._events.length;
     }
     pastEvents() {
@@ -64,14 +61,14 @@ class ESAggregate extends aggregate_1.Aggregate {
         const eventApplierMap = this._constructor().eventApplierMap();
         const applier = eventApplierMap.get(eventType);
         if (!applier)
-            throw new Error("IsEvent applier not found");
+            throw new Error("Event applier not found");
         return applier;
     }
     validateEventBeforeApply(event) {
         const { aggregateId, aggregateVersion } = event.source();
-        if (aggregateId !== this._id)
+        if (aggregateId !== this.id)
             throw new Error("Invalid aggregate id");
-        if (aggregateVersion !== this.version())
+        if (aggregateVersion !== this.version)
             throw new Error("Invalid aggregate version");
     }
     _applyEvent(event) {
@@ -99,33 +96,38 @@ class ESAggregate extends aggregate_1.Aggregate {
             this.applyEvent(event);
         });
     }
-    applyNewEvent(eventClass, props) {
-        this.applyEvent(this.newEvent(eventClass, props));
+    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("IsCommand handler not found");
+            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());
+            event.setCausationId(command.id);
+            event.setCorrelationIds(command.correlationIds);
         });
         this.applyEvents(events);
         this._handledCommands.push(command);
         return events;
     }
     takeSnapshot() {
-        if (this.isPropsEmpty())
+        if (!this.isPropsInitialized())
             throw new Error("Cannot create snapshot when the props is not initialized");
         return {
-            metadata: this.metadata(),
+            metadata: {
+                id: this.id,
+                version: this.version,
+            },
             props: this.props(),
         };
     }
@@ -133,10 +135,10 @@ class ESAggregate extends aggregate_1.Aggregate {
         this._pastEvents.push(...this.events());
         this._events = [];
     }
-    publishEvents(publisher) {
+    releaseEvents(releaser) {
         const events = this.events();
         this.commitEvents();
-        return publisher.publish(events);
+        return releaser.release(events);
     }
 }
 exports.ESAggregate = ESAggregate;

package/core/model/aggregate/event-releaser.d.ts

@@ -0,0 +1,4 @@
+import { AnyEvent } from "../message";
+export interface IEventReleaser<R = any> {
+    release(events: AnyEvent[]): R;
+}

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

@@ -1,4 +1,5 @@
 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,4 +17,5 @@ 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,23 +1,22 @@
 import { Class } from "type-fest";
 import { InferredProps, Props } from "../../../base";
 import { ClassStatic } from "../../../types";
-import { AnyEvent, EventClassWithTypedConstructor } from "../message";
-import { Aggregate, AggregateMetadata } from "./aggregate";
-import { IAggregateEventPublisher } from "./types";
-export interface StateAggregateMetadata extends AggregateMetadata {
-}
+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 build<T extends AnyStateAggregate>(this: StateAggregateClassWithTypedConstructor<T>, props: InferredProps<T>, metadata?: Partial<StateAggregateMetadata>): T;
+    static new<T extends AnyStateAggregate>(this: StateAggregateClassWithTypedConstructor<T>, props: InferredProps<T>, id?: Id): T;
     private _events;
-    constructor(metadata: StateAggregateMetadata, props: P);
+    constructor(id: Id, version: number, props: P);
     _constructor(): StateAggregateClass<typeof this>;
     props(): P;
-    version(): number;
+    get version(): number;
     events(): AnyEvent[];
     protected recordEvent<E extends AnyEvent>(event: E): void;
-    protected recordEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: InferredProps<E>): void;
+    protected recordEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: InferredProps<E>, options?: NewEventOptions): void;
     clearEvents(): void;
-    publishEvents<R = any>(publisher: IAggregateEventPublisher<R>): R;
+    releaseEvents<R = any>(eventReleaser: IEventReleaser<R>): R;
 }
 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>>> {

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

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StateAggregate = void 0;
+const uuid_1 = require("uuid");
 const aggregate_1 = require("./aggregate");
 class StateAggregate extends aggregate_1.Aggregate {
-    static build(props, metadata) {
-        return new this(this.createMetadata(metadata), props);
+    static new(props, id) {
+        return new this(id ?? (0, uuid_1.v4)(), 0, props);
     }
-    constructor(metadata, props) {
-        super(metadata, props);
+    constructor(id, version, props) {
+        super(id, version, props);
         this._events = [];
     }
     _constructor() {
@@ -16,29 +17,29 @@ class StateAggregate extends aggregate_1.Aggregate {
     props() {
         return super.props();
     }
-    version() {
+    get version() {
         return this._version;
     }
     events() {
         return Array.from(this._events);
     }
-    recordEvent(param1, param2) {
+    recordEvent(p1, p2, p3) {
         let event;
-        if (typeof param1 === "function" && param2) {
-            event = this.newEvent(param1, param2);
+        if (typeof p1 === "function" && p2) {
+            event = this.newEvent(p1, p2, p3);
         }
         else {
-            event = param1;
+            event = p1;
         }
         this._events.push(event);
     }
     clearEvents() {
         this._events = [];
     }
-    publishEvents(publisher) {
+    releaseEvents(eventReleaser) {
         const events = this.events();
         this.clearEvents();
-        return publisher.publish(events);
+        return eventReleaser.release(events);
     }
 }
 exports.StateAggregate = StateAggregate;

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

@@ -1,7 +1,3 @@
 import { ESAggregateClass } from "./es-aggregate";
 import { StateAggregateClass } from "./state-aggregate";
-import { AnyEvent } from "../message";
 export type AggregateClass = StateAggregateClass | ESAggregateClass;
-export interface IAggregateEventPublisher<R = any> {
-    publish(events: AnyEvent | AnyEvent[]): R;
-}

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

@@ -1,12 +1,10 @@
 import { Class } from "type-fest";
 import { InferredProps, Props } from "../../../base";
 import { ClassStatic } from "../../../types";
-import { Id, ModelWithId, ModelWithIdMetadata } from "../model-with-id";
-export interface EntityMetadata extends ModelWithIdMetadata {
-}
-export declare class Entity<P extends Props> extends ModelWithId<P> {
-    static build<T extends AnyEntity>(this: EntityClassWithTypedConstructor<T>, props: InferredProps<T>, id?: Id): T;
-    constructor(metadata: EntityMetadata, props: P);
+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>;
 }
 export type AnyEntity = Entity<Props>;

package/core/model/entity/entity.js

@@ -12,13 +12,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Entity = void 0;
 const uuid_1 = require("uuid");
 const base_1 = require("../../../base");
-const model_with_id_1 = require("../model-with-id");
-let Entity = class Entity extends model_with_id_1.ModelWithId {
-    static build(props, id) {
-        return new this({ id: id ?? (0, uuid_1.v4)() }, props);
+const identified_model_1 = require("../identified-model");
+let Entity = class Entity extends identified_model_1.IdentifiedModel {
+    static new(props, id) {
+        return new this(id ?? (0, uuid_1.v4)(), props);
     }
-    constructor(metadata, props) {
-        super(metadata);
+    constructor(id, props) {
+        super(id);
         this.initializeProps(props);
     }
     _constructor() {
@@ -28,5 +28,5 @@ let Entity = class Entity extends model_with_id_1.ModelWithId {
 exports.Entity = Entity;
 exports.Entity = Entity = __decorate([
     (0, base_1.Mutable)(true),
-    __metadata("design:paramtypes", [Object, Object])
+    __metadata("design:paramtypes", [String, Object])
 ], Entity);

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

@@ -6,6 +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 values(): Enum[];
     static from<T extends AnyEnum>(this: EnumClass<T>, value: EnumValue): T;
     constructor(value: EnumValue);

package/core/model/enum/enum.js

@@ -11,26 +11,28 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 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 values() {
-        return Array.from(this.modelDescriptor().ownModelStaticValues().values()).map((staticValue) => staticValue.value);
+        return Array.from(this.modelDescriptor().ownModelStaticValues.values()).map((staticValue) => staticValue.value);
     }
     static from(value) {
         if (!value)
             throw new Error("Cannot parse enum without value");
         let result;
-        this.modelDescriptor()
-            .ownModelStaticValues()
-            .forEach((staticValue) => {
-            if (staticValue.value instanceof this) {
-                const staticEnum = staticValue.value;
-                if (staticEnum.value === value && !result) {
-                    result = staticEnum;
-                }
+        this.enumPropertySet().forEach((enumProperty) => {
+            const enumValue = this?.[enumProperty];
+            if (!enumValue)
+                return;
+            if (enumValue.value === value && !result) {
+                result = enumValue;
             }
         });
         if (!result)
-            throw new Error(`Invalid provided value for enum ${this.modelDescriptor().modelName()}`);
+            throw new Error(`Invalid provided value for enum ${this.modelDescriptor().modelName}`);
         return result;
     }
     constructor(value) {

package/core/model/identified-model/id.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/model/identified-model/identified-model.d.ts

@@ -0,0 +1,16 @@
+import { Class } from "type-fest";
+import { DomainModel, InferredProps, Props } from "../../../base";
+import { ClassStatic } from "../../../types";
+import { Id } from "./id";
+export declare class IdentifiedModel<P extends Props> extends DomainModel<P> {
+    private _id;
+    constructor(id: Id);
+    get id(): string;
+    setId(id: Id): void;
+    hasId(id: Id): boolean;
+}
+export type AnyIdentifiedModel = IdentifiedModel<Props>;
+export interface IdentifiedModelClass<T extends AnyIdentifiedModel = AnyIdentifiedModel, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof IdentifiedModel<InferredProps<T>>> {
+}
+export interface IdentifiedModelClassWithTypedConstructor<T extends AnyIdentifiedModel = AnyIdentifiedModel> extends IdentifiedModelClass<T, ConstructorParameters<typeof IdentifiedModel<InferredProps<T>>>> {
+}

package/core/model/identified-model/identified-model.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentifiedModel = void 0;
+const base_1 = require("../../../base");
+class IdentifiedModel extends base_1.DomainModel {
+    constructor(id) {
+        super();
+        if (id)
+            this.setId(id);
+    }
+    get id() {
+        return this._id;
+    }
+    setId(id) {
+        this._id = id;
+    }
+    hasId(id) {
+        return this._id === id;
+    }
+}
+exports.IdentifiedModel = IdentifiedModel;

package/core/model/identified-model/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./id";
+export * from "./identified-model";

package/core/model/{model-with-id → identified-model}/index.js

@@ -15,4 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./id"), exports);
-__exportStar(require("./model-with-id"), exports);
+__exportStar(require("./identified-model"), exports);

package/core/model/index.d.ts

@@ -1,6 +1,6 @@
 export * from "./value-object";
 export * from "./enum";
-export * from "./model-with-id";
+export * from "./identified-model";
 export * from "./entity";
 export * from "./aggregate";
 export * from "./message";

package/core/model/index.js

@@ -16,7 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./value-object"), exports);
 __exportStar(require("./enum"), exports);
-__exportStar(require("./model-with-id"), exports);
+__exportStar(require("./identified-model"), exports);
 __exportStar(require("./entity"), exports);
 __exportStar(require("./aggregate"), exports);
 __exportStar(require("./message"), exports);

package/core/model/message/command.d.ts

@@ -2,17 +2,19 @@ import { Class } from "type-fest";
 import { InferredProps, Props } from "../../../base";
 import { ClassStatic } from "../../../types";
 import { CommandType } from "../../meta";
-import { Message, MessageClass, MessageMetadata, MessageMetadataInput } from "./message";
-export interface CommandMetadata extends MessageMetadata {
-    commandType: CommandType;
+import { Id } from "../identified-model";
+import { CausationId, CorrelationIds, Message, MessageClass } from "./message";
+export interface NewCommandOptions {
+    id?: Id;
+    causationId?: CausationId;
+    correlationIds?: CorrelationIds;
 }
 export declare class Command<P extends Props> extends Message<P> {
-    static build<T extends AnyCommand>(this: CommandClassWithTypedConstructor<T>, props: InferredProps<T>, metadata?: MessageMetadataInput): T;
+    static new<T extends AnyCommand>(this: CommandClassWithTypedConstructor<T>, props: InferredProps<T>, options?: NewCommandOptions): T;
     static commandType<T extends AnyCommand>(this: CommandClass<T>): string;
     protected readonly _commandType: CommandType;
-    constructor(metadata: Omit<CommandMetadata, "commandType">, props: P);
+    constructor(id: Id, timestamp: number, props: P, causationId?: Id, correlationIds?: CorrelationIds);
     _constructor(): CommandClass<typeof this>;
-    metadata(): CommandMetadata;
     commandType(): string;
 }
 export type AnyCommand = Command<Props>;

package/core/model/message/command.js

@@ -1,28 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Command = void 0;
+const uuid_1 = require("uuid");
 const meta_1 = require("../../meta");
 const message_1 = require("./message");
 class Command extends message_1.Message {
-    static build(props, metadata) {
-        return new this(this.createMetadata(metadata), props);
+    static new(props, options) {
+        return new this(options?.id ?? (0, uuid_1.v4)(), Date.now(), props, options?.causationId, options?.correlationIds);
     }
     static commandType() {
         return (0, meta_1.getCommandType)(this);
     }
-    constructor(metadata, props) {
-        super(metadata, props);
+    constructor(id, timestamp, props, causationId, correlationIds) {
+        super(id, timestamp, props, causationId, correlationIds);
         this._commandType = this._constructor().commandType();
     }
     _constructor() {
         return this.constructor;
     }
-    metadata() {
-        return {
-            ...super.metadata(),
-            commandType: this._commandType,
-        };
-    }
     commandType() {
         return this._commandType;
     }

package/core/model/message/event.d.ts

@@ -1,26 +1,24 @@
 import { Class } from "type-fest";
 import { InferredProps, Props } from "../../../base";
 import { ClassStatic } from "../../../types";
-import { EventType } from "../../meta";
-import { Id } from "../model-with-id";
-import { Message, MessageClass, MessageMetadata, MessageMetadataInput } from "./message";
+import { Id } from "../identified-model";
+import { CausationId, CorrelationIds, Message, MessageClass } from "./message";
 export type EventSource = Readonly<{
     aggregateId: Id;
     aggregateVersion: number;
 }>;
-export interface EventMetadata extends MessageMetadata {
-    eventType: EventType;
-    source: EventSource;
+export interface NewEventOptions {
+    id?: Id;
+    causationId?: CausationId;
+    correlationIds?: CorrelationIds;
 }
-export type EventMetadataInput = MessageMetadataInput & Pick<EventMetadata, "source">;
 export declare class Event<P extends Props> extends Message<P> {
-    static build<T extends AnyEvent>(this: EventClassWithTypedConstructor<T>, props: InferredProps<T>, metadata: EventMetadataInput): T;
+    static new<T extends AnyEvent>(this: EventClassWithTypedConstructor<T>, eventSource: EventSource, props: InferredProps<T>, options?: NewEventOptions): T;
     static eventType<T extends AnyEvent>(this: EventClass<T>): string;
     private readonly _eventType;
     private readonly _source;
-    constructor(metadata: Omit<EventMetadata, "eventType">, props: P);
+    constructor(id: Id, timestamp: number, eventSource: EventSource, props: P, causationId?: string, correlationIds?: CorrelationIds);
     _constructor(): EventClass<typeof this>;
-    metadata(): EventMetadata;
     eventType(): string;
     source(): Readonly<{
         aggregateId: Id;

package/core/model/message/event.js

@@ -1,30 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Event = void 0;
+const uuid_1 = require("uuid");
 const meta_1 = require("../../meta");
 const message_1 = require("./message");
 class Event extends message_1.Message {
-    static build(props, metadata) {
-        return new this({ ...this.createMetadata(), ...metadata }, props);
+    static new(eventSource, props, options) {
+        return new this(options?.id ?? (0, uuid_1.v4)(), Date.now(), eventSource, props, options?.causationId, options?.correlationIds);
     }
     static eventType() {
         return (0, meta_1.getEventType)(this);
     }
-    constructor(metadata, props) {
-        super(metadata, props);
+    constructor(id, timestamp, eventSource, props, causationId, correlationIds) {
+        super(id, timestamp, props, causationId, correlationIds);
         this._eventType = this._constructor().eventType();
-        this._source = metadata.source;
+        this._source = eventSource;
     }
     _constructor() {
         return this.constructor;
     }
-    metadata() {
-        return {
-            ...super.metadata(),
-            eventType: this._eventType,
-            source: this._source,
-        };
-    }
     eventType() {
         return this._eventType;
     }