ddd-node 24.7.0 → 26.0.0

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

@@ -2,3 +2,4 @@ export * from "./prop";
 export * from "./model";
 export * from "./static";
 export * from "./mutable";
+export * from "./props-validator";

package/dist/base/decorators/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./prop"), exports);
 __exportStar(require("./model"), exports);
 __exportStar(require("./static"), exports);
 __exportStar(require("./mutable"), exports);
+__exportStar(require("./props-validator"), exports);

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

@@ -1,10 +1,10 @@
 import { AnyModel, ModelClass } from "../model";
-import { PropsValidator } from "../meta";
+import { ModelPropsValidator } from "../meta";
 export type ModelOptions<T extends AnyModel = AnyModel> = {
     name?: string;
     version?: number;
     domain?: string;
-    propsValidator?: PropsValidator<T>;
+    propsValidator?: ModelPropsValidator<T>;
     autoRegisterModel?: boolean;
 };
 export declare function Model<T extends ModelClass, I extends InstanceType<T> = InstanceType<T>>(options?: ModelOptions<I>): any;

package/dist/base/decorators/model.js

@@ -48,7 +48,7 @@ function Model(p1, p2, p3) {
             domain.modelRegistry.registerModel(target);
         }
         if (modelOptions?.propsValidator)
-            (0, meta_1.definePropsValidator)(target, modelOptions.propsValidator);
+            (0, meta_1.defineModelPropsValidator)(target, modelOptions.propsValidator);
     };
 }
 exports.Model = Model;

package/dist/base/decorators/prop.js

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

package/dist/base/decorators/props-validator.d.ts

@@ -0,0 +1,2 @@
+import { AnyModel, ModelClass, ModelPropsValidator } from "..";
+export declare const PropsValidator: <T extends AnyModel>(target: ModelClass<T>, key: string, propertyDescriptor: TypedPropertyDescriptor<ModelPropsValidator<T>>) => void;

package/dist/base/decorators/props-validator.js

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

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

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

package/dist/base/decorators/static.js

@@ -4,8 +4,8 @@ exports.Static = void 0;
 const meta_1 = require("../meta");
 const Static = (builder) => {
     return (target, key) => {
-        (0, meta_1.setStaticValue)(target, key, builder);
-        (0, meta_1.defineStaticValueProperty)(target, key);
+        (0, meta_1.setModelStaticValue)(target, key, builder);
+        (0, meta_1.defineModelStaticValueProperty)(target, key);
     };
 };
 exports.Static = Static;

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

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

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

@@ -1,45 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPropsMap = exports.defineProp = exports.getOwnPropsMap = exports.PropsMap = void 0;
+exports.getModelPropsMap = exports.defineModelProp = exports.getOwnModelPropsMap = exports.ModelPropsMap = void 0;
 const model_1 = require("../model");
