ddd-node 34.0.0 → 34.2.0

package/base/decorators/model.d.ts

@@ -1,13 +1,23 @@
-import { ModelPropsValidator } from "../meta";
-import { AnyDomainModel, DomainModelClass } from "../model";
+import { Class } from "type-fest";
+import { ModelPropsValidatorWrapperInput } from "../meta";
+import { AnyDomainModel, DomainModelClass, InferredProps } from "../model";
 export type ModelOptions<T extends AnyDomainModel = AnyDomainModel> = {
     name?: string;
     version?: number;
     domain?: string;
-    propsValidator?: ModelPropsValidator<T>;
+    propsValidator?: ModelPropsValidatorWrapperInput<T>;
+    propsType?: Class<InferredProps<T>>;
     autoRegisterModel?: boolean;
 };
-export declare const DEFAULT_MODEL_OPTIONS: ModelOptions;
-export declare function Model<T extends DomainModelClass, I extends InstanceType<T> = InstanceType<T>>(options?: ModelOptions<I>): any;
-export declare function Model<T extends DomainModelClass, I extends InstanceType<T> = InstanceType<T>>(name: string, options?: ModelOptions<I>): any;
-export declare function Model<T extends DomainModelClass, I extends InstanceType<T> = InstanceType<T>>(name: string, version: number, options?: ModelOptions<I>): any;
+export declare const DEFAULT_MODEL_OPTIONS: Required<Pick<ModelOptions, "autoRegisterModel">>;
+/**
+ * @Model decorator — registers a DomainModel with metadata and domain context.
+ *
+ * Usage examples:
+ *  @Model()
+ *  @Model("User")
+ *  @Model("User", 2)
+ *  @Model("User", { domain: "Auth" })
+ *  @Model("User", 2, { domain: "Auth" })
+ */
+export declare function Model<T extends DomainModelClass, I extends InstanceType<T> = InstanceType<T>>(nameOrOptions?: string | ModelOptions<I>, versionOrOptions?: number | ModelOptions<I>, options?: ModelOptions<I>): (target: T) => void;

package/base/decorators/model.js

@@ -1,52 +1,76 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Model = exports.DEFAULT_MODEL_OPTIONS = void 0;
-const lodash_1 = __importDefault(require("lodash"));
+exports.DEFAULT_MODEL_OPTIONS = void 0;
+exports.Model = Model;
 const domain_1 = require("../domain");
 const meta_1 = require("../meta");
 exports.DEFAULT_MODEL_OPTIONS = {
     autoRegisterModel: true,
 };
