ddd-node 17.3.0 → 20.0.0

package/dist/core/enum/enum.d.ts

@@ -0,0 +1,21 @@
+import { Class } from "type-fest";
+import { ModelBase } from "../../model";
+import { ClassStatic } from "../../types";
+export type EnumValue = string | number;
+export interface EnumProps {
+    value: EnumValue;
+}
+export declare class EnumBase extends ModelBase<EnumProps> {
+    static values(): EnumBase[];
+    static parse<T extends AnyEnum>(this: EnumClass<T>, providedValue: EnumValue): T;
+    static parseSafe<T extends AnyEnum>(this: EnumClass<T>, providedValue: EnumValue): T | null;
+    constructor(value: EnumValue);
+    props(): EnumProps;
+    get value(): EnumValue;
+    equals<T extends AnyEnum>(other: T): boolean;
+}
+export type AnyEnum = EnumBase;
+export interface EnumClass<T extends AnyEnum = AnyEnum, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof EnumBase> {
+}
+export interface EnumClassWithTypedConstructor<T extends AnyEnum = AnyEnum> extends EnumClass<T, ConstructorParameters<typeof EnumBase>> {
+}

package/dist/core/enum/enum.js

@@ -0,0 +1,60 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumBase = void 0;
+const model_1 = require("../../model");
+let EnumBase = class EnumBase extends model_1.ModelBase {
+    static values() {
+        return Array.from(this.modelMetadata().ownStaticValues.values()).map((staticValue) => staticValue.value);
+    }
+    static parse(providedValue) {
+        let result = undefined;
+        this.modelMetadata().ownStaticValues.forEach((staticValue) => {
+            if (staticValue.value instanceof this) {
+                const staticEnum = staticValue.value;
+                if (staticEnum.value === providedValue && !result) {
+                    result = staticEnum;
+                }
+            }
+        });
+        if (!result)
+            throw new Error(`Invalid provided value for enum ${this.modelMetadata().modelName}`);
+        return result;
+    }
+    static parseSafe(providedValue) {
+        try {
+            return this.parse(providedValue);
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    constructor(value) {
+        super();
+        this.initializeProps({ value });
+    }
+    props() {
+        return super.props();
+    }
+    get value() {
+        return this._props.value;
+    }
+    equals(other) {
+        const equalType = other instanceof this.constructor;
+        const equalValue = other.value === this.value;
+        return equalType && equalValue;
+    }
+};
+exports.EnumBase = EnumBase;
+exports.EnumBase = EnumBase = __decorate([
+    (0, model_1.Mutable)(false),
+    __metadata("design:paramtypes", [Object])
+], EnumBase);

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

@@ -0,0 +1,2 @@
+export * from "./enum";
+export * from "./enum.builder";

package/dist/{meta/helpers → core/enum}/index.js

@@ -14,4 +14,5 @@ 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("./static-value"), exports);
+__exportStar(require("./enum"), exports);
+__exportStar(require("./enum.builder"), exports);

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

@@ -1,3 +1,3 @@
 export * from "./interface";
 export * from "./id";
-export * from "./common";
+export * from "./services";

package/dist/core/id/index.js

@@ -16,4 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./interface"), exports);
 __exportStar(require("./id"), exports);
-__exportStar(require("./common"), exports);
+__exportStar(require("./services"), exports);

package/dist/core/index.d.ts

@@ -1,10 +1,9 @@
-export * from "./model";
 export * from "./id";
-export * from "./aggregate";
+export * from "./model-with-id";
 export * from "./entity";
-export * from "./enum";
+export * from "./aggregate";
 export * from "./message";
+export * from "./enum";
 export * from "./value-object";
 export * from "./repository";
-export * from "./domain";
 export * from "./event-pubsub";

package/dist/core/index.js

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

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

@@ -0,0 +1,7 @@
+import { AnyCommand, CommandClassWithTypedConstructor } from "./command";
+import { MessageBuilderBase } from "../message-base";
+export declare class CommandBuilder<T extends AnyCommand> extends MessageBuilderBase<T> {
+    private commandClass;
+    constructor(commandClass: CommandClassWithTypedConstructor<T>);
+    build(): T;
+}

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandBuilder = void 0;
+const message_base_1 = require("../message-base");
+class CommandBuilder extends message_base_1.MessageBuilderBase {
+    constructor(commandClass) {
+        super();
+        this.commandClass = commandClass;
+    }
+    build() {
+        if (!this._props)
+            throw new Error();
+        return new this.commandClass({
+            id: this.getId(),
+            timestamp: this.getTimestamp(),
+            context: this._context,
+        }, this._props);
+    }
+}
+exports.CommandBuilder = CommandBuilder;

package/dist/core/message/{command.d.ts → command/command.d.ts}

@@ -1,16 +1,19 @@
-import { ClassStatic } from "../../types";
 import { Class } from "type-fest";
-import { Props, PropsOf } from "../model";
-import { MessageBase, MessageContext, MessageMetadata } from "./message";
-import { CommandType } from "../../meta";
+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"> {
 }
 export declare class CommandBase<P extends Props> extends MessageBase<P> {
     static readonly COMMAND_MESSAGE_TYPE = "command";
     constructor(metadata: CommandMetadata, props: P);
-    static commandType(): CommandType;
-    static newCommand<T extends AnyCommand>(this: CommandClassWithTypedConstructor<T>, props: PropsOf<T>, context?: MessageContext, timestamp?: number): T;
-    commandType(): string;
+    static commandModelMetadata<T extends AnyCommand>(this: CommandClass<T>): CommandModelMetadata;
+    commandModelMetadata(): CommandModelMetadata;
 }
 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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandBase = exports.CommandModelMetadata = 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 commandModelMetadata() {
+        return new CommandModelMetadata(this);
+    }
+    commandModelMetadata() {
+        return this.constructor.commandModelMetadata();
+    }
+}
+exports.CommandBase = CommandBase;
+CommandBase.COMMAND_MESSAGE_TYPE = "command";

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

