Implementing DDD, CQRS and Event Sourcing

This product has no download link. After payment, the download link will be sent by support.

by Alex Lawrence (Author) 

Learn how to implement DDD, CQRS and Event Sourcing. Understand the theory and put it into practice with JavaScript and Node.js. Utilize an extensive source code bundle and an interactive execution feature for a hands-on experience.

This book explains and illustrates how to implement Domain-Driven Design, Command Query Responsibility Segregation and Event Sourcing. The goal is to build software that is behavior-rich, event-based, problem-centric, reactive, scalable and well-designed. Domain-Driven Design is a concept that focuses on the problem space and its associated knowledge areas. Command Query Responsibility Segregation separates a software into a write side and a read side. Event Sourcing is an architectural pattern that represents state as a sequence of immutable events. The concepts are explained in theory and put into practice with standalone examples and a Sample Application. This is done without third-party software. The book comes with a source code bundle and supports interactive execution. All code is written in JavaScript and uses Node.js as runtime.

Style of this book

The primary focus of this book is the application and the implementation of concepts. Therefore, the purely theoretical parts are generally concise. The covered topics are illustrated extensively with a large amount of examples and code. Nevertheless, selected conceptual parts are discussed in greater detail. Apart from Node.js and JavaScript, this book does not utilize or explain specific frameworks or technologies. For all functionalities that require persistence or inter-process communication, it provides exemplary implementations that directly work with the filesystem. This includes Repositories, the Event Store, Read Model storages and a remote event distribution. The goal is to convey a deeper understanding of the concepts that are related to persistence and messaging. For production purposes, these implementations can be easily replaced with suitable technologies.

Table of Contents

Preface
Version & Feedback
Style of this book
Executing the code
About the author
Formatting and highlighting
Chapter summary
Chapter 1: Domains
Technological and business domains
Domain Experts
Subdomains
Identification of Subdomains
Sample Application: Domains
Chapter 2: Domain Models
Structure and components
Ubiquitous Language
Model representations
Domain Modeling
Sample Application: Domain Models
Chapter 3: Bounded Contexts
Relation to Domains
Model and context sizes
Contexts and language
Technological boundaries
Context Maps
Sample Application: Bounded Contexts
Chapter 4: Software Architecture
Common software parts
Layered Architecture
Onion Architecture
Approach for this book
Sample Application: Software architecture
Chapter 5: Code quality
Model binding
Readability
Behavior and state
Dealing with dependencies
Command-Query-Separation
Chapter 6: Value Objects, Entities and Services
Value Objects
Entities
Domain Services
Invariants
Sample Application: Domain Model implementation
Chapter 7: Domain Events
Relation to Event-driven Architecture
Naming conventions
Structure and content
Distribution and processing
Sample Application: Event-based integration
Chapter 8: Aggregates
Transactions
Structure and access
Concurrency
Design considerations
Eventual Consistency
Sample Application: Aggregates
Chapter 9: Repositories
Domain Model emphasis
Design and implementation
Optimistic Concurrency
Interaction with Domain Events
Sample Application: Repositories and event publishing
Chapter 10: Application Services
Service design
Use case scenarios
Transactions and Processes
Cross-cutting concerns
Authentication and Authorization
Sample Application: Application Services
Chapter 11: Command Query Responsibility Segregation
Architectural overview
Write and Read Model
Read Model synchronization
Commands and Queries
Command and Query Handlers
Sample Application: CQRS
Chapter 12: Event Sourcing
Architectural overview
Event-sourced Write Model
Event Store
Read Model Projection
Domain Event publishing
Sample Application: Event Sourcing
Chapter 13: Separate executable programs
Program layouts
Context-level communication
Remote use case execution
Remote event distribution
Sample Application: Separate executable programs
Chapter 14: User Interface
HTTP file server
Task-based UI
Optimistic UI
Reactive Read Models
Components and composition
Sample Application: User Interface
Conclusion
Apply what makes sense
Going into production
Exemplary technology stack
Bibliography