ddd-node 17.3.0 → 20.0.0

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

@@ -0,0 +1,7 @@
+import { EntityBuilderBase } from "../../entity";
+import { AnyAggregate } from "./aggregate";
+export declare abstract class AggregateBuilderBase<T extends AnyAggregate> extends EntityBuilderBase<T> {
+    protected _version?: number;
+    getVersion(): number;
+    withVersion(version: number): this;
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateBuilderBase = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const entity_1 = require("../../entity");
+class AggregateBuilderBase extends entity_1.EntityBuilderBase {
+    getVersion() {
+        return !lodash_1.default.isUndefined(this._version) ? this._version : 0;
+    }
+    withVersion(version) {
+        this._version = version;
+        return this;
+    }
+}
+exports.AggregateBuilderBase = AggregateBuilderBase;

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

@@ -0,0 +1,16 @@
+import { EntityBase, EntityMetadata } from "../../entity";
+import { Props, PropsOf } from "../../../model";
+import { AnyEvent, EventClassWithTypedConstructor, EventSource } from "../../message";
+import { IEventDispatcher } from "../event-dispatcher.interface";
+export interface AggregateMetadata extends EntityMetadata {
+    version: number;
+}
+export declare abstract class AggregateBase<P extends Props> extends EntityBase<P> {
+    protected readonly _version: number;
+    constructor(metadata: AggregateMetadata, props?: P);
+    abstract version(): number;
+    protected createEventSource(): EventSource;
+    protected newEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: PropsOf<E>): E;
+    abstract dispatchEvents(dispatcher: IEventDispatcher): void;
+}
+export type AnyAggregate = AggregateBase<Props>;

package/dist/core/aggregate/{base.js → aggregate-base/aggregate.js}

