Node.js Design Patterns: Design and implement production-grade Node.js applications using proven patterns and techniques, 3rd Edition

Cover
Copyright
Packt Page
Contributors
Table of Contents
Preface
Chapter 1: The Node.js Platform
	The Node.js philosophy
		Small core
		Small modules
		Small surface area
		Simplicity and pragmatism
	How Node.js works
		I/O is slow
		Blocking I/O
		Non-blocking I/O
		Event demultiplexing
		The reactor pattern
		Libuv, the I/O engine of Node.js
		The recipe for Node.js
	JavaScript in Node.js
		Run the latest JavaScript with confidence
		The module system
		Full access to operating system services
		Running native code
	Summary
Chapter 2: The Module System
	The need for modules
	Module systems in JavaScript and Node.js
	The module system and its patterns
		The revealing module pattern
	CommonJS modules
		A homemade module loader
		Defining a module
		module.exports versus exports
		The require function is synchronous
		The resolving algorithm
		The module cache
		Circular dependencies
	Module definition patterns
		Named exports
		Exporting a function
		Exporting a class
		Exporting an instance
		Modifying other modules or the global scope
	ESM: ECMAScript modules
		Using ESM in Node.js
		Named exports and imports
		Default exports and imports
		Mixed exports
		Module identifiers
		Async imports
		Module loading in depth
			Loading phases
			Read-only live bindings
			Circular dependency resolution
		Modifying other modules
	ESM and CommonJS differences and interoperability
		ESM runs in strict mode
		Missing references in ESM
		Interoperability
	Summary
Chapter 3: Callbacks and Events
	The Callback pattern
		The continuation-passing style
			Synchronous CPS
			Asynchronous CPS
			Non-CPS callbacks
		Synchronous or asynchronous?
			An unpredictable function
			Unleashing Zalgo
			Using synchronous APIs
			Guaranteeing asynchronicity with deferred execution
		Node.js callback conventions
			The callback comes last
			Any error always comes first
			Propagating errors
			Uncaught exceptions
	The Observer pattern
		The EventEmitter
		Creating and using the EventEmitter
		Propagating errors
		Making any object observable
		EventEmitter and memory leaks
		Synchronous and asynchronous events
		EventEmitter versus callbacks
		Combining callbacks and events
	Summary
	Exercises
Chapter 4: Asynchronous Control Flow Patterns with Callbacks
	The difficulties of asynchronous programming
		Creating a simple web spider
		Callback hell
	Callback best practices and control flow patterns
		Callback discipline
		Applying the callback discipline
		Sequential execution
			Executing a known set of tasks in sequence
			Sequential iteration
		Parallel execution
			Web spider version 3
			The pattern
			Fixing race conditions with concurrent tasks
		Limited parallel execution
			Limiting concurrency
			Globally limiting concurrency
	The async library
	Summary
	Exercises
Chapter 5: Asynchronous Control Flow Patterns with Promises and Async/Await
	Promises
		What is a promise?
		Promises/A+ and thenables
		The promise API
		Creating a promise
		Promisification
		Sequential execution and iteration
		Parallel execution
		Limited parallel execution
			Implementing the TaskQueue class with promises
			Updating the web spider
	Async/await
		Async functions and the await expression
		Error handling with async/await
			A unified try...catch experience
			The "return" versus "return await" trap
		Sequential execution and iteration
			Antipattern – using async/await with Array.forEach for serial execution
		Parallel execution
		Limited parallel execution
	The problem with infinite recursive promise resolution chains
	Summary
	Exercises
Chapter 6: Coding with Streams
	Discovering the importance of streams
		Buffering versus streaming
		Spatial efficiency
			Gzipping using a buffered API
			Gzipping using streams
		Time efficiency
		Composability
			Adding client-side encryption
			Adding server-side decryption
	Getting started with streams
		Anatomy of streams
		Readable streams
			Reading from a stream
			Implementing Readable streams
		Writable streams
			Writing to a stream
			Backpressure
			Implementing Writable streams
		Duplex streams
		Transform streams
			Implementing Transform streams
			Filtering and aggregating data with Transform streams
		PassThrough streams
			Observability
			Late piping
		Lazy streams
		Connecting streams using pipes
			Pipes and error handling
			Better error handling with pipeline()
	Asynchronous control flow patterns with streams
		Sequential execution
		Unordered parallel execution
			Implementing an unordered parallel stream
			Implementing a URL status monitoring application
		Unordered limited parallel execution
		Ordered parallel execution
	Piping patterns
		Combining streams
			Implementing a combined stream
		Forking streams
			Implementing a multiple checksum generator
		Merging streams
			Merging text files
		Multiplexing and demultiplexing
			Building a remote logger
			Multiplexing and demultiplexing object streams
	Summary
	Exercises
Chapter 7: Creational Design Patterns
	Factory
		Decoupling object creation and implementation
		A mechanism to enforce encapsulation
		Building a simple code profiler
		In the wild
	Builder
		Implementing a URL object builder
		In the wild
	Revealing Constructor
		Building an immutable buffer
		In the wild
	Singleton
	Wiring modules
		Singleton dependencies
		Dependency Injection
	Summary
	Exercises
Chapter 8: Structural Design Patterns
	Proxy
		Techniques for implementing proxies
			Object composition
			Object augmentation
			The built-in Proxy object
			A comparison of the different proxying techniques
		Creating a logging Writable stream
		Change observer with Proxy
		In the wild
	Decorator
		Techniques for implementing decorators
			Composition
			Object augmentation
			Decorating with the Proxy object
		Decorating a LevelUP database
			Introducing LevelUP and LevelDB
			Implementing a LevelUP plugin
		In the wild
	The line between proxy and decorator
	Adapter
		Using LevelUP through the filesystem API
		In the wild
	Summary
	Exercises
