ddd-node 17.2.0 → 18.0.0

package/dist/meta/aggregate-es/event-applier-map.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEventApplierMap = exports.EventApplierMapMetaKey = exports.defineEventApplier = exports.getOwnEventApplierMap = exports.OwnEventApplierMapMetaKey = exports.EventApplierMap = void 0;
+require("reflect-metadata");
+class EventApplierMap extends Map {
+}
+exports.EventApplierMap = EventApplierMap;
+exports.OwnEventApplierMapMetaKey = Symbol.for("OWN_EVENT_APPLIER_MAP");
+const getOwnEventApplierMap = (target) => {
+    if (!Reflect.hasOwnMetadata(exports.OwnEventApplierMapMetaKey, target))
+        Reflect.defineMetadata(exports.OwnEventApplierMapMetaKey, new EventApplierMap(), target);
+    return Reflect.getMetadata(exports.OwnEventApplierMapMetaKey, target);
+};
+exports.getOwnEventApplierMap = getOwnEventApplierMap;
+const defineEventApplier = (target, eventType, applier) => {
+    const eventAppliersMap = (0, exports.getOwnEventApplierMap)(target);
+    eventAppliersMap.set(eventType, applier);
+};
+exports.defineEventApplier = defineEventApplier;
+exports.EventApplierMapMetaKey = Symbol.for("EVENT_HANDLER_MAP");
+const getEventApplierMap = (target) => {
+    if (!Reflect.hasOwnMetadata(exports.EventApplierMapMetaKey, target)) {
+        const buildEventApplierMap = (target) => {
+            let _target = target;
+            const result = new EventApplierMap();
+            const ownEventApplierMaps = [];
+            do {
+                const ownEventApplierMap = (0, exports.getOwnEventApplierMap)(_target);
+                ownEventApplierMaps.unshift(ownEventApplierMap);
+                _target = Reflect.getPrototypeOf(_target);
+            } while (_target !== null);
+            ownEventApplierMaps.forEach((ownEventApplierMap) => {
+                ownEventApplierMap.forEach((eventApplier, methodName) => {
+                    result.set(methodName, eventApplier);
+                });
+            });
+            return result;
+        };
+        Reflect.defineMetadata(exports.EventApplierMapMetaKey, buildEventApplierMap(target), target);
+    }
+    return Reflect.getOwnMetadata(exports.EventApplierMapMetaKey, target);
+};
+exports.getEventApplierMap = getEventApplierMap;

package/dist/meta/aggregate-es/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./event-applier-map";
+export * from "./command-handler-map";

package/dist/meta/{helpers → aggregate-es}/index.js

@@ -14,4 +14,5 @@ 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("./static-value"), exports);
+__exportStar(require("./event-applier-map"), exports);
+__exportStar(require("./command-handler-map"), exports);

package/dist/meta/command.metadata.d.ts

@@ -1,4 +1,8 @@
 import "reflect-metadata";
 export type CommandType = string;
-export declare const setCommandType: (target: object, commandType: CommandType) => void;
-export declare const getCommandType: (target: object) => CommandType | undefined;
+export declare class CType extends String {
+    static validate(commandType: string): void;
+    constructor(commandType: CommandType);
+}
+export declare const defineCommandType: (target: object, commandType: CommandType) => void;
+export declare const getCommandType: (target: object) => CommandType;

package/dist/meta/command.metadata.js

@@ -1,13 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCommandType = exports.setCommandType = void 0;
+exports.getCommandType = exports.defineCommandType = exports.CType = void 0;
 require("reflect-metadata");
+class CType extends String {
+    static validate(commandType) {
+        if (commandType.trim().length === 0)
+            throw new Error("Command type cannot be an empty string");
+    }
+    constructor(commandType) {
+        CType.validate(commandType);
+        super(commandType);
+    }
+}
+exports.CType = CType;
 const CommandTypeMetaKey = Symbol.for("COMMAND_TYPE");
