ddd-node 29.2.0 → 29.4.0

package/dist/core/aggregate/event-sourced-aggregate/event-sourced-aggregate.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSourcedAggregateBase = void 0;
+const meta_1 = require("../../../meta");
+const utils_1 = require("../../../utils");
+const aggregate_base_1 = require("../aggregate-base");
+const _1 = require(".");
+class EventSourcedAggregateBase extends aggregate_base_1.AggregateBase {
+    static builder() {
+        return new _1.EventSourcedAggregateBuilder(this);
+    }
+    constructor(metadata, props) {
+        super(metadata, props);
+        this._handledCommands = [];
+        this._events = [];
+        this._pastEvents = [];
+    }
+    static ownEventApplierMap() {
+        return (0, meta_1.getOwnEventApplierMap)(this.prototype);
+    }
+    static eventApplierMap() {
+        return (0, meta_1.getEventApplierMap)(this.prototype);
+    }
+    static ownCommandHandlerMap() {
+        return (0, meta_1.getOwnCommandHandlerMap)(this.prototype);
+    }
+    static commandHandlerMap() {
+        return (0, meta_1.getCommandHandlerMap)(this.prototype);
+    }
+    modelDescriptor() {
+        const aggregateClass = this.constructor;
+        return {
+            ...super.modelDescriptor(),
+            ownEventApplierMap: aggregateClass.ownEventApplierMap(),
+            eventApplierMap: aggregateClass.eventApplierMap(),
+            ownCommandHandlerMap: aggregateClass.ownCommandHandlerMap(),
+            commandHandlerMap: aggregateClass.commandHandlerMap(),
+        };
+    }
+    version() {
+        return this._version + this._pastEvents.length + this._events.length;
+    }
+    pastEvents() {
+        return Array.from(this._pastEvents);
+    }
+    events() {
+        return Array.from(this._events);
+    }
+    handledCommands() {
+        return Array.from(this._handledCommands);
+    }
+    hasNewEvent() {
+        return Boolean(this._events.length);
+    }
+    getEventApplier(event) {
+        const { eventType } = event.modelDescriptor();
+        const { eventApplierMap } = this.modelDescriptor();
+        const applier = eventApplierMap.get(eventType);
+        if (!applier)
+            throw new Error("Event applier not found");
+        return applier;
+    }
+    validateEventBeforeApply(event) {
+        const { aggregateId, aggregateVersion } = event.source();
+        if (aggregateId !== this._id)
+            throw new Error("Invalid aggregate id");
+        if (aggregateVersion !== this.version())
+            throw new Error("Invalid aggregate version");
+    }
+    _applyEvent(event) {
+        const applier = this.getEventApplier(event);
+        this.validateEventBeforeApply(event);
+        applier.call(this, event);
+    }
+    applyPastEvent(event) {
+        if (this.hasNewEvent())
+            throw new Error("Cannot apply a past event when new event is recorded");
+        this._applyEvent(event);
+        this._pastEvents.push(event);
+    }
+    applyPastEvents(pastEvents) {
+        pastEvents.forEach((pastEvent) => {
+            this.applyPastEvent(pastEvent);
+        });
+    }
+    applyEvent(event) {
+        this._applyEvent(event);
+        this._events.push(event);
+    }
+    applyEvents(events) {
+        events.forEach((event) => {
+            this.applyEvent(event);
+        });
+    }
+    applyNewEvent(eventClass, props) {
+        this.applyEvent(this.newEvent(eventClass, props));
+    }
+    getCommandHandler(command) {
+        const { commandType } = command.modelDescriptor();
+        const { commandHandlerMap } = this.modelDescriptor();
+        const handler = commandHandlerMap.get(commandType);
+        if (!handler)
+            throw new Error("Command handler not found");
+        return handler;
+    }
+    handleCommand(command) {
+        const handler = this.getCommandHandler(command);
+        const events = (0, utils_1.toArray)(handler.call(this, command));
+        events.forEach((event) => {
+            event.setCausationId(command.id());
+            event.setCorrelationIds(command.correlationIds());
+        });
+        this.applyEvents(events);
+        this._handledCommands.push(command);
+        return events;
+    }
+    snapMetadata() {
+        return {
+            id: this.id(),
+            version: this.version(),
+        };
+    }
+    snap() {
+        if (this.propsIsEmpty())
+            throw new Error("Cannot create snapshot when the props is not initialized");
+        return {
+            metadata: this.snapMetadata(),
+            props: this.props(),
+        };
+    }
+    archiveEvents() {
+        const events = this.events();
+        this._events = [];
+        this._pastEvents.push(...events);
+    }
+    publishEvents(publisher) {
+        publisher.publish(this.events());
+        this.archiveEvents();
+    }
+}
+exports.EventSourcedAggregateBase = EventSourcedAggregateBase;

