ddd-node 16.3.0 → 16.4.0

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();

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/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";
+export type CommandType = string;
 export interface CommandMetadata extends Omit<MessageMetadata, "messageType"> {
 }
 export declare class CommandBase<P extends Props> extends MessageBase<P> {
     static readonly COMMAND_MESSAGE_TYPE = "command";
     constructor(metadata: CommandMetadata, props: P);
-    static commandType(): 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,6 +3,7 @@ import { Class } from "type-fest";
 import { Id } from "../id";
 import { Props, PropsOf } from "../model";
 import { MessageBase, MessageContext, MessageMetadata } from "./message";
+export type EventType = string;
 export type EventSource = Readonly<{
     aggregate: string;
     id: Id;
@@ -15,7 +16,7 @@ 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;

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

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

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

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;
+import { CommandType } from "../core";
+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;
+import { EventType } from "../core";
+export declare const setEventType: (target: object, eventType: EventType) => void;
+export declare const getEventType: (target: object) => EventType | undefined;

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":"16.4.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": "16.4.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";