Facade Design Pattern

Introduction

The Facade is a structural design pattern. It helps create a simple intermediary object that interacts with multiple systems (such as subsystems). The responsibilities of the Facade Pattern include:

Simplifying complex interactions with systems through the intermediary Facade object.
Hiding the complex internal operations of subsystems, making them easier to use.

Frequency of use: quite high.

Problem and solution

In cases where some processes require interaction with multiple services or third-party systems, and these processes are needed repeatedly in various places within the system, the typical solution might be to copy and paste the logic to those places. However, this leads to duplicated code in many locations, making maintenance and updates difficult when there are changes.

The solution is to use the Facade Pattern to create an intermediary object to communicate with subsystems. This allows for the implementation of complex logic in a centralized and well-defined manner, making it easier to update in the future when necessary.

Architecture

Components in the model:

Facade: The intermediary object that contains the logic for interacting with complex systems.
Additional Facade: If there is too much logic to fit into a single Facade, distribute the logic appropriately across multiple Additional Facades.
Complex Subsystems: Consist of multiple different objects, each performing a specific function of the subsystem. They handle tasks called by the Facade. It's important to note that these classes do not need to know about the Facade and do not reference it.
Client: The client object uses the Facade to interact with subsystems instead of directly calling them.

If you only need one Facade object throughout the entire system, you can implement the Facade instance as a Singleton.

Advantages & disadvantages

Advantages

Can isolate the code from the complexity of subsystems.
Systems integrated through a Facade are simpler since they only need to interact with the Facade instead of multiple objects.
Increases independence, reduces dependencies, and makes future changes easier.
Can encapsulate poorly designed functions into a better-designed one.

Disadvantages

The Facade class can become too large when it needs to handle too many tasks with numerous internal functions.
It can easily violate SOLID principles.
Using a Facade for simple systems may become unnecessary.

Implementation example with TypeScript

// Subsystem classes

class AccountService {
  getAccount(email: string): void {
    console.log(`Getting the account of ${email}`)
  }
}

class EmailService {
  sendMail(mailTo: string): void {
    console.log(`Sending an email to ${mailTo}`)
  }
}

class PaymentService {
  paymentByPaypal(): void {
    console.log('Payment by Paypal')
  }
  paymentByCreditCard(): void {
    console.log('Payment by Credit Card')
  }
  paymentByEBankingAccount(): void {
    console.log('Payment by E-banking account')
  }
  paymentByCash(): void {
    console.log('Payment by cash')
  }
}

class ShippingService {
  freeShipping(): void {
    console.log('Free Shipping')
  }
  standardShipping(): void {
    console.log('Standard Shipping')
  }
  expressShipping(): void {
    console.log('Express Shipping')
  }
}

class SmsService {
  sendSMS(mobilePhone: string): void {
    console.log(`Sending a message to ${mobilePhone}`)
  }
}

// Facade class
class Shop {
  static #instance: Shop

  accountService: AccountService
  paymentService: PaymentService
  shippingService: ShippingService
  emailService: EmailService
  smsService: SmsService

  constructor() {
    this.accountService = new AccountService()
    this.paymentService = new PaymentService()
    this.shippingService = new ShippingService()
    this.emailService = new EmailService()
    this.smsService = new SmsService()
  }

  static getInstance(): Shop {
    if (!this.#instance) this.#instance = new Shop()
    return this.#instance
  }

  buyProductByCashWithFreeShipping(email: string): void {
    this.accountService.getAccount(email)
    this.paymentService.paymentByCash()
    this.shippingService.freeShipping()
    this.emailService.sendMail(email)
    console.log('Done\n')
  }

  buyProductByPaypalWithStandardShipping(email: string, mobilePhone: string): void {
    this.accountService.getAccount(email)
    this.paymentService.paymentByPaypal()
    this.shippingService.standardShipping()
    this.emailService.sendMail(email)
    this.smsService.sendSMS(mobilePhone)
    console.log('Done\n')
  }
}

Shop.getInstance().buyProductByCashWithFreeShipping('email@domain.com')
Shop.getInstance().buyProductByPaypalWithStandardShipping('email@domain.com', '+123456789')