package/dist/core/aggregate/event-sourced-aggregate/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./event-sourced-aggregate";
+export * from "./event-sourced-aggregate.builder";

package/dist/core/aggregate/event-sourced-aggregate/index.js

@@ -0,0 +1,18 @@
+"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("./event-sourced-aggregate"), exports);
+__exportStar(require("./event-sourced-aggregate.builder"), exports);

package/dist/core/aggregate/event-sourced-aggregate/snapshot.d.ts

@@ -0,0 +1,8 @@
+import { InferredProps } from "../../../base";
+import { AnyEventSourcedAggregate, EventSourceAggregateMetadata } from "./event-sourced-aggregate";
+export interface SnapshotMetadata extends EventSourceAggregateMetadata {
+}
+export interface Snapshot<T extends AnyEventSourcedAggregate> {
+    metadata: SnapshotMetadata;
+    props: InferredProps<T>;
+}

package/dist/core/aggregate/event-sourced-aggregate/snapshot.js

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

package/dist/core/aggregate/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./aggregate-base";
+export * from "./state-aggregate";
+export * from "./event-sourced-aggregate";
+export * from "./types";

package/dist/core/aggregate/index.js

@@ -0,0 +1,20 @@
+"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("./aggregate-base"), exports);
+__exportStar(require("./state-aggregate"), exports);
+__exportStar(require("./event-sourced-aggregate"), exports);
+__exportStar(require("./types"), exports);

package/dist/core/aggregate/state-aggregate/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./state-aggregate";
+export * from "./state-aggregate.builder";

package/dist/core/aggregate/state-aggregate/index.js

@@ -0,0 +1,18 @@
+"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("./state-aggregate"), exports);
+__exportStar(require("./state-aggregate.builder"), exports);

package/dist/core/aggregate/state-aggregate/state-aggregate.builder.d.ts

@@ -0,0 +1,7 @@
+import { AggregateBuilderBase } from "../aggregate-base";
+import { AnyStateAggregate, StateAggregateClassWithTypedConstructor } from "./state-aggregate";
+export declare class StateAggregateBuilder<T extends AnyStateAggregate> extends AggregateBuilderBase<T> {
+    private aggregateClass;
+    constructor(aggregateClass: StateAggregateClassWithTypedConstructor<T>);
+    build(): T;
+}

package/dist/core/aggregate/state-aggregate/state-aggregate.builder.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateAggregateBuilder = void 0;
+const aggregate_base_1 = require("../aggregate-base");
+class StateAggregateBuilder extends aggregate_base_1.AggregateBuilderBase {
+    constructor(aggregateClass) {
+        super();
+        this.aggregateClass = aggregateClass;
+    }
+    build() {
+        if (!this.props)
+            throw new Error("The props must be set before build");
+        return new this.aggregateClass({
+            id: this.id,
+            version: this.version,
+        }, this.props);
+    }
+}
+exports.StateAggregateBuilder = StateAggregateBuilder;

package/dist/core/aggregate/state-aggregate/state-aggregate.d.ts

