ddd-node 35.1.0 → 36.0.1

package/base/decorators/model.js

@@ -5,7 +5,7 @@ exports.Model = Model;
 const domain_1 = require("../domain");
 const meta_1 = require("../meta");
 exports.DEFAULT_MODEL_OPTIONS = {
-    autoRegisterModel: true,
+    autoRegisterModel: true
 };
 /**
  * @Model decorator — registers a DomainModel with metadata and domain context.
@@ -66,7 +66,7 @@ function defineModel(target, options) {
  * Registers the model in its associated domain via DomainManager.
  */
 function registerModel(target) {
-    const domainName = (0, meta_1.getModelDomain)(target);
+    const domainName = (0, meta_1.resolveModelDomain)(target);
     const domainManager = domain_1.DomainManager.instance();
     if (!domainManager.hasDomain(domainName)) {
         domainManager.addDomain(new domain_1.Domain(domainName));

package/base/decorators/static.d.ts

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

package/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.setModelStaticValue)(target, key, builder);
-        (0, meta_1.defineModelStaticValueProperty)(target, key);
+        (0, meta_1.setStaticEntry)(target, key, builder);
+        (0, meta_1.defineStaticEntryProperty)(target, key);
     };
 };
 exports.Static = Static;

package/base/meta/index.d.ts

@@ -1,9 +1,9 @@
+export * from "./model-domain";
 export * from "./model-id";
+export * from "./model-mutable";
 export * from "./model-name";
 export * from "./model-property-accessor";
-export * from "./model-static-values";
+export * from "./model-props-type";
 export * from "./model-props-validator";
 export * from "./model-version";
-export * from "./model-domain";
-export * from "./model-mutable";
-export * from "./model-props-type";
+export * from "./static-entry";

package/base/meta/index.js

@@ -14,12 +14,12 @@ 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("./model-domain"), exports);
 __exportStar(require("./model-id"), exports);
+__exportStar(require("./model-mutable"), exports);
 __exportStar(require("./model-name"), exports);
 __exportStar(require("./model-property-accessor"), exports);
-__exportStar(require("./model-static-values"), exports);
+__exportStar(require("./model-props-type"), exports);
 __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);
+__exportStar(require("./static-entry"), exports);

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

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

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

@@ -12,5 +12,5 @@ export declare class $ModelId extends String {
     static makeValue(modelName: ModelName, modelVersion: ModelVersion): ModelId;
     constructor(modelName: ModelName, modelVersion: ModelVersion);
 }
-export declare const setModelId: <T extends AnyDomainModel>(target: DomainModelClass<T>, modelId: $ModelId) => void;
-export declare const getModelId: <T extends AnyDomainModel>(target: DomainModelClass<T>) => ModelId;
+export declare const defineModelId: <T extends AnyDomainModel>(target: DomainModelClass<T>, modelId: $ModelId) => void;
+export declare const resolveModelId: <T extends AnyDomainModel>(target: DomainModelClass<T>) => ModelId;

