ddd-node 5.0.0 → 6.0.0

package/dist/base/aggregate.js

@@ -1,175 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AggregateES = exports.Aggregate = void 0;
-const aggregate_1 = require("../metadata/aggregate");
-const to_array_1 = require("../utils/to-array");
-const entity_1 = require("./entity");
-const aggregate_error_1 = require("./errors/aggregate.error");
-const id_1 = require("./id");
-class Aggregate extends entity_1.Entity {
-    constructor(metadata, props) {
-        super({ id: metadata.id }, props);
-        this.events = [];
-        this._aggregateType = metadata.aggregateType;
-        this._version = metadata.version;
-    }
-    static aggregateType() {
-        return (0, aggregate_1.getAggregateType)(this.prototype);
-    }
-    static newAggregate(props, metadata) {
-        return new this(Object.assign({ aggregateType: this.aggregateType(), id: id_1.Id.unique(), version: 0 }, metadata), props);
-    }
-    get version() {
-        return this._version;
-    }
-    get aggregateType() {
-        return this._aggregateType;
-    }
-    getEvents() {
-        return this.events;
-    }
-    hasEvents() {
-        return Boolean(this.events.length);
-    }
-    nextVersion() {
-        return this.version + 1;
-    }
-    newEvent(eventClass, props, metadata) {
-        return eventClass.newEvent({
-            id: this.id,
-            version: this.nextVersion(),
-        }, props, metadata);
-    }
-    addEvent(event) {
-        this.events.push(event);
-    }
-    addNewEvent(eventClass, props, metadata) {
-        const event = this.newEvent(eventClass, props, metadata);
-        this.addEvent(event);
-    }
-}
-exports.Aggregate = Aggregate;
-class AggregateES extends Aggregate {
-    constructor() {
-        super(...arguments);
-        this.handledCommands = [];
-        this.pastEvents = [];
-    }
-    static stream(id, events) {
-        const aggregate = this.newAggregate(undefined, { id });
-        aggregate.applyEvents(events, true);
-        return aggregate;
-    }
-    static snapshot(snapshot, eventsAfterSnapshot) {
-        const { metadata, props } = snapshot;
-        const aggregate = new this(metadata, props);
-        aggregate.applyEvents(eventsAfterSnapshot, true);
-        return aggregate;
-    }
-    getHandledCommands() {
-        return this.handledCommands;
-    }
-    getPastEvents() {
-        return this.pastEvents;
-    }
-    lastEvent() {
-        return this.hasEvents() ? this.events.at(-1) : this.pastEvents.at(-1);
-    }
-    currentVersion() {
-        const lastEvent = this.lastEvent();
-        if (lastEvent)
-            return lastEvent.aggregate.version;
-        return this.version;
-    }
-    nextVersion() {
-        return this.currentVersion() + 1;
-    }
-    addPastEvent(event) {
-        if (this.hasEvents())
-            throw new aggregate_error_1.PastEventCannotBeAddedError();
-        this.pastEvents.push(event);
-    }
-    validateEventBeforeApply(event) {
-        const { aggregateType } = event;
-        const { id, version } = event.aggregate;
-        if (aggregateType !== this.aggregateType)
-            throw new aggregate_error_1.InvalidEventAggregateTypeError();
-        if (!id.equals(this.id))
-            throw new aggregate_error_1.InvalidEventAggregateIdError();
-        if (version !== this.nextVersion())
-            throw new aggregate_error_1.InvalidEventAggregateVersionError();
-    }
-    getEventApplierSafe(eventType) {
-        const prototype = Object.getPrototypeOf(this);
-        const eventApplier = (0, aggregate_1.getAggregateEventApplier)(prototype, eventType);
-        if (eventApplier)
-            return eventApplier.bind(this);
-        return null;
-    }
-    getEventApplier(eventType) {
-        const applier = this.getEventApplierSafe(eventType);
-        if (!applier)
-            throw new aggregate_error_1.EventApplierNotFoundError(eventType);
-        return applier;
-    }
-    applyEvent(event, fromHistory = false) {
-        const { eventType } = event;
-        const applier = this.getEventApplier(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);
-        });
-    }
-    getCommandHandlerSafe(commandType) {
-        const prototype = Object.getPrototypeOf(this);
-        const commandHandler = (0, aggregate_1.getAggregateCommandHandler)(prototype, commandType);
-        if (commandHandler)
-            return commandHandler.bind(this);
-        return null;
-    }
-    getCommandHandler(commandType) {
-        const handler = this.getCommandHandlerSafe(commandType);
-        if (!handler)
-            throw new aggregate_error_1.CommandHandlerNotFoundError(commandType);
-        return handler;
-    }
-    validateCommandBeforeProcess(command) {
-        const { aggregateType } = command;
-        if (aggregateType !== this.aggregateType)
-            throw new aggregate_error_1.InvalidCommandAggregateTypeError();
-    }
-    processCommand(command) {
-        const { commandType } = command;
-        const handler = this.getCommandHandler(commandType);
-        this.validateCommandBeforeProcess(command);
-        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;
-    }
-    snap() {
-        return {
-            metadata: {
-                id: this.id,
-                aggregateType: this.aggregateType,
-                version: this.version,
-            },
-            props: this.getProps(),
-        };
-    }
-}
-exports.AggregateES = AggregateES;