@@ -0,0 +1,25 @@
+import { Class } from "type-fest";
+import { Props, InferredProps } from "../../../base";
+import { ClassStatic } from "../../../types";
+import { AnyEvent, EventClassWithTypedConstructor } from "../../message";
+import { AggregateBase, AggregateMetadata, IAggregateEventPublisher } from "../aggregate-base";
+import { StateAggregateBuilder } from ".";
+export interface StateAggregateMetadata extends AggregateMetadata {
+}
+export declare class StateAggregateBase<P extends Props> extends AggregateBase<P> {
+    static builder<T extends AnyStateAggregate>(this: StateAggregateClass<T>): StateAggregateBuilder<T>;
+    private _events;
+    constructor(metadata: StateAggregateMetadata, props: P);
+    props(): P;
+    version(): number;
+    events(): AnyEvent[];
+    protected recordEvent<E extends AnyEvent>(event: E): void;
+    protected recordEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: InferredProps<E>): void;
+    clearEvents(): void;
+    publishEvents(publisher: IAggregateEventPublisher): void;
+}
+export type AnyStateAggregate = StateAggregateBase<Props>;
+export interface StateAggregateClass<T extends AnyStateAggregate = AnyStateAggregate, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof StateAggregateBase<InferredProps<T>>> {
+}
+export interface StateAggregateClassWithTypedConstructor<T extends AnyStateAggregate = AnyStateAggregate> extends StateAggregateClass<T, ConstructorParameters<typeof StateAggregateBase<InferredProps<T>>>> {
+}

package/dist/core/aggregate/state-aggregate/state-aggregate.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateAggregateBase = void 0;
+const aggregate_base_1 = require("../aggregate-base");
+const _1 = require(".");
+class StateAggregateBase extends aggregate_base_1.AggregateBase {
+    static builder() {
+        return new _1.StateAggregateBuilder(this);
+    }
+    constructor(metadata, props) {
+        super(metadata, props);
+        this._events = [];
+    }
+    props() {
+        return super.props();
+    }
+    version() {
+        return this._version;
+    }
+    events() {
+        return Array.from(this._events);
+    }
+    recordEvent(param1, param2) {
+        let event;
+        if (typeof param1 === "function" && param2) {
+            event = this.newEvent(param1, param2);
+        }
+        else {
+            event = param1;
+        }
+        this._events.push(event);
+    }
+    clearEvents() {
+        this._events = [];
+    }
+    publishEvents(publisher) {
+        publisher.publish(this.events());
+        this.clearEvents();
+    }
+}
+exports.StateAggregateBase = StateAggregateBase;

package/dist/core/aggregate/types.d.ts

@@ -0,0 +1,4 @@
+import { AnyEventSourcedAggregate, EventSourcedAggregateClass } from "./event-sourced-aggregate/event-sourced-aggregate";
+import { AnyStateAggregate, StateAggregateClass } from "./state-aggregate";
+export type Aggregate = AnyStateAggregate | AnyEventSourcedAggregate;
+export type AggregateClass = StateAggregateClass | EventSourcedAggregateClass;

package/dist/core/aggregate/types.js

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

package/dist/core/entity/entity.builder.d.ts

@@ -0,0 +1,7 @@
+import { ModelWithIdBuilder } from "../model-with-id";
+import { AnyEntity, EntityClassWithTypedConstructor } from "./entity";
+export declare class EntityBuilder<T extends AnyEntity> extends ModelWithIdBuilder<T> {
+    private entityClass;
+    constructor(entityClass: EntityClassWithTypedConstructor<T>);
+    build(): T;
+}

package/dist/core/entity/entity.builder.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityBuilder = void 0;
+const model_with_id_1 = require("../model-with-id");
+class EntityBuilder extends model_with_id_1.ModelWithIdBuilder {
+    constructor(entityClass) {
+        super();
+        this.entityClass = entityClass;
+    }
+    build() {
+        if (!this.props)
+            throw new Error("The props must be set before build");
+        return new this.entityClass({ id: this.id }, this.props);
+    }
+}
+exports.EntityBuilder = EntityBuilder;

