ddd-node 29.2.0 → 29.4.0

package/dist/core/value-object/value-object.js

@@ -0,0 +1,64 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var ValueObjectBase_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueObjectBase = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const base_1 = require("../../base");
+let ValueObjectBase = ValueObjectBase_1 = class ValueObjectBase extends base_1.ModelBase {
+    constructor(props) {
+        super();
+        this.initializeProps(props);
+    }
+    props() {
+        return super.props();
+    }
+    equals(vo) {
+        const equalsType = vo instanceof this.constructor;
+        const equalsValue = this.getEqualityValue() === vo.getEqualityValue();
+        return equalsType && equalsValue;
+    }
+    with(props) {
+        const newProps = lodash_1.default.merge(this.props(), props);
+        return new this.constructor(newProps);
+    }
+    clone() {
+        return this.with({});
+    }
+    getEqualityValue() {
+        return JSON.stringify(this.getEqualityObject());
+    }
+    getEqualityObject() {
+        const result = {};
+        const props = this.props();
+        const valueOf = (v) => v instanceof ValueObjectBase_1 ? v.getEqualityObject() : v;
+        for (let [key, value] of Object.entries(props)) {
+            if (Array.isArray(value)) {
+                result[key] = value.map((v) => valueOf(v));
+                const stringValueOf = (v) => JSON.stringify(v);
+                result[key].sort((a, b) => {
+                    return stringValueOf(a).localeCompare(stringValueOf(b));
+                });
+                continue;
+            }
+            result[key] = valueOf(value);
+        }
+        return result;
+    }
+};
+exports.ValueObjectBase = ValueObjectBase;
+exports.ValueObjectBase = ValueObjectBase = ValueObjectBase_1 = __decorate([
+    (0, base_1.Mutable)(false),
+    __metadata("design:paramtypes", [Object])
+], ValueObjectBase);

package/dist/decorators/aggregate-es/handle.d.ts

@@ -0,0 +1,2 @@
+import { AnyCommand, AnyEventSourcedAggregate, CommandClass, CommandHandler } from "../../core";
+export declare const Handle: <T extends AnyCommand>(commandClass: CommandClass<T, any[]>) => <U extends CommandHandler<T>>(target: AnyEventSourcedAggregate, propertyKey: string, descriptor: TypedPropertyDescriptor<U>) => void;

package/dist/decorators/aggregate-es/handle.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Handle = void 0;
+const meta_1 = require("../../meta");
+const Handle = (commandClass) => {
+    return (target, propertyKey, descriptor) => {
+        if (typeof descriptor.value === "function") {
+            const commandType = commandClass.commandType();
+            (0, meta_1.defineCommandHandler)(target, commandType, descriptor.value);
+        }
+    };
+};
+exports.Handle = Handle;

package/dist/decorators/aggregate-es/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./handle";
+export * from "./when";

package/dist/decorators/aggregate-es/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("./handle"), exports);
+__exportStar(require("./when"), exports);

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

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

package/dist/decorators/aggregate-es/when.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.When = void 0;
+const meta_1 = require("../../meta");
+const When = (eventClass) => {
+    return (target, propertyKey, descriptor) => {
+        if (typeof descriptor.value === "function") {
+            const eventType = eventClass.eventType();
+            (0, meta_1.defineEventApplier)(target, eventType, descriptor.value);
+        }
+    };
+};
+exports.When = When;

package/dist/decorators/enum.d.ts

@@ -0,0 +1,2 @@
+import { EnumClass, EnumValue } from "../core";
+export declare const Enum: (value?: EnumValue) => <T extends EnumClass<import("../core").EnumBase, any[]>>(target: T, key: string) => void;

package/dist/decorators/enum.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Enum = void 0;
+const base_1 = require("../base");
+const Enum = (value) => {
+    return (target, key) => {
+        (0, base_1.Static)(() => new target(value ?? key))(target, key);
+    };
+};
+exports.Enum = Enum;

package/dist/decorators/index.d.ts

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

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

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

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

package/dist/decorators/message/command.js

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

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

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

package/dist/decorators/message/event.js

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

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

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

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

package/dist/decorators/type.d.ts

@@ -0,0 +1,2 @@
+import { Class } from "type-fest";
+export type TypedClassDecorator<T extends Class<any> = Class<any>> = (target: T) => T | void;

package/dist/decorators/type.js

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

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

@@ -0,0 +1 @@
+export * from "./subscribe-to-events";

package/dist/event-pubsub/decorators/index.js

@@ -0,0 +1,17 @@
+"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("./subscribe-to-events"), exports);

package/dist/event-pubsub/decorators/subscribe-to-events.d.ts