package/dist/base/command.d.ts

@@ -1,21 +0,0 @@
-import { Class } from "../types/class";
-import { ClassStatic } from "../types/class-static";
-import { IMessageMetadata, Message } from "./message";
-import { PropsOf } from "./props-envelope";
-export interface ICommandMetadata extends IMessageMetadata {
-    readonly commandType: string;
-}
-export type NewCommandMetadataOptions = Omit<ICommandMetadata, "aggregateType" | "timestamp">;
-export declare class Command<P extends object> extends Message<P> implements ICommandMetadata {
-    private readonly _commandType;
-    constructor(metadata: ICommandMetadata, props: P);
-    static commandType(): string;
-    static newCommand<T extends AnyCommand>(this: CommandClass<T>, props: PropsOf<T>, metadata?: NewCommandMetadataOptions): T;
-    get 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 = Class<AnyCommand>;

package/dist/base/command.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Command = void 0;
-const command_1 = require("../metadata/command");
-const id_1 = require("./id");
-const message_1 = require("./message");
-class Command extends message_1.Message {
-    constructor(metadata, props) {
-        super(metadata, props);
-        this._commandType = metadata.commandType;
-    }
-    static commandType() {
-        return (0, command_1.getCommandType)(this.prototype);
-    }
-    static newCommand(props, metadata) {
-        return new this(Object.assign({ commandType: this.commandType(), id: id_1.Id.unique(), timestamp: Date.now(), aggregateType: this.aggregateType() }, metadata), props);
-    }
-    get commandType() {
-        return this._commandType;
-    }
-}
-exports.Command = Command;

package/dist/base/entity.d.ts

@@ -1,23 +0,0 @@
-import { Class } from "../types/class";
-import { ClassStatic } from "../types/class-static";
-import { Id } from "./id";
-import { PropsEnvelope, PropsOf } from "./props-envelope";
-export interface IEntityMetadata {
-    readonly id: Id;
-}
-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(): Id;
-    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 = Class<AnyEntity>;

package/dist/base/entity.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Entity = void 0;
-const entity_1 = require("../metadata/entity");
-const id_1 = require("./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: id_1.Id.unique() }, 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.equals(entity.id);
-        return equalsType && equalsId;
-    }
-}
-exports.Entity = Entity;

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

