Mediator

About

It is like a middle-man or broker (mediator), this pattern help reducing coupling between two or multiple Objects, by intruducing a bus/channel for communication, so that one Object can notify the other Object whenever it has to.

It provides separation of concerns and eliminates code duplication.

A Mediator have a relationship of $many \to many$, meaning:

• Many Objects can notify/publish. (One or multiple events)

• Many Objects can subscribe and react to these events.

Depending on how you use it, Mediator can also act as Mediator.

Ex.:

• If many different Objects generate events to many interested parties, it acts as Mediator.

• If only one Object generate events to many different parties, it acts as Observer.

interface Handler {
    // The Event name
    event: string;
    // What must be executed when this Event happens
    callback: Function
}

class Mediator {
    // The handlers are the interested parties
    handlers: Handler[];
    
    constructor() {
        this.handlers = [];
    }
    
    // Here we register events to the handlers and set what should execute when
    // the event happens.
    register(event: string, callback: Function) {
        this.handlers.push({ event, callback });
    }
    
    // When a notify of a specific event is called, all handlers that subscribed
    // to this event get notified.
    async notify(event: string, data: any) {
        for (const handler of this.handlers) {
            if (handler.event === event) await handler.callback(data);
        }
    }
}

Chaining Usecases Example

In this example, lets suppose that we have these three usecases (FinishRide, ProcessPayment and GenerateInvoice), and the last two should be called after the Ride ends.

To avoid injecting and calling ProcessPayment and GenerateInvoice inside FinishRide class, we use a Mediator to generate the nofication that the Ride ended.

Notify from Application Layer

Usecases

export class FinishRide {
    @inject('mediator')
    mediator?: Mediator;
    
    async execute(input: Input): Promise<void> {
        // Get the Ride to be finished and put it in a Domain Object
        const ride = await this.rideRepository.getRideById(input.rideId);
        // Mutate the Domain Object
        ride.finish();
        // Persist the Domain Object
        await this.rideRepository.updateRide(ride);
        // Notify the Ride Completion
        await this.mediator.notify('rideCompleted', { rideId: ride.getRideId(), fare: ride.getFare() });
    }
}

export class ProcessPayment {
    async execute(): Promise<void> { ... }
}

export class GenerateInvoice {
    async execute(): Promise<void> { ... }
}

Main.ts

const processPayment = new ProcessPayment();
const generateInvoice = new GenerateInvoice();
const mediator = new Mediator();
mediator.register('rideCompleted', async function (event: any) {
    await processPayment.execute(event);
    await generateInvoice.execute(event);
});
Registry.getInstance().provide('mediator', mediator)

Notify from Domain Layer

You could be more strict, and state that the Event notification is the Domain Object Ride responsability.

We avoid making the finish() method from Ride return the Event data, because otherwise, the method return type is tied to Events.

For this we can make these changes:

Ride.ts

export class Ride extends Mediator {
    ...
    finish(): void {
        ...
        this.notify('triggerPublishRideCompletedEvent', { rideId: this.getRideId(), fare: this.getFare() });
    }
}

As a curiosity:

When making the Ride extend Mediator, the Mediator is actually acting as an Mediator, because it has a relationship of $1 \to many$, since only the Ride Object can notify (create events).

FinishRide.ts

export class FinishRide {
    @inject('mediator')
    mediator?: Mediator;
    
    async execute(input: Input): Promise<void> {
        // Get the Ride to be finished and put it in a Domain Object
        const ride = await this.rideRepository.getRideById(input.rideId);
        
        /*
            Note that the Mediator from `Ride` is a different instance of the Mediator
            from `Main.ts`, and for this reason we must make the notify from `Ride`
            trigger the notify for the injected Mediator.
        */
        ride.register('triggerPublishRideCompletedEvent', async (event: any) => {
            // Persist the Domain Object
            // Moved inside here so that Ride is persisted before the notify.
            await this.rideRepository.updateRide(ride);
            // Notify the Ride Completion
            await this.mediator.notify('rideCompleted', event);
        });
        // Mutate the Domain Object
        ride.finish();
    }
}

Notify from Domain Layer - With Domain Event

It is possible to define the Event, more specifically, as a Domain Event.

RideCompletedEvent.ts

export class RideCompletedEvent {
   constructor(readonly rideId: string, readonly fare: number) {} 
}

Ride.ts

export class Ride {
    ...
    finish(): RideCompletedEvent {
        ...
        this.notify('rideCompleted', new RideCompletedEvent(this.getRideId(), this.getFare()));
    }
}