-function Model(p1, p2, p3) {
-    const defaultModelOptions = lodash_1.default.clone(exports.DEFAULT_MODEL_OPTIONS);
-    let modelOptions = {};
-    if (p1 && !p2 && !p3) {
-        if (typeof p1 === "string")
-            modelOptions = { name: p1 };
-        else
-            modelOptions = p1;
-    }
-    else if (p1 && p2 && !p3) {
-        if (typeof p2 === "number")
-            modelOptions = { name: p1, version: p2 };
-        else
-            modelOptions = Object.assign({ name: p1 }, p2);
-    }
-    else if (p1 && p2 && p3) {
-        modelOptions = Object.assign({ name: p1, version: p2 }, p3);
-    }
-    modelOptions = lodash_1.default.merge(defaultModelOptions, modelOptions);
+/**
+ * @Model decorator — registers a DomainModel with metadata and domain context.
+ *
+ * Usage examples:
+ *  @Model()
+ *  @Model("User")
+ *  @Model("User", 2)
+ *  @Model("User", { domain: "Auth" })
+ *  @Model("User", 2, { domain: "Auth" })
+ */
+function Model(nameOrOptions, versionOrOptions, options) {
+    const modelOptions = normalizeModelOptions(nameOrOptions, versionOrOptions, options);
     return (target) => {
-        if (modelOptions === null || modelOptions === void 0 ? void 0 : modelOptions.name)
-            (0, meta_1.defineModelName)(target, modelOptions.name);
-        if (modelOptions === null || modelOptions === void 0 ? void 0 : modelOptions.version)
-            (0, meta_1.defineModelVersion)(target, modelOptions.version);
-        if (modelOptions === null || modelOptions === void 0 ? void 0 : modelOptions.domain)
-            (0, meta_1.defineModelDomain)(target, modelOptions.domain);
-        if (modelOptions === null || modelOptions === void 0 ? void 0 : modelOptions.autoRegisterModel) {
-            const domainName = (0, meta_1.getModelDomain)(target);
-            const domainManager = domain_1.DomainManager.instance();
-            if (!domainManager.hasDomain(domainName)) {
-                domainManager.addDomain(new domain_1.Domain(domainName));
-            }
-            const domain = domainManager.getDomain(domainName);
-            domain.modelRegistry.registerModel(target);
+        defineModel(target, modelOptions);
+        if (modelOptions.autoRegisterModel) {
+            registerModel(target);
         }
-        if (modelOptions === null || modelOptions === void 0 ? void 0 : modelOptions.propsValidator)
-            (0, meta_1.defineModelPropGettersValidator)(target, modelOptions.propsValidator);
     };
 }
-exports.Model = Model;
+/**
+ * Normalizes decorator overload arguments into a unified ModelOptions object.
+ */
+function normalizeModelOptions(p1, p2, p3) {
+    let options = {};
+    if (typeof p1 === "string" && typeof p2 === "number") {
+        options = { name: p1, version: p2, ...p3 };
+    }
+    else if (typeof p1 === "string" && typeof p2 === "object") {
+        options = { name: p1, ...p2 };
+    }
+    else if (typeof p1 === "string") {
+        options = { name: p1 };
+    }
+    else if (typeof p1 === "object") {
+        options = { ...p1 };
+    }
+    return { ...exports.DEFAULT_MODEL_OPTIONS, ...options };
+}
+/**
+ * Defines model metadata such as name, version, domain, propsType, and validator.
+ */
+function defineModel(target, options) {
+    if (options.name)
+        (0, meta_1.defineModelName)(target, options.name);
+    if (options.version)
+        (0, meta_1.defineModelVersion)(target, options.version);
+    if (options.domain)
+        (0, meta_1.defineModelDomain)(target, options.domain);
+    if (options.propsValidator) {
+        (0, meta_1.defineModelPropsValidator)(target, new meta_1.ModelPropsValidatorWrapper(options.propsValidator));
+    }
+    if (options.propsType) {
+        (0, meta_1.defineModelPropsType)(target, options.propsType);
+    }
+}
+/**
+ * Registers the model in its associated domain via DomainManager.
+ */
+function registerModel(target) {
+    const domainName = (0, meta_1.getModelDomain)(target);
+    const domainManager = domain_1.DomainManager.instance();
+    if (!domainManager.hasDomain(domainName)) {
+        domainManager.addDomain(new domain_1.Domain(domainName));
+    }
+    const domain = domainManager.getDomain(domainName);
+    domain.modelRegistry.registerModel(target);
+}

package/base/decorators/prop.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Prop = void 0;
+exports.Prop = Prop;
 const meta_1 = require("../meta");
 function Prop(p1, p2) {
     let propTargetKey, converter;
@@ -24,4 +24,3 @@ function Prop(p1, p2) {
         (0, meta_1.registerPropertyAccessor)(target, key, propTargetKey, converter);
     });
 }
-exports.Prop = Prop;

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

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

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.defineModelPropGettersValidator)(target, propertyDescriptor.value);
+    (0, __1.defineModelPropsValidator)(target, new __1.ModelPropsValidatorWrapper(propertyDescriptor.value.bind(target)));
 };
 exports.PropsValidator = PropsValidator;

package/base/meta/index.d.ts

@@ -6,3 +6,4 @@ export * from "./model-props-validator";
 export * from "./model-version";
 export * from "./model-domain";
 export * from "./model-mutable";
+export * from "./model-props-type";

package/base/meta/index.js

@@ -22,3 +22,4 @@ __exportStar(require("./model-props-validator"), exports);
 __exportStar(require("./model-version"), exports);
 __exportStar(require("./model-domain"), exports);
 __exportStar(require("./model-mutable"), exports);
+__exportStar(require("./model-props-type"), exports);

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

@@ -1,5 +1,4 @@
 import { DomainName } from "../domain";
 import { AnyDomainModel, DomainModelClass } from "../model";
-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.MODEL_DOMAIN = void 0;
+exports.getModelDomain = exports.defineModelDomain = void 0;
 const domain_1 = require("../domain");
