ddd-node 2.0.0

package/dist/base/aggregate.d.ts

@@ -0,0 +1,48 @@
+import { Class } from "../types/class";
+import { ClassStatic } from "../types/class-static";
+import { AnyCommand } from "./command";
+import { Entity, IEntityMetadata } from "./entity";
+import { AnyEvent, EventClass, IEventAggregate, NewEventMetadataOptions } from "./event";
+import { PropsOf } from "./props-envelope";
+export interface IAggregateMetadata extends IEntityMetadata {
+    readonly version: number;
+}
+export type NewAggregateMetadataOptions = Partial<Omit<IAggregateMetadata, "version">>;
+export declare class Aggregate<P extends object> extends Entity<P> implements IAggregateMetadata {
+    private readonly _version;
+    private handledCommands;
+    private pastEvents;
+    private events;
+    constructor(metadata: IAggregateMetadata, props?: P);
+    static agggregateType(): string;
+    static newAggregate<T extends AnyAggregate>(this: AggregateClass<T>, props?: PropsOf<T>, metadata?: NewAggregateMetadataOptions): T;
+    static loadAggregate<T extends AnyAggregate>(this: AggregateClass<T>, id: string, version: number, props: PropsOf<T>, pastEvents: AnyEvent[]): T;
+    get version(): number;
+    aggregateType(): string;
+    getHandledCommands(): AnyCommand[];
+    getPastEvents(): AnyEvent[];
+    getEvents(): AnyEvent[];
+    hasEvents(): boolean;
+    lastEvent(): AnyEvent | undefined;
+    lastEventVersion(): number;
+    nextEventVersion(): number;
+    nextEventAggregate(): IEventAggregate;
+    protected newEvent<E extends AnyEvent>(eventClass: EventClass<E>, props: PropsOf<E>, metadata?: NewEventMetadataOptions): E;
+    protected addEvent<E extends AnyEvent>(event: E): void;
+    protected addPastEvent<E extends AnyEvent>(event: E): void;
+    getEventApplier(eventType: string): AggregateEventApplier<AnyEvent> | null;
+    private validateEventBeforeApply;
+    applyEvent<E extends AnyEvent>(event: E, fromHistory?: boolean): void;
+    applyEvents(events: AnyEvent[], fromHistory?: boolean): void;
+    getCommandHandler(commandType: string): AggregateCommandHandler<AnyCommand> | null;
+    processCommand<C extends AnyCommand>(command: C): AnyEvent[];
+    processCommands(commands: AnyCommand[]): Record<string, AnyEvent[]>;
+}
+export type AnyAggregate = Aggregate<any>;
+export type AggregateEventApplier<E extends AnyEvent> = (event: E) => void;
+export type AggregateCommandHandler<C extends AnyCommand, E extends AnyEvent = AnyEvent> = (command: C) => E | E[];
+export type AggregateConstructorParamsWithProps<P extends object> = ConstructorParameters<typeof Aggregate<P>>;
+export type AggregateClassWithProps<P extends object> = Class<Aggregate<P>, AggregateConstructorParamsWithProps<P>> & ClassStatic<typeof Aggregate<P>>;
+export type AggregateConstructorParams<T extends AnyAggregate> = AggregateConstructorParamsWithProps<PropsOf<T>>;
+export type AggregateClass<T extends AnyAggregate> = Class<T, AggregateConstructorParams<T>> & ClassStatic<typeof Aggregate<PropsOf<T>>>;
+export type AnyAggregateClass = AggregateClass<AnyAggregate>;

