ddd-node 33.0.0 → 34.0.0

package/base/decorators/model.js

@@ -46,7 +46,7 @@ function Model(p1, p2, p3) {
             domain.modelRegistry.registerModel(target);
         }
         if (modelOptions === null || modelOptions === void 0 ? void 0 : modelOptions.propsValidator)
-            (0, meta_1.defineModelPropsValidator)(target, modelOptions.propsValidator);
+            (0, meta_1.defineModelPropGettersValidator)(target, modelOptions.propsValidator);
     };
 }
 exports.Model = Model;

package/base/decorators/prop.d.ts

@@ -1,2 +1,4 @@
 import { AnyDomainModel, InferredProps } from "../model";
-export declare const Prop: <T extends AnyDomainModel>(propTargetKey?: keyof InferredProps<T> | undefined) => (target: T, key: PropertyKey) => void;
+import { PropertyConverter } from "../meta";
+export declare function Prop<T extends AnyDomainModel>(propTargetKey?: keyof InferredProps<T>, converter?: PropertyConverter): PropertyDecorator;
+export declare function Prop<T extends AnyDomainModel>(converter?: PropertyConverter): PropertyDecorator;

package/base/decorators/prop.js

@@ -2,9 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Prop = void 0;
 const meta_1 = require("../meta");
-const Prop = (propTargetKey) => {
-    return (target, key) => {
-        (0, meta_1.defineModelProp)(target, key, propTargetKey !== null && propTargetKey !== void 0 ? propTargetKey : key);
-    };
-};
+function Prop(p1, p2) {
+    let propTargetKey, converter;
+    return ((target, key) => {
+        if (!p1 && !p2) {
+            propTargetKey = key;
+        }
+        else if (p1 && !p2) {
+            if (typeof p1 === "function") {
+                propTargetKey = key;
+                converter = p1;
+            }
+            else {
+                propTargetKey = p1;
+            }
+        }
+        else if (p1 && p2) {
+            propTargetKey = p1;
+            converter = p2;
+        }
+        (0, meta_1.registerPropertyAccessor)(target, key, propTargetKey, converter);
+    });
+}
 exports.Prop = Prop;

package/base/decorators/props-validator.js

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PropsValidator = void 0;
 const __1 = require("..");
 const PropsValidator = (target, key, propertyDescriptor) => {
-    (0, __1.defineModelPropsValidator)(target, propertyDescriptor.value);
+    (0, __1.defineModelPropGettersValidator)(target, propertyDescriptor.value);
 };
 exports.PropsValidator = PropsValidator;

package/base/meta/index.d.ts

@@ -1,6 +1,6 @@
 export * from "./model-id";
 export * from "./model-name";
-export * from "./model-props-map";
+export * from "./model-property-accessor";
 export * from "./model-static-values";
 export * from "./model-props-validator";
 export * from "./model-version";

package/base/meta/index.js

@@ -16,7 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./model-id"), exports);
 __exportStar(require("./model-name"), exports);
-__exportStar(require("./model-props-map"), exports);
+__exportStar(require("./model-property-accessor"), exports);
 __exportStar(require("./model-static-values"), exports);
 __exportStar(require("./model-props-validator"), exports);
 __exportStar(require("./model-version"), exports);

package/base/meta/model-domain.d.ts

@@ -1,5 +1,5 @@
 import { DomainName } from "../domain";
 import { AnyDomainModel, DomainModelClass } from "../model";
-export declare const ModelDomainMetaKey: unique symbol;
+export declare const MODEL_DOMAIN: unique symbol;
 export declare const defineModelDomain: <T extends AnyDomainModel>(target: DomainModelClass<T>, domainName: DomainName) => void;
 export declare const getModelDomain: <T extends AnyDomainModel>(target: DomainModelClass<T>) => string;

package/base/meta/model-domain.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getModelDomain = exports.defineModelDomain = exports.ModelDomainMetaKey = void 0;
+exports.getModelDomain = exports.defineModelDomain = exports.MODEL_DOMAIN = void 0;
 const domain_1 = require("../domain");