@@ -1,19 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AggregateBase = void 0;
-const entity_1 = require("../entity");
+const entity_1 = require("../../entity");
+const message_1 = require("../../message");
 class AggregateBase extends entity_1.EntityBase {
     constructor(metadata, props) {
         super(metadata, props);
         this._version = metadata.version;
     }
-    newEvent(eventClass, props) {
-        const eventSource = {
-            aggregateModel: this.modelName(),
+    createEventSource() {
+        return {
+            aggregateModelId: this.modelMetadata().modelId,
             aggregateId: this.id(),
             aggregateVersion: this.version(),
         };
-        return eventClass.newEvent(eventSource, props);
+    }
+    newEvent(eventClass, props) {
+        const eventBuilder = new message_1.EventBuilder(eventClass);
+        return eventBuilder
+            .withSource(this.createEventSource())
+            .withProps(props)
+            .build();
     }
 }
 exports.AggregateBase = AggregateBase;

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

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

package/dist/core/aggregate/aggregate-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("./aggregate"), exports);
+__exportStar(require("./aggregate.builder"), exports);

package/dist/core/aggregate/event-dispatcher.interface.d.ts

@@ -0,0 +1,4 @@
+import { AnyEvent } from "../message";
+export interface IEventDispatcher {
+    dispatch(event: AnyEvent): void;
+}

package/dist/core/aggregate/event-dispatcher.interface.js

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

package/dist/core/aggregate/event-sourced-aggregate/event-sourced-aggregate.builder.d.ts

@@ -0,0 +1,12 @@
+import { AnyEvent } from "../../message";
+import { AggregateBuilderBase } from "../aggregate-base";
+import { AnyEventSourcedAggregate, EventSourcedAggregateClassWithTypedConstructor, Snapshot } from "./event-sourced-aggregate";
+export declare class EventSourcedAggregateBuilder<T extends AnyEventSourcedAggregate> extends AggregateBuilderBase<T> {
+    private aggregateClass;
+    private _pastEvents?;
+    private _snapshot?;
+    constructor(aggregateClass: EventSourcedAggregateClassWithTypedConstructor<T>);
+    withPastEvents(pastEvents: AnyEvent[]): this;
+    withSnapshot(snapshot: Snapshot<T>): this;
+    build(): T;
+}

package/dist/core/aggregate/event-sourced-aggregate/event-sourced-aggregate.builder.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSourcedAggregateBuilder = void 0;
+const aggregate_base_1 = require("../aggregate-base");
+class EventSourcedAggregateBuilder extends aggregate_base_1.AggregateBuilderBase {
+    constructor(aggregateClass) {
+        super();
+        this.aggregateClass = aggregateClass;
+    }
+    withPastEvents(pastEvents) {
+        this._pastEvents = pastEvents;
+        return this;
+    }
+    withSnapshot(snapshot) {
+        this._snapshot = snapshot;
+        return this;
+    }
+    build() {
+        if (this._snapshot) {
+            const { id, version } = this._snapshot.metadata;
+            const { props } = this._snapshot;
+            this.withId(id).withVersion(version).withProps(props);
+        }
+        const instance = new this.aggregateClass({
+            id: this.getId(),
+            version: this.getVersion(),
+        }, this._props);
+        if (this._pastEvents) {
+            const pastEvents = this._pastEvents.filter((_pastEvent) => _pastEvent.source().aggregateVersion >= instance.version());
+            instance.applyPastEvents(pastEvents);
+        }
+        return instance;
+    }
+}
+exports.EventSourcedAggregateBuilder = EventSourcedAggregateBuilder;

package/dist/core/aggregate/{event-sourced-aggregate.d.ts → event-sourced-aggregate/event-sourced-aggregate.d.ts}

@@ -1,9 +1,10 @@
 import { Class } from "type-fest";
-import { ClassStatic } from "../../types";
-import { Id } from "../id";
-import { AnyCommand, AnyEvent, EventClassWithTypedConstructor } from "../message";
-import { Props, PropsOf } from "../model";
-import { AggregateBase, AggregateMetadata } from "./base";
+import { Props, PropsOf } from "../../../model";
+import { ClassStatic } from "../../../types";
+import { AnyCommand, AnyEvent, EventClassWithTypedConstructor } from "../../message";
+import { AggregateBase, AggregateMetadata } from "../aggregate-base";
+import { IEventDispatcher } from "../event-dispatcher.interface";
+import { ESAModelMetadata } from "./event-sourced-aggregate.model-metadata";
 export interface SnapshotMetadata extends AggregateMetadata {
 }
 export interface Snapshot<T extends AnyEventSourcedAggregate> {
@@ -15,30 +16,27 @@ export declare class EventSourcedAggregateBase<P extends Props> extends Aggregat
     private _pastEvents;
     private _events;
     constructor(metadata: AggregateMetadata, props?: P);
-    static newStream<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClassWithTypedConstructor<T>, id?: Id): T;
-    static fromStream<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClassWithTypedConstructor<T>, id: Id, pastEvents?: AnyEvent[]): T;
-    static fromSnapshot<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClassWithTypedConstructor<T>, snapshot: Snapshot<T>, pastEventsAfterSnapshot?: AnyEvent[]): T;
-    static eventApplierMap<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClass<T>): Map<string, EventApplier>;
-    static commandHandlerMap<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClass<T>): Map<string, CommandHandler>;
+    static esaModelMetadata<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClass<T>): ESAModelMetadata<T>;
+    esaModelMetadata(): ESAModelMetadata<this>;
     version(): number;
     pastEvents(): AnyEvent[];
     events(): AnyEvent[];
     handledCommands(): AnyCommand[];
-    eventApplierMap(): Map<string, EventApplier>;
     hasNewEvent(): boolean;
     getApplierForEvent<E extends AnyEvent>(event: E): EventApplier<E>;
     private validateEventBeforeApply;
     private _applyEvent;
     private applyPastEvent;
