ddd-node 27.0.0 → 29.0.0

package/dist/base/decorators/model.d.ts

@@ -1,5 +1,5 @@
-import { AnyModel, ModelClass } from "../model";
 import { ModelPropsValidator } from "../meta";
+import { AnyModel, ModelClass } from "../model";
 export type ModelOptions<T extends AnyModel = AnyModel> = {
     name?: string;
     version?: number;
@@ -7,6 +7,7 @@ export type ModelOptions<T extends AnyModel = AnyModel> = {
     propsValidator?: ModelPropsValidator<T>;
     autoRegisterModel?: boolean;
 };
+export declare const DEFAULT_MODEL_OPTIONS: ModelOptions;
 export declare function Model<T extends ModelClass, I extends InstanceType<T> = InstanceType<T>>(options?: ModelOptions<I>): any;
 export declare function Model<T extends ModelClass, I extends InstanceType<T> = InstanceType<T>>(name: string, options?: ModelOptions<I>): any;
 export declare function Model<T extends ModelClass, I extends InstanceType<T> = InstanceType<T>>(name: string, version: number, options?: ModelOptions<I>): any;

package/dist/base/decorators/model.js

@@ -3,14 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Model = void 0;
+exports.Model = exports.DEFAULT_MODEL_OPTIONS = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 const domain_1 = require("../domain");
 const meta_1 = require("../meta");
+exports.DEFAULT_MODEL_OPTIONS = {
+    autoRegisterModel: true,
+};
 function Model(p1, p2, p3) {
-    const defaultModelOptions = {
-        autoRegisterModel: true,
-    };
+    const defaultModelOptions = lodash_1.default.clone(exports.DEFAULT_MODEL_OPTIONS);
     let modelOptions = {};
     if (p1 && !p2 && !p3) {
         if (typeof p1 === "string")
@@ -41,10 +42,11 @@ function Model(p1, p2, p3) {
             (0, meta_1.defineModelDomain)(target, modelOptions.domain);
         if (modelOptions?.autoRegisterModel) {
             const domainName = (0, meta_1.getModelDomain)(target);
-            if (!domain_1.domainManager.hasDomain(domainName)) {
-                domain_1.domainManager.addDomain(new domain_1.Domain(domainName));
+            const domainManager = domain_1.DomainManager.instance();
+            if (!domainManager.hasDomain(domainName)) {
+                domainManager.addDomain(new domain_1.Domain(domainName));
             }
-            const domain = domain_1.domainManager.getDomain(domainName);
+            const domain = domainManager.getDomain(domainName);
             domain.modelRegistry.registerModel(target);
         }
         if (modelOptions?.propsValidator)

package/dist/base/decorators/prop.d.ts

@@ -1,2 +1,2 @@
-import { AnyModel, PropsOf } from "../model";
-export declare const Prop: <T extends AnyModel>(propTargetKey?: keyof PropsOf<T> | undefined) => (target: T, key: PropertyKey) => void;
+import { AnyModel, InferredProps } from "../model";
+export declare const Prop: <T extends AnyModel>(propTargetKey?: keyof InferredProps<T> | undefined) => (target: T, key: PropertyKey) => void;

package/dist/base/domain.js

@@ -15,9 +15,10 @@ class DomainMap extends Map {
 exports.DomainMap = DomainMap;
 class DomainManager {
     static instance() {
-        if (!this._instance)
+        if (!this._instance) {
             this._instance = new DomainManager();
-        this._instance.addDomain(new Domain(exports.DEFAULT_DOMAIN));
+            this._instance.addDomain(new Domain(exports.DEFAULT_DOMAIN));
+        }
         return this._instance;
     }
     constructor() {

package/dist/base/meta/model-props-map.d.ts

@@ -1,6 +1,6 @@
-import { AnyModel, PropsOf } from "../model";
-export declare class ModelPropsMap<T extends AnyModel = AnyModel> extends Map<PropertyKey, keyof PropsOf<T>> {
+import { AnyModel, InferredProps } from "../model";
+export declare class ModelPropsMap<T extends AnyModel = AnyModel> extends Map<PropertyKey, keyof InferredProps<T>> {
 }
 export declare const getOwnModelPropsMap: <T extends AnyModel = AnyModel>(target: object) => ModelPropsMap<T>;
-export declare const defineModelProp: <T extends AnyModel = AnyModel>(target: object, key: PropertyKey, propTargetKey?: keyof PropsOf<T> | undefined) => void;
+export declare const defineModelProp: <T extends AnyModel = AnyModel>(target: object, key: PropertyKey, propTargetKey?: keyof InferredProps<T> | undefined) => void;
 export declare const getModelPropsMap: <T extends AnyModel = AnyModel>(target: object) => ModelPropsMap<T>;

package/dist/base/meta/model-props-validator.d.ts

@@ -1,5 +1,5 @@
-import { AnyModel, PropsOf } from "../model";
-export type ModelPropsValidator<T extends AnyModel = AnyModel> = (props: PropsOf<T>) => void;
+import { AnyModel, InferredProps } from "../model";
+export type ModelPropsValidator<T extends AnyModel = AnyModel> = (props: InferredProps<T>) => void;
 export declare const defineModelPropsValidator: <T extends AnyModel>(target: object, validator: ModelPropsValidator<T>) => void;
 export declare const getOwnModelPropsValidator: <T extends AnyModel>(target: object) => ModelPropsValidator<T> | undefined;
 export declare const ModelPropsValidatorsMetaKey: unique symbol;

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

@@ -1,11 +1,11 @@
-import { AnyModel, PropsOf } from "./model";
+import { AnyModel, InferredProps } from "./model";
 export interface IModelBuilder<T extends AnyModel = AnyModel> {
     buildSafe(): T | null;
     build(): T;
 }
 export declare abstract class ModelBuilder<T extends AnyModel = AnyModel> implements IModelBuilder<T> {
-    protected props?: PropsOf<T>;
-    withProps(props: PropsOf<T>): this;
+    protected props?: InferredProps<T>;
+    withProps(props: InferredProps<T>): this;
     abstract build(): T;
     buildSafe(): T | null;
 }

package/dist/base/model/model.d.ts

@@ -33,8 +33,8 @@ export declare class ModelBase<P extends Props> {
     protected initializeProps(props: P): void;
 }
 export type AnyModel = ModelBase<Props>;
-export type PropsOf<T extends AnyModel> = T extends ModelBase<infer P> ? P : never;
-export interface ModelClass<T extends AnyModel = AnyModel> extends Class<T>, ClassStatic<typeof ModelBase<PropsOf<T>>> {
+export type InferredProps<T extends AnyModel> = T extends ModelBase<infer P> ? P : never;
+export interface ModelClass<T extends AnyModel = AnyModel> extends Class<T>, ClassStatic<typeof ModelBase<InferredProps<T>>> {
 }
-export interface AbstractModelClass<T extends AnyModel = AnyModel> extends AbstractClass<T>, ClassStatic<typeof ModelBase<PropsOf<T>>> {
+export interface AbstractModelClass<T extends AnyModel = AnyModel> extends AbstractClass<T>, ClassStatic<typeof ModelBase<InferredProps<T>>> {
 }

package/dist/core/aggregate/aggregate-base/aggregate-event-publisher.interface.d.ts

@@ -0,0 +1,4 @@
+import { AnyEvent } from "../../message";
+export interface IAggregateEventPublisher {
+    publish(events: AnyEvent | AnyEvent[]): void;
+}

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

@@ -1,7 +1,7 @@
-import { Props, PropsOf } from "../../../base";
+import { Props, InferredProps } from "../../../base";
 import { ModelWithId, ModelWithIdMetadata } from "../../model-with-id";
 import { AnyEvent, EventClassWithTypedConstructor, EventSource } from "../../message";
-import { IAggregateEventDispatcher } from "./aggregate-event-dispatcher.interface";
+import { IAggregateEventPublisher } from "./aggregate-event-publisher.interface";
 export interface AggregateMetadata extends ModelWithIdMetadata {
     version: number;
 }
@@ -11,7 +11,7 @@ export declare abstract class AggregateBase<P extends Props> extends ModelWithId
     abstract version(): number;
     metadata(): AggregateMetadata;
     protected createEventSource(): EventSource;
-    protected newEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: PropsOf<E>): E;
-    abstract dispatchEvents(dispatcher: IAggregateEventDispatcher): void;
+    protected newEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: InferredProps<E>): E;
+    abstract publishEvents(publisher: IAggregateEventPublisher): void;
 }
 export type AnyAggregate = AggregateBase<Props>;

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

@@ -1,3 +1,3 @@
 export * from "./aggregate";
 export * from "./aggregate.builder";
-export * from "./aggregate-event-dispatcher.interface";
+export * from "./aggregate-event-publisher.interface";

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

@@ -16,4 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./aggregate"), exports);
 __exportStar(require("./aggregate.builder"), exports);
-__exportStar(require("./aggregate-event-dispatcher.interface"), exports);
+__exportStar(require("./aggregate-event-publisher.interface"), exports);

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

@@ -1,9 +1,9 @@
 import { Class } from "type-fest";
-import { Props, PropsOf } from "../../../base";
+import { Props, InferredProps } from "../../../base";
 import { ClassStatic } from "../../../types";
 import { AnyCommand, AnyEvent, EventClassWithTypedConstructor } from "../../message";
 import { AggregateBase, AggregateMetadata } from "../aggregate-base";
-import { IAggregateEventDispatcher } from "../aggregate-base";
+import { IAggregateEventPublisher } from "../aggregate-base";
 import { EventSourcedAggregateModelDescriptor } from "./event-sourced-aggregate-model-descriptor";
 import { Snapshot, SnapshotMetadata } from "./snapshot";
 import { EventSourcedAggregateBuilder } from ".";
@@ -32,18 +32,18 @@ export declare class EventSourcedAggregateBase<P extends Props> extends Aggregat
     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;
+    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[];
     snapMetadata(): SnapshotMetadata;
     snap(): Snapshot<this>;
     protected archiveEvents(): void;
-    dispatchEvents(dispatcher: IAggregateEventDispatcher): void;
+    publishEvents(publisher: IAggregateEventPublisher): 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>>> {
+export interface EventSourcedAggregateClass<T extends AnyEventSourcedAggregate = AnyEventSourcedAggregate, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof EventSourcedAggregateBase<InferredProps<T>>> {
 }
-export interface EventSourcedAggregateClassWithTypedConstructor<T extends AnyEventSourcedAggregate = AnyEventSourcedAggregate> extends EventSourcedAggregateClass<T, ConstructorParameters<typeof EventSourcedAggregateBase<PropsOf<T>>>> {
+export interface EventSourcedAggregateClassWithTypedConstructor<T extends AnyEventSourcedAggregate = AnyEventSourcedAggregate> extends EventSourcedAggregateClass<T, ConstructorParameters<typeof EventSourcedAggregateBase<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;

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

@@ -133,10 +133,8 @@ class EventSourcedAggregateBase extends aggregate_base_1.AggregateBase {
         this._events = [];
         this._pastEvents.push(...events);
     }
-    dispatchEvents(dispatcher) {
-        this.events().forEach((event) => {
-            dispatcher.dispatch(event);
-        });
+    publishEvents(publisher) {
+        publisher.publish(this.events());
         this.archiveEvents();
     }
 }

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

@@ -1,8 +1,8 @@
-import { PropsOf } from "../../../base";
+import { InferredProps } from "../../../base";
 import { AnyEventSourcedAggregate, EventSourceAggregateMetadata } from "./event-sourced-aggregate";
 export interface SnapshotMetadata extends EventSourceAggregateMetadata {
 }
 export interface Snapshot<T extends AnyEventSourcedAggregate> {
     metadata: SnapshotMetadata;
-    props: PropsOf<T>;
+    props: InferredProps<T>;
 }

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

@@ -1,8 +1,8 @@
 import { Class } from "type-fest";
-import { Props, PropsOf } from "../../../base";
+import { Props, InferredProps } from "../../../base";
 import { ClassStatic } from "../../../types";
 import { AnyEvent, EventClassWithTypedConstructor } from "../../message";
-import { AggregateBase, AggregateMetadata, IAggregateEventDispatcher } from "../aggregate-base";
+import { AggregateBase, AggregateMetadata, IAggregateEventPublisher } from "../aggregate-base";
 import { StateAggregateBuilder } from ".";
 export interface StateAggregateMetadata extends AggregateMetadata {
 }
@@ -14,12 +14,12 @@ export declare class StateAggregateBase<P extends Props> extends AggregateBase<P
     version(): number;
     events(): AnyEvent[];
     protected recordEvent<E extends AnyEvent>(event: E): void;
-    protected recordEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: PropsOf<E>): void;
+    protected recordEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: InferredProps<E>): void;
     clearEvents(): void;
-    dispatchEvents(dispatcher: IAggregateEventDispatcher): 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<PropsOf<T>>> {
+export interface StateAggregateClass<T extends AnyStateAggregate = AnyStateAggregate, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof StateAggregateBase<InferredProps<T>>> {
 }
-export interface StateAggregateClassWithTypedConstructor<T extends AnyStateAggregate = AnyStateAggregate> extends StateAggregateClass<T, ConstructorParameters<typeof StateAggregateBase<PropsOf<T>>>> {
+export interface StateAggregateClassWithTypedConstructor<T extends AnyStateAggregate = AnyStateAggregate> extends StateAggregateClass<T, ConstructorParameters<typeof StateAggregateBase<InferredProps<T>>>> {
 }

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

@@ -33,10 +33,8 @@ class StateAggregateBase extends aggregate_base_1.AggregateBase {
     clearEvents() {
         this._events = [];
     }
-    dispatchEvents(dispatcher) {
-        this.events().forEach((event) => {
-            dispatcher.dispatch(event);
-        });
+    publishEvents(publisher) {
+        publisher.publish(this.events());
         this.clearEvents();
     }
 }

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

@@ -1,5 +1,5 @@
 import { Class } from "type-fest";
-import { Props, PropsOf } from "../../base";
+import { Props, InferredProps } from "../../base";
 import { ClassStatic } from "../../types";
 import { ModelWithId, ModelWithIdMetadata } from "../model-with-id";
 import { EntityBuilder } from ".";
@@ -10,9 +10,9 @@ export declare class EntityBase<P extends Props> extends ModelWithId<P> {
     constructor(metadata: EntityMetadata, props: P);
 }
 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>>> {
+export interface EntityClass<T extends AnyEntity = AnyEntity, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof EntityBase<InferredProps<T>>> {
 }
-export interface EntityClassWithTypedConstructor<T extends AnyEntity = AnyEntity> extends EntityClass<T, ConstructorParameters<typeof EntityBase<PropsOf<T>>>> {
+export interface EntityClassWithTypedConstructor<T extends AnyEntity = AnyEntity> extends EntityClass<T, ConstructorParameters<typeof EntityBase<InferredProps<T>>>> {
 }
 export interface EntityClassWithProps<P extends Props> extends EntityClass<EntityBase<P>> {
 }

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

@@ -1,6 +1,6 @@
 import { Class } from "type-fest";
 import { CommandType } from "../../../meta";
-import { Props, PropsOf } from "../../../base";
+import { Props, InferredProps } from "../../../base";
 import { ClassStatic } from "../../../types";
 import { MessageBase, MessageMetadata } from "../message-base";
 import { CommandModelDescriptor } from "./command-model-descriptor";
@@ -18,7 +18,7 @@ export declare class CommandBase<P extends Props> extends MessageBase<P> {
     commandType(): string;
 }
 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>>> {
+export interface CommandClass<T extends AnyCommand = AnyCommand, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof CommandBase<InferredProps<T>>> {
 }
-export interface CommandClassWithTypedConstructor<T extends AnyCommand = AnyCommand> extends CommandClass<T, ConstructorParameters<typeof CommandBase<PropsOf<T>>>> {
+export interface CommandClassWithTypedConstructor<T extends AnyCommand = AnyCommand> extends CommandClass<T, ConstructorParameters<typeof CommandBase<InferredProps<T>>>> {
 }

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

@@ -1,6 +1,6 @@
 import { Class } from "type-fest";
 import { EventType } from "../../../meta";
-import { Props, PropsOf } from "../../../base";
+import { Props, InferredProps } from "../../../base";
 import { ClassStatic } from "../../../types";
 import { Id } from "../../model-with-id";
 import { MessageBase, MessageMetadata } from "../message-base";
@@ -29,7 +29,7 @@ export declare class EventBase<P extends Props> extends MessageBase<P> {
     }>;
 }
 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>>> {
+export interface EventClass<T extends AnyEvent = AnyEvent, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof EventBase<InferredProps<T>>> {
 }
-export interface EventClassWithTypedConstructor<T extends AnyEvent = AnyEvent> extends EventClass<T, ConstructorParameters<typeof EventBase<PropsOf<T>>>> {
+export interface EventClassWithTypedConstructor<T extends AnyEvent = AnyEvent> extends EventClass<T, ConstructorParameters<typeof EventBase<InferredProps<T>>>> {
 }

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

@@ -1,5 +1,5 @@
 import { Class } from "type-fest";
-import { Props, PropsOf } from "../../../base";
+import { Props, InferredProps } from "../../../base";
 import { ClassStatic } from "../../../types";
 import { ModelWithId, ModelWithIdMetadata } from "../../model-with-id";
 export interface CorrelationIds {
@@ -25,7 +25,7 @@ export declare class MessageBase<P extends Props> extends ModelWithId<P> {
     setCorrelationIds(correlationIds: CorrelationIds): 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 MessageClass<T extends AnyMessage = AnyMessage, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof MessageBase<InferredProps<T>>> {
 }
-export interface MessageClassWithTypedConstructor<T extends AnyMessage = AnyMessage> extends MessageClass<T, ConstructorParameters<typeof MessageBase<PropsOf<T>>>> {
+export interface MessageClassWithTypedConstructor<T extends AnyMessage = AnyMessage> extends MessageClass<T, ConstructorParameters<typeof MessageBase<InferredProps<T>>>> {
 }

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

@@ -1,5 +1,5 @@
 import { Class } from "type-fest";
-import { ModelBase, Props, PropsOf } from "../../base";
+import { ModelBase, Props, InferredProps } from "../../base";
 import { ClassStatic } from "../../types";
 export declare class ValueObjectBase<P extends Props> extends ModelBase<P> {
     constructor(props: P);
@@ -11,7 +11,7 @@ export declare class ValueObjectBase<P extends Props> extends ModelBase<P> {
     protected getEqualityObject(): any;
 }
 export type AnyValueObject = ValueObjectBase<Props>;
-export interface ValueObjectClass<T extends AnyValueObject = AnyValueObject> extends Class<T>, ClassStatic<typeof ValueObjectBase<PropsOf<T>>> {
+export interface ValueObjectClass<T extends AnyValueObject = AnyValueObject> extends Class<T>, ClassStatic<typeof ValueObjectBase<InferredProps<T>>> {
 }
-export interface ValueObjectClassWithTypedConstructor<T extends AnyValueObject = AnyValueObject> extends Class<T, ConstructorParameters<typeof ValueObjectBase<PropsOf<T>>>> {
+export interface ValueObjectClassWithTypedConstructor<T extends AnyValueObject = AnyValueObject> extends Class<T, ConstructorParameters<typeof ValueObjectBase<InferredProps<T>>>> {
 }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "ddd-node",
-  "version": "27.0.0",
+  "version": "29.0.0",
   "description": "Domain Driven Design base for NodeJs",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "build": "rm -rf dist && tsc -p src/tsconfig.build.json && tsc-alias -p src/tsconfig.build.json && node setup-package.js",
+    "build": "rm -rf dist && tsc -p src/tsconfig.build.json && tsc-alias -p src/tsconfig.build.json",
     "test": "mocha"
   },
   "files": [
@@ -34,13 +34,13 @@
     "chai-deep-match": "^1.2.1",
     "ddd-node": "file:dist",
     "mocha": "^10.4.0",
-    "ts-node": "^10.9.1",
     "tsconfig-paths": "^4.2.0",
     "typescript": "^5.2.2"
   },
   "dependencies": {
     "lodash": "^4.17.21",
     "reflect-metadata": "^0.1.13",
+    "ts-node": "^10.9.2",
     "tsc-alias": "^1.8.8",
     "type-fest": "^4.20.1",
     "uuid": "^9.0.1"

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

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

package/dist/package.json

@@ -1 +0,0 @@
-{"name":"ddd-node","version":"27.0.0","description":"Domain Driven Design base for NodeJs","type":"commonjs","main":"index.js","types":"index.d.ts","files":["dist"],"repository":{"type":"git","url":"https://github.com/nqd881/ddd-node"},"keywords":["ddd","ddd-node","ddd-base","ddd-ts","ddd-js"],"author":"Quoc Dai","license":"ISC","devDependencies":{"@types/chai":"^4.3.16","@types/lodash":"^4.14.200","@types/mocha":"^10.0.6","@types/uuid":"^9.0.6","chai":"^5.1.1","chai-deep-match":"^1.2.1","ddd-node":"file:dist","mocha":"^10.4.0","ts-node":"^10.9.1","tsconfig-paths":"^4.2.0","typescript":"^5.2.2"},"dependencies":{"lodash":"^4.17.21","reflect-metadata":"^0.1.13","tsc-alias":"^1.8.8","type-fest":"^4.20.1","uuid":"^9.0.1"}}