-const setCommandType = (target, commandType) => {
-    Reflect.defineMetadata(CommandTypeMetaKey, commandType, target);
+const defineCommandType = (target, commandType) => {
+    Reflect.defineMetadata(CommandTypeMetaKey, new CType(commandType), target);
 };
-exports.setCommandType = setCommandType;
+exports.defineCommandType = defineCommandType;
 const getCommandType = (target) => {
-    return Reflect.getOwnMetadata(CommandTypeMetaKey, target);
+    const commandType = Reflect.getOwnMetadata(CommandTypeMetaKey, target);
+    if (!commandType)
+        throw new Error("Command's type is not defined");
+    return commandType.valueOf();
 };
 exports.getCommandType = getCommandType;

package/dist/meta/event.metadata.d.ts

@@ -1,4 +1,8 @@
 import "reflect-metadata";
 export type EventType = string;
-export declare const setEventType: (target: object, eventType: EventType) => void;
-export declare const getEventType: (target: object) => EventType | undefined;
+export declare class EType extends String {
+    static validate(eventType: string): void;
+    constructor(eventType: EventType);
+}
+export declare const defineEventType: (target: object, eventType: EventType) => void;
+export declare const getEventType: (target: object) => EventType;

package/dist/meta/event.metadata.js

@@ -1,13 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEventType = exports.setEventType = void 0;
+exports.getEventType = exports.defineEventType = exports.EType = void 0;
 require("reflect-metadata");
+class EType extends String {
+    static validate(eventType) {
+        if (eventType.trim().length === 0)
+            throw new Error("Event type cannot be an empty string");
+    }
+    constructor(eventType) {
+        EType.validate(eventType);
+        super(eventType);
+    }
+}
+exports.EType = EType;
 const EventTypeMetaKey = Symbol.for("EVENT_TYPE");
-const setEventType = (target, eventType) => {
-    Reflect.defineMetadata(EventTypeMetaKey, eventType, target);
+const defineEventType = (target, eventType) => {
+    Reflect.defineMetadata(EventTypeMetaKey, new EType(eventType), target);
 };
-exports.setEventType = setEventType;
+exports.defineEventType = defineEventType;
 const getEventType = (target) => {
-    return Reflect.getOwnMetadata(EventTypeMetaKey, target);
+    const eventType = Reflect.getOwnMetadata(EventTypeMetaKey, target);
+    if (!eventType)
+        throw new Error("Event's type is not defined");
+    return eventType.valueOf();
 };
 exports.getEventType = getEventType;

package/dist/meta/id.metadata.js

@@ -9,9 +9,8 @@ const defineIdService = (target, idService) => {
 exports.defineIdService = defineIdService;
 const getIdService = (target) => {
     const idService = () => Reflect.getMetadata(exports.IdServiceMetaKey, target);
-    if (idService())
-        return idService();
-    Reflect.defineMetadata(exports.IdServiceMetaKey, new core_1.Uuid4Service(), target);
+    if (!idService())
+        (0, exports.defineIdService)(target, new core_1.Uuid4Service());
     return idService();
 };
 exports.getIdService = getIdService;

package/dist/meta/index.d.ts

@@ -1,6 +1,5 @@
-export * from "./helpers";
-export * from "./aggregate.metadata";
+export * from "./model";
+export * from "./aggregate-es";
 export * from "./id.metadata";
-export * from "./model.metadata";
 export * from "./event.metadata";
 export * from "./command.metadata";

package/dist/meta/index.js

@@ -14,9 +14,8 @@ 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("./helpers"), exports);
-__exportStar(require("./aggregate.metadata"), exports);
+__exportStar(require("./model"), exports);
+__exportStar(require("./aggregate-es"), exports);
 __exportStar(require("./id.metadata"), exports);
-__exportStar(require("./model.metadata"), exports);
 __exportStar(require("./event.metadata"), exports);
 __exportStar(require("./command.metadata"), exports);

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

@@ -0,0 +1,7 @@
+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";

package/dist/meta/model/index.js

@@ -0,0 +1,23 @@
+"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);

package/dist/meta/model/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/meta/model/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/meta/model/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/meta/model/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/meta/model/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/meta/model/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/meta/model/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: T) => PropsMap<T>;
+export declare const defineProp: <T extends AnyModel = AnyModel>(target: T, key: PropertyKey, propTargetKey?: keyof PropsOf<T> | undefined) => void;
+export declare const getPropsMap: <T extends AnyModel = AnyModel>(target: T) => PropsMap<T>;

package/dist/meta/model/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/meta/model/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/meta/model/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/meta/model/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;

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

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

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

@@ -0,0 +1,8 @@
+import { AnyModel, ModelClass } from "../../core";
+export type ModelVersion = number;
+export declare class MVersion extends Number {
+    static validate(modelVersion: ModelVersion): void;
+    constructor(modelVersion: ModelVersion);
+}
+export declare const defineModelVersion: <T extends AnyModel>(target: ModelClass<T>, modelVersion: ModelVersion) => void;
+export declare const getModelVersion: <T extends AnyModel>(target: ModelClass<T>) => ModelVersion;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModelVersion = exports.defineModelVersion = exports.MVersion = void 0;
+class MVersion extends Number {
+    static validate(modelVersion) {
+        if (modelVersion < 0 && Number.isInteger(modelVersion))
+            throw new Error("Model version must be a non-negative integer number");
+    }
+    constructor(modelVersion) {
+        MVersion.validate(modelVersion);
+        super(modelVersion);
+    }
+}
+exports.MVersion = MVersion;
+const ModelVersionMetaKey = Symbol.for("MODEL_VERSION");
+const defineModelVersion = (target, modelVersion) => {
+    Reflect.defineMetadata(ModelVersionMetaKey, new MVersion(modelVersion), target);
+};
+exports.defineModelVersion = defineModelVersion;
+const getModelVersion = (target) => {
+    if (!Reflect.hasOwnMetadata(ModelVersionMetaKey, target))
+        (0, exports.defineModelVersion)(target, 0);
+    return Reflect.getOwnMetadata(ModelVersionMetaKey, target).valueOf();
+};
+exports.getModelVersion = getModelVersion;

package/dist/package.json

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

package/package.json

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

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

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

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

@@ -1,3 +0,0 @@
-import { ModelClass } from "../../core";
-import { PropsValidator } from "../../meta";
-export declare const Validator: <T extends ModelClass<import("../../core").AnyModel>, I extends InstanceType<T> = InstanceType<T>>(validator?: PropsValidator<I> | undefined) => (target: T) => void;

package/dist/decorators/model/validator.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Validator = void 0;
-const meta_1 = require("../../meta");
-const Validator = (validator) => {
-    return (target) => {
-        if (validator)
-            (0, meta_1.setPropsValidator)(target, validator);
-    };
-};
-exports.Validator = Validator;

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

@@ -1,2 +0,0 @@
-import { ModelClass } from "../../core";
-export declare const Version: (version: number) => <T extends ModelClass<import("../../core").AnyModel>>(target: T) => void;

package/dist/decorators/model/version.js

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

package/dist/meta/aggregate.metadata.d.ts

@@ -1,8 +0,0 @@
-import { AnyCommand, AnyEvent, CommandHandler, EventApplier } from "../core";
-import "reflect-metadata";
-export declare const EventApplierMapMetaKey: unique symbol;
-export declare const getEventApplierMap: (target: object) => Map<string, EventApplier>;
-export declare const defineEventApplier: <T extends AnyEvent>(target: object, eventType: string, applier: EventApplier<T>) => void;
-export declare const CommandHandlerMapMetaKey: unique symbol;
-export declare const getCommandHandlerMap: (target: object) => Map<string, CommandHandler>;
-export declare const defineCommandHandler: <T extends AnyCommand>(target: object, commandType: string, handler: CommandHandler<T>) => void;

package/dist/meta/aggregate.metadata.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineCommandHandler = exports.getCommandHandlerMap = exports.CommandHandlerMapMetaKey = exports.defineEventApplier = exports.getEventApplierMap = exports.EventApplierMapMetaKey = void 0;
-require("reflect-metadata");
-// Event applier map
-exports.EventApplierMapMetaKey = Symbol.for("EVENT_APPLIER_MAP");
-const getEventApplierMap = (target) => {
-    const eventApplierMap = () => Reflect.getMetadata(exports.EventApplierMapMetaKey, target);
-    if (eventApplierMap())
-        return eventApplierMap();
-    Reflect.defineMetadata(exports.EventApplierMapMetaKey, new Map(), target);
-    return eventApplierMap();
-};
-exports.getEventApplierMap = getEventApplierMap;
-const defineEventApplier = (target, eventType, applier) => {
-    const eventAppliersMap = (0, exports.getEventApplierMap)(target);
-    eventAppliersMap.set(eventType, applier);
-};
-exports.defineEventApplier = defineEventApplier;
-// Command handler map
-exports.CommandHandlerMapMetaKey = Symbol.for("COMMAND_HANDLER_MAP");
-const getCommandHandlerMap = (target) => {
-    const commandHandlerMap = () => Reflect.getMetadata(exports.CommandHandlerMapMetaKey, target);
-    if (commandHandlerMap())
-        return commandHandlerMap();
-    Reflect.defineMetadata(exports.CommandHandlerMapMetaKey, new Map(), target);
-    return commandHandlerMap();
-};
-exports.getCommandHandlerMap = getCommandHandlerMap;
-const defineCommandHandler = (target, commandType, handler) => {
-    const commandHandlersMap = (0, exports.getCommandHandlerMap)(target);
-    commandHandlersMap.set(commandType, handler);
-};
-exports.defineCommandHandler = defineCommandHandler;