laravel-ddd

Crafting an Action. The heart of business logic.

Crafting custom collections. Domain pipelines.

Crafting Concerns (traits). Thin wiring, not business logic.

Crafting Context Objects. Parameter encapsulation for complex operations.

Crafting thin controllers. Traffic cops, not business logic.

Crafting Domain Structure. Mini-Laravel-app per domain.

Crafting DTOs with Spatie Laravel Data v4.

Crafting Event-Driven Models. Side effects via observers.

Crafting Guard Clauses. Early returns for preconditions.

Crafting Jobs. Queue orchestration, not business logic.

Crafting the Eloquent model. Source of truth.

Crafting model states. Explicit state machines.

Crafting Null Objects. Safe defaults instead of null checks.

Crafting QueryBuilders. Eloquent power, not Repositories.

Crafting Queueable Actions. Skip job boilerplate.

Crafting Registries. Multi-provider handler dispatch.

Crafting Result Objects. Rich outcomes beyond success/failure.

Crafting Shared Domain. Cross-cutting concerns namespace.

Crafting Support namespace code. Reusable, domain-agnostic.

Crafting Test Factories. Beyond Laravel defaults.

Crafting Value Objects. Immutable, serialization-safe.

Crafting ViewModels. Data transformation for views.

When to abstract vs copy-paste. The rule of three.

When to use the fluent Builder pattern vs constructors or factories.

When to use Eloquent Cast vs Accessor. Value representation decisions.

When and how to process large datasets. Memory-efficient iteration.

When to use Trait+Interface vs Abstract Class. The art of mixing behaviors.

When to use DTO vs array. Type safety threshold.

When to eager load relationships. N+1 prevention decisions.

When to use enum vs state pattern. Complexity threshold.

When to use Events & Listeners vs direct calls. Decoupling decisions.

When to extract an Action class vs inline code. Extraction decisions.

When to return early vs throw. Control flow clarity.

When to place code in Support vs Domain. Namespace decisions.

When to use Laravel Pipelines vs sequential calls. Flow decisions.

When to queue work vs execute synchronously. Async decisions.

When to use the Registry pattern for runtime extensibility.

When to stream vs chunk vs load all. Memory vs complexity.

Action composition. Reuse without deep chains.

Consumer-first design. Shape the call-site before the implementation.

Domain evolution. Refactor structure as understanding deepens.

Domain thinking. Code mirrors business reality.

Fail-fast patterns. Reject invalid input at the boundary.

Laravel philosophy. Convention over config. Eloquent as truth. Invoke ONCE when entering Laravel context.

Pragmatism. Balance strictness with shipping.

Type safety philosophy. Catch bugs at write time, not run time.

Laravel polish. PHP/Laravel standards for each polish pass. Invoke when polishing PHP/Laravel code.