ddd-node 17.3.0 → 18.0.0

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

@@ -18,13 +18,16 @@ export declare class EventSourcedAggregateBase<P extends Props> extends Aggregat
     static newStream<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClassWithTypedConstructor<T>, id?: Id): T;
     static fromStream<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClassWithTypedConstructor<T>, id: Id, pastEvents?: AnyEvent[]): T;
     static fromSnapshot<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClassWithTypedConstructor<T>, snapshot: Snapshot<T>, pastEventsAfterSnapshot?: AnyEvent[]): T;
-    static eventApplierMap<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClass<T>): Map<string, EventApplier>;
-    static commandHandlerMap<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClass<T>): Map<string, CommandHandler>;
+    static ownEventApplierMap(): import("../../meta").EventApplierMap;
+    static eventApplierMap<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClass<T>): import("../../meta").EventApplierMap;
+    static ownCommandHandlerMap(): import("../../meta").CommandHandlerMap;
+    static commandHandlerMap<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClass<T>): import("../../meta").CommandHandlerMap;
     version(): number;
     pastEvents(): AnyEvent[];
     events(): AnyEvent[];
     handledCommands(): AnyCommand[];
-    eventApplierMap(): Map<string, EventApplier>;
+    ownEventApplierMap(): import("../../meta").EventApplierMap;
+    eventApplierMap(): import("../../meta").EventApplierMap;
     hasNewEvent(): boolean;
     getApplierForEvent<E extends AnyEvent>(event: E): EventApplier<E>;
     private validateEventBeforeApply;
@@ -34,7 +37,8 @@ export declare class EventSourcedAggregateBase<P extends Props> extends Aggregat
     applyEvent<E extends AnyEvent>(event: E): void;
     applyEvents(events: AnyEvent[]): void;
     applyNewEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: PropsOf<E>): void;
-    commandHandlerMap(): Map<string, CommandHandler>;
+    ownCommandHandlerMap(): import("../../meta").CommandHandlerMap;
+    commandHandlerMap(): import("../../meta").CommandHandlerMap;
     getHandlerForCommand<C extends AnyCommand>(command: C): CommandHandler<C, AnyEvent | AnyEvent[]>;
     handleCommand<C extends AnyCommand>(command: C): AnyEvent[];
     snapMetadata(): SnapshotMetadata;

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

@@ -28,9 +28,15 @@ class EventSourcedAggregateBase extends base_1.AggregateBase {
         instance.applyPastEvents(pastEventsAfterSnapshot);
         return instance;
     }
+    static ownEventApplierMap() {
+        return (0, meta_1.getOwnEventApplierMap)(this.prototype);
+    }
     static eventApplierMap() {
         return (0, meta_1.getEventApplierMap)(this.prototype);
     }
+    static ownCommandHandlerMap() {
+        return (0, meta_1.getOwnCommandHandlerMap)(this.prototype);
+    }
     static commandHandlerMap() {
         return (0, meta_1.getCommandHandlerMap)(this.prototype);
     }
