ddd-node 21.0.2 → 22.0.0

package/dist/core/index.js

@@ -14,12 +14,12 @@ 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("./value-object"), exports);
+__exportStar(require("./enum"), exports);
 __exportStar(require("./id"), exports);
-__exportStar(require("./model-with-id"), exports);
+__exportStar(require("./identifiable-model"), exports);
 __exportStar(require("./entity"), exports);
 __exportStar(require("./aggregate"), exports);
 __exportStar(require("./message"), exports);
-__exportStar(require("./enum"), exports);
-__exportStar(require("./value-object"), exports);
 __exportStar(require("./repository"), exports);
 __exportStar(require("./event-pubsub"), exports);

package/dist/core/message/command/command-model.metadata.d.ts

@@ -0,0 +1,6 @@
+import { AnyCommand } from "./command";
+import { CommandType } from "../../../meta";
+import { IModelMetadata } from "../../../model";
+export interface ICommandModelMetadata<T extends AnyCommand> extends IModelMetadata<T> {
+    commandType: CommandType;
+}

package/dist/core/message/command/command-model.metadata.js

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

package/dist/core/message/command/command.builder.js

@@ -8,13 +8,13 @@ class CommandBuilder extends message_base_1.MessageBuilderBase {
         this.commandClass = commandClass;
     }
     build() {
-        if (!this._props)
+        if (!this.props)
             throw new Error();
         return new this.commandClass({
-            id: this.getId(),
-            timestamp: this.getTimestamp(),
-            context: this._context,
-        }, this._props);
+            id: this.id,
+            timestamp: this.timestamp,
+            context: this.context,
+        }, this.props);
     }
 }
 exports.CommandBuilder = CommandBuilder;

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

@@ -2,18 +2,13 @@ import { Class } from "type-fest";
 import { Props, PropsOf } from "../../../model";
 import { ClassStatic } from "../../../types";
 import { MessageBase, MessageMetadata } from "../message-base";
