ddd-node 30.1.2 → 32.0.0

package/core/decorators/es-aggregate/when.d.ts

@@ -0,0 +1,2 @@
+import { AnyEvent, AnyESAggregate, EventApplier, EventClass } from "../..";
+export declare const When: <T extends AnyEvent>(eventClass: EventClass<T>) => <U extends EventApplier<T>>(target: AnyESAggregate, propertyKey: string, descriptor: TypedPropertyDescriptor<U>) => void;

package/{decorators → core/decorators}/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./aggregate-es";
+export * from "./es-aggregate";
 export * from "./message";
 export * from "./enum";

package/{decorators → core/decorators}/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("./aggregate-es"), exports);
+__exportStar(require("./es-aggregate"), exports);
 __exportStar(require("./message"), exports);
 __exportStar(require("./enum"), exports);

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

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

package/core/decorators/message/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("./is-command"), exports);
+__exportStar(require("./is-event"), exports);

package/core/decorators/message/is-command.d.ts

@@ -0,0 +1,4 @@
+import { ModelOptions } from "../../../base";
+import { AnyCommand, CommandClass } from "../../../core";
+import { CommandType } from "../../meta";
+export declare const IsCommand: (commandType: CommandType, modelOptions?: ModelOptions) => <T extends AnyCommand>(target: CommandClass<T>) => void;

package/{decorators/message/command.js → core/decorators/message/is-command.js}

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Command = void 0;
-const base_1 = require("../../base");
+exports.IsCommand = void 0;
+const base_1 = require("../../../base");
 const meta_1 = require("../../meta");