@@ -1,21 +0,0 @@
-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();
-}
-export declare class InvalidCommandAggregateTypeError extends Error {
-    constructor();
-}

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

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvalidCommandAggregateTypeError = 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 aggregate type equal to the type of the aggregate instance");
-    }
-}
-exports.InvalidEventAggregateTypeError = InvalidEventAggregateTypeError;
-class InvalidEventAggregateIdError extends Error {
-    constructor() {
-        super("The event must have the aggregate id equal to the id of the aggregate instance");
-    }
-}
-exports.InvalidEventAggregateIdError = InvalidEventAggregateIdError;
-class InvalidEventAggregateVersionError extends Error {
-    constructor() {
-        super("The event must have the aggregate version equal to the next version of the aggregate instance");
-    }
-}
-exports.InvalidEventAggregateVersionError = InvalidEventAggregateVersionError;
-class InvalidCommandAggregateTypeError extends Error {
-    constructor() {
-        super("The command must have the aggregate type equal to the type of the aggregate instance");
-    }
-}
-exports.InvalidCommandAggregateTypeError = InvalidCommandAggregateTypeError;

package/dist/base/event.d.ts

@@ -1,29 +0,0 @@
-import { Class } from "../types/class";
-import { ClassStatic } from "../types/class-static";
-import { Id } from "./id";
-import { IMessageMetadata, Message } from "./message";
-import { PropsOf } from "./props-envelope";
-export interface IEventAggregate {
-    readonly id: Id;
-    readonly version: number;
-}
-export interface IEventMetadata extends IMessageMetadata {
-    readonly eventType: string;
-    readonly aggregate: IEventAggregate;
-}
-export type NewEventMetadataOptions = Omit<IEventMetadata, "aggregateType" | "aggregate" | "timestamp">;
-export declare class Event<P extends object> extends Message<P> implements IEventMetadata {
-    private readonly _eventType;
-    private readonly _aggregate;
-    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 eventType(): string;
-    get aggregate(): IEventAggregate;
-}
-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 = Class<AnyEvent>;

package/dist/base/event.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Event = void 0;
-const event_1 = require("../metadata/event");
-const id_1 = require("./id");
-const message_1 = require("./message");
-class Event extends message_1.Message {
-    constructor(metadata, props) {
-        super(metadata, props);
-        this._eventType = metadata.eventType;
-        this._aggregate = metadata.aggregate;
-    }
-    static eventType() {
-        return (0, event_1.getEventType)(this.prototype);
-    }
-    static newEvent(aggregate, props, metadata) {
-        return new this(Object.assign({ eventType: this.eventType(), id: id_1.Id.unique(), timestamp: Date.now(), aggregateType: this.aggregateType(), aggregate }, metadata), props);
-    }
-    get eventType() {
-        return this._eventType;
-    }
-    get aggregate() {
-        return this._aggregate;
-    }
-}
-exports.Event = Event;

package/dist/base/message.d.ts

@@ -1,33 +0,0 @@
-import { Class } from "../types/class";
-import { ClassStatic } from "../types/class-static";
-import { Id } from "./id";
-import { PropsEnvelope, PropsOf } from "./props-envelope";
-export interface IMessageMetadata {
-    readonly id: Id;
-    readonly timestamp: number;
-    readonly aggregateType: string;
-    correlationId?: string;
-    causationId?: string;
-}
-export declare class Message<P extends object> extends PropsEnvelope<P> implements IMessageMetadata {
-    private readonly _id;
-    private readonly _timestamp;
-    private readonly _aggregateType;
-    private _correlationId?;
-    private _causationId?;
-    constructor(metadata: IMessageMetadata, props: P);
-    static aggregateType(): string;
-    get id(): Id;
-    get timestamp(): number;
-    get aggregateType(): string;
-    get correlationId(): string | undefined;
-    get causationId(): string | undefined;
-    setCorrelationId(correlationId: string): void;
-    setCausationId(causationId: string): void;
-}
-export type AnyMessage = Message<any>;
-export type MessageConstructorParamsWithProps<P extends object> = ConstructorParameters<typeof Message<P>>;
-export type MessageClassWithProps<P extends object> = Class<Message<P>, MessageConstructorParamsWithProps<P>> & ClassStatic<typeof Message<P>>;
-export type MessageConstructorParams<T extends AnyMessage> = MessageConstructorParamsWithProps<PropsOf<T>>;
-export type MessageClass<T extends AnyMessage> = Class<T, MessageConstructorParams<T>> & ClassStatic<typeof Message<PropsOf<T>>>;
-export type AnyMessageClass = Class<AnyMessage>;

