Provide bus abstractions

[RomanReznichenko]

Abstractions that should be provided:

• Command
• Event
• CommandDispatcher
• EventDispatcher
• Handler
• RetryStrategy
• EventBus

Command

Should be generic. Users should be able to provide message and response types.

export abstract class Command<T, R> {
  // ...
}

The Command can be executed in a way that is more approach you or convenient from the client's perspective.

await new Command<T, R>(/*parameters*/).execute(dispatcher);
await dispatcher.execute(await new Command<T, R>(/*parameters*/));

Event

Should be generic. Users should be able to provide message type. To get the Event publishing result users should register Handler.

export abstract class Event<T> {
  // ...
}

The Event can be executed in a way that is more approach you or convenient from the client's perspective.

await new Event <T>(/*parameters*/).publish(dispatcher);
await dispatcher.publish(await new Event<T>(/*parameters*/));

CommandDispatcher

Users can use CommandDispatcher to synchronously execute commands

export interface CommandDispatcher {
  execute<T, R>(command: Command<T, R>): Promise<R | undefined>;
}

EventDispatcher

Users can use EventDispatcher to asynchronously publish events

export interface EventDispatcher {
  publish<T>(event: Event<T>): Promise<void>;
}

Handler

Users can use Handler to handle events dispatched from the application

export interface Handler<T, R> {
  handle(argument: T): Promise<R>;
}

RetryStrategy

Users can be able to use retries in the case when the connection is lost

export interface RetryStrategy {
  acquire<T extends (...args: unknown[]) => unknown>(
    task: T
  ): Promise<ReturnType<T>>;
}

EventBus

Users can use EventBus to communicate between the service. EventBus should extend from EventDispatcher and CommandDispatcher

export interface EventBus extends EventDispatcher, CommandDispatcher {
  register<T extends Event<R>, R>(
    type: new (...args: unknown[]) => EventHandler<T>
  ): Promise<void>;

  unregister<T extends Event<R>, R>(
    type: new (...args: unknown[]) => EventHandler<T>
  ): Promise<void>;

  init?(): Promise<void>;
  destroy?(): Promise<void>;
}