Mediator Pattern: Centralizing Complex Interactions

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

// ═══════════════════════════════════════════════════════════════════
// CHAT ROOM MEDIATOR - Production-Ready Implementation
// ═══════════════════════════════════════════════════════════════════
 
interface ChatMediator {
    sendMessage(message: Message, sender: User): void;
    sendPrivateMessage(message: Message, sender: User, recipientId: string): void;
    userJoined(user: User): void;
    userLeft(user: User): void;
}
 
interface Message {
    content: string;
    timestamp: Date;
    type: "text" | "image" | "system";
}
 
abstract class User {
    protected mediator: ChatMediator;
    public readonly id: string;
    public readonly displayName: string;
    protected status: "online" | "away" | "dnd" = "online";
    
    constructor(id: string, name: string, mediator: ChatMediator) {
        this.id = id;
        this.displayName = name;
        this.mediator = mediator;
    }
    
    public sendMessage(content: string): void {
        const message: Message = {
            content,
            timestamp: new Date(),
            type: "text"
        };
        this.mediator.sendMessage(message, this);
    }
    
    public sendPrivateMessage(content: string, recipientId: string): void {
        const message: Message = { content, timestamp: new Date(), type: "text" };
        this.mediator.sendPrivateMessage(message, this, recipientId);
    }
    
    public abstract receiveMessage(message: Message, from: User): void;
    public abstract receiveSystemNotification(notification: string): void;
}
 
class StandardUser extends User {
    private messageHistory: Array<{message: Message, from: string}> = [];
    
    receiveMessage(message: Message, from: User): void {
        this.messageHistory.push({ message, from: from.displayName });
        console.log(`[${this.displayName}] received from ${from.displayName}: ${message.content}`);
    }
    
    receiveSystemNotification(notification: string): void {
        console.log(`[${this.displayName}] SYSTEM: ${notification}`);
    }
}
 
class ChatRoom implements ChatMediator {
    private users: Map<string, User> = new Map();
    private bannedUsers: Set<string> = new Set();
    private messageRateLimit: Map<string, number[]> = new Map();
    
    userJoined(user: User): void {
        if (this.bannedUsers.has(user.id)) {
            console.log(`Banned user ${user.displayName} attempted to join`);
            return;
        }
        
        this.users.set(user.id, user);
        
        // Notify all existing users
        const notification = `${user.displayName} joined the chat`;
        this.users.forEach((u) => {
            if (u.id !== user.id) {
                u.receiveSystemNotification(notification);
            }
        });
    }
    
    userLeft(user: User): void {
        this.users.delete(user.id);
        const notification = `${user.displayName} left the chat`;
        this.users.forEach((u) => u.receiveSystemNotification(notification));
    }
    
    sendMessage(message: Message, sender: User): void {
        // Rate limiting check
        if (!this.checkRateLimit(sender.id)) {
            sender.receiveSystemNotification("Rate limit exceeded. Please slow down.");
            return;
        }
        
        // Broadcast to all users except sender
        this.users.forEach((user) => {
            if (user.id !== sender.id) {
                user.receiveMessage(message, sender);
            }
        });
    }
    
    sendPrivateMessage(message: Message, sender: User, recipientId: string): void {
        const recipient = this.users.get(recipientId);
        if (recipient) {
            recipient.receiveMessage(message, sender);
        } else {
            sender.receiveSystemNotification(`User ${recipientId} not found`);
        }
    }
    