-exports.MODEL_DOMAIN = Symbol.for("MODEL_DOMAIN");
+const MODEL_DOMAIN = Symbol.for("MODEL_DOMAIN");
 const defineModelDomain = (target, domainName) => {
-    Reflect.defineMetadata(exports.MODEL_DOMAIN, domainName, target);
+    Reflect.defineMetadata(MODEL_DOMAIN, domainName, target);
 };
 exports.defineModelDomain = defineModelDomain;
 const getModelDomain = (target) => {
-    if (!Reflect.hasOwnMetadata(exports.MODEL_DOMAIN, target))
+    if (!Reflect.hasOwnMetadata(MODEL_DOMAIN, target))
         (0, exports.defineModelDomain)(target, domain_1.DEFAULT_DOMAIN);
-    return Reflect.getOwnMetadata(exports.MODEL_DOMAIN, target);
+    return Reflect.getOwnMetadata(MODEL_DOMAIN, target);
 };
 exports.getModelDomain = getModelDomain;

package/base/meta/model-name.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getModelName = exports.defineModelName = exports.$ModelName = void 0;
+const MODEL_NAME = Symbol.for("MODEL_NAME");
 class $ModelName extends String {
     static validate(modelName) {
         if (modelName.trim().length === 0)
@@ -12,7 +13,6 @@ class $ModelName extends String {
     }
 }
 exports.$ModelName = $ModelName;
-const MODEL_NAME = Symbol.for("MODEL_NAME");
 const defineModelName = (target, modelName) => {
     Reflect.defineMetadata(MODEL_NAME, new $ModelName(modelName), target);
 };

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

@@ -3,7 +3,6 @@ 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;
@@ -24,22 +23,16 @@ const registerPropertyAccessor = (target, key, propTargetKey, 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);
+    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;
 };
 exports.getResolvedPropertyAccessors = getResolvedPropertyAccessors;

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

@@ -0,0 +1,4 @@
+import { Class } from "type-fest";
+import { AnyDomainModel, DomainModelClass, InferredProps } from "../model";
+export declare const defineModelPropsType: <T extends AnyDomainModel>(target: DomainModelClass<T>, propsType: Class<InferredProps<T>>) => void;
+export declare const getModelPropsType: <T extends AnyDomainModel>(target: DomainModelClass<T>) => Class<InferredProps<T>> | undefined;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModelPropsType = exports.defineModelPropsType = void 0;
+const MODEL_PROPS_TYPE = Symbol.for("MODEL_PROPS_TYPE");
+const defineModelPropsType = (target, propsType) => {
+    Reflect.defineMetadata(MODEL_PROPS_TYPE, propsType, target);
+};
+exports.defineModelPropsType = defineModelPropsType;
+const getModelPropsType = (target) => {
+    return Reflect.getMetadata(MODEL_PROPS_TYPE, target);
+};
+exports.getModelPropsType = getModelPropsType;

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

@@ -1,6 +1,16 @@
+import { Class } from "type-fest";
 import { AnyDomainModel, InferredProps } from "../model";
-export type ModelPropsValidator<T extends AnyDomainModel = AnyDomainModel> = (props: InferredProps<T>) => void;
-export declare const defineModelPropGettersValidator: <T extends AnyDomainModel>(target: object, validator: ModelPropsValidator<T>) => void;
+export interface ModelPropsValidator<T extends AnyDomainModel = AnyDomainModel> {
+    validate(props: InferredProps<T>): void;
+}
+export type ModelPropsValidateFn<T extends AnyDomainModel> = ModelPropsValidator<T>["validate"];
+export type ModelPropsValidatorBuilder<T extends AnyDomainModel> = () => ModelPropsValidator<T>;
+export type ModelPropsValidatorWrapperInput<T extends AnyDomainModel> = Class<ModelPropsValidator<T>, []> | ModelPropsValidator<T> | ModelPropsValidateFn<T> | ModelPropsValidatorBuilder<T>;
+export declare class ModelPropsValidatorWrapper<T extends AnyDomainModel> implements ModelPropsValidator<T> {
+    private input;
+    constructor(input: ModelPropsValidatorWrapperInput<T>);
+    validate(props: InferredProps<T>): void;
+}
+export declare const defineModelPropsValidator: <T extends AnyDomainModel>(target: object, validator: ModelPropsValidator<T>) => void;
 export declare const getOwnModelPropsValidator: <T extends AnyDomainModel>(target: object) => ModelPropsValidator<T> | undefined;
-export declare const MODEL_PROPS_VALIDATORS: unique symbol;
 export declare const getModelPropsValidators: (target: object) => ModelPropsValidator[];

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

@@ -3,31 +3,49 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getModelPropsValidators = exports.MODEL_PROPS_VALIDATORS = exports.getOwnModelPropsValidator = exports.defineModelPropGettersValidator = void 0;
+exports.getModelPropsValidators = exports.getOwnModelPropsValidator = exports.defineModelPropsValidator = exports.ModelPropsValidatorWrapper = void 0;
+const is_class_1 = __importDefault(require("is-class"));
 const lodash_1 = __importDefault(require("lodash"));
