Domain-Driven Design with Laravel (Martin Joo)（Z-Library）

【One-Line Pitch】 A practical, project-driven guide to applying Domain-Driven Design (DDD) patterns inside Laravel, showing you how to build a real-world email marketing platform (like ConvertKit or MailChimp) while keeping your code clean, testable, and maintainable. Ideal for Laravel developers who want to move beyond tutorials and learn how to structure complex applications with Actions, Value Objects, View Models, and more. 【Book Arc】 - **Opening (~0%–3%)**: Introduces the core promise—mastering DDD the "Laravel way"—and contrasts it with the author's past experience of writing overly complex, factory-heavy code. Sets the stage for a pragmatic, framework-native approach to DDD rather than a purist one. - **Early (~3%–13%)**: Lays the foundational building blocks: Value Objects (wrapping scalar data with formatting logic), custom Eloquent casts, and the debate between repositories and custom query builders. The author argues that query builders are the more Laravel-idiomatic equivalent of repositories. - **Early (~13%–19%)**: Introduces Actions (invokable classes for single-use operations), View Models (for preparing page-specific data), and States/Transitions (replacing status strings with class-based state logic). These patterns are shown with concrete code examples. - **Early (~19%–29%)**: Shifts to the demo application—an email marketing platform. Describes the core features (subscribers, tags, broadcasts, sequences, forms, tracking) and begins designing the domain model, including the `sent_mails` polymorphic table for tracking sent emails. - **Middle (~29%–48%)**: Covers code organization by Domains (e.g., `Domain\Subscriber`, `Domain\Shared`) and Applications. Explains how to handle the User model, BaseModel, factories, and global scopes (like `UserScope` for tenant-like filtering). Introduces DTOs via the `laravel-data` package, which unifies Request, Resource, and DTO into one class. - **Middle (~48%–end)**: Demonstrates practical implementation details: building subscriber lists with pagination, using View Models with Inertia.js, creating APIs from the same codebase, and handling CSV imports with tag creation. The book concludes by showing how all patterns work together in a complete, real-world flow. 【Key Takeaways】 - **Value Objects turn scattered scalar data into cohesive, typed objects** (Early): Instead of passing raw floats or strings around, wrap them in classes like `Percent` or `Millions` that encapsulate formatting and null-handling. This improves type safety and centralizes formatting logic. - **Custom query builders are the Laravel-native alternative to repositories** (Early): Override `newEloquentBuilder` on your model to return a custom builder class. This keeps models thin and queries organized without the ceremony of repository interfaces. - **Actions are invokable classes for single-use operations** (Early): Use `__invoke` to create callable classes like `CreateTodoAction`. They're easy to inject, test, and compose—especially when one action needs to call another. - **View Models prepare page-specific data without cluttering controllers** (Early): A View Model exposes public methods that return DTOs or collections, and a base class uses reflection to convert those methods into an array for the frontend. This is especially powerful with Inertia.js. - **States and Transitions replace fragile status strings** (Early): Instead of checking `if ($status === 'draft')`, use dedicated state classes. This makes state logic explicit, type-safe, and easier to extend. - **Organize code by Domains, not by class type** (Middle): Structure folders like `Domain\Subscriber\Models` and `Domain\Shared\Models` instead of `App\Models`. This aligns with DDD's bounded contexts and makes it clear which code belongs to which feature area. - **DTOs via `laravel-data` unify Request, Resource, and Data Transfer** (Middle): One class handles validation rules, request injection, and response serialization. This reduces boilerplate and keeps data contracts consistent across web and API routes. - **Global scopes can enforce user ownership automatically** (Middle): A `UserScope` that adds `whereBelongsTo($user)` to every query simplifies multi-user applications, but be careful—it only works when a request exists, so CLI commands need explicit `user_id` handling. 【Reading Tips】 - **Skim the opening code examples** (~0%–3%): The legacy factory code is meant to show what *not* to do. Focus on the Value Object and cast examples that follow—they're the foundation for everything else. - **Deep-read the Action and View Model chapters** (~13%–19%): These are the most reusable patterns. Pay attention to how Actions are injected and how View Models use reflection—this will save you hours of refactoring later. - **Treat the demo app chapters as a case study** (~19%–48%): Don't get bogged down in every feature detail. Instead, watch how the author decides *where* to put things (Domains, Shared, Actions) and how the patterns interact. - **Watch for the `laravel-data` package specifics** (~32%–42%): The static `rules` method and the `ignore` callback are non-obvious. If you plan to use this package, read these sections carefully. - **Take away the "why" over the "how"**: The author frequently explains *why* he prefers query builders over repositories or DTOs over arrays. These opinions are the real value—they'll help you make your own architectural decisions. 【Coverage Limits】 This guide covers the book's core patterns (Value Objects, Actions, View Models, States, Domains, DTOs, CQRS) and the email marketing demo application. The excerpts do not cover the final chapters on CQRS implementation details, advanced reporting, or deployment concerns—those sections were not included in the source material.