ddd-node 13.0.0-0 → 13.0.0

package/dist/core/aggregate.d.ts

@@ -3,19 +3,19 @@ import { Class } from "type-fest";
 import { EntityBase, EntityMetadata } from "./entity";
 import { Id } from "./id";
 import { AnyCommand, AnyEvent, EventClass, EventClassWithTypedConstructor } from "./message";
-import { PropsOf } from "./model/model";
+import { Props, PropsOf } from "./model";
 export interface AggregateBaseMetadata extends EntityMetadata {
     version: number;
 }
-export declare abstract class AggregateCore<Props extends object> extends EntityBase<Props> {
+export declare abstract class AggregateCore<P extends Props> extends EntityBase<P> {
     protected readonly _version: number;
-    constructor(metadata: AggregateBaseMetadata, props?: Props);
+    constructor(metadata: AggregateBaseMetadata, props?: P);
     abstract getVersion(): number;
     protected newEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: PropsOf<E>): E;
 }
-export declare abstract class AggregateBase<Props extends object> extends AggregateCore<Props> {
+export declare abstract class AggregateBase<P extends Props> extends AggregateCore<P> {
     private _events;
-    constructor(metadata: AggregateBaseMetadata, props: Props);
+    constructor(metadata: AggregateBaseMetadata, props: P);
     static newAggregate<T extends AnyAggregate>(this: AggregateClassWithTypedConstructor<T>, props: PropsOf<T>, id?: Id): T;
     getVersion(): number;
     getEvents(): AnyEvent[];
@@ -29,11 +29,11 @@ export interface Snapshot<T extends AnyAggregateES> {
     metadata: SnapshotMetadata;
     props: PropsOf<T>;
 }
-export declare abstract class AggregateESBase<Props extends object> extends AggregateCore<Props> {
+export declare abstract class AggregateESBase<P extends Props> extends AggregateCore<P> {
     private _handledCommands;
     private _pastEvents;
     private _events;
-    constructor(metadata: AggregateBaseMetadata, props?: Props);
+    constructor(metadata: AggregateBaseMetadata, props?: P);
     static newStream<T extends AnyAggregateES>(this: AggregateESClassWithTypedConstructor<T>, id?: Id): T;
     static fromStream<T extends AnyAggregateES>(this: AggregateESClassWithTypedConstructor<T>, id: Id, events?: AnyEvent[]): T;
     static fromSnapshot<T extends AnyAggregateES>(this: AggregateESClassWithTypedConstructor<T>, snapshot: Snapshot<T>, events?: AnyEvent[]): T;
@@ -58,10 +58,14 @@ export declare abstract class AggregateESBase<Props extends object> extends Aggr
     snap(): Snapshot<this>;
 }
 export type AnyAggregate = AggregateBase<any>;
-export type AggregateClass<T extends AnyAggregate = AnyAggregate, Arguments extends unknown[] = any[]> = Class<T, Arguments> & ClassStatic<typeof AggregateBase<PropsOf<T>>>;
-export type AggregateClassWithTypedConstructor<T extends AnyAggregate = AnyAggregate> = AggregateClass<T, ConstructorParameters<typeof AggregateBase<PropsOf<T>>>>;
+export interface AggregateClass<T extends AnyAggregate = AnyAggregate, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof AggregateBase<PropsOf<T>>> {
+}
+export interface AggregateClassWithTypedConstructor<T extends AnyAggregate = AnyAggregate> extends AggregateClass<T, ConstructorParameters<typeof AggregateBase<PropsOf<T>>>> {
+}
 export type AnyAggregateES = AggregateESBase<any>;
-export type AggregateESClass<T extends AnyAggregateES = AnyAggregateES, Arguments extends unknown[] = any[]> = Class<T, Arguments> & ClassStatic<typeof AggregateESBase<PropsOf<T>>>;
-export type AggregateESClassWithTypedConstructor<T extends AnyAggregateES = AnyAggregateES> = AggregateESClass<T, ConstructorParameters<typeof AggregateESBase<PropsOf<T>>>>;
+export interface AggregateESClass<T extends AnyAggregateES = AnyAggregateES, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof AggregateESBase<PropsOf<T>>> {
+}
+export interface AggregateESClassWithTypedConstructor<T extends AnyAggregateES = AnyAggregateES> extends AggregateESClass<T, ConstructorParameters<typeof AggregateESBase<PropsOf<T>>>> {
+}
 export type EventApplier<T extends AnyEvent = AnyEvent> = (event: T) => void;
 export type CommandHandler<T extends AnyCommand = AnyCommand, U extends AnyEvent | AnyEvent[] = AnyEvent> = (command: T) => U;

package/dist/core/aggregate.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AggregateESBase = exports.AggregateBase = exports.AggregateCore = void 0;
 const _utils_1 = require("../utils/index");
 const entity_1 = require("./entity");
-const aggregate_metadata_1 = require("../meta/aggregate.metadata");
+const _meta_1 = require("../meta/index");
 class AggregateCore extends entity_1.EntityBase {
     constructor(metadata, props) {
         super(metadata, props);
@@ -12,7 +12,7 @@ class AggregateCore extends entity_1.EntityBase {
     newEvent(eventClass, props) {
         const eventSource = {
             aggregate: this.modelName(),
-            id: this.getId(),
+            id: this.id(),
             version: this.getVersion(),
         };
         return eventClass.newEvent(eventSource, props);
@@ -76,10 +76,10 @@ class AggregateESBase extends AggregateCore {
         return instance;
     }
     static eventAppliersMap() {
-        return (0, aggregate_metadata_1.getEventAppliersMap)(this.prototype);
+        return (0, _meta_1.getEventAppliersMap)(this.prototype);
     }
     static commandHandlersMap() {
-        return (0, aggregate_metadata_1.getCommandHandlersMap)(this.prototype);
+        return (0, _meta_1.getCommandHandlersMap)(this.prototype);
     }
     getVersion() {
         return this._version + this._pastEvents.length + this._events.length;
@@ -157,7 +157,7 @@ class AggregateESBase extends AggregateCore {
             var _a;
             event.setContext({
                 correlationId: (_a = command.getContext()) === null || _a === void 0 ? void 0 : _a.correlationId,
-                causationId: command.getId().value,
+                causationId: command.id().value,
             });
         });
         this.applyEvents(events);
@@ -169,7 +169,7 @@ class AggregateESBase extends AggregateCore {
             throw new Error();
         return {
             metadata: {
-                id: this.getId(),
+                id: this.id(),
                 version: this.getVersion(),
             },
             props: this.props(),

package/dist/core/entity.d.ts

@@ -1,16 +1,19 @@
 import { Class } from "type-fest";
 import { Id } from "./id";
-import { ModelWithId, PropsOf } from "./model";
+import { ModelWithId, Props, PropsOf } from "./model";
 import { ClassStatic } from "../types/index";
 export interface EntityMetadata {
     readonly id: Id;
 }
-export declare abstract class EntityBase<Props extends object> extends ModelWithId<Props> {
-    constructor(metadata: EntityMetadata, props?: Props);
-    static isMutable(): boolean;
+export declare abstract class EntityBase<P extends Props> extends ModelWithId<P> {
+    constructor(metadata: EntityMetadata, props?: P);
+    static mutable(): boolean;
     static newEntity<T extends AnyEntity>(this: EntityClassWithTypedConstructor<T>, props: PropsOf<T>, id?: Id): T;
 }
 export type AnyEntity = EntityBase<object>;
-export type EntityClass<T extends AnyEntity = AnyEntity, Arguments extends unknown[] = any[]> = Class<T, Arguments> & ClassStatic<typeof EntityBase<PropsOf<T>>>;
-export type EntityClassWithTypedConstructor<T extends AnyEntity = AnyEntity> = EntityClass<T, ConstructorParameters<typeof EntityBase<PropsOf<T>>>>;
-export type EntityClassWithProps<P extends object> = EntityClass<EntityBase<P>>;
+export interface EntityClass<T extends AnyEntity = AnyEntity, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof EntityBase<PropsOf<T>>> {
+}
+export interface EntityClassWithTypedConstructor<T extends AnyEntity = AnyEntity> extends EntityClass<T, ConstructorParameters<typeof EntityBase<PropsOf<T>>>> {
+}
+export interface EntityClassWithProps<P extends object> extends EntityClass<EntityBase<P>> {
+}

package/dist/core/entity.js

@@ -8,7 +8,7 @@ class EntityBase extends model_1.ModelWithId {
         if (props)
             this.initializeProps(props);
     }
-    static isMutable() {
+    static mutable() {
         return true;
     }
     static newEntity(props, id) {

package/dist/core/enum.d.ts

@@ -2,14 +2,15 @@ import { ClassStatic } from "../types/index";
 import { Class } from "type-fest";
 import { ModelBase } from "./model";
 export type EnumValue = string | number;
-export interface EnumProps<V extends EnumValue> {
-    value: V;
+export interface EnumProps {
+    value: EnumValue;
 }
-export declare class EnumBase<V extends EnumValue = EnumValue> extends ModelBase<EnumProps<V>> {
-    static values<T extends EnumBase>(): void;
-    static parse<T extends EnumBase>(this: EnumClass<T>, value: EnumValue): void;
-    constructor(value: V);
-    value: V;
+export declare class EnumBase extends ModelBase<EnumProps> {
+    static values(): EnumBase[];
+    static parse<T extends EnumBase>(this: EnumClass<T>, providedValue: EnumValue): T | undefined;
+    constructor(value: EnumValue);
+    value: EnumValue;
+    equals<T extends EnumBase>(other: T): boolean;
+}
+export interface EnumClass<T extends EnumBase = EnumBase> extends Class<T>, ClassStatic<typeof EnumBase> {
 }
-export type ValueOf<T extends EnumBase> = T extends EnumBase<infer V extends EnumValue> ? V : never;
-export type EnumClass<T extends EnumBase = EnumBase> = Class<T> & ClassStatic<typeof EnumBase>;

package/dist/core/enum.js

@@ -13,15 +13,36 @@ exports.EnumBase = void 0;
 const _decorators_1 = require("../decorators/index");
 const model_1 = require("./model");
 class EnumBase extends model_1.ModelBase {
-    static values() { }
-    static parse(value) { }
+    static values() {
+        return Array.from(this.ownStaticValues().values()).map((staticValue) => staticValue.value);
+    }
+    static parse(providedValue) {
+        var _a;
+        let key;
+        this.ownStaticValues().forEach((staticValue, staticValueKey) => {
+            if (staticValue.value instanceof this) {
+                const staticEnum = staticValue.value;
+                if (staticEnum.value === providedValue && !key) {
+                    key = staticValueKey;
+                }
+            }
+        });
+        if (key)
+            return (_a = this.ownStaticValues().get(key)) === null || _a === void 0 ? void 0 : _a.value;
+        return undefined;
+    }
     constructor(value) {
         super();
         this.initializeProps({ value });
     }
+    equals(other) {
+        const equalType = other instanceof this.constructor;
+        const equalValue = other.value === this.value;
+        return equalType && equalValue;
+    }
 }
 exports.EnumBase = EnumBase;
 __decorate([
-    _decorators_1.Prop,
+    (0, _decorators_1.Prop)(),
     __metadata("design:type", Object)
 ], EnumBase.prototype, "value", void 0);

package/dist/core/message/command.d.ts

@@ -1,13 +1,15 @@
+import { ClassStatic } from "../../types/index";
 import { Class } from "type-fest";
-import { PropsOf } from "../model";
+import { Props, PropsOf } from "../model";
 import { MessageBase, MessageContext, MessageMetadata } from "./message";
-import { ClassStatic } from "../../types/index";
 export interface CommandMetadata extends MessageMetadata {
 }
-export declare abstract class CommandBase<Props extends object> extends MessageBase<Props> {
-    constructor(metadata: CommandMetadata, props: Props);
+export declare abstract class CommandBase<P extends Props> extends MessageBase<P> {
+    constructor(metadata: CommandMetadata, props: P);
     static newCommand<T extends AnyCommand>(this: CommandClassWithTypedConstructor<T>, props: PropsOf<T>, context?: MessageContext): T;
 }
 export type AnyCommand = CommandBase<any>;
-export type CommandClass<T extends AnyCommand = AnyCommand, Arguments extends unknown[] = any[]> = Class<T, Arguments> & ClassStatic<typeof CommandBase<PropsOf<T>>>;
-export type CommandClassWithTypedConstructor<T extends AnyCommand = AnyCommand> = CommandClass<T, ConstructorParameters<typeof CommandBase<PropsOf<T>>>>;
+export interface CommandClass<T extends AnyCommand = AnyCommand, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof CommandBase<PropsOf<T>>> {
+}
+export interface CommandClassWithTypedConstructor<T extends AnyCommand = AnyCommand> extends CommandClass<T, ConstructorParameters<typeof CommandBase<PropsOf<T>>>> {
+}

package/dist/core/message/event.d.ts

@@ -1,8 +1,8 @@
+import { ClassStatic } from "../../types/index";
 import { Class } from "type-fest";
 import { Id } from "../id";
-import { PropsOf } from "../model";
+import { Props, PropsOf } from "../model";
 import { MessageBase, MessageContext, MessageMetadata } from "./message";
-import { ClassStatic } from "../../types/index";
 export type EventSource = Readonly<{
     aggregate: string;
     id: Id;
@@ -11,17 +11,19 @@ export type EventSource = Readonly<{
 export interface EventMetadata extends MessageMetadata {
     source: EventSource;
 }
-export declare abstract class EventBase<Props extends object, Raw = any> extends MessageBase<Props> {
+export declare abstract class EventBase<P extends Props, R = any> extends MessageBase<P> {
     private readonly _source;
-    constructor(metadata: EventMetadata, props: Props);
+    constructor(metadata: EventMetadata, props: P);
     static newEvent<T extends AnyEvent>(this: EventClassWithTypedConstructor<T>, source: EventSource, props: PropsOf<T>, context?: MessageContext): T;
     getSource(): Readonly<{
         aggregate: string;
         id: Id;
         version: number;
     }>;
-    getRaw(): Raw | null;
+    getRaw(): R | null;
 }
 export type AnyEvent = EventBase<any>;
-export type EventClass<T extends AnyEvent = AnyEvent, Arguments extends unknown[] = any[]> = Class<T, Arguments> & ClassStatic<typeof EventBase<PropsOf<T>>>;
-export type EventClassWithTypedConstructor<T extends AnyEvent = AnyEvent> = EventClass<T, ConstructorParameters<typeof EventBase<PropsOf<T>>>>;
+export interface EventClass<T extends AnyEvent = AnyEvent, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof EventBase<PropsOf<T>>> {
+}
+export interface EventClassWithTypedConstructor<T extends AnyEvent = AnyEvent> extends EventClass<T, ConstructorParameters<typeof EventBase<PropsOf<T>>>> {
+}

package/dist/core/message/message.d.ts

@@ -1,5 +1,5 @@
 import { Id } from "../id";
-import { ModelWithId } from "../model";
+import { ModelWithId, Props } from "../model";
 export interface MessageContext {
     correlationId?: string;
     causationId?: string;
@@ -9,10 +9,10 @@ export interface MessageMetadata {
     readonly timestamp: number;
     context?: MessageContext;
 }
-export declare abstract class MessageBase<Props extends object> extends ModelWithId<Props> {
+export declare abstract class MessageBase<P extends Props> extends ModelWithId<P> {
     private readonly _timestamp;
     private _context?;
-    protected constructor(metadata: MessageMetadata, props: Props);
+    protected constructor(metadata: MessageMetadata, props: P);
     getTimestamp(): number;
     getContext(): MessageContext | undefined;
     setContext(context: Partial<MessageContext>): void;

package/dist/core/model/model-with-id.d.ts

@@ -1,11 +1,11 @@
 import { Id, IdGeneratorBase } from "../id";
-import { ModelBase } from "./model";
-export declare abstract class ModelWithId<Props extends object> extends ModelBase<Props> {
+import { ModelBase, Props } from "./model";
+export declare abstract class ModelWithId<P extends Props> extends ModelBase<P> {
     protected readonly _id: Id;
     constructor(id: Id);
-    static getIdGenerator(this: any): IdGeneratorBase;
+    static idGenerator(this: any): IdGeneratorBase;
     static id(id?: Id): Id;
-    getId(): Id;
+    id(): Id;
     hasId(id: Id): boolean;
     rawId(): string;
 }

package/dist/core/model/model-with-id.js

@@ -9,14 +9,14 @@ class ModelWithId extends model_1.ModelBase {
         super();
         this._id = id;
     }
-    static getIdGenerator() {
+    static idGenerator() {
         return (0, _meta_1.getIdGenerator)(this) || new id_1.Uuid4Generator();
     }
     static id(id) {
-        const generator = this.getIdGenerator();
+        const generator = this.idGenerator();
         return id ? generator.fromId(id) : generator.newId();
     }
-    getId() {
+    id() {
         return this._id;
     }
     hasId(id) {

package/dist/core/model/model.d.ts

@@ -1,26 +1,35 @@
-import { ModelMetadata } from "../../meta/index";
 import { ClassStatic } from "../../types/index";
 import { Class } from "type-fest";
-export declare class ModelBase<Props extends object> {
-    static readonly STATIC_VALUES_KEY: "__STATIC_VALUES__";
+export type PropKey = string | symbol;
+export interface Props {
+    [key: PropKey]: any;
+}
+export declare class ModelBase<P extends Props> {
     static readonly EMPTY_PROPS: {};
-    private _metadata;
-    private _propKeys;
-    protected _props: Props;
-    static isMutable(): boolean;
+    protected _props: P;
     static isModel(model: any): model is AnyModel;
+    static mutable(): boolean;
+    static modelName<T extends AnyModel>(this: ModelClass<T>): string;
+    static propsValidator<T extends AnyModel>(this: ModelClass<T>): import("../../meta/index").PropsValidator<T> | undefined;
+    static ownStaticValues<T extends AnyModel>(this: ModelClass<T>): Map<string | symbol, import("../../meta/index").StaticValue<T>>;
+    static ownPropsMap(): import("../../meta/index").PropsMap<ModelBase<any>>;
+    static propsMap(): import("../../meta/index").PropsMap<ModelBase<any>>;
     constructor();
     private redefineModel;
+    protected get _prototype(): object;
+    protected get _type(): ModelClass<this>;
     isMutable(): boolean;
-    getPropKeys(): Set<string | symbol>;
-    validateProps(props: Props): void;
-    validate(): void;
-    getModelMetadata(): ModelMetadata<this>;
     modelName(): string;
+    propsValidator(): import("../../meta/index").PropsValidator<this> | undefined;
+    ownPropsMap(): import("../../meta/index").PropsMap<ModelBase<any>>;
+    propsMap(): import("../../meta/index").PropsMap<ModelBase<any>>;
+    validateProps(props: P): void;
+    validate(): void;
     props(): any;
-    protected initializeProps(props: Props): void;
+    protected initializeProps(props: P): void;
 }
 export type AnyModel = ModelBase<object>;
-export type PropsOf<T extends AnyModel> = T extends ModelBase<infer P extends object> ? P : never;
-export type ModelClass<T extends AnyModel = AnyModel> = Class<T> & ClassStatic<typeof ModelBase<PropsOf<T>>>;
+export type PropsOf<T extends AnyModel> = T extends ModelBase<infer P extends Props> ? P : never;
+export interface ModelClass<T extends AnyModel = AnyModel> extends Class<T>, ClassStatic<typeof ModelBase<PropsOf<T>>> {
+}
 export type EmptyProps = {};

package/dist/core/model/model.js

@@ -7,57 +7,75 @@ exports.ModelBase = void 0;
 const _meta_1 = require("../../meta/index");
 const lodash_1 = __importDefault(require("lodash"));
 class ModelBase {
-    static isMutable() {
-        return false;
-    }
     static isModel(model) {
         return model instanceof ModelBase;
     }
+    static mutable() {
+        return false;
+    }
+    static modelName() {
+        return (0, _meta_1.getModelName)(this);
+    }
+    static propsValidator() {
+        return (0, _meta_1.getPropsValidator)(this);
+    }
+    static ownStaticValues() {
+        return (0, _meta_1.getOwnStaticValues)(this);
+    }
+    static ownPropsMap() {
+        return (0, _meta_1.getOwnPropsMap)(this.prototype);
+    }
+    static propsMap() {
+        return (0, _meta_1.getPropsMap)(this.prototype);
+    }
     constructor() {
         this._props = ModelBase.EMPTY_PROPS;
         this.redefineModel();
     }
     redefineModel() {
-        this.getPropKeys().forEach((propKey) => {
-            Object.defineProperty(this, propKey, {
+        this.propsMap().forEach((propKeyTarget, key) => {
+            Object.defineProperty(this, key, {
                 configurable: true,
                 enumerable: true,
                 get() {
                     var _a;
-                    return (_a = this._props) === null || _a === void 0 ? void 0 : _a[propKey];
+                    return (_a = this._props) === null || _a === void 0 ? void 0 : _a[propKeyTarget];
                 },
                 set() {
-                    throw new Error(`Prop "${propKey.toString()}" cannot be set directly`);
+                    throw new Error(`Cannot set "${key.toString()}"`);
                 },
             });
         });
     }
+    get _prototype() {
+        return Reflect.getPrototypeOf(this);
+    }
+    get _type() {
+        return this.constructor;
+    }
     isMutable() {
-        return this.constructor.isMutable();
+        return this._type.mutable();
     }
-    getPropKeys() {
-        if (!this._propKeys) {
-            this._propKeys = (0, _meta_1.getPropKeySet)(Reflect.getPrototypeOf(this));
-        }
-        return this._propKeys;
+    modelName() {
+        return this._type.modelName();
+    }
+    propsValidator() {
+        return this._type.propsValidator();
+    }
+    ownPropsMap() {
+        return this._type.ownPropsMap();
+    }
+    propsMap() {
+        return this._type.propsMap();
     }
     validateProps(props) {
-        const { validator } = this.getModelMetadata();
-        if (validator)
-            validator(props);
+        const propsValidator = this.propsValidator();
+        if (propsValidator)
+            propsValidator(props);
     }
     validate() {
         this.validateProps(this._props);
     }
-    getModelMetadata() {
-        if (!this._metadata) {
-            this._metadata = (0, _meta_1.getModelMetadata)(this.constructor);
-        }
-        return this._metadata;
-    }
-    modelName() {
-        return this.getModelMetadata().name;
-    }
     props() {
         return lodash_1.default.cloneDeepWith(this._props, (value) => {
             if (ModelBase.isModel(value)) {
@@ -66,6 +84,7 @@ class ModelBase {
             }
         });
     }
+    // initializeProps must be call in leaf class, it cannot be call in a extendable model class
     initializeProps(props) {
         if (this._props !== ModelBase.EMPTY_PROPS)
             throw new Error("Props is initialized");
@@ -86,5 +105,4 @@ class ModelBase {
     }
 }
 exports.ModelBase = ModelBase;
-ModelBase.STATIC_VALUES_KEY = "__STATIC_VALUES__";
 ModelBase.EMPTY_PROPS = {};

package/dist/core/value-object.d.ts

@@ -1,11 +1,13 @@
 import { Class } from "type-fest";
-import { ModelBase, PropsOf } from "./model";
+import { ModelBase, Props, PropsOf } from "./model";
 import { ClassStatic } from "../types/index";
-export declare abstract class ValueObjectBase<Props extends object> extends ModelBase<Props> {
-    constructor(props: Props);
+export declare abstract class ValueObjectBase<P extends Props> extends ModelBase<P> {
+    constructor(props: P);
     equals<V extends AnyValueObject>(vo: V): boolean;
-    with(props: Partial<Props>): this;
+    with(props: Partial<P>): this;
 }
 export type AnyValueObject = ValueObjectBase<any>;
-export type ValueObjectClass<T extends AnyValueObject = AnyValueObject> = Class<T> & ClassStatic<typeof ValueObjectBase<PropsOf<T>>>;
-export type ValueObjectClassWithTypedConstructor<T extends AnyValueObject = AnyValueObject> = Class<T, ConstructorParameters<typeof ValueObjectBase<PropsOf<T>>>>;
+export interface ValueObjectClass<T extends AnyValueObject = AnyValueObject> extends Class<T>, ClassStatic<typeof ValueObjectBase<PropsOf<T>>> {
+}
+export interface ValueObjectClassWithTypedConstructor<T extends AnyValueObject = AnyValueObject> extends Class<T, ConstructorParameters<typeof ValueObjectBase<PropsOf<T>>>> {
+}

package/dist/decorators/aggregate/handle.d.ts

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

package/dist/decorators/aggregate/when.d.ts

@@ -1,2 +1,2 @@
 import { AnyEvent, EventApplier, EventClass } from "../../core/index";
-export declare const When: <T extends AnyEvent>(eventClass: EventClass<T>) => <U extends EventApplier<T>>(target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<U>) => void;
+export declare const When: <T extends AnyEvent>(eventClass: EventClass<T, any[]>) => <U extends EventApplier<T>>(target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<U>) => void;

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

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

package/dist/decorators/model/enum.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Enum = void 0;
+const static_1 = require("./static");
+const Enum = (value) => {
+    return (target, key) => {
+        (0, static_1.Static)(() => new target(value))(target, key);
+    };
+};
+exports.Enum = Enum;

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

@@ -1,5 +1,5 @@
 export * from "./prop";
-export * from "./name";
-export * from "./validate";
-export * from "./model";
+export * from "./model-name";
+export * from "./validator";
 export * from "./static";
+export * from "./enum";

package/dist/decorators/model/index.js

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

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

@@ -0,0 +1,2 @@
+import { ModelClass } from "../../core/index";
+export declare const ModelName: (name?: string) => <T extends ModelClass<import("../../core/index").AnyModel>>(target: T) => void;

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelName = void 0;
+const _meta_1 = require("../../meta/index");
+const ModelName = (name) => {
+    return (target) => {
+        (0, _meta_1.setModelName)(target, name);
+    };
+};
+exports.ModelName = ModelName;

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

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

package/dist/decorators/model/prop.js

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Prop = void 0;
 const _meta_1 = require("../../meta/index");
-const Prop = (target, propKey) => {
-    (0, _meta_1.setPropKey)(target, propKey);
+const Prop = (propKey) => {
+    return (target, key) => {
+        (0, _meta_1.setProp)(target, key, propKey !== null && propKey !== void 0 ? propKey : key);
+    };
 };
 exports.Prop = Prop;

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

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

package/dist/decorators/model/static.js

@@ -1,37 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Static = void 0;
-const static_values_1 = require("./helpers/static-values");
-// Lazy builder for static value (value of static prop is an instance of that model)
+const _meta_1 = require("../../meta/index");
 const Static = (builder) => {
     return (target, key) => {
-        const STATIC_VALUES_KEY = target.STATIC_VALUES_KEY;
-        const typedTarget = target;
-        let staticValues = typedTarget[STATIC_VALUES_KEY];
-        if (!staticValues || staticValues.target !== target) {
-            Object.defineProperty(target, STATIC_VALUES_KEY, {
-                configurable: false,
-                enumerable: false,
-                writable: false,
-                value: new static_values_1.StaticValues(target),
-            });
-            staticValues = typedTarget[STATIC_VALUES_KEY];
-        }
-        staticValues.setValue(key, builder);
+        (0, _meta_1.setStaticValue)(target, key, builder);
         Object.defineProperty(target, key, {
             configurable: false,
             enumerable: true,
             get() {
-                let loopTarget = typedTarget;
-                do {
-                    const sValues = loopTarget[STATIC_VALUES_KEY];
-                    if (!sValues)
-                        return undefined;
-                    if (sValues.hasValueOf(key))
-                        return sValues.getValue(key);
-                    loopTarget = Reflect.getPrototypeOf(loopTarget);
-                } while (loopTarget !== null);
-                return undefined;
+                return (0, _meta_1.getStaticValue)(target, key);
+            },
+            set() {
+                throw new Error("Static value is readonly");
             },
         });
     };

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

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

package/dist/decorators/model/{validate.js → validator.js}

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

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

@@ -0,0 +1 @@
+export * from "./static-value";

package/dist/meta/helpers/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("./static-value"), exports);

package/dist/meta/helpers/static-value.d.ts

@@ -0,0 +1,7 @@
+import { AnyModel } from "../../core/index";
+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;
+}

package/dist/meta/helpers/static-value.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;

package/dist/meta/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./helpers";
 export * from "./aggregate.metadata";
 export * from "./id.metadata";
 export * from "./model.metadata";

package/dist/meta/index.js

@@ -14,6 +14,7 @@ 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("./id.metadata"), exports);
 __exportStar(require("./model.metadata"), exports);

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

@@ -1,13 +1,15 @@
-import { AnyModel, PropsOf } from "../core/index";
-export declare const getPropKeySet: (target: object | null) => Set<string | symbol>;
-export declare const setPropKey: (target: object, propKey: string) => void;
-export declare const setModelName: (target: object, name: string) => void;
-export declare const getModelName: (target: object) => string;
+import { AnyModel, ModelClass, PropKey, PropsOf } from "../core/index";
+import { StaticValue, StaticValueBuilder } from "./helpers/static-value";
+export declare class PropsMap<T extends AnyModel = AnyModel> extends Map<PropKey, keyof PropsOf<T>> {
+}
+export declare const getOwnPropsMap: <T extends AnyModel = AnyModel>(target: T) => PropsMap<T>;
+export declare const setProp: <T extends AnyModel = AnyModel>(target: T, key: PropKey, targetPropKey?: keyof PropsOf<T> | undefined) => void;
+export declare const getPropsMap: <T extends AnyModel = AnyModel>(target: T) => PropsMap<T>;
+export declare const setModelName: <T extends AnyModel>(target: ModelClass<T>, name?: string) => void;
+export declare const getModelName: <T extends AnyModel>(target: ModelClass<T>) => string;
 export type PropsValidator<T extends AnyModel = AnyModel> = (props: PropsOf<T>) => void;
-export declare const setValidateProps: <T extends AnyModel>(target: object, validator: PropsValidator<T>) => void;
-export declare const getValidateProps: <T extends AnyModel>(target: object) => PropsValidator<T> | undefined;
-export type ModelMetadata<T extends AnyModel = AnyModel> = {
-    name: string;
-    validator?: PropsValidator<T>;
-};
-export declare const getModelMetadata: <T extends AnyModel = AnyModel>(target: object) => ModelMetadata<T>;
+export declare const setPropsValidator: <T extends AnyModel>(target: object, validator: PropsValidator<T>) => void;
+export declare const getPropsValidator: <T extends AnyModel>(target: object) => PropsValidator<T> | undefined;
+export declare const getOwnStaticValues: <T extends AnyModel>(target: object) => Map<string | symbol, StaticValue<T>>;
+export declare const setStaticValue: <T extends AnyModel>(target: object, key: string, value: T | StaticValueBuilder<T>) => void;
+export declare const getStaticValue: (target: object, key: string | symbol) => AnyModel | undefined;

package/dist/meta/model.metadata.js

@@ -1,46 +1,97 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getModelMetadata = exports.getValidateProps = exports.setValidateProps = exports.getModelName = exports.setModelName = exports.setPropKey = exports.getPropKeySet = void 0;
-const PropMetaKey = Symbol.for("PROP");
-const getPropKeySet = (target) => {
-    var _a;
-    if (!target)
-        return new Set();
-    return (_a = Reflect.getMetadata(PropMetaKey, target)) !== null && _a !== void 0 ? _a : new Set();
+exports.getStaticValue = exports.setStaticValue = exports.getOwnStaticValues = exports.getPropsValidator = exports.setPropsValidator = exports.getModelName = exports.setModelName = exports.getPropsMap = exports.setProp = exports.getOwnPropsMap = exports.PropsMap = void 0;
+const _core_1 = require("../core/index");
+const static_value_1 = require("./helpers/static-value");
+const OwnPropsMapMetaKey = Symbol.for("OWN_PROPS_MAP");
+// Prop keys map is a Map<Key, TargetPropKey>;
+class PropsMap extends Map {
+}
+exports.PropsMap = PropsMap;
+// target is prototype
+const getOwnPropsMap = (target) => {
+    const ownPropsMap = () => Reflect.getOwnMetadata(OwnPropsMapMetaKey, target);
+    if (!ownPropsMap())
+        Reflect.defineMetadata(OwnPropsMapMetaKey, new PropsMap(), target);
+    return ownPropsMap();
+};
+exports.getOwnPropsMap = getOwnPropsMap;
+const setProp = (target, key, targetPropKey) => {
+    const ownPropsMap = (0, exports.getOwnPropsMap)(target);
+    if (targetPropKey)
+        ownPropsMap.set(key, targetPropKey);
 };
-exports.getPropKeySet = getPropKeySet;
-const setPropKey = (target, propKey) => {
-    const propKeySet = (0, exports.getPropKeySet)(target);
-    propKeySet.add(propKey);
-    Reflect.defineMetadata(PropMetaKey, propKeySet, target);
+exports.setProp = setProp;
+const PropsMapMetaKey = Symbol.for("PROPS_MAP");
+const getPropsMap = (target) => {
+    const propsMap = () => Reflect.getOwnMetadata(PropsMapMetaKey, target);
+    if (propsMap())
+        return propsMap();
+    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 propsMap();
 };
-exports.setPropKey = setPropKey;
+exports.getPropsMap = getPropsMap;
 //
 const ModelNameMetaKey = Symbol.for("MODEL_NAME");
 const setModelName = (target, name) => {
-    Reflect.defineMetadata(ModelNameMetaKey, name, target);
+    Reflect.defineMetadata(ModelNameMetaKey, name !== null && name !== void 0 ? name : target.name, target);
 };
 exports.setModelName = setModelName;
 const getModelName = (target) => {
-    const modelName = Reflect.getMetadata(ModelNameMetaKey, target);
-    if (!modelName)
-        throw new Error();
-    return modelName;
+    const modelName = () => Reflect.getMetadata(ModelNameMetaKey, target);
+    if (!modelName())
+        (0, exports.setModelName)(target);
+    return modelName();
 };
 exports.getModelName = getModelName;
-const ValidatePropsMetaKey = Symbol.for("VALIDATE_PROPS");
-const setValidateProps = (target, validator) => {
-    Reflect.defineMetadata(ValidatePropsMetaKey, validator, target);
-};
-exports.setValidateProps = setValidateProps;
-const getValidateProps = (target) => {
-    return Reflect.getMetadata(ValidatePropsMetaKey, target);
-};
-exports.getValidateProps = getValidateProps;
-const getModelMetadata = (target) => {
-    return {
-        name: (0, exports.getModelName)(target),
-        validator: (0, exports.getValidateProps)(target),
-    };
+const PropsValidatorMetaKey = Symbol.for("PROPS_VALIDATOR");
+const setPropsValidator = (target, validator) => {
+    Reflect.defineMetadata(PropsValidatorMetaKey, validator, target);
+};
+exports.setPropsValidator = setPropsValidator;
+const getPropsValidator = (target) => {
+    return Reflect.getMetadata(PropsValidatorMetaKey, target);
+};
+exports.getPropsValidator = getPropsValidator;
+//
+const OwnStaticValuesMetaKey = Symbol.for("OWN_STATIC_VALUES");
+const getOwnStaticValues = (target) => {
+    const ownStaticValues = () => Reflect.getOwnMetadata(OwnStaticValuesMetaKey, target);
+    if (!ownStaticValues())
+        Reflect.defineMetadata(OwnStaticValuesMetaKey, new Map(), target);
+    return ownStaticValues();
+};
+exports.getOwnStaticValues = getOwnStaticValues;
+const setStaticValue = (target, key, value) => {
+    const staticValues = (0, exports.getOwnStaticValues)(target);
+    staticValues.set(key, new static_value_1.StaticValue(value));
+};
+exports.setStaticValue = setStaticValue;
+const getStaticValue = (target, key) => {
+    var _a;
+    let _target = target;
+    do {
+        const staticValues = (0, exports.getOwnStaticValues)(_target);
+        if (staticValues.has(key))
+            return (_a = staticValues.get(key)) === null || _a === void 0 ? void 0 : _a.value;
+        _target = Reflect.getPrototypeOf(_target);
+    } while (_target !== null);
+    return undefined;
 };
-exports.getModelMetadata = getModelMetadata;
+exports.getStaticValue = getStaticValue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ddd-node",
-  "version": "13.0.0-0",
+  "version": "13.0.0",
   "description": "Domain Driven Design base for NodeJs",
   "main": "dist/index.js",
   "scripts": {

package/dist/decorators/model/helpers/static-values.d.ts

@@ -1,12 +0,0 @@
-import { AnyModel, ModelClass } from "../../../core/index";
-import { StaticValueBuilder } from "../types/static-value-builder";
-export declare class StaticValues<T extends AnyModel> {
-    private readonly _target;
-    private readonly _values;
-    constructor(target: ModelClass<T>);
-    get target(): ModelClass<T>;
-    get values(): Map<string | symbol, T | StaticValueBuilder<T>>;
-    getValue(key: string | symbol): T | StaticValueBuilder<T> | undefined;
-    setValue(key: string | symbol, value: T | StaticValueBuilder<T>): void;
-    hasValueOf(key: string | symbol): boolean;
-}

package/dist/decorators/model/helpers/static-values.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StaticValues = void 0;
-class StaticValues {
-    constructor(target) {
-        this._target = target;
-        this._values = new Map();
-    }
-    get target() {
-        return this._target;
-    }
-    get values() {
-        return this._values;
-    }
-    getValue(key) {
-        const valueOrBulider = this._values.get(key);
-        if (typeof valueOrBulider === "function") {
-            const value = valueOrBulider();
-            this.setValue(key, value);
-        }
-        return this._values.get(key);
-    }
-    setValue(key, value) {
-        this._values.set(key, value);
-    }
-    hasValueOf(key) {
-        return this._values.has(key);
-    }
-}
-exports.StaticValues = StaticValues;

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

@@ -1,10 +0,0 @@
-import { AnyModel, ModelClass } from "../../core/index";
-import { PropsValidator } from "../../meta/index";
-import { TypedClassDecorator } from "../type";
-export type ModelOptions<T extends AnyModel> = {
-    name?: string;
-    validator?: PropsValidator<T>;
-};
-export declare function Model<T extends ModelClass, I extends InstanceType<T> = InstanceType<T>>(options?: ModelOptions<I>): TypedClassDecorator<T>;
-export declare function Model<T extends ModelClass, I extends InstanceType<T> = InstanceType<T>>(name?: string, validator?: PropsValidator<I>): TypedClassDecorator<T>;
-export declare function Model<T extends ModelClass, I extends InstanceType<T> = InstanceType<T>>(name?: string, options?: Omit<ModelOptions<I>, "name">): TypedClassDecorator<T>;

package/dist/decorators/model/model.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Model = void 0;
-const model_1 = require("../model");
-function Model(p1, p2) {
-    return (target) => {
-        let options = {};
-        if (p1 && !p2) {
-            if (typeof p1 === "string")
-                options = { name: p1 };
-            else
-                options = p1;
-        }
-        else if (p1 && p2) {
-            p1 = p1;
-            if (typeof p2 === "function")
-                options = { name: p1, validator: p2 };
-            else
-                options = Object.assign({ name: p1 }, p2);
-        }
-        const { name, validator } = options;
-        (0, model_1.Name)(name)(target);
-        (0, model_1.Validate)(validator)(target);
-    };
-}
-exports.Model = Model;

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

@@ -1,2 +0,0 @@
-import { AnyModel, ModelClass } from "../../core/index";
-export declare const Name: (name?: string) => <T extends AnyModel>(target: ModelClass<T>) => void;

package/dist/decorators/model/name.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Name = void 0;
-const _meta_1 = require("../../meta/index");
-const Name = (name) => {
-    return (target) => {
-        (0, _meta_1.setModelName)(target, name !== null && name !== void 0 ? name : target.name);
-    };
-};
-exports.Name = Name;

package/dist/decorators/model/types/static-typed-target.d.ts

@@ -1,5 +0,0 @@
-import { ModelBase, ModelClass } from "../../../core/index";
-import { StaticValues } from "../helpers/static-values";
-export type StaticTypedTarget<T extends ModelClass = ModelClass, I extends InstanceType<T> = InstanceType<T>> = T & {
-    [ModelBase.STATIC_VALUES_KEY]?: StaticValues<I>;
-};

package/dist/decorators/model/types/static-typed-target.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const _core_1 = require("../../../core/index");

package/dist/decorators/model/types/static-value-builder.d.ts

@@ -1,2 +0,0 @@
-import { AnyModel } from "../../../core/index";
-export type StaticValueBuilder<T extends AnyModel> = () => T;

package/dist/decorators/model/types/static-value-builder.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

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