package/dist/base/aggregate.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Aggregate = void 0;
+const aggregate_1 = require("../metadata/aggregate");
+const id_1 = require("../utils/id");
+const to_array_1 = require("../utils/to-array");
+const entity_1 = require("./entity");
+const aggregate_error_1 = require("./errors/aggregate.error");
+class Aggregate extends entity_1.Entity {
+    constructor(metadata, props) {
+        super({ id: metadata.id }, props);
+        this.handledCommands = [];
+        this.pastEvents = [];
+        this.events = [];
+        this._version = metadata.version;
+    }
+    static agggregateType() {
+        return (0, aggregate_1.getAggregateType)(this.prototype);
+    }
+    static newAggregate(props, metadata) {
+        return new this(Object.assign({ id: (0, id_1.generatePrefixedUUID)(this.agggregateType()), version: 0 }, metadata), props);
+    }
+    static loadAggregate(id, version, props, pastEvents) {
+        const aggregate = new this({ id, version }, props);
+        aggregate.applyEvents(pastEvents, true);
+        return aggregate;
+    }
+    get version() {
+        return this._version;
+    }
+    aggregateType() {
+        const prototype = Object.getPrototypeOf(this);
+        return (0, aggregate_1.getAggregateType)(prototype);
+    }
+    getHandledCommands() {
+        return this.handledCommands;
+    }
+    getPastEvents() {
+        return this.pastEvents;
+    }
+    getEvents() {
+        return this.events;
+    }
+    hasEvents() {
+        return Boolean(this.events.length);
+    }
+    lastEvent() {
+        return this.hasEvents() ? this.events.at(-1) : this.pastEvents.at(-1);
+    }
+    lastEventVersion() {
+        const lastEvent = this.lastEvent();
+        if (lastEvent)
+            return lastEvent.aggregate.version;
+        return this.version;
+    }
+    nextEventVersion() {
+        return this.lastEventVersion() + 1;
+    }
+    nextEventAggregate() {
+        return {
+            type: this.aggregateType(),
+            id: this.id,
+            version: this.nextEventVersion(),
+        };
+    }
+    newEvent(eventClass, props, metadata) {
+        return eventClass.newEvent(this.nextEventAggregate(), props, metadata);
+    }
+    addEvent(event) {
+        this.events.push(event);
+    }
+    addPastEvent(event) {
+        if (this.hasEvents())
+            throw new aggregate_error_1.PastEventCannotBeAddedError();
+        this.pastEvents.push(event);
+    }
+    getEventApplier(eventType) {
+        const prototype = Object.getPrototypeOf(this);
+        const eventApplier = (0, aggregate_1.getAggregateEventApplier)(prototype, eventType);
+        if (eventApplier)
+            return eventApplier.bind(this);
+        return null;
+    }
+    validateEventBeforeApply(event) {
+        const { type, id, version } = event.aggregate;
+        if (type !== this.aggregateType())
+            throw new aggregate_error_1.InvalidEventAggregateTypeError();
+        if (id !== this.id)
+            throw new aggregate_error_1.InvalidEventAggregateIdError();
+        if (version !== this.nextEventVersion())
+            throw new aggregate_error_1.InvalidEventAggregateVersionError();
+    }
+    applyEvent(event, fromHistory = false) {
+        const eventType = event.eventType();
+        const applier = this.getEventApplier(eventType);
+        if (!applier)
+            throw new aggregate_error_1.EventApplierNotFoundError(eventType);
+        this.validateEventBeforeApply(event);
+        if (fromHistory)
+            this.addPastEvent(event);
+        else
+            this.addEvent(event);
+        applier(event);
+    }
+    applyEvents(events, fromHistory = false) {
+        events.forEach((event) => {
+            this.applyEvent(event, fromHistory);
+        });
+    }
+    getCommandHandler(commandType) {
+        const prototype = Object.getPrototypeOf(this);
+        const commandHandler = (0, aggregate_1.getAggregateCommandHandler)(prototype, commandType);
+        if (commandHandler)
+            return commandHandler.bind(this);
+        return null;
+    }
+    processCommand(command) {
+        const commandType = command.commandType();
+        const handler = this.getCommandHandler(commandType);
+        if (!handler)
+            throw new aggregate_error_1.CommandHandlerNotFoundError(commandType);
+        const events = (0, to_array_1.toArray)(handler(command));
+        const { correlationId, causationId } = command;
+        events.forEach((event) => {
+            if (correlationId)
+                event.setCorrelationId(correlationId);
+            if (causationId)
+                event.setCausationId(causationId);
+            this.applyEvent(event);
+        });
+        this.handledCommands.push(command);
+        return events;
+    }
+    processCommands(commands) {
+        const result = {};
+        commands.forEach((command) => {
+            const events = this.processCommand(command);
+            result[command.id] = events;
+        });
+        return result;
+    }
+}
+exports.Aggregate = Aggregate;

