Node.js Design Patterns

When writing asynchronous code in Node.js, the default and fundamental pattern used is the callback pattern. There are, however, pitfalls to using this pattern at scale and complexity.

   •  Examine the callback pattern using an example

   •  Know more about callback hell

   •  Examine a callback hell situation using example code

To prevent callback hell, we can use promises which results in cleaner and manageable asynchronous code.

   •  Define promises and its workings

   •  Know how promises can help us write cleaner code

   •  Implement promises in a Node.js application

While promises help us write cleaner asynchronous code, the async/await pattern further simplifies this pattern by letting you write synchronous style code.

   •  Define the async/await pattern and its synchronous style execution pattern

   •  Handle multiple asynchronous methods using async/await

   •  Examine the async/await pattern using an example

A generator function produces an iterator and allows you to pause and resume execution. This allows you to implement controlled iteration which can be incredibly useful for tasks like paging.

   •  Understand the difference between regular functions and generators

   •  Explore the anatomy of a generator function and async generators

   •  Implement generators and async generators in code

Writing modular code is at the heart of Node.js applications. At its core, it implements the revealing module pattern. We can also implement this pattern when using ES6 classes.

   •  Examine the Node.js module system and the issue of scope

   •  Understand the revealing module pattern in Node.js

   •  Implement the revealing module pattern effectively when using ES6 classes

Node.js apps are made up of multiple dependencies. Hard wiring and tightly coupled dependencies can result in a lot of refactoring. The dependency injection pattern helps us write decoupled code.

   •  Understand the issues with tightly coupled dependencies

   •  Examine the dependency injection pattern as a solution to tight cohesion

   •  Implement the dependency injection pattern in a Node.js app

There is often a need to introduce a virtualization layer between an object and a consumer, without introducing changes to the interface. This is where the proxy pattern is particularly useful.

   •  Examine the proxy pattern and understand its typical use cases

   •  Implement the pattern using composable wrappers with the proxy API

   •  Implement the proxy for encrypting data and creating an observable object

When designing interfaces that have to work with another interface, we often need to bridge the differences in implementation without causing major code refactoring. The adapter pattern helps us achieve this result.

   •  Examine the pattern and its application as a bridge between two interfaces

   •  Examine a scenario where a change of database engine introduces API incompatibilities

   •  Implement an adapter to solve the incompatibilities

When an object needs to be augmented with additional capabilities, the usual route is to subclass. However, when subclasses are not an option, decorators can be used to dynamically add features.

   •  Examine the pattern and how it can empower an object

   •  Examine decorators for functions as a higher order function

   •  Implement the TC39 proposed decorator syntax for classes

Designing hierarchical trees of objects which stem from a base class can be tough. The composite pattern comes to rescue and allows you to create leaf nodes and collections of leaves that implement a common interface.

   •  Examine the composite pattern and its elements

   •  Learn the need for a uniform interface across entities and collection of entities

   •  Implement the composite pattern in a Node.js

When you want to maintain a uniform interface and still be able to offer multiple flavors of algorithms, the strategy design pattern comes to rescue.

   •  Examine the strategy pattern and its use

   •  Understand the constituents of the strategy pattern

   •  Implement the strategy pattern in a hypothetical payment gateway

Designing a uniform interface that helps invoke commands can be hard, especially when every command is implemented uniquely. The command design pattern helps us write a diverse set of operations, without affecting or refactoring the invocation interface.

   •  Understand the need for the command pattern

   •  Examine the internals of the command pattern

   •  Implement the command pattern in a command line blog app

When designing systems that should react to changes in an object, you can implement the observer pattern. This pattern allows you to observe state changes and implement one or more dependencies that are notified automatically.

   •  Examine the observer pattern and compare its benefits with the callback pattern

   •  Understand the event emitter interface in Node.js

   •  Implement the observer pattern using the event emitter interface

When an incoming request or data needs to be augmented/modified before it actually is consumed by the target object, a series of intermediary functions can be designed. The middleware pattern helps us implement such a pipeline of functions easily.

   •  Understand the need for the middleware pattern

   •  Explore the role of a middleware manager and use cases

   •  Create a middleware manager in Node.js

Designing uniform interfaces when the internal implementation varies, is always a challenge and we’ve seen how patterns like strategy can help us streamline the process. The template pattern also helps us build a uniform interface when internal implementations are bound to vary by usage.

   •  Understand the template pattern and its constituents

   •  Learn the role of the abstract class and template methods

   •  Implement the template method pattern in an app

When multiple clients need to request data from a server or a resource, the request-reply pattern is the right choice to do the job.

   •  Understand the request – reply pattern.

   •  Examine the role of the correlation identifier.

   •  Implement the request and reply pattern in a simple Node.js app.

When multiple services need to communicate with each other, or when two isolated mediums want to share data, or when a source needs to publish data for multiple independent consumers, the publisher – subscriber pattern is a great solution.

   •  Understand the publisher-subscriber pattern and its use cases.

   •  Study the role of a message broker as a unifying medium.

   •  Demonstrate the use of a message broker and the publisher – subscriber pattern.