-const Command = (commandType, modelOptions) => {
+const IsCommand = (commandType, modelOptions) => {
     return (target) => {
         (0, meta_1.defineCommandType)(target, commandType);
         (0, base_1.Model)(modelOptions)(target);
     };
 };
-exports.Command = Command;
+exports.IsCommand = IsCommand;

package/core/decorators/message/is-event.d.ts

@@ -0,0 +1,4 @@
+import { ModelOptions } from "../../../base";
+import { AnyEvent, EventClass } from "../../../core";
+import { EventType } from "../../meta";
+export declare const IsEvent: (eventType: EventType, modelOptions?: ModelOptions) => <T extends AnyEvent>(target: EventClass<T>) => void;

package/{decorators/message/event.js → core/decorators/message/is-event.js}

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Event = void 0;
-const base_1 = require("../../base");
+exports.IsEvent = void 0;
+const base_1 = require("../../../base");
 const meta_1 = require("../../meta");
-const Event = (eventType, modelOptions) => {
+const IsEvent = (eventType, modelOptions) => {
     return (target) => {
         (0, meta_1.defineEventType)(target, eventType);
         (0, base_1.Model)(modelOptions)(target);
     };
 };
-exports.Event = Event;
+exports.IsEvent = IsEvent;

package/core/index.d.ts

@@ -1,7 +1,4 @@
-export * from "./value-object";
-export * from "./enum";
-export * from "./model-with-id";
-export * from "./entity";
-export * from "./aggregate";
-export * from "./message";
+export * from "./model";
 export * from "./repository";
+export * from "./decorators";
+export * from "./meta";

package/core/index.js

@@ -14,10 +14,7 @@ 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("./model-with-id"), exports);
-__exportStar(require("./entity"), exports);
-__exportStar(require("./aggregate"), exports);
-__exportStar(require("./message"), exports);
+__exportStar(require("./model"), exports);
 __exportStar(require("./repository"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./meta"), exports);

package/{meta → core/meta}/command.metadata.js

@@ -5,7 +5,7 @@ require("reflect-metadata");
 class $CommandType extends String {
     static validate(commandType) {
         if (commandType.trim().length === 0)
-            throw new Error("Command type cannot be an empty string");
+            throw new Error("IsCommand type cannot be an empty string");
     }
     constructor(commandType) {
         $CommandType.validate(commandType);
@@ -21,7 +21,7 @@ exports.defineCommandType = defineCommandType;
 const getCommandType = (target) => {
     const commandType = Reflect.getOwnMetadata(CommandTypeMetaKey, target);
     if (!commandType)
-        throw new Error("Command's type is not defined");
+        throw new Error("IsCommand's type is not defined");
     return commandType.valueOf();
 };
 exports.getCommandType = getCommandType;

package/{meta/aggregate-es → core/meta/es-aggregate}/command-handler-map.d.ts

@@ -1,4 +1,4 @@
-import { AnyCommand, CommandHandler } from "../../core";
+import { AnyCommand, CommandHandler } from "../../model";
 export declare class CommandHandlerMap extends Map<string, CommandHandler> {
 }
 export declare const OwnCommandHandlerMapMetaKey: unique symbol;

package/{meta/aggregate-es → core/meta/es-aggregate}/event-applier-map.d.ts

@@ -1,5 +1,5 @@
 import "reflect-metadata";
-import { AnyEvent, EventApplier } from "../../core";
+import { AnyEvent, EventApplier } from "../../model";
 export declare class EventApplierMap extends Map<string, EventApplier> {
 }
 export declare const OwnEventApplierMapMetaKey: unique symbol;

package/{meta → core/meta}/event.metadata.js

@@ -5,7 +5,7 @@ require("reflect-metadata");
 class $EventType extends String {
     static validate(eventType) {
         if (eventType.trim().length === 0)
-            throw new Error("Event type cannot be an empty string");
+            throw new Error("IsEvent type cannot be an empty string");
     }
     constructor(eventType) {
         $EventType.validate(eventType);

package/{meta → core/meta}/index.d.ts

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

package/{meta → core/meta}/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("./aggregate-es"), exports);
+__exportStar(require("./es-aggregate"), exports);
 __exportStar(require("./event.metadata"), exports);
 __exportStar(require("./command.metadata"), exports);

package/core/{aggregate/aggregate-base → model/aggregate}/aggregate.d.ts

@@ -1,11 +1,12 @@
-import { Props, InferredProps } from "../../../base";
-import { ModelWithId, ModelWithIdMetadata } from "../../model-with-id";
-import { AnyEvent, EventClassWithTypedConstructor, EventSource } from "../../message";
-import { IAggregateEventPublisher } from "./aggregate-event-publisher.interface";
+import { AnyEvent, EventClassWithTypedConstructor, EventSource } from "../message";
+import { ModelWithId, ModelWithIdMetadata } from "../model-with-id";
+import { InferredProps, Props } from "./../../../base";
+import { IAggregateEventPublisher } from "./types";
 export interface AggregateMetadata extends ModelWithIdMetadata {
     version: number;
 }
-export declare abstract class AggregateBase<P extends Props> extends ModelWithId<P> {
+export declare abstract class Aggregate<P extends Props> extends ModelWithId<P> {
+    static createMetadata: (metadata?: Partial<AggregateMetadata>) => AggregateMetadata;
     protected readonly _version: number;
     constructor(metadata: AggregateMetadata, props?: P);
     abstract version(): number;
@@ -14,4 +15,4 @@ export declare abstract class AggregateBase<P extends Props> extends ModelWithId
     protected newEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: InferredProps<E>): E;
     abstract publishEvents(publisher: IAggregateEventPublisher): void;
 }
-export type AnyAggregate = AggregateBase<Props>;
+export type AnyAggregate = Aggregate<Props>;

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

@@ -9,10 +9,11 @@ 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.AggregateBase = void 0;
-const base_1 = require("../../../base");
-const model_with_id_1 = require("../../model-with-id");
-let AggregateBase = class AggregateBase extends model_with_id_1.ModelWithId {
+exports.Aggregate = void 0;
+const uuid_1 = require("uuid");
+const model_with_id_1 = require("../model-with-id");
+const base_1 = require("./../../../base");
+let Aggregate = class Aggregate extends model_with_id_1.ModelWithId {
     constructor(metadata, props) {
         super(metadata);
         if (props)
@@ -29,15 +30,14 @@ let AggregateBase = class AggregateBase extends model_with_id_1.ModelWithId {
         };
     }
     newEvent(eventClass, props) {
-        return eventClass
-            .builder()
-            .withSource(this.createEventSource())
-            .withProps(props)
-            .build();
+        return eventClass.build(props, { source: this.createEventSource() });
     }
 };
-exports.AggregateBase = AggregateBase;
-exports.AggregateBase = AggregateBase = __decorate([
+exports.Aggregate = Aggregate;
+Aggregate.createMetadata = (metadata) => {
+    return Object.assign({ id: (0, uuid_1.v4)(), version: 0 }, metadata);
+};
+exports.Aggregate = Aggregate = __decorate([
     (0, base_1.Mutable)(true),
     __metadata("design:paramtypes", [Object, Object])
-], AggregateBase);
+], Aggregate);

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

@@ -0,0 +1,50 @@
+import { Id } from "src";
+import { Class } from "type-fest";
+import { InferredProps, Props } from "../../../base";
+import { ClassStatic } from "../../../types";
+import { AnyCommand, AnyEvent, EventClassWithTypedConstructor } from "../message";
+import { Aggregate, AggregateMetadata } from "./aggregate";
+import { IAggregateEventPublisher } from "./types";
+export declare class ESAggregate<P extends Props> extends Aggregate<P> {
+    static fromStream<T extends AnyESAggregate>(this: ESAggregateClassWithTypedConstructor<T>, pastEvents: AnyEvent[], id?: Id): T;
+    static newStream<T extends AnyESAggregate>(this: ESAggregateClassWithTypedConstructor<T>, id?: Id): T;
+    static fromSnapshot<T extends AnyESAggregate>(this: ESAggregateClassWithTypedConstructor<T>, snapshot: Snapshot<T>, pastEvents?: AnyEvent[]): T;
+    static ownEventApplierMap<T extends AnyESAggregate>(this: ESAggregateClass<T>): import("src").EventApplierMap;
+    static eventApplierMap<T extends AnyESAggregate>(this: ESAggregateClass<T>): import("src").EventApplierMap;
+    static ownCommandHandlerMap<T extends AnyESAggregate>(this: ESAggregateClass<T>): import("src").CommandHandlerMap;
+    static commandHandlerMap<T extends AnyESAggregate>(this: ESAggregateClass<T>): import("src").CommandHandlerMap;
+    private _handledCommands;
+    private _pastEvents;
+    private _events;
+    constructor(metadata: AggregateMetadata, props?: P);
+    _constructor(): ESAggregateClass<this, any[]>;
+    version(): number;
+    pastEvents(): AnyEvent[];
+    events(): AnyEvent[];
+    handledCommands(): AnyCommand[];
+    hasNewEvent(): boolean;
+    getEventApplier<E extends AnyEvent>(event: E): EventApplier<E>;
+    private validateEventBeforeApply;
+    private _applyEvent;
+    private applyPastEvent;
+    applyPastEvents(pastEvents: AnyEvent[]): void;
+    applyEvent<E extends AnyEvent>(event: E): void;
+    applyEvents(events: AnyEvent[]): void;
+    applyNewEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: InferredProps<E>): void;
+    getCommandHandler<C extends AnyCommand>(command: C): CommandHandler<C, AnyEvent | AnyEvent[]>;
+    handleCommand<C extends AnyCommand>(command: C): AnyEvent[];
+    takeSnapshot(): Snapshot<this>;
+    protected commitEvents(): void;
+    publishEvents(publisher: IAggregateEventPublisher): void;
+}
+export type AnyESAggregate = ESAggregate<Props>;
+export interface ESAggregateClass<T extends AnyESAggregate = AnyESAggregate, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof ESAggregate<InferredProps<T>>> {
+}
+export interface ESAggregateClassWithTypedConstructor<T extends AnyESAggregate = AnyESAggregate> extends ESAggregateClass<T, ConstructorParameters<typeof ESAggregate<InferredProps<T>>>> {
+}
+export type EventApplier<T extends AnyEvent = AnyEvent> = (event: T) => void;
+export type CommandHandler<T extends AnyCommand = AnyCommand, U extends AnyEvent | AnyEvent[] = AnyEvent | AnyEvent[]> = (command: T) => U;
+export interface Snapshot<T extends AnyESAggregate> {
+    metadata: AggregateMetadata;
+    props: InferredProps<T>;
+}

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

@@ -1,19 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventSourcedAggregateBase = void 0;
-const meta_1 = require("../../../meta");
+exports.ESAggregate = void 0;
 const utils_1 = require("../../../utils");
-const aggregate_base_1 = require("../aggregate-base");
-const _1 = require(".");
-class EventSourcedAggregateBase extends aggregate_base_1.AggregateBase {
-    static builder() {
-        return new _1.EventSourcedAggregateBuilder(this);
-    }
-    constructor(metadata, props) {
-        super(metadata, props);
-        this._handledCommands = [];
-        this._events = [];
-        this._pastEvents = [];
+const meta_1 = require("../../meta");
+const aggregate_1 = require("./aggregate");
+class ESAggregate extends aggregate_1.Aggregate {
+    static fromStream(pastEvents, id) {
+        const instance = new this(this.createMetadata({ id }));
+        instance.applyPastEvents(pastEvents);
+        return instance;
+    }
+    static newStream(id) {
+        return this.fromStream([], id);
+    }
+    static fromSnapshot(snapshot, pastEvents = []) {
+        const { id, version } = snapshot.metadata;
+        const { props } = snapshot;
+        const instance = new this({
+            id,
+            version,
+        }, props);
+        instance.applyPastEvents(pastEvents);
+        return instance;
     }
     static ownEventApplierMap() {
         return (0, meta_1.getOwnEventApplierMap)(this.prototype);
@@ -27,9 +35,14 @@ class EventSourcedAggregateBase extends aggregate_base_1.AggregateBase {
     static commandHandlerMap() {
         return (0, meta_1.getCommandHandlerMap)(this.prototype);
     }
-    modelDescriptor() {
-        const aggregateClass = this.constructor;
-        return Object.assign(Object.assign({}, super.modelDescriptor()), { ownEventApplierMap: aggregateClass.ownEventApplierMap(), eventApplierMap: aggregateClass.eventApplierMap(), ownCommandHandlerMap: aggregateClass.ownCommandHandlerMap(), commandHandlerMap: aggregateClass.commandHandlerMap() });
+    constructor(metadata, props) {
+        super(metadata, props);
+        this._handledCommands = [];
+        this._events = [];
+        this._pastEvents = [];
+    }
+    _constructor() {
+        return this.constructor;
     }
     version() {
         return this._version + this._pastEvents.length + this._events.length;
@@ -47,11 +60,11 @@ class EventSourcedAggregateBase extends aggregate_base_1.AggregateBase {
         return Boolean(this._events.length);
     }
     getEventApplier(event) {
-        const { eventType } = event.modelDescriptor();
-        const { eventApplierMap } = this.modelDescriptor();
+        const eventType = event.eventType();
+        const eventApplierMap = this._constructor().eventApplierMap();
         const applier = eventApplierMap.get(eventType);
         if (!applier)
-            throw new Error("Event applier not found");
+            throw new Error("IsEvent applier not found");
         return applier;
     }
     validateEventBeforeApply(event) {
@@ -90,11 +103,11 @@ class EventSourcedAggregateBase extends aggregate_base_1.AggregateBase {
         this.applyEvent(this.newEvent(eventClass, props));
     }
     getCommandHandler(command) {
-        const { commandType } = command.modelDescriptor();
-        const { commandHandlerMap } = this.modelDescriptor();
+        const commandType = command.commandType();
+        const commandHandlerMap = this._constructor().commandHandlerMap();
         const handler = commandHandlerMap.get(commandType);
         if (!handler)
-            throw new Error("Command handler not found");
+            throw new Error("IsCommand handler not found");
         return handler;
     }
     handleCommand(command) {
@@ -108,28 +121,22 @@ class EventSourcedAggregateBase extends aggregate_base_1.AggregateBase {
         this._handledCommands.push(command);
         return events;
     }
-    snapMetadata() {
-        return {
-            id: this.id(),
-            version: this.version(),
-        };
-    }
-    snap() {
+    takeSnapshot() {
         if (this.propsIsEmpty())
             throw new Error("Cannot create snapshot when the props is not initialized");
         return {
-            metadata: this.snapMetadata(),
+            metadata: this.metadata(),
             props: this.props(),
         };
     }
-    archiveEvents() {
+    commitEvents() {
         const events = this.events();
         this._events = [];
         this._pastEvents.push(...events);
     }
     publishEvents(publisher) {
         publisher.publish(this.events());
-        this.archiveEvents();
+        this.commitEvents();
     }
 }
-exports.EventSourcedAggregateBase = EventSourcedAggregateBase;
+exports.ESAggregate = ESAggregate;

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

@@ -0,0 +1,4 @@
+export * from "./aggregate";
+export * from "./state-aggregate";
+export * from "./es-aggregate";
+export * from "./types";

package/core/{aggregate → model/aggregate}/index.js

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

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

@@ -1,15 +1,16 @@
 import { Class } from "type-fest";
-import { Props, InferredProps } from "../../../base";
+import { InferredProps, Props } from "../../../base";
 import { ClassStatic } from "../../../types";
-import { AnyEvent, EventClassWithTypedConstructor } from "../../message";
-import { AggregateBase, AggregateMetadata, IAggregateEventPublisher } from "../aggregate-base";
-import { StateAggregateBuilder } from ".";
+import { AnyEvent, EventClassWithTypedConstructor } from "../message";
+import { Aggregate, AggregateMetadata } from "./aggregate";
+import { IAggregateEventPublisher } from "./types";
 export interface StateAggregateMetadata extends AggregateMetadata {
 }
-export declare class StateAggregateBase<P extends Props> extends AggregateBase<P> {
-    static builder<T extends AnyStateAggregate>(this: StateAggregateClass<T>): StateAggregateBuilder<T>;
+export declare class StateAggregate<P extends Props> extends Aggregate<P> {
+    static build<T extends AnyStateAggregate>(this: StateAggregateClassWithTypedConstructor<T>, props: InferredProps<T>, metadata?: Partial<StateAggregateMetadata>): T;
     private _events;
     constructor(metadata: StateAggregateMetadata, props: P);
+    _constructor(): StateAggregateClass<this, any[]>;
     props(): P;
     version(): number;
     events(): AnyEvent[];
@@ -18,8 +19,8 @@ export declare class StateAggregateBase<P extends Props> extends AggregateBase<P
     clearEvents(): void;
     publishEvents(publisher: IAggregateEventPublisher): void;
 }
-export type AnyStateAggregate = StateAggregateBase<Props>;
-export interface StateAggregateClass<T extends AnyStateAggregate = AnyStateAggregate, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof StateAggregateBase<InferredProps<T>>> {
+export type AnyStateAggregate = StateAggregate<Props>;
+export interface StateAggregateClass<T extends AnyStateAggregate = AnyStateAggregate, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof StateAggregate<InferredProps<T>>> {
 }
-export interface StateAggregateClassWithTypedConstructor<T extends AnyStateAggregate = AnyStateAggregate> extends StateAggregateClass<T, ConstructorParameters<typeof StateAggregateBase<InferredProps<T>>>> {
+export interface StateAggregateClassWithTypedConstructor<T extends AnyStateAggregate = AnyStateAggregate> extends StateAggregateClass<T, ConstructorParameters<typeof StateAggregate<InferredProps<T>>>> {
 }

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

@@ -1,16 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StateAggregateBase = void 0;
-const aggregate_base_1 = require("../aggregate-base");
-const _1 = require(".");
-class StateAggregateBase extends aggregate_base_1.AggregateBase {
-    static builder() {
-        return new _1.StateAggregateBuilder(this);
+exports.StateAggregate = void 0;
+const aggregate_1 = require("./aggregate");
+class StateAggregate extends aggregate_1.Aggregate {
+    static build(props, metadata) {
+        return new this(this.createMetadata(metadata), props);
     }
     constructor(metadata, props) {
         super(metadata, props);
         this._events = [];
     }
+    _constructor() {
+        return this.constructor;
+    }
     props() {
         return super.props();
     }
@@ -38,4 +40,4 @@ class StateAggregateBase extends aggregate_base_1.AggregateBase {
         this.clearEvents();
     }
 }
-exports.StateAggregateBase = StateAggregateBase;
+exports.StateAggregate = StateAggregate;

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

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

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

@@ -0,0 +1,18 @@
+import { Class } from "type-fest";
+import { InferredProps, Props } from "../../../base";
+import { ClassStatic } from "../../../types";
+import { Id, ModelWithId, ModelWithIdMetadata } from "../model-with-id";
+export interface EntityMetadata extends ModelWithIdMetadata {
+}
+export declare class Entity<P extends Props> extends ModelWithId<P> {
+    static build<T extends AnyEntity>(this: EntityClassWithTypedConstructor<T>, props: InferredProps<T>, id?: Id): T;
+    constructor(metadata: EntityMetadata, props: P);
+    _constructor(): EntityClass<this, any[]>;
+}
+export type AnyEntity = Entity<Props>;
+export interface EntityClass<T extends AnyEntity = AnyEntity, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof Entity<InferredProps<T>>> {
+}
+export interface EntityClassWithTypedConstructor<T extends AnyEntity = AnyEntity> extends EntityClass<T, ConstructorParameters<typeof Entity<InferredProps<T>>>> {
+}
+export interface EntityClassWithProps<P extends Props> extends EntityClass<Entity<P>> {
+}

package/core/{entity → model/entity}/entity.js

@@ -9,21 +9,24 @@ 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 base_1 = require("../../base");
+exports.Entity = void 0;
+const uuid_1 = require("uuid");
+const base_1 = require("../../../base");
 const model_with_id_1 = require("../model-with-id");
-const _1 = require(".");
-let EntityBase = class EntityBase extends model_with_id_1.ModelWithId {
-    static builder() {
-        return new _1.EntityBuilder(this);
+let Entity = class Entity extends model_with_id_1.ModelWithId {
+    static build(props, id) {
+        return new this({ id: id !== null && id !== void 0 ? id : (0, uuid_1.v4)() }, props);
     }
     constructor(metadata, props) {
         super(metadata);
         this.initializeProps(props);
     }
+    _constructor() {
+        return this.constructor;
+    }
 };
-exports.EntityBase = EntityBase;
-exports.EntityBase = EntityBase = __decorate([
+exports.Entity = Entity;
+exports.Entity = Entity = __decorate([
     (0, base_1.Mutable)(true),
     __metadata("design:paramtypes", [Object, Object])
-], EntityBase);
+], Entity);

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

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

package/core/{entity → model/entity}/index.js

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

package/core/{enum → model/enum}/enum.d.ts

@@ -1,22 +1,19 @@
 import { Class } from "type-fest";
-import { ModelBase } from "../../base";
-import { ClassStatic } from "../../types";
-import { EnumBuilder } from ".";
+import { DomainModel } from "../../../base";
+import { ClassStatic } from "../../../types";
 export type EnumValue = string | number;
 export interface EnumProps {
     value: EnumValue;
 }
-export declare class EnumBase extends ModelBase<EnumProps> {
-    static builder<T extends AnyEnum>(this: EnumClass<T>): EnumBuilder<T>;
-    static values(): EnumBase[];
+export declare class Enum extends DomainModel<EnumProps> {
+    static values(): Enum[];
     static from<T extends AnyEnum>(this: EnumClass<T>, value: EnumValue): T;
-    static fromSafe<T extends AnyEnum>(this: EnumClass<T>, value: EnumValue): T | null;
     constructor(value: EnumValue);
     value: EnumValue;
     valueOf(): EnumValue;
 }
-export type AnyEnum = EnumBase;
-export interface EnumClass<T extends AnyEnum = AnyEnum, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof EnumBase> {
+export type AnyEnum = Enum;
+export interface EnumClass<T extends AnyEnum = AnyEnum, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof Enum> {
 }
-export interface EnumClassWithTypedConstructor<T extends AnyEnum = AnyEnum> extends EnumClass<T, ConstructorParameters<typeof EnumBase>> {
+export interface EnumClassWithTypedConstructor<T extends AnyEnum = AnyEnum> extends EnumClass<T, ConstructorParameters<typeof Enum>> {
 }