ddd-node 34.1.0 → 35.0.0

package/base/decorators/model.d.ts

@@ -1,13 +1,23 @@
-import { ModelPropsValidateFn, 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> | ModelPropsValidateFn<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,58 +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);
-        }
-        if (modelOptions === null || modelOptions === void 0 ? void 0 : modelOptions.propsValidator) {
-            if (typeof modelOptions.propsValidator === "function")
-                (0, meta_1.defineModelPropGettersValidator)(target, {
-                    validate: modelOptions.propsValidator,
-                });
-            else
-                (0, meta_1.defineModelPropGettersValidator)(target, modelOptions.propsValidator);
+        defineModel(target, modelOptions);
+        if (modelOptions.autoRegisterModel) {
+            registerModel(target);
         }
     };
 }
-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.js

@@ -3,8 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PropsValidator = void 0;
 const __1 = require("..");
 const PropsValidator = (target, key, propertyDescriptor) => {
-    (0, __1.defineModelPropGettersValidator)(target, {
-        validate: propertyDescriptor.value.bind(target),
-    });
+    (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-id.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getModelId = exports.setModelId = exports.$ModelId = void 0;
 const model_name_1 = require("./model-name");
 const model_version_1 = require("./model-version");
+const MODEL_ID = Symbol.for("MODEL_ID");
 class $ModelId extends String {
     static fromValue(value) {
         if (!this.Format.test(value))
@@ -23,7 +24,6 @@ class $ModelId extends String {
 exports.$ModelId = $ModelId;
 $ModelId.Divider = "|";
 $ModelId.Format = new RegExp(/^.+\|[0-9]+$/);
-const MODEL_ID = Symbol.for("MODEL_ID");
 const setModelId = (target, modelId) => {
     Reflect.defineMetadata(MODEL_ID, modelId, target);
 };

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,9 +1,16 @@
+import { Class } from "type-fest";
 import { AnyDomainModel, InferredProps } from "../model";
 export interface ModelPropsValidator<T extends AnyDomainModel = AnyDomainModel> {
     validate(props: InferredProps<T>): void;
 }
 export type ModelPropsValidateFn<T extends AnyDomainModel> = ModelPropsValidator<T>["validate"];
-export declare const defineModelPropGettersValidator: <T extends AnyDomainModel>(target: object, validator: ModelPropsValidator<T>) => void;
+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"));
 const OWN_MODEL_PROPS_VALIDATOR = Symbol.for("OWN_MODEL_PROPS_VALIDATOR");
-const defineModelPropGettersValidator = (target, validator) => {
+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 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,16 +1,18 @@
-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>;
     constructor(modelClass: DomainModelClass<T>);
-    modelDomain(): string;
-    modelMutable(): boolean;
-    modelName(): ModelName;
-    modelVersion(): ModelVersion;
-    modelId(): ModelId;
-    ownModelPropsValidator(): ModelPropsValidator<T> | undefined;
-    modelPropsValidators(): ModelPropsValidator[];
-    ownModelStaticValues(): ModelStaticValuesMap<T>;
-    declaredPropertyAccessors(): ModelPropertyAccessorMap<T>;
-    resolvedPropertyAccessors(): ModelPropertyAccessorMap<T>;
+    get modelDomain(): string;
+    get modelMutable(): boolean;
+    get modelName(): ModelName;
+    get modelVersion(): ModelVersion;
+    get modelId(): ModelId;
+    get ownModelPropsValidator(): ModelPropsValidator<T> | undefined;
+    get modelPropsValidators(): ModelPropsValidator[];
+    get ownModelStaticValues(): ModelStaticValuesMap<T>;
+    get declaredPropertyAccessors(): ModelPropertyAccessorMap<T>;
+    get resolvedPropertyAccessors(): ModelPropertyAccessorMap<T>;
+    get propsType(): Class<InferredProps<T>> | undefined;
 }

package/base/model/model-descriptor.js

@@ -6,36 +6,38 @@ class ModelDescriptor {
     constructor(modelClass) {
         this.modelClass = modelClass;
     }
-    modelDomain() {
+    get modelDomain() {
         return (0, meta_1.getModelDomain)(this.modelClass);
     }
-    modelMutable() {
-        var _a;
-        return (_a = (0, meta_1.getModelMutable)(this.modelClass)) !== null && _a !== void 0 ? _a : false;
+    get modelMutable() {
+        return (0, meta_1.getModelMutable)(this.modelClass) ?? false;
     }
-    modelName() {
+    get modelName() {
         return (0, meta_1.getModelName)(this.modelClass);
     }
-    modelVersion() {
+    get modelVersion() {
         return (0, meta_1.getModelVersion)(this.modelClass);
     }
-    modelId() {
+    get modelId() {
         return (0, meta_1.getModelId)(this.modelClass);
     }
-    ownModelPropsValidator() {
+    get ownModelPropsValidator() {
         return (0, meta_1.getOwnModelPropsValidator)(this.modelClass);
     }
-    modelPropsValidators() {
+    get modelPropsValidators() {
         return (0, meta_1.getModelPropsValidators)(this.modelClass);
     }
-    ownModelStaticValues() {
+    get ownModelStaticValues() {
         return (0, meta_1.getOwnModelStaticValues)(this.modelClass);
     }
-    declaredPropertyAccessors() {
+    get declaredPropertyAccessors() {
         return (0, meta_1.getDeclaredPropertyAccessors)(this.modelClass.prototype);
     }
-    resolvedPropertyAccessors() {
+    get resolvedPropertyAccessors() {
         return (0, meta_1.getResolvedPropertyAccessors)(this.modelClass.prototype);
     }
+    get propsType() {
+        return (0, meta_1.getModelPropsType)(this.modelClass);
+    }
 }
 exports.ModelDescriptor = ModelDescriptor;

package/base/model/model.d.ts

@@ -1,7 +1,7 @@
 import { AbstractClass, Class } from "type-fest";
+import { PropertyConverter } from "..";
 import { ClassStatic } from "../../types";
 import { ModelDescriptor } from "./model-descriptor";
-import { PropertyConverter } from "..";
 export interface Props {
     [key: PropertyKey]: any;
 }
@@ -17,18 +17,18 @@ export declare class DomainModel<P extends Props> {
     constructor();
     definePropertyAccessors(): void;
     protected definePropAccessor<K extends keyof P>(key: keyof this, propTargetKey: K, propConverter?: PropertyConverter): void;
-    modelDescriptor(): ModelDescriptor<AnyDomainModel>;
+    get modelDescriptor(): ModelDescriptor<AnyDomainModel>;
     validateProps(props: P): void;
     validate(): void;
-    isPropsEmpty(): this is InitializedDomainModel<P>;
+    isPropsEmpty(): boolean;
+    isPropsInitialized<T extends AnyDomainModel>(this: T): this is InitializedDomainModel<typeof this>;
     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 InitializedDomainModel<T extends AnyDomainModel> = T & {
+    props(): InferredProps<T>;
+};
 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>>>;
 export type AbstractDomainModelClass<T extends AnyDomainModel = AnyDomainModel> = AbstractClass<T> & ClassStatic<typeof DomainModel<InferredProps<T>>>;

package/base/model/model.js

@@ -19,9 +19,7 @@ class DomainModel {
         this.definePropertyAccessors();
     }
     definePropertyAccessors() {
-        this.modelDescriptor()
-            .resolvedPropertyAccessors()
-            .forEach(({ targetKey, converter }, key) => {
+        this.modelDescriptor.resolvedPropertyAccessors.forEach(({ targetKey, converter }, key) => {
             this.definePropAccessor(key, targetKey, converter);
         });
     }
@@ -30,22 +28,19 @@ 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);
             },
         });
     }
-    modelDescriptor() {
+    get modelDescriptor() {
         return new model_descriptor_1.ModelDescriptor(this.constructor);
     }
     validateProps(props) {
-        const modelPropsValidators = this.modelDescriptor().modelPropsValidators();
-        modelPropsValidators.forEach((propsValidator) => propsValidator.validate(props)
-        // propsValidator.call(this.constructor, props)
-        );
+        const modelPropsValidators = this.modelDescriptor.modelPropsValidators;
+        modelPropsValidators.forEach((propsValidator) => propsValidator.validate(props));
     }
     validate() {
         this.validateProps(this._props);
@@ -53,23 +48,23 @@ class DomainModel {
     isPropsEmpty() {
         return this._props === DomainModel.EMPTY_PROPS;
     }
+    isPropsInitialized() {
+        return !this.isPropsEmpty();
+    }
     props() {
         if (this.isPropsEmpty())
             return null;
         return lodash_1.default.cloneDeep(this._props);
     }
-    metadata() {
-        return {};
-    }
     initializeProps(propsOrBuilder) {
-        if (!this.isPropsEmpty())
+        if (this.isPropsInitialized())
             throw new errors_1.PropsInitializedError();
         let props;
         if (typeof propsOrBuilder === "function")
             props = propsOrBuilder.call(this);
         else
             props = propsOrBuilder;
-        if (!this.modelDescriptor().modelMutable) {
+        if (!this.modelDescriptor.modelMutable) {
             this._props = props;
             Object.freeze(this._props);
         }

package/base/model-registry.d.ts

@@ -1,5 +1,5 @@
-import { AnyDomainModel, DomainModelClass } from "./model";
 import { ModelId, ModelName, ModelVersion } from "./meta";
+import { AnyDomainModel, DomainModelClass } from "./model";
 export declare class ModelVersions<T extends AnyDomainModel = AnyDomainModel> extends Map<ModelVersion, DomainModelClass<T>> {
     readonly modelName: ModelName;
     constructor(modelName: ModelName);