package/dist/base/message.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Message = void 0;
-const message_1 = require("../metadata/message");
-const props_envelope_1 = require("./props-envelope");
-class Message extends props_envelope_1.PropsEnvelope {
-    constructor(metadata, props) {
-        super(props);
-        this._id = metadata.id;
-        this._timestamp = metadata.timestamp;
-        this._aggregateType = metadata.aggregateType;
-        this._correlationId = metadata === null || metadata === void 0 ? void 0 : metadata.correlationId;
-        this._causationId = metadata === null || metadata === void 0 ? void 0 : metadata.causationId;
-    }
-    static aggregateType() {
-        return (0, message_1.getMessageAggregateType)(this.prototype);
-    }
-    get id() {
-        return this._id;
-    }
-    get timestamp() {
-        return this._timestamp;
-    }
-    get aggregateType() {
-        return this._aggregateType;
-    }
-    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;
-    }
-}
-exports.Message = Message;

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

@@ -1,11 +0,0 @@
-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/repository.d.ts

@@ -1,6 +0,0 @@
-import { AnyAggregate } from "./aggregate";
-import { Id } from "./id";
-export interface Repository<T extends AnyAggregate> {
-    findById(id: Id): Promise<T | undefined>;
-    save(aggregate: T): Promise<void>;
-}

package/dist/base/repository.js

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

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

@@ -1,16 +0,0 @@
-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 = Class<AnyValueObject>;

package/dist/decorators/index.d.ts

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

package/dist/decorators/index.js

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

package/dist/decorators/message.d.ts

@@ -1,2 +0,0 @@
-import { AnyMessageClass } from "../base/message";
-export declare const TypeMessage: (aggregateType: string) => <U extends AnyMessageClass>(target: U) => void;

package/dist/decorators/message.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeMessage = void 0;
-const message_1 = require("../metadata/message");
-const TypeMessage = (aggregateType) => {
-    return (target) => {
-        (0, message_1.defineMessageAggregateType)(target.prototype, aggregateType);
-    };
-};
-exports.TypeMessage = TypeMessage;

package/dist/metadata/aggregate.d.ts

@@ -1,14 +0,0 @@
-import { AggregateCommandHandler, AggregateEventApplier, AnyAggregateClass } from "../base/aggregate";
-import { AnyCommand } from "../base/command";
-import { AnyEvent } from "../base/event";
-import "reflect-metadata";
-import { Registry } from "./registry";
-export declare const AggregateRegistry: Registry<AnyAggregateClass>;
-export declare const defineAggregateType: (target: object, aggregateType: string) => void;
-export declare const getAggregateType: (target: object) => string;
-export declare const getAggregateEventAppliersMap: <T extends AnyEvent>(target: object) => Map<string, AggregateEventApplier<T>>;
-export declare const defineAggregateEventApplier: <T extends AnyEvent>(target: object, eventType: string, applier: AggregateEventApplier<T>) => void;
-export declare const getAggregateEventApplier: (target: object | null, eventType: string) => AggregateEventApplier<AnyEvent> | null;
-export declare const getAggregateCommandHandlersMap: <T extends AnyCommand>(target: object) => Map<string, AggregateCommandHandler<T>>;
-export declare const defineAggregateCommandHandler: <T extends AnyCommand>(target: object, commandType: string, handler: AggregateCommandHandler<T>) => void;
-export declare const getAggregateCommandHandler: (target: object | null, commandType: string) => AggregateCommandHandler<AnyCommand> | null;