@@ -0,0 +1,5 @@
+import { Class } from "type-fest";
+import { EventClass } from "../../core";
+import { IEventSubscriber } from "../interfaces";
+export declare const SubscribedEventsMetaKey: unique symbol;
+export declare const SubscribeToEvents: <T extends EventClass<import("../../core").AnyEvent, any[]>>(subscribedEvents: T | T[]) => (target: Class<IEventSubscriber<InstanceType<T>>>) => void;

package/dist/event-pubsub/decorators/subscribe-to-events.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscribeToEvents = exports.SubscribedEventsMetaKey = void 0;
+const utils_1 = require("../../utils");
+exports.SubscribedEventsMetaKey = Symbol.for("SUBSCRIBED_EVENTS");
+const SubscribeToEvents = (subscribedEvents) => {
+    return (target) => {
+        Reflect.defineMetadata(exports.SubscribedEventsMetaKey, (0, utils_1.toArray)(subscribedEvents), target);
+    };
+};
+exports.SubscribeToEvents = SubscribeToEvents;

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

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

package/dist/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.getAllSubscribersForEvent(event.constructor);
+        await Promise.all(subscribers.map((subscriber) => subscriber.handleEvent(event)));
+    }
+}
+exports.EventPublisher = EventPublisher;

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

@@ -0,0 +1,23 @@
+import { AnyEvent, EventClass } from "../core";
+import { IEventSubscriber, IEventSubscriberRegistry, IGlobalEventSubscriber, Unsubscriber } from "./interfaces";
+export declare class EventSubscriberRegistry implements IEventSubscriberRegistry {
+    private static _instance;
+    static instance(): EventSubscriberRegistry;
+    private _globalSubscribers;
+    private _subscribers;
+    constructor(subscribers?: IEventSubscriber[]);
+    private _setSubscribersForEvent;
+    private _initSubscribersForEvent;
+    private _getSubscribersForEvent;
+    private _hasSubscriber;
+    private _addSubscriber;
+    private _removeSubscriber;
+    registerGlobalSubscriber(subscriber: IGlobalEventSubscriber): Unsubscriber;
+    deregisterGlobalSubscriber(subscriber: IGlobalEventSubscriber): void;
+    registerSubscriber(subscriber: IEventSubscriber): Unsubscriber;
+    deregisterSubscriber(subscriber: IEventSubscriber<AnyEvent>): void;
+    getGlobalSubscribers(): IGlobalEventSubscriber[];
+    getSubscribers(): IEventSubscriber[];
+    getSubscribersForEvent<T extends AnyEvent = AnyEvent>(eventType: EventClass<T>): IEventSubscriber<T>[];
+    getAllSubscribersForEvent<T extends AnyEvent = AnyEvent>(eventType: EventClass<T>): (IGlobalEventSubscriber | IEventSubscriber<T>)[];
+}

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSubscriberRegistry = void 0;
+const utils_1 = require("../utils");
+class EventSubscriberRegistry {
+    static instance() {
+        if (!this._instance)
+            this._instance = new EventSubscriberRegistry();
+        return this._instance;
+    }
+    constructor(subscribers = []) {
+        this._globalSubscribers = new Set();
+        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(subscribedEvent, subscriber) {
+        const subscribers = this._getSubscribersForEvent(subscribedEvent);
+        return subscribers.some((_subscriber) => _subscriber === subscriber);
+    }
+    _addSubscriber(subscribedEvent, subscriber) {
+        if (!this._hasSubscriber(subscribedEvent, subscriber)) {
+            const subscribers = this._getSubscribersForEvent(subscribedEvent);
+            subscribers.push(subscriber);
+        }
+    }
+    _removeSubscriber(subscribedEvent, subscriber) {
+        const subscribers = this._getSubscribersForEvent(subscribedEvent);
+        this._setSubscribersForEvent(subscribedEvent, subscribers.filter((_subscriber) => _subscriber !== subscriber));
+    }
+    registerGlobalSubscriber(subscriber) {
+        this._globalSubscribers.add(subscriber);
+        return () => this.deregisterGlobalSubscriber(subscriber);
+    }
+    deregisterGlobalSubscriber(subscriber) {
+        this._globalSubscribers.delete(subscriber);
+    }
+    registerSubscriber(subscriber) {
+        const subscribedEvents = (0, utils_1.toArray)(subscriber.subscribeToEvents());
+        subscribedEvents.forEach((subscribedEvent) => {
+            this._addSubscriber(subscribedEvent, subscriber);
+        });
+        return () => this.deregisterSubscriber(subscriber);
+    }
+    deregisterSubscriber(subscriber) {
+        const subscribedEvents = (0, utils_1.toArray)(subscriber.subscribeToEvents());
+        subscribedEvents.forEach((subscribedEvent) => {
+            this._removeSubscriber(subscribedEvent, subscriber);
+        });
+    }
+    getGlobalSubscribers() {
+        return Array.from(this._globalSubscribers);
+    }
+    getSubscribers() {
+        return Array.from(this._subscribers.values()).flat();
+    }
+    getSubscribersForEvent(eventType) {
+        return Array.from(this._getSubscribersForEvent(eventType));
+    }
+    getAllSubscribersForEvent(eventType) {
+        return [
+            ...this.getGlobalSubscribers(),
+            ...this.getSubscribersForEvent(eventType),
+        ];
+    }
+}
+exports.EventSubscriberRegistry = EventSubscriberRegistry;

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

@@ -0,0 +1,13 @@
+import { AnyEvent, EventClass } from "../core";
+import { EventSubscriberHandler, IEventSubscriber } from "./interfaces";
+export declare abstract class EventSubscriber<T extends AnyEvent = AnyEvent> implements IEventSubscriber<T> {
+    subscribeToEvents(): EventClass<T, any[]> | EventClass<T, any[]>[];
+    abstract handleEvent(event: T): Promise<void>;
+}
+export declare class DynamicEventSubscriber<T extends AnyEvent = AnyEvent> implements IEventSubscriber<T> {
+    private readonly subscribedEvents;
+    private readonly eventHandler;
+    constructor(subscribedEvents: EventClass<T> | EventClass<T>[], eventHandler: EventSubscriberHandler<T>);
+    subscribeToEvents(): EventClass<T, any[]> | EventClass<T, any[]>[];
+    handleEvent(event: T): Promise<void>;
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicEventSubscriber = exports.EventSubscriber = void 0;
+const decorators_1 = require("./decorators");
+class EventSubscriber {
+    subscribeToEvents() {
+        const subscribedEvents = Reflect.getOwnMetadata(decorators_1.SubscribedEventsMetaKey, this.constructor) ?? [];
+        return subscribedEvents;
+    }
+}
+exports.EventSubscriber = EventSubscriber;
+class DynamicEventSubscriber {
+    constructor(subscribedEvents, eventHandler) {
+        this.subscribedEvents = subscribedEvents;
+        this.eventHandler = eventHandler;
+    }
+    subscribeToEvents() {
+        return this.subscribedEvents;
+    }
+    handleEvent(event) {
+        return this.eventHandler(event);
+    }
+}
+exports.DynamicEventSubscriber = DynamicEventSubscriber;

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

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

package/dist/event-pubsub/index.js

@@ -0,0 +1,21 @@
+"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("./interfaces"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./event-subscriber"), exports);
+__exportStar(require("./event-publisher"), exports);
+__exportStar(require("./event-subscriber-registry"), exports);

