ddd-node 30.1.1 → 31.0.0

package/base/decorators/model.d.ts

@@ -1,6 +1,6 @@
 import { ModelPropsValidator } from "../meta";
-import { AnyModel, ModelClass } from "../model";
-export type ModelOptions<T extends AnyModel = AnyModel> = {
+import { AnyDomainModel, DomainModelClass } from "../model";
+export type ModelOptions<T extends AnyDomainModel = AnyDomainModel> = {
     name?: string;
     version?: number;
     domain?: string;
@@ -8,6 +8,6 @@ export type ModelOptions<T extends AnyModel = AnyModel> = {
     autoRegisterModel?: boolean;
 };
 export declare const DEFAULT_MODEL_OPTIONS: ModelOptions;
-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;
+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;

package/base/decorators/mutable.d.ts

@@ -1,2 +1,2 @@
-import { AbstractModelClass, ModelClass } from "../model";
-export declare const Mutable: (mutable?: boolean) => <T extends ModelClass<import("../model").AnyModel> | AbstractModelClass<import("../model").AnyModel>>(target: T) => void;
+import { AbstractDomainModelClass, DomainModelClass } from "../model";
+export declare const Mutable: (mutable?: boolean) => <T extends DomainModelClass | AbstractDomainModelClass>(target: T) => void;

package/base/decorators/prop.d.ts

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

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

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

package/base/decorators/static.d.ts

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

package/base/domain.d.ts

@@ -5,6 +5,7 @@ export declare class Domain {
     readonly name: DomainName;
     readonly modelRegistry: ModelRegistry;
     constructor(name: DomainName);
+    reset(): void;
 }
 export declare class DomainMap extends Map<DomainName, Domain> {
 }

package/base/domain.js

@@ -8,6 +8,9 @@ class Domain {
         this.name = name;
         this.modelRegistry = new model_registry_1.ModelRegistry();
     }
+    reset() {
+        this.modelRegistry.clearAll();
+    }
 }
 exports.Domain = Domain;
 class DomainMap extends Map {

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

@@ -1,4 +1,5 @@
-import { AnyModel, ModelClass } from "../model";
+import { DomainName } from "../domain";
+import { AnyDomainModel, DomainModelClass } from "../model";
 export declare const ModelDomainMetaKey: unique symbol;
-export declare const defineModelDomain: <T extends AnyModel>(target: ModelClass<T>, domainName: string) => void;
-export declare const getModelDomain: <T extends AnyModel>(target: ModelClass<T>) => string;
+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-id.d.ts

@@ -1,4 +1,4 @@
-import { AnyModel, ModelClass } from "../model";
+import { AnyDomainModel, DomainModelClass } from "../model";
 import { ModelName } from "./model-name";
 import { ModelVersion } from "./model-version";
 export type ModelId = string;
@@ -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 AnyModel>(target: ModelClass<T>, modelId: $ModelId) => void;
-export declare const getModelId: <T extends AnyModel>(target: ModelClass<T>) => ModelId;
+export declare const setModelId: <T extends AnyDomainModel>(target: DomainModelClass<T>, modelId: $ModelId) => void;
+export declare const getModelId: <T extends AnyDomainModel>(target: DomainModelClass<T>) => ModelId;

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

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

package/base/meta/model-mutable.js

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

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

@@ -1,8 +1,8 @@
-import { AnyModel, ModelClass } from "../model";
+import { AnyDomainModel, DomainModelClass } from "../model";
 export type ModelName = string;
 export declare class $ModelName 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;
+export declare const defineModelName: <T extends AnyDomainModel>(target: DomainModelClass<T>, modelName: ModelName) => void;
+export declare const getModelName: <T extends AnyDomainModel>(target: DomainModelClass<T>) => ModelName;

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

@@ -1,6 +1,6 @@
-import { AnyModel, InferredProps } from "../model";
-export declare class ModelPropsMap<T extends AnyModel = AnyModel> extends Map<PropertyKey, keyof InferredProps<T>> {
+import { AnyDomainModel, InferredProps } from "../model";
+export declare class ModelPropsMap<T extends AnyDomainModel = AnyDomainModel> extends Map<PropertyKey, keyof InferredProps<T>> {
 }
-export declare const getOwnModelPropsMap: <T extends AnyModel = AnyModel>(target: object) => ModelPropsMap<T>;
-export declare const defineModelProp: <T extends AnyModel = AnyModel>(target: object, key: PropertyKey, propTargetKey?: keyof InferredProps<T> | undefined) => void;
-export declare const getModelPropsMap: <T extends AnyModel = AnyModel>(target: object) => ModelPropsMap<T>;
+export declare const getOwnModelPropsMap: <T extends AnyDomainModel = AnyDomainModel>(target: object) => ModelPropsMap<T>;
+export declare const defineModelProp: <T extends AnyDomainModel = AnyDomainModel>(target: object, key: PropertyKey, propTargetKey?: keyof InferredProps<T> | undefined) => void;
+export declare const getModelPropsMap: <T extends AnyDomainModel = AnyDomainModel>(target: object) => ModelPropsMap<T>;

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

@@ -27,7 +27,7 @@ const getModelPropsMap = (target) => {
             const result = new ModelPropsMap();
             const ownPropsMapList = [];
             do {
-                if (model_1.ModelBase.isModel(_target)) {
+                if (model_1.DomainModel.isDomainModel(_target)) {
                     const ownModelPropsMap = (0, exports.getOwnModelPropsMap)(_target);
                     ownPropsMapList.unshift(ownModelPropsMap);
                 }

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

@@ -1,6 +1,6 @@
-import { AnyModel, InferredProps } from "../model";
-export type ModelPropsValidator<T extends AnyModel = AnyModel> = (props: InferredProps<T>) => void;
-export declare const defineModelPropsValidator: <T extends AnyModel>(target: object, validator: ModelPropsValidator<T>) => void;
-export declare const getOwnModelPropsValidator: <T extends AnyModel>(target: object) => ModelPropsValidator<T> | undefined;
+import { AnyDomainModel, InferredProps } from "../model";
+export type ModelPropsValidator<T extends AnyDomainModel = AnyDomainModel> = (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 ModelPropsValidatorsMetaKey: unique symbol;
 export declare const getModelPropsValidators: (target: object) => ModelPropsValidator[];

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

@@ -1,13 +1,13 @@
-import { AnyModel, ModelClass } from "../model";
-export type ModelStaticValueBuilder<T extends AnyModel = AnyModel> = () => T;
-export declare class ModelStaticValue<T extends AnyModel = AnyModel> {
+import { AnyDomainModel, DomainModelClass } from "../model";
+export type ModelStaticValueBuilder<T extends AnyDomainModel = AnyDomainModel> = () => T;
+export declare class ModelStaticValue<T extends AnyDomainModel = AnyDomainModel> {
     private _value;
     constructor(value: T | ModelStaticValueBuilder<T>);
     get value(): T;
 }
-export declare class ModelStaticValuesMap<T extends AnyModel = AnyModel> extends Map<PropertyKey, ModelStaticValue<T>> {
+export declare class ModelStaticValuesMap<T extends AnyDomainModel = AnyDomainModel> extends Map<PropertyKey, ModelStaticValue<T>> {
 }
-export declare const getOwnModelStaticValues: <T extends AnyModel>(target: object) => ModelStaticValuesMap<T>;
-export declare const setModelStaticValue: <T extends AnyModel>(target: object, key: PropertyKey, value: T | ModelStaticValueBuilder<T>) => void;
-export declare const getModelStaticValue: (target: object, key: PropertyKey) => AnyModel | undefined;
-export declare const defineModelStaticValueProperty: (target: ModelClass, key: PropertyKey) => void;
+export declare const getOwnModelStaticValues: <T extends AnyDomainModel>(target: object) => ModelStaticValuesMap<T>;
+export declare const setModelStaticValue: <T extends AnyDomainModel>(target: object, key: PropertyKey, value: T | ModelStaticValueBuilder<T>) => void;
+export declare const getModelStaticValue: (target: object, key: PropertyKey) => AnyDomainModel | undefined;
+export declare const defineModelStaticValueProperty: (target: DomainModelClass, key: PropertyKey) => void;

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

@@ -1,8 +1,8 @@
-import { AnyModel, ModelClass } from "../model";
+import { AnyDomainModel, DomainModelClass } from "../model";
 export type ModelVersion = number;
 export declare class $ModelVersion 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;
+export declare const defineModelVersion: <T extends AnyDomainModel>(target: DomainModelClass<T>, modelVersion: ModelVersion) => void;
+export declare const getModelVersion: <T extends AnyDomainModel>(target: DomainModelClass<T>) => ModelVersion;

package/base/model/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./model";
 export * from "./model-descriptor";
-export * from "./model.builder";

package/base/model/index.js

@@ -16,4 +16,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./model"), exports);
 __exportStar(require("./model-descriptor"), exports);
-__exportStar(require("./model.builder"), exports);

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

@@ -1,13 +1,16 @@
-import { AnyModel } from "./model";
-import { ModelId, ModelName, ModelVersion, ModelPropsMap, ModelPropsValidator, ModelStaticValuesMap } from "../meta";
-export interface ModelDescriptor<T extends AnyModel = AnyModel> {
-    modelId: ModelId;
-    modelName: ModelName;
-    modelVersion: ModelVersion;
-    modelMutable: boolean;
-    ownModelPropsValidator?: ModelPropsValidator<T>;
-    modelPropsValidators: ModelPropsValidator[];
-    ownModelStaticValues: ModelStaticValuesMap<T>;
-    ownModelPropsMap: ModelPropsMap<T>;
-    modelPropsMap: ModelPropsMap<T>;
+import { AnyDomainModel, DomainModelClass } from ".";
+import { ModelId, ModelName, ModelPropsMap, 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>;
+    ownModelPropsMap(): ModelPropsMap<T>;
+    modelPropsMap(): ModelPropsMap<T>;
 }

package/base/model/model-descriptor.js

@@ -1,2 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelDescriptor = void 0;
+const meta_1 = require("../meta");
+class ModelDescriptor {
+    constructor(modelClass) {
+        this.modelClass = modelClass;
+    }
+    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;
+    }
+    modelName() {
+        return (0, meta_1.getModelName)(this.modelClass);
+    }
+    modelVersion() {
+        return (0, meta_1.getModelVersion)(this.modelClass);
+    }
+    modelId() {
+        return (0, meta_1.getModelId)(this.modelClass);
+    }
+    ownModelPropsValidator() {
+        return (0, meta_1.getOwnModelPropsValidator)(this.modelClass);
+    }
+    modelPropsValidators() {
+        return (0, meta_1.getModelPropsValidators)(this.modelClass);
+    }
+    ownModelStaticValues() {
+        return (0, meta_1.getOwnModelStaticValues)(this.modelClass);
+    }
+    ownModelPropsMap() {
+        return (0, meta_1.getOwnModelPropsMap)(this.modelClass.prototype);
+    }
+    modelPropsMap() {
+        return (0, meta_1.getModelPropsMap)(this.modelClass.prototype);
+    }
+}
+exports.ModelDescriptor = ModelDescriptor;

package/base/model/model.d.ts

@@ -1,40 +1,30 @@
 import { AbstractClass, Class } from "type-fest";
 import { ClassStatic } from "../../types";
-import { ModelId, ModelName, ModelPropsMap, ModelPropsValidator, ModelStaticValuesMap, ModelVersion } from "../meta";
 import { ModelDescriptor } from "./model-descriptor";
 export interface Props {
     [key: PropertyKey]: any;
 }
+export type PropsBuilder<T extends AnyDomainModel> = () => InferredProps<T>;
 export type EmptyProps = {
     [key: PropertyKey]: never;
 };
-export declare class ModelBase<P extends Props> {
+export declare class DomainModel<P extends Props> {
     static readonly EMPTY_PROPS: EmptyProps;
+    static modelDescriptor<T extends AnyDomainModel>(this: DomainModelClass<T>): ModelDescriptor<T>;
+    static isDomainModel(model: any): model is AnyDomainModel;
     protected _props: P;
-    static isModel(model: any): model is AnyModel;
-    static modelMutable<T extends AnyModel>(this: ModelClass<T>): boolean;
-    static modelName<T extends AnyModel>(this: ModelClass<T>): ModelName;
-    static modelVersion<T extends AnyModel>(this: ModelClass<T>): ModelVersion;
-    static modelId<T extends AnyModel>(this: ModelClass<T>): ModelId;
-    static ownModelPropsValidator<T extends AnyModel>(this: ModelClass<T>): ModelPropsValidator<T> | undefined;
-    static modelPropsValidators<T extends AnyModel>(this: ModelClass<T>): ModelPropsValidator[];
-    static ownModelStaticValues<T extends AnyModel>(this: ModelClass<T>): ModelStaticValuesMap<T>;
-    static ownModelPropsMap<T extends AnyModel>(this: ModelClass<T>): ModelPropsMap<T>;
-    static modelPropsMap<T extends AnyModel>(this: ModelClass<T>): ModelPropsMap<T>;
     constructor();
     redefineModel(): void;
     protected redefineProp<K extends keyof P>(key: keyof this, propTargetKey: K): void;
-    modelDescriptor(): ModelDescriptor<typeof this>;
+    modelDescriptor(): ModelDescriptor<AnyDomainModel>;
     validateProps(props: P): void;
     validate(): void;
     propsIsEmpty(): boolean;
     props(): P | null;
     metadata(): any;
-    protected initializeProps(props: P): void;
-}
-export type AnyModel = ModelBase<Props>;
-export type InferredProps<T extends AnyModel> = T extends ModelBase<infer P> ? P : never;
-export interface ModelClass<T extends AnyModel = AnyModel> extends Class<T>, ClassStatic<typeof ModelBase<InferredProps<T>>> {
-}
-export interface AbstractModelClass<T extends AnyModel = AnyModel> extends AbstractClass<T>, ClassStatic<typeof ModelBase<InferredProps<T>>> {
+    protected initializeProps(propsOrBuilder: P | PropsBuilder<typeof this>): void;
 }
+export type AnyDomainModel = DomainModel<Props>;
+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

@@ -3,48 +3,25 @@ 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.DomainModel = void 0;
 const lodash_1 = __importDefault(require("lodash"));
-const meta_1 = require("../meta");
 const errors_1 = require("./errors");
-class ModelBase {
-    static isModel(model) {
-        return model instanceof ModelBase;
+const model_descriptor_1 = require("./model-descriptor");
+class DomainModel {
+    static modelDescriptor() {
+        return new model_descriptor_1.ModelDescriptor(this);
     }
-    static modelMutable() {
-        var _a;
-        return (_a = (0, meta_1.getModelMutable)(this)) !== null && _a !== void 0 ? _a : false;
-    }
-    static modelName() {
-        return (0, meta_1.getModelName)(this);
-    }
-    static modelVersion() {
-        return (0, meta_1.getModelVersion)(this);
-    }
-    static modelId() {
-        return (0, meta_1.getModelId)(this);
-    }
-    static ownModelPropsValidator() {
-        return (0, meta_1.getOwnModelPropsValidator)(this);
-    }
-    static modelPropsValidators() {
-        return (0, meta_1.getModelPropsValidators)(this);
-    }
-    static ownModelStaticValues() {
-        return (0, meta_1.getOwnModelStaticValues)(this);
-    }
-    static ownModelPropsMap() {
-        return (0, meta_1.getOwnModelPropsMap)(this.prototype);
-    }
-    static modelPropsMap() {
-        return (0, meta_1.getModelPropsMap)(this.prototype);
+    static isDomainModel(model) {
+        return model instanceof DomainModel;
     }
     constructor() {
-        this._props = ModelBase.EMPTY_PROPS;
+        this._props = DomainModel.EMPTY_PROPS;
         this.redefineModel();
     }
     redefineModel() {
-        this.modelDescriptor().modelPropsMap.forEach((propTargetKey, key) => {
+        this.modelDescriptor()
+            .modelPropsMap()
+            .forEach((propTargetKey, key) => {
             this.redefineProp(key, propTargetKey);
         });
     }
@@ -60,34 +37,23 @@ class ModelBase {
         });
     }
     modelDescriptor() {
-        const modelClass = this.constructor;
-        return {
-            modelMutable: modelClass.modelMutable(),
-            modelId: modelClass.modelId(),
-            modelName: modelClass.modelName(),
-            modelVersion: modelClass.modelVersion(),
-            ownModelPropsValidator: modelClass.ownModelPropsValidator(),
-            modelPropsValidators: modelClass.modelPropsValidators(),
-            ownModelStaticValues: modelClass.ownModelStaticValues(),
-            ownModelPropsMap: modelClass.ownModelPropsMap(),
-            modelPropsMap: modelClass.modelPropsMap(),
-        };
+        return new model_descriptor_1.ModelDescriptor(this.constructor);
     }
     validateProps(props) {
-        const modelPropsValidators = this.modelDescriptor().modelPropsValidators;
+        const modelPropsValidators = this.modelDescriptor().modelPropsValidators();
         modelPropsValidators.forEach((propsValidator) => propsValidator.call(this.constructor, props));
     }
     validate() {
         this.validateProps(this._props);
     }
     propsIsEmpty() {
-        return this._props === ModelBase.EMPTY_PROPS;
+        return this._props === DomainModel.EMPTY_PROPS;
     }
     props() {
         if (this.propsIsEmpty())
             return null;
         return lodash_1.default.cloneDeepWith(this._props, (value) => {
-            if (ModelBase.isModel(value)) {
+            if (DomainModel.isDomainModel(value)) {
                 value.redefineModel();
                 return value;
             }
@@ -96,9 +62,14 @@ class ModelBase {
     metadata() {
         return {};
     }
-    initializeProps(props) {
+    initializeProps(propsOrBuilder) {
         if (!this.propsIsEmpty())
             throw new errors_1.PropsInitializedError();
+        let props;
+        if (typeof propsOrBuilder === "function")
+            props = propsOrBuilder.call(this);
+        else
+            props = propsOrBuilder;
         if (!this.modelDescriptor().modelMutable) {
             this._props = props;
             Object.freeze(this._props);
@@ -115,5 +86,5 @@ class ModelBase {
         this.validate();
     }
 }
-exports.ModelBase = ModelBase;
-ModelBase.EMPTY_PROPS = {};
+exports.DomainModel = DomainModel;
+DomainModel.EMPTY_PROPS = {};

package/base/model-registry.d.ts

@@ -1,17 +1,21 @@
-import { AnyModel, ModelClass } from "./model";
+import { AnyDomainModel, DomainModelClass } from "./model";
 import { ModelId, ModelName, ModelVersion } from "./meta";
-export declare class ModelVersionMap<T extends AnyModel = AnyModel> extends Map<ModelVersion, ModelClass<T>> {
+export declare class ModelVersions<T extends AnyDomainModel = AnyDomainModel> extends Map<ModelVersion, DomainModelClass<T>> {
     readonly modelName: ModelName;
     constructor(modelName: ModelName);
 }
-export declare class ModelMap<T extends AnyModel = AnyModel> extends Map<ModelName, ModelVersionMap<T>> {
+export declare class ModelStore<T extends AnyDomainModel = AnyDomainModel> extends Map<ModelName, ModelVersions<T>> {
 }
 export declare class ModelRegistry {
-    private readonly modelMap;
-    getModelVersionMap<T extends AnyModel = AnyModel>(modelName: ModelName): ModelVersionMap<T>;
-    getModel<T extends AnyModel = AnyModel>(modelName: ModelName, modelVersion?: ModelVersion): ModelClass<T> | undefined;
-    getModelByModelId<T extends AnyModel = AnyModel>(modelId: ModelId): ModelClass<T> | undefined;
-    hasRegisteredModel(modelName: ModelName, modelVersion: ModelVersion): boolean;
-    hasRegisteredModel(model: ModelClass): boolean;
-    registerModel(modelClass: ModelClass): this;
+    private store;
+    getModelVersions<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;
+    hasRegisteredModel(p1: ModelName | DomainModelClass, p2?: ModelVersion): boolean;
+    hasRegisteredModelWithId(modelId: ModelId): boolean;
+    registerModel(modelClass: DomainModelClass): this;
+    deregisterModel(p1: ModelName | DomainModelClass, p2?: ModelVersion): void;
+    clearModelVersions(modelName: ModelName): void;
+    clearAll(): void;
 }

package/base/model-registry.js

@@ -1,55 +1,70 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModelRegistry = exports.ModelMap = exports.ModelVersionMap = void 0;
+exports.ModelRegistry = exports.ModelStore = exports.ModelVersions = void 0;
 const meta_1 = require("./meta");
-class ModelVersionMap extends Map {
+class ModelVersions extends Map {
     constructor(modelName) {
         super();
         this.modelName = modelName;
     }
 }
-exports.ModelVersionMap = ModelVersionMap;
-class ModelMap extends Map {
+exports.ModelVersions = ModelVersions;
+class ModelStore extends Map {
 }
-exports.ModelMap = ModelMap;
+exports.ModelStore = ModelStore;
 class ModelRegistry {
     constructor() {
-        this.modelMap = new ModelMap();
+        this.store = new ModelStore();
     }
-    getModelVersionMap(modelName) {
-        const modelVersionMap = () => this.modelMap.get(modelName);
-        if (!modelVersionMap())
-            this.modelMap.set(modelName, new ModelVersionMap(modelName));
-        return modelVersionMap();
+    getModelVersions(modelName) {
+        const current = () => this.store.get(modelName);
+        if (!current())
+            this.store.set(modelName, new ModelVersions(modelName));
+        return current();
+    }
+    resolveModelId(p1, p2) {
+        if (typeof p1 === "string") {
+            return new meta_1.$ModelId(p1, p2);
+        }
+        return meta_1.$ModelId.fromValue(p1.modelDescriptor().modelId());
     }
     getModel(modelName, modelVersion = 0) {
-        const modelVersionMap = this.getModelVersionMap(modelName);
-        return modelVersionMap.get(modelVersion);
+        const versions = this.getModelVersions(modelName);
+        return versions.get(modelVersion);
     }
     getModelByModelId(modelId) {
         const { modelName, modelVersion } = meta_1.$ModelId.fromValue(modelId);
         return this.getModel(modelName, modelVersion);
     }
     hasRegisteredModel(p1, p2) {
-        let modelName, modelVersion;
-        if (typeof p1 === "string") {
-            modelName = p1;
-            modelVersion = p2;
-        }
-        else {
-            modelName = p1.modelName();
-            modelVersion = p1.modelVersion();
-        }
+        const { modelName, modelVersion } = this.resolveModelId(p1, p2);
+        return Boolean(this.getModel(modelName, modelVersion));
+    }
+    hasRegisteredModelWithId(modelId) {
+        const { modelName, modelVersion } = meta_1.$ModelId.fromValue(modelId);
         return Boolean(this.getModel(modelName, modelVersion));
     }
     registerModel(modelClass) {
-        const modelName = modelClass.modelName();
-        const modelVersion = modelClass.modelVersion();
+        const modelName = modelClass.modelDescriptor().modelName();
+        const modelVersion = modelClass.modelDescriptor().modelVersion();
         if (this.hasRegisteredModel(modelName, modelVersion))
-            throw new Error(`Model ${modelName} with version ${modelVersion} has been registered`);
-        const modelVersionMap = this.getModelVersionMap(modelName);
-        modelVersionMap.set(modelVersion, modelClass);
+            throw new Error(`Cannot register: Model ${modelName} with version ${modelVersion} is already registered.`);
+        const versions = this.getModelVersions(modelName);
+        versions.set(modelVersion, modelClass);
         return this;
     }
+    deregisterModel(p1, p2) {
+        const { modelName, modelVersion } = this.resolveModelId(p1, p2);
+        if (!this.hasRegisteredModel(modelName, modelVersion))
+            return;
+        const versions = this.getModelVersions(modelName);
+        versions.delete(modelVersion);
+    }
+    clearModelVersions(modelName) {
+        this.store.delete(modelName);
+    }
+    clearAll() {
+        this.store = new ModelStore();
+    }
 }
 exports.ModelRegistry = ModelRegistry;

package/core/decorators/enum/index.d.ts

@@ -0,0 +1 @@
+export * from "./is-enum";

package/core/decorators/enum/index.js

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

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

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

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

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Enum = void 0;
-const base_1 = require("../base");
-const Enum = (value) => {
+exports.IsEnum = void 0;
+const base_1 = require("../../../base");
+const IsEnum = (value) => {
     return (target, key) => {
         (0, base_1.Static)(() => new target(value !== null && value !== void 0 ? value : key))(target, key);
     };
 };
-exports.Enum = Enum;
+exports.IsEnum = IsEnum;

package/core/decorators/es-aggregate/handle.d.ts

@@ -0,0 +1,2 @@
+import { AnyCommand, AnyESAggregate, CommandClass, CommandHandler } from "../..";
+export declare const Handle: <T extends AnyCommand>(commandClass: CommandClass<T>) => <U extends CommandHandler<T>>(target: AnyESAggregate, propertyKey: string, descriptor: TypedPropertyDescriptor<U>) => void;