package/dist/metadata/aggregate.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAggregateCommandHandler = exports.defineAggregateCommandHandler = exports.getAggregateCommandHandlersMap = exports.getAggregateEventApplier = exports.defineAggregateEventApplier = exports.getAggregateEventAppliersMap = exports.getAggregateType = exports.defineAggregateType = exports.AggregateRegistry = void 0;
-require("reflect-metadata");
-const constants_1 = require("./constants");
-const errors_1 = require("./errors");
-const registry_1 = require("./registry");
-exports.AggregateRegistry = new registry_1.Registry();
-// Aggregate Type
-const defineAggregateType = (target, aggregateType) => {
-    Reflect.defineMetadata(constants_1.AGGREGATE_TYPE, aggregateType, target);
-};
-exports.defineAggregateType = defineAggregateType;
-const getAggregateType = (target) => {
-    const aggregateType = Reflect.getMetadata(constants_1.AGGREGATE_TYPE, target);
-    if (!aggregateType)
-        throw new errors_1.AggregateTypeHasNotBeenSetError();
-    return aggregateType;
-};
-exports.getAggregateType = getAggregateType;
-// Aggregate Event Applier
-const getAggregateEventAppliersMap = (target) => {
-    return (Reflect.getMetadata(constants_1.AGGREGATE_EVENTS_APPLIERS, target) ||
-        new Map());
-};
-exports.getAggregateEventAppliersMap = getAggregateEventAppliersMap;
-const defineAggregateEventApplier = (target, eventType, applier) => {
-    const eventAppliersMap = (0, exports.getAggregateEventAppliersMap)(target);
-    eventAppliersMap.set(eventType, applier);
-    Reflect.defineMetadata(constants_1.AGGREGATE_EVENTS_APPLIERS, eventAppliersMap, target);
-};
-exports.defineAggregateEventApplier = defineAggregateEventApplier;
-const getAggregateEventApplier = (target, eventType) => {
-    if (!target)
-        return null;
-    do {
-        const eventAppliersMap = (0, exports.getAggregateEventAppliersMap)(target);
-        const eventApplier = eventAppliersMap.get(eventType);
-        if (eventApplier)
-            return eventApplier;
-    } while ((target = Reflect.getPrototypeOf(target)) &&
-        target !== Object.prototype);
-    return null;
-};
-exports.getAggregateEventApplier = getAggregateEventApplier;
-// Aggregate Command Handler
-const getAggregateCommandHandlersMap = (target) => {
-    return (Reflect.getMetadata(constants_1.AGGREGATE_COMMANDS_HANDLERS, target) ||
-        new Map());
-};
-exports.getAggregateCommandHandlersMap = getAggregateCommandHandlersMap;
-const defineAggregateCommandHandler = (target, commandType, handler) => {
-    const commandHandlersMap = (0, exports.getAggregateCommandHandlersMap)(target);
-    commandHandlersMap.set(commandType, handler);
-    Reflect.defineMetadata(constants_1.AGGREGATE_COMMANDS_HANDLERS, commandHandlersMap, target);
-};
-exports.defineAggregateCommandHandler = defineAggregateCommandHandler;
-const getAggregateCommandHandler = (target, commandType) => {
-    if (!target)
-        return null;
-    do {
-        const commandHandlersMap = (0, exports.getAggregateCommandHandlersMap)(target);
-        const commandHandler = commandHandlersMap.get(commandType);
-        if (commandHandler)
-            return commandHandler;
-    } while ((target = Reflect.getPrototypeOf(target)) &&
-        target !== Object.prototype);
-    return null;
-};
-exports.getAggregateCommandHandler = getAggregateCommandHandler;

package/dist/metadata/command.d.ts

@@ -1,6 +0,0 @@
-import { AnyCommandClass } from "../base/command";
-import "reflect-metadata";
-import { Registry } from "./registry";
-export declare const CommandRegistry: Registry<AnyCommandClass>;
-export declare const defineCommandType: (target: object, commandType: string) => void;
-export declare const getCommandType: (target: object) => string;