package/dist/base/command.d.ts

@@ -0,0 +1,32 @@
+import { Class } from "../types/class";
+import { ClassStatic } from "../types/class-static";
+import { PropsEnvelope, PropsOf } from "./props-envelope";
+export interface ICommandMetadata {
+    readonly id: string;
+    readonly timestamp: number;
+    correlationId?: string;
+    causationId?: string;
+}
+export type NewCommandMetadataOptions = Partial<Omit<ICommandMetadata, "timestamp">>;
+export declare class Command<P extends object> extends PropsEnvelope<P> implements ICommandMetadata {
+    private readonly _id;
+    private readonly _timestamp;
+    private _correlationId?;
+    private _causationId?;
+    constructor(metadata: ICommandMetadata, props: P);
+    static commandType(): string;
+    static newCommand<T extends AnyCommand>(this: CommandClass<T>, props: PropsOf<T>, metadata?: NewCommandMetadataOptions): T;
+    get id(): string;
+    get timestamp(): number;
+    get correlationId(): string | undefined;
+    get causationId(): string | undefined;
+    setCorrelationId(correlationId: string): void;
+    setCausationId(causationId: string): void;
+    commandType(): string;
+}
+export type AnyCommand = Command<any>;
+export type CommandConstructorParamsWithProps<P extends object> = ConstructorParameters<typeof Command<P>>;
+export type CommandClassWithProps<P extends object> = Class<Command<P>, CommandConstructorParamsWithProps<P>> & ClassStatic<typeof Command<P>>;
+export type CommandConstructorParams<T extends AnyCommand> = CommandConstructorParamsWithProps<PropsOf<T>>;
+export type CommandClass<T extends AnyCommand> = Class<T, CommandConstructorParams<T>> & ClassStatic<typeof Command<PropsOf<T>>>;
+export type AnyCommandClass = CommandClass<AnyCommand>;

package/dist/base/command.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Command = void 0;
+const command_1 = require("../metadata/command");
+const id_1 = require("../utils/id");
+const props_envelope_1 = require("./props-envelope");
+class Command extends props_envelope_1.PropsEnvelope {
+    constructor(metadata, props) {
+        super(props);
+        this._id = metadata.id;
+        this._timestamp = metadata.timestamp;
+        this._correlationId = metadata === null || metadata === void 0 ? void 0 : metadata.correlationId;
+        this._causationId = metadata === null || metadata === void 0 ? void 0 : metadata.causationId;
+    }
+    static commandType() {
+        return (0, command_1.getCommandType)(this.prototype);
+    }
+    static newCommand(props, metadata) {
+        return new this(Object.assign({ id: (0, id_1.generatePrefixedUUID)(this.commandType()), timestamp: Date.now() }, metadata), props);
+    }
+    get id() {
+        return this._id;
+    }
+    get timestamp() {
+        return this._timestamp;
+    }
+    get correlationId() {
+        return this._correlationId;
+    }
+    get causationId() {
+        return this._causationId;
+    }
+    setCorrelationId(correlationId) {
+        if (!this.correlationId)
+            this._correlationId = correlationId;
+    }
+    setCausationId(causationId) {
+        if (!this.causationId)
+            this._causationId = causationId;
+    }
+    commandType() {
+        const prototype = Object.getPrototypeOf(this);
+        return (0, command_1.getCommandType)(prototype);
+    }
+}
+exports.Command = Command;

package/dist/base/entity.d.ts

