ddd-node 13.0.0-0 → 14.0.0

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

@@ -1,13 +1,18 @@
+import { ClassStatic } from "../../types";
 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 interface CommandMetadata extends Omit<MessageMetadata, "messageType"> {
 }
-export declare abstract class CommandBase<Props extends object> extends MessageBase<Props> {
-    constructor(metadata: CommandMetadata, props: Props);
-    static newCommand<T extends AnyCommand>(this: CommandClassWithTypedConstructor<T>, props: PropsOf<T>, context?: MessageContext): T;
+export declare class CommandBase<P extends Props> extends MessageBase<P> {
+    static readonly COMMAND_MESSAGE_TYPE = "command";
+    private _commandType;
+    constructor(metadata: CommandMetadata, props: P);
+    static newCommand<T extends AnyCommand>(this: CommandClassWithTypedConstructor<T>, props: PropsOf<T>, context?: MessageContext, timestamp?: number): T;
+    getCommandType(): void;
+}
+export type AnyCommand = CommandBase<Props>;
+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>>>> {
 }
-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>>>>;

package/dist/core/message/command.js

@@ -1,17 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommandBase = void 0;
-const message_1 = require("./message");
-class CommandBase extends message_1.MessageBase {
+import { MessageBase } from "./message";
+export class CommandBase extends MessageBase {
     constructor(metadata, props) {
-        super(metadata, props);
+        super({ ...metadata, messageType: CommandBase.COMMAND_MESSAGE_TYPE }, props);
+        this._commandType = this.modelName();
     }
-    static newCommand(props, context) {
+    static newCommand(props, context, timestamp) {
         return new this({
             id: this.id(),
-            timestamp: Date.now(),
             context,
+            timestamp,
         }, props);
     }
+    getCommandType() {
+        this._commandType;
+    }
 }
-exports.CommandBase = CommandBase;
+CommandBase.COMMAND_MESSAGE_TYPE = "command";

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

@@ -1,27 +1,31 @@
+import { ClassStatic } from "../../types";
 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;
     version: number;
 }>;
-export interface EventMetadata extends MessageMetadata {
+export interface EventMetadata extends Omit<MessageMetadata, "messageType"> {
     source: EventSource;
 }
-export declare abstract class EventBase<Props extends object, Raw = any> extends MessageBase<Props> {
+export declare class EventBase<P extends Props> extends MessageBase<P> {
+    static readonly EVENT_MESSAGE_TYPE = "event";
     private readonly _source;
-    constructor(metadata: EventMetadata, props: Props);
-    static newEvent<T extends AnyEvent>(this: EventClassWithTypedConstructor<T>, source: EventSource, props: PropsOf<T>, context?: MessageContext): T;
+    private readonly _eventType;
+    constructor(metadata: EventMetadata, props: P);
+    static newEvent<T extends AnyEvent>(this: EventClassWithTypedConstructor<T>, source: EventSource, props: PropsOf<T>, context?: MessageContext, timestamp?: number): T;
     getSource(): Readonly<{
         aggregate: string;
-        id: Id;
+        id: Id<any>;
         version: number;
     }>;
-    getRaw(): Raw | null;
+    getEventType(): string;
+}
+export type AnyEvent = EventBase<Props>;
+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>>>> {
 }
-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>>>>;

package/dist/core/message/event.js

@@ -1,25 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventBase = void 0;
-const message_1 = require("./message");
-class EventBase extends message_1.MessageBase {
+import { MessageBase } from "./message";
+export class EventBase extends MessageBase {
     constructor(metadata, props) {
-        super(metadata, props);
+        super({ ...metadata, messageType: EventBase.EVENT_MESSAGE_TYPE }, props);
         this._source = metadata.source;
+        this._eventType = this.modelName();
     }
-    static newEvent(source, props, context) {
+    static newEvent(source, props, context, timestamp) {
         return new this({
             id: this.id(),
-            timestamp: Date.now(),
             source,
             context,
+            timestamp,
         }, props);
     }
     getSource() {
         return this._source;
     }
-    getRaw() {
-        return null;
+    getEventType() {
+        return this._eventType;
     }
 }
-exports.EventBase = EventBase;
+EventBase.EVENT_MESSAGE_TYPE = "event";

package/dist/core/message/index.js

@@ -1,19 +1,3 @@
-"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("./message"), exports);
-__exportStar(require("./command"), exports);
-__exportStar(require("./event"), exports);
+export * from "./message";
+export * from "./command";
+export * from "./event";

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

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

package/dist/core/message/message.js

@@ -1,19 +1,19 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageBase = void 0;
-const lodash_1 = __importDefault(require("lodash"));
-const model_1 = require("../model");
-class MessageBase extends model_1.ModelWithId {
+import _ from "lodash";
+import { ModelWithId } from "../model";
+export class MessageBase extends ModelWithId {
     constructor(metadata, props) {
-        var _a;
         super(metadata.id);
-        this._timestamp = metadata.timestamp;
-        this._context = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.context) !== null && _a !== void 0 ? _a : {};
+        this._messageType = metadata.messageType;
+        this._context = metadata?.context ?? {};
+        this._timestamp = metadata.timestamp ?? Date.now();
         this.initializeProps(props);
     }
+    props() {
+        return super.props();
+    }
+    getMessageType() {
+        return this._messageType;
+    }
     getTimestamp() {
         return this._timestamp;
     }
@@ -21,7 +21,6 @@ class MessageBase extends model_1.ModelWithId {
         return this._context;
     }
     setContext(context) {
-        this._context = lodash_1.default.merge(this._context, context);
+        this._context = _.merge(this._context, context);
     }
 }
-exports.MessageBase = MessageBase;

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

@@ -0,0 +1,3 @@
+export declare class PropsInitializedError extends Error {
+    constructor();
+}

package/dist/core/model/errors.js

@@ -0,0 +1,5 @@
+export class PropsInitializedError extends Error {
+    constructor() {
+        super("Props is initialized");
+    }
+}

package/dist/core/model/index.js

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

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

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

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

@@ -1,22 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModelWithId = void 0;
-const _meta_1 = require("../../meta/index");
-const id_1 = require("../id");
-const model_1 = require("./model");
-class ModelWithId extends model_1.ModelBase {
+import { getIdService } from "../../meta";
+import { Id } from "../id";
+import { ModelBase } from "./model";
+export class ModelWithId extends ModelBase {
     constructor(id) {
         super();
         this._id = id;
     }
-    static getIdGenerator() {
-        return (0, _meta_1.getIdGenerator)(this) || new id_1.Uuid4Generator();
+    static idService() {
+        return getIdService(this);
     }
     static id(id) {
-        const generator = this.getIdGenerator();
-        return id ? generator.fromId(id) : generator.newId();
+        const idService = this.idService();
+        return new Id(idService, id);
     }
-    getId() {
+    id() {
         return this._id;
     }
     hasId(id) {
@@ -26,4 +23,3 @@ class ModelWithId extends model_1.ModelBase {
         return this._id.value;
     }
 }
-exports.ModelWithId = ModelWithId;

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

@@ -1,26 +1,37 @@
-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__";
-    static readonly EMPTY_PROPS: {};
-    private _metadata;
-    private _propKeys;
-    protected _props: Props;
-    static isMutable(): boolean;
+import { ClassStatic } from "../../types";
+export type PropKey = string | symbol;
+export interface Props {
+    [key: PropKey]: any;
+}
+export type EmptyProps = {
+    [key: PropKey]: never;
+};
+export declare class ModelBase<P extends Props> {
+    static readonly EMPTY_PROPS: EmptyProps;
+    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").PropsValidator<T> | undefined;
+    static ownStaticValues<T extends AnyModel>(this: ModelClass<T>): Map<string | symbol, import("../../meta").StaticValue<T>>;
+    static ownPropsMap(): import("../../meta").PropsMap<ModelBase<any>>;
+    static propsMap(): import("../../meta").PropsMap<ModelBase<any>>;
     constructor();
     private redefineModel;
+    protected get currentModelType(): ModelClass<this>;
     isMutable(): boolean;
-    getPropKeys(): Set<string | symbol>;
-    validateProps(props: Props): void;
-    validate(): void;
-    getModelMetadata(): ModelMetadata<this>;
     modelName(): string;
-    props(): any;
-    protected initializeProps(props: Props): void;
+    propsValidator(): import("../../meta").PropsValidator<this> | undefined;
+    ownPropsMap(): import("../../meta").PropsMap<ModelBase<any>>;
+    propsMap(): import("../../meta").PropsMap<any>;
+    validateProps(props: P): void;
+    validate(): void;
+    propsIsEmpty(): boolean;
+    props(): P | null;
+    protected initializeProps(props: P): void;
+}
+export type AnyModel = ModelBase<Props>;
+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 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 EmptyProps = {};

package/dist/core/model/model.js

@@ -1,65 +1,76 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModelBase = void 0;
-const _meta_1 = require("../../meta/index");
-const lodash_1 = __importDefault(require("lodash"));
-class ModelBase {
-    static isMutable() {
-        return false;
-    }
+import _ from "lodash";
+import { getModelName, getOwnPropsMap, getOwnStaticValues, getPropsMap, getPropsValidator, } from "../../meta";
+import { PropsInitializedError } from "./errors";
+export class ModelBase {
     static isModel(model) {
         return model instanceof ModelBase;
     }
+    static mutable() {
+        return false;
+    }
+    static modelName() {
+        return getModelName(this);
+    }
+    static propsValidator() {
+        return getPropsValidator(this);
+    }
+    static ownStaticValues() {
+        return getOwnStaticValues(this);
+    }
+    static ownPropsMap() {
+        return getOwnPropsMap(this.prototype);
+    }
+    static propsMap() {
+        return 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];
-                },
-                set() {
-                    throw new Error(`Prop "${propKey.toString()}" cannot be set directly`);
+                    return this._props?.[propKeyTarget];
                 },
             });
         });
     }
+    get currentModelType() {
+        return this.constructor;
+    }
     isMutable() {
-        return this.constructor.isMutable();
+        return this.currentModelType.mutable();
     }
-    getPropKeys() {
-        if (!this._propKeys) {
-            this._propKeys = (0, _meta_1.getPropKeySet)(Reflect.getPrototypeOf(this));
-        }
-        return this._propKeys;
+    modelName() {
+        return this.currentModelType.modelName();
+    }
+    propsValidator() {
+        return this.currentModelType.propsValidator();
+    }
+    ownPropsMap() {
+        return this.currentModelType.ownPropsMap();
+    }
+    propsMap() {
+        return getPropsMap(Reflect.getPrototypeOf(this));
     }
     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;
+    propsIsEmpty() {
+        return this._props === ModelBase.EMPTY_PROPS;
     }
     props() {
-        return lodash_1.default.cloneDeepWith(this._props, (value) => {
+        if (this.propsIsEmpty())
+            return null;
+        return _.cloneDeepWith(this._props, (value) => {
             if (ModelBase.isModel(value)) {
                 value.redefineModel();
                 return value;
@@ -67,8 +78,8 @@ class ModelBase {
         });
     }
     initializeProps(props) {
-        if (this._props !== ModelBase.EMPTY_PROPS)
-            throw new Error("Props is initialized");
+        if (!this.propsIsEmpty())
+            throw new PropsInitializedError();
         if (!this.isMutable()) {
             this._props = props;
             Object.freeze(this._props);
@@ -85,6 +96,4 @@ class ModelBase {
         this.validate();
     }
 }
-exports.ModelBase = ModelBase;
-ModelBase.STATIC_VALUES_KEY = "__STATIC_VALUES__";
 ModelBase.EMPTY_PROPS = {};

package/dist/core/repository.d.ts

@@ -1,6 +1,6 @@
-import { AnyAggregate, AnyAggregateES } from "./aggregate";
+import { AnyAggregate } from "./aggregate";
 import { Id } from "./id";
-export interface IRepository<T extends AnyAggregate | AnyAggregateES> {
+export interface IRepository<T extends AnyAggregate> {
     findById(id: Id): Promise<T | null>;
     save(instance: T): Promise<any>;
 }

package/dist/core/repository.js

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

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

@@ -1,11 +1,14 @@
 import { Class } from "type-fest";
-import { ModelBase, PropsOf } from "./model";
-import { ClassStatic } from "../types/index";
-export declare abstract class ValueObjectBase<Props extends object> extends ModelBase<Props> {
-    constructor(props: Props);
+import { ModelBase, Props, PropsOf } from "./model";
+import { ClassStatic } from "../types";
+export declare class ValueObjectBase<P extends Props> extends ModelBase<P> {
+    constructor(props: P);
+    props(): P;
     equals<V extends AnyValueObject>(vo: V): boolean;
-    with(props: Partial<Props>): this;
+    with(props: Partial<P>): this;
+}
+export type AnyValueObject = ValueObjectBase<Props>;
+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>>>> {
 }
-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>>>>;

package/dist/core/value-object.js

@@ -1,24 +1,20 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueObjectBase = void 0;
-const lodash_1 = __importDefault(require("lodash"));
-const model_1 = require("./model");
-class ValueObjectBase extends model_1.ModelBase {
+import _ from "lodash";
+import { ModelBase } from "./model";
+export class ValueObjectBase extends ModelBase {
     constructor(props) {
         super();
         this.initializeProps(props);
     }
+    props() {
+        return super.props();
+    }
     equals(vo) {
         const equalsType = vo instanceof this.constructor;
-        const equalsValue = JSON.stringify(vo) === JSON.stringify(this);
+        const equalsValue = JSON.stringify(vo.props()) === JSON.stringify(this.props());
         return equalsType && equalsValue;
     }
     with(props) {
-        const newProps = lodash_1.default.merge(this.props(), props);
+        const newProps = _.merge(this.props(), props);
         return new this.constructor(newProps);
     }
 }
-exports.ValueObjectBase = ValueObjectBase;

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

@@ -0,0 +1,2 @@
+import { AnyCommand, CommandClass, CommandHandler } from "../../core";
+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-es/handle.js

@@ -0,0 +1,9 @@
+import { defineCommandHandler, getModelName } from "../../meta";
+export const Handle = (commandClass) => {
+    return (target, propertyKey, descriptor) => {
+        if (typeof descriptor.value === "function") {
+            const commandName = getModelName(commandClass);
+            defineCommandHandler(target, commandName, descriptor.value);
+        }
+    };
+};

package/dist/decorators/aggregate-es/index.js

@@ -0,0 +1,2 @@
+export * from "./handle";
+export * from "./when";

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

@@ -0,0 +1,2 @@
+import { AnyEvent, EventApplier, EventClass } from "../../core";
+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/aggregate-es/when.js

@@ -0,0 +1,9 @@
+import { defineEventApplier, getModelName } from "../../meta";
+export const When = (eventClass) => {
+    return (target, propertyKey, descriptor) => {
+        if (typeof descriptor.value === "function") {
+            const eventName = getModelName(eventClass);
+            defineEventApplier(target, eventName, descriptor.value);
+        }
+    };
+};

package/dist/decorators/id.d.ts

@@ -1,2 +1,2 @@
-import { AnyModelWithId, IdGeneratorBase, ModelClass } from "../core/index";
-export declare const UseId: (generator: IdGeneratorBase) => <T extends AnyModelWithId>(target: ModelClass<T>) => void;
+import { AnyModelWithId, IIdService, ModelClass } from "../core";
+export declare const UseIdService: (idService: IIdService) => <T extends AnyModelWithId>(target: ModelClass<T>) => void;

package/dist/decorators/id.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UseId = void 0;
-const _meta_1 = require("../meta/index");
-const UseId = (generator) => {
+import { defineIdService } from "../meta";
+export const UseIdService = (idService) => {
     return (target) => {
-        (0, _meta_1.defineIdGenerator)(target, generator);
+        defineIdService(target, idService);
     };
 };
-exports.UseId = UseId;