ddd-node 4.0.1 → 5.0.0

package/dist/base/aggregate.d.ts

@@ -6,21 +6,25 @@ import { AnyEvent, EventClass, NewEventMetadataOptions } from "./event";
 import { Id } from "./id";
 import { PropsOf } from "./props-envelope";
 export interface IAggregateMetadata extends IEntityMetadata {
+    readonly aggregateType: string;
     readonly version: number;
 }
+export type NewAggregateMetadata = Partial<Omit<IAggregateMetadata, "aggregateType">>;
 export declare class Aggregate<P extends object> extends Entity<P> implements IAggregateMetadata {
+    private readonly _aggregateType;
     protected readonly _version: number;
     protected events: AnyEvent[];
     constructor(metadata: IAggregateMetadata, props?: P);
     static aggregateType(): string;
-    static newAggregate<T extends AnyAggregate>(this: AggregateClass<T>, props?: PropsOf<T>): T;
+    static newAggregate<T extends AnyAggregate>(this: AggregateClass<T>, props?: PropsOf<T>, metadata?: NewAggregateMetadata): T;
     get version(): number;
-    aggregateType(): string;
+    get aggregateType(): string;
     getEvents(): AnyEvent[];
     hasEvents(): boolean;
     nextVersion(): number;
     protected newEvent<E extends AnyEvent>(eventClass: EventClass<E>, props: PropsOf<E>, metadata?: NewEventMetadataOptions): E;
     protected addEvent<E extends AnyEvent>(event: E): void;
+    protected addNewEvent<E extends AnyEvent>(eventClass: EventClass<E>, props: PropsOf<E>, metadata?: NewEventMetadataOptions): void;
 }
 export interface SnapshotWithProps<P extends object> {
     metadata: IAggregateMetadata;
@@ -40,10 +44,13 @@ export declare class AggregateES<P extends object> extends Aggregate<P> {
     nextVersion(): number;
     private addPastEvent;
     private validateEventBeforeApply;
-    getEventApplier(eventType: string): AggregateEventApplier<AnyEvent> | null;
+    getEventApplierSafe(eventType: string): AggregateEventApplier<AnyEvent> | null;
+    getEventApplier(eventType: string): AggregateEventApplier<AnyEvent>;
     applyEvent<E extends AnyEvent>(event: E, fromHistory?: boolean): void;
     applyEvents(events: AnyEvent[], fromHistory?: boolean): void;
-    getCommandHandler(commandType: string): AggregateCommandHandler<AnyCommand> | null;
+    getCommandHandlerSafe(commandType: string): AggregateCommandHandler<AnyCommand> | null;
+    getCommandHandler(commandType: string): AggregateCommandHandler<AnyCommand>;
+    private validateCommandBeforeProcess;
     processCommand<C extends AnyCommand>(command: C): AnyEvent[];
     snap(): SnapshotWithProps<P>;
 }
@@ -58,4 +65,4 @@ export type AggregateConstructorParams<T extends AnyAggregate> = AggregateConstr
 export type AggregateClass<T extends AnyAggregate> = Class<T, AggregateConstructorParams<T>> & ClassStatic<typeof Aggregate<PropsOf<T>>>;
 export type AggregateESClass<T extends AnyAggregateES> = Class<T, AggregateConstructorParams<T>> & ClassStatic<typeof AggregateES<PropsOf<T>>>;
 export type InferAggregateClass<T extends AnyAggregate> = T extends AnyAggregateES ? AggregateESClass<T> : AggregateClass<T>;
-export type AnyAggregateClass = AggregateClass<AnyAggregate>;
+export type AnyAggregateClass = Class<AnyAggregate>;

package/dist/base/aggregate.js

@@ -10,23 +10,20 @@ class Aggregate extends entity_1.Entity {
     constructor(metadata, props) {
         super({ id: metadata.id }, props);
         this.events = [];
+        this._aggregateType = metadata.aggregateType;
         this._version = metadata.version;
     }
     static aggregateType() {
         return (0, aggregate_1.getAggregateType)(this.prototype);
     }
-    static newAggregate(props) {
-        return new this({
-            id: id_1.Id.unique(),
-            version: 0,
-        }, props);
+    static newAggregate(props, metadata) {
+        return new this(Object.assign({ aggregateType: this.aggregateType(), id: id_1.Id.unique(), version: 0 }, metadata), props);
     }
     get version() {
         return this._version;
     }
-    aggregateType() {
-        const prototype = Object.getPrototypeOf(this);
-        return (0, aggregate_1.getAggregateType)(prototype);
+    get aggregateType() {
+        return this._aggregateType;
     }
     getEvents() {
         return this.events;
@@ -40,13 +37,16 @@ class Aggregate extends entity_1.Entity {
     newEvent(eventClass, props, metadata) {
         return eventClass.newEvent({
             id: this.id,
-            type: this.aggregateType(),
             version: this.nextVersion(),
         }, props, metadata);
     }
     addEvent(event) {
         this.events.push(event);
     }
+    addNewEvent(eventClass, props, metadata) {
+        const event = this.newEvent(eventClass, props, metadata);
+        this.addEvent(event);
+    }
 }
 exports.Aggregate = Aggregate;
 class AggregateES extends Aggregate {
@@ -56,7 +56,7 @@ class AggregateES extends Aggregate {
         this.pastEvents = [];
     }
     static stream(id, events) {
-        const aggregate = new this({ id, version: 0 });
+        const aggregate = this.newAggregate(undefined, { id });
         aggregate.applyEvents(events, true);
         return aggregate;
     }
@@ -90,26 +90,31 @@ class AggregateES extends Aggregate {
         this.pastEvents.push(event);
     }
     validateEventBeforeApply(event) {
-        const { type, id, version } = event.aggregate;
-        if (type !== this.aggregateType())
+        const { aggregateType } = event;
+        const { id, version } = event.aggregate;
+        if (aggregateType !== this.aggregateType)
             throw new aggregate_error_1.InvalidEventAggregateTypeError();
-        if (id !== this.id)
+        if (!id.equals(this.id))
             throw new aggregate_error_1.InvalidEventAggregateIdError();
         if (version !== this.nextVersion())
             throw new aggregate_error_1.InvalidEventAggregateVersionError();
     }
-    getEventApplier(eventType) {
+    getEventApplierSafe(eventType) {
         const prototype = Object.getPrototypeOf(this);
         const eventApplier = (0, aggregate_1.getAggregateEventApplier)(prototype, eventType);
         if (eventApplier)
             return eventApplier.bind(this);
         return null;
     }
-    applyEvent(event, fromHistory = false) {
-        const eventType = event.eventType();
-        const applier = this.getEventApplier(eventType);
+    getEventApplier(eventType) {
+        const applier = this.getEventApplierSafe(eventType);
         if (!applier)
             throw new aggregate_error_1.EventApplierNotFoundError(eventType);
+        return applier;
+    }
+    applyEvent(event, fromHistory = false) {
+        const { eventType } = event;
+        const applier = this.getEventApplier(eventType);
         this.validateEventBeforeApply(event);
         if (fromHistory)
             this.addPastEvent(event);
@@ -122,18 +127,28 @@ class AggregateES extends Aggregate {
             this.applyEvent(event, fromHistory);
         });
     }
-    getCommandHandler(commandType) {
+    getCommandHandlerSafe(commandType) {
         const prototype = Object.getPrototypeOf(this);
         const commandHandler = (0, aggregate_1.getAggregateCommandHandler)(prototype, commandType);
         if (commandHandler)
             return commandHandler.bind(this);
         return null;
     }
-    processCommand(command) {
-        const commandType = command.commandType();
-        const handler = this.getCommandHandler(commandType);
+    getCommandHandler(commandType) {
+        const handler = this.getCommandHandlerSafe(commandType);
         if (!handler)
             throw new aggregate_error_1.CommandHandlerNotFoundError(commandType);
+        return handler;
+    }
+    validateCommandBeforeProcess(command) {
+        const { aggregateType } = command;
+        if (aggregateType !== this.aggregateType)
+            throw new aggregate_error_1.InvalidCommandAggregateTypeError();
+    }
+    processCommand(command) {
+        const { commandType } = command;
+        const handler = this.getCommandHandler(commandType);
+        this.validateCommandBeforeProcess(command);
         const events = (0, to_array_1.toArray)(handler(command));
         const { correlationId, causationId } = command;
         events.forEach((event) => {
@@ -150,6 +165,7 @@ class AggregateES extends Aggregate {
         return {
             metadata: {
                 id: this.id,
+                aggregateType: this.aggregateType,
                 version: this.version,
             },
             props: this.getProps(),

package/dist/base/command.d.ts

@@ -1,33 +1,21 @@
 import { Class } from "../types/class";
 import { ClassStatic } from "../types/class-static";
-import { Id } from "./id";
-import { PropsEnvelope, PropsOf } from "./props-envelope";
-export interface ICommandMetadata {
-    readonly id: Id;
-    readonly timestamp: number;
-    correlationId?: string;
-    causationId?: string;
+import { IMessageMetadata, Message } from "./message";
+import { PropsOf } from "./props-envelope";
+export interface ICommandMetadata extends IMessageMetadata {
+    readonly commandType: string;
 }
-export type NewCommandMetadataOptions = Partial<Omit<ICommandMetadata, "timestamp">>;
-export declare class Command<P extends object> extends PropsEnvelope<P> implements ICommandMetadata {
-    private readonly _id;
-    private readonly _timestamp;
-    private _correlationId?;
-    private _causationId?;
+export type NewCommandMetadataOptions = Omit<ICommandMetadata, "aggregateType" | "timestamp">;
+export declare class Command<P extends object> extends Message<P> implements ICommandMetadata {
+    private readonly _commandType;
     constructor(metadata: ICommandMetadata, props: P);
     static commandType(): string;
     static newCommand<T extends AnyCommand>(this: CommandClass<T>, props: PropsOf<T>, metadata?: NewCommandMetadataOptions): T;
-    get id(): Id;
-    get timestamp(): number;
-    get correlationId(): string | undefined;
-    get causationId(): string | undefined;
-    setCorrelationId(correlationId: string): void;
-    setCausationId(causationId: string): void;
-    commandType(): string;
+    get commandType(): string;
 }
 export type AnyCommand = Command<any>;
 export type CommandConstructorParamsWithProps<P extends object> = ConstructorParameters<typeof Command<P>>;
 export type CommandClassWithProps<P extends object> = Class<Command<P>, CommandConstructorParamsWithProps<P>> & ClassStatic<typeof Command<P>>;
 export type CommandConstructorParams<T extends AnyCommand> = CommandConstructorParamsWithProps<PropsOf<T>>;
 export type CommandClass<T extends AnyCommand> = Class<T, CommandConstructorParams<T>> & ClassStatic<typeof Command<PropsOf<T>>>;
-export type AnyCommandClass = CommandClass<AnyCommand>;
+export type AnyCommandClass = Class<AnyCommand>;

package/dist/base/command.js

@@ -3,44 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Command = void 0;
 const command_1 = require("../metadata/command");
 const id_1 = require("./id");
-const props_envelope_1 = require("./props-envelope");
-class Command extends props_envelope_1.PropsEnvelope {
+const message_1 = require("./message");
+class Command extends message_1.Message {
     constructor(metadata, props) {
-        super(props);
-        this._id = metadata.id;
-        this._timestamp = metadata.timestamp;
-        this._correlationId = metadata === null || metadata === void 0 ? void 0 : metadata.correlationId;
-        this._causationId = metadata === null || metadata === void 0 ? void 0 : metadata.causationId;
+        super(metadata, props);
+        this._commandType = metadata.commandType;
     }
     static commandType() {
         return (0, command_1.getCommandType)(this.prototype);
     }
     static newCommand(props, metadata) {
-        return new this(Object.assign({ id: id_1.Id.unique(), timestamp: Date.now() }, metadata), props);
+        return new this(Object.assign({ commandType: this.commandType(), id: id_1.Id.unique(), timestamp: Date.now(), aggregateType: this.aggregateType() }, metadata), props);
     }
-    get id() {
-        return this._id;
-    }
-    get timestamp() {
-        return this._timestamp;
-    }
-    get correlationId() {
-        return this._correlationId;
-    }
-    get causationId() {
-        return this._causationId;
-    }
-    setCorrelationId(correlationId) {
-        if (!this.correlationId)
-            this._correlationId = correlationId;
-    }
-    setCausationId(causationId) {
-        if (!this.causationId)
-            this._causationId = causationId;
-    }
-    commandType() {
-        const prototype = Object.getPrototypeOf(this);
-        return (0, command_1.getCommandType)(prototype);
+    get commandType() {
+        return this._commandType;
     }
 }
 exports.Command = Command;

package/dist/base/entity.d.ts

@@ -20,4 +20,4 @@ export type EntityConstructorParamsWithProps<P extends object> = ConstructorPara
 export type EntityClassWithProps<P extends object> = Class<Entity<P>, EntityConstructorParamsWithProps<P>> & ClassStatic<typeof Entity<P>>;
 export type EntityConstructorParams<T extends AnyEntity> = EntityConstructorParamsWithProps<PropsOf<T>>;
 export type EntityClass<T extends AnyEntity> = Class<T, EntityConstructorParams<T>> & ClassStatic<typeof Entity<PropsOf<T>>>;
-export type AnyEntityClass = EntityClass<AnyEntity>;
+export type AnyEntityClass = Class<AnyEntity>;

package/dist/base/errors/aggregate.error.d.ts

@@ -16,3 +16,6 @@ export declare class InvalidEventAggregateIdError extends Error {
 export declare class InvalidEventAggregateVersionError extends Error {
     constructor();
 }
+export declare class InvalidCommandAggregateTypeError extends Error {
+    constructor();
+}

package/dist/base/errors/aggregate.error.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvalidEventAggregateVersionError = exports.InvalidEventAggregateIdError = exports.InvalidEventAggregateTypeError = exports.CommandHandlerNotFoundError = exports.EventApplierNotFoundError = exports.PastEventCannotBeAddedError = void 0;
+exports.InvalidCommandAggregateTypeError = exports.InvalidEventAggregateVersionError = exports.InvalidEventAggregateIdError = exports.InvalidEventAggregateTypeError = exports.CommandHandlerNotFoundError = exports.EventApplierNotFoundError = exports.PastEventCannotBeAddedError = void 0;
 class PastEventCannotBeAddedError extends Error {
     constructor() {
         super("Past event cannot be added once a new event has been added");
@@ -21,19 +21,25 @@ class CommandHandlerNotFoundError extends Error {
 exports.CommandHandlerNotFoundError = CommandHandlerNotFoundError;
 class InvalidEventAggregateTypeError extends Error {
     constructor() {
-        super("The event must have the aggregateType is equal to the type of the aggregate that applied that event");
+        super("The event must have the aggregate type equal to the type of the aggregate instance");
     }
 }
 exports.InvalidEventAggregateTypeError = InvalidEventAggregateTypeError;
 class InvalidEventAggregateIdError extends Error {
     constructor() {
-        super("The event must have the aggregateId is equal to the id of the aggregate that applied that event");
+        super("The event must have the aggregate id equal to the id of the aggregate instance");
     }
 }
 exports.InvalidEventAggregateIdError = InvalidEventAggregateIdError;
 class InvalidEventAggregateVersionError extends Error {
     constructor() {
-        super("The event must have the aggregateVersion is equal to the next version of the aggregate that applied that event");
+        super("The event must have the aggregate version equal to the next version of the aggregate instance");
     }
 }
 exports.InvalidEventAggregateVersionError = InvalidEventAggregateVersionError;
+class InvalidCommandAggregateTypeError extends Error {
+    constructor() {
+        super("The command must have the aggregate type equal to the type of the aggregate instance");
+    }
+}
+exports.InvalidCommandAggregateTypeError = InvalidCommandAggregateTypeError;

package/dist/base/event.d.ts

@@ -1,41 +1,29 @@
 import { Class } from "../types/class";
 import { ClassStatic } from "../types/class-static";
 import { Id } from "./id";
-import { PropsEnvelope, PropsOf } from "./props-envelope";
+import { IMessageMetadata, Message } from "./message";
+import { PropsOf } from "./props-envelope";
 export interface IEventAggregate {
     readonly id: Id;
-    readonly type: string;
     readonly version: number;
 }
-export interface IEventMetadata {
-    readonly id: Id;
-    readonly timestamp: number;
+export interface IEventMetadata extends IMessageMetadata {
+    readonly eventType: string;
     readonly aggregate: IEventAggregate;
-    correlationId?: string;
-    causationId?: string;
 }
-export type NewEventMetadataOptions = Partial<Omit<IEventMetadata, "aggregate" | "timestamp">>;
-export declare class Event<P extends object> extends PropsEnvelope<P> implements IEventMetadata {
-    private readonly _id;
-    private readonly _timestamp;
+export type NewEventMetadataOptions = Omit<IEventMetadata, "aggregateType" | "aggregate" | "timestamp">;
+export declare class Event<P extends object> extends Message<P> implements IEventMetadata {
+    private readonly _eventType;
     private readonly _aggregate;
-    private _correlationId?;
-    private _causationId?;
     constructor(metadata: IEventMetadata, props: P);
     static eventType(): string;
     static newEvent<T extends AnyEvent>(this: EventClass<T>, aggregate: IEventAggregate, props: PropsOf<T>, metadata?: NewEventMetadataOptions): T;
-    get id(): Id;
-    get timestamp(): number;
+    get eventType(): string;
     get aggregate(): IEventAggregate;
-    get correlationId(): string | undefined;
-    get causationId(): string | undefined;
-    setCorrelationId(correlationId: string): void;
-    setCausationId(causationId: string): void;
-    eventType(): string;
 }
 export type AnyEvent = Event<any>;
 export type EventConstructorParamsWithProps<P extends object> = ConstructorParameters<typeof Event<P>>;
 export type EventClassWithProps<P extends object> = Class<Event<P>, EventConstructorParamsWithProps<P>> & ClassStatic<typeof Event<P>>;
 export type EventConstructorParams<T extends AnyEvent> = EventConstructorParamsWithProps<PropsOf<T>>;
 export type EventClass<T extends AnyEvent> = Class<T, EventConstructorParams<T>> & ClassStatic<typeof Event<PropsOf<T>>>;
-export type AnyEventClass = EventClass<AnyEvent>;
+export type AnyEventClass = Class<AnyEvent>;

package/dist/base/event.js

@@ -3,48 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Event = void 0;
 const event_1 = require("../metadata/event");
 const id_1 = require("./id");
-const props_envelope_1 = require("./props-envelope");
-class Event extends props_envelope_1.PropsEnvelope {
+const message_1 = require("./message");
+class Event extends message_1.Message {
     constructor(metadata, props) {
-        super(props);
-        this._id = metadata.id;
-        this._timestamp = metadata.timestamp;
+        super(metadata, props);
+        this._eventType = metadata.eventType;
         this._aggregate = metadata.aggregate;
-        this._correlationId = metadata === null || metadata === void 0 ? void 0 : metadata.correlationId;
-        this._causationId = metadata === null || metadata === void 0 ? void 0 : metadata.causationId;
     }
     static eventType() {
         return (0, event_1.getEventType)(this.prototype);
     }
     static newEvent(aggregate, props, metadata) {
-        return new this(Object.assign({ id: id_1.Id.unique(), timestamp: Date.now(), aggregate }, metadata), props);
+        return new this(Object.assign({ eventType: this.eventType(), id: id_1.Id.unique(), timestamp: Date.now(), aggregateType: this.aggregateType(), aggregate }, metadata), props);
     }
-    get id() {
-        return this._id;
-    }
-    get timestamp() {
-        return this._timestamp;
+    get eventType() {
+        return this._eventType;
     }
     get aggregate() {
         return this._aggregate;
     }
-    get correlationId() {
-        return this._correlationId;
-    }
-    get causationId() {
-        return this._causationId;
-    }
-    setCorrelationId(correlationId) {
-        if (!this.correlationId)
-            this._correlationId = correlationId;
-    }
-    setCausationId(causationId) {
-        if (!this.causationId)
-            this._causationId = causationId;
-    }
-    eventType() {
-        const prototype = Object.getPrototypeOf(this);
-        return (0, event_1.getEventType)(prototype);
-    }
 }
 exports.Event = Event;

package/dist/base/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./aggregate";
+export * from "./message";
 export * from "./command";
 export * from "./entity";
 export * from "./event";

package/dist/base/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./aggregate"), exports);
+__exportStar(require("./message"), exports);
 __exportStar(require("./command"), exports);
 __exportStar(require("./entity"), exports);
 __exportStar(require("./event"), exports);

package/dist/base/message.d.ts

@@ -0,0 +1,33 @@
+import { Class } from "../types/class";
+import { ClassStatic } from "../types/class-static";
+import { Id } from "./id";
+import { PropsEnvelope, PropsOf } from "./props-envelope";
+export interface IMessageMetadata {
+    readonly id: Id;
+    readonly timestamp: number;
+    readonly aggregateType: string;
+    correlationId?: string;
+    causationId?: string;
+}
+export declare class Message<P extends object> extends PropsEnvelope<P> implements IMessageMetadata {
+    private readonly _id;
+    private readonly _timestamp;
+    private readonly _aggregateType;
+    private _correlationId?;
+    private _causationId?;
+    constructor(metadata: IMessageMetadata, props: P);
+    static aggregateType(): string;
+    get id(): Id;
+    get timestamp(): number;
+    get aggregateType(): string;
+    get correlationId(): string | undefined;
+    get causationId(): string | undefined;
+    setCorrelationId(correlationId: string): void;
+    setCausationId(causationId: string): void;
+}
+export type AnyMessage = Message<any>;
+export type MessageConstructorParamsWithProps<P extends object> = ConstructorParameters<typeof Message<P>>;
+export type MessageClassWithProps<P extends object> = Class<Message<P>, MessageConstructorParamsWithProps<P>> & ClassStatic<typeof Message<P>>;
+export type MessageConstructorParams<T extends AnyMessage> = MessageConstructorParamsWithProps<PropsOf<T>>;
+export type MessageClass<T extends AnyMessage> = Class<T, MessageConstructorParams<T>> & ClassStatic<typeof Message<PropsOf<T>>>;
+export type AnyMessageClass = Class<AnyMessage>;

package/dist/base/message.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Message = void 0;
+const message_1 = require("../metadata/message");
+const props_envelope_1 = require("./props-envelope");
+class Message extends props_envelope_1.PropsEnvelope {
+    constructor(metadata, props) {
+        super(props);
+        this._id = metadata.id;
+        this._timestamp = metadata.timestamp;
+        this._aggregateType = metadata.aggregateType;
+        this._correlationId = metadata === null || metadata === void 0 ? void 0 : metadata.correlationId;
+        this._causationId = metadata === null || metadata === void 0 ? void 0 : metadata.causationId;
+    }
+    static aggregateType() {
+        return (0, message_1.getMessageAggregateType)(this.prototype);
+    }
+    get id() {
+        return this._id;
+    }
+    get timestamp() {
+        return this._timestamp;
+    }
+    get aggregateType() {
+        return this._aggregateType;
+    }
+    get correlationId() {
+        return this._correlationId;
+    }
+    get causationId() {
+        return this._causationId;
+    }
+    setCorrelationId(correlationId) {
+        if (!this.correlationId)
+            this._correlationId = correlationId;
+    }
+    setCausationId(causationId) {
+        if (!this.causationId)
+            this._causationId = causationId;
+    }
+}
+exports.Message = Message;

package/dist/base/value-object.d.ts

@@ -13,4 +13,4 @@ export type ValueObjectConstructorParamsWithProps<P extends object> = Constructo
 export type ValueObjectClassWithProps<P extends object> = Class<ValueObject<P>, ValueObjectConstructorParamsWithProps<P>> & ClassStatic<typeof ValueObject<P>>;
 export type ValueObjectConstructorParams<T extends AnyValueObject> = ValueObjectConstructorParamsWithProps<PropsOf<T>>;
 export type ValueObjectClass<T extends AnyValueObject> = Class<T, ValueObjectConstructorParams<T>> & ClassStatic<typeof ValueObject<PropsOf<T>>>;
-export type AnyValueObjectClass = ValueObjectClass<AnyValueObject>;
+export type AnyValueObjectClass = Class<AnyValueObject>;

package/dist/decorators/command.d.ts

@@ -1,2 +1,2 @@
 import { AnyCommand, CommandClass } from "../base/command";
-export declare const TypeCommand: <T extends AnyCommand>(commandType?: string) => <U extends CommandClass<T>>(target: U) => void;
+export declare const TypeCommand: <T extends AnyCommand>(aggregateType: string, commandType?: string) => <U extends CommandClass<T>>(target: U) => void;

package/dist/decorators/command.js

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeCommand = void 0;
 const command_1 = require("../metadata/command");
-const TypeCommand = (commandType) => {
+const message_1 = require("./message");
+const TypeCommand = (aggregateType, commandType) => {
     return (target) => {
+        (0, message_1.TypeMessage)(aggregateType)(target);
         commandType = commandType !== null && commandType !== void 0 ? commandType : target.name;
         (0, command_1.defineCommandType)(target.prototype, commandType);
         command_1.CommandRegistry.register(commandType, target);

package/dist/decorators/event.d.ts

@@ -1,2 +1,2 @@
 import { AnyEvent, EventClass } from "../base/event";
-export declare const TypeEvent: <T extends AnyEvent>(eventType?: string) => <U extends EventClass<T>>(target: U) => void;
+export declare const TypeEvent: <T extends AnyEvent>(aggregateType: string, eventType?: string) => <U extends EventClass<T>>(target: U) => void;

package/dist/decorators/event.js

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeEvent = void 0;
 const event_1 = require("../metadata/event");
-const TypeEvent = (eventType) => {
+const message_1 = require("./message");
+const TypeEvent = (aggregateType, eventType) => {
     return (target) => {
+        (0, message_1.TypeMessage)(aggregateType)(target);
         eventType = eventType !== null && eventType !== void 0 ? eventType : target.name;
         (0, event_1.defineEventType)(target.prototype, eventType !== null && eventType !== void 0 ? eventType : target.name);
         event_1.EventRegistry.register(eventType, target);

package/dist/decorators/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./aggregate";
+export * from "./message";
 export * from "./entity";
 export * from "./command";
 export * from "./event";

package/dist/decorators/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./aggregate"), exports);
+__exportStar(require("./message"), exports);
 __exportStar(require("./entity"), exports);
 __exportStar(require("./command"), exports);
 __exportStar(require("./event"), exports);

package/dist/decorators/message.d.ts

@@ -0,0 +1,2 @@
+import { AnyMessageClass } from "../base/message";
+export declare const TypeMessage: (aggregateType: string) => <U extends AnyMessageClass>(target: U) => void;

package/dist/decorators/message.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeMessage = void 0;
+const message_1 = require("../metadata/message");
+const TypeMessage = (aggregateType) => {
+    return (target) => {
+        (0, message_1.defineMessageAggregateType)(target.prototype, aggregateType);
+    };
+};
+exports.TypeMessage = TypeMessage;

package/dist/metadata/constants.d.ts

@@ -3,5 +3,6 @@ export declare const ENTITY_TYPE = "__entity_type__";
 export declare const VALUE_OBJECT_TYPE = "__value_object_type__";
 export declare const EVENT_TYPE = "__event_type__";
 export declare const COMMAND_TYPE = "__command_type__";
+export declare const MESSAGE_AGGREGATE_TYPE = "__message_aggregate_type__";
 export declare const AGGREGATE_EVENTS_APPLIERS = "__aggregate_events_appliers__";
 export declare const AGGREGATE_COMMANDS_HANDLERS = "__aggregate_commands_handlers__";

package/dist/metadata/constants.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AGGREGATE_COMMANDS_HANDLERS = exports.AGGREGATE_EVENTS_APPLIERS = exports.COMMAND_TYPE = exports.EVENT_TYPE = exports.VALUE_OBJECT_TYPE = exports.ENTITY_TYPE = exports.AGGREGATE_TYPE = void 0;
+exports.AGGREGATE_COMMANDS_HANDLERS = exports.AGGREGATE_EVENTS_APPLIERS = exports.MESSAGE_AGGREGATE_TYPE = exports.COMMAND_TYPE = exports.EVENT_TYPE = exports.VALUE_OBJECT_TYPE = exports.ENTITY_TYPE = exports.AGGREGATE_TYPE = void 0;
 exports.AGGREGATE_TYPE = "__aggregate_type__";
 exports.ENTITY_TYPE = "__entity_type__";
 exports.VALUE_OBJECT_TYPE = "__value_object_type__";
 exports.EVENT_TYPE = "__event_type__";
 exports.COMMAND_TYPE = "__command_type__";
+exports.MESSAGE_AGGREGATE_TYPE = "__message_aggregate_type__";
 exports.AGGREGATE_EVENTS_APPLIERS = "__aggregate_events_appliers__";
 exports.AGGREGATE_COMMANDS_HANDLERS = "__aggregate_commands_handlers__";

package/dist/metadata/event.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEventType = exports.defineEventType = exports.EventRegistry = void 0;
 require("reflect-metadata");
 const constants_1 = require("./constants");
-const registry_1 = require("./registry");
 const errors_1 = require("./errors");
+const registry_1 = require("./registry");
 exports.EventRegistry = new registry_1.Registry();
 const defineEventType = (target, eventType) => {
     Reflect.defineMetadata(constants_1.EVENT_TYPE, eventType, target);

package/dist/metadata/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./constants";
 export * from "./aggregate";
+export * from "./message";
 export * from "./command";
 export * from "./event";
 export * from "./entity";

package/dist/metadata/index.js

@@ -16,6 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./constants"), exports);
 __exportStar(require("./aggregate"), exports);
+__exportStar(require("./message"), exports);
 __exportStar(require("./command"), exports);
 __exportStar(require("./event"), exports);
 __exportStar(require("./entity"), exports);

package/dist/metadata/message.d.ts

@@ -0,0 +1,3 @@
+import "reflect-metadata";
+export declare const defineMessageAggregateType: (target: object, aggregateType: string) => void;
+export declare const getMessageAggregateType: (target: object) => string;

package/dist/metadata/message.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMessageAggregateType = exports.defineMessageAggregateType = void 0;
+require("reflect-metadata");
+const constants_1 = require("./constants");
+const defineMessageAggregateType = (target, aggregateType) => {
+    Reflect.defineMetadata(constants_1.MESSAGE_AGGREGATE_TYPE, aggregateType, target);
+};
+exports.defineMessageAggregateType = defineMessageAggregateType;
+const getMessageAggregateType = (target) => {
+    const aggregateType = Reflect.getMetadata(constants_1.MESSAGE_AGGREGATE_TYPE, target);
+    if (!aggregateType)
+        throw new Error();
+    return aggregateType;
+};
+exports.getMessageAggregateType = getMessageAggregateType;

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "ddd-node",
-  "version": "4.0.1",
+  "version": "5.0.0",
   "description": "Domain Driven Design base for NodeJs",
   "main": "dist/index.js",
   "scripts": {
     "build": "rm -rf dist && tsc --project tsconfig.build.json && tsc-alias -p tsconfig.build.json",
-    "example": "ts-node -r tsconfig-paths/register test/example/index.ts"
+    "example": "ts-node -r tsconfig-paths/register test/example/main.ts"
   },
   "repository": {
     "type": "git",