ddd-node 17.3.0 → 20.0.0

package/dist/{core/model → model/core}/model.js

@@ -3,50 +3,56 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModelBase = void 0;
+exports.ModelBase = exports.ModelMetadata = void 0;
 const lodash_1 = __importDefault(require("lodash"));
-const meta_1 = require("../../meta");
+const meta_1 = require("../meta");
 const errors_1 = require("./errors");
-class ModelBase {
-    static isModel(model) {
-        return model instanceof ModelBase;
+class ModelMetadata {
+    constructor(modelClass) {
+        this.modelClass = modelClass;
     }
-    static mutable() {
-        return false;
+    get modelMutable() {
+        return (0, meta_1.getModelMutable)(this.modelClass) ?? false;
     }
-    static modelName() {
-        return (0, meta_1.getModelName)(this);
+    get modelName() {
+        return (0, meta_1.getModelName)(this.modelClass);
     }
-    static modelVersion() {
-        return (0, meta_1.getModelVersion)(this);
+    get modelVersion() {
+        return (0, meta_1.getModelVersion)(this.modelClass);
     }
-    static modelId() {
-        return (0, meta_1.getModelId)(this);
+    get modelId() {
+        return (0, meta_1.getModelId)(this.modelClass);
     }
-    static hasModelId(modelId) {
-        return this.modelId() === modelId;
+    get ownPropsValidator() {
+        return (0, meta_1.getOwnPropsValidator)(this.modelClass);
     }
-    static ownPropsValidator() {
-        return (0, meta_1.getOwnPropsValidator)(this);
+    get propsValidators() {
+        return (0, meta_1.getPropsValidators)(this.modelClass);
     }
-    static propsValidators() {
-        return (0, meta_1.getPropsValidators)(this);
+    get ownStaticValues() {
+        return (0, meta_1.getOwnStaticValues)(this.modelClass);
     }
-    static ownStaticValues() {
-        return (0, meta_1.getOwnStaticValues)(this);
+    get ownPropsMap() {
+        return (0, meta_1.getOwnPropsMap)(this.modelClass.prototype);
     }
-    static ownPropsMap() {
-        return (0, meta_1.getOwnPropsMap)(this.prototype);
+    get propsMap() {
+        return (0, meta_1.getPropsMap)(this.modelClass.prototype);
     }
-    static propsMap() {
-        return (0, meta_1.getPropsMap)(this.prototype);
+}
+exports.ModelMetadata = ModelMetadata;
+class ModelBase {
+    static isModel(model) {
+        return model instanceof ModelBase;
+    }
+    static modelMetadata() {
+        return new ModelMetadata(this);
     }
     constructor() {
         this._props = ModelBase.EMPTY_PROPS;
         this.redefineModel();
     }
     redefineModel() {
-        this.propsMap().forEach((propTargetKey, key) => {
+        this.modelMetadata().propsMap.forEach((propTargetKey, key) => {
             this.redefineProp(key, propTargetKey);
         });
     }
@@ -60,38 +66,11 @@ class ModelBase {
             },
         });
     }
-    get _modelClass() {
-        return this.constructor;
-    }
-    isMutable() {
-        return this._modelClass.mutable();
-    }
-    modelName() {
-        return this._modelClass.modelName();
-    }
-    modelVersion() {
-        return this._modelClass.modelVersion();
-    }
-    modelId() {
-        return this._modelClass.modelId();
-    }
-    hasModelId(modelId) {
-        return this._modelClass.hasModelId(modelId);
-    }
-    ownPropsValidator() {
-        return this._modelClass.ownPropsValidator();
-    }
-    propsValidators() {
-        return this._modelClass.propsValidators();
-    }
-    ownPropsMap() {
-        return this._modelClass.ownPropsMap();
-    }
-    propsMap() {
-        return (0, meta_1.getPropsMap)(Reflect.getPrototypeOf(this));
+    modelMetadata() {
+        return this.constructor.modelMetadata();
     }
     validateProps(props) {
-        const propsValidators = this.propsValidators();
+        const propsValidators = this.modelMetadata().propsValidators;
         propsValidators.forEach((propsValidator) => propsValidator(props));
     }
     validate() {
@@ -113,7 +92,7 @@ class ModelBase {
     initializeProps(props) {
         if (!this.propsIsEmpty())
             throw new errors_1.PropsInitializedError();
-        if (!this.isMutable()) {
+        if (!this.modelMetadata().modelMutable) {
             this._props = props;
             Object.freeze(this._props);
         }

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

@@ -0,0 +1,4 @@
+export * from "./prop";
+export * from "./model";
+export * from "./static";
+export * from "./mutable";

package/dist/{decorators/model → model/decorators}/index.js

@@ -16,7 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./prop"), exports);
 __exportStar(require("./model"), exports);
-__exportStar(require("./version"), exports);
-__exportStar(require("./validator"), exports);
 __exportStar(require("./static"), exports);
-__exportStar(require("./enum"), exports);
+__exportStar(require("./mutable"), exports);

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

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

package/dist/model/decorators/model.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Model = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const domain_1 = require("../domain");
+const meta_1 = require("../meta");
+function Model(p1, p2, p3) {
+    const defaultModelOptions = {
+        autoRegisterModel: true,
+    };
+    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 = { name: p1, ...p2 };
+    }
+    else if (p1 && p2 && p3) {
+        modelOptions = {
+            name: p1,
+            version: p2,
+            ...p3,
+        };
+    }
+    modelOptions = lodash_1.default.merge(defaultModelOptions, modelOptions);
+    return (target) => {
+        if (modelOptions?.name)
+            (0, meta_1.defineModelName)(target, modelOptions.name);
+        if (modelOptions?.version)
+            (0, meta_1.defineModelVersion)(target, modelOptions.version);
+        if (modelOptions?.domain)
+            (0, meta_1.defineModelDomain)(target, modelOptions.domain);
+        if (modelOptions?.autoRegisterModel) {
+            const domainName = (0, meta_1.getModelDomain)(target);
+            if (!domain_1.domainManager.hasDomain(domainName)) {
+                domain_1.domainManager.addDomain(new domain_1.Domain(domainName));
+            }
+            const domain = domain_1.domainManager.getDomain(domainName);
+            domain.modelRegistry.registerModel(target);
+        }
+        if (modelOptions?.propsValidator)
+            (0, meta_1.definePropsValidator)(target, modelOptions.propsValidator);
+    };
+}
+exports.Model = Model;

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

@@ -0,0 +1,2 @@
+import { ModelClass } from "../core";
+export declare const Mutable: (mutable?: boolean) => (target: ModelClass) => void;

package/dist/model/decorators/mutable.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mutable = void 0;
+const meta_1 = require("../meta");
+const Mutable = (mutable = true) => {
+    return (target) => {
+        (0, meta_1.defineModelMutable)(target, mutable);
+    };
+};
+exports.Mutable = Mutable;

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

@@ -0,0 +1,2 @@
+import { AnyModel, PropsOf } from "../core";
+export declare const Prop: <T extends AnyModel>(propTargetKey?: keyof PropsOf<T> | undefined) => (target: T, key: PropertyKey) => void;

package/dist/{decorators/model → model/decorators}/prop.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Prop = void 0;
-const meta_1 = require("../../meta");
+const meta_1 = require("../meta");
 const Prop = (propTargetKey) => {
     return (target, key) => {
-        (0, meta_1.setProp)(target, key, propTargetKey ?? key);
+        (0, meta_1.defineProp)(target, key, propTargetKey ?? key);
     };
 };
 exports.Prop = Prop;

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

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

package/dist/model/decorators/static.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Static = void 0;
+const meta_1 = require("../meta");
+const Static = (builder) => {
+    return (target, key) => {
+        (0, meta_1.setStaticValue)(target, key, builder);
+        (0, meta_1.defineStaticValueProperty)(target, key);
+    };
+};
+exports.Static = Static;

package/dist/model/domain.d.ts

@@ -0,0 +1,20 @@
+import { ModelRegistry } from "./model-registry";
+export type DomainName = string;
+export declare class Domain {
+    readonly name: DomainName;
+    readonly modelRegistry: ModelRegistry;
+    constructor(name: DomainName);
+}
+export declare class DomainMap extends Map<DomainName, Domain> {
+}
+export declare class DomainManager {
+    static _instance: DomainManager;
+    static instance(): DomainManager;
+    private constructor();
+    private _domains;
+    hasDomain(domainName: DomainName): boolean;
+    getDomain(domainName: DomainName): Domain | undefined;
+    addDomain(domain: Domain): void;
+    deleteDomain(domainName: DomainName): void;
+}
+export declare const domainManager: DomainManager;

package/dist/model/domain.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.domainManager = exports.DomainManager = exports.DomainMap = exports.Domain = void 0;
+const model_registry_1 = require("./model-registry");
+class Domain {
+    constructor(name) {
+        this.name = name;
+        this.modelRegistry = new model_registry_1.ModelRegistry();
+    }
+}
+exports.Domain = Domain;
+class DomainMap extends Map {
+}
+exports.DomainMap = DomainMap;
+class DomainManager {
+    static instance() {
+        if (!this._instance)
+            this._instance = new DomainManager();
+        return this._instance;
+    }
+    constructor() {
+        this._domains = new DomainMap();
+    }
+    hasDomain(domainName) {
+        return this._domains.has(domainName);
+    }
+    getDomain(domainName) {
+        return this._domains.get(domainName);
+    }
+    addDomain(domain) {
+        if (this.hasDomain(domain.name))
+            throw new Error(`Domain ${domain.name} has already exist`);
+        this._domains.set(domain.name, domain);
+    }
+    deleteDomain(domainName) {
+        this._domains.delete(domainName);
+    }
+}
+exports.DomainManager = DomainManager;
+exports.domainManager = DomainManager.instance();

package/dist/model/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./meta";
+export * from "./core";
+export * from "./decorators";
+export * from "./domain";
+export * from "./model-registry";

package/dist/model/index.js

@@ -0,0 +1,21 @@
+"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("./meta"), exports);
+__exportStar(require("./core"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./domain"), exports);
+__exportStar(require("./model-registry"), exports);

package/dist/model/meta/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./model-id";
+export * from "./model-name";
+export * from "./model-props-map";
+export * from "./model-static-values";
+export * from "./model-props-validator";
+export * from "./model-version";
+export * from "./model-domain";
+export * from "./model-mutable";

package/dist/model/meta/index.js

@@ -0,0 +1,24 @@
+"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("./model-id"), exports);
+__exportStar(require("./model-name"), exports);
+__exportStar(require("./model-props-map"), exports);
+__exportStar(require("./model-static-values"), exports);
+__exportStar(require("./model-props-validator"), exports);
+__exportStar(require("./model-version"), exports);
+__exportStar(require("./model-domain"), exports);
+__exportStar(require("./model-mutable"), exports);

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

@@ -0,0 +1,5 @@
+import { AnyModel, ModelClass } from "../core";
+export declare const ModelDomainMetaKey: unique symbol;
+export declare const DEFAULT_MODEL_DOMAIN = "default";
+export declare const defineModelDomain: <T extends AnyModel>(target: ModelClass<T>, domainName: string) => void;
+export declare const getModelDomain: <T extends AnyModel>(target: ModelClass<T>) => string;

package/dist/model/meta/model-domain.js

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

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

@@ -0,0 +1,16 @@
+import { AnyModel, ModelClass } from "../core";
+import { ModelName } from "./model-name";
+import { ModelVersion } from "./model-version";
+export type ModelId = string;
+export type MIdFormat = `${string}${typeof MId.Divider}${number}`;
+export declare class MId extends String {
+    readonly modelName: ModelName;
+    readonly modelVersion: ModelVersion;
+    static Divider: "|";
+    static Format: RegExp;
+    static fromValue(value: ModelId): MId;
+    static makeValue(modelName: ModelName, modelVersion: ModelVersion): ModelId;
+    constructor(modelName: ModelName, modelVersion: ModelVersion);
+}
+export declare const setModelId: <T extends AnyModel>(target: ModelClass<T>, modelId: MId) => void;
+export declare const getModelId: <T extends AnyModel>(target: ModelClass<T>) => ModelId;

package/dist/model/meta/model-id.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModelId = exports.setModelId = exports.MId = void 0;
+const model_name_1 = require("./model-name");
+const model_version_1 = require("./model-version");
+class MId extends String {
+    static fromValue(value) {
+        if (!this.Format.test(value))
+            throw new Error(`Cannot parse MId from value ${value}`);
+        const [modelName, modelVersion] = value.split(this.Divider);
+        return new MId(modelName, Number(modelVersion));
+    }
+    static makeValue(modelName, modelVersion) {
+        const modelId = `${modelName}${this.Divider}${modelVersion}`;
+        return modelId;
+    }
+    constructor(modelName, modelVersion) {
+        super(MId.makeValue(modelName, modelVersion));
+        this.modelName = modelName;
+        this.modelVersion = modelVersion;
+    }
+}
+exports.MId = MId;
+MId.Divider = "|";
+MId.Format = new RegExp(/^.+\|[0-9]+$/);
+const ModelIdMetaKey = Symbol.for("MODEL_ID");
+const setModelId = (target, modelId) => {
+    Reflect.defineMetadata(ModelIdMetaKey, modelId, target);
+};
+exports.setModelId = setModelId;
+const getModelId = (target) => {
+    if (!Reflect.hasOwnMetadata(ModelIdMetaKey, target)) {
+        const modelName = (0, model_name_1.getModelName)(target);
+        const modelVersion = (0, model_version_1.getModelVersion)(target);
+        (0, exports.setModelId)(target, new MId(modelName, modelVersion));
+    }
+    return Reflect.getOwnMetadata(ModelIdMetaKey, target).valueOf();
+};
+exports.getModelId = getModelId;

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

@@ -0,0 +1,2 @@
+export declare const defineModelMutable: (target: object, mutable: boolean) => void;
+export declare const getModelMutable: (target: object) => boolean | undefined;

package/dist/model/meta/model-mutable.js

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

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

@@ -0,0 +1,8 @@
+import { AnyModel, ModelClass } from "../core";
+export type ModelName = string;
+export declare class MName extends String {
+    static validate(modelName: ModelName): void;
+    constructor(modelName: ModelName);
+}
+export declare const defineModelName: <T extends AnyModel>(target: ModelClass<T>, modelName: ModelName) => void;
+export declare const getModelName: <T extends AnyModel>(target: ModelClass<T>) => ModelName;

package/dist/model/meta/model-name.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModelName = exports.defineModelName = exports.MName = void 0;
+class MName extends String {
+    static validate(modelName) {
+        if (modelName.trim().length === 0)
+            throw new Error("Model name cannot be an empty string");
+    }
+    constructor(modelName) {
+        MName.validate(modelName);
+        super(modelName);
+    }
+}
+exports.MName = MName;
+const ModelNameMetaKey = Symbol.for("MODEL_NAME");
+const defineModelName = (target, modelName) => {
+    Reflect.defineMetadata(ModelNameMetaKey, new MName(modelName), target);
+};
+exports.defineModelName = defineModelName;
+const getModelName = (target) => {
+    if (!Reflect.hasOwnMetadata(ModelNameMetaKey, target))
+        (0, exports.defineModelName)(target, target.name);
+    return Reflect.getOwnMetadata(ModelNameMetaKey, target).valueOf();
+};
+exports.getModelName = getModelName;

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

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

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPropsMap = exports.defineProp = exports.getOwnPropsMap = exports.PropsMap = void 0;
+const core_1 = require("../core");
+const OwnPropsMapMetaKey = Symbol.for("OWN_PROPS_MAP");
+class PropsMap extends Map {
+}
+exports.PropsMap = PropsMap;
+// target is prototype
+const getOwnPropsMap = (target) => {
+    if (!Reflect.hasOwnMetadata(OwnPropsMapMetaKey, target))
+        Reflect.defineMetadata(OwnPropsMapMetaKey, new PropsMap(), target);
+    return Reflect.getOwnMetadata(OwnPropsMapMetaKey, target);
+};
+exports.getOwnPropsMap = getOwnPropsMap;
+const defineProp = (target, key, propTargetKey) => {
+    const ownPropsMap = (0, exports.getOwnPropsMap)(target);
+    if (propTargetKey)
+        ownPropsMap.set(key, propTargetKey);
+};
+exports.defineProp = defineProp;
+const PropsMapMetaKey = Symbol.for("PROPS_MAP");
+const getPropsMap = (target) => {
+    if (!Reflect.hasOwnMetadata(PropsMapMetaKey, target)) {
+        const buildPropsMap = (target) => {
+            let _target = target;
+            const result = new PropsMap();
+            const ownPropsMapList = [];
+            do {
+                if (core_1.ModelBase.isModel(_target)) {
+                    const ownPropsMap = (0, exports.getOwnPropsMap)(_target);
+                    ownPropsMapList.unshift(ownPropsMap);
+                }
+                _target = Reflect.getPrototypeOf(_target);
+            } while (_target !== null);
+            ownPropsMapList.forEach((ownPropsMap) => {
+                ownPropsMap.forEach((targetPropKey, key) => result.set(key, targetPropKey));
+            });
+            return result;
+        };
+        Reflect.defineMetadata(PropsMapMetaKey, buildPropsMap(target), target);
+    }
+    return Reflect.getOwnMetadata(PropsMapMetaKey, target);
+};
+exports.getPropsMap = getPropsMap;

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

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

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

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

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

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