ddd-node 9.2.1 → 12.2.0

package/dist/core/metadata/model.metadata.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModelMetadata = exports.getValidateProps = exports.setValidateProps = exports.getModelName = exports.setModelName = exports.setPropKey = exports.getPropKeySet = void 0;
+const PropMetaKey = Symbol.for("PROP");
+const getPropKeySet = (target) => {
+    var _a;
+    if (!target)
+        return new Set();
+    return (_a = Reflect.getMetadata(PropMetaKey, target)) !== null && _a !== void 0 ? _a : new Set();
+};
+exports.getPropKeySet = getPropKeySet;
+const setPropKey = (target, propKey) => {
+    const propKeySet = (0, exports.getPropKeySet)(target);
+    propKeySet.add(propKey);
+    Reflect.defineMetadata(PropMetaKey, propKeySet, target);
+};
+exports.setPropKey = setPropKey;
+//
+const ModelNameMetaKey = Symbol.for("MODEL_NAME");
+const setModelName = (target, name) => {
+    Reflect.defineMetadata(ModelNameMetaKey, name, target);
+};
+exports.setModelName = setModelName;
+const getModelName = (target) => {
+    const modelName = Reflect.getMetadata(ModelNameMetaKey, target);
+    if (!modelName)
+        throw new Error();
+    return modelName;
+};
+exports.getModelName = getModelName;
+const ValidatePropsMetaKey = Symbol.for("VALIDATE_PROPS");
+const setValidateProps = (target, validator) => {
+    Reflect.defineMetadata(ValidatePropsMetaKey, validator, target);
+};
+exports.setValidateProps = setValidateProps;
+const getValidateProps = (target) => {
+    return Reflect.getMetadata(ValidatePropsMetaKey, target);
+};
+exports.getValidateProps = getValidateProps;
+const getModelMetadata = (target) => {
+    return {
+        name: (0, exports.getModelName)(target),
+        validator: (0, exports.getValidateProps)(target),
+    };
+};
+exports.getModelMetadata = getModelMetadata;

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

@@ -1,3 +1,2 @@
 export * from "./model";
-export * from "./model-type";
 export * from "./model-with-id";

package/dist/core/model/index.js

@@ -15,5 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./model"), exports);
-__exportStar(require("./model-type"), exports);
 __exportStar(require("./model-with-id"), exports);

package/dist/core/model/model-with-id.d.ts