-    private applyPastEvents;
+    applyPastEvents(pastEvents: AnyEvent[]): void;
     applyEvent<E extends AnyEvent>(event: E): void;
     applyEvents(events: AnyEvent[]): void;
     applyNewEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: PropsOf<E>): void;
-    commandHandlerMap(): Map<string, CommandHandler>;
     getHandlerForCommand<C extends AnyCommand>(command: C): CommandHandler<C, AnyEvent | AnyEvent[]>;
     handleCommand<C extends AnyCommand>(command: C): AnyEvent[];
     snapMetadata(): SnapshotMetadata;
     snap(): Snapshot<this>;
+    protected archiveEvents(): void;
+    dispatchEvents(dispatcher: IEventDispatcher): void;
 }
 export type AnyEventSourcedAggregate = EventSourcedAggregateBase<Props>;
 export interface EventSourcedAggregateClass<T extends AnyEventSourcedAggregate = AnyEventSourcedAggregate, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof EventSourcedAggregateBase<PropsOf<T>>> {

package/dist/core/aggregate/{event-sourced-aggregate.js → event-sourced-aggregate/event-sourced-aggregate.js}

@@ -1,38 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventSourcedAggregateBase = void 0;
-const meta_1 = require("../../meta");
-const utils_1 = require("../../utils");
-const base_1 = require("./base");
-class EventSourcedAggregateBase extends base_1.AggregateBase {
+const utils_1 = require("../../../utils");
+const aggregate_base_1 = require("../aggregate-base");
+const event_sourced_aggregate_model_metadata_1 = require("./event-sourced-aggregate.model-metadata");
+class EventSourcedAggregateBase extends aggregate_base_1.AggregateBase {
     constructor(metadata, props) {
         super(metadata, props);
         this._handledCommands = [];
         this._events = [];
         this._pastEvents = [];
     }
-    static newStream(id) {
-        return new this({
-            id: this.id(id),
-            version: 0,
-        });
-    }
-    static fromStream(id, pastEvents = []) {
-        const instance = this.newStream(id);
-        instance.applyPastEvents(pastEvents);
-        return instance;
-    }
-    static fromSnapshot(snapshot, pastEventsAfterSnapshot = []) {
-        const { metadata, props } = snapshot;
-        const instance = new this(metadata, props);
-        instance.applyPastEvents(pastEventsAfterSnapshot);
-        return instance;
+    static esaModelMetadata() {
+        return new event_sourced_aggregate_model_metadata_1.ESAModelMetadata(this);
     }
-    static eventApplierMap() {
-        return (0, meta_1.getEventApplierMap)(this.prototype);
-    }
-    static commandHandlerMap() {
-        return (0, meta_1.getCommandHandlerMap)(this.prototype);
+    esaModelMetadata() {
+        return this.constructor.esaModelMetadata();
     }
     version() {
         return this._version + this._pastEvents.length + this._events.length;
@@ -46,22 +29,20 @@ class EventSourcedAggregateBase extends base_1.AggregateBase {
     handledCommands() {
         return Array.from(this._handledCommands);
     }
-    eventApplierMap() {
-        return this.constructor.eventApplierMap();
-    }
     hasNewEvent() {
         return Boolean(this._events.length);
     }
     getApplierForEvent(event) {
-        const eventType = event.eventType();
-        const applier = this.eventApplierMap().get(eventType);
+        const { eventType } = event.eventModelMetadata();
+        const { eventApplierMap } = this.esaModelMetadata();
+        const applier = eventApplierMap.get(eventType);
         if (!applier)
             throw new Error("Event applier not found");
         return applier;
     }
     validateEventBeforeApply(event) {
         const eventSource = event.source();
-        if (eventSource.aggregateModel !== this.modelName())
+        if (eventSource.aggregateModelId !== this.modelMetadata().modelId)
             throw new Error("Invalid source type");
         if (!eventSource.aggregateId.equals(this._id))
             throw new Error("Invalid source id");
@@ -96,12 +77,10 @@ class EventSourcedAggregateBase extends base_1.AggregateBase {
     applyNewEvent(eventClass, props) {
         this.applyEvent(this.newEvent(eventClass, props));
     }
-    commandHandlerMap() {
-        return this.constructor.commandHandlerMap();
-    }
     getHandlerForCommand(command) {
-        const commandType = command.commandType();
-        const handler = this.commandHandlerMap().get(commandType);
+        const { commandType } = command.commandModelMetadata();
+        const { commandHandlerMap } = this.esaModelMetadata();
+        const handler = commandHandlerMap.get(commandType);
         if (!handler)
             throw new Error("Command handler not found");
         return handler;
@@ -133,5 +112,16 @@ class EventSourcedAggregateBase extends base_1.AggregateBase {
             props: this.props(),
         };
     }
+    archiveEvents() {
+        const events = this.events();
+        this._events = [];
+        this._pastEvents.push(...events);
+    }
+    dispatchEvents(dispatcher) {
+        this.events().forEach((event) => {
+            dispatcher.dispatch(event);
+        });
+        this.archiveEvents();
+    }
 }
 exports.EventSourcedAggregateBase = EventSourcedAggregateBase;

package/dist/core/aggregate/event-sourced-aggregate/event-sourced-aggregate.model-metadata.d.ts

@@ -0,0 +1,9 @@
+import { AnyEventSourcedAggregate, EventSourcedAggregateClass } from "..";
+export declare class ESAModelMetadata<T extends AnyEventSourcedAggregate> {
+    private aggregateClass;
+    constructor(aggregateClass: EventSourcedAggregateClass<T>);
+    get ownEventApplierMap(): import("../../../meta").EventApplierMap;
+    get eventApplierMap(): import("../../../meta").EventApplierMap;
+    get ownCommandHandlerMap(): import("../../../meta").CommandHandlerMap;
+    get commandHandlerMap(): import("../../../meta").CommandHandlerMap;
+}

package/dist/core/aggregate/event-sourced-aggregate/event-sourced-aggregate.model-metadata.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ESAModelMetadata = void 0;
+const meta_1 = require("../../../meta");
+class ESAModelMetadata {
+    constructor(aggregateClass) {
+        this.aggregateClass = aggregateClass;
+    }
+    get ownEventApplierMap() {
+        return (0, meta_1.getOwnEventApplierMap)(this.aggregateClass.prototype);
+    }
+    get eventApplierMap() {
+        return (0, meta_1.getEventApplierMap)(this.aggregateClass.prototype);
+    }
+    get ownCommandHandlerMap() {
+        return (0, meta_1.getOwnCommandHandlerMap)(this.aggregateClass.prototype);
+    }
+    get commandHandlerMap() {
+        return (0, meta_1.getCommandHandlerMap)(this.aggregateClass.prototype);
+    }
+}
+exports.ESAModelMetadata = ESAModelMetadata;

package/dist/core/aggregate/event-sourced-aggregate/index.d.ts

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

package/dist/core/aggregate/event-sourced-aggregate/index.js

@@ -0,0 +1,19 @@
+"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-sourced-aggregate"), exports);
+__exportStar(require("./event-sourced-aggregate.builder"), exports);
+__exportStar(require("./event-sourced-aggregate.model-metadata"), exports);

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

@@ -1,3 +1,5 @@
+export * from "./event-dispatcher.interface";
+export * from "./aggregate-base";
 export * from "./state-aggregate";
 export * from "./event-sourced-aggregate";
 export * from "./types";

package/dist/core/aggregate/index.js

@@ -14,6 +14,8 @@ 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-dispatcher.interface"), exports);
+__exportStar(require("./aggregate-base"), exports);
 __exportStar(require("./state-aggregate"), exports);
 __exportStar(require("./event-sourced-aggregate"), exports);
 __exportStar(require("./types"), exports);

package/dist/core/aggregate/state-aggregate/index.d.ts

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

package/dist/core/aggregate/state-aggregate/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("./state-aggregate"), exports);
+__exportStar(require("./state-aggregate.builder"), exports);

package/dist/core/aggregate/state-aggregate/state-aggregate.builder.d.ts

@@ -0,0 +1,7 @@
+import { AggregateBuilderBase } from "../aggregate-base";
+import { AnyStateAggregate, StateAggregateClassWithTypedConstructor } from "./state-aggregate";
+export declare class StateAggregateBuilder<T extends AnyStateAggregate> extends AggregateBuilderBase<T> {
+    private aggregateClass;
+    constructor(aggregateClass: StateAggregateClassWithTypedConstructor<T>);
+    build(): T;
+}

package/dist/core/aggregate/state-aggregate/state-aggregate.builder.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateAggregateBuilder = void 0;
+const aggregate_base_1 = require("../aggregate-base");
+class StateAggregateBuilder extends aggregate_base_1.AggregateBuilderBase {
+    constructor(aggregateClass) {
+        super();
+        this.aggregateClass = aggregateClass;
+    }
+    build() {
+        if (!this._props)
+            throw new Error("The props must be set before build");
+        return new this.aggregateClass({
+            id: this.getId(),
+            version: this.getVersion(),
+        }, this._props);
+    }
+}
+exports.StateAggregateBuilder = StateAggregateBuilder;

package/dist/core/aggregate/{state-aggregate.d.ts → state-aggregate/state-aggregate.d.ts}

@@ -1,16 +1,12 @@
 import { Class } from "type-fest";
-import { ClassStatic } from "../../types";
-import { Id } from "../id";
-import { AnyEvent, EventClass } from "../message";
-import { Props, PropsOf } from "../model";
-import { AggregateBase, AggregateMetadata } from "./base";
-export interface IEventDispatcher {
-    dispatch(event: AnyEvent): void;
-}
+import { Props, PropsOf } from "../../../model";
+import { ClassStatic } from "../../../types";
+import { AnyEvent, EventClass } from "../../message";
+import { AggregateBase, AggregateMetadata } from "../aggregate-base";
+import { IEventDispatcher } from "../event-dispatcher.interface";
 export declare class StateAggregateBase<P extends Props> extends AggregateBase<P> {
     private _events;
     constructor(metadata: AggregateMetadata, props: P);
-    static newAggregate<T extends AnyStateAggregate>(this: StateAggregateClassWithTypedConstructor<T>, props: PropsOf<T>, id?: Id): T;
     props(): P;
     version(): number;
     events(): AnyEvent[];

package/dist/core/aggregate/{state-aggregate.js → state-aggregate/state-aggregate.js}

@@ -1,18 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StateAggregateBase = void 0;
-const base_1 = require("./base");
-class StateAggregateBase extends base_1.AggregateBase {
+const aggregate_base_1 = require("../aggregate-base");
+class StateAggregateBase extends aggregate_base_1.AggregateBase {
     constructor(metadata, props) {
         super(metadata, props);
         this._events = [];
     }
-    static newAggregate(props, id) {
-        return new this({
-            id: this.id(id),
-            version: 0,
-        }, props);
-    }
     props() {
         return super.props();
     }

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

@@ -1,4 +1,4 @@
-import { AnyEventSourcedAggregate, EventSourcedAggregateClass } from "./event-sourced-aggregate";
+import { AnyEventSourcedAggregate, EventSourcedAggregateClass } from "./event-sourced-aggregate/event-sourced-aggregate";
 import { AnyStateAggregate, StateAggregateClass } from "./state-aggregate";
-export type AnyAggregate = AnyStateAggregate | AnyEventSourcedAggregate;
-export type AnyAggregateClass = StateAggregateClass | EventSourcedAggregateClass;
+export type Aggregate = AnyStateAggregate | AnyEventSourcedAggregate;
+export type AggregateClass = StateAggregateClass | EventSourcedAggregateClass;

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

@@ -0,0 +1,9 @@
+import { ModelWithIdBuilder } from "..";
+import { AnyEntity, EntityClassWithTypedConstructor } from "./entity";
+export declare abstract class EntityBuilderBase<T extends AnyEntity> extends ModelWithIdBuilder<T> {
+}
+export declare class EntityBuilder<T extends AnyEntity> extends EntityBuilderBase<T> {
+    private entityClass;
+    constructor(entityClass: EntityClassWithTypedConstructor<T>);
+    build(): T;
+}

package/dist/core/entity/entity.builder.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityBuilder = exports.EntityBuilderBase = void 0;
+const __1 = require("..");
+class EntityBuilderBase extends __1.ModelWithIdBuilder {
+}
+exports.EntityBuilderBase = EntityBuilderBase;
+class EntityBuilder extends EntityBuilderBase {
+    constructor(entityClass) {
+        super();
+        this.entityClass = entityClass;
+    }
+    build() {
+        return new this.entityClass({ id: this.getId() }, this._props);
+    }
+}
+exports.EntityBuilder = EntityBuilder;

package/dist/core/{entity.d.ts → entity/entity.d.ts}

@@ -1,14 +1,13 @@
 import { Class } from "type-fest";
-import { Id } from "./id";
-import { ModelWithId, Props, PropsOf } from "./model";
-import { ClassStatic } from "../types";
+import { Props, PropsOf } from "../../model";
+import { ClassStatic } from "../../types";
+import { Id } from "../id";
+import { ModelWithId } from "../model-with-id";
 export interface EntityMetadata {
     readonly id: Id;
 }
 export declare class EntityBase<P extends Props> extends ModelWithId<P> {
     constructor(metadata: EntityMetadata, props?: P);
-    static mutable(): boolean;
-    static newEntity<T extends AnyEntity>(this: EntityClassWithTypedConstructor<T>, props: PropsOf<T>, id?: Id): T;
 }
 export type AnyEntity = EntityBase<Props>;
 export interface EntityClass<T extends AnyEntity = AnyEntity, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof EntityBase<PropsOf<T>>> {

package/dist/core/entity/entity.js

@@ -0,0 +1,26 @@
+"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.EntityBase = void 0;
+const model_1 = require("../../model");
+const model_with_id_1 = require("../model-with-id");
+let EntityBase = class EntityBase extends model_with_id_1.ModelWithId {
+    constructor(metadata, props) {
+        super(metadata.id);
+        if (props)
+            this.initializeProps(props);
+    }
+};
+exports.EntityBase = EntityBase;
+exports.EntityBase = EntityBase = __decorate([
+    (0, model_1.Mutable)(true),
+    __metadata("design:paramtypes", [Object, Object])
+], EntityBase);

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

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

package/dist/core/entity/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("./entity"), exports);
+__exportStar(require("./entity.builder"), exports);

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

@@ -0,0 +1,9 @@
+import { ModelBuilder } from "../../model";
+import { AnyEnum, EnumClassWithTypedConstructor, EnumValue } from "./enum";
+export declare class EnumBuilder<T extends AnyEnum> extends ModelBuilder<T> {
+    private enumClass;
+    protected _value: EnumValue;
+    constructor(enumClass: EnumClassWithTypedConstructor<T>);
+    withValue(value: EnumValue): this;
+    build(): T;
+}

package/dist/core/enum/enum.builder.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumBuilder = void 0;
+const model_1 = require("../../model");
+class EnumBuilder extends model_1.ModelBuilder {
+    constructor(enumClass) {
+        super();
+        this.enumClass = enumClass;
+    }
+    withValue(value) {
+        this._value = value;
+        return this;
+    }
+    build() {
+        if (!this._value)
+            throw new Error("The value must be set before build");
+        return this.enumClass.parse(this._value);
+    }
+}
+exports.EnumBuilder = EnumBuilder;