From Core to Contract

Volume I built a core with no database and no web server, and dared you to call that a limitation. From Core to Contract is the volume where the database and the wire finally arrive — and the entire discipline is keeping them on their own side of the seam.

This is the second volume of the NEXUS-1 backend trilogy. It takes the fully tested Domain and Application layers built in From Blueprint to Core and gives them the two things Clean Architecture spends its whole life holding at arm's length: persistence and a public API. By the last page, EF Core is mapping an aggregate to real SQL Server tables, HTTP requests are flowing in and problem-details refusals are flowing back out, JWTs are being issued and validated — and not one line of that infrastructure has reached up past the boundary to change a rule the core already proved.

That restraint is the subject of the book. Anyone can wire up a DbContext and a controller. The hard part — the part most books wave through — is doing it so that the framework, the database, and the wire format stay below the seam, adapters to ports that were declared before any of them existed. This volume implements those ports against the exact 654 tables of the published schema atlas, across 17 bounded contexts, and it does so under the same standing rule that governs the whole series: nothing claims to exist that does not. Every project compiles, every class is shown in full, and every invariant is proven by a test that commits the exact crime the rule forbids and watches it fail by name.

It practices what it teaches. Every boundary decision is made once, in the open, and then held to. When the outbox needs a table of its own in Chapter 7, it doesn't quietly appear — it is admitted as a lawful Infrastructure citizen by amending, on the page, the very statute Chapter 2 wrote to keep Infrastructure out of the Domain's tables. When an earlier chapter's own code needs correcting, the fix happens in a visible diff, not in silence.

It shows its refusals, not just its successes. Optimistic concurrency isn't asserted — it's watched, with two real database connections racing for the same row until one loses by name. A DTO leak is proven by shipping the domain-carrying type on purpose and reading the leak back as JSON. Refusals cross the wire as RFC 7807 problem details carrying the platform's published refusal codes, so the client sees the same "no" the core meant.

It draws what it explains. Eighteen chapters are each followed by a two-page Deep Dive companion — plain-language explanations and original UML for readers newer to persistence, EF Core, web APIs, tokens, and authorization, adding floors under the material without lowering the technical ceiling above it. A recurring "Where We Are in the Solution" panel tracks the growing codebase, the migration's table count, and the test total, so you always know exactly how much of the system exists at any page.

It knows exactly what it hasn't built yet. The book closes with an Epilogue — The Honest Boundary of Volume II — an itemized account of what is deliberately deferred (the outbox dispatcher, the integration harness, logging, configuration environments, health checks, the container) and which volume owns each one. The seam to Volume III is stated in plain sight; it is part of the design, not an omission.

• Part I — The Persistence Boundary. The NexusDbContext wired to the configuration atlas of From Entity to Context; repositories as three-line adapters behind Volume I's ports; the Unit of Work with its after-commit dispatch clause; optimistic concurrency armed by a single typed RowVersion; the write half of the outbox; and migrations and seeding that build to the exact tables of the schema atlas.
• Part II — The API Layer. The composition root completed; controllers kept honest by a thinness statute; DTOs and the three-vocabularies translation that keeps the Domain off the wire; refusals as RFC 7807; idempotency as a pipeline behavior; and versioning behind a browsable, honest Swagger contract.
• Part III — The Security Context (The Closing Act). Operators and roles modeled in code; JWT issuance and validation; and authorization where OperatorId is no longer taken on faith but carried, checked, and enforced.
• Part IV — First Light. One operational night, traced end to end over a real wire — the whole stack the book has built, from HTTP request to persisted twin and back, in a single run that proves the layers actually meet.
• Five appendices — an installation guide, the full Volume-II solution skeleton, the tools-and-packages ledger, the bounded-context → schema → DbContext map, and the refusal-code → HTTP-status registry — plus source references, a glossary, and an index.

Developers who have read a Clean Architecture or DDD book and then hit the question those books skip: how do you add a database and an HTTP API without the framework leaking upward into the rules you worked so hard to isolate? Architects who want a fully worked persistence-and-API layer to hold their own team's decisions against. And readers of Volume I who want to watch the ports finally get their adapters.

Volume I is a companion, not a prerequisite — but this book assumes a tested Domain and Application core already exists, and From Blueprint to Core is where that core was built. Everything you need to follow this book's code is inside it.

Author: Grigorios Kyriakos Agathangelidis

Greek name: Γρηγόριος Κυριάκος Αγαθαγγελίδης

Also searchable as: Αγαθαγγελίδης Γρηγόριος, Αγαθαγγελιδης Γρηγοριος, Grigorios Agathangelidis.