@@ -1,6 +1,12 @@
-import { Id, IdGenerator } from "../id";
-import { Model } from "./model";
-export declare class ModelWithId<Props extends object> extends Model<Props> {
-    static getIdGenerator(this: any): IdGenerator;
+import { Id, IdGeneratorBase } from "../id";
+import { ModelBase } from "./model";
+export declare abstract class ModelWithId<Props extends object> extends ModelBase<Props> {
+    protected readonly _id: Id;
+    constructor(id: Id);
+    static getIdGenerator(this: any): IdGeneratorBase;
     static id(id?: Id): Id;
+    getId(): Id;
+    hasId(id: Id): boolean;
+    rawId(): string;
 }
+export type AnyModelWithId = ModelWithId<any>;

package/dist/core/model/model-with-id.js

@@ -2,15 +2,28 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModelWithId = void 0;
 const id_1 = require("../id");
-const metadata_1 = require("../metadata");
+const id_metadata_1 = require("../metadata/id.metadata");
 const model_1 = require("./model");
-class ModelWithId extends model_1.Model {
+class ModelWithId extends model_1.ModelBase {
+    constructor(id) {
+        super();
+        this._id = id;
+    }
     static getIdGenerator() {
-        return (0, metadata_1.getIdGenerator)(this) || new id_1.Uuid4Generator();
+        return (0, id_metadata_1.getIdGenerator)(this) || new id_1.Uuid4Generator();
     }
     static id(id) {
         const generator = this.getIdGenerator();
         return id ? generator.fromId(id) : generator.newId();
     }
+    getId() {
+        return this._id;
+    }
+    hasId(id) {
+        return this._id.equals(id);
+    }
+    rawId() {
+        return this._id.value;
+    }
 }
 exports.ModelWithId = ModelWithId;

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

@@ -1,15 +1,25 @@
-import { Class } from "../../types/index";
-export declare class Model<Props extends object> {
+import { ClassStatic } from "../../types/index";
+import { Class } from "type-fest";
+import { ModelMetadata } from "../metadata/model.metadata";
+export declare class ModelBase<Props extends object> {
+    static readonly EMPTY_PROPS: {};
+    private _metadata;
+    private _propKeys;
     protected _props: Props;
-    constructor(props?: Props);
-    static isModel(obj: object): obj is AnyModel;
-    static type(): `${string}#${string}`;
-    protected initializeProps(props: Props): void;
+    static isMutable(): boolean;
+    static isModel(model: any): model is AnyModel;
+    constructor();
+    private redefineModel;
+    isMutable(): boolean;
+    getPropKeys(): Set<string | symbol>;
+    validateProps(props: Props): void;
     validate(): void;
-    getType(): `${string}#${string}`;
-    props(): Props;
+    getModelMetadata(): ModelMetadata<this>;
+    modelName(): string;
+    props(): any;
+    protected initializeProps(props: Props): void;
 }
-export type AnyModel = Model<object>;
-export type PropsOf<T> = T extends Model<infer P> ? P : never;
-export type ModelClass<T extends AnyModel = AnyModel> = Class<T>;
+export type AnyModel = ModelBase<object>;
+export type PropsOf<T extends AnyModel> = T extends ModelBase<infer P extends object> ? P : never;
+export type ModelClass<T extends AnyModel = AnyModel> = Class<T> & ClassStatic<typeof ModelBase<PropsOf<T>>>;
 export type EmptyProps = {};

package/dist/core/model/model.js

@@ -3,32 +3,87 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Model = void 0;
+exports.ModelBase = void 0;
 const lodash_1 = __importDefault(require("lodash"));
-const metadata_1 = require("../metadata");
-class Model {
-    constructor(props) {
-        if (props)
-            this.initializeProps(props);
+const model_metadata_1 = require("../metadata/model.metadata");
+class ModelBase {
+    static isMutable() {
+        return false;
     }
-    static isModel(obj) {
-        return obj instanceof Model;
+    static isModel(model) {
+        return model instanceof ModelBase;
     }
-    static type() {
-        return (0, metadata_1.getModelType)(this.prototype);
+    constructor() {
+        this._props = ModelBase.EMPTY_PROPS;
+        this.redefineModel();
     }
-    initializeProps(props) {
-        if (!this._props) {
-            this._props = props;
-            this.validate();
+    redefineModel() {
+        this.getPropKeys().forEach((propKey) => {
+            Object.defineProperty(this, propKey, {
+                configurable: true,
+                enumerable: true,
+                get() {
+                    var _a;
+                    return (_a = this._props) === null || _a === void 0 ? void 0 : _a[propKey];
+                },
+                set() {
+                    throw new Error(`Prop "${propKey.toString()}" cannot be set directly`);
+                },
+            });
+        });
+    }
+    isMutable() {
+        return this.constructor.isMutable();
+    }
+    getPropKeys() {
+        if (!this._propKeys) {
+            this._propKeys = (0, model_metadata_1.getPropKeySet)(Reflect.getPrototypeOf(this));
         }
+        return this._propKeys;
     }
-    validate() { }
-    getType() {
-        return (0, metadata_1.getModelType)(Object.getPrototypeOf(this));
+    validateProps(props) {
+        const { validator } = this.getModelMetadata();
+        if (validator)
+            validator(props);
+    }
+    validate() {
+        this.validateProps(this._props);
+    }
+    getModelMetadata() {
+        if (!this._metadata) {
+            this._metadata = (0, model_metadata_1.getModelMetadata)(this.constructor);
+        }
+        return this._metadata;
+    }
+    modelName() {
+        return this.getModelMetadata().name;
     }
     props() {
-        return lodash_1.default.cloneDeep(this._props);
+        return lodash_1.default.cloneDeepWith(this._props, (value) => {
+            if (ModelBase.isModel(value)) {
+                value.redefineModel();
+                return value;
+            }
+        });
+    }
+    initializeProps(props) {
+        if (this._props !== ModelBase.EMPTY_PROPS)
+            throw new Error("Props is initialized");
+        if (!this.isMutable()) {
+            this._props = props;
+            Object.freeze(this._props);
+        }
+        else {
+            this._props = new Proxy(props, {
+                set: (target, propKey, value) => {
+                    let result = Reflect.set(target, propKey, value);
+                    this.validate();
+                    return result;
+                },
+            });
+        }
+        this.validate();
     }
 }
-exports.Model = Model;
+exports.ModelBase = ModelBase;
+ModelBase.EMPTY_PROPS = {};

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

@@ -1,10 +1,11 @@
-import { Class } from "../types/index";
-import { Model, PropsOf } from "./model";
-export declare class ValueObject<Props extends object> extends Model<Props> {
+import { Class } from "type-fest";
+import { ModelBase, PropsOf } from "./model";
+import { ClassStatic } from "../types/index";
+export declare abstract class ValueObjectBase<Props extends object> extends ModelBase<Props> {
     constructor(props: Props);
     equals<V extends AnyValueObject>(vo: V): boolean;
     with(props: Partial<Props>): this;
 }
-export type AnyValueObject = ValueObject<any>;
-export type ValueObjectClass<T extends AnyValueObject = AnyValueObject> = Class<T>;
-export type ValueObjectClassWithTypedConstructor<T extends AnyValueObject = AnyValueObject> = Class<T, ConstructorParameters<typeof ValueObject<PropsOf<T>>>>;
+export type AnyValueObject = ValueObjectBase<any>;
+export type ValueObjectClass<T extends AnyValueObject = AnyValueObject> = Class<T> & ClassStatic<typeof ValueObjectBase<PropsOf<T>>>;
+export type ValueObjectClassWithTypedConstructor<T extends AnyValueObject = AnyValueObject> = Class<T, ConstructorParameters<typeof ValueObjectBase<PropsOf<T>>>>;

package/dist/core/value-object.js

@@ -3,12 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueObject = void 0;
+exports.ValueObjectBase = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 const model_1 = require("./model");
-class ValueObject extends model_1.Model {
+class ValueObjectBase extends model_1.ModelBase {
     constructor(props) {
-        super(props);
+        super();
+        this.initializeProps(props);
     }
     equals(vo) {
         const equalsType = vo instanceof this.constructor;
@@ -20,4 +21,4 @@ class ValueObject extends model_1.Model {
         return new this.constructor(newProps);
     }
 }
-exports.ValueObject = ValueObject;
+exports.ValueObjectBase = ValueObjectBase;

package/dist/decorators/aggregate.d.ts

@@ -1,4 +1,3 @@
-import { AggregateClass, AggregateESClass, AnyCommand, AnyEvent, CommandClass, CommandHandler, EventApplier, EventClass } from "../core/index";
-export declare const aggregate: (name?: string) => <T extends AggregateClass | AggregateESClass>(target: T) => void;
-export declare const applyEvent: <T extends AnyEvent>(eventClass: EventClass<T>) => <U extends EventApplier<T>>(target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<U>) => void;
-export declare const handleCommand: <T extends AnyCommand>(commandClass: CommandClass<T>) => <U extends CommandHandler<T>>(target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<U>) => void;
+import { AnyCommand, AnyEvent, CommandClass, CommandHandler, EventApplier, EventClass } from "../core/index";
+export declare const ApplyEvent: <T extends AnyEvent>(eventClass: EventClass<T>) => <U extends EventApplier<T>>(target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<U>) => void;
+export declare const HandleCommand: <T extends AnyCommand>(commandClass: CommandClass<T>) => <U extends CommandHandler<T>>(target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<U>) => void;

package/dist/decorators/aggregate.js

@@ -1,28 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleCommand = exports.applyEvent = exports.aggregate = void 0;
+exports.HandleCommand = exports.ApplyEvent = void 0;
 const _core_1 = require("../core/index");
-const model_1 = require("./model");
-const aggregate = (name) => (target) => {
-    const aggregateType = new _core_1.AggregateType(name !== null && name !== void 0 ? name : target.name);
-    (0, model_1.model)(aggregateType.value)(target);
-};
-exports.aggregate = aggregate;
-const applyEvent = (eventClass) => {
+const ApplyEvent = (eventClass) => {
     return (target, propertyKey, descriptor) => {
         if (typeof descriptor.value === "function") {
-            const type = (0, _core_1.getModelType)(eventClass.prototype);
-            (0, _core_1.defineEventApplier)(target, type, descriptor.value);
+            const eventName = (0, _core_1.getModelName)(eventClass);
+            (0, _core_1.defineEventApplier)(target, eventName, descriptor.value);
         }
     };
 };
-exports.applyEvent = applyEvent;
-const handleCommand = (commandClass) => {
+exports.ApplyEvent = ApplyEvent;
+const HandleCommand = (commandClass) => {
     return (target, propertyKey, descriptor) => {
         if (typeof descriptor.value === "function") {
-            const type = (0, _core_1.getModelType)(commandClass.prototype);
-            (0, _core_1.defineCommandHandler)(target, type, descriptor.value);
+            const commandName = (0, _core_1.getModelName)(commandClass);
+            (0, _core_1.defineCommandHandler)(target, commandName, descriptor.value);
         }
     };
 };
-exports.handleCommand = handleCommand;
+exports.HandleCommand = HandleCommand;

package/dist/decorators/id.d.ts

@@ -1,2 +1,2 @@
-import { IdGenerator } from "../core/index";
-export declare const id: <T extends IdGenerator>(idGenerator: T) => (target: object) => void;
+import { AnyModelWithId, IdGeneratorBase, ModelClass } from "../core/index";
+export declare const UseId: (idGenerator: IdGeneratorBase) => <T extends AnyModelWithId>(target: ModelClass<T>) => void;

package/dist/decorators/id.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.id = void 0;
+exports.UseId = void 0;
 const _core_1 = require("../core/index");
-const id = (idGenerator) => {
+const UseId = (idGenerator) => {
     return (target) => {
-        console.log("Target", target);
         (0, _core_1.defineIdGenerator)(target, idGenerator);
     };
 };
-exports.id = id;
+exports.UseId = UseId;

package/dist/decorators/index.d.ts

@@ -1,7 +1,3 @@
 export * from "./aggregate";
-export * from "./command";
-export * from "./entity";
-export * from "./event";
 export * from "./id";
 export * from "./model";
-export * from "./value-object";

package/dist/decorators/index.js

@@ -15,9 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./aggregate"), exports);
-__exportStar(require("./command"), exports);
-__exportStar(require("./entity"), exports);
-__exportStar(require("./event"), exports);
 __exportStar(require("./id"), exports);
 __exportStar(require("./model"), exports);
-__exportStar(require("./value-object"), exports);

package/dist/decorators/model.d.ts

@@ -1,2 +1,13 @@
-import { ModelClass, ModelTypePattern } from "../core/index";
-export declare const model: (type: ModelTypePattern) => <T extends ModelClass>(target: T) => void;
+import { AnyModel, ModelClass, PropsValidator } from "../core/index";
+import { TypedClassDecorator } from "./type";
+export declare const Prop: (target: object, propKey: string) => void;
+export declare const Name: (name?: string) => <T extends AnyModel>(target: ModelClass<T>) => void;
+export declare const Validate: <T extends AnyModel>(validator?: PropsValidator<T> | undefined) => (target: ModelClass<T>) => void;
+export type ModelOptions<T extends AnyModel> = {
+    name?: string;
+    validator?: PropsValidator<T>;
+};
+export declare function Model<T extends ModelClass, I extends InstanceType<T> = InstanceType<T>>(options?: ModelOptions<I>): TypedClassDecorator<T>;
+export declare function Model<T extends ModelClass, I extends InstanceType<T> = InstanceType<T>>(name?: string, validator?: PropsValidator<I>): TypedClassDecorator<T>;
+export declare function Model<T extends ModelClass, I extends InstanceType<T> = InstanceType<T>>(name?: string, options?: Omit<ModelOptions<I>, "name">): TypedClassDecorator<T>;
+export declare const Static: <T extends ModelClass, I extends InstanceType<T> = InstanceType<T>>(builder: () => I) => (target: T, key: Extract<keyof T, string>) => void;

package/dist/decorators/model.js

@@ -1,11 +1,73 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.model = void 0;
+exports.Static = exports.Model = exports.Validate = exports.Name = exports.Prop = void 0;
 const _core_1 = require("../core/index");
-const model = (type) => {
+const Prop = (target, propKey) => {
+    (0, _core_1.setPropKey)(target, propKey);
+};
+exports.Prop = Prop;
+const Name = (name) => {
+    return (target) => {
+        (0, _core_1.setModelName)(target, name !== null && name !== void 0 ? name : target.name);
+    };
+};
+exports.Name = Name;
+const Validate = (validator) => {
     return (target) => {
-        _core_1.ModelRegistry.instance().registerModel(type, target);
-        (0, _core_1.defineModelType)(target.prototype, type);
+        if (validator)
+            (0, _core_1.setValidateProps)(target, validator);
+    };
+};
+exports.Validate = Validate;
+function Model(p1, p2) {
+    return (target) => {
+        let options = {};
+        if (p1 && !p2) {
+            if (typeof p1 === "string")
+                options = { name: p1 };
+            else
+                options = p1;
+        }
+        else if (p1 && p2) {
+            p1 = p1;
+            if (typeof p2 === "function")
+                options = { name: p1, validator: p2 };
+            else
+                options = Object.assign({ name: p1 }, p2);
+        }
+        const { name, validator } = options;
+        (0, exports.Name)(name)(target);
+        (0, exports.Validate)(validator)(target);
+    };
+}
+exports.Model = Model;
+// Lazy builder for static value (value of static prop is an instance of that model)
+const Static = (builder) => {
+    return (target, key) => {
+        const type = Reflect.getMetadata("design:type", target, key);
+        const STATIC_VALUES_KEY = "_staticValues";
+        const typedTarget = target;
+        if (!typedTarget[STATIC_VALUES_KEY])
+            Object.defineProperty(target, STATIC_VALUES_KEY, {
+                configurable: false,
+                enumerable: false,
+                writable: false,
+                value: new Map(),
+            });
+        Object.defineProperty(target, key, {
+            configurable: false,
+            enumerable: true,
+            get() {
+                const staticValues = typedTarget[STATIC_VALUES_KEY];
+                if (!staticValues.has(key)) {
+                    const value = builder();
+                    if (!(value instanceof type))
+                        throw new Error(`Invalid return type. The return of builder must be an instance of model ${type.modelName()} (class ${type.name})`);
+                    staticValues.set(key, value);
+                }
+                return staticValues.get(key);
+            },
+        });
     };
 };
-exports.model = model;
+exports.Static = Static;

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/types/class-static.d.ts

@@ -1,2 +1,2 @@
-import { Class } from "./class";
-export type ClassStatic<T extends Class<any>> = Omit<T, "constructor" | "prototype">;
+import { AnyClass } from "./class";
+export type ClassStatic<T extends AnyClass<any>> = Omit<T, "constructor" | "prototype">;

package/dist/types/class.d.ts

@@ -1,4 +1,2 @@
-export type Constructor<T, Arguments extends unknown[] = any[]> = new (...arguments_: Arguments) => T;
-export type Class<T, Arguments extends unknown[] = any[]> = Constructor<T, Arguments> & {
-    prototype: T;
-};
+import { AbstractClass, Class } from "type-fest";
+export type AnyClass<T = any> = Class<T> | AbstractClass<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ddd-node",
-  "version": "9.2.1",
+  "version": "12.2.0",
   "description": "Domain Driven Design base for NodeJs",
   "main": "dist/index.js",
   "scripts": {
@@ -32,6 +32,7 @@
     "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/tsconfig.json

@@ -31,7 +31,7 @@
     "baseUrl": "./" /* Specify the base directory to resolve non-relative module names. */,
     "paths": {
       "#core": ["src/core/index"],
-      "#decorators": ["src/dedcorators/index"],
+      "#decorators": ["src/decorators/index"],
       "#utils": ["src/utils/index"],
       "#types": ["src/types/index"]
     } /* Specify a set of entries that re-map imports to additional lookup locations. */,

package/dist/core/metadata.d.ts

@@ -1,17 +0,0 @@
-import "reflect-metadata";
-import { CommandHandler, EventApplier } from "./aggregate";
-import { IdGenerator } from "./id";
-import { ModelTypePattern } from "./model";
-import { AnyCommand, AnyEvent } from "./message";
-export declare const MODEL_TYPE = "MODEL_TYPE";
-export declare const defineModelType: (target: object, type: ModelTypePattern) => void;
-export declare const getModelType: (target: object) => ModelTypePattern;
-export declare const ID_GENERATOR = "ID_GENERATOR";
-export declare const defineIdGenerator: (target: object, idGenerator: IdGenerator) => void;
-export declare const getIdGenerator: (target: object) => any;
-export declare const EVENT_APPLIERS = "EVENT_APPLIERS";
-export declare const getEventAppliersMap: (target: object) => Map<string, EventApplier>;
-export declare const defineEventApplier: <T extends AnyEvent>(target: object, eventType: string, applier: EventApplier<T>) => void;
-export declare const COMMAND_HANDLERS = "COMMAND_HANDLERS";
-export declare const getCommandHandlersMap: (target: object) => Map<string, CommandHandler>;
-export declare const defineCommandHandler: <T extends AnyCommand>(target: object, commandType: string, handler: CommandHandler<T>) => void;

package/dist/core/metadata.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineCommandHandler = exports.getCommandHandlersMap = exports.COMMAND_HANDLERS = exports.defineEventApplier = exports.getEventAppliersMap = exports.EVENT_APPLIERS = exports.getIdGenerator = exports.defineIdGenerator = exports.ID_GENERATOR = exports.getModelType = exports.defineModelType = exports.MODEL_TYPE = void 0;
-require("reflect-metadata");
-// Model type
-exports.MODEL_TYPE = "MODEL_TYPE";
-const defineModelType = (target, type) => {
-    Reflect.defineMetadata(exports.MODEL_TYPE, type, target);
-};
-exports.defineModelType = defineModelType;
-const getModelType = (target) => {
-    const type = Reflect.getMetadata(exports.MODEL_TYPE, target);
-    if (!type)
-        throw new Error("The type has not been defined");
-    return type;
-};
-exports.getModelType = getModelType;
-// Id generator
-exports.ID_GENERATOR = "ID_GENERATOR";
-const defineIdGenerator = (target, idGenerator) => {
-    Reflect.defineMetadata(exports.ID_GENERATOR, idGenerator, target);
-};
-exports.defineIdGenerator = defineIdGenerator;
-const getIdGenerator = (target) => {
-    return Reflect.getMetadata(exports.ID_GENERATOR, target);
-};
-exports.getIdGenerator = getIdGenerator;
-// Event applier map
-exports.EVENT_APPLIERS = "EVENT_APPLIERS";
-const getEventAppliersMap = (target) => {
-    return (Reflect.getMetadata(exports.EVENT_APPLIERS, target) ||
-        new Map());
-};
-exports.getEventAppliersMap = getEventAppliersMap;
-const defineEventApplier = (target, eventType, applier) => {
-    const eventAppliersMap = (0, exports.getEventAppliersMap)(target);
-    eventAppliersMap.set(eventType, applier);
-    Reflect.defineMetadata(exports.EVENT_APPLIERS, eventAppliersMap, target);
-};
-exports.defineEventApplier = defineEventApplier;
-// Command handler map
-exports.COMMAND_HANDLERS = "COMMAND_HANDLERS";
-const getCommandHandlersMap = (target) => {
-    return (Reflect.getMetadata(exports.COMMAND_HANDLERS, target) ||
-        new Map());
-};
-exports.getCommandHandlersMap = getCommandHandlersMap;
-const defineCommandHandler = (target, commandType, handler) => {
-    const commandHandlersMap = (0, exports.getCommandHandlersMap)(target);
-    commandHandlersMap.set(commandType, handler);
-    Reflect.defineMetadata(exports.COMMAND_HANDLERS, commandHandlersMap, target);
-};
-exports.defineCommandHandler = defineCommandHandler;