@@ -0,0 +1,22 @@
+import { Class } from "../types/class";
+import { ClassStatic } from "../types/class-static";
+import { PropsEnvelope, PropsOf } from "./props-envelope";
+export interface IEntityMetadata {
+    readonly id: string;
+}
+export type NewEntityMetadataOptions = Partial<IEntityMetadata>;
+export declare class Entity<P extends object> extends PropsEnvelope<P> implements IEntityMetadata {
+    private readonly _id;
+    constructor(metadata: IEntityMetadata, props?: P);
+    static entityType(): string;
+    static newEntity<T extends AnyEntity>(this: EntityClass<T>, props?: PropsOf<T>, metadata?: NewEntityMetadataOptions): T;
+    get id(): string;
+    entityType(): string;
+    equals<E extends AnyEntity>(entity: E): boolean;
+}
+export type AnyEntity = Entity<any>;
+export type EntityConstructorParamsWithProps<P extends object> = ConstructorParameters<typeof Entity<P>>;
+export type EntityClassWithProps<P extends object> = Class<Entity<P>, EntityConstructorParamsWithProps<P>> & ClassStatic<typeof Entity<P>>;
+export type EntityConstructorParams<T extends AnyEntity> = EntityConstructorParamsWithProps<PropsOf<T>>;
+export type EntityClass<T extends AnyEntity> = Class<T, EntityConstructorParams<T>> & ClassStatic<typeof Entity<PropsOf<T>>>;
+export type AnyEntityClass = EntityClass<AnyEntity>;

package/dist/base/entity.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entity = void 0;
+const entity_1 = require("../metadata/entity");
+const id_1 = require("../utils/id");
+const props_envelope_1 = require("./props-envelope");
+class Entity extends props_envelope_1.PropsEnvelope {
+    constructor(metadata, props) {
+        super(props);
+        this._id = metadata.id;
+    }
+    static entityType() {
+        return (0, entity_1.getEntityType)(this.prototype);
+    }
+    static newEntity(props, metadata) {
+        return new this(Object.assign({ id: (0, id_1.generatePrefixedUUID)(this.entityType()) }, metadata), props);
+    }
+    get id() {
+        return this._id;
+    }
+    entityType() {
+        const prototype = Object.getPrototypeOf(this);
+        return (0, entity_1.getEntityType)(prototype);
+    }
+    equals(entity) {
+        const equalsType = entity instanceof this.constructor;
+        const equalsId = entity.id === this.id;
+        return equalsType && equalsId;
+    }
+}
+exports.Entity = Entity;

package/dist/base/errors/aggregate.error.d.ts

@@ -0,0 +1,18 @@
+export declare class PastEventCannotBeAddedError extends Error {
+    constructor();
+}
+export declare class EventApplierNotFoundError extends Error {
+    constructor(eventType: string);
+}
+export declare class CommandHandlerNotFoundError extends Error {
+    constructor(commandType: string);
+}
+export declare class InvalidEventAggregateTypeError extends Error {
+    constructor();
+}
+export declare class InvalidEventAggregateIdError extends Error {
+    constructor();
+}
+export declare class InvalidEventAggregateVersionError extends Error {
+    constructor();
+}

