Builder Pattern

Builders §

The Builder Pattern is a creational design pattern that is used to construct complex objects step by step. It allows the creation of different representations of an object using the same construction process.

This pattern is particularly useful when an object has a large number of optional parameters or configurations.

Let's take an example of a Car, how would you represent or model a Car Object ?

You would probably think that it’s easy, just write a class that has all these properties right ? well turns out, to represent a complex object such as a car is a bit cumbersome.

The combinations of optional and non-optional features, Such as color, engine type, navigation system, sunroof, and more… is just hard to model. As you add more features, the number of constructor overloads grows exponentially, leading to a messy and hard-to-maintain codebase.

You surely don't want to do something like this!

Building objects just by passing data to your constructor is great for simple objects, but pretty untenable for complex objects

class Car {
  constructor(
    make, model, year, color, engineSize,
    transmission, seats, sunroof, navigation,
    heatedSeats, airbags, soundSystem, bluetooth,
    parkingAssist, price, yourGrandMother) 
  {
    this.make = make;
    this.model = model;
    // ...
  }
}
 
// Nobody wants to have a constructor that looks like this!
// What if tomorrow Color need to be obtional ? 
const car1 = new Car(
'Toyota', 'Camry', 2022, 'Red', '2.5L',
'Automatic', 5, true, true, true, 6, 'Premium',
true, true, 25000
);

The Builder pattern suggests that you extract the object construction code out of its own class and move it to separate objects called builders.

Example of a user builder §

Let’s imagine a scenario where we would want to build a user object, For the sake of this example, the object is not going to be as complex as a user Object can get, this example will provide you with an overview of how builders can really simplify object creation

// Define a type for the properties used to create a User object
type UserCreationParams = {
  name: string;
  email: string;
  age: number;
  phone: string;
  address: Address;
};
 
// Define a class to represent an Address
class Address {
  constructor(
    public zip: number,
    public street: string
  ) {}
}
 
// Define a class to represent a User
class User {
  public name: string;
  public email: string;
  public age: number;
  public phone: string;
  public address: Address;
 
  // Constructor to initialize User properties
  constructor(properties: UserCreationParams) {
    this.name = properties.name;
    this.email = properties.email;
    this.age = properties.age;
    this.phone = properties.phone;
    this.address = properties.address;
  }
}
 
// Define a builder class to facilitate User creation
class UserBuilder {
  // Private properties to hold User creation parameters
  private readonly properties: Partial<UserCreationParams> = {};
 
  // Method to set User properties
  with(prop: Partial<UserCreationParams>) {
    // Merge properties with existing ones
    Object.assign(this.properties, prop);
    return this; // Return the builder instance for method chaining
  }
 
  // Method to set specific properties
  withAge(age: number) {
    this.properties.age = age;
    return this; // return builder instance for method chaining
  }
 
 
  withPhone(phone: string) {
    this.properties.phone = phone;
    return this; 
  }
 
 
  withEmail(email: string) {
    this.properties.email = email;
    return this; 
  }
  
  withAddress({ zip, street }: Address) {
    this.properties.address = new Address(zip, street);
    return this;
  }
  
  // Method to build the User object
  build() {
    return new User(this.properties as UserCreationParams);
  }
}
 
 
const user = new UserBuilder()
  .with({
    name: 'Mob',
    age: 23,
    address: { zip: 23, street: 'kn123,st' },
  })
  .withEmail('Hello.com')
  .build();
 

Why this Builder is Great: §

1. Flexibility: The builder provides a flexible way to construct objects by allowing clients to specify properties in any order using a fluent interface. This makes the construction process intuitive and adaptable to different use cases.

2. Encapsulation: The builder encapsulates the construction logic within a separate class, keeping the creation process isolated from the client code. This enhances code maintainability and readability by separating concerns.

3. Optional Parameters: With the builder, clients can selectively specify only the properties they need, omitting optional parameters if desired. This simplifies object creation and reduces the complexity of constructor overloads.

4. Consistency: Using a builder promotes consistency in object creation across different parts of the codebase!

There is no limitation with what you can do with builders !

Builders are commonly used in testing scenarios to create mock objects with specific configurations, or even to construct DTOs with complex data transfer requirements