ddd-node 16.3.0 → 17.0.0

package/dist/core/aggregate/base.js

@@ -9,9 +9,9 @@ class AggregateBase extends entity_1.EntityBase {
     }
     newEvent(eventClass, props) {
         const eventSource = {
-            aggregate: this.modelName(),
-            id: this.id(),
-            version: this.version(),
+            aggregateModel: this.modelName(),
+            aggregateId: this.id(),
+            aggregateVersion: this.version(),
         };
         return eventClass.newEvent(eventSource, props);
     }

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

@@ -38,13 +38,13 @@ class EventSourcedAggregateBase extends base_1.AggregateBase {
         return this._version + this._pastEvents.length + this._events.length;
     }
     pastEvents() {
-        return [...this._pastEvents];
+        return Array.from(this._pastEvents);
     }
     events() {
-        return [...this._events];
+        return Array.from(this._events);
     }
     handledCommands() {
-        return [...this._handledCommands];
+        return Array.from(this._handledCommands);
     }
     eventApplierMap() {
         return this.constructor.eventApplierMap();
@@ -61,11 +61,11 @@ class EventSourcedAggregateBase extends base_1.AggregateBase {
     }
     validateEventBeforeApply(event) {
         const eventSource = event.source();
-        if (eventSource.aggregate !== this.modelName())
+        if (eventSource.aggregateModel !== this.modelName())
             throw new Error("Invalid source type");
-        if (!eventSource.id.equals(this._id))
+        if (!eventSource.aggregateId.equals(this._id))
             throw new Error("Invalid source id");
-        if (eventSource.version !== this.version())
+        if (eventSource.aggregateVersion !== this.version())
             throw new Error("Invalid source version");
     }
     _applyEvent(event) {

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

@@ -4,7 +4,9 @@ import { Id } from "../id";
 import { AnyEvent, EventClass } from "../message";
 import { Props, PropsOf } from "../model";
 import { AggregateBase, AggregateMetadata } from "./base";
-import { IEventPublisher } from "../abstraction/event-publisher";
+export interface IEventDispatcher {
+    dispatch(event: AnyEvent): void;
+}
 export declare class StateAggregateBase<P extends Props> extends AggregateBase<P> {
     private _events;
     constructor(metadata: AggregateMetadata, props: P);
@@ -14,8 +16,8 @@ export declare class StateAggregateBase<P extends Props> extends AggregateBase<P
     events(): AnyEvent[];
     protected recordEvent<E extends AnyEvent>(event: E): void;
     protected recordEvent<E extends AnyEvent>(eventClass: EventClass<E>, props: PropsOf<E>): void;
-    publishEvents(eventPublisher: IEventPublisher): Promise<void>;
     clearEvents(): void;
+    dispatchEvents(dispatcher: IEventDispatcher): 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>>> {

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

@@ -20,7 +20,7 @@ class StateAggregateBase extends base_1.AggregateBase {
         return this._version;
     }
     events() {
-        return [...this._events];
+        return Array.from(this._events);
     }
     recordEvent(param1, param2) {
         let event;
@@ -32,12 +32,14 @@ class StateAggregateBase extends base_1.AggregateBase {
         }
         this._events.push(event);
     }
-    async publishEvents(eventPublisher) {
-        await eventPublisher.publishAll(this.events());
-        this.clearEvents();
-    }
     clearEvents() {
         this._events = [];
     }
+    dispatchEvents(dispatcher) {
+        this.events().forEach((event) => {
+            dispatcher.dispatch(event);
+        });
+        this.clearEvents();
+    }
 }
 exports.StateAggregateBase = StateAggregateBase;

package/dist/core/domain.d.ts

@@ -1,19 +1,17 @@
+import { ModelName, ModelVersion } from "../meta";
 import { AnyModel, ModelClass } from "./model";
-type ModelName = string;
-type ModelVersion = number;
 export declare class ModelVersionRegistry<T extends AnyModel = AnyModel> extends Map<ModelVersion, ModelClass<T>> {
 }
 export declare class ModelRegistry<T extends AnyModel = AnyModel> extends Map<ModelName, ModelVersionRegistry<T>> {
 }
 export type DomainName = string;
 export declare class Domain {
-    readonly name?: DomainName;
+    readonly name: DomainName;
     private readonly modelRegistry;
-    constructor(name?: DomainName);
+    constructor(name: DomainName);
     getModelVersionRegistry(modelName: ModelName): ModelVersionRegistry<AnyModel>;
     getModel(modelName: ModelName, modelVersion?: ModelVersion): ModelClass<AnyModel> | undefined;
     hasRegisteredModel(modelName: ModelName, modelVersion: ModelVersion): boolean;
     hasRegisteredModel(model: ModelClass): boolean;
     registerModel(modelClass: ModelClass): this;
 }
-export {};

package/dist/core/enum.js

@@ -7,7 +7,7 @@ class EnumBase extends model_1.ModelBase {
         return Array.from(this.ownStaticValues().values()).map((staticValue) => staticValue.value);
     }
     static parseSafe(providedValue) {
-        let key;
+        let key = undefined;
         this.ownStaticValues().forEach((staticValue, staticValueKey) => {
             if (staticValue.value instanceof this) {
                 const staticEnum = staticValue.value;

package/dist/core/event-pubsub/event-publisher.d.ts

@@ -0,0 +1,10 @@
+import { AnyEvent } from "../message";
+import { IEventSubscriberRegistry } from "./event-subscriber-registry";
+export interface IEventPublisher {
+    publish<T extends AnyEvent = AnyEvent>(event: T): Promise<void>;
+}
+export declare class EventPublisher implements IEventPublisher {
+    private subscriberRegistry;
+    constructor(subscriberRegistry: IEventSubscriberRegistry);
+    publish<T extends AnyEvent = AnyEvent>(event: T): Promise<void>;
+}

package/dist/core/event-pubsub/event-publisher.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventPublisher = void 0;
+class EventPublisher {
+    constructor(subscriberRegistry) {
+        this.subscriberRegistry = subscriberRegistry;
+    }
+    async publish(event) {
+        const subscribers = this.subscriberRegistry.getSubscribersForEvent(event.constructor);
+        await Promise.all(subscribers.map((subscriber) => subscriber.handleEvent(event)));
+    }
+}
+exports.EventPublisher = EventPublisher;

package/dist/core/event-pubsub/event-subscriber-registry.d.ts

@@ -0,0 +1,25 @@
+import { AnyEvent, EventClass } from "../message";
+import { IEventSubscriber } from "./event-subscriber";
+export type Unsubscriber = () => void;
+export interface IEventSubscriberRegistry {
+    registerSubscriber(subscriber: IEventSubscriber): Unsubscriber;
+    deregisterSubscriber(subscriber: IEventSubscriber): void;
+    getSubscribersForEvent<T extends AnyEvent = AnyEvent>(eventType: EventClass<T>): IEventSubscriber<T>[];
+    getSubscribers(): IEventSubscriber[];
+}
+export declare class EventSubscriberRegistry implements IEventSubscriberRegistry {
+    private static _instance;
+    static instance(): EventSubscriberRegistry;
+    private _subscribers;
+    constructor(subscribers?: IEventSubscriber[]);
+    private _setSubscribersForEvent;
+    private _initSubscribersForEvent;
+    private _getSubscribersForEvent;
+    private _hasSubscriber;
+    private _addSubscriber;
+    private _removeSubscriber;
+    registerSubscriber(subscriber: IEventSubscriber): () => void;
+    deregisterSubscriber(subscriber: IEventSubscriber<AnyEvent>): void;
+    getSubscribersForEvent<T extends AnyEvent = AnyEvent>(eventType: EventClass<T, any[]>): IEventSubscriber<T>[];
+    getSubscribers(): IEventSubscriber[];
+}

package/dist/core/event-pubsub/event-subscriber-registry.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSubscriberRegistry = void 0;
+class EventSubscriberRegistry {
+    static instance() {
+        if (!this._instance)
+            this._instance = new EventSubscriberRegistry();
+        return this._instance;
+    }
+    constructor(subscribers = []) {
+        this._subscribers = new Map();
+        subscribers.forEach((subscriber) => {
+            this.registerSubscriber(subscriber);
+        });
+    }
+    _setSubscribersForEvent(eventType, subscribers) {
+        this._subscribers.set(eventType, subscribers);
+    }
+    _initSubscribersForEvent(eventType) {
+        this._setSubscribersForEvent(eventType, []);
+    }
+    _getSubscribersForEvent(eventType) {
+        const subscribers = () => this._subscribers.get(eventType);
+        if (!subscribers())
+            this._initSubscribersForEvent(eventType);
+        return subscribers();
+    }
+    _hasSubscriber(subscriber) {
+        const subscribedEvent = subscriber.subscribeToEvent();
+        const subscribers = this._getSubscribersForEvent(subscribedEvent);
+        return subscribers.some((_subscriber) => _subscriber === subscriber);
+    }
+    _addSubscriber(subscriber) {
+        if (!this._hasSubscriber(subscriber)) {
+            const subscribedEvent = subscriber.subscribeToEvent();
+            const subscribers = this._getSubscribersForEvent(subscribedEvent);
+            subscribers.push(subscriber);
+        }
+    }
+    _removeSubscriber(subscriber) {
+        const subscribedEvent = subscriber.subscribeToEvent();
+        const subscribers = this._getSubscribersForEvent(subscribedEvent);
+        this._setSubscribersForEvent(subscribedEvent, subscribers.filter((_subscriber) => _subscriber !== subscriber));
+    }
+    registerSubscriber(subscriber) {
+        this._addSubscriber(subscriber);
+        return () => this.deregisterSubscriber(subscriber);
+    }
+    deregisterSubscriber(subscriber) {
+        this._removeSubscriber(subscriber);
+    }
+    getSubscribersForEvent(eventType) {
+        return Array.from(this._getSubscribersForEvent(eventType));
+    }
+    getSubscribers() {
+        return Array.from(this._subscribers.values()).flat();
+    }
+}
+exports.EventSubscriberRegistry = EventSubscriberRegistry;

package/dist/core/event-pubsub/event-subscriber.d.ts

@@ -0,0 +1,13 @@
+import { AnyEvent, EventClass } from "../message";
+export interface IEventSubscriber<T extends AnyEvent = AnyEvent> {
+    subscribeToEvent(): EventClass<T>;
+    handleEvent(event: T): Promise<void>;
+}
+export type EventSubscriberHandler<T extends AnyEvent = AnyEvent> = IEventSubscriber<T>["handleEvent"];
+export declare class EventSubscriber<T extends AnyEvent = AnyEvent> implements IEventSubscriber<T> {
+    private readonly subscribedEvent;
+    private readonly eventHandler;
+    constructor(subscribedEvent: EventClass<T>, eventHandler: EventSubscriberHandler<T>);
+    subscribeToEvent(): EventClass<T, any[]>;
+    handleEvent(event: T): Promise<void>;
+}

package/dist/core/event-pubsub/event-subscriber.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSubscriber = void 0;
+class EventSubscriber {
+    constructor(subscribedEvent, eventHandler) {
+        this.subscribedEvent = subscribedEvent;
+        this.eventHandler = eventHandler;
+    }
+    subscribeToEvent() {
+        return this.subscribedEvent;
+    }
+    handleEvent(event) {
+        return this.eventHandler(event);
+    }
+}
+exports.EventSubscriber = EventSubscriber;

package/dist/core/event-pubsub/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./event-subscriber";
+export * from "./event-publisher";
+export * from "./event-subscriber-registry";

package/dist/core/event-pubsub/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-subscriber"), exports);
+__exportStar(require("./event-publisher"), exports);
+__exportStar(require("./event-subscriber-registry"), exports);

package/dist/core/index.d.ts

@@ -5,5 +5,6 @@ export * from "./entity";
 export * from "./enum";
 export * from "./message";
 export * from "./value-object";
-export * from "./abstraction";
+export * from "./repository";
 export * from "./domain";
+export * from "./event-pubsub";

package/dist/core/index.js

@@ -21,5 +21,6 @@ __exportStar(require("./entity"), exports);
 __exportStar(require("./enum"), exports);
 __exportStar(require("./message"), exports);
 __exportStar(require("./value-object"), exports);
-__exportStar(require("./abstraction"), exports);
+__exportStar(require("./repository"), exports);
 __exportStar(require("./domain"), exports);
+__exportStar(require("./event-pubsub"), exports);

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

@@ -2,12 +2,13 @@ import { ClassStatic } from "../../types";
 import { Class } from "type-fest";
 import { Props, PropsOf } from "../model";
 import { MessageBase, MessageContext, MessageMetadata } from "./message";
+import { CommandType } from "../../meta";
 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(): string;
+    static commandType(): CommandType;
     static newCommand<T extends AnyCommand>(this: CommandClassWithTypedConstructor<T>, props: PropsOf<T>, context?: MessageContext, timestamp?: number): T;
     commandType(): string;
 }

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

@@ -3,10 +3,11 @@ import { Class } from "type-fest";
 import { Id } from "../id";
 import { Props, PropsOf } from "../model";
 import { MessageBase, MessageContext, MessageMetadata } from "./message";
+import { EventType } from "../../meta";
 export type EventSource = Readonly<{
-    aggregate: string;
-    id: Id;
-    version: number;
+    aggregateModel: string;
+    aggregateId: Id;
+    aggregateVersion: number;
 }>;
 export interface EventMetadata extends Omit<MessageMetadata, "messageType"> {
     source: EventSource;
@@ -15,12 +16,12 @@ 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(): string;
+    static eventType(): EventType;
     static newEvent<T extends AnyEvent>(this: EventClassWithTypedConstructor<T>, source: EventSource, props: PropsOf<T>, context?: MessageContext, timestamp?: number): T;
     source(): Readonly<{
-        aggregate: string;
-        id: Id;
-        version: number;
+        aggregateModel: string;
+        aggregateId: Id;
+        aggregateVersion: number;
     }>;
     eventType(): string;
 }

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

@@ -16,7 +16,7 @@ export declare class ModelBase<P extends Props> {
     static modelVersion<T extends AnyModel>(this: ModelClass<T>): number;
     static ownPropsValidator<T extends AnyModel>(this: ModelClass<T>): import("../../meta").PropsValidator<T> | undefined;
     static propsValidators<T extends AnyModel>(this: ModelClass<T>): import("../../meta").PropsValidator<AnyModel>[];
-    static ownStaticValues<T extends AnyModel>(this: ModelClass<T>): Map<string | symbol, import("../../meta").StaticValue<T>>;
+    static ownStaticValues<T extends AnyModel>(this: ModelClass<T>): Map<PropertyKey, import("../../meta").StaticValue<T>>;
     static ownPropsMap(): import("../../meta").PropsMap<ModelBase<any>>;
     static propsMap(): import("../../meta").PropsMap<ModelBase<any>>;
     constructor();

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

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

package/dist/core/{abstraction → repository}/index.js

@@ -14,5 +14,4 @@ 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-publisher"), exports);
 __exportStar(require("./repository"), exports);

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

@@ -1,2 +1,3 @@
 import { AnyCommand, CommandClass } from "../../core";
-export declare const Command: (commandType: string) => <T extends AnyCommand>(target: CommandClass<T, any[]>) => void;
+import { CommandType } from "../../meta";
+export declare const Command: (commandType: CommandType) => <T extends AnyCommand>(target: CommandClass<T, any[]>) => void;

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

@@ -1,2 +1,3 @@
 import { AnyEvent, EventClass } from "../../core";
-export declare const Event: (eventType: string) => <T extends AnyEvent>(target: EventClass<T, any[]>) => void;
+import { EventType } from "../../meta";
+export declare const Event: (eventType: EventType) => <T extends AnyEvent>(target: EventClass<T, any[]>) => void;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./meta";
-export * from "./core";
-export * from "./decorators";
 export * from "./types";
 export * from "./utils";
+export * from "./core";
+export * from "./decorators";

package/dist/index.js

@@ -15,7 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./meta"), exports);
-__exportStar(require("./core"), exports);
-__exportStar(require("./decorators"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils"), exports);
+__exportStar(require("./core"), exports);
+__exportStar(require("./decorators"), exports);

package/dist/meta/command.metadata.d.ts

@@ -1,3 +1,4 @@
 import "reflect-metadata";
-export declare const setCommandType: (target: object, commandType: string) => void;
-export declare const getCommandType: (target: object) => string | undefined;
+export type CommandType = string;
+export declare const setCommandType: (target: object, commandType: CommandType) => void;
+export declare const getCommandType: (target: object) => CommandType | undefined;

package/dist/meta/event.metadata.d.ts

@@ -1,3 +1,4 @@
 import "reflect-metadata";
-export declare const setEventType: (target: object, eventType: string) => void;
-export declare const getEventType: (target: object) => string | undefined;
+export type EventType = string;
+export declare const setEventType: (target: object, eventType: EventType) => void;
+export declare const getEventType: (target: object) => EventType | undefined;

package/dist/meta/model.metadata.d.ts

@@ -5,15 +5,17 @@ export declare class PropsMap<T extends AnyModel = AnyModel> extends Map<PropKey
 export declare const getOwnPropsMap: <T extends AnyModel = AnyModel>(target: T) => PropsMap<T>;
 export declare const setProp: <T extends AnyModel = AnyModel>(target: T, key: PropKey, propTargetKey?: keyof PropsOf<T> | undefined) => void;
 export declare const getPropsMap: <T extends AnyModel = AnyModel>(target: T) => PropsMap<T>;
-export declare const setModelName: <T extends AnyModel>(target: ModelClass<T>, name: string) => void;
-export declare const getModelName: <T extends AnyModel>(target: ModelClass<T>) => string;
-export declare const setModelVersion: <T extends AnyModel>(target: ModelClass<T>, version: number) => void;
-export declare const getModelVersion: <T extends AnyModel>(target: ModelClass<T>) => number;
+export type ModelName = string;
+export declare const setModelName: <T extends AnyModel>(target: ModelClass<T>, name: ModelName) => void;
+export declare const getModelName: <T extends AnyModel>(target: ModelClass<T>) => ModelName;
+export type ModelVersion = number;
+export declare const setModelVersion: <T extends AnyModel>(target: ModelClass<T>, version: ModelVersion) => void;
+export declare const getModelVersion: <T extends AnyModel>(target: ModelClass<T>) => ModelVersion;
 export type PropsValidator<T extends AnyModel = AnyModel> = (props: PropsOf<T>) => void;
 export declare const setPropsValidator: <T extends AnyModel>(target: object, validator: PropsValidator<T>) => void;
 export declare const getOwnPropsValidator: <T extends AnyModel>(target: object) => PropsValidator<T> | undefined;
 export declare const PropsValidatorsMetaKey: unique symbol;
-export declare const getPropsValidators: (target: object) => PropsValidator<AnyModel>[];
-export declare const getOwnStaticValues: <T extends AnyModel>(target: object) => Map<string | symbol, StaticValue<T>>;
-export declare const setStaticValue: <T extends AnyModel>(target: object, key: string, value: T | StaticValueBuilder<T>) => void;
+export declare const getPropsValidators: (target: object) => PropsValidator[];
+export declare const getOwnStaticValues: <T extends AnyModel>(target: object) => Map<PropertyKey, StaticValue<T>>;
+export declare const setStaticValue: <T extends AnyModel>(target: object, key: PropertyKey, value: T | StaticValueBuilder<T>) => void;
 export declare const getStaticValue: (target: object, key: string | symbol) => AnyModel | undefined;

package/dist/meta/model.metadata.js

@@ -50,7 +50,6 @@ const getPropsMap = (target) => {
     return propsMap();
 };
 exports.getPropsMap = getPropsMap;
-//
 const ModelNameMetaKey = Symbol.for("MODEL_NAME");
 const setModelName = (target, name) => {
     Reflect.defineMetadata(ModelNameMetaKey, name, target);
@@ -63,7 +62,6 @@ const getModelName = (target) => {
     return modelName();
 };
 exports.getModelName = getModelName;
-//
 const ModelVersionMetaKey = Symbol.for("MODEL_VERSION");
 const setModelVersion = (target, version) => {
     Reflect.defineMetadata(ModelVersionMetaKey, version, target);

package/dist/package.json

@@ -1 +1 @@
-{"name":"ddd-node","version":"16.3.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","nodejs-snowflake":"^2.0.1","reflect-metadata":"^0.1.13","tsc-alias":"^1.8.8","type-fest":"^4.15.0","uuid":"^9.0.1"}}
+{"name":"ddd-node","version":"17.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","nodejs-snowflake":"^2.0.1","reflect-metadata":"^0.1.13","tsc-alias":"^1.8.8","type-fest":"^4.15.0","uuid":"^9.0.1"}}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ddd-node",
-  "version": "16.3.0",
+  "version": "17.0.0",
   "description": "Domain Driven Design base for NodeJs",
   "type": "module",
   "main": "dist/index.js",

package/dist/core/abstraction/event-publisher.d.ts

@@ -1,5 +0,0 @@
-import { AnyEvent } from "../message";
-export interface IEventPublisher {
-    publish(event: AnyEvent): Promise<void>;
-    publishAll(events: AnyEvent[]): Promise<void>;
-}

package/dist/core/abstraction/event-publisher.js

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

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

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