package/dist/base/errors/aggregate.error.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidEventAggregateVersionError = exports.InvalidEventAggregateIdError = exports.InvalidEventAggregateTypeError = exports.CommandHandlerNotFoundError = exports.EventApplierNotFoundError = exports.PastEventCannotBeAddedError = void 0;
+class PastEventCannotBeAddedError extends Error {
+    constructor() {
+        super("Past event cannot be added once a new event has been added");
+    }
+}
+exports.PastEventCannotBeAddedError = PastEventCannotBeAddedError;
+class EventApplierNotFoundError extends Error {
+    constructor(eventType) {
+        super(`Not found event applier for event with type ${eventType}`);
+    }
+}
+exports.EventApplierNotFoundError = EventApplierNotFoundError;
+class CommandHandlerNotFoundError extends Error {
+    constructor(commandType) {
+        super(`Not found command handler for command with type ${commandType}`);
+    }
+}
+exports.CommandHandlerNotFoundError = CommandHandlerNotFoundError;
+class InvalidEventAggregateTypeError extends Error {
+    constructor() {
+        super("The event must have the aggregateType is equal to the type of the aggregate that applied that event");
+    }
+}
+exports.InvalidEventAggregateTypeError = InvalidEventAggregateTypeError;
+class InvalidEventAggregateIdError extends Error {
+    constructor() {
+        super("The event must have the aggregateId is equal to the id of the aggregate that applied that event");
+    }
+}
+exports.InvalidEventAggregateIdError = InvalidEventAggregateIdError;
+class InvalidEventAggregateVersionError extends Error {
+    constructor() {
+        super("The event must have the aggregateVersion is equal to the next version of the aggregate that applied that event");
+    }
+}
+exports.InvalidEventAggregateVersionError = InvalidEventAggregateVersionError;

package/dist/base/event.d.ts

@@ -0,0 +1,40 @@
+import { Class } from "../types/class";
+import { ClassStatic } from "../types/class-static";
+import { PropsEnvelope, PropsOf } from "./props-envelope";
+export interface IEventAggregate {
+    readonly type: string;
+    readonly id: string;
+    readonly version: number;
+}
+export interface IEventMetadata {
+    readonly id: string;
+    readonly timestamp: number;
+    readonly aggregate: IEventAggregate;
+    correlationId?: string;
+    causationId?: string;
+}
+export type NewEventMetadataOptions = Partial<Omit<IEventMetadata, "aggregate" | "timestamp">>;
+export declare class Event<P extends object> extends PropsEnvelope<P> implements IEventMetadata {
+    private readonly _id;
+    private readonly _timestamp;
+    private readonly _aggregate;
+    private _correlationId?;
+    private _causationId?;
+    constructor(metadata: IEventMetadata, props: P);
+    static eventType(): string;
+    static newEvent<T extends AnyEvent>(this: EventClass<T>, aggregate: IEventAggregate, props: PropsOf<T>, metadata?: NewEventMetadataOptions): T;
+    get id(): string;
+    get timestamp(): number;
+    get aggregate(): IEventAggregate;
+    get correlationId(): string | undefined;
+    get causationId(): string | undefined;
+    setCorrelationId(correlationId: string): void;
+    setCausationId(causationId: string): void;
+    eventType(): string;
+}
+export type AnyEvent = Event<any>;
+export type EventConstructorParamsWithProps<P extends object> = ConstructorParameters<typeof Event<P>>;
+export type EventClassWithProps<P extends object> = Class<Event<P>, EventConstructorParamsWithProps<P>> & ClassStatic<typeof Event<P>>;
+export type EventConstructorParams<T extends AnyEvent> = EventConstructorParamsWithProps<PropsOf<T>>;
+export type EventClass<T extends AnyEvent> = Class<T, EventConstructorParams<T>> & ClassStatic<typeof Event<PropsOf<T>>>;
+export type AnyEventClass = EventClass<AnyEvent>;