package/dist/core/entity/entity.d.ts

@@ -0,0 +1,18 @@
+import { Class } from "type-fest";
+import { Props, InferredProps } from "../../base";
+import { ClassStatic } from "../../types";
+import { ModelWithId, ModelWithIdMetadata } from "../model-with-id";
+import { EntityBuilder } from ".";
+export interface EntityMetadata extends ModelWithIdMetadata {
+}
+export declare class EntityBase<P extends Props> extends ModelWithId<P> {
+    static builder<T extends AnyEntity>(this: EntityClass<T>): EntityBuilder<T>;
+    constructor(metadata: EntityMetadata, props: P);
+}
+export type AnyEntity = EntityBase<Props>;
+export interface EntityClass<T extends AnyEntity = AnyEntity, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof EntityBase<InferredProps<T>>> {
+}
+export interface EntityClassWithTypedConstructor<T extends AnyEntity = AnyEntity> extends EntityClass<T, ConstructorParameters<typeof EntityBase<InferredProps<T>>>> {
+}
+export interface EntityClassWithProps<P extends Props> extends EntityClass<EntityBase<P>> {
+}

package/dist/core/entity/entity.js

@@ -0,0 +1,29 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityBase = void 0;
+const base_1 = require("../../base");
+const model_with_id_1 = require("../model-with-id");
+const _1 = require(".");
+let EntityBase = class EntityBase extends model_with_id_1.ModelWithId {
+    static builder() {
+        return new _1.EntityBuilder(this);
+    }
+    constructor(metadata, props) {
+        super(metadata);
+        this.initializeProps(props);
+    }
+};
+exports.EntityBase = EntityBase;
+exports.EntityBase = EntityBase = __decorate([
+    (0, base_1.Mutable)(true),
+    __metadata("design:paramtypes", [Object, Object])
+], EntityBase);

package/dist/core/entity/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./entity";
+export * from "./entity.builder";

package/dist/core/entity/index.js

@@ -0,0 +1,18 @@
+"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("./entity"), exports);
+__exportStar(require("./entity.builder"), exports);

package/dist/core/enum/enum-builder.d.ts

@@ -0,0 +1,9 @@
+import { ModelBuilder } from "../../base";
+import { AnyEnum, EnumClass, EnumValue } from "./enum";
+export declare class EnumBuilder<T extends AnyEnum> extends ModelBuilder<T> {
+    private enumClass;
+    protected _value?: EnumValue;
+    constructor(enumClass: EnumClass<T>);
+    withValue(value: EnumValue): this;
+    build(): T;
+}

package/dist/core/enum/enum-builder.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumBuilder = void 0;
+const base_1 = require("../../base");
+class EnumBuilder extends base_1.ModelBuilder {
+    constructor(enumClass) {
+        super();
+        this.enumClass = enumClass;
+    }
+    withValue(value) {
+        this._value = value;
+        return this;
+    }
+    build() {
+        if (!this._value)
+            throw new Error("Cannot parse enum without value");
+        const { enumClass } = this;
+        let result;
+        enumClass.ownModelStaticValues().forEach((staticValue) => {
+            if (staticValue.value instanceof enumClass) {
+                const staticEnum = staticValue.value;
+                if (staticEnum.value === this._value && !result) {
+                    result = staticEnum;
+                }
+            }
+        });
+        if (!result)
+            throw new Error(`Invalid provided value for enum ${enumClass.modelName()}`);
+        return result;
+    }
+}
+exports.EnumBuilder = EnumBuilder;

package/dist/core/enum/enum.d.ts