package/dist/event-pubsub/interfaces/event-publisher.interface.d.ts

@@ -0,0 +1,4 @@
+import { AnyEvent } from "../../core";
+export interface IEventPublisher {
+    publish<T extends AnyEvent = AnyEvent>(event: T): Promise<void>;
+}

package/dist/event-pubsub/interfaces/event-publisher.interface.js

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

package/dist/event-pubsub/interfaces/event-subscriber-registry.interface.d.ts

@@ -0,0 +1,13 @@
+import { AnyEvent, EventClass } from "../../core";
+import { IEventSubscriber, IGlobalEventSubscriber } from "./event-subscriber.interface";
+export type Unsubscriber = () => void;
+export interface IEventSubscriberRegistry {
+    registerGlobalSubscriber(subscriber: IGlobalEventSubscriber): Unsubscriber;
+    deregisterGlobalSubscriber(subscriber: IGlobalEventSubscriber): void;
+    registerSubscriber(subscriber: IEventSubscriber): Unsubscriber;
+    deregisterSubscriber(subscriber: IEventSubscriber): void;
+    getGlobalSubscribers(): IGlobalEventSubscriber[];
+    getSubscribers(): IEventSubscriber[];
+    getSubscribersForEvent<T extends AnyEvent = AnyEvent>(eventType: EventClass<T>): IEventSubscriber<T>[];
+    getAllSubscribersForEvent<T extends AnyEvent = AnyEvent>(eventType: EventClass<T>): (IGlobalEventSubscriber | IEventSubscriber<T>)[];
+}

package/dist/event-pubsub/interfaces/event-subscriber-registry.interface.js

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

package/dist/event-pubsub/interfaces/event-subscriber.interface.d.ts