package/dist/base/event.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Event = void 0;
+const event_1 = require("../metadata/event");
+const id_1 = require("../utils/id");
+const props_envelope_1 = require("./props-envelope");
+class Event extends props_envelope_1.PropsEnvelope {
+    constructor(metadata, props) {
+        super(props);
+        this._id = metadata.id;
+        this._timestamp = metadata.timestamp;
+        this._aggregate = metadata.aggregate;
+        this._correlationId = metadata === null || metadata === void 0 ? void 0 : metadata.correlationId;
+        this._causationId = metadata === null || metadata === void 0 ? void 0 : metadata.causationId;
+    }
+    static eventType() {
+        return (0, event_1.getEventType)(this.prototype);
+    }
+    static newEvent(aggregate, props, metadata) {
+        return new this(Object.assign({ id: (0, id_1.generatePrefixedUUID)(this.eventType()), timestamp: Date.now(), aggregate }, metadata), props);
+    }
+    get id() {
+        return this._id;
+    }
+    get timestamp() {
+        return this._timestamp;
+    }
+    get aggregate() {
+        return this._aggregate;
+    }
+    get correlationId() {
+        return this._correlationId;
+    }
+    get causationId() {
+        return this._causationId;
+    }
+    setCorrelationId(correlationId) {
+        if (!this.correlationId)
+            this._correlationId = correlationId;
+    }
+    setCausationId(causationId) {
+        if (!this.causationId)
+            this._causationId = causationId;
+    }
+    eventType() {
+        const prototype = Object.getPrototypeOf(this);
+        return (0, event_1.getEventType)(prototype);
+    }
+}
+exports.Event = Event;

package/dist/base/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./aggregate";
+export * from "./entity";
+export * from "./command";
+export * from "./event";
+export * from "./props-envelope";
+export * from "./value-object";

package/dist/base/index.js

@@ -0,0 +1,22 @@
+"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"), exports);
+__exportStar(require("./entity"), exports);
+__exportStar(require("./command"), exports);
+__exportStar(require("./event"), exports);
+__exportStar(require("./props-envelope"), exports);
+__exportStar(require("./value-object"), exports);

package/dist/base/props-envelope.d.ts

@@ -0,0 +1,11 @@
+export declare class PropsEnvelope<P extends object> {
+    private _props;
+    constructor(props?: P);
+    validate(): void;
+    initProps(props: P): void;
+    protected get props(): P;
+    getProps(): P;
+}
+export type AnyPropsEnvelope = PropsEnvelope<any>;
+export type PropsOf<T extends AnyPropsEnvelope> = T extends PropsEnvelope<infer P> ? P : never;
+export type EmptyProps = {};

package/dist/base/props-envelope.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropsEnvelope = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+class PropsEnvelope {
+    constructor(props) {
+        if (props)
+            this.initProps(props);
+    }
+    validate() { }
+    initProps(props) {
+        if (this.props)
+            return;
+        this._props = props;
+        this.validate();
+    }
+    get props() {
+        return this._props;
+    }
+    getProps() {
+        return lodash_1.default.cloneDeep(this._props);
+    }
+}
+exports.PropsEnvelope = PropsEnvelope;

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

@@ -0,0 +1,16 @@
+import { Class } from "../types/class";
+import { ClassStatic } from "../types/class-static";
+import { PropsEnvelope, PropsOf } from "./props-envelope";
+export declare class ValueObject<P extends object> extends PropsEnvelope<P> {
+    constructor(props: P);
+    static valueObjectType(): string;
+    valueObjectType(): string;
+    equals<V extends AnyValueObject>(vo: V): boolean;
+    with(props: Partial<P>): this;
+}
+export type AnyValueObject = ValueObject<any>;
+export type ValueObjectConstructorParamsWithProps<P extends object> = ConstructorParameters<typeof ValueObject<P>>;
+export type ValueObjectClassWithProps<P extends object> = Class<ValueObject<P>, ValueObjectConstructorParamsWithProps<P>> & ClassStatic<typeof ValueObject<P>>;
+export type ValueObjectConstructorParams<T extends AnyValueObject> = ValueObjectConstructorParamsWithProps<PropsOf<T>>;
+export type ValueObjectClass<T extends AnyValueObject> = Class<T, ValueObjectConstructorParams<T>> & ClassStatic<typeof ValueObject<PropsOf<T>>>;
+export type AnyValueObjectClass = ValueObjectClass<AnyValueObject>;

