ddd-node 34.2.0 → 35.0.0

package/base/meta/model-id.js

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

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

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getModelPropsValidators = exports.getOwnModelPropsValidator = exports.defineModelPropsValidator = exports.ModelPropsValidatorWrapper = void 0;
 const is_class_1 = __importDefault(require("is-class"));
 const lodash_1 = __importDefault(require("lodash"));
+const OWN_MODEL_PROPS_VALIDATOR = Symbol.for("OWN_MODEL_PROPS_VALIDATOR");
 class ModelPropsValidatorWrapper {
     constructor(input) {
         this.input = input;
@@ -27,7 +28,6 @@ class ModelPropsValidatorWrapper {
     }
 }
 exports.ModelPropsValidatorWrapper = ModelPropsValidatorWrapper;
-const OWN_MODEL_PROPS_VALIDATOR = Symbol.for("OWN_MODEL_PROPS_VALIDATOR");
 const defineModelPropsValidator = (target, validator) => {
     Reflect.defineMetadata(OWN_MODEL_PROPS_VALIDATOR, validator, target);
 };

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

@@ -4,15 +4,15 @@ import { ModelId, ModelName, ModelPropertyAccessorMap, ModelPropsValidator, Mode
 export declare class ModelDescriptor<T extends AnyDomainModel = AnyDomainModel> {
     readonly modelClass: DomainModelClass<T>;
     constructor(modelClass: DomainModelClass<T>);
-    modelDomain(): string;
-    modelMutable(): boolean;
-    modelName(): ModelName;
-    modelVersion(): ModelVersion;
-    modelId(): ModelId;
-    ownModelPropsValidator(): ModelPropsValidator<T> | undefined;
-    modelPropsValidators(): ModelPropsValidator[];
-    ownModelStaticValues(): ModelStaticValuesMap<T>;
-    declaredPropertyAccessors(): ModelPropertyAccessorMap<T>;
-    resolvedPropertyAccessors(): ModelPropertyAccessorMap<T>;
-    propsType(): Class<InferredProps<T>> | undefined;
+    get modelDomain(): string;
+    get modelMutable(): boolean;
+    get modelName(): ModelName;
+    get modelVersion(): ModelVersion;
+    get modelId(): ModelId;
+    get ownModelPropsValidator(): ModelPropsValidator<T> | undefined;
+    get modelPropsValidators(): ModelPropsValidator[];
+    get ownModelStaticValues(): ModelStaticValuesMap<T>;
+    get declaredPropertyAccessors(): ModelPropertyAccessorMap<T>;
+    get resolvedPropertyAccessors(): ModelPropertyAccessorMap<T>;
+    get propsType(): Class<InferredProps<T>> | undefined;
 }

package/base/model/model-descriptor.js

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

package/base/model/model.d.ts

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

package/base/model/model.js

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

package/base/model-registry.d.ts

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

package/base/model-registry.js

@@ -26,7 +26,7 @@ class ModelRegistry {
         if (typeof p1 === "string") {
             return new meta_1.$ModelId(p1, p2);
         }
-        return meta_1.$ModelId.fromValue(p1.modelDescriptor().modelId());
+        return meta_1.$ModelId.fromValue(p1.modelDescriptor().modelId);
     }
     getModel(modelName, modelVersion = 0) {
         const versions = this.getModelVersions(modelName);
@@ -45,8 +45,8 @@ class ModelRegistry {
         return Boolean(this.getModel(modelName, modelVersion));
     }
     registerModel(modelClass) {
-        const modelName = modelClass.modelDescriptor().modelName();
-        const modelVersion = modelClass.modelDescriptor().modelVersion();
+        const modelName = modelClass.modelDescriptor().modelName;
+        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);

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

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

package/core/decorators/enum/is-enum.js

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

package/core/decorators/es-aggregate/handle.js

@@ -6,7 +6,7 @@ const Handle = (commandClass) => {
     return (target, propertyKey, descriptor) => {
         if (typeof descriptor.value === "function") {
             const commandType = commandClass.commandType();
-            (0, meta_1.defineCommandHandler)(target, commandType, descriptor.value);
+            (0, meta_1.defineOwnCommandHandler)(target, commandType, descriptor.value);
         }
     };
 };

package/core/decorators/es-aggregate/when.js

@@ -6,7 +6,7 @@ const When = (eventClass) => {
     return (target, propertyKey, descriptor) => {
         if (typeof descriptor.value === "function") {
             const eventType = eventClass.eventType();
-            (0, meta_1.defineEventApplier)(target, eventType, descriptor.value);
+            (0, meta_1.defineOwnEventApplier)(target, eventType, descriptor.value);
         }
     };
 };

package/core/meta/{command.metadata.js → command.js}

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

package/core/meta/enum.d.ts

@@ -0,0 +1,7 @@
+import "reflect-metadata";
+export type EnumProperty<T extends Object = Object> = Extract<keyof T, string>;
+export declare class EnumPropertySet<T extends Object = Object> extends Set<EnumProperty<T>> {
+}
+export declare const markEnumProperty: <T extends Object>(target: T, key: EnumProperty<T>) => void;
+export declare const getOwnEnumPropertySet: <T extends Object>(target: T) => EnumPropertySet<T>;
+export declare const getEnumPropertySet: <T extends Object>(target: T) => EnumPropertySet<T>;

package/core/meta/enum.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnumPropertySet = exports.getOwnEnumPropertySet = exports.markEnumProperty = exports.EnumPropertySet = void 0;
+require("reflect-metadata");
+const ENUM_PROP_SET = Symbol.for("ENUM_PROP_SET");
+class EnumPropertySet extends Set {
+}
+exports.EnumPropertySet = EnumPropertySet;
+const markEnumProperty = (target, key) => {
+    const enumSet = (0, exports.getOwnEnumPropertySet)(target);
+    enumSet.add(key);
+};
+exports.markEnumProperty = markEnumProperty;
+const getOwnEnumPropertySet = (target) => {
+    if (!Reflect.getOwnMetadata(ENUM_PROP_SET, target)) {
+        Reflect.defineMetadata(ENUM_PROP_SET, new EnumPropertySet(), target);
+    }
+    return Reflect.getOwnMetadata(ENUM_PROP_SET, target);
+};
+exports.getOwnEnumPropertySet = getOwnEnumPropertySet;
+const getEnumPropertySet = (target) => {
+    let _target = target;
+    const result = new EnumPropertySet();
+    do {
+        const ownMarkedEnumValues = (0, exports.getOwnEnumPropertySet)(_target);
+        ownMarkedEnumValues.forEach((markedEnumValue) => {
+            result.add(markedEnumValue);
+        });
+        _target = Reflect.getPrototypeOf(_target);
+    } while (_target !== null);
+    return result;
+};
+exports.getEnumPropertySet = getEnumPropertySet;

package/core/meta/es-aggregate/{command-handler-map.d.ts → command-handler.d.ts}

@@ -1,8 +1,7 @@
+import "reflect-metadata";
 import { AnyCommand, CommandHandler } from "../../model";
 export declare class CommandHandlerMap extends Map<string, CommandHandler> {
 }
-export declare const OwnCommandHandlerMapMetaKey: unique symbol;
 export declare const getOwnCommandHandlerMap: (target: object) => CommandHandlerMap;
-export declare const defineCommandHandler: <T extends AnyCommand>(target: object, commandType: string, handler: CommandHandler<T>) => void;
-export declare const CommandHandlerMapMetaKey: unique symbol;
+export declare const defineOwnCommandHandler: <T extends AnyCommand>(target: object, commandType: string, handler: CommandHandler<T>) => void;
 export declare const getCommandHandlerMap: (target: object) => CommandHandlerMap;

package/core/meta/es-aggregate/{command-handler-map.js → command-handler.js}

@@ -1,25 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCommandHandlerMap = exports.CommandHandlerMapMetaKey = exports.defineCommandHandler = exports.getOwnCommandHandlerMap = exports.OwnCommandHandlerMapMetaKey = exports.CommandHandlerMap = void 0;
+exports.getCommandHandlerMap = exports.defineOwnCommandHandler = exports.getOwnCommandHandlerMap = exports.CommandHandlerMap = void 0;
+require("reflect-metadata");
+const OWN_COMMAND_HANDLER_MAP = Symbol.for("OWN_COMMAND_HANDLER_MAP");
+const COMMAND_HANDLER_MAP = Symbol.for("COMMAND_HANDLER_MAP");
 class CommandHandlerMap extends Map {
 }
 exports.CommandHandlerMap = CommandHandlerMap;
-exports.OwnCommandHandlerMapMetaKey = Symbol.for("OWN_COMMAND_HANDLER_MAP");
 const getOwnCommandHandlerMap = (target) => {
-    const ownCommandHandlerMap = () => Reflect.getOwnMetadata(exports.OwnCommandHandlerMapMetaKey, target);
+    const ownCommandHandlerMap = () => Reflect.getOwnMetadata(OWN_COMMAND_HANDLER_MAP, target);
     if (!ownCommandHandlerMap())
-        Reflect.defineMetadata(exports.OwnCommandHandlerMapMetaKey, new CommandHandlerMap(), target);
+        Reflect.defineMetadata(OWN_COMMAND_HANDLER_MAP, new CommandHandlerMap(), target);
     return ownCommandHandlerMap();
 };
 exports.getOwnCommandHandlerMap = getOwnCommandHandlerMap;
-const defineCommandHandler = (target, commandType, handler) => {
+const defineOwnCommandHandler = (target, commandType, handler) => {
     const commandHandlersMap = (0, exports.getOwnCommandHandlerMap)(target);
     commandHandlersMap.set(commandType, handler);
 };
-exports.defineCommandHandler = defineCommandHandler;
-exports.CommandHandlerMapMetaKey = Symbol.for("COMMAND_HANDLER_MAP");
+exports.defineOwnCommandHandler = defineOwnCommandHandler;
 const getCommandHandlerMap = (target) => {
-    if (!Reflect.hasOwnMetadata(exports.CommandHandlerMapMetaKey, target)) {
+    if (!Reflect.hasOwnMetadata(COMMAND_HANDLER_MAP, target)) {
         const buildCommandHandlerMap = (target) => {
             let _target = target;
             const result = new CommandHandlerMap();
@@ -36,8 +37,8 @@ const getCommandHandlerMap = (target) => {
             });
             return result;
         };
-        Reflect.defineMetadata(exports.CommandHandlerMapMetaKey, buildCommandHandlerMap(target), target);
+        Reflect.defineMetadata(COMMAND_HANDLER_MAP, buildCommandHandlerMap(target), target);
     }
-    return Reflect.getOwnMetadata(exports.CommandHandlerMapMetaKey, target);
+    return Reflect.getOwnMetadata(COMMAND_HANDLER_MAP, target);
 };
 exports.getCommandHandlerMap = getCommandHandlerMap;

package/core/meta/es-aggregate/{event-applier-map.d.ts → event-applier.d.ts}

@@ -2,8 +2,6 @@ import "reflect-metadata";
 import { AnyEvent, EventApplier } from "../../model";
 export declare class EventApplierMap extends Map<string, EventApplier> {
 }
-export declare const OwnEventApplierMapMetaKey: unique symbol;
 export declare const getOwnEventApplierMap: (target: object) => EventApplierMap;
-export declare const defineEventApplier: <T extends AnyEvent>(target: object, eventType: string, applier: EventApplier<T>) => void;
-export declare const EventApplierMapMetaKey: unique symbol;
+export declare const defineOwnEventApplier: <T extends AnyEvent>(target: object, eventType: string, applier: EventApplier<T>) => void;
 export declare const getEventApplierMap: (target: object) => EventApplierMap;

package/core/meta/es-aggregate/{event-applier-map.js → event-applier.js}

@@ -1,25 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEventApplierMap = exports.EventApplierMapMetaKey = exports.defineEventApplier = exports.getOwnEventApplierMap = exports.OwnEventApplierMapMetaKey = exports.EventApplierMap = void 0;
+exports.getEventApplierMap = exports.defineOwnEventApplier = exports.getOwnEventApplierMap = exports.EventApplierMap = void 0;
 require("reflect-metadata");
+const OWN_EVENT_APPLIER_MAP = Symbol.for("OWN_EVENT_APPLIER_MAP");
+const EVENT_APPLIER_MAP = Symbol.for("EVENT_HANDLER_MAP");
 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);
+    if (!Reflect.hasOwnMetadata(OWN_EVENT_APPLIER_MAP, target))
+        Reflect.defineMetadata(OWN_EVENT_APPLIER_MAP, new EventApplierMap(), target);
+    return Reflect.getMetadata(OWN_EVENT_APPLIER_MAP, target);
 };
 exports.getOwnEventApplierMap = getOwnEventApplierMap;
-const defineEventApplier = (target, eventType, applier) => {
+const defineOwnEventApplier = (target, eventType, applier) => {
     const eventAppliersMap = (0, exports.getOwnEventApplierMap)(target);
     eventAppliersMap.set(eventType, applier);
 };
-exports.defineEventApplier = defineEventApplier;
-exports.EventApplierMapMetaKey = Symbol.for("EVENT_HANDLER_MAP");
+exports.defineOwnEventApplier = defineOwnEventApplier;
 const getEventApplierMap = (target) => {
-    if (!Reflect.hasOwnMetadata(exports.EventApplierMapMetaKey, target)) {
+    if (!Reflect.hasOwnMetadata(EVENT_APPLIER_MAP, target)) {
         const buildEventApplierMap = (target) => {
             let _target = target;
             const result = new EventApplierMap();
@@ -36,8 +36,8 @@ const getEventApplierMap = (target) => {
             });
             return result;
         };
-        Reflect.defineMetadata(exports.EventApplierMapMetaKey, buildEventApplierMap(target), target);
+        Reflect.defineMetadata(EVENT_APPLIER_MAP, buildEventApplierMap(target), target);
     }
-    return Reflect.getOwnMetadata(exports.EventApplierMapMetaKey, target);
+    return Reflect.getOwnMetadata(EVENT_APPLIER_MAP, target);
 };
 exports.getEventApplierMap = getEventApplierMap;

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

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

package/core/meta/es-aggregate/index.js

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

package/core/meta/{event.metadata.js → event.js}

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

package/core/meta/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./es-aggregate";
-export * from "./event.metadata";
-export * from "./command.metadata";
+export * from "./event";
+export * from "./command";
+export * from "./enum";

package/core/meta/index.js

@@ -15,5 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./es-aggregate"), exports);
-__exportStar(require("./event.metadata"), exports);
-__exportStar(require("./command.metadata"), exports);
+__exportStar(require("./event"), exports);
+__exportStar(require("./command"), exports);
+__exportStar(require("./enum"), exports);

package/core/model/aggregate/aggregate.d.ts

@@ -1,18 +1,13 @@
-import { AnyEvent, EventClassWithTypedConstructor, EventSource } from "../message";
-import { ModelWithId, ModelWithIdMetadata } from "../model-with-id";
+import { Id, IdentifiedModel } from "../identified-model";
+import { AnyEvent, EventClassWithTypedConstructor, EventSource, NewEventOptions } from "../message";
 import { InferredProps, Props } from "./../../../base";
-import { IAggregateEventPublisher } from "./types";
-export interface AggregateMetadata extends ModelWithIdMetadata {
-    version: number;
-}
-export declare abstract class Aggregate<P extends Props> extends ModelWithId<P> {
-    static createMetadata: (metadata?: Partial<AggregateMetadata>) => AggregateMetadata;
+import { IEventReleaser } from "./event-releaser";
+export declare abstract class Aggregate<P extends Props> extends IdentifiedModel<P> {
     protected readonly _version: number;
-    constructor(metadata: AggregateMetadata, props?: P);
-    abstract version(): number;
-    metadata(): AggregateMetadata;
-    protected createEventSource(): EventSource;
-    protected newEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: InferredProps<E>): E;
-    abstract publishEvents<R = any>(publisher: IAggregateEventPublisher<R>): R;
+    constructor(id: Id, version: number, props?: P);
+    abstract get version(): number;
+    protected asEventSource(): EventSource;
+    protected newEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: InferredProps<E>, options?: NewEventOptions): E;
+    abstract releaseEvents<R = any>(eventReleaser: IEventReleaser<R>): R;
 }
 export type AnyAggregate = Aggregate<Props>;

package/core/model/aggregate/aggregate.js

@@ -10,41 +10,27 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Aggregate = void 0;
-const uuid_1 = require("uuid");
-const model_with_id_1 = require("../model-with-id");
+const identified_model_1 = require("../identified-model");
 const base_1 = require("./../../../base");
-let Aggregate = class Aggregate extends model_with_id_1.ModelWithId {
-    constructor(metadata, props) {
-        super(metadata);
+let Aggregate = class Aggregate extends identified_model_1.IdentifiedModel {
+    constructor(id, version, props) {
+        super(id);
+        this._version = version;
         if (props)
             this.initializeProps(props);
-        this._version = metadata.version;
     }
-    metadata() {
+    asEventSource() {
         return {
-            ...super.metadata(),
-            version: this.version(),
+            aggregateId: this.id,
+            aggregateVersion: this.version,
         };
     }
-    createEventSource() {
-        return {
-            aggregateId: this.id(),
-            aggregateVersion: this.version(),
-        };
-    }
-    newEvent(eventClass, props) {
-        return eventClass.build(props, { source: this.createEventSource() });
+    newEvent(eventClass, props, options) {
+        return eventClass.new(this.asEventSource(), props, options);
     }
 };
 exports.Aggregate = Aggregate;
-Aggregate.createMetadata = (metadata) => {
-    return {
-        id: (0, uuid_1.v4)(),
-        version: 0,
-        ...metadata,
-    };
-};
 exports.Aggregate = Aggregate = __decorate([
     (0, base_1.Mutable)(true),
-    __metadata("design:paramtypes", [Object, Object])
+    __metadata("design:paramtypes", [String, Number, Object])
 ], Aggregate);