package/base/meta/model-id.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getModelId = exports.setModelId = exports.$ModelId = void 0;
+exports.resolveModelId = exports.defineModelId = 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");
+const MODEL_ID = Symbol("MODEL_ID");
 class $ModelId extends String {
     static fromValue(value) {
         if (!this.Format.test(value))
@@ -24,16 +24,16 @@ class $ModelId extends String {
 exports.$ModelId = $ModelId;
 $ModelId.Divider = "|";
 $ModelId.Format = new RegExp(/^.+\|[0-9]+$/);
-const setModelId = (target, modelId) => {
+const defineModelId = (target, modelId) => {
     Reflect.defineMetadata(MODEL_ID, modelId, target);
 };
-exports.setModelId = setModelId;
-const getModelId = (target) => {
+exports.defineModelId = defineModelId;
+const resolveModelId = (target) => {
     if (!Reflect.hasOwnMetadata(MODEL_ID, target)) {
-        const modelName = (0, model_name_1.getModelName)(target);
-        const modelVersion = (0, model_version_1.getModelVersion)(target);
-        (0, exports.setModelId)(target, new $ModelId(modelName, modelVersion));
+        const modelName = (0, model_name_1.resolveModelName)(target);
+        const modelVersion = (0, model_version_1.resolveModelVersion)(target);
+        (0, exports.defineModelId)(target, new $ModelId(modelName, modelVersion));
     }
     return Reflect.getOwnMetadata(MODEL_ID, target).valueOf();
 };
-exports.getModelId = getModelId;
+exports.resolveModelId = resolveModelId;

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

@@ -1,3 +1,3 @@
 import "reflect-metadata";
 export declare const defineModelMutable: (target: object, mutable: boolean) => void;
-export declare const getModelMutable: (target: object) => boolean | undefined;
+export declare const resolveModelMutable: (target: object) => boolean | undefined;

package/base/meta/model-mutable.js

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

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

@@ -5,4 +5,4 @@ export declare class $ModelName extends String {
     constructor(modelName: ModelName);
 }
 export declare const defineModelName: <T extends AnyDomainModel>(target: DomainModelClass<T>, modelName: ModelName) => void;
-export declare const getModelName: <T extends AnyDomainModel>(target: DomainModelClass<T>) => ModelName;
+export declare const resolveModelName: <T extends AnyDomainModel>(target: DomainModelClass<T>) => ModelName;

package/base/meta/model-name.js

@@ -1,7 +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");
+exports.resolveModelName = exports.defineModelName = exports.$ModelName = void 0;
+const MODEL_NAME = Symbol("MODEL_NAME");
 class $ModelName extends String {
     static validate(modelName) {
         if (modelName.trim().length === 0)
@@ -17,9 +17,9 @@ const defineModelName = (target, modelName) => {
     Reflect.defineMetadata(MODEL_NAME, new $ModelName(modelName), target);
 };
 exports.defineModelName = defineModelName;
-const getModelName = (target) => {
+const resolveModelName = (target) => {
     if (!Reflect.hasOwnMetadata(MODEL_NAME, target))
         (0, exports.defineModelName)(target, target.name);
     return Reflect.getOwnMetadata(MODEL_NAME, target).valueOf();
 };
-exports.getModelName = getModelName;
+exports.resolveModelName = resolveModelName;

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

@@ -6,6 +6,6 @@ export type PropertyAccessorMetadata<T extends AnyDomainModel, R> = {
 };
 export declare class ModelPropertyAccessorMap<T extends AnyDomainModel = AnyDomainModel> extends Map<PropertyKey, PropertyAccessorMetadata<T, any>> {
 }
-export declare const getDeclaredPropertyAccessors: <T extends AnyDomainModel = AnyDomainModel>(target: object) => ModelPropertyAccessorMap<T>;
+export declare const resolveOwnPropertyAccessors: <T extends AnyDomainModel = AnyDomainModel>(target: object) => ModelPropertyAccessorMap<T>;
 export declare const registerPropertyAccessor: <T extends AnyDomainModel = AnyDomainModel>(target: object, key: PropertyKey, propTargetKey: keyof InferredProps<T>, propConverter?: PropertyConverter) => void;
-export declare const getResolvedPropertyAccessors: <T extends AnyDomainModel = AnyDomainModel>(target: object) => ModelPropertyAccessorMap<T>;
+export declare const resolvePropertyAccessors: <T extends AnyDomainModel = AnyDomainModel>(target: object) => ModelPropertyAccessorMap<T>;

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

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

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

@@ -1,4 +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;
+export declare const resolveModelPropsType: <T extends AnyDomainModel>(target: DomainModelClass<T>) => Class<InferredProps<T>> | undefined;

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

@@ -1,12 +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");
+exports.resolveModelPropsType = exports.defineModelPropsType = void 0;
+const MODEL_PROPS_TYPE = Symbol("MODEL_PROPS_TYPE");
 const defineModelPropsType = (target, propsType) => {
     Reflect.defineMetadata(MODEL_PROPS_TYPE, propsType, target);
 };
 exports.defineModelPropsType = defineModelPropsType;
-const getModelPropsType = (target) => {
+const resolveModelPropsType = (target) => {
     return Reflect.getMetadata(MODEL_PROPS_TYPE, target);
 };
-exports.getModelPropsType = getModelPropsType;
+exports.resolveModelPropsType = resolveModelPropsType;

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

@@ -12,5 +12,5 @@ export declare class ModelPropsValidatorWrapper<T extends AnyDomainModel> implem
     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 getModelPropsValidators: (target: object) => ModelPropsValidator[];
+export declare const resolveOwnModelPropsValidator: <T extends AnyDomainModel>(target: object) => ModelPropsValidator<T> | undefined;
+export declare const resolveModelPropsValidators: (target: object) => ModelPropsValidator[];

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

@@ -3,10 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getModelPropsValidators = exports.getOwnModelPropsValidator = exports.defineModelPropsValidator = exports.ModelPropsValidatorWrapper = void 0;
+exports.resolveModelPropsValidators = exports.resolveOwnModelPropsValidator = 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 OWN_MODEL_PROPS_VALIDATOR = Symbol("OWN_MODEL_PROPS_VALIDATOR");
 class ModelPropsValidatorWrapper {
     constructor(input) {
         this.input = input;
@@ -32,15 +32,15 @@ const defineModelPropsValidator = (target, validator) => {
     Reflect.defineMetadata(OWN_MODEL_PROPS_VALIDATOR, validator, target);
 };
 exports.defineModelPropsValidator = defineModelPropsValidator;
-const getOwnModelPropsValidator = (target) => {
+const resolveOwnModelPropsValidator = (target) => {
     return Reflect.getOwnMetadata(OWN_MODEL_PROPS_VALIDATOR, target);
 };
-exports.getOwnModelPropsValidator = getOwnModelPropsValidator;
-const getModelPropsValidators = (target) => {
+exports.resolveOwnModelPropsValidator = resolveOwnModelPropsValidator;
+const resolveModelPropsValidators = (target) => {
     let result = [];
     let _target = target;
     do {
-        const ownValidator = (0, exports.getOwnModelPropsValidator)(_target);
+        const ownValidator = (0, exports.resolveOwnModelPropsValidator)(_target);
         if (ownValidator)
             result.push(ownValidator);
         _target = Reflect.getPrototypeOf(_target);
@@ -48,4 +48,4 @@ const getModelPropsValidators = (target) => {
     result = lodash_1.default.uniq(result);
     return result;
 };
-exports.getModelPropsValidators = getModelPropsValidators;
+exports.resolveModelPropsValidators = resolveModelPropsValidators;

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

@@ -5,4 +5,4 @@ export declare class $ModelVersion extends Number {
     constructor(modelVersion: ModelVersion);
 }
 export declare const defineModelVersion: <T extends AnyDomainModel>(target: DomainModelClass<T>, modelVersion: ModelVersion) => void;
-export declare const getModelVersion: <T extends AnyDomainModel>(target: DomainModelClass<T>) => ModelVersion;
+export declare const resolveModelVersion: <T extends AnyDomainModel>(target: DomainModelClass<T>) => ModelVersion;

package/base/meta/model-version.js

@@ -1,7 +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");
+exports.resolveModelVersion = exports.defineModelVersion = exports.$ModelVersion = void 0;
+const MODEL_VERSION = Symbol("MODEL_VERSION");
 class $ModelVersion extends Number {
     static validate(modelVersion) {
         if (modelVersion < 0 && Number.isInteger(modelVersion))
@@ -17,9 +17,9 @@ const defineModelVersion = (target, modelVersion) => {
     Reflect.defineMetadata(MODEL_VERSION, new $ModelVersion(modelVersion), target);
 };
 exports.defineModelVersion = defineModelVersion;
-const getModelVersion = (target) => {
+const resolveModelVersion = (target) => {
     if (!Reflect.hasOwnMetadata(MODEL_VERSION, target))
         (0, exports.defineModelVersion)(target, 0);
     return Reflect.getOwnMetadata(MODEL_VERSION, target).valueOf();
 };
-exports.getModelVersion = getModelVersion;
+exports.resolveModelVersion = resolveModelVersion;

package/base/meta/static-entry.d.ts

@@ -0,0 +1,13 @@
+import { AnyDomainModel, DomainModelClass } from "../model";
+export type StaticEntryBuilder<T extends AnyDomainModel = AnyDomainModel> = () => T;
+export declare class StaticEntry<T extends AnyDomainModel = AnyDomainModel> {
+    private _value;
+    constructor(value: T | StaticEntryBuilder<T>);
+    get value(): T;
+}
+export declare class StaticEntryMap<T extends AnyDomainModel = AnyDomainModel> extends Map<PropertyKey, StaticEntry<T>> {
+}
+export declare const resolveOwnStaticEntries: <T extends AnyDomainModel>(target: object) => StaticEntryMap<T>;
+export declare const setStaticEntry: <T extends AnyDomainModel>(target: object, key: PropertyKey, value: T | StaticEntryBuilder<T>) => void;
+export declare const resolveStaticEntryValue: (target: object, key: PropertyKey) => AnyDomainModel | undefined;
+export declare const defineStaticEntryProperty: (target: DomainModelClass, key: PropertyKey) => void;

package/base/meta/static-entry.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineStaticEntryProperty = exports.resolveStaticEntryValue = exports.setStaticEntry = exports.resolveOwnStaticEntries = exports.StaticEntryMap = exports.StaticEntry = void 0;
+const OWN_STATIC_ENTRIES = Symbol("OWN_STATIC_ENTRIES");
+class StaticEntry {
+    constructor(value) {
+        this._value = value;
+    }
+    get value() {
+        if (typeof this._value === "function") {
+            this._value = this._value();
+        }
+        return this._value;
+    }
+}
+exports.StaticEntry = StaticEntry;
+class StaticEntryMap extends Map {
+}
+exports.StaticEntryMap = StaticEntryMap;
+const resolveOwnStaticEntries = (target) => {
+    if (!Reflect.hasOwnMetadata(OWN_STATIC_ENTRIES, target))
+        Reflect.defineMetadata(OWN_STATIC_ENTRIES, new StaticEntryMap(), target);
+    return Reflect.getOwnMetadata(OWN_STATIC_ENTRIES, target);
+};
+exports.resolveOwnStaticEntries = resolveOwnStaticEntries;
+const setStaticEntry = (target, key, value) => {
+    const staticEntries = (0, exports.resolveOwnStaticEntries)(target);
+    staticEntries.set(key, new StaticEntry(value));
+};
+exports.setStaticEntry = setStaticEntry;
+const resolveStaticEntryValue = (target, key) => {
+    let _target = target;
+    do {
+        const staticEntries = (0, exports.resolveOwnStaticEntries)(_target);
+        if (staticEntries.has(key))
+            return staticEntries.get(key)?.value;
+        _target = Reflect.getPrototypeOf(_target);
+    } while (_target !== null);
+    return undefined;
+};
+exports.resolveStaticEntryValue = resolveStaticEntryValue;
+const defineStaticEntryProperty = (target, key) => {
+    Object.defineProperty(target, key, {
+        configurable: false,
+        enumerable: true,
+        get() {
+            return (0, exports.resolveStaticEntryValue)(target, key);
+        },
+        set() {
+            throw new Error("Static value is readonly");
+        }
+    });
+};
+exports.defineStaticEntryProperty = defineStaticEntryProperty;

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

@@ -1,6 +1,6 @@
 import { Class } from "type-fest";
 import { AnyDomainModel, DomainModelClass, InferredProps } from ".";
-import { ModelId, ModelName, ModelPropertyAccessorMap, ModelPropsValidator, ModelStaticValuesMap, ModelVersion } from "../meta";
+import { ModelId, ModelName, ModelPropertyAccessorMap, ModelPropsValidator, ModelVersion, StaticEntryMap } from "../meta";
 export declare class ModelDescriptor<T extends AnyDomainModel = AnyDomainModel> {
     readonly modelClass: DomainModelClass<T>;
     constructor(modelClass: DomainModelClass<T>);
@@ -11,8 +11,8 @@ export declare class ModelDescriptor<T extends AnyDomainModel = AnyDomainModel>
     get modelId(): ModelId;
     get ownModelPropsValidator(): ModelPropsValidator<T> | undefined;
     get modelPropsValidators(): ModelPropsValidator[];
-    get ownModelStaticValues(): ModelStaticValuesMap<T>;
-    get declaredPropertyAccessors(): ModelPropertyAccessorMap<T>;
-    get resolvedPropertyAccessors(): ModelPropertyAccessorMap<T>;
+    get ownStaticEntries(): StaticEntryMap<T>;
+    get ownPropertyAccessors(): ModelPropertyAccessorMap<T>;
+    get propertyAccessors(): ModelPropertyAccessorMap<T>;
     get propsType(): Class<InferredProps<T>> | undefined;
 }

package/base/model/model-descriptor.js

@@ -7,37 +7,37 @@ class ModelDescriptor {
         this.modelClass = modelClass;
     }
     get modelDomain() {
-        return (0, meta_1.getModelDomain)(this.modelClass);
+        return (0, meta_1.resolveModelDomain)(this.modelClass);
     }
     get modelMutable() {
-        return (0, meta_1.getModelMutable)(this.modelClass) ?? false;
+        return (0, meta_1.resolveModelMutable)(this.modelClass) ?? false;
     }
     get modelName() {
-        return (0, meta_1.getModelName)(this.modelClass);
+        return (0, meta_1.resolveModelName)(this.modelClass);
     }
     get modelVersion() {
-        return (0, meta_1.getModelVersion)(this.modelClass);
+        return (0, meta_1.resolveModelVersion)(this.modelClass);
     }
     get modelId() {
-        return (0, meta_1.getModelId)(this.modelClass);
+        return (0, meta_1.resolveModelId)(this.modelClass);
     }
     get ownModelPropsValidator() {
-        return (0, meta_1.getOwnModelPropsValidator)(this.modelClass);
+        return (0, meta_1.resolveOwnModelPropsValidator)(this.modelClass);
     }
     get modelPropsValidators() {
-        return (0, meta_1.getModelPropsValidators)(this.modelClass);
+        return (0, meta_1.resolveModelPropsValidators)(this.modelClass);
     }
-    get ownModelStaticValues() {
-        return (0, meta_1.getOwnModelStaticValues)(this.modelClass);
+    get ownStaticEntries() {
+        return (0, meta_1.resolveOwnStaticEntries)(this.modelClass);
     }
-    get declaredPropertyAccessors() {
-        return (0, meta_1.getDeclaredPropertyAccessors)(this.modelClass.prototype);
+    get ownPropertyAccessors() {
+        return (0, meta_1.resolveOwnPropertyAccessors)(this.modelClass.prototype);
     }
-    get resolvedPropertyAccessors() {
-        return (0, meta_1.getResolvedPropertyAccessors)(this.modelClass.prototype);
+    get propertyAccessors() {
+        return (0, meta_1.resolvePropertyAccessors)(this.modelClass.prototype);
     }
     get propsType() {
-        return (0, meta_1.getModelPropsType)(this.modelClass);
+        return (0, meta_1.resolveModelPropsType)(this.modelClass);
     }
 }
 exports.ModelDescriptor = ModelDescriptor;

package/base/model/model.js

@@ -19,7 +19,7 @@ class DomainModel {
         this.definePropertyAccessors();
     }
     definePropertyAccessors() {
-        this.modelDescriptor.resolvedPropertyAccessors.forEach(({ targetKey, converter }, key) => {
+        this.modelDescriptor.propertyAccessors.forEach(({ targetKey, converter }, key) => {
             this.definePropAccessor(key, targetKey, converter);
         });
     }
@@ -32,7 +32,7 @@ class DomainModel {
                 if (!propConverter)
                     return value;
                 return propConverter(value);
-            },
+            }
         });
     }
     get modelDescriptor() {
@@ -74,7 +74,7 @@ class DomainModel {
                     let result = Reflect.set(target, propKey, value);
                     this.validate();
                     return result;
-                },
+                }
             });
         }
         this.validate();

package/base/model-registry.d.ts

@@ -8,7 +8,7 @@ export declare class ModelStore<T extends AnyDomainModel = AnyDomainModel> exten
 }
 export declare class ModelRegistry {
     private store;
-    getModelVersions<T extends AnyDomainModel = AnyDomainModel>(modelName: ModelName): ModelVersions<T>;
+    resolveModelVersions<T extends AnyDomainModel = AnyDomainModel>(modelName: ModelName): ModelVersions<T>;
     private resolveModelId;
     getModel<T extends AnyDomainModel = AnyDomainModel>(modelName: ModelName, modelVersion?: ModelVersion): DomainModelClass<T> | undefined;
     getModelByModelId<T extends AnyDomainModel = AnyDomainModel>(modelId: ModelId): DomainModelClass<T> | undefined;

package/base/model-registry.js

@@ -16,7 +16,7 @@ class ModelRegistry {
     constructor() {
         this.store = new ModelStore();
     }
-    getModelVersions(modelName) {
+    resolveModelVersions(modelName) {
         const current = () => this.store.get(modelName);
         if (!current())
             this.store.set(modelName, new ModelVersions(modelName));
@@ -29,7 +29,7 @@ class ModelRegistry {
         return meta_1.$ModelId.fromValue(p1.modelDescriptor().modelId);
     }
     getModel(modelName, modelVersion = 0) {
-        const versions = this.getModelVersions(modelName);
+        const versions = this.resolveModelVersions(modelName);
         return versions.get(modelVersion);
     }
     getModelByModelId(modelId) {
@@ -49,7 +49,7 @@ class ModelRegistry {
         const modelVersion = modelClass.modelDescriptor().modelVersion;
         if (this.hasRegisteredModel(modelName, modelVersion))
             throw new Error(`Cannot register: Model ${modelName} with version ${modelVersion} is already registered.`);
-        const versions = this.getModelVersions(modelName);
+        const versions = this.resolveModelVersions(modelName);
         versions.set(modelVersion, modelClass);
         return this;
     }
@@ -57,7 +57,7 @@ class ModelRegistry {
         const { modelName, modelVersion } = this.resolveModelId(p1, p2);
         if (!this.hasRegisteredModel(modelName, modelVersion))
             return;
-        const versions = this.getModelVersions(modelName);
+        const versions = this.resolveModelVersions(modelName);
         versions.delete(modelVersion);
     }
     clearModelVersions(modelName) {

package/core/decorators/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./es-aggregate";
-export * from "./message";
-export * from "./enum";
+export * from "./is-enum";
+export * from "./is-event";
+export * from "./when";

package/core/decorators/index.js

@@ -14,6 +14,6 @@ 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("./es-aggregate"), exports);
-__exportStar(require("./message"), exports);
-__exportStar(require("./enum"), exports);
+__exportStar(require("./is-enum"), exports);
+__exportStar(require("./is-event"), exports);
+__exportStar(require("./when"), exports);

package/core/decorators/{enum/is-enum.d.ts → is-enum.d.ts}

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

package/core/decorators/{enum/is-enum.js → is-enum.js}

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsEnum = void 0;
-const base_1 = require("../../../base");
-const core_1 = require("../../../core");
+const base_1 = require("../../base");
+const __1 = require("..");
 const IsEnum = (value) => {
     return (target, key) => {
-        (0, core_1.markEnumProperty)(target, key);
+        (0, __1.markEnumProperty)(target, key);
         const enumBuilder = () => new target(value ?? key);
         (0, base_1.Static)(enumBuilder)(target, key);
     };

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

@@ -0,0 +1,4 @@
+import { ModelOptions } from "../../base";
+import { EventType } from "../meta";
+import { AnyEvent, EventClass } from "../model";
+export declare const IsEvent: (eventType: EventType, modelOptions?: ModelOptions) => <T extends AnyEvent>(target: EventClass<T>) => void;