-export declare class CommandModelMetadata {
-    private commandClass;
-    constructor(commandClass: CommandClass);
-    get commandType(): string;
-}
-export interface CommandMetadata extends Omit<MessageMetadata, "messageType"> {
+import { ICommandModelMetadata } from "./command-model.metadata";
+export interface CommandMetadata extends MessageMetadata {
 }
 export declare class CommandBase<P extends Props> extends MessageBase<P> {
-    static readonly COMMAND_MESSAGE_TYPE = "command";
+    static commandType(): string;
     constructor(metadata: CommandMetadata, props: P);
-    static commandModelMetadata<T extends AnyCommand>(this: CommandClass<T>): CommandModelMetadata;
-    commandModelMetadata(): CommandModelMetadata;
+    modelMetadata(): ICommandModelMetadata<typeof this>;
 }
 export type AnyCommand = CommandBase<Props>;
 export interface CommandClass<T extends AnyCommand = AnyCommand, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof CommandBase<PropsOf<T>>> {

package/dist/core/message/command/command.js

@@ -1,27 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommandBase = exports.CommandModelMetadata = void 0;
+exports.CommandBase = void 0;
 const meta_1 = require("../../../meta");
 const message_base_1 = require("../message-base");
-class CommandModelMetadata {
-    constructor(commandClass) {
-        this.commandClass = commandClass;
-    }
-    get commandType() {
-        return (0, meta_1.getCommandType)(this.commandClass);
-    }
-}
-exports.CommandModelMetadata = CommandModelMetadata;
 class CommandBase extends message_base_1.MessageBase {
-    constructor(metadata, props) {
-        super({ ...metadata, messageType: CommandBase.COMMAND_MESSAGE_TYPE }, props);
+    static commandType() {
+        return (0, meta_1.getCommandType)(this);
     }
-    static commandModelMetadata() {
-        return new CommandModelMetadata(this);
+    constructor(metadata, props) {
+        super(metadata, props);
     }
-    commandModelMetadata() {
-        return this.constructor.commandModelMetadata();
+    modelMetadata() {
+        const commandClass = this.constructor;
+        return {
+            ...super.modelMetadata(),
+            commandType: commandClass.commandType(),
+        };
     }
 }
 exports.CommandBase = CommandBase;
-CommandBase.COMMAND_MESSAGE_TYPE = "command";

package/dist/core/message/command/index.d.ts

@@ -1,2 +1,3 @@
+export * from "./command-model.metadata";
 export * from "./command";
 export * from "./command.builder";

package/dist/core/message/command/index.js

@@ -14,5 +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("./command-model.metadata"), exports);
 __exportStar(require("./command"), exports);
 __exportStar(require("./command.builder"), exports);

package/dist/core/message/event/event-model.metadata.d.ts

@@ -0,0 +1,5 @@
+import { AnyEvent } from ".";
+import { IModelMetadata } from "../../../model";
+export interface IEventModelMetadata<T extends AnyEvent> extends IModelMetadata<T> {
+    eventType: string;
+}

package/dist/core/message/event/event-model.metadata.js

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

package/dist/core/message/event/event.builder.d.ts

@@ -2,7 +2,7 @@ import { AnyEvent, EventClassWithTypedConstructor, EventSource } from "./event";
 import { MessageBuilderBase } from "../message-base";
 export declare class EventBuilder<T extends AnyEvent> extends MessageBuilderBase<T> {
     private eventClass;
-    protected _source?: EventSource;
+    protected source?: EventSource;
     constructor(eventClass: EventClassWithTypedConstructor<T>);
     withSource(source: EventSource): this;
     build(): T;

package/dist/core/message/event/event.builder.js

@@ -8,20 +8,20 @@ class EventBuilder extends message_base_1.MessageBuilderBase {
         this.eventClass = eventClass;
     }
     withSource(source) {
-        this._source = source;
+        this.source = source;
         return this;
     }
     build() {
-        if (!this._source)
+        if (!this.source)
             throw new Error("The event source must be set before build");
-        if (!this._props)
+        if (!this.props)
             throw new Error("The props must be set before build");
         return new this.eventClass({
-            id: this.getId(),
-            timestamp: this.getTimestamp(),
-            source: this._source,
-            context: this._context,
-        }, this._props);
+            id: this.id,
+            timestamp: this.timestamp,
+            source: this.source,
+            context: this.context,
+        }, this.props);
     }
 }
 exports.EventBuilder = EventBuilder;

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

@@ -1,29 +1,24 @@
 import { Class } from "type-fest";
-import { ModelId, Props, PropsOf } from "../../../model";
+import { EventType } from "../../../meta";
+import { Props, PropsOf } from "../../../model";
 import { ClassStatic } from "../../../types";
 import { Id } from "../../id";
 import { MessageBase, MessageMetadata } from "../message-base";
-export declare class EventModelMetadata {
-    private eventClass;
-    constructor(eventClass: EventClass);
-    get eventType(): string;
-}
+import { IEventModelMetadata } from "./event-model.metadata";
 export type EventSource = Readonly<{
-    aggregateModelId: ModelId;
     aggregateId: Id;
     aggregateVersion: number;
 }>;
-export interface EventMetadata extends Omit<MessageMetadata, "messageType"> {
+export interface EventMetadata extends MessageMetadata {
     source: EventSource;
 }
 export declare class EventBase<P extends Props> extends MessageBase<P> {
-    static readonly EVENT_MESSAGE_TYPE = "event";
     private readonly _source;
     constructor(metadata: EventMetadata, props: P);
-    static eventModelMetadata<T extends AnyEvent>(this: EventClass<T>): EventModelMetadata;
-    eventModelMetadata(): EventModelMetadata;
+    static eventType(): EventType;
+    modelMetadata(): IEventModelMetadata<typeof this>;
+    metadata(): EventMetadata;
     source(): Readonly<{
-        aggregateModelId: string;
         aggregateId: Id;
         aggregateVersion: number;
     }>;

package/dist/core/message/event/event.js

@@ -1,31 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventBase = exports.EventModelMetadata = void 0;
+exports.EventBase = void 0;
 const meta_1 = require("../../../meta");
 const message_base_1 = require("../message-base");
-class EventModelMetadata {
-    constructor(eventClass) {
-        this.eventClass = eventClass;
-    }
-    get eventType() {
-        return (0, meta_1.getEventType)(this.eventClass);
-    }
-}
-exports.EventModelMetadata = EventModelMetadata;
 class EventBase extends message_base_1.MessageBase {
     constructor(metadata, props) {
-        super({ ...metadata, messageType: EventBase.EVENT_MESSAGE_TYPE }, props);
+        super(metadata, props);
         this._source = metadata.source;
     }
-    static eventModelMetadata() {
-        return new EventModelMetadata(this);
+    static eventType() {
+        return (0, meta_1.getEventType)(this);
+    }
+    modelMetadata() {
+        const eventClass = this.constructor;
+        return {
+            ...super.modelMetadata(),
+            eventType: eventClass.eventType(),
+        };
     }
-    eventModelMetadata() {
-        return this.constructor.eventModelMetadata();
+    metadata() {
+        return {
+            ...super.metadata(),
+            source: this._source,
+        };
     }
     source() {
         return this._source;
     }
 }
 exports.EventBase = EventBase;
-EventBase.EVENT_MESSAGE_TYPE = "event";

package/dist/core/message/event/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./event";
+export * from "./event-model.metadata";
 export * from "./event.builder";

package/dist/core/message/event/index.js

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

package/dist/core/message/message-base/message.builder.d.ts

@@ -1,13 +1,11 @@
-import { ModelWithIdBuilder } from "../../model-with-id";
+import { IdentifiableModelBuilder } from "../../identifiable-model";
 import { AnyMessage, MessageClassWithTypedConstructor, MessageContext } from "./message";
-export declare abstract class MessageBuilderBase<T extends AnyMessage> extends ModelWithIdBuilder<T> {
-    protected _messageType?: string;
-    protected _context?: MessageContext;
-    protected _timestamp?: number;
-    getTimestamp(): number;
-    withMessageType(messageType: string): this;
+export declare abstract class MessageBuilderBase<T extends AnyMessage> extends IdentifiableModelBuilder<T> {
+    protected timestamp: number;
+    protected context?: MessageContext;
     withContext(context: MessageContext): this;
     withTimestamp(timestamp: number): this;
+    withTimestampNow(): this;
 }
 export declare class MessageBuilder<T extends AnyMessage> extends MessageBuilderBase<T> {
     private messageClass;

package/dist/core/message/message-base/message.builder.js

@@ -1,27 +1,23 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessageBuilder = exports.MessageBuilderBase = void 0;
-const lodash_1 = __importDefault(require("lodash"));
-const model_with_id_1 = require("../../model-with-id");
-class MessageBuilderBase extends model_with_id_1.ModelWithIdBuilder {
-    getTimestamp() {
-        return !lodash_1.default.isUndefined(this._timestamp) ? this._timestamp : Date.now();
-    }
-    withMessageType(messageType) {
-        this._messageType = messageType;
-        return this;
+const identifiable_model_1 = require("../../identifiable-model");
+class MessageBuilderBase extends identifiable_model_1.IdentifiableModelBuilder {
+    constructor() {
+        super(...arguments);
+        this.timestamp = Date.now();
     }
     withContext(context) {
-        this._context = context;
+        this.context = context;
         return this;
     }
     withTimestamp(timestamp) {
-        this._timestamp = timestamp;
+        this.timestamp = timestamp;
         return this;
     }
+    withTimestampNow() {
+        return this.withTimestamp(Date.now());
+    }
 }
 exports.MessageBuilderBase = MessageBuilderBase;
 class MessageBuilder extends MessageBuilderBase {
@@ -30,16 +26,13 @@ class MessageBuilder extends MessageBuilderBase {
         this.messageClass = messageClass;
     }
     build() {
-        if (!this._messageType)
-            throw new Error("The message type must be set before build");
-        if (!this._props)
+        if (!this.props)
             throw new Error("The props must be set before build");
         return new this.messageClass({
-            messageType: this._messageType,
-            id: this.getId(),
-            context: this._context,
-            timestamp: this.getTimestamp(),
-        }, this._props);
+            id: this.id,
+            context: this.context,
+            timestamp: this.timestamp,
+        }, this.props);
     }
 }
 exports.MessageBuilder = MessageBuilder;

package/dist/core/message/message-base/message.d.ts

@@ -1,25 +1,21 @@
 import { Class } from "type-fest";
 import { Props, PropsOf } from "../../../model";
 import { ClassStatic } from "../../../types";
-import { Id } from "../../id";
-import { ModelWithId } from "../../model-with-id";
+import { IdentifiableModel, IdentifiableModelMetadata } from "../../identifiable-model";
 export interface MessageContext {
     correlationId?: string;
     causationId?: string;
 }
-export interface MessageMetadata {
-    readonly id: Id;
-    readonly messageType: string;
-    readonly timestamp: number;
+export interface MessageMetadata extends IdentifiableModelMetadata {
+    timestamp: number;
     context?: MessageContext;
 }
-export declare class MessageBase<P extends Props> extends ModelWithId<P> {
-    private readonly _messageType;
+export declare class MessageBase<P extends Props> extends IdentifiableModel<P> {
     private readonly _timestamp;
     private _context?;
     constructor(metadata: MessageMetadata, props: P);
     props(): P;
-    messageType(): string;
+    metadata(): MessageMetadata;
     timestamp(): number;
     context(): MessageContext | undefined;
     setContext(context: Partial<MessageContext>): void;

package/dist/core/message/message-base/message.js

@@ -15,11 +15,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessageBase = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 const model_1 = require("../../../model");
-const model_with_id_1 = require("../../model-with-id");
-let MessageBase = class MessageBase extends model_with_id_1.ModelWithId {
+const identifiable_model_1 = require("../../identifiable-model");
+let MessageBase = class MessageBase extends identifiable_model_1.IdentifiableModel {
     constructor(metadata, props) {
-        super(metadata.id);
-        this._messageType = metadata.messageType;
+        super(metadata);
         this._context = metadata?.context ?? {};
         this._timestamp = metadata.timestamp;
         this.initializeProps(props);
@@ -27,8 +26,12 @@ let MessageBase = class MessageBase extends model_with_id_1.ModelWithId {
     props() {
         return super.props();
     }
-    messageType() {
-        return this._messageType;
+    metadata() {
+        return {
+            ...super.metadata(),
+            timestamp: this._timestamp,
+            context: this._context,
+        };
     }
     timestamp() {
         return this._timestamp;

package/dist/core/value-object/value-object.builder.js

@@ -8,9 +8,9 @@ class ValueObjectBuilder extends model_1.ModelBuilder {
         this.valueObjectClass = valueObjectClass;
     }
     build() {
-        if (!this._props)
+        if (!this.props)
             throw new Error("The props must be set before build");
-        return new this.valueObjectClass(this._props);
+        return new this.valueObjectClass(this.props);
     }
 }
 exports.ValueObjectBuilder = ValueObjectBuilder;

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

@@ -5,7 +5,7 @@ export declare class ValueObjectBase<P extends Props> extends ModelBase<P> {
     constructor(props: P);
     props(): P;
     equals<V extends AnyValueObject>(vo: V): boolean;
-    with(props: Partial<P>): this;
+    with(props: Partial<P>): typeof this;
 }
 export type AnyValueObject = ValueObjectBase<Props>;
 export interface ValueObjectClass<T extends AnyValueObject = AnyValueObject> extends Class<T>, ClassStatic<typeof ValueObjectBase<PropsOf<T>>> {

package/dist/decorators/aggregate-es/handle.js

@@ -5,7 +5,7 @@ const meta_1 = require("../../meta");
 const Handle = (commandClass) => {
     return (target, propertyKey, descriptor) => {
         if (typeof descriptor.value === "function") {
-            const { commandType } = commandClass.commandModelMetadata();
+            const commandType = commandClass.commandType();
             (0, meta_1.defineCommandHandler)(target, commandType, descriptor.value);
         }
     };

package/dist/decorators/aggregate-es/when.js

@@ -5,7 +5,7 @@ const meta_1 = require("../../meta");
 const When = (eventClass) => {
     return (target, propertyKey, descriptor) => {
         if (typeof descriptor.value === "function") {
-            const { eventType } = eventClass.eventModelMetadata();
+            const eventType = eventClass.eventType();
             (0, meta_1.defineEventApplier)(target, eventType, descriptor.value);
         }
     };

package/dist/meta/index.d.ts

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

package/dist/meta/index.js

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

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

@@ -1,2 +1,3 @@
 export * from "./model";
+export * from "./model-metadata";
 export * from "./model.builder";

package/dist/model/core/index.js

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

package/dist/model/core/model-metadata.d.ts

@@ -0,0 +1,13 @@
+import { AnyModel } from "./model";
+import { ModelId, ModelName, ModelVersion, PropsMap, PropsValidator, StaticValuesMap } from "../meta";
+export interface IModelMetadata<T extends AnyModel = AnyModel> {
+    modelMutable: boolean;
+    modelId: ModelId;
+    modelName: ModelName;
+    modelVersion: ModelVersion;
+    ownPropsValidator?: PropsValidator<T>;
+    propsValidators: PropsValidator[];
+    ownStaticValues: StaticValuesMap<T>;
+    ownPropsMap: PropsMap<T>;
+    propsMap: PropsMap<T>;
+}

package/dist/model/core/model-metadata.js

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

package/dist/model/core/model.builder.d.ts

@@ -4,7 +4,7 @@ export interface IModelBuilder<T extends AnyModel = AnyModel> {
     build(): T;
 }
 export declare abstract class ModelBuilder<T extends AnyModel = AnyModel> implements IModelBuilder<T> {
-    protected _props?: PropsOf<T>;
+    protected props?: PropsOf<T>;
     withProps(props: PropsOf<T>): this;
     abstract build(): T;
     buildSafe(): T | null;

package/dist/model/core/model.builder.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModelBuilder = void 0;
 class ModelBuilder {
     withProps(props) {
-        this._props = props;
+        this.props = props;
         return this;
     }
     buildSafe() {

package/dist/model/core/model.d.ts

@@ -1,38 +1,35 @@
 import { Class } from "type-fest";
 import { ModelId, ModelName, ModelVersion, PropsMap, PropsValidator, StaticValuesMap } from "../meta";
 import { ClassStatic } from "../../types";
+import { IModelMetadata } from "./model-metadata";
 export interface Props {
     [key: PropertyKey]: any;
 }
 export type EmptyProps = {
     [key: PropertyKey]: never;
 };
-export declare class ModelMetadata<T extends AnyModel = AnyModel> {
-    private modelClass;
-    constructor(modelClass: ModelClass<T>);
-    get modelMutable(): boolean;
-    get modelName(): ModelName;
-    get modelVersion(): ModelVersion;
-    get modelId(): ModelId;
-    get ownPropsValidator(): PropsValidator<T> | undefined;
-    get propsValidators(): PropsValidator[];
-    get ownStaticValues(): StaticValuesMap<T>;
-    get ownPropsMap(): PropsMap<T>;
-    get propsMap(): PropsMap<T>;
-}
 export declare class ModelBase<P extends Props> {
     static readonly EMPTY_PROPS: EmptyProps;
     protected _props: P;
     static isModel(model: any): model is AnyModel;
-    static modelMetadata<T extends AnyModel>(this: ModelClass<T>): ModelMetadata<T>;
+    static modelMutable<T extends AnyModel>(this: ModelClass<T>): boolean;
+    static modelName<T extends AnyModel>(this: ModelClass<T>): ModelName;
+    static modelVersion<T extends AnyModel>(this: ModelClass<T>): ModelVersion;
+    static modelId<T extends AnyModel>(this: ModelClass<T>): ModelId;
+    static ownPropsValidator<T extends AnyModel>(this: ModelClass<T>): PropsValidator<T> | undefined;
+    static propsValidators<T extends AnyModel>(this: ModelClass<T>): PropsValidator[];
+    static ownStaticValues<T extends AnyModel>(this: ModelClass<T>): StaticValuesMap<T>;
+    static ownPropsMap<T extends AnyModel>(this: ModelClass<T>): PropsMap<T>;
+    static propsMap<T extends AnyModel>(this: ModelClass<T>): PropsMap<T>;
     constructor();
     redefineModel(): void;
     protected redefineProp(key: keyof this, propTargetKey: keyof P): void;
-    modelMetadata(): ModelMetadata<typeof this>;
+    modelMetadata(): IModelMetadata<typeof this>;
     validateProps(props: P): void;
     validate(): void;
     propsIsEmpty(): boolean;
     props(): P | null;
+    metadata(): {};
     protected initializeProps(props: P): void;
 }
 export type AnyModel = ModelBase<Props>;