@@ -0,0 +1,2 @@
+export * from "./command";
+export * from "./command.builder";

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

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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"), exports);
+__exportStar(require("./command.builder"), exports);

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

@@ -0,0 +1,9 @@
+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;
+    constructor(eventClass: EventClassWithTypedConstructor<T>);
+    withSource(source: EventSource): this;
+    build(): T;
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBuilder = void 0;
+const message_base_1 = require("../message-base");
+class EventBuilder extends message_base_1.MessageBuilderBase {
+    constructor(eventClass) {
+        super();
+        this.eventClass = eventClass;
+    }
+    withSource(source) {
+        this._source = source;
+        return this;
+    }
+    build() {
+        if (!this._source)
+            throw new Error("The event source must be set before build");
+        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);
+    }
+}
+exports.EventBuilder = EventBuilder;

package/dist/core/message/{event.d.ts → event/event.d.ts}

@@ -1,11 +1,15 @@
-import { ClassStatic } from "../../types";
 import { Class } from "type-fest";
-import { Id } from "../id";
-import { Props, PropsOf } from "../model";
-import { MessageBase, MessageContext, MessageMetadata } from "./message";
-import { EventType } from "../../meta";
+import { ModelId, 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;
+}
 export type EventSource = Readonly<{
-    aggregateModel: string;
+    aggregateModelId: ModelId;
     aggregateId: Id;
     aggregateVersion: number;
 }>;
@@ -16,14 +20,13 @@ 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 eventType(): EventType;
-    static newEvent<T extends AnyEvent>(this: EventClassWithTypedConstructor<T>, source: EventSource, props: PropsOf<T>, context?: MessageContext, timestamp?: number): T;
+    static eventModelMetadata<T extends AnyEvent>(this: EventClass<T>): EventModelMetadata;
+    eventModelMetadata(): EventModelMetadata;
     source(): Readonly<{
-        aggregateModel: string;
+        aggregateModelId: string;
         aggregateId: Id;
         aggregateVersion: number;
     }>;
-    eventType(): string;
 }
 export type AnyEvent = EventBase<Props>;
 export interface EventClass<T extends AnyEvent = AnyEvent, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof EventBase<PropsOf<T>>> {

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBase = exports.EventModelMetadata = 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);
+        this._source = metadata.source;
+    }
+    static eventModelMetadata() {
+        return new EventModelMetadata(this);
+    }
+    eventModelMetadata() {
+        return this.constructor.eventModelMetadata();
+    }
+    source() {
+        return this._source;
+    }
+}
+exports.EventBase = EventBase;
+EventBase.EVENT_MESSAGE_TYPE = "event";

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

@@ -0,0 +1,2 @@
+export * from "./event";
+export * from "./event.builder";

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

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./event"), exports);
+__exportStar(require("./event.builder"), exports);

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

@@ -1,3 +1,3 @@
-export * from "./message";
+export * from "./message-base";
 export * from "./command";
 export * from "./event";

package/dist/core/message/index.js

@@ -14,6 +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("./message"), exports);
+__exportStar(require("./message-base"), exports);
 __exportStar(require("./command"), exports);
 __exportStar(require("./event"), exports);

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

@@ -0,0 +1,2 @@
+export * from "./message";
+export * from "./message.builder";

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

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./message"), exports);
+__exportStar(require("./message.builder"), exports);

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

@@ -0,0 +1,16 @@
+import { ModelWithIdBuilder } from "../../model-with-id";
+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;
+    withContext(context: MessageContext): this;
+    withTimestamp(timestamp: number): this;
+}
+export declare class MessageBuilder<T extends AnyMessage> extends MessageBuilderBase<T> {
+    private messageClass;
+    constructor(messageClass: MessageClassWithTypedConstructor<T>);
+    build(): T;
+}

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