@@ -0,0 +1,22 @@
+import { Class } from "type-fest";
+import { ModelBase } from "../../base";
+import { ClassStatic } from "../../types";
+import { EnumBuilder } from ".";
+export type EnumValue = string | number;
+export interface EnumProps {
+    value: EnumValue;
+}
+export declare class EnumBase extends ModelBase<EnumProps> {
+    static builder<T extends AnyEnum>(this: EnumClass<T>): EnumBuilder<T>;
+    static values(): EnumBase[];
+    static from<T extends AnyEnum>(this: EnumClass<T>, value: EnumValue): T;
+    static fromSafe<T extends AnyEnum>(this: EnumClass<T>, value: EnumValue): T | null;
+    constructor(value: EnumValue);
+    value: EnumValue;
+    valueOf(): EnumValue;
+}
+export type AnyEnum = EnumBase;
+export interface EnumClass<T extends AnyEnum = AnyEnum, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof EnumBase> {
+}
+export interface EnumClassWithTypedConstructor<T extends AnyEnum = AnyEnum> extends EnumClass<T, ConstructorParameters<typeof EnumBase>> {
+}

package/dist/core/enum/enum.js

@@ -0,0 +1,44 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumBase = void 0;
+const base_1 = require("../../base");
+const _1 = require(".");
+let EnumBase = class EnumBase extends base_1.ModelBase {
+    static builder() {
+        return new _1.EnumBuilder(this);
+    }
+    static values() {
+        return Array.from(this.ownModelStaticValues().values()).map((staticValue) => staticValue.value);
+    }
+    static from(value) {
+        return this.builder().withValue(value).build();
+    }
+    static fromSafe(value) {
+        return this.builder().withValue(value).buildSafe();
+    }
+    constructor(value) {
+        super();
+        this.initializeProps({ value });
+    }
+    valueOf() {
+        return this.value;
+    }
+};
+exports.EnumBase = EnumBase;
+__decorate([
+    (0, base_1.Prop)(),
+    __metadata("design:type", Object)
+], EnumBase.prototype, "value", void 0);
+exports.EnumBase = EnumBase = __decorate([
+    (0, base_1.Mutable)(false),
+    __metadata("design:paramtypes", [Object])
+], EnumBase);

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

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

package/dist/core/enum/index.js

@@ -0,0 +1,18 @@
+"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("./enum"), exports);
+__exportStar(require("./enum-builder"), exports);

package/dist/core/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./value-object";
+export * from "./enum";
+export * from "./model-with-id";
+export * from "./entity";
+export * from "./aggregate";
+export * from "./message";
+export * from "./repository";

package/dist/core/index.js

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

package/dist/core/message/command/command-model-descriptor.d.ts

@@ -0,0 +1,6 @@
+import { AnyCommand } from "./command";
+import { CommandType } from "../../../meta";
+import { ModelDescriptor } from "../../../base";
+export interface CommandModelDescriptor<T extends AnyCommand> extends ModelDescriptor<T> {
+    commandType: CommandType;
+}

package/dist/core/message/command/command-model-descriptor.js

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

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

@@ -0,0 +1,7 @@
+import { AnyCommand, CommandClassWithTypedConstructor } from "./command";
+import { MessageBuilderBase } from "../message-base";
+export declare class CommandBuilder<T extends AnyCommand> extends MessageBuilderBase<T> {
+    private commandClass;
+    constructor(commandClass: CommandClassWithTypedConstructor<T>);
+    build(): T;
+}

package/dist/core/message/command/command.builder.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandBuilder = void 0;
+const message_base_1 = require("../message-base");
+class CommandBuilder extends message_base_1.MessageBuilderBase {
+    constructor(commandClass) {
+        super();
+        this.commandClass = commandClass;
+    }
+    build() {
+        if (!this.props)
+            throw new Error("The props must be set before build");
+        return new this.commandClass({
+            id: this.id,
+            timestamp: this.timestamp,
+            causationId: this.causationId,
+            correlationIds: this.correlationIds,
+        }, this.props);
+    }
+}
+exports.CommandBuilder = CommandBuilder;