Implementing the Clean Architecture

Foreword
	Why I wrote this book?
	Tools-driven era
Who is this book for?
What will you find in this book?
The Clean Architecture basics
	What is it all for?
	Code Organization - horizontal slicing
	External world
	Infrastructure
	Application
	Domain
	The Dependency Rule
	Boundaries
	MVC anyone?
	Chapter summary
Referential implementation
	Disclaimer
	Control flow in the Clean Architecture
	Business requirements
	Implementation
	Sequence diagram
	Input Boundary
	Output Boundary
	Presenter
	View model
	Use Case
	Data Access Interface
	Data Access
	Entities - Bid
	Entities - Auction
	Chapter summary
The Clean Architecture modifications
	Presenter dilemma
	Getting rid of Input Boundary
	Alternative design of Use Cases
	Application Facade
	Command handlers + Mediator (Command Bus)
	Modeling Entities using ORM
	Chapter summary
Dependency injection
	Abstractions & classes everywhere!
	Abstractions in the Clean Architecture
	Inversion of Control
	IoC Container vs Service Locator
	Dependency Injection vs configuration
	Chapter summary
CQRS
	Introduction
	What does it have to do with the Clean Architecture?
	Separate read stack - why?
	Separate read stack - how?
	Query as DTO
	Queries as separate classes
	Read model facade
	CQRS vs REST API
	CQRS vs GraphQL
	Chapter summary
Sharp boundary
	A word on complexity
	Two worlds
	Boundary between Application and External World
	Writing Input DTOs
	Value objects
	Chapter summary
End-To-End example
	Where to start?
	Walking skeleton
	PlacingBid Use Case / Interactor
	Naming
	Arguments
	Output
	Unit testing
	Auction and Bid Entities
	Naming
	Value Objects for identity types
	Implementation
	Unit testing
	Implementation continued
	Data Access Interface (Abstract Repository)
	Naming
	Implementation
	Data Access (Repository)
	In-memory implementation
	Evolving in-memory implementation with TDD
	Finishing our first Use Case
	Dependency Injection
	Making first reasonable test pass
	Remove boilerplate code with Refactoring
	Packaging code
	Packaging Application & Domain code
	Packaging Infrastructure code
	Main - putting everything together
	Attaching web interface
	Implementing EndingAuction Use Case
	Use Case outline with Input DTO
	Extending Auction Entity to fulfilL new requirements
	If Entites should not have any dependencies, can they use time functions?
	Introducing Port for payments
	Error handling vs The Dependency Rule
	Implementing Adapter
	How to live when Adapter grows?
	Read only operations
	Use Case - based approach
	CQRS to the rescue
	Liberal approach with Read Model Facade
	A little bit more structured approach with Query classes
	Inverting Control with Events
	Example - sending e-mails
	Inverting control techniques
	Event implementation
	Where do I get one of these Event Buses from?
	How to get events out of Entities?
	Subscribing to Events
	Testing Entities that emit Events
	Events vs transactions vs side effects
	Introducing Unit Of Work
	Reliable message-sending: The outbox pattern
	Unit Of Work lifetime
	Relation between Unit Of Work and Event Bus
	Dealing with other cross-cutting concerns
	Configuration
	Validation
	Synchronization
	Chapter summary
Modularity
	The burden of success - growth & continuous changes
	Cohesion and modules
	Packaging code by feature
	Modules and flexibility of interior design
	Modules versus microservices
	Modules versus user
	Modules vs Bounded Contexts
	Modules implementation
	Strategic Domain-Driven Design
	Modules depending on each other
	Separate ways
	Direct dependency - both modules implement the Clean Architecture
	Indirect dependency - two instances of the Clean Architecture
	Dependency when one of the modules is not implementing the Clean Architecture
	Flavors of events-based integration
	Dependencies between modules - reassurance
	Case study - auctioning platform
	Discover different modules
	Auctioning platform modules
	Anatomy of a module - common part
	Modules’ architecture differences - can they be unified?
	Dependencies between modules
	Events emitting and handling basics
	In-module event handling
	Cross-modules event handling - simple cases
	Cross-modules event handling - complex cases
	Process Manager versus persistence
	Process Manager versus race conditions
	Chapter summary
Testing
	Testing strategy and feature flavors
	The Test Pyramid - a myth or the only right thing to do?
	Tests types taxonomy
	How to test a database browser?
	How to test a proxy to other systems?
	How to test a deep system?
	Rediscovering unit-testing
	black- and white-box testing
	state and interaction oriented testing
	Introduction
	Perils of state oriented testing
	Perils of interaction oriented testing
	Stubs versus mocks
	Unit-testing of an entire module
	Testing doubles - quick recap
	Putting a system under test in a desired state (Arrange / Given)
	Invoking an action on system under test (Act / When)
	Verification (Assert / Then)
	Dealing with dependencies (Ports & Repositories)
	Chapter summary
Final words
Appendix A: Migrating from legacy
	Should I even migrate?
	How to do it?
	“I cannot stop delivering new features”
Appendix B: Introduction to Event Sourcing
	What is Event Sourcing?
	Simple example of an Event Sourcing aggregate
	Order as Entity
	Introducing events
	These are not domain events we saw before!
	Order as Aggregate
	Testing aggregates
	Persistence in Event Sourcing
	Append-only event streams
	Retrieving strategy
	Storing strategy
	Requirements wrap-up
	Example implementation using PostgreSQL
	Snapshots
	Projections
	Event Sourcing versus a modular application
	Event Sourcing is a private detail of a module (including testing)
	Need integration? Use Domain Events alongside Event Sourcing events
Bibliography