@@ -0,0 +1,45 @@
+"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;
+    }
+    withContext(context) {
+        this._context = context;
+        return this;
+    }
+    withTimestamp(timestamp) {
+        this._timestamp = timestamp;
+        return this;
+    }
+}
+exports.MessageBuilderBase = MessageBuilderBase;
+class MessageBuilder extends MessageBuilderBase {
+    constructor(messageClass) {
+        super();
+        this.messageClass = messageClass;
+    }
+    build() {
+        if (!this._messageType)
+            throw new Error("The message type must be set before build");
+        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);
+    }
+}
+exports.MessageBuilder = MessageBuilder;

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

@@ -0,0 +1,31 @@
+import { Class } from "type-fest";
+import { Props, PropsOf } from "../../../model";
+import { ClassStatic } from "../../../types";
+import { Id } from "../../id";
+import { ModelWithId } from "../../model-with-id";
+export interface MessageContext {
+    correlationId?: string;
+    causationId?: string;
+}
+export interface MessageMetadata {
+    readonly id: Id;
+    readonly messageType: string;
+    readonly timestamp: number;
+    context?: MessageContext;
+}
+export declare class MessageBase<P extends Props> extends ModelWithId<P> {
+    private readonly _messageType;
+    private readonly _timestamp;
+    private _context?;
+    constructor(metadata: MessageMetadata, props: P);
+    props(): P;
+    messageType(): string;
+    timestamp(): number;
+    context(): MessageContext | undefined;
+    setContext(context: Partial<MessageContext>): void;
+}
+export type AnyMessage = MessageBase<Props>;
+export interface MessageClass<T extends AnyMessage = AnyMessage, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof MessageBase<PropsOf<T>>> {
+}
+export interface MessageClassWithTypedConstructor<T extends AnyMessage = AnyMessage> extends MessageClass<T, ConstructorParameters<typeof MessageBase<PropsOf<T>>>> {
+}

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

@@ -0,0 +1,47 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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 {
+    constructor(metadata, props) {
+        super(metadata.id);
+        this._messageType = metadata.messageType;
+        this._context = metadata?.context ?? {};
+        this._timestamp = metadata.timestamp;
+        this.initializeProps(props);
+    }
+    props() {
+        return super.props();
+    }
+    messageType() {
+        return this._messageType;
+    }
+    timestamp() {
+        return this._timestamp;
+    }
+    context() {
+        return this._context;
+    }
+    setContext(context) {
+        this._context = lodash_1.default.merge(this._context, context);
+    }
+};
+exports.MessageBase = MessageBase;
+exports.MessageBase = MessageBase = __decorate([
+    (0, model_1.Mutable)(false),
+    __metadata("design:paramtypes", [Object, Object])
+], MessageBase);

package/dist/core/model-with-id/index.d.ts

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

package/dist/core/model-with-id/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./model-with-id"), exports);
+__exportStar(require("./model-with-id.builder"), exports);

package/dist/core/model-with-id/model-with-id.builder.d.ts

@@ -0,0 +1,11 @@
+import { ModelBuilder } from "../../model";
+import { IIdService, Id } from "../id";
+import { AnyModelWithId } from "./model-with-id";
+export declare abstract class ModelWithIdBuilder<T extends AnyModelWithId> extends ModelBuilder<T> {
+    protected _id?: Id;
+    protected _idService?: IIdService;
+    getIdService(): IIdService;
+    getId(): Id;
+    withId(id: Id): this;
+    withIdService(idService: IIdService): this;
+}

package/dist/core/model-with-id/model-with-id.builder.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelWithIdBuilder = void 0;
+const model_1 = require("../../model");
+const id_1 = require("../id");
+class ModelWithIdBuilder extends model_1.ModelBuilder {
+    getIdService() {
+        return this._idService ?? new id_1.Uuid4Service();
+    }
+    getId() {
+        return this._id ?? new id_1.Id(this.getIdService().generateValue());
+    }
+    withId(id) {
+        this._id = id;
+        return this;
+    }
+    withIdService(idService) {
+        this._idService = idService;
+        return this;
+    }
+}
+exports.ModelWithIdBuilder = ModelWithIdBuilder;

package/dist/core/{model → model-with-id}/model-with-id.d.ts

@@ -1,10 +1,8 @@
+import { ModelBase, Props } from "../../model";
 import { Id } from "../id";
-import { ModelBase, Props } from "./model";
 export declare class ModelWithId<P extends Props> extends ModelBase<P> {
     protected readonly _id: Id;
     constructor(id: Id);
-    static idService(): import("../id").IIdService;
-    static id(id?: Id | string): Id;
     id(): Id;
     hasId(id: Id): boolean;
 }