Mastering Domain-Driven Design in TypeScript: The Factory Pattern
Written on
Chapter 1: Introduction to the Factory Pattern
In the ongoing exploration of Domain-Driven Design (DDD), one key design pattern to highlight is the Factory pattern. This pattern plays a crucial role in creating complex objects while maintaining code clarity.
Some developers are known for their rapid coding abilities, often completing tasks well before deadlines. While this can be beneficial, it sometimes leads to issues with code quality and the introduction of hidden bugs. I’ve witnessed this scenario repeatedly, and it's clear that every team benefits from at least one member who can work efficiently. However, many of these quick coders struggle with maintaining high-quality code, resulting in logic that is scattered and difficult to test.
I can personally relate to this experience. Earlier in my career, I was the one generating a large volume of code with insufficient quality. My code was often convoluted, making it challenging to unit test, with bugs that seemed to appear out of nowhere. Fortunately, a transformative summer spent reading "Clean Code" dramatically changed my approach. Now, I can maintain a high pace of coding while delivering production-ready code that remains bug-free even after five years.
One significant takeaway from that book was the importance of using Factories. Many developers are familiar with this concept through renowned patterns like the Factory Method and Abstract Factory. It’s worth noting that DDD also employs these patterns effectively.
Section 1.1: The Importance of Avoiding Large Constructors
Large constructors can introduce unnecessary complexity into the codebase. While they often encapsulate important business logic, I find myself questioning the desire to unit-test them. This is precisely where the Factory pattern becomes invaluable.
The Factory pattern is essential in DDD for isolating complex creation logic from other business processes. This separation allows for easier testing and greater maintainability.
The first video titled Factory Design Pattern in TypeScript explores the foundational principles of the Factory pattern, illustrating its implementation in TypeScript applications.
Section 1.2: Implementing the Factory Pattern
The Factory pattern typically resides within the domain layer, providing a centralized method for creating objects throughout the application. Below is a basic illustration of a Factory.
class Loan {
constructor(
private id: string,
// additional fields
) {}
}
interface LoanFactory {
createShortTermLoan(specification: LoanSpecification): Loan;
createLongTermLoan(specification: LoanSpecification): Loan;
}
In this example, we see the LoanFactory exemplifying the Factory pattern within DDD, specifically the Factory Method. It creates instances of the Loan class based on varying payment terms.
Section 1.3: Exploring Variations in Factory Implementations
The Factory pattern can manifest in multiple forms, with the Factory Method being the most common. It provides specialized methods for creating instances, allowing for distinct variations based on context.
class LoanFactory {
public createShortTermLoan(bankAccountID: string, amount: Money): Loan {
return new Loan(12, bankAccountID, amount, false);}
createLongTermLoan(bankAccountID: string, amount: Money): Loan {
return new Loan(360, bankAccountID, amount, true);}
}
In this snippet, the LoanFactory demonstrates a clear implementation of the Factory Method, providing distinct creation methods for short-term and long-term loans.
Chapter 2: Abstract Factory Pattern
The Abstract Factory pattern allows for the instantiation of multiple related objects, as demonstrated in the following example of Investment creation.
The second video titled TypeScript Factory Patterns (No BS TS Series 2 Episode 1) delves into the Abstract Factory pattern, providing practical insights into its application.
interface Investment {
amount(): Money;
}
class EtfInvestment {
constructor(
private etfId: string,
private investedAmount: Money,
private bankAccountId: string
) {}
amount(): Money {
return this.investedAmount;}
}
// Additional Investment classes omitted for brevity
Here, both the EtfInvestment and StockInvestment classes implement the Investment interface, showcasing how different Factory implementations can produce varied outcomes based on specific requirements.
Section 2.1: Application of the Factory Pattern in Other Layers
The Factory pattern can also be effectively utilized in various layers of an application, such as the infrastructure and presentation layers, where it can facilitate the conversion of Data Transfer Objects (DTOs) to Entities and vice versa. This approach significantly enhances the maintainability and testability of code.
Conclusion
The Factory pattern, rooted in the foundational concepts from the Gang of Four, remains a vital tool in software development. Whether implemented as an Abstract Factory or Factory Method, its primary purpose is to decouple creation logic from business logic, making the codebase more manageable and easier to test.
Useful Resources:
Thank you for being a part of our community! Don't forget to clap and follow for more insights. You can find additional content at PlainEnglish.io and stay updated through our newsletter.