-const OwnPropsMapMetaKey = Symbol.for("OWN_PROPS_MAP");
-class PropsMap extends Map {
+const OwnModelPropsMapMetaKey = Symbol.for("OWN_MODEL_PROPS_MAP");
+class ModelPropsMap extends Map {
 }
-exports.PropsMap = PropsMap;
+exports.ModelPropsMap = ModelPropsMap;
 // target is prototype
-const getOwnPropsMap = (target) => {
-    if (!Reflect.hasOwnMetadata(OwnPropsMapMetaKey, target))
-        Reflect.defineMetadata(OwnPropsMapMetaKey, new PropsMap(), target);
-    return Reflect.getOwnMetadata(OwnPropsMapMetaKey, target);
+const getOwnModelPropsMap = (target) => {
+    if (!Reflect.hasOwnMetadata(OwnModelPropsMapMetaKey, target))
+        Reflect.defineMetadata(OwnModelPropsMapMetaKey, new ModelPropsMap(), target);
+    return Reflect.getOwnMetadata(OwnModelPropsMapMetaKey, target);
 };
-exports.getOwnPropsMap = getOwnPropsMap;
-const defineProp = (target, key, propTargetKey) => {
-    const ownPropsMap = (0, exports.getOwnPropsMap)(target);
+exports.getOwnModelPropsMap = getOwnModelPropsMap;
+const defineModelProp = (target, key, propTargetKey) => {
+    const ownModelPropsMap = (0, exports.getOwnModelPropsMap)(target);
     if (propTargetKey)
-        ownPropsMap.set(key, propTargetKey);
+        ownModelPropsMap.set(key, propTargetKey);
 };
-exports.defineProp = defineProp;
-const PropsMapMetaKey = Symbol.for("PROPS_MAP");
-const getPropsMap = (target) => {
-    if (!Reflect.hasOwnMetadata(PropsMapMetaKey, target)) {
+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 PropsMap();
+            const result = new ModelPropsMap();
             const ownPropsMapList = [];
             do {
                 if (model_1.ModelBase.isModel(_target)) {
-                    const ownPropsMap = (0, exports.getOwnPropsMap)(_target);
-                    ownPropsMapList.unshift(ownPropsMap);
+                    const ownModelPropsMap = (0, exports.getOwnModelPropsMap)(_target);
+                    ownPropsMapList.unshift(ownModelPropsMap);
                 }
                 _target = Reflect.getPrototypeOf(_target);
             } while (_target !== null);
-            ownPropsMapList.forEach((ownPropsMap) => {
-                ownPropsMap.forEach((targetPropKey, key) => result.set(key, targetPropKey));
+            ownPropsMapList.forEach((ownModelPropsMap) => {
+                ownModelPropsMap.forEach((targetPropKey, key) => result.set(key, targetPropKey));
             });
             return result;
         };
-        Reflect.defineMetadata(PropsMapMetaKey, buildPropsMap(target), target);
+        Reflect.defineMetadata(ModelPropsMapMetaKey, buildPropsMap(target), target);
     }
-    return Reflect.getOwnMetadata(PropsMapMetaKey, target);
+    return Reflect.getOwnMetadata(ModelPropsMapMetaKey, target);
 };
-exports.getPropsMap = getPropsMap;
+exports.getModelPropsMap = getModelPropsMap;

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

@@ -1,6 +1,6 @@
 import { AnyModel, PropsOf } from "../model";
-export type PropsValidator<T extends AnyModel = AnyModel> = (props: PropsOf<T>) => void;
-export declare const definePropsValidator: <T extends AnyModel>(target: object, validator: PropsValidator<T>) => void;
-export declare const getOwnPropsValidator: <T extends AnyModel>(target: object) => PropsValidator<T> | undefined;
-export declare const PropsValidatorsMetaKey: unique symbol;
-export declare const getPropsValidators: (target: object) => PropsValidator[];
+export type ModelPropsValidator<T extends AnyModel = AnyModel> = (props: PropsOf<T>) => void;
+export declare const defineModelPropsValidator: <T extends AnyModel>(target: object, validator: ModelPropsValidator<T>) => void;
+export declare const getOwnModelPropsValidator: <T extends AnyModel>(target: object) => ModelPropsValidator<T> | undefined;
+export declare const ModelPropsValidatorsMetaKey: unique symbol;
+export declare const getModelPropsValidators: (target: object) => ModelPropsValidator[];

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

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

package/dist/base/meta/model-static-values.d.ts

@@ -1,13 +1,13 @@
 import { AnyModel, ModelClass } from "../model";
-export type StaticValueBuilder<T extends AnyModel = AnyModel> = () => T;
-export declare class StaticValue<T extends AnyModel = AnyModel> {
+export type ModelStaticValueBuilder<T extends AnyModel = AnyModel> = () => T;
+export declare class ModelStaticValue<T extends AnyModel = AnyModel> {
     private _value;
-    constructor(value: T | StaticValueBuilder<T>);
+    constructor(value: T | ModelStaticValueBuilder<T>);
     get value(): T;
 }
-export declare class StaticValuesMap<T extends AnyModel = AnyModel> extends Map<PropertyKey, StaticValue<T>> {
+export declare class ModelStaticValuesMap<T extends AnyModel = AnyModel> extends Map<PropertyKey, ModelStaticValue<T>> {
 }
-export declare const getOwnStaticValues: <T extends AnyModel>(target: object) => StaticValuesMap<T>;
-export declare const setStaticValue: <T extends AnyModel>(target: object, key: PropertyKey, value: T | StaticValueBuilder<T>) => void;
-export declare const getStaticValue: (target: object, key: PropertyKey) => AnyModel | undefined;
-export declare const defineStaticValueProperty: (target: ModelClass, key: PropertyKey) => void;
+export declare const getOwnModelStaticValues: <T extends AnyModel>(target: object) => ModelStaticValuesMap<T>;
+export declare const setModelStaticValue: <T extends AnyModel>(target: object, key: PropertyKey, value: T | ModelStaticValueBuilder<T>) => void;
+export declare const getModelStaticValue: (target: object, key: PropertyKey) => AnyModel | undefined;
+export declare const defineModelStaticValueProperty: (target: ModelClass, key: PropertyKey) => void;

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineStaticValueProperty = exports.getStaticValue = exports.setStaticValue = exports.getOwnStaticValues = exports.StaticValuesMap = exports.StaticValue = void 0;
-class StaticValue {
+exports.defineModelStaticValueProperty = exports.getModelStaticValue = exports.setModelStaticValue = exports.getOwnModelStaticValues = exports.ModelStaticValuesMap = exports.ModelStaticValue = void 0;
+class ModelStaticValue {
     constructor(value) {
         this._value = value;
     }
@@ -12,43 +12,43 @@ class StaticValue {
         return this._value;
     }
 }
-exports.StaticValue = StaticValue;
-const OwnStaticValuesMetaKey = Symbol.for("OWN_STATIC_VALUES");
-class StaticValuesMap extends Map {
+exports.ModelStaticValue = ModelStaticValue;
+const OwnModelStaticValuesMetaKey = Symbol.for("OWN_MODEL_STATIC_VALUES");
+class ModelStaticValuesMap extends Map {
 }
-exports.StaticValuesMap = StaticValuesMap;
-const getOwnStaticValues = (target) => {
-    if (!Reflect.hasOwnMetadata(OwnStaticValuesMetaKey, target))
-        Reflect.defineMetadata(OwnStaticValuesMetaKey, new StaticValuesMap(), target);
-    return Reflect.getOwnMetadata(OwnStaticValuesMetaKey, target);
+exports.ModelStaticValuesMap = ModelStaticValuesMap;
+const getOwnModelStaticValues = (target) => {
+    if (!Reflect.hasOwnMetadata(OwnModelStaticValuesMetaKey, target))
+        Reflect.defineMetadata(OwnModelStaticValuesMetaKey, new ModelStaticValuesMap(), target);
+    return Reflect.getOwnMetadata(OwnModelStaticValuesMetaKey, target);
 };
-exports.getOwnStaticValues = getOwnStaticValues;
-const setStaticValue = (target, key, value) => {
-    const staticValues = (0, exports.getOwnStaticValues)(target);
-    staticValues.set(key, new StaticValue(value));
+exports.getOwnModelStaticValues = getOwnModelStaticValues;
+const setModelStaticValue = (target, key, value) => {
+    const staticValues = (0, exports.getOwnModelStaticValues)(target);
+    staticValues.set(key, new ModelStaticValue(value));
 };
-exports.setStaticValue = setStaticValue;
-const getStaticValue = (target, key) => {
+exports.setModelStaticValue = setModelStaticValue;
+const getModelStaticValue = (target, key) => {
     let _target = target;
     do {
-        const staticValues = (0, exports.getOwnStaticValues)(_target);
+        const staticValues = (0, exports.getOwnModelStaticValues)(_target);
         if (staticValues.has(key))
             return staticValues.get(key)?.value;
         _target = Reflect.getPrototypeOf(_target);
     } while (_target !== null);
     return undefined;
 };
-exports.getStaticValue = getStaticValue;
-const defineStaticValueProperty = (target, key) => {
+exports.getModelStaticValue = getModelStaticValue;
+const defineModelStaticValueProperty = (target, key) => {
     Object.defineProperty(target, key, {
         configurable: false,
         enumerable: true,
         get() {
-            return (0, exports.getStaticValue)(target, key);
+            return (0, exports.getModelStaticValue)(target, key);
         },
         set() {
             throw new Error("Static value is readonly");
         },
     });
 };
-exports.defineStaticValueProperty = defineStaticValueProperty;
+exports.defineModelStaticValueProperty = defineModelStaticValueProperty;

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

@@ -1,13 +1,13 @@
 import { AnyModel } from "./model";
-import { ModelId, ModelName, ModelVersion, PropsMap, PropsValidator, StaticValuesMap } from "../meta";
+import { ModelId, ModelName, ModelVersion, ModelPropsMap, ModelPropsValidator, ModelStaticValuesMap } from "../meta";
 export interface ModelDescriptor<T extends AnyModel = AnyModel> {
     modelId: ModelId;
     modelName: ModelName;
     modelVersion: ModelVersion;
     modelMutable: boolean;
-    ownPropsValidator?: PropsValidator<T>;
-    propsValidators: PropsValidator[];
-    ownStaticValues: StaticValuesMap<T>;
-    ownPropsMap: PropsMap<T>;
-    propsMap: PropsMap<T>;
+    ownModelPropsValidator?: ModelPropsValidator<T>;
+    modelPropsValidators: ModelPropsValidator[];
+    ownModelStaticValues: ModelStaticValuesMap<T>;
+    ownModelPropsMap: ModelPropsMap<T>;
+    modelPropsMap: ModelPropsMap<T>;
 }

package/dist/base/model/model.d.ts

@@ -1,6 +1,6 @@
 import { AbstractClass, Class } from "type-fest";
 import { ClassStatic } from "../../types";
-import { ModelId, ModelName, ModelVersion, PropsMap, PropsValidator, StaticValuesMap } from "../meta";
+import { ModelId, ModelName, ModelPropsMap, ModelPropsValidator, ModelStaticValuesMap, ModelVersion } from "../meta";
 import { ModelDescriptor } from "./model-descriptor";
 export interface Props {
     [key: PropertyKey]: any;
@@ -16,11 +16,11 @@ export declare class ModelBase<P extends Props> {
     static modelName<T extends AnyModel>(this: ModelClass<T>): ModelName;
     static modelVersion<T extends AnyModel>(this: ModelClass<T>): ModelVersion;
     static modelId<T extends AnyModel>(this: ModelClass<T>): ModelId;
-    static ownPropsValidator<T extends AnyModel>(this: ModelClass<T>): PropsValidator<T> | undefined;
-    static propsValidators<T extends AnyModel>(this: ModelClass<T>): PropsValidator[];
-    static ownStaticValues<T extends AnyModel>(this: ModelClass<T>): StaticValuesMap<T>;
-    static ownPropsMap<T extends AnyModel>(this: ModelClass<T>): PropsMap<T>;
-    static propsMap<T extends AnyModel>(this: ModelClass<T>): PropsMap<T>;
+    static ownModelPropsValidator<T extends AnyModel>(this: ModelClass<T>): ModelPropsValidator<T> | undefined;
+    static modelPropsValidators<T extends AnyModel>(this: ModelClass<T>): ModelPropsValidator[];
+    static ownModelStaticValues<T extends AnyModel>(this: ModelClass<T>): ModelStaticValuesMap<T>;
+    static ownModelPropsMap<T extends AnyModel>(this: ModelClass<T>): ModelPropsMap<T>;
+    static modelPropsMap<T extends AnyModel>(this: ModelClass<T>): ModelPropsMap<T>;
     constructor();
     redefineModel(): void;
     protected redefineProp<K extends keyof P>(key: keyof this, propTargetKey: K): void;

package/dist/base/model/model.js

@@ -23,27 +23,27 @@ class ModelBase {
     static modelId() {
         return (0, meta_1.getModelId)(this);
     }
-    static ownPropsValidator() {
-        return (0, meta_1.getOwnPropsValidator)(this);
+    static ownModelPropsValidator() {
+        return (0, meta_1.getOwnModelPropsValidator)(this);
     }
-    static propsValidators() {
-        return (0, meta_1.getPropsValidators)(this);
+    static modelPropsValidators() {
+        return (0, meta_1.getModelPropsValidators)(this);
     }
-    static ownStaticValues() {
-        return (0, meta_1.getOwnStaticValues)(this);
+    static ownModelStaticValues() {
+        return (0, meta_1.getOwnModelStaticValues)(this);
     }
-    static ownPropsMap() {
-        return (0, meta_1.getOwnPropsMap)(this.prototype);
+    static ownModelPropsMap() {
+        return (0, meta_1.getOwnModelPropsMap)(this.prototype);
     }
-    static propsMap() {
-        return (0, meta_1.getPropsMap)(this.prototype);
+    static modelPropsMap() {
+        return (0, meta_1.getModelPropsMap)(this.prototype);
     }
     constructor() {
         this._props = ModelBase.EMPTY_PROPS;
         this.redefineModel();
     }
     redefineModel() {
-        this.modelDescriptor().propsMap.forEach((propTargetKey, key) => {
+        this.modelDescriptor().modelPropsMap.forEach((propTargetKey, key) => {
             this.redefineProp(key, propTargetKey);
         });
     }
@@ -64,16 +64,16 @@ class ModelBase {
             modelId: modelClass.modelId(),
             modelName: modelClass.modelName(),
             modelVersion: modelClass.modelVersion(),
-            ownPropsValidator: modelClass.ownPropsValidator(),
-            propsValidators: modelClass.propsValidators(),
-            ownStaticValues: modelClass.ownStaticValues(),
-            ownPropsMap: modelClass.ownPropsMap(),
-            propsMap: modelClass.propsMap(),
+            ownModelPropsValidator: modelClass.ownModelPropsValidator(),
+            modelPropsValidators: modelClass.modelPropsValidators(),
+            ownModelStaticValues: modelClass.ownModelStaticValues(),
+            ownModelPropsMap: modelClass.ownModelPropsMap(),
+            modelPropsMap: modelClass.modelPropsMap(),
         };
     }
     validateProps(props) {
-        const propsValidators = this.modelDescriptor().propsValidators;
-        propsValidators.forEach((propsValidator) => propsValidator.call(this.constructor, props));
+        const modelPropsValidators = this.modelDescriptor().modelPropsValidators;
+        modelPropsValidators.forEach((propsValidator) => propsValidator.call(this.constructor, props));
     }
     validate() {
         this.validateProps(this._props);

package/dist/core/aggregate/aggregate-base/aggregate.builder.d.ts

@@ -1,6 +1,6 @@
-import { EntityBuilderBase } from "../../entity";
+import { IdentifiableModelBuilder } from "../../identifiable-model";
 import { AnyAggregate } from "./aggregate";
-export declare abstract class AggregateBuilderBase<T extends AnyAggregate> extends EntityBuilderBase<T> {
+export declare abstract class AggregateBuilderBase<T extends AnyAggregate> extends IdentifiableModelBuilder<T> {
     protected version: number;
     withVersion(version: number): this;
 }

package/dist/core/aggregate/aggregate-base/aggregate.builder.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AggregateBuilderBase = void 0;
-const entity_1 = require("../../entity");
-class AggregateBuilderBase extends entity_1.EntityBuilderBase {
+const identifiable_model_1 = require("../../identifiable-model");
+class AggregateBuilderBase extends identifiable_model_1.IdentifiableModelBuilder {
     constructor() {
         super(...arguments);
         this.version = 0;

package/dist/core/aggregate/aggregate-base/aggregate.d.ts

@@ -1,11 +1,11 @@
 import { Props, PropsOf } from "../../../base";
-import { EntityBase, EntityMetadata } from "../../entity";
+import { IdentifiableModel, IdentifiableModelMetadata } from "../../identifiable-model";
 import { AnyEvent, EventClassWithTypedConstructor, EventSource } from "../../message";
 import { IAggregateEventDispatcher } from "./aggregate-event-dispatcher.interface";
-export interface AggregateMetadata extends EntityMetadata {
+export interface AggregateMetadata extends IdentifiableModelMetadata {
     version: number;
 }
-export declare abstract class AggregateBase<P extends Props> extends EntityBase<P> {
+export declare abstract class AggregateBase<P extends Props> extends IdentifiableModel<P> {
     protected readonly _version: number;
     constructor(metadata: AggregateMetadata, props?: P);
     abstract version(): number;

package/dist/core/aggregate/aggregate-base/aggregate.js

@@ -1,11 +1,22 @@
 "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);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AggregateBase = void 0;
-const entity_1 = require("../../entity");
-const message_1 = require("../../message");
-class AggregateBase extends entity_1.EntityBase {
+const base_1 = require("../../../base");
+const identifiable_model_1 = require("../../identifiable-model");
+let AggregateBase = class AggregateBase extends identifiable_model_1.IdentifiableModel {
     constructor(metadata, props) {
-        super(metadata, props);
+        super(metadata);
+        if (props)
+            this.initializeProps(props);
         this._version = metadata.version;
     }
     metadata() {
@@ -21,11 +32,15 @@ class AggregateBase extends entity_1.EntityBase {
         };
     }
     newEvent(eventClass, props) {
-        const eventBuilder = new message_1.EventBuilder(eventClass);
-        return eventBuilder
+        return eventClass
+            .builder()
             .withSource(this.createEventSource())
             .withProps(props)
             .build();
     }
-}
+};
 exports.AggregateBase = AggregateBase;
+exports.AggregateBase = AggregateBase = __decorate([
+    (0, base_1.Mutable)(true),
+    __metadata("design:paramtypes", [Object, Object])
+], AggregateBase);

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

@@ -6,9 +6,11 @@ import { AggregateBase, AggregateMetadata } from "../aggregate-base";
 import { IAggregateEventDispatcher } from "../aggregate-base";
 import { EventSourcedAggregateModelDescriptor } from "./event-sourced-aggregate-model-descriptor";
 import { Snapshot, SnapshotMetadata } from "./snapshot";
+import { EventSourcedAggregateBuilder } from ".";
 export interface EventSourceAggregateMetadata extends AggregateMetadata {
 }
 export declare class EventSourcedAggregateBase<P extends Props> extends AggregateBase<P> {
+    static builder<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClass<T>): EventSourcedAggregateBuilder<T>;
     private _handledCommands;
     private _pastEvents;
     private _events;
@@ -23,7 +25,7 @@ export declare class EventSourcedAggregateBase<P extends Props> extends Aggregat
     events(): AnyEvent[];
     handledCommands(): AnyCommand[];
     hasNewEvent(): boolean;
-    getApplierForEvent<E extends AnyEvent>(event: E): EventApplier<E>;
+    getEventApplier<E extends AnyEvent>(event: E): EventApplier<E>;
     private validateEventBeforeApply;
     private _applyEvent;
     private applyPastEvent;
@@ -31,7 +33,7 @@ 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;
-    getHandlerForCommand<C extends AnyCommand>(command: C): CommandHandler<C, AnyEvent | AnyEvent[]>;
+    getCommandHandler<C extends AnyCommand>(command: C): CommandHandler<C, AnyEvent | AnyEvent[]>;
     handleCommand<C extends AnyCommand>(command: C): AnyEvent[];
     snapMetadata(): SnapshotMetadata;
     snap(): Snapshot<this>;

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

@@ -4,7 +4,11 @@ exports.EventSourcedAggregateBase = void 0;
 const meta_1 = require("../../../meta");
 const utils_1 = require("../../../utils");
 const aggregate_base_1 = require("../aggregate-base");
+const _1 = require(".");
 class EventSourcedAggregateBase extends aggregate_base_1.AggregateBase {
+    static builder() {
+        return new _1.EventSourcedAggregateBuilder(this);
+    }
     constructor(metadata, props) {
         super(metadata, props);
         this._handledCommands = [];
@@ -48,7 +52,7 @@ class EventSourcedAggregateBase extends aggregate_base_1.AggregateBase {
     hasNewEvent() {
         return Boolean(this._events.length);
     }
-    getApplierForEvent(event) {
+    getEventApplier(event) {
         const { eventType } = event.modelDescriptor();
         const { eventApplierMap } = this.modelDescriptor();
         const applier = eventApplierMap.get(eventType);
@@ -64,13 +68,13 @@ class EventSourcedAggregateBase extends aggregate_base_1.AggregateBase {
             throw new Error("Invalid aggregate version");
     }
     _applyEvent(event) {
-        const applier = this.getApplierForEvent(event);
+        const applier = this.getEventApplier(event);
         this.validateEventBeforeApply(event);
         applier.call(this, event);
     }
     applyPastEvent(event) {
         if (this.hasNewEvent())
-            throw new Error();
+            throw new Error("Cannot apply a past event when new event is recorded");
         this._applyEvent(event);
         this._pastEvents.push(event);
     }
@@ -91,7 +95,7 @@ class EventSourcedAggregateBase extends aggregate_base_1.AggregateBase {
     applyNewEvent(eventClass, props) {
         this.applyEvent(this.newEvent(eventClass, props));
     }
-    getHandlerForCommand(command) {
+    getCommandHandler(command) {
         const { commandType } = command.modelDescriptor();
         const { commandHandlerMap } = this.modelDescriptor();
         const handler = commandHandlerMap.get(commandType);
@@ -100,7 +104,7 @@ class EventSourcedAggregateBase extends aggregate_base_1.AggregateBase {
         return handler;
     }
     handleCommand(command) {
-        const handler = this.getHandlerForCommand(command);
+        const handler = this.getCommandHandler(command);
         const events = (0, utils_1.toArray)(handler.call(this, command));
         events.forEach((event) => {
             event.setCausationId(command.id());

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

@@ -3,9 +3,11 @@ import { Props, PropsOf } from "../../../base";
 import { ClassStatic } from "../../../types";
 import { AnyEvent, EventClassWithTypedConstructor } from "../../message";
 import { AggregateBase, AggregateMetadata, IAggregateEventDispatcher } from "../aggregate-base";
+import { StateAggregateBuilder } from ".";
 export interface StateAggregateMetadata extends AggregateMetadata {
 }
 export declare class StateAggregateBase<P extends Props> extends AggregateBase<P> {
+    static builder<T extends AnyStateAggregate>(this: StateAggregateClass<T>): StateAggregateBuilder<T>;
     private _events;
     constructor(metadata: StateAggregateMetadata, props: P);
     props(): P;

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

@@ -2,7 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StateAggregateBase = void 0;
 const aggregate_base_1 = require("../aggregate-base");
+const _1 = require(".");
 class StateAggregateBase extends aggregate_base_1.AggregateBase {
+    static builder() {
+        return new _1.StateAggregateBuilder(this);
+    }
     constructor(metadata, props) {
         super(metadata, props);
         this._events = [];

package/dist/core/entity/entity.builder.d.ts

@@ -1,8 +1,6 @@
 import { IdentifiableModelBuilder } from "../identifiable-model";
 import { AnyEntity, EntityClassWithTypedConstructor } from "./entity";
-export declare abstract class EntityBuilderBase<T extends AnyEntity> extends IdentifiableModelBuilder<T> {
-}
-export declare class EntityBuilder<T extends AnyEntity> extends EntityBuilderBase<T> {
+export declare class EntityBuilder<T extends AnyEntity> extends IdentifiableModelBuilder<T> {
     private entityClass;
     constructor(entityClass: EntityClassWithTypedConstructor<T>);
     build(): T;

package/dist/core/entity/entity.builder.js

@@ -1,16 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityBuilder = exports.EntityBuilderBase = void 0;
+exports.EntityBuilder = void 0;
 const identifiable_model_1 = require("../identifiable-model");
-class EntityBuilderBase extends identifiable_model_1.IdentifiableModelBuilder {
-}
-exports.EntityBuilderBase = EntityBuilderBase;
-class EntityBuilder extends EntityBuilderBase {
+class EntityBuilder extends identifiable_model_1.IdentifiableModelBuilder {
     constructor(entityClass) {
         super();
         this.entityClass = entityClass;
     }
     build() {
+        if (!this.props)
+            throw new Error("The props must be set before build");
         return new this.entityClass({ id: this.id }, this.props);
     }
 }

package/dist/core/entity/entity.d.ts

@@ -2,10 +2,12 @@ import { Class } from "type-fest";
 import { Props, PropsOf } from "../../base";
 import { ClassStatic } from "../../types";
 import { IdentifiableModel, IdentifiableModelMetadata } from "../identifiable-model";
+import { EntityBuilder } from ".";
 export interface EntityMetadata extends IdentifiableModelMetadata {
 }
 export declare class EntityBase<P extends Props> extends IdentifiableModel<P> {
-    constructor(metadata: EntityMetadata, props?: P);
+    static builder<T extends AnyEntity>(this: EntityClass<T>): EntityBuilder<T>;
+    constructor(metadata: EntityMetadata, props: P);
 }
 export type AnyEntity = EntityBase<Props>;
 export interface EntityClass<T extends AnyEntity = AnyEntity, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof EntityBase<PropsOf<T>>> {

package/dist/core/entity/entity.js

@@ -12,11 +12,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntityBase = void 0;
 const base_1 = require("../../base");
 const identifiable_model_1 = require("../identifiable-model");
+const _1 = require(".");
 let EntityBase = class EntityBase extends identifiable_model_1.IdentifiableModel {
+    static builder() {
+        return new _1.EntityBuilder(this);
+    }
     constructor(metadata, props) {
         super(metadata);
-        if (props)
-            this.initializeProps(props);
+        this.initializeProps(props);
     }
 };
 exports.EntityBase = EntityBase;

package/dist/core/enum/enum-builder.js

@@ -16,7 +16,7 @@ class EnumBuilder extends base_1.ModelBuilder {
             throw new Error("Cannot parse enum without value");
         const { enumClass } = this;
         let result;
-        enumClass.ownStaticValues().forEach((staticValue) => {
+        enumClass.ownModelStaticValues().forEach((staticValue) => {
             if (staticValue.value instanceof enumClass) {
                 const staticEnum = staticValue.value;
                 if (staticEnum.value === this._value && !result) {

package/dist/core/enum/enum.d.ts

@@ -1,12 +1,16 @@
 import { Class } from "type-fest";
 import { ModelBase } from "../../base";
 import { ClassStatic } from "../../types";
+import { EnumBuilder } from ".";
 export type EnumValue = string | number;
 export interface EnumProps {
     value: EnumValue;
 }
 export declare class EnumBase extends ModelBase<EnumProps> {
+    static builder<T extends AnyEnum>(this: EnumClass<T>): EnumBuilder<T>;
     static values(): EnumBase[];
+    static from<T extends AnyEnum>(this: EnumClass<T>, value: EnumValue): T;
+    static fromSafe<T extends AnyEnum>(this: EnumClass<T>, value: EnumValue): T | null;
     constructor(value: EnumValue);
     value: EnumValue;
     valueOf(): EnumValue;

package/dist/core/enum/enum.js

@@ -11,9 +11,19 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EnumBase = void 0;
 const base_1 = require("../../base");
+const _1 = require(".");
 let EnumBase = class EnumBase extends base_1.ModelBase {
+    static builder() {
+        return new _1.EnumBuilder(this);
+    }
     static values() {
-        return Array.from(this.ownStaticValues().values()).map((staticValue) => staticValue.value);
+        return Array.from(this.ownModelStaticValues().values()).map((staticValue) => staticValue.value);
+    }
+    static from(value) {
+        return this.builder().withValue(value).build();
+    }
+    static fromSafe(value) {
+        return this.builder().withValue(value).buildSafe();
     }
     constructor(value) {
         super();

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

@@ -4,10 +4,12 @@ import { Props, PropsOf } from "../../../base";
 import { ClassStatic } from "../../../types";
 import { MessageBase, MessageMetadata } from "../message-base";
 import { CommandModelDescriptor } from "./command-model-descriptor";
+import { CommandBuilder } from ".";
 export interface CommandMetadata extends MessageMetadata {
     commandType: CommandType;
 }
 export declare class CommandBase<P extends Props> extends MessageBase<P> {
+    static builder<T extends AnyCommand>(this: CommandClass<T>): CommandBuilder<T>;
     protected readonly _commandType: CommandType;
     static commandType(): string;
     constructor(metadata: Omit<CommandMetadata, "commandType">, props: P);

package/dist/core/message/command/command.js

@@ -3,7 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandBase = void 0;
 const meta_1 = require("../../../meta");
 const message_base_1 = require("../message-base");
+const _1 = require(".");
 class CommandBase extends message_base_1.MessageBase {
+    static builder() {
+        return new _1.CommandBuilder(this);
+    }
     static commandType() {
         return (0, meta_1.getCommandType)(this);
     }

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

@@ -5,6 +5,7 @@ import { ClassStatic } from "../../../types";
 import { Id } from "../../identifiable-model";
 import { MessageBase, MessageMetadata } from "../message-base";
 import { EventModelDescriptor } from "./event-model-descriptor";
+import { EventBuilder } from ".";
 export type EventSource = Readonly<{
     aggregateId: Id;
     aggregateVersion: number;
@@ -14,6 +15,7 @@ export interface EventMetadata extends MessageMetadata {
     source: EventSource;
 }
 export declare class EventBase<P extends Props> extends MessageBase<P> {
+    static builder<T extends AnyEvent>(this: EventClass<T>): EventBuilder<T>;
     private readonly _eventType;
     private readonly _source;
     constructor(metadata: Omit<EventMetadata, "eventType">, props: P);

package/dist/core/message/event/event.js

@@ -3,7 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventBase = void 0;
 const meta_1 = require("../../../meta");
 const message_base_1 = require("../message-base");
+const _1 = require(".");
 class EventBase extends message_base_1.MessageBase {
+    static builder() {
+        return new _1.EventBuilder(this);
+    }
     constructor(metadata, props) {
         super(metadata, props);
         this._eventType = (0, meta_1.getEventType)(this.constructor);

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

@@ -7,7 +7,6 @@ class EventPublisher {
     }
     async publish(event) {
         const subscribers = this.subscriberRegistry.getAllSubscribersForEvent(event.constructor);
-        // TODO: should convert to for await (subscriber be called sequently) ?
         await Promise.all(subscribers.map((subscriber) => subscriber.handleEvent(event)));
     }
 }

package/dist/package.json

@@ -1 +1 @@
-{"name":"ddd-node","version":"24.7.0","description":"Domain Driven Design base for NodeJs","type":"commonjs","main":"index.js","types":"index.d.ts","files":["dist"],"repository":{"type":"git","url":"https://github.com/nqd881/ddd-node"},"keywords":["ddd","ddd-node","ddd-base","ddd-ts","ddd-js"],"author":"Quoc Dai","license":"ISC","devDependencies":{"@types/chai":"^4.3.16","@types/lodash":"^4.14.200","@types/mocha":"^10.0.6","@types/uuid":"^9.0.6","chai":"^5.1.1","chai-deep-match":"^1.2.1","ddd-node":"file:dist","mocha":"^10.4.0","ts-node":"^10.9.1","tsconfig-paths":"^4.2.0","typescript":"^5.2.2"},"dependencies":{"lodash":"^4.17.21","reflect-metadata":"^0.1.13","tsc-alias":"^1.8.8","type-fest":"^4.20.1","uuid":"^9.0.1"}}
+{"name":"ddd-node","version":"26.0.0","description":"Domain Driven Design base for NodeJs","type":"commonjs","main":"index.js","types":"index.d.ts","files":["dist"],"repository":{"type":"git","url":"https://github.com/nqd881/ddd-node"},"keywords":["ddd","ddd-node","ddd-base","ddd-ts","ddd-js"],"author":"Quoc Dai","license":"ISC","devDependencies":{"@types/chai":"^4.3.16","@types/lodash":"^4.14.200","@types/mocha":"^10.0.6","@types/uuid":"^9.0.6","chai":"^5.1.1","chai-deep-match":"^1.2.1","ddd-node":"file:dist","mocha":"^10.4.0","ts-node":"^10.9.1","tsconfig-paths":"^4.2.0","typescript":"^5.2.2"},"dependencies":{"lodash":"^4.17.21","reflect-metadata":"^0.1.13","tsc-alias":"^1.8.8","type-fest":"^4.20.1","uuid":"^9.0.1"}}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ddd-node",
-  "version": "24.7.0",
+  "version": "26.0.0",
   "description": "Domain Driven Design base for NodeJs",
   "type": "module",
   "main": "dist/index.js",