    private checkRateLimit(userId: string): boolean {
        const now = Date.now();
        const userMessages = this.messageRateLimit.get(userId) || [];
        const recentMessages = userMessages.filter(t => now - t < 60000);
        
        if (recentMessages.length >= 30) return false;
        
        recentMessages.push(now);
        this.messageRateLimit.set(userId, recentMessages);
        return true;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

// ═══════════════════════════════════════════════════════════════════
// TYPE-SAFE EVENT BUS MEDIATOR
// ═══════════════════════════════════════════════════════════════════
 
// Type-safe event definitions
interface EventMap {
    "user:registered": { userId: string; email: string; timestamp: Date };
    "order:placed": { orderId: string; userId: string; amount: number };
    "payment:completed": { orderId: string; transactionId: string };
    "inventory:low": { productId: string; currentStock: number };
}
 
type EventName = keyof EventMap;
 
interface EventHandler<T extends EventName> {
    handle(event: EventMap[T]): void | Promise<void>;
}
 
class EventBusMediator {
    private handlers: Map<EventName, Set<EventHandler<any>>> = new Map();
    private eventLog: Array<{event: EventName; data: any; timestamp: Date}> = [];
    
    subscribe<T extends EventName>(eventName: T, handler: EventHandler<T>): void {
        if (!this.handlers.has(eventName)) {
            this.handlers.set(eventName, new Set());
        }
        this.handlers.get(eventName)!.add(handler);
    }
    
    unsubscribe<T extends EventName>(eventName: T, handler: EventHandler<T>): void {
        this.handlers.get(eventName)?.delete(handler);
    }
    
    async publish<T extends EventName>(eventName: T, data: EventMap[T]): Promise<void> {
        // Log for audit
        this.eventLog.push({ event: eventName, data, timestamp: new Date() });
        
        const handlers = this.handlers.get(eventName);
        if (!handlers) return;
        
        // Execute handlers (could be parallel or sequential based on needs)
        const promises = Array.from(handlers).map(handler => handler.handle(data));
        await Promise.all(promises);
    }
}
 
// Service implementations
class EmailService implements EventHandler<"user:registered"> {
    handle(event: EventMap["user:registered"]): void {
        console.log(`📧 Sending welcome email to ${event.email}`);
    }
}
 
class AnalyticsService implements EventHandler<"order:placed"> {
    handle(event: EventMap["order:placed"]): void {
        console.log(`📊 Recording order ${event.orderId} for analytics`);
    }
}
 
class InventoryService implements EventHandler<"order:placed"> {
    private eventBus: EventBusMediator;
    
    constructor(eventBus: EventBusMediator) {
        this.eventBus = eventBus;
    }
    
    handle(event: EventMap["order:placed"]): void {
        console.log(`📦 Reserving inventory for order ${event.orderId}`);
        
        // May trigger its own events
        this.eventBus.publish("inventory:low", {
            productId: "SKU-123",
            currentStock: 5
        });
    }
}
 
// Usage
const eventBus = new EventBusMediator();
eventBus.subscribe("user:registered", new EmailService());
eventBus.subscribe("order:placed", new AnalyticsService());
eventBus.subscribe("order:placed", new InventoryService(eventBus));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

// ═══════════════════════════════════════════════════════════════════
// STATE MANAGEMENT MEDIATOR (Redux-like pattern)
// ═══════════════════════════════════════════════════════════════════
 
interface Action {
    type: string;
    payload?: any;
}
 
type Reducer<S> = (state: S, action: Action) => S;
type Subscriber<S> = (state: S) => void;
 
class StateMediator<S> {
    private state: S;
    private reducer: Reducer<S>;
    private subscribers: Set<Subscriber<S>> = new Set();
    
    constructor(initialState: S, reducer: Reducer<S>) {
        this.state = initialState;
        this.reducer = reducer;
    }
    
    getState(): S {
        return this.state;
    }
    
    dispatch(action: Action): void {
        console.log(`📤 Dispatching: ${action.type}`);
        
        // Reduce to new state
        const newState = this.reducer(this.state, action);
        
        // Only notify if state changed
        if (newState !== this.state) {
            this.state = newState;
            this.notifySubscribers();
        }
    }
    
    subscribe(subscriber: Subscriber<S>): () => void {
        this.subscribers.add(subscriber);
        
        // Return unsubscribe function
        return () => this.subscribers.delete(subscriber);
    }
    
    private notifySubscribers(): void {
        this.subscribers.forEach(sub => sub(this.state));
    }
}
 
// Application state
interface AppState {
    user: { name: string; loggedIn: boolean } | null;
    cart: Array<{ id: string; quantity: number }>;
    notifications: string[];
}
 
// Reducer (pure function handling state transitions)
const appReducer: Reducer<AppState> = (state, action) => {
    switch (action.type) {
        case "LOGIN":
            return { ...state, user: action.payload };
        case "ADD_TO_CART":
            return { ...state, cart: [...state.cart, action.payload] };
        case "SHOW_NOTIFICATION":
            return { ...state, notifications: [...state.notifications, action.payload] };
        default:
            return state;
    }
};
 
// Usage
const store = new StateMediator<AppState>(
    { user: null, cart: [], notifications: [] },
    appReducer
);
 
// Components subscribe to state changes
store.subscribe((state) => {
    console.log(`Header updated: user = ${state.user?.name || "Guest"}`);
});
 
store.subscribe((state) => {
    console.log(`Cart badge: ${state.cart.length} items`);
});
 
// Components dispatch actions
store.dispatch({ type: "LOGIN", payload: { name: "Alice", loggedIn: true } });
store.dispatch({ type: "ADD_TO_CART", payload: { id: "item-1", quantity: 2 } });

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

// ═══════════════════════════════════════════════════════════════════
// GAME EVENT MEDIATOR
// ═══════════════════════════════════════════════════════════════════
 
interface GameEvent {
    type: string;
    source: GameEntity;
    data: any;
}
 
interface GameMediator {
    notify(event: GameEvent): void;
    register(entity: GameEntity): void;
}
 
abstract class GameEntity {
    protected mediator: GameMediator;
    public readonly id: string;
    public position: { x: number; y: number };
    public health: number;
    
    constructor(id: string, mediator: GameMediator) {
        this.id = id;
        this.mediator = mediator;
        this.position = { x: 0, y: 0 };
        this.health = 100;
        mediator.register(this);
    }
    
    protected emit(type: string, data: any): void {
        this.mediator.notify({ type, source: this, data });
    }
    
    abstract handleEvent(event: GameEvent): void;
}
 
class Player extends GameEntity {
    public score: number = 0;
    
    attack(): void {
        this.emit("player:attack", { damage: 25, range: 50 });
    }
    
    handleEvent(event: GameEvent): void {
        if (event.type === "enemy:defeated") {
            this.score += event.data.points;
            console.log(`Player score: ${this.score}`);
        }
        if (event.type === "item:collected" && event.data.type === "health") {
            this.health = Math.min(100, this.health + event.data.value);
        }
    }
}
 
class Enemy extends GameEntity {
    takeDamage(amount: number): void {
        this.health -= amount;
        if (this.health <= 0) {
            this.emit("enemy:defeated", { points: 100 });
        }
    }
    
    handleEvent(event: GameEvent): void {
        if (event.type === "player:attack") {
            const distance = this.calculateDistance(event.source.position);
            if (distance <= event.data.range) {
                this.takeDamage(event.data.damage);
            }
        }
    }
    
    private calculateDistance(pos: {x: number; y: number}): number {
        return Math.sqrt(Math.pow(pos.x - this.position.x, 2) + 
                         Math.pow(pos.y - this.position.y, 2));
    }
}
 
class GameManager implements GameMediator {
    private entities: Map<string, GameEntity> = new Map();
    
    register(entity: GameEntity): void {
        this.entities.set(entity.id, entity);
    }
    
    notify(event: GameEvent): void {
        console.log(`🎮 Event: ${event.type}`);
        
        this.entities.forEach((entity) => {
            if (entity.id !== event.source.id) {
                entity.handleEvent(event);
            }
        });
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

// ═══════════════════════════════════════════════════════════════════
// ORDER PROCESSING ORCHESTRATOR
// ═══════════════════════════════════════════════════════════════════
 
interface ServiceResult {
    success: boolean;
    error?: string;
    data?: any;
}
 
// Services don't know about each other
class InventoryService {
    async reserveItems(items: any[]): Promise<ServiceResult> {
        console.log("📦 Reserving inventory...");
        return { success: true, data: { reservationId: "RES-123" } };
    }
    
    async releaseReservation(reservationId: string): Promise<void> {
        console.log(`📦 Releasing reservation ${reservationId}`);
    }
}
 
class PaymentService {
    async processPayment(amount: number): Promise<ServiceResult> {
        console.log(`💳 Processing payment of $${amount}...`);
        return { success: true, data: { transactionId: "TXN-456" } };
    }
    
    async refund(transactionId: string): Promise<void> {
        console.log(`💳 Refunding transaction ${transactionId}`);
    }
}
 
class ShippingService {
    async scheduleShipment(orderId: string): Promise<ServiceResult> {
        console.log(`🚚 Scheduling shipment for ${orderId}...`);
        return { success: true, data: { trackingNumber: "TRACK-789" } };
    }
}
 
// Orchestrator mediates the entire workflow
class OrderOrchestrator {
    constructor(
        private inventory: InventoryService,
        private payment: PaymentService,
        private shipping: ShippingService
    ) {}
    
    async processOrder(order: {id: string; items: any[]; amount: number}): Promise<ServiceResult> {
        console.log(`\n🛒 Processing order ${order.id}`);
        
        // Step 1: Reserve inventory
        const inventoryResult = await this.inventory.reserveItems(order.items);
        if (!inventoryResult.success) {
            return { success: false, error: "Inventory reservation failed" };
        }
        
        // Step 2: Process payment
        const paymentResult = await this.payment.processPayment(order.amount);
        if (!paymentResult.success) {
            // Compensating action: release inventory
            await this.inventory.releaseReservation(inventoryResult.data.reservationId);
            return { success: false, error: "Payment failed" };
        }
        
        // Step 3: Schedule shipping
        const shippingResult = await this.shipping.scheduleShipment(order.id);
        if (!shippingResult.success) {
            // Compensating actions
            await this.payment.refund(paymentResult.data.transactionId);
            await this.inventory.releaseReservation(inventoryResult.data.reservationId);
            return { success: false, error: "Shipping failed" };
        }
        
        console.log(`✅ Order ${order.id} completed successfully`);
        return {
            success: true,
            data: {
                orderId: order.id,
                reservationId: inventoryResult.data.reservationId,
                transactionId: paymentResult.data.transactionId,
                trackingNumber: shippingResult.data.trackingNumber
            }
        };
    }
}