@@ -46,6 +52,9 @@ class EventSourcedAggregateBase extends base_1.AggregateBase {
     handledCommands() {
         return Array.from(this._handledCommands);
     }
+    ownEventApplierMap() {
+        return this.constructor.ownEventApplierMap();
+    }
     eventApplierMap() {
         return this.constructor.eventApplierMap();
     }
@@ -96,6 +105,9 @@ class EventSourcedAggregateBase extends base_1.AggregateBase {
     applyNewEvent(eventClass, props) {
         this.applyEvent(this.newEvent(eventClass, props));
     }
+    ownCommandHandlerMap() {
+        return this.constructor.ownCommandHandlerMap();
+    }
     commandHandlerMap() {
         return this.constructor.commandHandlerMap();
     }

package/dist/core/domain.d.ts

@@ -1,17 +1,20 @@
-import { ModelName, ModelVersion } from "../meta";
-import { AnyModel, ModelClass } from "./model";
-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>> {
-}
+import { ModelRegistry } from "./model-registry";
 export type DomainName = string;
 export declare class Domain {
     readonly name: DomainName;
-    private readonly modelRegistry;
+    readonly modelRegistry: ModelRegistry;
     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 declare class DomainMap extends Map<DomainName, Domain> {
+}
+export declare class DomainManager {
+    static _instance: DomainManager;
+    static instance(): DomainManager;
+    private constructor();
+    private _domains;
+    hasDomain(domainName: DomainName): boolean;
+    getDomain(domainName: DomainName): Domain | undefined;
+    addDomain(domain: Domain): void;
+    deleteDomain(domainName: DomainName): void;
+}
+export declare const domainManager: DomainManager;

package/dist/core/domain.js

@@ -1,47 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Domain = exports.ModelRegistry = exports.ModelVersionRegistry = void 0;
-class ModelVersionRegistry extends Map {
-}
-exports.ModelVersionRegistry = ModelVersionRegistry;
-class ModelRegistry extends Map {
-}
-exports.ModelRegistry = ModelRegistry;
+exports.domainManager = exports.DomainManager = exports.DomainMap = exports.Domain = void 0;
+const model_registry_1 = require("./model-registry");
 class Domain {
     constructor(name) {
-        this.modelRegistry = new ModelRegistry();
         this.name = name;
+        this.modelRegistry = new model_registry_1.ModelRegistry();
+    }
+}
+exports.Domain = Domain;
+class DomainMap extends Map {
+}
+exports.DomainMap = DomainMap;
+class DomainManager {
+    static instance() {
+        if (!this._instance)
+            this._instance = new DomainManager();
+        return this._instance;
     }
-    getModelVersionRegistry(modelName) {
-        const modelVersionRegistry = () => this.modelRegistry.get(modelName);
-        if (!modelVersionRegistry())
-            this.modelRegistry.set(modelName, new ModelVersionRegistry());
-        return modelVersionRegistry();
+    constructor() {
+        this._domains = new DomainMap();
     }
-    getModel(modelName, modelVersion = 0) {
-        const modelVersionRegistry = this.getModelVersionRegistry(modelName);
-        return modelVersionRegistry.get(modelVersion);
+    hasDomain(domainName) {
+        return this._domains.has(domainName);
     }
-    hasRegisteredModel(p1, p2) {
-        let modelName, modelVersion;
-        if (typeof p1 === "string") {
-            modelName = p1;
-            modelVersion = p2;
-        }
-        else {
-            modelName = p1.modelName();
-            modelVersion = p1.modelVersion();
-        }
-        return Boolean(this.getModel(modelName, modelVersion));
+    getDomain(domainName) {
+        return this._domains.get(domainName);
     }
-    registerModel(modelClass) {
-        const modelName = modelClass.modelName();
-        const modelVersion = modelClass.modelVersion();
-        if (this.hasRegisteredModel(modelName, modelVersion))
-            throw new Error(`Model ${modelName} with version ${modelVersion} has been registered`);
-        const modelVersionRegistry = this.getModelVersionRegistry(modelName);
-        modelVersionRegistry.set(modelVersion, modelClass);
-        return this;
+    addDomain(domain) {
+        if (this.hasDomain(domain.name))
+            throw new Error(`Domain ${domain.name} has already exist`);
+        this._domains.set(domain.name, domain);
+    }
+    deleteDomain(domainName) {
+        this._domains.delete(domainName);
     }
 }
-exports.Domain = Domain;
+exports.DomainManager = DomainManager;
+exports.domainManager = DomainManager.instance();

package/dist/core/index.d.ts

@@ -8,3 +8,4 @@ export * from "./value-object";
 export * from "./repository";
 export * from "./domain";
 export * from "./event-pubsub";
+export * from "./model-registry";

package/dist/core/index.js

@@ -24,3 +24,4 @@ __exportStar(require("./value-object"), exports);
 __exportStar(require("./repository"), exports);
 __exportStar(require("./domain"), exports);
 __exportStar(require("./event-pubsub"), exports);
+__exportStar(require("./model-registry"), exports);

package/dist/core/message/command.js

@@ -8,7 +8,7 @@ class CommandBase extends message_1.MessageBase {
         super({ ...metadata, messageType: CommandBase.COMMAND_MESSAGE_TYPE }, props);
     }
     static commandType() {
-        return (0, meta_1.getCommandType)(this) || this.modelName();
+        return (0, meta_1.getCommandType)(this);
     }
     static newCommand(props, context, timestamp) {
         return new this({

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

@@ -1,9 +1,9 @@
-import { ClassStatic } from "../../types";
 import { Class } from "type-fest";
+import { EventType } from "../../meta";
+import { ClassStatic } from "../../types";
 import { Id } from "../id";
 import { Props, PropsOf } from "../model";
 import { MessageBase, MessageContext, MessageMetadata } from "./message";
-import { EventType } from "../../meta";
 export type EventSource = Readonly<{
     aggregateModel: string;
     aggregateId: Id;

package/dist/core/message/event.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventBase = void 0;
-const message_1 = require("./message");
 const meta_1 = require("../../meta");
+const message_1 = require("./message");
 class EventBase extends message_1.MessageBase {
     constructor(metadata, props) {
         super({ ...metadata, messageType: EventBase.EVENT_MESSAGE_TYPE }, props);
         this._source = metadata.source;
     }
     static eventType() {
-        return (0, meta_1.getEventType)(this) || this.modelName();
+        return (0, meta_1.getEventType)(this);
     }
     static newEvent(source, props, context, timestamp) {
         return new this({

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

@@ -1,12 +1,10 @@
 import { Class } from "type-fest";
-import { ModelId } from "../../meta";
 import { ClassStatic } from "../../types";
-export type PropKey = string | symbol;
 export interface Props {
-    [key: PropKey]: any;
+    [key: PropertyKey]: any;
 }
 export type EmptyProps = {
-    [key: PropKey]: never;
+    [key: PropertyKey]: never;
 };
 export declare class ModelBase<P extends Props> {
     static readonly EMPTY_PROPS: EmptyProps;
@@ -15,11 +13,11 @@ export declare class ModelBase<P extends Props> {
     static mutable(): boolean;
     static modelName<T extends AnyModel>(this: ModelClass<T>): string;
     static modelVersion<T extends AnyModel>(this: ModelClass<T>): number;
-    static modelId<T extends AnyModel>(this: ModelClass<T>): `${string}|${number}`;
-    static hasModelId<T extends AnyModel>(this: ModelClass<T>, modelId: ModelId): boolean;
+    static modelId<T extends AnyModel>(this: ModelClass<T>): string;
+    static hasModelId<T extends AnyModel>(this: ModelClass<T>, modelId: string): boolean;
     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<PropertyKey, import("../../meta").StaticValue<T>>;
+    static ownStaticValues<T extends AnyModel>(this: ModelClass<T>): import("../../meta").StaticValuesMap<T>;
     static ownPropsMap(): import("../../meta").PropsMap<ModelBase<any>>;
     static propsMap(): import("../../meta").PropsMap<ModelBase<any>>;
     constructor();
@@ -29,8 +27,8 @@ export declare class ModelBase<P extends Props> {
     isMutable(): boolean;
     modelName(): string;
     modelVersion(): number;
-    modelId(): `${string}|${number}`;
-    hasModelId(modelId: ModelId): boolean;
+    modelId(): string;
+    hasModelId(modelId: string): boolean;
     ownPropsValidator(): import("../../meta").PropsValidator<this> | undefined;
     propsValidators(): import("../../meta").PropsValidator<AnyModel>[];
     ownPropsMap(): import("../../meta").PropsMap<ModelBase<any>>;

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

@@ -0,0 +1,17 @@
+import { ModelId, ModelName, ModelVersion } from "../meta";
+import { AnyModel, ModelClass } from "./model";
+export declare class ModelVersionMap<T extends AnyModel = AnyModel> extends Map<ModelVersion, ModelClass<T>> {
+    readonly modelName: ModelName;
+    constructor(modelName: ModelName);
+}
+export declare class ModelMap<T extends AnyModel = AnyModel> extends Map<ModelName, ModelVersionMap<T>> {
+}
+export declare class ModelRegistry {
+    private readonly modelMap;
+    getModelVersionMap(modelName: ModelName): ModelVersionMap<AnyModel>;
+    getModel(modelName: ModelName, modelVersion?: ModelVersion): ModelClass<AnyModel> | undefined;
+    getModelByModelId(modelId: ModelId): ModelClass<AnyModel> | undefined;
+    hasRegisteredModel(modelName: ModelName, modelVersion: ModelVersion): boolean;
+    hasRegisteredModel(model: ModelClass): boolean;
+    registerModel(modelClass: ModelClass): this;
+}

package/dist/core/model-registry.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelRegistry = exports.ModelMap = exports.ModelVersionMap = void 0;
+const meta_1 = require("../meta");
+class ModelVersionMap extends Map {
+    constructor(modelName) {
+        super();
+        this.modelName = modelName;
+    }
+}
+exports.ModelVersionMap = ModelVersionMap;
+class ModelMap extends Map {
+}
+exports.ModelMap = ModelMap;
+class ModelRegistry {
+    constructor() {
+        this.modelMap = new ModelMap();
+    }
+    getModelVersionMap(modelName) {
+        const modelVersionMap = () => this.modelMap.get(modelName);
+        if (!modelVersionMap())
+            this.modelMap.set(modelName, new ModelVersionMap(modelName));
+        return modelVersionMap();
+    }
+    getModel(modelName, modelVersion = 0) {
+        const modelVersionMap = this.getModelVersionMap(modelName);
+        return modelVersionMap.get(modelVersion);
+    }
+    getModelByModelId(modelId) {
+        const { modelName, modelVersion } = meta_1.MId.fromValue(modelId);
+        return this.getModel(modelName, modelVersion);
+    }
+    hasRegisteredModel(p1, p2) {
+        let modelName, modelVersion;
+        if (typeof p1 === "string") {
+            modelName = p1;
+            modelVersion = p2;
+        }
+        else {
+            modelName = p1.modelName();
+            modelVersion = p1.modelVersion();
+        }
+        return Boolean(this.getModel(modelName, modelVersion));
+    }
+    registerModel(modelClass) {
+        const modelName = modelClass.modelName();
+        const modelVersion = modelClass.modelVersion();
+        if (this.hasRegisteredModel(modelName, modelVersion))
+            throw new Error(`Model ${modelName} with version ${modelVersion} has been registered`);
+        const modelVersionMap = this.getModelVersionMap(modelName);
+        modelVersionMap.set(modelVersion, modelClass);
+        return this;
+    }
+}
+exports.ModelRegistry = ModelRegistry;

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>>(target: T, key: string) => void;

package/dist/decorators/{model/enum.js → enum.js}

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

package/dist/decorators/index.d.ts

@@ -2,3 +2,4 @@ export * from "./aggregate-es";
 export * from "./id";
 export * from "./model";
 export * from "./message";
+export * from "./enum";

package/dist/decorators/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./aggregate-es"), exports);
 __exportStar(require("./id"), exports);
 __exportStar(require("./model"), exports);
 __exportStar(require("./message"), exports);
+__exportStar(require("./enum"), exports);

package/dist/decorators/message/command.js

@@ -4,7 +4,7 @@ exports.Command = void 0;
 const meta_1 = require("../../meta");
 const Command = (commandType) => {
     return (target) => {
-        (0, meta_1.setCommandType)(target, commandType);
+        (0, meta_1.defineCommandType)(target, commandType);
     };
 };
 exports.Command = Command;

package/dist/decorators/message/event.js

@@ -4,7 +4,7 @@ exports.Event = void 0;
 const meta_1 = require("../../meta");
 const Event = (eventType) => {
     return (target) => {
-        (0, meta_1.setEventType)(target, eventType);
+        (0, meta_1.defineEventType)(target, eventType);
     };
 };
 exports.Event = Event;

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

@@ -1,6 +1,4 @@
 export * from "./prop";
 export * from "./model";
-export * from "./version";
-export * from "./validator";
 export * from "./static";
-export * from "./enum";
+export * from "../enum";

package/dist/decorators/model/index.js

@@ -16,7 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./prop"), exports);
 __exportStar(require("./model"), exports);
-__exportStar(require("./version"), exports);
-__exportStar(require("./validator"), exports);
 __exportStar(require("./static"), exports);
-__exportStar(require("./enum"), exports);
+__exportStar(require("../enum"), exports);

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

@@ -1,2 +1,12 @@
-import { ModelClass } from "../../core";
-export declare const Model: (name: string) => <T extends ModelClass<import("../../core").AnyModel>>(target: T) => void;
+import { AnyModel, ModelClass } from "../../core";
+import { PropsValidator } from "../../meta";
+export type ModelOptions<T extends AnyModel = AnyModel> = {
+    name?: string;
+    version?: number;
+    domain?: string;
+    propsValidator?: PropsValidator<T>;
+    autoRegisterModel?: boolean;
+};
+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/decorators/model/model.js

@@ -1,10 +1,54 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Model = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const core_1 = require("../../core");
 const meta_1 = require("../../meta");
-const Model = (name) => {
+function Model(p1, p2, p3) {
+    const defaultModelOptions = {
+        autoRegisterModel: true,
+    };
+    let modelOptions = {};
+    if (p1 && !p2 && !p3) {
+        if (typeof p1 === "string")
+            modelOptions = { name: p1 };
+        else
+            modelOptions = p1;
+    }
+    else if (p1 && p2 && !p3) {
+        if (typeof p2 === "number")
+            modelOptions = { name: p1, version: p2 };
+        else
+            modelOptions = { name: p1, ...p2 };
+    }
+    else if (p1 && p2 && p3) {
+        modelOptions = {
+            name: p1,
+            version: p2,
+            ...p3,
+        };
+    }
+    modelOptions = lodash_1.default.merge(defaultModelOptions, modelOptions);
     return (target) => {
-        (0, meta_1.setModelName)(target, name);
+        if (modelOptions?.name)
+            (0, meta_1.defineModelName)(target, modelOptions.name);
+        if (modelOptions?.version)
+            (0, meta_1.defineModelVersion)(target, modelOptions.version);
+        if (modelOptions?.domain)
+            (0, meta_1.defineModelDomain)(target, modelOptions.domain);
+        if (modelOptions?.autoRegisterModel) {
+            const domainName = (0, meta_1.getModelDomain)(target);
+            if (!core_1.domainManager.hasDomain(domainName)) {
+                core_1.domainManager.addDomain(new core_1.Domain(domainName));
+            }
+            const domain = core_1.domainManager.getDomain(domainName);
+            domain.modelRegistry.registerModel(target);
+        }
+        if (modelOptions?.propsValidator)
+            (0, meta_1.definePropsValidator)(target, modelOptions.propsValidator);
     };
-};
+}
 exports.Model = Model;

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

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

package/dist/decorators/model/prop.js

@@ -4,7 +4,7 @@ exports.Prop = void 0;
 const meta_1 = require("../../meta");
 const Prop = (propTargetKey) => {
     return (target, key) => {
-        (0, meta_1.setProp)(target, key, propTargetKey ?? key);
+        (0, meta_1.defineProp)(target, key, propTargetKey ?? key);
     };
 };
 exports.Prop = Prop;

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

@@ -1,3 +1,3 @@
 import { ModelClass } from "../../core";
 import { StaticValueBuilder } from "../../meta";
-export declare const Static: <T extends ModelClass<import("../../core").AnyModel>, I extends InstanceType<T> = InstanceType<T>>(builder: StaticValueBuilder<I>) => (target: T, key: string) => void;
+export declare const Static: <T extends ModelClass<import("../../core").AnyModel>, I extends InstanceType<T> = InstanceType<T>>(builder: StaticValueBuilder<I>) => (target: T, key: PropertyKey) => void;

package/dist/decorators/model/static.js

@@ -5,16 +5,7 @@ const meta_1 = require("../../meta");
 const Static = (builder) => {
     return (target, key) => {
         (0, meta_1.setStaticValue)(target, key, builder);
-        Object.defineProperty(target, key, {
-            configurable: false,
-            enumerable: true,
-            get() {
-                return (0, meta_1.getStaticValue)(target, key);
-            },
-            set() {
-                throw new Error("Static value is readonly");
-            },
-        });
+        (0, meta_1.defineStaticValueProperty)(target, key);
     };
 };
 exports.Static = Static;

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="src/declarations" />
 export * from "./meta";
 export * from "./types";
 export * from "./utils";

package/dist/index.js

@@ -1,4 +1,5 @@
 "use strict";
+/// <reference path="./declarations/index.d.ts" />
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

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, methodName) => {
+                    result.set(methodName, 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;