package/dist/base/value-object.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueObject = void 0;
+const value_object_1 = require("../metadata/value-object");
+const lodash_1 = __importDefault(require("lodash"));
+const props_envelope_1 = require("./props-envelope");
+class ValueObject extends props_envelope_1.PropsEnvelope {
+    constructor(props) {
+        super(props);
+    }
+    static valueObjectType() {
+        return (0, value_object_1.getValueObjectType)(this.prototype);
+    }
+    valueObjectType() {
+        const prototype = Object.getPrototypeOf(this);
+        return (0, value_object_1.getValueObjectType)(prototype);
+    }
+    equals(vo) {
+        const equalsType = vo instanceof this.constructor;
+        const equalsValue = JSON.stringify(vo) === JSON.stringify(this);
+        return equalsType && equalsValue;
+    }
+    with(props) {
+        const newProps = lodash_1.default.merge(this.getProps(), props);
+        return new this.constructor(newProps);
+    }
+}
+exports.ValueObject = ValueObject;

package/dist/decorators/aggregate.d.ts

@@ -0,0 +1,7 @@
+import { AggregateClass, AggregateCommandHandler, AggregateEventApplier, AnyAggregate } from "../base/aggregate";
+import { AnyCommand } from "../base/command";
+import { AnyEvent } from "../base/event";
+import { Class } from "../types/class";
+export declare const TypeAggregate: <T extends AnyAggregate>(aggregateType?: string) => <U extends AggregateClass<T>>(target: U) => void;
+export declare const ApplyEvent: <E extends AnyEvent>(eventClass: Class<E>) => <T extends AggregateEventApplier<E>>(target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => void;
+export declare const ProcessCommand: <C extends AnyCommand>(commandClass: Class<C>) => <T extends AggregateCommandHandler<C>>(target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => void;

package/dist/decorators/aggregate.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessCommand = exports.ApplyEvent = exports.TypeAggregate = void 0;
+const aggregate_1 = require("../metadata/aggregate");
+const command_1 = require("../metadata/command");
+const event_1 = require("../metadata/event");
+const TypeAggregate = (aggregateType) => {
+    return (target) => {
+        aggregateType = aggregateType !== null && aggregateType !== void 0 ? aggregateType : target.name;
+        (0, aggregate_1.defineAggregateType)(target.prototype, aggregateType);
+        aggregate_1.AggregateRegistry.register(aggregateType, target);
+    };
+};
+exports.TypeAggregate = TypeAggregate;
+const ApplyEvent = (eventClass) => {
+    return (target, propertyKey, descriptor) => {
+        if (typeof descriptor.value === "function") {
+            const eventType = (0, event_1.getEventType)(eventClass.prototype);
+            (0, aggregate_1.defineAggregateEventApplier)(target, eventType, descriptor.value);
+        }
+    };
+};
+exports.ApplyEvent = ApplyEvent;
+const ProcessCommand = (commandClass) => {
+    return (target, propertyKey, descriptor) => {
+        if (typeof descriptor.value === "function") {
+            const commandType = (0, command_1.getCommandType)(commandClass.prototype);
+            (0, aggregate_1.defineAggregateCommandHandler)(target, commandType, descriptor.value);
+        }
+    };
+};
+exports.ProcessCommand = ProcessCommand;

package/dist/decorators/command.d.ts

@@ -0,0 +1,2 @@
+import { AnyCommand, CommandClass } from "../base/command";
+export declare const TypeCommand: <T extends AnyCommand>(commandType?: string) => <U extends CommandClass<T>>(target: U) => void;

package/dist/decorators/command.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeCommand = void 0;
+const command_1 = require("../metadata/command");
+const TypeCommand = (commandType) => {
+    return (target) => {
+        commandType = commandType !== null && commandType !== void 0 ? commandType : target.name;
+        (0, command_1.defineCommandType)(target.prototype, commandType);
+        command_1.CommandRegistry.register(commandType, target);
+    };
+};
+exports.TypeCommand = TypeCommand;

package/dist/decorators/entity.d.ts

@@ -0,0 +1,2 @@
+import { AnyEntity, EntityClass } from "../base/entity";
+export declare const TypeEntity: <T extends AnyEntity>(entityType?: string) => <U extends EntityClass<T>>(target: U) => void;