Chapter 9: Behavioral Design Patterns
	Strategy
		Multi-format configuration objects
		In the wild
	State
		Implementing a basic failsafe socket
	Template
		A configuration manager template
		In the wild
	Iterator
		The iterator protocol
		The iterable protocol
		Iterators and iterables as a native JavaScript interface
		Generators
			Generators in theory
			A simple generator function
			Controlling a generator iterator
			How to use generators in place of iterators
		Async iterators
		Async generators
		Async iterators and Node.js streams
		In the wild
	Middleware
		Middleware in Express
		Middleware as a pattern
		Creating a middleware framework for ZeroMQ
			The Middleware Manager
			Implementing the middleware to process messages
			Using the ZeroMQ middleware framework
		In the wild
	Command
		The Task pattern
		A more complex command
	Summary
	Exercises
Chapter 10: Universal JavaScript for Web Applications
	Sharing code with the browser
		JavaScript modules in a cross-platform context
			Module bundlers
			How a module bundler works
			Using webpack
	Fundamentals of cross-platform development
		Runtime code branching
			Challenges of runtime code branching
		Build-time code branching
		Module swapping
		Design patterns for cross-platform development
	A brief introduction to React
		Hello React
		Alternatives to react.createElement
		Stateful components
	Creating a Universal JavaScript app
		Frontend-only app
		Server-side rendering
		Asynchronous data retrieval
		Universal data retrieval
			Two-pass rendering
			Async pages
			Implementing async pages
	Summary
Chapter 11: Advanced Recipes
	Dealing with asynchronously initialized components
		The issue with asynchronously initialized components
			Local initialization check
			Delayed startup
		Pre-initialization queues
		In the wild
	Asynchronous request batching and caching
		What's asynchronous request batching?
		Optimal asynchronous request caching
		An API server without caching or batching
		Batching and caching with promises
			Batching requests in the total sales web server
			Caching requests in the total sales web server
			Notes about implementing caching mechanisms
	Canceling asynchronous operations
		A basic recipe for creating cancelable functions
		Wrapping asynchronous invocations
		Cancelable async functions with generators
	Running CPU-bound tasks
		Solving the subset sum problem
		Interleaving with setImmediate
			Interleaving the steps of the subset sum algorithm
			Considerations on the interleaving approach
		Using external processes
			Delegating the subset sum task to an external process
			Considerations for the multi-process approach
		Using worker threads
			Running the subset sum task in a worker thread
		Running CPU-bound tasks in production
	Summary
	Exercises
Chapter 12: Scalability and Architectural Patterns
	An introduction to application scaling
		Scaling Node.js applications
		The three dimensions of scalability
	Cloning and load balancing
		The cluster module
			Notes on the behavior of the cluster module
			Building a simple HTTP server
			Scaling with the cluster module
			Resiliency and availability with the cluster module
			Zero-downtime restart
		Dealing with stateful communications
			Sharing the state across multiple instances
			Sticky load balancing
		Scaling with a reverse proxy
			Load balancing with Nginx
		Dynamic horizontal scaling
			Using a service registry
			Implementing a dynamic load balancer with http-proxy and Consul
		Peer-to-peer load balancing
			Implementing an HTTP client that can balance requests across multiple servers
		Scaling applications using containers
			What is a container?
			Creating and running a container with Docker
			What is Kubernetes?
			Deploying and scaling an application on Kubernetes
	Decomposing complex applications
		Monolithic architecture
		The microservice architecture
			An example of a microservice architecture
			Microservices – advantages and disadvantages
		Integration patterns in a microservice architecture
			The API proxy
			API orchestration
			Integration with a message broker
	Summary
	Exercises
Chapter 13: Messaging and Integration Patterns
	Fundamentals of a messaging system
		One way versus request/reply patterns
		Message types
			Command Messages
			Event Messages
			Document Messages
		Asynchronous messaging, queues, and streams
		Peer-to-peer or broker-based messaging
	Publish/Subscribe pattern
		Building a minimalist real-time chat application
			Implementing the server side
			Implementing the client side
			Running and scaling the chat application
		Using Redis as a simple message broker
		Peer-to-peer Publish/Subscribe with ZeroMQ
			Introducing ZeroMQ
			Designing a peer-to-peer architecture for the chat server
			Using the ZeroMQ PUB/SUB sockets
		Reliable message delivery with queues
			Introducing AMQP
			Durable subscribers with AMQP and RabbitMQ
		Reliable messaging with streams
			Characteristics of a streaming platform
			Streams versus message queues
			Implementing the chat application using Redis Streams
	Task distribution patterns
		The ZeroMQ Fanout/Fanin pattern
			PUSH/PULL sockets
			Building a distributed hashsum cracker with ZeroMQ
		Pipelines and competing consumers in AMQP
			Point-to-point communications and competing consumers
			Implementing the hashsum cracker using AMQP
		Distributing tasks with Redis Streams
			Redis consumer groups
			Implementing the hashsum cracker using Redis Streams
	Request/Reply patterns
		Correlation Identifier
			Implementing a request/reply abstraction using correlation identifiers
		Return address
			Implementing the Return Address pattern in AMQP
	Summary
	Exercises
Other Books You May Enjoy
Index