-exports.ModelDomainMetaKey = Symbol.for("MODEL_DOMAIN");
+exports.MODEL_DOMAIN = Symbol.for("MODEL_DOMAIN");
 const defineModelDomain = (target, domainName) => {
-    Reflect.defineMetadata(exports.ModelDomainMetaKey, domainName, target);
+    Reflect.defineMetadata(exports.MODEL_DOMAIN, domainName, target);
 };
 exports.defineModelDomain = defineModelDomain;
 const getModelDomain = (target) => {
-    if (!Reflect.hasOwnMetadata(exports.ModelDomainMetaKey, target))
+    if (!Reflect.hasOwnMetadata(exports.MODEL_DOMAIN, target))
         (0, exports.defineModelDomain)(target, domain_1.DEFAULT_DOMAIN);
-    return Reflect.getOwnMetadata(exports.ModelDomainMetaKey, target);
+    return Reflect.getOwnMetadata(exports.MODEL_DOMAIN, target);
 };
 exports.getModelDomain = getModelDomain;

package/base/meta/model-id.js

@@ -23,17 +23,17 @@ class $ModelId extends String {
 exports.$ModelId = $ModelId;
 $ModelId.Divider = "|";
 $ModelId.Format = new RegExp(/^.+\|[0-9]+$/);
-const ModelIdMetaKey = Symbol.for("MODEL_ID");
+const MODEL_ID = Symbol.for("MODEL_ID");
 const setModelId = (target, modelId) => {
-    Reflect.defineMetadata(ModelIdMetaKey, modelId, target);
+    Reflect.defineMetadata(MODEL_ID, modelId, target);
 };
 exports.setModelId = setModelId;
 const getModelId = (target) => {
-    if (!Reflect.hasOwnMetadata(ModelIdMetaKey, target)) {
+    if (!Reflect.hasOwnMetadata(MODEL_ID, target)) {
         const modelName = (0, model_name_1.getModelName)(target);
         const modelVersion = (0, model_version_1.getModelVersion)(target);
         (0, exports.setModelId)(target, new $ModelId(modelName, modelVersion));
     }
-    return Reflect.getOwnMetadata(ModelIdMetaKey, target).valueOf();
+    return Reflect.getOwnMetadata(MODEL_ID, target).valueOf();
 };
 exports.getModelId = getModelId;

package/base/meta/model-mutable.js

@@ -2,14 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getModelMutable = exports.defineModelMutable = void 0;
 require("reflect-metadata");
-const ModelMutableMetaKey = Symbol.for("MODEL_MUTABLE");
+const MODEL_MUTABLE = Symbol.for("MODEL_MUTABLE");
 const defineModelMutable = (target, mutable) => {
-    if (Reflect.hasMetadata(ModelMutableMetaKey, target))
+    if (Reflect.hasMetadata(MODEL_MUTABLE, target))
         return;
-    Reflect.defineMetadata(ModelMutableMetaKey, mutable, target);
+    Reflect.defineMetadata(MODEL_MUTABLE, mutable, target);
 };
 exports.defineModelMutable = defineModelMutable;
 const getModelMutable = (target) => {
-    return Reflect.getMetadata(ModelMutableMetaKey, target);
+    return Reflect.getMetadata(MODEL_MUTABLE, target);
 };
 exports.getModelMutable = getModelMutable;

package/base/meta/model-name.js

@@ -12,14 +12,14 @@ class $ModelName extends String {
     }
 }
 exports.$ModelName = $ModelName;
-const ModelNameMetaKey = Symbol.for("MODEL_NAME");
+const MODEL_NAME = Symbol.for("MODEL_NAME");
 const defineModelName = (target, modelName) => {
-    Reflect.defineMetadata(ModelNameMetaKey, new $ModelName(modelName), target);
+    Reflect.defineMetadata(MODEL_NAME, new $ModelName(modelName), target);
 };
 exports.defineModelName = defineModelName;
 const getModelName = (target) => {
-    if (!Reflect.hasOwnMetadata(ModelNameMetaKey, target))
+    if (!Reflect.hasOwnMetadata(MODEL_NAME, target))
         (0, exports.defineModelName)(target, target.name);
-    return Reflect.getOwnMetadata(ModelNameMetaKey, target).valueOf();
+    return Reflect.getOwnMetadata(MODEL_NAME, target).valueOf();
 };
 exports.getModelName = getModelName;

package/base/meta/model-property-accessor.d.ts

@@ -0,0 +1,11 @@
+import { AnyDomainModel, InferredProps } from "../model";
+export type PropertyConverter<T = any> = (value: any) => T;
+export type PropertyAccessorMetadata<T extends AnyDomainModel, R> = {
+    targetKey: keyof InferredProps<T>;
+    converter?: PropertyConverter<R>;
+};
+export declare class ModelPropertyAccessorMap<T extends AnyDomainModel = AnyDomainModel> extends Map<PropertyKey, PropertyAccessorMetadata<T, any>> {
+}
+export declare const getDeclaredPropertyAccessors: <T extends AnyDomainModel = AnyDomainModel>(target: object) => ModelPropertyAccessorMap<T>;
+export declare const registerPropertyAccessor: <T extends AnyDomainModel = AnyDomainModel>(target: object, key: PropertyKey, propTargetKey: keyof InferredProps<T>, propConverter?: PropertyConverter) => void;
+export declare const getResolvedPropertyAccessors: <T extends AnyDomainModel = AnyDomainModel>(target: object) => ModelPropertyAccessorMap<T>;

package/base/meta/model-property-accessor.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResolvedPropertyAccessors = exports.registerPropertyAccessor = exports.getDeclaredPropertyAccessors = exports.ModelPropertyAccessorMap = void 0;
+const model_1 = require("../model");
+const OWN_MODEL_PROPERTY_ACCESSORS = Symbol.for("OWN_MODEL_PROPERTY_ACCESSORS");
+const MODEL_PROPERTY_ACCESSORS = Symbol.for("MODEL_PROPERTY_ACCESSORS");
+class ModelPropertyAccessorMap extends Map {
+}
+exports.ModelPropertyAccessorMap = ModelPropertyAccessorMap;
+// target = prototype
+const getDeclaredPropertyAccessors = (target) => {
+    if (!Reflect.hasOwnMetadata(OWN_MODEL_PROPERTY_ACCESSORS, target)) {
+        Reflect.defineMetadata(OWN_MODEL_PROPERTY_ACCESSORS, new ModelPropertyAccessorMap(), target);
+    }
+    return Reflect.getOwnMetadata(OWN_MODEL_PROPERTY_ACCESSORS, target);
+};
+exports.getDeclaredPropertyAccessors = getDeclaredPropertyAccessors;
+const registerPropertyAccessor = (target, key, propTargetKey, propConverter) => {
+    const declaredMap = (0, exports.getDeclaredPropertyAccessors)(target);
+    declaredMap.set(key, {
+        targetKey: propTargetKey,
+        converter: propConverter,
+    });
+};
+exports.registerPropertyAccessor = registerPropertyAccessor;
+const getResolvedPropertyAccessors = (target) => {
+    if (!Reflect.hasOwnMetadata(MODEL_PROPERTY_ACCESSORS, target)) {
+        const buildMap = (target) => {
+            const result = new ModelPropertyAccessorMap();
+            const ownMaps = [];
+            let current = target;
+            do {
+                if (model_1.DomainModel.isDomainModel(current)) {
+                    ownMaps.unshift((0, exports.getDeclaredPropertyAccessors)(current));
+                }
+                current = Reflect.getPrototypeOf(current);
+            } while (current !== null);
+            ownMaps.forEach((map) => map.forEach((meta, key) => result.set(key, meta)));
+            return result;
+        };
+        Reflect.defineMetadata(MODEL_PROPERTY_ACCESSORS, buildMap(target), target);
+    }
+    return Reflect.getOwnMetadata(MODEL_PROPERTY_ACCESSORS, target);
+};
+exports.getResolvedPropertyAccessors = getResolvedPropertyAccessors;

package/base/meta/model-props-validator.d.ts

@@ -1,6 +1,6 @@
 import { AnyDomainModel, InferredProps } from "../model";
 export type ModelPropsValidator<T extends AnyDomainModel = AnyDomainModel> = (props: InferredProps<T>) => void;
-export declare const defineModelPropsValidator: <T extends AnyDomainModel>(target: object, validator: ModelPropsValidator<T>) => void;
+export declare const defineModelPropGettersValidator: <T extends AnyDomainModel>(target: object, validator: ModelPropsValidator<T>) => void;
 export declare const getOwnModelPropsValidator: <T extends AnyDomainModel>(target: object) => ModelPropsValidator<T> | undefined;
-export declare const ModelPropsValidatorsMetaKey: unique symbol;
+export declare const MODEL_PROPS_VALIDATORS: unique symbol;
 export declare const getModelPropsValidators: (target: object) => ModelPropsValidator[];

package/base/meta/model-props-validator.js

@@ -3,20 +3,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getModelPropsValidators = exports.ModelPropsValidatorsMetaKey = exports.getOwnModelPropsValidator = exports.defineModelPropsValidator = void 0;
+exports.getModelPropsValidators = exports.MODEL_PROPS_VALIDATORS = exports.getOwnModelPropsValidator = exports.defineModelPropGettersValidator = void 0;
 const lodash_1 = __importDefault(require("lodash"));
-const OwnPropsValidatorMetaKey = Symbol.for("OWN_MODEL_PROPS_VALIDATOR");
-const defineModelPropsValidator = (target, validator) => {
-    Reflect.defineMetadata(OwnPropsValidatorMetaKey, validator, target);
+const OWN_MODEL_PROPS_VALIDATOR = Symbol.for("OWN_MODEL_PROPS_VALIDATOR");
+const defineModelPropGettersValidator = (target, validator) => {
+    Reflect.defineMetadata(OWN_MODEL_PROPS_VALIDATOR, validator, target);
 };
-exports.defineModelPropsValidator = defineModelPropsValidator;
+exports.defineModelPropGettersValidator = defineModelPropGettersValidator;
 const getOwnModelPropsValidator = (target) => {
-    return Reflect.getOwnMetadata(OwnPropsValidatorMetaKey, target);
+    return Reflect.getOwnMetadata(OWN_MODEL_PROPS_VALIDATOR, target);
 };
 exports.getOwnModelPropsValidator = getOwnModelPropsValidator;
-exports.ModelPropsValidatorsMetaKey = Symbol.for("MODEL_PROPS_VALIDATORS");
+exports.MODEL_PROPS_VALIDATORS = Symbol.for("MODEL_PROPS_VALIDATORS");
 const getModelPropsValidators = (target) => {
-    if (!Reflect.hasOwnMetadata(exports.ModelPropsValidatorsMetaKey, target)) {
+    if (!Reflect.hasOwnMetadata(exports.MODEL_PROPS_VALIDATORS, target)) {
         let result = [];
         let _target = target;
         do {
@@ -26,8 +26,8 @@ const getModelPropsValidators = (target) => {
             _target = Reflect.getPrototypeOf(_target);
         } while (_target !== null);
         result = lodash_1.default.uniq(result);
-        Reflect.defineMetadata(exports.ModelPropsValidatorsMetaKey, result, target);
+        Reflect.defineMetadata(exports.MODEL_PROPS_VALIDATORS, result, target);
     }
-    return Reflect.getOwnMetadata(exports.ModelPropsValidatorsMetaKey, target);
+    return Reflect.getOwnMetadata(exports.MODEL_PROPS_VALIDATORS, target);
 };
 exports.getModelPropsValidators = getModelPropsValidators;

package/base/meta/model-static-values.js

@@ -13,14 +13,14 @@ class ModelStaticValue {
     }
 }
 exports.ModelStaticValue = ModelStaticValue;
-const OwnModelStaticValuesMetaKey = Symbol.for("OWN_MODEL_STATIC_VALUES");
+const OWN_MODEL_STATIC_VALUES = Symbol.for("OWN_MODEL_STATIC_VALUES");
 class ModelStaticValuesMap extends Map {
 }
 exports.ModelStaticValuesMap = ModelStaticValuesMap;
 const getOwnModelStaticValues = (target) => {
-    if (!Reflect.hasOwnMetadata(OwnModelStaticValuesMetaKey, target))
-        Reflect.defineMetadata(OwnModelStaticValuesMetaKey, new ModelStaticValuesMap(), target);
-    return Reflect.getOwnMetadata(OwnModelStaticValuesMetaKey, target);
+    if (!Reflect.hasOwnMetadata(OWN_MODEL_STATIC_VALUES, target))
+        Reflect.defineMetadata(OWN_MODEL_STATIC_VALUES, new ModelStaticValuesMap(), target);
+    return Reflect.getOwnMetadata(OWN_MODEL_STATIC_VALUES, target);
 };
 exports.getOwnModelStaticValues = getOwnModelStaticValues;
 const setModelStaticValue = (target, key, value) => {

package/base/meta/model-version.js

@@ -12,14 +12,14 @@ class $ModelVersion extends Number {
     }
 }
 exports.$ModelVersion = $ModelVersion;
-const ModelVersionMetaKey = Symbol.for("MODEL_VERSION");
+const MODEL_VERSION = Symbol.for("MODEL_VERSION");
 const defineModelVersion = (target, modelVersion) => {
-    Reflect.defineMetadata(ModelVersionMetaKey, new $ModelVersion(modelVersion), target);
+    Reflect.defineMetadata(MODEL_VERSION, new $ModelVersion(modelVersion), target);
 };
 exports.defineModelVersion = defineModelVersion;
 const getModelVersion = (target) => {
-    if (!Reflect.hasOwnMetadata(ModelVersionMetaKey, target))
+    if (!Reflect.hasOwnMetadata(MODEL_VERSION, target))
         (0, exports.defineModelVersion)(target, 0);
-    return Reflect.getOwnMetadata(ModelVersionMetaKey, target).valueOf();
+    return Reflect.getOwnMetadata(MODEL_VERSION, target).valueOf();
 };
 exports.getModelVersion = getModelVersion;

package/base/model/model-descriptor.d.ts

@@ -1,5 +1,5 @@
 import { AnyDomainModel, DomainModelClass } from ".";
-import { ModelId, ModelName, ModelPropsMap, ModelPropsValidator, ModelStaticValuesMap, ModelVersion } from "../meta";
+import { ModelId, ModelName, ModelPropertyAccessorMap, ModelPropsValidator, ModelStaticValuesMap, ModelVersion } from "../meta";
 export declare class ModelDescriptor<T extends AnyDomainModel = AnyDomainModel> {
     readonly modelClass: DomainModelClass<T>;
     constructor(modelClass: DomainModelClass<T>);
@@ -11,6 +11,6 @@ export declare class ModelDescriptor<T extends AnyDomainModel = AnyDomainModel>
     ownModelPropsValidator(): ModelPropsValidator<T> | undefined;
     modelPropsValidators(): ModelPropsValidator[];
     ownModelStaticValues(): ModelStaticValuesMap<T>;
-    ownModelPropsMap(): ModelPropsMap<T>;
-    modelPropsMap(): ModelPropsMap<T>;
+    declaredPropertyAccessors(): ModelPropertyAccessorMap<T>;
+    resolvedPropertyAccessors(): ModelPropertyAccessorMap<T>;
 }

package/base/model/model-descriptor.js

@@ -31,11 +31,11 @@ class ModelDescriptor {
     ownModelStaticValues() {
         return (0, meta_1.getOwnModelStaticValues)(this.modelClass);
     }
-    ownModelPropsMap() {
-        return (0, meta_1.getOwnModelPropsMap)(this.modelClass.prototype);
+    declaredPropertyAccessors() {
+        return (0, meta_1.getDeclaredPropertyAccessors)(this.modelClass.prototype);
     }
-    modelPropsMap() {
-        return (0, meta_1.getModelPropsMap)(this.modelClass.prototype);
+    resolvedPropertyAccessors() {
+        return (0, meta_1.getResolvedPropertyAccessors)(this.modelClass.prototype);
     }
 }
 exports.ModelDescriptor = ModelDescriptor;

package/base/model/model.d.ts

@@ -1,6 +1,7 @@
 import { AbstractClass, Class } from "type-fest";
 import { ClassStatic } from "../../types";
 import { ModelDescriptor } from "./model-descriptor";
+import { PropertyConverter } from "..";
 export interface Props {
     [key: PropertyKey]: any;
 }
@@ -14,16 +15,19 @@ export declare class DomainModel<P extends Props> {
     static isDomainModel(model: any): model is AnyDomainModel;
     protected _props: P;
     constructor();
-    redefineModel(): void;
-    protected redefineProp<K extends keyof P>(key: keyof this, propTargetKey: K): void;
+    definePropertyAccessors(): void;
+    protected definePropAccessor<K extends keyof P>(key: keyof this, propTargetKey: K, propConverter?: PropertyConverter): void;
     modelDescriptor(): ModelDescriptor<AnyDomainModel>;
     validateProps(props: P): void;
     validate(): void;
-    propsIsEmpty(): boolean;
+    isPropsEmpty(): this is InitializedDomainModel<P>;
     props(): P | null;
     metadata(): any;
     protected initializeProps(propsOrBuilder: P | PropsBuilder<typeof this>): void;
 }
+export type InitializedDomainModel<P extends Props> = DomainModel<P> & {
+    props(): P;
+};
 export type AnyDomainModel = DomainModel<Props>;
 export type InferredProps<T extends AnyDomainModel> = T extends DomainModel<infer P> ? P : never;
 export type DomainModelClass<T extends AnyDomainModel = AnyDomainModel> = Class<T> & ClassStatic<typeof DomainModel<InferredProps<T>>>;

package/base/model/model.js

@@ -16,23 +16,25 @@ class DomainModel {
     }
     constructor() {
         this._props = DomainModel.EMPTY_PROPS;
-        this.redefineModel();
+        this.definePropertyAccessors();
     }
-    redefineModel() {
+    definePropertyAccessors() {
         this.modelDescriptor()
-            .modelPropsMap()
-            .forEach((propTargetKey, key) => {
-            this.redefineProp(key, propTargetKey);
+            .resolvedPropertyAccessors()
+            .forEach(({ targetKey, converter }, key) => {
+            this.definePropAccessor(key, targetKey, converter);
         });
     }
-    redefineProp(key, propTargetKey) {
+    definePropAccessor(key, propTargetKey, propConverter) {
         Object.defineProperty(this, key, {
-            // must be true because the props() method need to recall redefineModel(-> redefineProp)
-            configurable: true,
+            configurable: false,
             enumerable: true,
             get() {
                 var _a;
-                return (_a = this._props) === null || _a === void 0 ? void 0 : _a[propTargetKey];
+                const value = (_a = this._props) === null || _a === void 0 ? void 0 : _a[propTargetKey];
+                if (!propConverter)
+                    return value;
+                return propConverter(value);
             },
         });
     }
@@ -46,24 +48,19 @@ class DomainModel {
     validate() {
         this.validateProps(this._props);
     }
-    propsIsEmpty() {
+    isPropsEmpty() {
         return this._props === DomainModel.EMPTY_PROPS;
     }
     props() {
-        if (this.propsIsEmpty())
+        if (this.isPropsEmpty())
             return null;
-        return lodash_1.default.cloneDeepWith(this._props, (value) => {
-            if (DomainModel.isDomainModel(value)) {
-                value.redefineModel();
-                return value;
-            }
-        });
+        return lodash_1.default.cloneDeep(this._props);
     }
     metadata() {
         return {};
     }
     initializeProps(propsOrBuilder) {
-        if (!this.propsIsEmpty())
+        if (!this.isPropsEmpty())
             throw new errors_1.PropsInitializedError();
         let props;
         if (typeof propsOrBuilder === "function")

package/core/model/aggregate/aggregate.d.ts

@@ -13,6 +13,6 @@ export declare abstract class Aggregate<P extends Props> extends ModelWithId<P>
     metadata(): AggregateMetadata;
     protected createEventSource(): EventSource;
     protected newEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: InferredProps<E>): E;
-    abstract publishEvents(publisher: IAggregateEventPublisher): void;
+    abstract publishEvents<R = any>(publisher: IAggregateEventPublisher<R>): R;
 }
 export type AnyAggregate = Aggregate<Props>;

package/core/model/aggregate/es-aggregate.d.ts

@@ -35,7 +35,7 @@ export declare class ESAggregate<P extends Props> extends Aggregate<P> {
     handleCommand<C extends AnyCommand>(command: C): AnyEvent[];
     takeSnapshot(): Snapshot<this>;
     protected commitEvents(): void;
-    publishEvents(publisher: IAggregateEventPublisher): void;
+    publishEvents<R = any>(publisher: IAggregateEventPublisher<R>): R;
 }
 export type AnyESAggregate = ESAggregate<Props>;
 export interface ESAggregateClass<T extends AnyESAggregate = AnyESAggregate, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof ESAggregate<InferredProps<T>>> {

package/core/model/aggregate/es-aggregate.js

@@ -122,7 +122,7 @@ class ESAggregate extends aggregate_1.Aggregate {
         return events;
     }
     takeSnapshot() {
-        if (this.propsIsEmpty())
+        if (this.isPropsEmpty())
             throw new Error("Cannot create snapshot when the props is not initialized");
         return {
             metadata: this.metadata(),
@@ -130,13 +130,13 @@ class ESAggregate extends aggregate_1.Aggregate {
         };
     }
     commitEvents() {
-        const events = this.events();
+        this._pastEvents.push(...this.events());
         this._events = [];
-        this._pastEvents.push(...events);
     }
     publishEvents(publisher) {
-        publisher.publish(this.events());
+        const events = this.events();
         this.commitEvents();
+        return publisher.publish(events);
     }
 }
 exports.ESAggregate = ESAggregate;

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

@@ -17,7 +17,7 @@ export declare class StateAggregate<P extends Props> extends Aggregate<P> {
     protected recordEvent<E extends AnyEvent>(event: E): void;
     protected recordEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: InferredProps<E>): void;
     clearEvents(): void;
-    publishEvents(publisher: IAggregateEventPublisher): void;
+    publishEvents<R = any>(publisher: IAggregateEventPublisher<R>): R;
 }
 export type AnyStateAggregate = StateAggregate<Props>;
 export interface StateAggregateClass<T extends AnyStateAggregate = AnyStateAggregate, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof StateAggregate<InferredProps<T>>> {

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

@@ -36,8 +36,9 @@ class StateAggregate extends aggregate_1.Aggregate {
         this._events = [];
     }
     publishEvents(publisher) {
-        publisher.publish(this.events());
+        const events = this.events();
         this.clearEvents();
+        return publisher.publish(events);
     }
 }
 exports.StateAggregate = StateAggregate;

package/core/model/aggregate/types.d.ts

@@ -2,6 +2,6 @@ import { ESAggregateClass } from "./es-aggregate";
 import { StateAggregateClass } from "./state-aggregate";
 import { AnyEvent } from "../message";
 export type AggregateClass = StateAggregateClass | ESAggregateClass;
-export interface IAggregateEventPublisher {
-    publish(events: AnyEvent | AnyEvent[]): void;
+export interface IAggregateEventPublisher<R = any> {
+    publish(events: AnyEvent | AnyEvent[]): R;
 }

package/package.json

@@ -1 +1 @@
-{"name":"ddd-node","version":"33.0.0","description":"Domain Driven Design base for NodeJs","type":"commonjs","main":"index.js","types":"index.d.ts","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","tsconfig-paths":"^4.2.0","typescript":"^5.2.2"},"dependencies":{"lodash":"^4.17.21","reflect-metadata":"^0.1.13","ts-node":"^10.9.2","tsc-alias":"^1.8.8","type-fest":"^4.20.1","uuid":"^9.0.1"}}
+{"name":"ddd-node","version":"34.0.0","description":"Domain Driven Design base for NodeJs","type":"commonjs","main":"index.js","types":"index.d.ts","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","tsconfig-paths":"^4.2.0","typescript":"^5.2.2"},"dependencies":{"lodash":"^4.17.21","reflect-metadata":"^0.1.13","ts-node":"^10.9.2","tsc-alias":"^1.8.8","type-fest":"^4.20.1","uuid":"^9.0.1"}}

package/base/meta/model-props-map.d.ts

@@ -1,6 +0,0 @@
-import { AnyDomainModel, InferredProps } from "../model";
-export declare class ModelPropsMap<T extends AnyDomainModel = AnyDomainModel> extends Map<PropertyKey, keyof InferredProps<T>> {
-}
-export declare const getOwnModelPropsMap: <T extends AnyDomainModel = AnyDomainModel>(target: object) => ModelPropsMap<T>;
-export declare const defineModelProp: <T extends AnyDomainModel = AnyDomainModel>(target: object, key: PropertyKey, propTargetKey?: keyof InferredProps<T> | undefined) => void;
-export declare const getModelPropsMap: <T extends AnyDomainModel = AnyDomainModel>(target: object) => ModelPropsMap<T>;

package/base/meta/model-props-map.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getModelPropsMap = exports.defineModelProp = exports.getOwnModelPropsMap = exports.ModelPropsMap = void 0;
-const model_1 = require("../model");
-const OwnModelPropsMapMetaKey = Symbol.for("OWN_MODEL_PROPS_MAP");
-class ModelPropsMap extends Map {
-}
-exports.ModelPropsMap = ModelPropsMap;
-// target is prototype
-const getOwnModelPropsMap = (target) => {
-    if (!Reflect.hasOwnMetadata(OwnModelPropsMapMetaKey, target))
-        Reflect.defineMetadata(OwnModelPropsMapMetaKey, new ModelPropsMap(), target);
-    return Reflect.getOwnMetadata(OwnModelPropsMapMetaKey, target);
-};
-exports.getOwnModelPropsMap = getOwnModelPropsMap;
-const defineModelProp = (target, key, propTargetKey) => {
-    const ownModelPropsMap = (0, exports.getOwnModelPropsMap)(target);
-    if (propTargetKey)
-        ownModelPropsMap.set(key, propTargetKey);
-};
-exports.defineModelProp = defineModelProp;
-const ModelPropsMapMetaKey = Symbol.for("MODEL_PROPS_MAP");
-const getModelPropsMap = (target) => {
-    if (!Reflect.hasOwnMetadata(ModelPropsMapMetaKey, target)) {
-        const buildPropsMap = (target) => {
-            let _target = target;
-            const result = new ModelPropsMap();
-            const ownPropsMapList = [];
-            do {
-                if (model_1.DomainModel.isDomainModel(_target)) {
-                    const ownModelPropsMap = (0, exports.getOwnModelPropsMap)(_target);
-                    ownPropsMapList.unshift(ownModelPropsMap);
-                }
-                _target = Reflect.getPrototypeOf(_target);
-            } while (_target !== null);
-            ownPropsMapList.forEach((ownModelPropsMap) => {
-                ownModelPropsMap.forEach((targetPropKey, key) => result.set(key, targetPropKey));
-            });
-            return result;
-        };
-        Reflect.defineMetadata(ModelPropsMapMetaKey, buildPropsMap(target), target);
-    }
-    return Reflect.getOwnMetadata(ModelPropsMapMetaKey, target);
-};
-exports.getModelPropsMap = getModelPropsMap;