+class ModelPropsValidatorWrapper {
+    constructor(input) {
+        this.input = input;
+    }
+    validate(props) {
+        if ((0, is_class_1.default)(this.input)) {
+            const instance = new this.input();
+            return instance.validate(props);
+        }
+        if (typeof this.input === "function") {
+            const res = this.input(props);
+            const resIsValidator = res && typeof res === "object" && "validate" in res;
+            if (resIsValidator) {
+                return res.validate(props);
+            }
+            return res;
+        }
+        return this.input.validate(props);
+    }
+}
+exports.ModelPropsValidatorWrapper = ModelPropsValidatorWrapper;
 const OWN_MODEL_PROPS_VALIDATOR = Symbol.for("OWN_MODEL_PROPS_VALIDATOR");
-const defineModelPropGettersValidator = (target, validator) => {
+const defineModelPropsValidator = (target, validator) => {
     Reflect.defineMetadata(OWN_MODEL_PROPS_VALIDATOR, validator, target);
 };
-exports.defineModelPropGettersValidator = defineModelPropGettersValidator;
+exports.defineModelPropsValidator = defineModelPropsValidator;
 const getOwnModelPropsValidator = (target) => {
     return Reflect.getOwnMetadata(OWN_MODEL_PROPS_VALIDATOR, target);
 };
 exports.getOwnModelPropsValidator = getOwnModelPropsValidator;
-exports.MODEL_PROPS_VALIDATORS = Symbol.for("MODEL_PROPS_VALIDATORS");
 const getModelPropsValidators = (target) => {
-    if (!Reflect.hasOwnMetadata(exports.MODEL_PROPS_VALIDATORS, target)) {
-        let result = [];
-        let _target = target;
-        do {
-            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.MODEL_PROPS_VALIDATORS, result, target);
-    }
-    return Reflect.getOwnMetadata(exports.MODEL_PROPS_VALIDATORS, target);
+    let result = [];
+    let _target = target;
+    do {
+        const ownValidator = (0, exports.getOwnModelPropsValidator)(_target);
+        if (ownValidator)
+            result.push(ownValidator);
+        _target = Reflect.getPrototypeOf(_target);
+    } while (_target !== null);
+    result = lodash_1.default.uniq(result);
+    return result;
 };
 exports.getModelPropsValidators = getModelPropsValidators;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defineModelStaticValueProperty = exports.getModelStaticValue = exports.setModelStaticValue = exports.getOwnModelStaticValues = exports.ModelStaticValuesMap = exports.ModelStaticValue = void 0;
+const OWN_MODEL_STATIC_VALUES = Symbol.for("OWN_MODEL_STATIC_VALUES");
 class ModelStaticValue {
     constructor(value) {
         this._value = value;
@@ -13,7 +14,6 @@ class ModelStaticValue {
     }
 }
 exports.ModelStaticValue = ModelStaticValue;
-const OWN_MODEL_STATIC_VALUES = Symbol.for("OWN_MODEL_STATIC_VALUES");
 class ModelStaticValuesMap extends Map {
 }
 exports.ModelStaticValuesMap = ModelStaticValuesMap;
@@ -29,12 +29,11 @@ const setModelStaticValue = (target, key, value) => {
 };
 exports.setModelStaticValue = setModelStaticValue;
 const getModelStaticValue = (target, key) => {
-    var _a;
     let _target = target;
     do {
         const staticValues = (0, exports.getOwnModelStaticValues)(_target);
         if (staticValues.has(key))
-            return (_a = staticValues.get(key)) === null || _a === void 0 ? void 0 : _a.value;
+            return staticValues.get(key)?.value;
         _target = Reflect.getPrototypeOf(_target);
     } while (_target !== null);
     return undefined;

package/base/meta/model-version.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getModelVersion = exports.defineModelVersion = exports.$ModelVersion = void 0;
+const MODEL_VERSION = Symbol.for("MODEL_VERSION");
 class $ModelVersion extends Number {
     static validate(modelVersion) {
         if (modelVersion < 0 && Number.isInteger(modelVersion))
@@ -12,7 +13,6 @@ class $ModelVersion extends Number {
     }
 }
 exports.$ModelVersion = $ModelVersion;
-const MODEL_VERSION = Symbol.for("MODEL_VERSION");
 const defineModelVersion = (target, modelVersion) => {
     Reflect.defineMetadata(MODEL_VERSION, new $ModelVersion(modelVersion), target);
 };

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

@@ -1,4 +1,5 @@
-import { AnyDomainModel, DomainModelClass } from ".";
+import { Class } from "type-fest";
+import { AnyDomainModel, DomainModelClass, InferredProps } from ".";
 import { ModelId, ModelName, ModelPropertyAccessorMap, ModelPropsValidator, ModelStaticValuesMap, ModelVersion } from "../meta";
 export declare class ModelDescriptor<T extends AnyDomainModel = AnyDomainModel> {
     readonly modelClass: DomainModelClass<T>;
@@ -13,4 +14,5 @@ export declare class ModelDescriptor<T extends AnyDomainModel = AnyDomainModel>
     ownModelStaticValues(): ModelStaticValuesMap<T>;
     declaredPropertyAccessors(): ModelPropertyAccessorMap<T>;
     resolvedPropertyAccessors(): ModelPropertyAccessorMap<T>;
+    propsType(): Class<InferredProps<T>> | undefined;
 }

package/base/model/model-descriptor.js

@@ -10,8 +10,7 @@ class ModelDescriptor {
         return (0, meta_1.getModelDomain)(this.modelClass);
     }
     modelMutable() {
-        var _a;
-        return (_a = (0, meta_1.getModelMutable)(this.modelClass)) !== null && _a !== void 0 ? _a : false;
+        return (0, meta_1.getModelMutable)(this.modelClass) ?? false;
     }
     modelName() {
         return (0, meta_1.getModelName)(this.modelClass);
@@ -37,5 +36,8 @@ class ModelDescriptor {
     resolvedPropertyAccessors() {
         return (0, meta_1.getResolvedPropertyAccessors)(this.modelClass.prototype);
     }
+    propsType() {
+        return (0, meta_1.getModelPropsType)(this.modelClass);
+    }
 }
 exports.ModelDescriptor = ModelDescriptor;

package/base/model/model.js

@@ -30,8 +30,7 @@ class DomainModel {
             configurable: false,
             enumerable: true,
             get() {
-                var _a;
-                const value = (_a = this._props) === null || _a === void 0 ? void 0 : _a[propTargetKey];
+                const value = this._props?.[propTargetKey];
                 if (!propConverter)
                     return value;
                 return propConverter(value);
@@ -43,7 +42,9 @@ class DomainModel {
     }
     validateProps(props) {
         const modelPropsValidators = this.modelDescriptor().modelPropsValidators();
-        modelPropsValidators.forEach((propsValidator) => propsValidator.call(this.constructor, props));
+        modelPropsValidators.forEach((propsValidator) => propsValidator.validate(props)
+        // propsValidator.call(this.constructor, props)
+        );
     }
     validate() {
         this.validateProps(this._props);

package/common/index.d.ts

@@ -0,0 +1 @@
+export * from "./props-validator";

package/common/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./props-validator"), exports);

package/common/props-validator/index.d.ts

@@ -0,0 +1 @@
+export * from "./use-class-validator";

package/common/props-validator/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./use-class-validator"), exports);

package/common/props-validator/use-class-validator.d.ts

@@ -0,0 +1,17 @@
+import { ValidationError, ValidatorOptions } from "class-validator";
+import { Class } from "type-fest";
+import { AnyDomainModel, InferredProps, ModelPropsValidator } from "../../base";
+export declare function UseClassValidator<T extends AnyDomainModel>(validatorOptions?: ValidatorOptions): ClassDecorator;
+export declare function UseClassValidator<T extends AnyDomainModel>(propsType: Class<InferredProps<T>>, validatorOptions?: ValidatorOptions): ClassDecorator;
+export declare class ClassValidatorError extends Error {
+    readonly errors: ValidationError[];
+    static getErrorMessage(errors: ValidationError[]): string;
+    constructor(errors: ValidationError[]);
+}
+export declare class ClassValidatorModelPropsValidator<T extends AnyDomainModel> implements ModelPropsValidator<T> {
+    readonly propsClass: Class<InferredProps<T>>;
+    readonly validatorOptions?: ValidatorOptions | undefined;
+    constructor(propsClass: Class<InferredProps<T>>, validatorOptions?: ValidatorOptions | undefined);
+    transform(props: InferredProps<T>): InferredProps<T>;
+    validate(props: InferredProps<T>): void;
+}

package/common/props-validator/use-class-validator.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassValidatorModelPropsValidator = exports.ClassValidatorError = void 0;
+exports.UseClassValidator = UseClassValidator;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const base_1 = require("../../base");
+function UseClassValidator(p1, p2) {
+    return ((target) => {
+        const { propsType, validatorOptions } = resolveUseClassValidatorArgs(p1, p2, target);
+        const builder = () => new ClassValidatorModelPropsValidator(propsType, validatorOptions);
+        (0, base_1.defineModelPropsValidator)(target, new base_1.ModelPropsValidatorWrapper(builder));
+    });
+}
+/**
+ * Internal helper for resolving @UseClassValidator overloads.
+ */
+function resolveUseClassValidatorArgs(p1, p2, target) {
+    let propsType;
+    let validatorOptions;
+    if (typeof p1 === "function") {
+        propsType = p1;
+        validatorOptions = p2;
+    }
+    else {
+        validatorOptions = p1;
+    }
+    propsType ?? (propsType = (0, base_1.getModelPropsType)(target));
+    if (!propsType) {
+        throw new Error(`Props type must be provided or defined for ${target.name}`);
+    }
+    return { propsType, validatorOptions };
+}
+class ClassValidatorError extends Error {
+    static getErrorMessage(errors) {
+        return errors
+            .map((error) => Object.values(error.constraints || {}).join(", "))
+            .join("\n");
+    }
+    constructor(errors) {
+        super(ClassValidatorError.getErrorMessage(errors));
+        this.errors = errors;
+    }
+}
+exports.ClassValidatorError = ClassValidatorError;
+class ClassValidatorModelPropsValidator {
+    constructor(propsClass, validatorOptions) {
+        this.propsClass = propsClass;
+        this.validatorOptions = validatorOptions;
+    }
+    transform(props) {
+        return (0, class_transformer_1.plainToInstance)(this.propsClass, props);
+    }
+    validate(props) {
+        const transformedProps = this.transform(props);
+        const errors = (0, class_validator_1.validateSync)(transformedProps, this.validatorOptions);
+        if (errors.length) {
+            throw new ClassValidatorError(errors);
+        }
+    }
+}
+exports.ClassValidatorModelPropsValidator = ClassValidatorModelPropsValidator;

package/core/decorators/enum/is-enum.d.ts

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

package/core/decorators/enum/is-enum.js

@@ -4,7 +4,7 @@ exports.IsEnum = void 0;
 const base_1 = require("../../../base");
 const IsEnum = (value) => {
     return (target, key) => {
-        (0, base_1.Static)(() => new target(value !== null && value !== void 0 ? value : key))(target, key);
+        (0, base_1.Static)(() => new target(value ?? key))(target, key);
     };
 };
 exports.IsEnum = IsEnum;

package/core/model/aggregate/aggregate.js

@@ -21,7 +21,10 @@ let Aggregate = class Aggregate extends model_with_id_1.ModelWithId {
         this._version = metadata.version;
     }
     metadata() {
-        return Object.assign(Object.assign({}, super.metadata()), { version: this.version() });
+        return {
+            ...super.metadata(),
+            version: this.version(),
+        };
     }
     createEventSource() {
         return {
@@ -35,7 +38,11 @@ let Aggregate = class Aggregate extends model_with_id_1.ModelWithId {
 };
 exports.Aggregate = Aggregate;
 Aggregate.createMetadata = (metadata) => {
-    return Object.assign({ id: (0, uuid_1.v4)(), version: 0 }, metadata);
+    return {
+        id: (0, uuid_1.v4)(),
+        version: 0,
+        ...metadata,
+    };
 };
 exports.Aggregate = Aggregate = __decorate([
     (0, base_1.Mutable)(true),

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

@@ -17,7 +17,7 @@ export declare class ESAggregate<P extends Props> extends Aggregate<P> {
     private _pastEvents;
     private _events;
     constructor(metadata: AggregateMetadata, props?: P);
-    _constructor(): ESAggregateClass<this, any[]>;
+    _constructor(): ESAggregateClass<typeof this>;
     version(): number;
     pastEvents(): AnyEvent[];
     events(): AnyEvent[];
@@ -31,9 +31,9 @@ export declare class ESAggregate<P extends Props> extends Aggregate<P> {
     applyEvent<E extends AnyEvent>(event: E): void;
     applyEvents(events: AnyEvent[]): void;
     applyNewEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: InferredProps<E>): void;
-    getCommandHandler<C extends AnyCommand>(command: C): CommandHandler<C, AnyEvent | AnyEvent[]>;
+    getCommandHandler<C extends AnyCommand>(command: C): CommandHandler<C>;
     handleCommand<C extends AnyCommand>(command: C): AnyEvent[];
-    takeSnapshot(): Snapshot<this>;
+    takeSnapshot(): Snapshot<typeof this>;
     protected commitEvents(): void;
     publishEvents<R = any>(publisher: IAggregateEventPublisher<R>): R;
 }

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

@@ -10,7 +10,7 @@ export declare class StateAggregate<P extends Props> extends Aggregate<P> {
     static build<T extends AnyStateAggregate>(this: StateAggregateClassWithTypedConstructor<T>, props: InferredProps<T>, metadata?: Partial<StateAggregateMetadata>): T;
     private _events;
     constructor(metadata: StateAggregateMetadata, props: P);
-    _constructor(): StateAggregateClass<this, any[]>;
+    _constructor(): StateAggregateClass<typeof this>;
     props(): P;
     version(): number;
     events(): AnyEvent[];

package/core/model/entity/entity.d.ts

@@ -7,7 +7,7 @@ export interface EntityMetadata extends ModelWithIdMetadata {
 export declare class Entity<P extends Props> extends ModelWithId<P> {
     static build<T extends AnyEntity>(this: EntityClassWithTypedConstructor<T>, props: InferredProps<T>, id?: Id): T;
     constructor(metadata: EntityMetadata, props: P);
-    _constructor(): EntityClass<this, any[]>;
+    _constructor(): EntityClass<typeof this>;
 }
 export type AnyEntity = Entity<Props>;
 export interface EntityClass<T extends AnyEntity = AnyEntity, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof Entity<InferredProps<T>>> {

package/core/model/entity/entity.js

@@ -15,7 +15,7 @@ const base_1 = require("../../../base");
 const model_with_id_1 = require("../model-with-id");
 let Entity = class Entity extends model_with_id_1.ModelWithId {
     static build(props, id) {
-        return new this({ id: id !== null && id !== void 0 ? id : (0, uuid_1.v4)() }, props);
+        return new this({ id: id ?? (0, uuid_1.v4)() }, props);
     }
     constructor(metadata, props) {
         super(metadata);

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

@@ -11,7 +11,7 @@ export declare class Command<P extends Props> extends Message<P> {
     static commandType<T extends AnyCommand>(this: CommandClass<T>): string;
     protected readonly _commandType: CommandType;
     constructor(metadata: Omit<CommandMetadata, "commandType">, props: P);
-    _constructor(): CommandClass<this, any[]>;
+    _constructor(): CommandClass<typeof this>;
     metadata(): CommandMetadata;
     commandType(): string;
 }

package/core/model/message/command.js

@@ -18,7 +18,10 @@ class Command extends message_1.Message {
         return this.constructor;
     }
     metadata() {
-        return Object.assign(Object.assign({}, super.metadata()), { commandType: this._commandType });
+        return {
+            ...super.metadata(),
+            commandType: this._commandType,
+        };
     }
     commandType() {
         return this._commandType;

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

@@ -19,11 +19,11 @@ export declare class Event<P extends Props> extends Message<P> {
     private readonly _eventType;
     private readonly _source;
     constructor(metadata: Omit<EventMetadata, "eventType">, props: P);
-    _constructor(): EventClass<this, any[]>;
+    _constructor(): EventClass<typeof this>;
     metadata(): EventMetadata;
     eventType(): string;
     source(): Readonly<{
-        aggregateId: string;
+        aggregateId: Id;
         aggregateVersion: number;
     }>;
 }

package/core/model/message/event.js

@@ -5,7 +5,7 @@ const meta_1 = require("../../meta");
 const message_1 = require("./message");
 class Event extends message_1.Message {
     static build(props, metadata) {
-        return new this(Object.assign(Object.assign({}, this.createMetadata()), metadata), props);
+        return new this({ ...this.createMetadata(), ...metadata }, props);
     }
     static eventType() {
         return (0, meta_1.getEventType)(this);
@@ -19,7 +19,11 @@ class Event extends message_1.Message {
         return this.constructor;
     }
     metadata() {
-        return Object.assign(Object.assign({}, super.metadata()), { eventType: this._eventType, source: this._source });
+        return {
+            ...super.metadata(),
+            eventType: this._eventType,
+            source: this._source,
+        };
     }
     eventType() {
         return this._eventType;

package/core/model/message/message.d.ts

@@ -14,9 +14,9 @@ export type MessageMetadataInput = Partial<MessageMetadata>;
 export declare class Message<P extends Props> extends ModelWithId<P> {
     static createMetadata: (metadata?: MessageMetadataInput) => {
         timestamp: number;
-        causationId?: string | undefined;
+        causationId?: string;
         correlationIds: CorrelationIds;
-        id: string;
+        id: import("../model-with-id").Id;
     };
     static buildMessage<T extends AnyMessage>(this: MessageClassWithTypedConstructor<T>, props: InferredProps<T>, metadata?: MessageMetadataInput): T;
     private readonly _timestamp;

package/core/model/message/message.js

@@ -28,7 +28,12 @@ let Message = class Message extends model_with_id_1.ModelWithId {
         return super.props();
     }
     metadata() {
-        return Object.assign(Object.assign({}, super.metadata()), { timestamp: this._timestamp, correlationIds: this._correlationIds, causationId: this._causationId });
+        return {
+            ...super.metadata(),
+            timestamp: this._timestamp,
+            correlationIds: this._correlationIds,
+            causationId: this._causationId,
+        };
     }
     timestamp() {
         return this._timestamp;
@@ -52,7 +57,12 @@ let Message = class Message extends model_with_id_1.ModelWithId {
 };
 exports.Message = Message;
 Message.createMetadata = (metadata) => {
-    return Object.assign({ id: (0, uuid_1.v4)(), timestamp: Date.now(), correlationIds: {} }, metadata);
+    return {
+        id: (0, uuid_1.v4)(),
+        timestamp: Date.now(),
+        correlationIds: {},
+        ...metadata,
+    };
 };
 exports.Message = Message = __decorate([
     (0, base_1.Mutable)(false),

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

@@ -8,7 +8,10 @@ class ModelWithId extends base_1.DomainModel {
         this._id = metadata.id;
     }
     metadata() {
-        return Object.assign(Object.assign({}, super.metadata()), { id: this._id });
+        return {
+            ...super.metadata(),
+            id: this._id,
+        };
     }
     id() {
         return this._id;

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

@@ -3,7 +3,7 @@ import { DomainModel, InferredProps, Props, PropsBuilder } from "../../../base";
 import { ClassStatic } from "../../../types";
 export declare class ValueObject<P extends Props> extends DomainModel<P> {
     constructor(props?: P | PropsBuilder<ValueObject<P>>);
-    _constructor(): ValueObjectClass<this>;
+    _constructor(): ValueObjectClass<typeof this>;
     props(): P;
     equals<V extends AnyValueObject>(vo: V): boolean;
     with(props: Partial<P>): typeof this;

package/handling-event/event-dispatcher.js

@@ -1,24 +1,13 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventDispatcher = void 0;
 class EventDispatcher {
     constructor(subscriberRegistry) {
         this.subscriberRegistry = subscriberRegistry;
     }
-    dispatch(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const subscribers = this.subscriberRegistry.getAllSubscribersForEvent(event.constructor);
-            yield Promise.all(subscribers.map((subscriber) => subscriber.handleEvent(event)));
-        });
+    async dispatch(event) {
+        const subscribers = this.subscriberRegistry.getAllSubscribersForEvent(event.constructor);
+        await Promise.all(subscribers.map((subscriber) => subscriber.handleEvent(event)));
     }
 }
 exports.EventDispatcher = EventDispatcher;

package/handling-event/event-subscriber.js

@@ -4,8 +4,7 @@ exports.DynamicEventSubscriber = exports.EventSubscriber = void 0;
 const decorators_1 = require("./decorators");
 class EventSubscriber {
     subscribeToEvents() {
-        var _a;
-        const subscribedEvents = (_a = Reflect.getOwnMetadata(decorators_1.SubscribedEventsMetaKey, this.constructor)) !== null && _a !== void 0 ? _a : [];
+        const subscribedEvents = Reflect.getOwnMetadata(decorators_1.SubscribedEventsMetaKey, this.constructor) ?? [];
         return subscribedEvents;
     }
 }

package/index.d.ts

@@ -1,6 +1,6 @@
-/// <reference types="src/#declarations" />
 export * from "./base";
 export * from "./types";
 export * from "./core";
 export * from "./handling-event";
 export * from "./utils";
+export * from "./common";

package/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./types"), exports);
 __exportStar(require("./core"), exports);
 __exportStar(require("./handling-event"), exports);
 __exportStar(require("./utils"), exports);
+__exportStar(require("./common"), exports);

package/package.json

@@ -1 +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"}}
+{"name":"ddd-node","version":"34.2.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.9.3"},"dependencies":{"class-transformer":"^0.5.1","is-class":"^0.0.9","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"},"peerDependencies":{"class-validator":"^0.14.2"}}