@@ -0,0 +1,9 @@
+import { AnyEvent, EventClass } from "../../core";
+export interface IGlobalEventSubscriber {
+    handleEvent(event: AnyEvent): Promise<void>;
+}
+export interface IEventSubscriber<T extends AnyEvent = AnyEvent> {
+    subscribeToEvents(): EventClass<T> | EventClass<T>[];
+    handleEvent(event: T): Promise<void>;
+}
+export type EventSubscriberHandler<T extends AnyEvent = AnyEvent> = IEventSubscriber<T>["handleEvent"];

package/dist/event-pubsub/interfaces/event-subscriber.interface.js

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

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

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

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

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="src/#declarations" />
+export * from "./base";
+export * from "./meta";
+export * from "./types";
+export * from "./utils";
+export * from "./core";
+export * from "./event-pubsub";
+export * from "./decorators";

package/dist/meta/aggregate-es/command-handler-map.d.ts

@@ -0,0 +1,8 @@
+import { AnyCommand, CommandHandler } from "../../core";
+export declare class CommandHandlerMap extends Map<string, CommandHandler> {
+}
+export declare const OwnCommandHandlerMapMetaKey: unique symbol;
+export declare const getOwnCommandHandlerMap: (target: object) => CommandHandlerMap;
+export declare const defineCommandHandler: <T extends AnyCommand>(target: object, commandType: string, handler: CommandHandler<T>) => void;
+export declare const CommandHandlerMapMetaKey: unique symbol;
+export declare const getCommandHandlerMap: (target: object) => CommandHandlerMap;

package/dist/meta/aggregate-es/command-handler-map.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCommandHandlerMap = exports.CommandHandlerMapMetaKey = exports.defineCommandHandler = exports.getOwnCommandHandlerMap = exports.OwnCommandHandlerMapMetaKey = exports.CommandHandlerMap = void 0;
+class CommandHandlerMap extends Map {
+}
+exports.CommandHandlerMap = CommandHandlerMap;
+exports.OwnCommandHandlerMapMetaKey = Symbol.for("OWN_COMMAND_HANDLER_MAP");
+const getOwnCommandHandlerMap = (target) => {
+    const ownCommandHandlerMap = () => Reflect.getOwnMetadata(exports.OwnCommandHandlerMapMetaKey, target);
+    if (!ownCommandHandlerMap())
+        Reflect.defineMetadata(exports.OwnCommandHandlerMapMetaKey, new CommandHandlerMap(), target);
+    return ownCommandHandlerMap();
+};
+exports.getOwnCommandHandlerMap = getOwnCommandHandlerMap;
+const defineCommandHandler = (target, commandType, handler) => {
+    const commandHandlersMap = (0, exports.getOwnCommandHandlerMap)(target);
+    commandHandlersMap.set(commandType, handler);
+};
+exports.defineCommandHandler = defineCommandHandler;
+exports.CommandHandlerMapMetaKey = Symbol.for("COMMAND_HANDLER_MAP");
+const getCommandHandlerMap = (target) => {
+    if (!Reflect.hasOwnMetadata(exports.CommandHandlerMapMetaKey, target)) {
+        const buildCommandHandlerMap = (target) => {
+            let _target = target;
+            const result = new CommandHandlerMap();
+            const ownCommandHandlerMaps = [];
+            do {
+                const ownCommandHandlerMap = (0, exports.getOwnCommandHandlerMap)(_target);
+                ownCommandHandlerMaps.unshift(ownCommandHandlerMap);
+                _target = Reflect.getPrototypeOf(_target);
+            } while (_target !== null);
+            ownCommandHandlerMaps.forEach((ownCommandHandlerMap) => {
+                ownCommandHandlerMap.forEach((commandHandler, commandType) => {
+                    result.set(commandType, commandHandler);
+                });
+            });
+            return result;
+        };
+        Reflect.defineMetadata(exports.CommandHandlerMapMetaKey, buildCommandHandlerMap(target), target);
+    }
+    return Reflect.getOwnMetadata(exports.CommandHandlerMapMetaKey, target);
+};
+exports.getCommandHandlerMap = getCommandHandlerMap;

package/dist/meta/aggregate-es/event-applier-map.d.ts

@@ -0,0 +1,9 @@
+import "reflect-metadata";
+import { AnyEvent, EventApplier } from "../../core";
+export declare class EventApplierMap extends Map<string, EventApplier> {
+}
+export declare const OwnEventApplierMapMetaKey: unique symbol;
+export declare const getOwnEventApplierMap: (target: object) => EventApplierMap;
+export declare const defineEventApplier: <T extends AnyEvent>(target: object, eventType: string, applier: EventApplier<T>) => void;
+export declare const EventApplierMapMetaKey: unique symbol;
+export declare const getEventApplierMap: (target: object) => EventApplierMap;