Domain-Driven Design Fundamentals with PHP

What Is Domain-Driven Design?

Domain-Driven Design (DDD) is a software design approach that puts the business domain at the centre of every decision. Instead of starting with a database schema or a framework, you start by deeply understanding the problem space — the domain — and modelling your code to mirror it.

Eric Evans introduced DDD in his 2003 book and the core insight is deceptively simple: the code should speak the same language as the business experts. When a lecturer says “a student enrols in a course only if they have completed the prerequisite,” your Enrolment class should enforce that rule — not some orphaned if statement in a controller a thousand lines away.

Common Misconceptions

In this tutorial, you will learn the four pillars of DDD — Ubiquitous Language, Bounded Contexts, Building Blocks, and Layered Architecture — and apply them by refactoring a real PHP example.

Apa Itu Domain-Driven Design?

Domain-Driven Design (DDD) adalah pendekatan desain perangkat lunak yang menempatkan domain bisnis di pusat setiap keputusan. Alih-alih memulai dengan skema database atau framework, Anda mulai dengan memahami secara mendalam ruang masalah, yaitu domain, lalu memodelkan kode Anda untuk mencerminkannya.

Eric Evans memperkenalkan DDD dalam bukunya tahun 2003 dan wawasan intinya sederhana namun menipu: kode harus berbicara dalam bahasa yang sama dengan para ahli bisnis. Ketika seorang dosen mengatakan “mahasiswa mendaftar mata kuliah hanya jika mereka telah menyelesaikan prasyaratnya,” kelas Enrolment Anda harus menegakkan aturan itu, bukan statement if yatim piatu di controller yang berjarak seribu baris.

Kesalahpahaman Umum

Dalam tutorial ini, Anda akan mempelajari empat pilar DDD: Ubiquitous Language, Bounded Contexts, Building Blocks, dan Layered Architecture, lalu menerapkannya dengan me-refactor contoh PHP nyata.

Pillar 1: Ubiquitous Language

The Problem

In a typical campus system, the same concept has different names in different places. The business expert says “course registration,” the database schema has a table called enrolments, the controller variable is $reg, and the API returns { "enrollment_status": "confirmed" }. When a bug report arrives, nobody is sure which term refers to what.

This translation layer — from business language to code language and back — is the source of countless misunderstandings and bugs.

The Solution

Ubiquitous Language is a shared, precise vocabulary used by everyone on the project: domain experts, developers, QA, and even the UI copy. The same term appears in conversation, user stories, class names, database columns, and API responses.

Building a Ubiquitous Language

Step 1 — Sit with a domain expert (a lecturer, a registrar) and capture raw statements:

“When a student wants to join a course, they submit a registration request. The system checks whether the student has completed all required prerequisite courses. If they have, the registration is confirmed and the student is added to the course roster.”

Step 2 — Extract the nouns and verbs. These become candidates for classes and methods:

Step 3 — Enforce the language in code. Never let a controller variable $reg slip through when the domain says $enrolment. Every mismatch erodes trust in the model.

PHP Example: Before and After

Before — inconsistent language:

<?php

class RegistrationCtrl
{
    public function joinCourse($sid, $cid): array
    {
        $reg = $this->db->findReg($sid, $cid);
        if ($reg) {
            return ['error' => 'already_in'];
        }

        $done = $this->checkDone($sid, $cid);
        if (!$done) {
            return ['error' => 'prereq_missing'];
        }

        $this->db->insertReg($sid, $cid);
        return ['status' => 'ok'];
    }

    private function checkDone($sid, $cid): bool
    {
        // Ambiguous: "done" what? Completed the course? Completed prerequisites?
        return true;
    }
}

After — ubiquitous language in class and method names:

<?php

class EnrolmentService
{
    public function enrol(Student $student, Course $course): EnrolmentResult
    {
        if ($this->enrolmentRepository->exists($student, $course)) {
            return EnrolmentResult::alreadyEnrolled();
        }

        if (!$student->hasCompletedPrerequisitesFor($course)) {
            return EnrolmentResult::prerequisitesNotMet(
                $course->prerequisitesNotCompletedBy($student)
            );
        }

        $enrolment = $student->enrolIn($course);
        $this->enrolmentRepository->save($enrolment);

        return EnrolmentResult::confirmed($enrolment);
    }
}

No translation needed. The code reads like the domain expert’s sentence.

Rules of Thumb

Pilar 1: Ubiquitous Language

Masalahnya

Dalam sistem kampus yang umum, konsep yang sama memiliki nama berbeda di tempat berbeda. Pakar bisnis mengatakan “registrasi mata kuliah,” skema database memiliki tabel bernama enrolments, variabel controller adalah $reg, dan API mengembalikan { "enrollment_status": "confirmed" }. Ketika laporan bug tiba, tidak ada yang yakin istilah mana merujuk ke apa.

Lapisan translasi ini, dari bahasa bisnis ke bahasa kode dan kembali, adalah sumber dari kesalahpahaman dan bug yang tak terhitung jumlahnya.

Solusinya

Ubiquitous Language adalah kosakata bersama yang tepat yang digunakan oleh semua orang di proyek: pakar domain, pengembang, QA, dan bahkan teks UI. Istilah yang sama muncul dalam percakapan, user story, nama kelas, kolom database, dan respons API.

Membangun Ubiquitous Language

Langkah 1: Duduklah dengan pakar domain (dosen, petugas registrasi) dan tangkap pernyataan mentah:

“Ketika seorang mahasiswa ingin bergabung dengan mata kuliah, mereka mengajukan permintaan registrasi. Sistem memeriksa apakah mahasiswa telah menyelesaikan semua mata kuliah prasyarat yang diperlukan. Jika sudah, registrasi dikonfirmasi dan mahasiswa ditambahkan ke daftar hadir mata kuliah.”

Langkah 2: Ekstrak kata benda dan kata kerja. Ini menjadi kandidat untuk kelas dan metode:

Langkah 3: Tegakkan bahasa dalam kode. Jangan pernah biarkan variabel controller $reg lolos ketika domain mengatakan $enrolment. Setiap ketidakcocokan mengikis kepercayaan pada model.

Contoh PHP: Before dan After

Before (bahasa yang tidak konsisten):

<?php

class RegistrationCtrl
{
    public function joinCourse($sid, $cid): array
    {
        $reg = $this->db->findReg($sid, $cid);
        if ($reg) {
            return ['error' => 'already_in'];
        }

        $done = $this->checkDone($sid, $cid);
        if (!$done) {
            return ['error' => 'prereq_missing'];
        }

        $this->db->insertReg($sid, $cid);
        return ['status' => 'ok'];
    }

    private function checkDone($sid, $cid): bool
    {
        // Ambigu: "done" apa? Menyelesaikan mata kuliah? Menyelesaikan prasyarat?
        return true;
    }
}

After (ubiquitous language dalam nama kelas dan metode):

<?php

class EnrolmentService
{
    public function enrol(Student $student, Course $course): EnrolmentResult
    {
        if ($this->enrolmentRepository->exists($student, $course)) {
            return EnrolmentResult::alreadyEnrolled();
        }

        if (!$student->hasCompletedPrerequisitesFor($course)) {
            return EnrolmentResult::prerequisitesNotMet(
                $course->prerequisitesNotCompletedBy($student)
            );
        }

        $enrolment = $student->enrolIn($course);
        $this->enrolmentRepository->save($enrolment);

        return EnrolmentResult::confirmed($enrolment);
    }
}

Tidak perlu translasi. Kode terbaca seperti kalimat pakar domain.

Aturan Praktis

Pillar 2: Bounded Contexts

The Problem

A large domain — like a university — contains many sub-domains: course catalogues, student enrolment, billing, library management, attendance tracking. If you try to build one unified model that satisfies every sub-domain, you end up with a Student class that has 200 properties (GPA, overdue books, unpaid invoices, dormitory room number, dietary preferences for the cafeteria) and every change to one sub-domain breaks another.

The Solution

A Bounded Context is a logical boundary within which a particular domain model applies. Inside each context, terms have precise, unambiguous meanings. The same real-world thing (e.g., a “Student”) may have different models in different contexts, and that is not only acceptable — it is correct.

Context Map for a Campus System

These five models of “Student” share an identity (a StudentId UUID), but they do not share a class. The Billing context does not need to know the student’s GPA, and the Attendance context does not need to know about overdue library books.

Context Relationships

Bounded contexts communicate through well-defined interfaces. The diagram below shows a typical campus context map:

Pilar 2: Bounded Contexts

Masalahnya

Domain besar, seperti universitas, berisi banyak sub-domain: katalog mata kuliah, pendaftaran mahasiswa, penagihan, manajemen perpustakaan, pelacakan kehadiran. Jika Anda mencoba membangun satu model terpadu yang memuaskan setiap sub-domain, Anda akan berakhir dengan kelas Student yang memiliki 200 properti (IPK, buku yang terlambat, invoice yang belum dibayar, nomor kamar asrama, preferensi diet untuk kafetaria) dan setiap perubahan pada satu sub-domain merusak yang lain.

Solusinya

Bounded Context adalah batas logis di mana model domain tertentu berlaku. Di dalam setiap context, istilah memiliki makna yang tepat dan tidak ambigu. Hal dunia nyata yang sama (misalnya, “Student”) mungkin memiliki model yang berbeda di context yang berbeda, dan itu bukan hanya dapat diterima, melainkan benar.

Context Map untuk Sistem Kampus

Kelima model “Student” ini berbagi identitas (UUID StudentId), tetapi mereka tidak berbagi kelas. Context Billing tidak perlu tahu IPK mahasiswa, dan context Attendance tidak perlu tahu tentang buku perpustakaan yang terlambat.

Hubungan Antar Context

Bounded context berkomunikasi melalui antarmuka yang terdefinisi dengan baik. Diagram di bawah ini menunjukkan context map kampus yang umum:

Integrating Contexts: Shared Kernel vs Anti-Corruption Layer

Two contexts that need to share data have several options:

Shared Kernel — two contexts agree on a small, shared subset of the model. For example, Identity and Enrolment contexts both use the same StudentId value object. Keep the shared kernel as small as possible.

Anti-Corruption Layer (ACL) — when one context must consume data from another, build a translation layer that converts the external model into your internal model. This prevents the other context’s design from “leaking” into yours.

<?php

// Anti-Corruption Layer: Enrolment context calls Billing context
// but translates the response into its own model

class BillingAntiCorruptionLayer
{
    public function __construct(
        private BillingApiClient $billingClient
    ) {}

    public function getStudentPaymentStatus(StudentId $studentId): PaymentStatus
    {
        $raw = $this->billingClient->fetchStudent(
            $studentId->toString()
        );

        // Translate external model into Enrolment context's model
        return match ($raw['financial_status']) {
            'clear'        => PaymentStatus::Clear,
            'outstanding'  => PaymentStatus::Outstanding,
            'suspended'    => PaymentStatus::Suspended,
            default        => throw new \RuntimeException(
                "Unknown billing status: {$raw['financial_status']}"
            ),
        };
    }
}

An ACL is extra code, but it is a one-time investment. Without it, a change in the Billing API silently cascades into every if-statement that checks $raw['financial_status'].

Mengintegrasikan Context: Shared Kernel vs Anti-Corruption Layer

Dua context yang perlu berbagi data memiliki beberapa opsi:

Shared Kernel: dua context menyetujui subset kecil model yang dibagikan. Misalnya, context Identity dan Enrolment sama-sama menggunakan value object StudentId yang sama. Jaga shared kernel sekecil mungkin.

Anti-Corruption Layer (ACL): ketika satu context harus mengonsumsi data dari context lain, bangun lapisan translasi yang mengonversi model eksternal ke dalam model internal Anda. Ini mencegah desain context lain “bocor” ke dalam desain Anda.

<?php

// Anti-Corruption Layer: Context Enrolment memanggil context Billing
// tetapi menerjemahkan responsnya ke dalam modelnya sendiri

class BillingAntiCorruptionLayer
{
    public function __construct(
        private BillingApiClient $billingClient
    ) {}

    public function getStudentPaymentStatus(StudentId $studentId): PaymentStatus
    {
        $raw = $this->billingClient->fetchStudent(
            $studentId->toString()
        );

        // Terjemahkan model eksternal ke model context Enrolment
        return match ($raw['financial_status']) {
            'clear'        => PaymentStatus::Clear,
            'outstanding'  => PaymentStatus::Outstanding,
            'suspended'    => PaymentStatus::Suspended,
            default        => throw new \RuntimeException(
                "Status billing tidak dikenal: {$raw['financial_status']}"
            ),
        };
    }
}

ACL adalah kode tambahan, tetapi ini adalah investasi satu kali. Tanpanya, perubahan di Billing API secara diam-diam merambat ke setiap if-statement yang memeriksa $raw['financial_status'].

Pillar 3: DDD Building Blocks in PHP

DDD provides a set of tactical patterns — concrete building blocks you use to construct the domain model. Each block has a specific role and a specific set of rules.

Entity

An Entity is an object defined by its identity, not its attributes. Two Student objects with the same NIM are the same student, even if one has a stale name and the other has an updated one. Entities are mutable — their attributes change over time while their identity remains constant.

<?php

class Student
{
    /** @param Enrolment[] $enrolments */
    private array $enrolments = [];

    private function __construct(
        private StudentId $id,
        private string $name,
        private Email $email,
        private NIM $nim,
    ) {}

    public static function register(
        StudentId $id,
        string $name,
        Email $email,
        NIM $nim
    ): self {
        return new self($id, $name, $email, $nim);
    }

    public function enrolIn(Course $course): Enrolment
    {
        $enrolment = Enrolment::create(
            EnrolmentId::generate(),
            $this->id,
            $course->id(),
            new \DateTimeImmutable()
        );

        $this->enrolments[] = $enrolment;

        return $enrolment;
    }

    public function id(): StudentId { return $this->id; }
    public function name(): string { return $this->name; }
    public function email(): Email { return $this->email; }
    public function nim(): NIM { return $this->nim; }

    /** @return Enrolment[] */
    public function enrolments(): array { return $this->enrolments; }
}

Key rules:

• An entity always has an identifier (StudentId, EnrolmentId).
• Identity equality: $studentA->id()->equals($studentB->id()) determines sameness, not $studentA == $studentB.
• Entities encapsulate behaviour. The enrolIn() method is on Student, not in a separate StudentService.

Value Object

A Value Object has no identity. It is defined entirely by its attributes. Two Money objects with the same amount and currency are interchangeable. Value Objects are immutable — methods return new instances rather than modifying state.

<?php

class StudentId
{
    private function __construct(
        private string $value
    ) {}

    public static function generate(): self
    {
        return new self(bin2hex(random_bytes(16)));
    }

    public static function fromString(string $value): self
    {
        if (!preg_match('/^[a-f0-9]{32}$/', $value)) {
            throw new \InvalidArgumentException("Invalid StudentId: $value");
        }
        return new self($value);
    }

    public function equals(self $other): bool
    {
        return $this->value === $other->value;
    }

    public function toString(): string
    {
        return $this->value;
    }
}

<?php

class NIM
{
    private function __construct(
        private string $value
    ) {}

    public static function fromString(string $value): self
    {
        if (!preg_match('/^\d{10}$/', $value)) {
            throw new \InvalidArgumentException("NIM must be exactly 10 digits, got: $value");
        }
        return new self($value);
    }

    public function equals(self $other): bool
    {
        return $this->value === $other->value;
    }

    public function toString(): string
    {
        return $this->value;
    }

    public function admissionYear(): int
    {
        return (int) substr($this->value, 0, 4);
    }
}

<?php

class Email
{
    private function __construct(
        private string $value
    ) {}

    public static function fromString(string $value): self
    {
        if (!filter_var($value, FILTER_VALIDATE_EMAIL)) {
            throw new \InvalidArgumentException("Invalid email address: $value");
        }
        return new self(strtolower($value));
    }

    public function equals(self $other): bool
    {
        return $this->value === $other->value;
    }

    public function toString(): string { return $this->value; }

    public function domain(): string
    {
        return substr($this->value, strpos($this->value, '@') + 1);
    }
}

Entity vs Value Object — Quick Decision Table

Aggregate and Aggregate Root

An Aggregate is a cluster of entities and value objects treated as a single unit for data changes. The Aggregate Root is the single entry point — all external references to the aggregate go through the root.

Why? Without aggregates, any part of the code can modify any entity, and business invariants scatter across the codebase. With aggregates, the root guarantees consistency.

Example: The Enrolment aggregate:

• Aggregate root: Enrolment
• Internal entity: EnrolmentHistory (a log of status changes, never accessed directly)
• Invariant: “An enrolment cannot be confirmed if the maximum capacity is reached.”

<?php

class Enrolment
{
    /** @var EnrolmentHistory[] */
    private array $history = [];

    private function __construct(
        private EnrolmentId $id,
        private StudentId $studentId,
        private CourseId $courseId,
        private EnrolmentStatus $status,
        private \DateTimeImmutable $createdAt,
    ) {}

    public static function create(
        EnrolmentId $id,
        StudentId $studentId,
        CourseId $courseId,
        \DateTimeImmutable $createdAt
    ): self {
        $enrolment = new self($id, $studentId, $courseId, EnrolmentStatus::Pending, $createdAt);
        $enrolment->recordEvent(new EnrolmentCreated($id, $studentId, $courseId, $createdAt));
        return $enrolment;
    }

    public function confirm(int $currentEnrolmentCount, int $maxCapacity): void
    {
        if ($this->status !== EnrolmentStatus::Pending) {
            throw new \DomainException("Only pending enrolments can be confirmed.");
        }

        if ($currentEnrolmentCount >= $maxCapacity) {
            throw new \DomainException(
                "Course capacity reached ({$maxCapacity}). Cannot confirm enrolment."
            );
        }

        $this->status = EnrolmentStatus::Confirmed;
        $this->recordEvent(new EnrolmentConfirmed($this->id, new \DateTimeImmutable()));
    }

    public function cancel(): void
    {
        if ($this->status === EnrolmentStatus::Cancelled) {
            throw new \DomainException("Enrolment is already cancelled.");
        }

        $this->status = EnrolmentStatus::Cancelled;
        $this->recordEvent(new EnrolmentCancelled($this->id, new \DateTimeImmutable()));
    }

    public function id(): EnrolmentId { return $this->id; }
    public function studentId(): StudentId { return $this->studentId; }
    public function courseId(): CourseId { return $this->courseId; }
    public function status(): EnrolmentStatus { return $this->status; }

    private function recordEvent(object $event): void
    {
        $this->history[] = new EnrolmentHistory(
            EnrolmentHistoryId::generate(),
            $this->id,
            $event,
            new \DateTimeImmutable()
        );
    }
}

Key rules:

• Only the aggregate root (Enrolment) has a global identity. Internal entities have local identities.
• External code never holds a reference to EnrolmentHistory. It talks to Enrolment only.
• All invariants are checked inside the aggregate before state changes.
• Aggregates should be small. A University aggregate containing every Student and Course is the wrong granularity — prefer many small aggregates.

Repository

A Repository provides the illusion of an in-memory collection for aggregate roots. Application code retrieves and persists aggregates through the repository, never touching the database directly.

<?php

interface EnrolmentRepository
{
    public function save(Enrolment $enrolment): void;
    public function findById(EnrolmentId $id): ?Enrolment;
    public function findByStudent(StudentId $studentId): array;
    public function countForCourse(CourseId $courseId): int;
    public function exists(StudentId $studentId, CourseId $courseId): bool;
}

A concrete implementation using PDO (in the infrastructure layer):

<?php

class PdoEnrolmentRepository implements EnrolmentRepository
{
    public function __construct(private \PDO $pdo) {}

    public function save(Enrolment $enrolment): void
    {
        $stmt = $this->pdo->prepare(
            'INSERT INTO enrolments (id, student_id, course_id, status, created_at)
             VALUES (?, ?, ?, ?, ?)
             ON CONFLICT (id) DO UPDATE SET status = ?, created_at = ?'
        );
        $stmt->execute([
            $enrolment->id()->toString(),
            $enrolment->studentId()->toString(),
            $enrolment->courseId()->toString(),
            $enrolment->status()->value,
            $enrolment->createdAt()->format('Y-m-d H:i:s'),
            $enrolment->status()->value,
            $enrolment->createdAt()->format('Y-m-d H:i:s'),
        ]);
    }

    public function findById(EnrolmentId $id): ?Enrolment
    {
        $stmt = $this->pdo->prepare(
            'SELECT * FROM enrolments WHERE id = ?'
        );
        $stmt->execute([$id->toString()]);
        $row = $stmt->fetch(\PDO::FETCH_ASSOC);

        return $row ? $this->hydrate($row) : null;
    }

    private function hydrate(array $row): Enrolment
    {
        return new Enrolment(
            EnrolmentId::fromString($row['id']),
            StudentId::fromString($row['student_id']),
            CourseId::fromString($row['course_id']),
            EnrolmentStatus::from($row['status']),
            new \DateTimeImmutable($row['created_at']),
        );
    }

    // ... other methods
}

The PdoEnrolmentRepository lives in the infrastructure layer. The EnrolmentRepository interface lives in the domain layer. Application code depends on the interface — it never knows about PDO.

Domain Service

When a business operation does not naturally belong to any single entity, use a Domain Service. Unlike application services (which orchestrate workflows), domain services contain pure domain logic.

<?php

class PrerequisiteChecker
{
    public function studentMeetsAllPrerequisites(
        Student $student,
        Course $course
    ): bool {
        foreach ($course->prerequisites() as $prerequisite) {
            if (!$student->hasCompleted($prerequisite->requiredCourseId())) {
                return false;
            }
        }
        return true;
    }
}

Building Blocks Summary

Pilar 3: Building Block DDD dalam PHP

DDD menyediakan serangkaian pola taktis, yaitu building block konkret yang Anda gunakan untuk membangun model domain. Setiap block memiliki peran spesifik dan seperangkat aturan spesifik.

Entity

Entity adalah objek yang didefinisikan oleh identitasnya, bukan atributnya. Dua objek Student dengan NIM yang sama adalah mahasiswa yang sama, meskipun satu memiliki nama usang dan yang lain memiliki nama yang diperbarui. Entity bersifat mutable: atributnya berubah seiring waktu sementara identitasnya tetap konstan.

<?php

class Student
{
    /** @param Enrolment[] $enrolments */
    private array $enrolments = [];

    private function __construct(
        private StudentId $id,
        private string $name,
        private Email $email,
        private NIM $nim,
    ) {}

    public static function register(
        StudentId $id,
        string $name,
        Email $email,
        NIM $nim
    ): self {
        return new self($id, $name, $email, $nim);
    }

    public function enrolIn(Course $course): Enrolment
    {
        $enrolment = Enrolment::create(
            EnrolmentId::generate(),
            $this->id,
            $course->id(),
            new \DateTimeImmutable()
        );

        $this->enrolments[] = $enrolment;

        return $enrolment;
    }

    public function id(): StudentId { return $this->id; }
    public function name(): string { return $this->name; }
    public function email(): Email { return $this->email; }
    public function nim(): NIM { return $this->nim; }

    /** @return Enrolment[] */
    public function enrolments(): array { return $this->enrolments; }
}

Aturan kunci:

• Entity selalu memiliki identifier (StudentId, EnrolmentId).
• Kesamaan identitas: $studentA->id()->equals($studentB->id()) menentukan kesamaan, bukan $studentA == $studentB.
• Entity mengenkapsulasi perilaku. Metode enrolIn() ada di Student, bukan di StudentService terpisah.

Value Object

Value Object tidak memiliki identitas. Ia didefinisikan sepenuhnya oleh atributnya. Dua objek Money dengan jumlah dan mata uang yang sama dapat dipertukarkan. Value Object bersifat immutable: metode mengembalikan instance baru, bukan memodifikasi state.

<?php

class StudentId
{
    private function __construct(
        private string $value
    ) {}

    public static function generate(): self
    {
        return new self(bin2hex(random_bytes(16)));
    }

    public static function fromString(string $value): self
    {
        if (!preg_match('/^[a-f0-9]{32}$/', $value)) {
            throw new \InvalidArgumentException("StudentId tidak valid: $value");
        }
        return new self($value);
    }

    public function equals(self $other): bool
    {
        return $this->value === $other->value;
    }

    public function toString(): string
    {
        return $this->value;
    }
}

<?php

class NIM
{
    private function __construct(
        private string $value
    ) {}

    public static function fromString(string $value): self
    {
        if (!preg_match('/^\d{10}$/', $value)) {
            throw new \InvalidArgumentException("NIM harus tepat 10 digit, diterima: $value");
        }
        return new self($value);
    }

    public function equals(self $other): bool
    {
        return $this->value === $other->value;
    }

    public function toString(): string
    {
        return $this->value;
    }

    public function admissionYear(): int
    {
        return (int) substr($this->value, 0, 4);
    }
}

<?php

class Email
{
    private function __construct(
        private string $value
    ) {}

    public static function fromString(string $value): self
    {
        if (!filter_var($value, FILTER_VALIDATE_EMAIL)) {
            throw new \InvalidArgumentException("Alamat email tidak valid: $value");
        }
        return new self(strtolower($value));
    }

    public function equals(self $other): bool
    {
        return $this->value === $other->value;
    }

    public function toString(): string { return $this->value; }

    public function domain(): string
    {
        return substr($this->value, strpos($this->value, '@') + 1);
    }
}

Entity vs Value Object: Tabel Keputusan Cepat

Aggregate dan Aggregate Root

Aggregate adalah kluster entity dan value object yang diperlakukan sebagai satu unit untuk perubahan data. Aggregate Root adalah titik masuk tunggal: semua referensi eksternal ke aggregate melalui root.

Mengapa? Tanpa aggregate, bagian kode mana pun dapat memodifikasi entity mana pun, dan invarian bisnis tersebar di seluruh basis kode. Dengan aggregate, root menjamin konsistensi.

Contoh: Aggregate Enrolment:

• Aggregate root: Enrolment
• Entity internal: EnrolmentHistory (log perubahan status, tidak pernah diakses langsung)
• Invarian: “Enrolment tidak dapat dikonfirmasi jika kapasitas maksimum tercapai.”

<?php

class Enrolment
{
    /** @var EnrolmentHistory[] */
    private array $history = [];

    private function __construct(
        private EnrolmentId $id,
        private StudentId $studentId,
        private CourseId $courseId,
        private EnrolmentStatus $status,
        private \DateTimeImmutable $createdAt,
    ) {}

    public static function create(
        EnrolmentId $id,
        StudentId $studentId,
        CourseId $courseId,
        \DateTimeImmutable $createdAt
    ): self {
        $enrolment = new self($id, $studentId, $courseId, EnrolmentStatus::Pending, $createdAt);
        $enrolment->recordEvent(new EnrolmentCreated($id, $studentId, $courseId, $createdAt));
        return $enrolment;
    }

    public function confirm(int $currentEnrolmentCount, int $maxCapacity): void
    {
        if ($this->status !== EnrolmentStatus::Pending) {
            throw new \DomainException("Hanya enrolment pending yang dapat dikonfirmasi.");
        }

        if ($currentEnrolmentCount >= $maxCapacity) {
            throw new \DomainException(
                "Kapasitas course tercapai ({$maxCapacity}). Tidak dapat mengkonfirmasi enrolment."
            );
        }

        $this->status = EnrolmentStatus::Confirmed;
        $this->recordEvent(new EnrolmentConfirmed($this->id, new \DateTimeImmutable()));
    }

    public function cancel(): void
    {
        if ($this->status === EnrolmentStatus::Cancelled) {
            throw new \DomainException("Enrolment sudah dibatalkan.");
        }

        $this->status = EnrolmentStatus::Cancelled;
        $this->recordEvent(new EnrolmentCancelled($this->id, new \DateTimeImmutable()));
    }

    public function id(): EnrolmentId { return $this->id; }
    public function studentId(): StudentId { return $this->studentId; }
    public function courseId(): CourseId { return $this->courseId; }
    public function status(): EnrolmentStatus { return $this->status; }

    private function recordEvent(object $event): void
    {
        $this->history[] = new EnrolmentHistory(
            EnrolmentHistoryId::generate(),
            $this->id,
            $event,
            new \DateTimeImmutable()
        );
    }
}

Aturan kunci:

• Hanya aggregate root (Enrolment) yang memiliki identitas global. Entity internal memiliki identitas lokal.
• Kode eksternal tidak pernah menyimpan referensi ke EnrolmentHistory. Ia hanya berbicara ke Enrolment.
• Semua invarian diperiksa di dalam aggregate sebelum perubahan state.
• Aggregate harus kecil. Aggregate University yang berisi setiap Student dan Course adalah granularitas yang salah, sebaiknya gunakan banyak aggregate kecil.

Repository

Repository menyediakan ilusi koleksi dalam memori untuk aggregate root. Kode aplikasi mengambil dan menyimpan aggregate melalui repository, tidak pernah menyentuh database secara langsung.

<?php

interface EnrolmentRepository
{
    public function save(Enrolment $enrolment): void;
    public function findById(EnrolmentId $id): ?Enrolment;
    public function findByStudent(StudentId $studentId): array;
    public function countForCourse(CourseId $courseId): int;
    public function exists(StudentId $studentId, CourseId $courseId): bool;
}

Implementasi konkret menggunakan PDO (di lapisan infrastruktur):

<?php

class PdoEnrolmentRepository implements EnrolmentRepository
{
    public function __construct(private \PDO $pdo) {}

    public function save(Enrolment $enrolment): void
    {
        $stmt = $this->pdo->prepare(
            'INSERT INTO enrolments (id, student_id, course_id, status, created_at)
             VALUES (?, ?, ?, ?, ?)
             ON CONFLICT (id) DO UPDATE SET status = ?, created_at = ?'
        );
        $stmt->execute([
            $enrolment->id()->toString(),
            $enrolment->studentId()->toString(),
            $enrolment->courseId()->toString(),
            $enrolment->status()->value,
            $enrolment->createdAt()->format('Y-m-d H:i:s'),
            $enrolment->status()->value,
            $enrolment->createdAt()->format('Y-m-d H:i:s'),
        ]);
    }

    public function findById(EnrolmentId $id): ?Enrolment
    {
        $stmt = $this->pdo->prepare(
            'SELECT * FROM enrolments WHERE id = ?'
        );
        $stmt->execute([$id->toString()]);
        $row = $stmt->fetch(\PDO::FETCH_ASSOC);

        return $row ? $this->hydrate($row) : null;
    }

    private function hydrate(array $row): Enrolment
    {
        return new Enrolment(
            EnrolmentId::fromString($row['id']),
            StudentId::fromString($row['student_id']),
            CourseId::fromString($row['course_id']),
            EnrolmentStatus::from($row['status']),
            new \DateTimeImmutable($row['created_at']),
        );
    }

    // ... metode lainnya
}

PdoEnrolmentRepository tinggal di lapisan infrastruktur. Interface EnrolmentRepository tinggal di lapisan domain. Kode aplikasi bergantung pada interface: ia tidak pernah tahu tentang PDO.

Domain Service

Ketika operasi bisnis tidak secara alami dimiliki oleh satu entity pun, gunakan Domain Service. Berbeda dengan application service (yang mengorkestrasi workflow), domain service berisi logika domain murni.

<?php

class PrerequisiteChecker
{
    public function studentMeetsAllPrerequisites(
        Student $student,
        Course $course
    ): bool {
        foreach ($course->prerequisites() as $prerequisite) {
            if (!$student->hasCompleted($prerequisite->requiredCourseId())) {
                return false;
            }
        }
        return true;
    }
}

Ringkasan Building Block

Pillar 4: Layered Architecture

DDD prescribes a layered architecture where each layer has a distinct responsibility and dependencies point inward. The domain layer is the heart — it has zero dependencies on frameworks, databases, or HTTP libraries.

The Four Layers

Folder Structure

src/
├── Domain/
│   ├── Enrolment/
│   │   ├── Enrolment.php              (aggregate root)
│   │   ├── EnrolmentId.php            (value object)
│   │   ├── EnrolmentStatus.php        (enum)
│   │   ├── EnrolmentRepository.php    (interface)
│   │   └── EnrolmentHistory.php       (internal entity)
│   ├── Student/
│   │   ├── Student.php                (entity)
│   │   ├── StudentId.php              (value object)
│   │   ├── NIM.php                    (value object)
│   │   ├── Email.php                  (value object)
│   │   └── StudentRepository.php      (interface)
│   └── Course/
│       ├── Course.php
│       ├── CourseId.php
│       └── Prerequisite.php
├── Application/
│   └── Enrolment/
│       ├── EnrolStudentUseCase.php
│       ├── CancelEnrolmentUseCase.php
│       └── EnrolmentResult.php
├── Infrastructure/
│   └── Persistence/
│       ├── PdoEnrolmentRepository.php
│       └── PdoStudentRepository.php
└── UserInterface/
    └── Controller/
        └── EnrolmentController.php

Notice:

• The Domain folder is organised around business concepts (Enrolment, Student, Course), not technical layers (Models, Services, Helpers).
• Each aggregate gets its own subfolder containing the root, value objects, repository interface, and internal entities.
• The EnrolmentRepository interface is in Domain/Enrolment/. The PDO implementation is in Infrastructure/Persistence/.

Dependency Rule

┌──────────────────────────────────────────┐
│        User Interface (Controllers)       │
│                                            │
│    ┌──────────────────────────────────┐    │
│    │      Application (Use Cases)      │    │
│    │                                    │    │
│    │    ┌──────────────────────────┐    │    │
│    │    │      Domain (Entities,    │    │    │
│    │    │   Value Objects, Repo    │    │    │
│    │    │      Interfaces)         │    │    │
│    │    └──────────────────────────┘    │    │
│    │              ▲                      │    │
│    └──────────────┼──────────────────────┘    │
│                   │                           │
│    ┌──────────────┴──────────────────────┐    │
│    │    Infrastructure (PDO, HTTP,        │    │
│    │    Mailer — implements Domain        │    │
│    │    interfaces)                       │    │
│    └─────────────────────────────────────┘    │
└──────────────────────────────────────────────┘

Dependencies always point toward Domain.
Infrastructure depends on Domain (not the reverse).

This means you can swap PdoEnrolmentRepository for a RedisEnrolmentRepository without touching a single line in the Domain or Application layers.

Pilar 4: Arsitektur Berlapis

DDD menganjurkan arsitektur berlapis di mana setiap lapisan memiliki tanggung jawab yang berbeda dan dependensi mengarah ke dalam. Lapisan domain adalah jantungnya: ia memiliki nol dependensi pada framework, database, atau library HTTP.

Empat Lapisan

Struktur Folder

src/
├── Domain/
│   ├── Enrolment/
│   │   ├── Enrolment.php              (aggregate root)
│   │   ├── EnrolmentId.php            (value object)
│   │   ├── EnrolmentStatus.php        (enum)
│   │   ├── EnrolmentRepository.php    (interface)
│   │   └── EnrolmentHistory.php       (entity internal)
│   ├── Student/
│   │   ├── Student.php                (entity)
│   │   ├── StudentId.php              (value object)
│   │   ├── NIM.php                    (value object)
│   │   ├── Email.php                  (value object)
│   │   └── StudentRepository.php      (interface)
│   └── Course/
│       ├── Course.php
│       ├── CourseId.php
│       └── Prerequisite.php
├── Application/
│   └── Enrolment/
│       ├── EnrolStudentUseCase.php
│       ├── CancelEnrolmentUseCase.php
│       └── EnrolmentResult.php
├── Infrastructure/
│   └── Persistence/
│       ├── PdoEnrolmentRepository.php
│       └── PdoStudentRepository.php
└── UserInterface/
    └── Controller/
        └── EnrolmentController.php

Perhatikan:

• Folder Domain diorganisasikan berdasarkan konsep bisnis (Enrolment, Student, Course), bukan lapisan teknis (Models, Services, Helpers).
• Setiap aggregate mendapatkan subfolder sendiri yang berisi root, value object, interface repository, dan entity internal.
• Interface EnrolmentRepository ada di Domain/Enrolment/. Implementasi PDO ada di Infrastructure/Persistence/.

Aturan Dependensi

┌──────────────────────────────────────────┐
│        User Interface (Controllers)       │
│                                            │
│    ┌──────────────────────────────────┐    │
│    │      Application (Use Cases)      │    │
│    │                                    │    │
│    │    ┌──────────────────────────┐    │    │
│    │    │      Domain (Entities,    │    │    │
│    │    │   Value Objects, Repo    │    │    │
│    │    │      Interfaces)         │    │    │
│    │    └──────────────────────────┘    │    │
│    │              ▲                      │    │
│    └──────────────┼──────────────────────┘    │
│                   │                           │
│    ┌──────────────┴──────────────────────┐    │
│    │    Infrastructure (PDO, HTTP,        │    │
│    │    Mailer — mengimplementasikan      │    │
│    │    interface Domain)                 │    │
│    └─────────────────────────────────────┘    │
└──────────────────────────────────────────────┘

Dependensi selalu mengarah ke Domain.
Infrastructure bergantung pada Domain (bukan sebaliknya).

Ini berarti Anda dapat menukar PdoEnrolmentRepository dengan RedisEnrolmentRepository tanpa menyentuh satu baris pun di lapisan Domain atau Application.

Hands-On: From Anemic CRUD (Create, Read, Update, Delete) to DDD Domain Model

Let us apply everything by refactoring a real example. We start with an anemic domain model — a common anti-pattern where “domain” classes are data bags with getters and setters, and all business logic lives in services or controllers.

Before: Anemic CRUD Course Registration

<?php

// The "model" — just a data bag
class Student
{
    public int $id;
    public string $name;
    public string $email;
    public string $nim;
}

class Course
{
    public int $id;
    public string $code;
    public string $title;
    public int $capacity;
    public array $prerequisiteIds; // array of course IDs
}

class Enrolment
{
    public int $id;
    public int $studentId;
    public int $courseId;
    public string $status; // 'pending', 'confirmed', 'cancelled'
    public string $createdAt;
}

// All business logic in a "service" class
class RegistrationService
{
    private \PDO $db;
    private Mailer $mailer;

    public function __construct(\PDO $db, Mailer $mailer)
    {
        $this->db = $db;
        $this->mailer = $mailer;
    }

    public function registerStudentForCourse(
        int $studentId,
        int $courseId
    ): array {
        // Fetch raw data
        $student = $this->findStudent($studentId);
        if (!$student) {
            return ['error' => 'Student not found'];
        }

        $course = $this->findCourse($courseId);
        if (!$course) {
            return ['error' => 'Course not found'];
        }

        // Check duplicate
        $existing = $this->db->prepare(
            'SELECT COUNT(*) FROM enrolments
             WHERE student_id = ? AND course_id = ? AND status != ?'
        );
        $existing->execute([$studentId, $courseId, 'cancelled']);
        if ($existing->fetchColumn() > 0) {
            return ['error' => 'Already enrolled'];
        }

        // Check prerequisites — this logic is here, not on the model
        foreach ($course['prerequisite_ids'] as $prereqId) {
            $completed = $this->db->prepare(
                'SELECT COUNT(*) FROM enrolments
                 WHERE student_id = ? AND course_id = ? AND status = ?'
            );
            $completed->execute([$studentId, $prereqId, 'completed']);
            if ($completed->fetchColumn() === 0) {
                return ['error' => "Prerequisite course {$prereqId} not completed"];
            }
        }

        // Check capacity — raw SQL check
        $count = $this->db->prepare(
            'SELECT COUNT(*) FROM enrolments
             WHERE course_id = ? AND status = ?'
        );
        $count->execute([$courseId, 'confirmed']);
        if ($count->fetchColumn() >= $course['capacity']) {
            return ['error' => 'Course is full'];
        }

        // Insert — string status, no domain event
        $stmt = $this->db->prepare(
            'INSERT INTO enrolments (student_id, course_id, status, created_at)
             VALUES (?, ?, ?, ?)'
        );
        $stmt->execute([$studentId, $courseId, 'confirmed', date('Y-m-d H:i:s')]);

        // Side effect directly in service
        $this->mailer->send(
            $student['email'],
            'Enrolment Confirmed',
            "You have been enrolled in {$course['title']}."
        );

        return [
            'id' => (int) $this->db->lastInsertId(),
            'status' => 'confirmed',
        ];
    }

    private function findStudent(int $id): ?array
    {
        $stmt = $this->db->prepare('SELECT * FROM students WHERE id = ?');
        $stmt->execute([$id]);
        $row = $stmt->fetch(\PDO::FETCH_ASSOC);
        return $row ?: null;
    }

    private function findCourse(int $id): ?array
    {
        $stmt = $this->db->prepare('SELECT * FROM courses WHERE id = ?');
        $stmt->execute([$id]);
        $row = $stmt->fetch(\PDO::FETCH_ASSOC);
        if ($row) {
            $row['prerequisite_ids'] = json_decode($row['prerequisite_ids'], true) ?? [];
        }
        return $row ?: null;
    }
}

// Usage
$service = new RegistrationService($pdo, $mailer);
$result = $service->registerStudentForCourse(42, 7);
print_r($result);

Problems with this code:

1. Anemic domain model. Student, Course, and Enrolment have zero behaviour. They are glorified arrays with public properties.
2. Scattered business rules. Prerequisite checking, capacity enforcement, and duplicate detection live inside RegistrationService — a class that should orchestrate, not contain domain logic.
3. String-based statuses. 'pending', 'confirmed', 'cancelled' are error-prone magic strings. A typo ('cnfirmed') goes undetected until runtime.
4. Framework-coupled data access. RegistrationService depends on \PDO directly. Swapping the database means rewriting every service.
5. Side effects embedded in business logic. Sending an email is hard-coded inside registerStudentForCourse. You cannot disable it in tests without mocking the mailer.
6. Unenforceable invariants. Nothing prevents code elsewhere from setting $enrolment->status = 'confirmed' without checking capacity.

After: DDD-Style Domain Model

We now refactor the same functionality following DDD principles.

Step 1 — Value Objects (Domain layer, zero dependencies):

<?php

class StudentId
{
    private function __construct(private string $value) {}

    public static function generate(): self
    {
        return new self(bin2hex(random_bytes(16)));
    }

    public static function fromString(string $value): self
    {
        if (!preg_match('/^[a-f0-9]{32}$/', $value)) {
            throw new \InvalidArgumentException("Invalid StudentId format.");
        }
        return new self($value);
    }

    public function equals(self $other): bool { return $this->value === $other->value; }
    public function toString(): string { return $this->value; }
}

class CourseId
{
    private function __construct(private string $value) {}

    public static function fromString(string $value): self
    {
        if (!preg_match('/^[a-f0-9]{32}$/', $value)) {
            throw new \InvalidArgumentException("Invalid CourseId format.");
        }
        return new self($value);
    }

    public function equals(self $other): bool { return $this->value === $other->value; }
    public function toString(): string { return $this->value; }
}

enum EnrolmentStatus: string
{
    case Pending = 'pending';
    case Confirmed = 'confirmed';
    case Cancelled = 'cancelled';
    case Completed = 'completed';
}

Step 2 — Entities with behaviour (Domain layer):

<?php

class Student
{
    /** @param CompletedCourse[] $completedCourses */
    private array $completedCourses;

    private function __construct(
        private StudentId $id,
        private string $name,
        private string $email,
        private string $nim,
    ) {
        $this->completedCourses = [];
    }

    public static function register(
        StudentId $id,
        string $name,
        string $email,
        string $nim,
    ): self {
        return new self($id, $name, $email, $nim);
    }

    public function hasCompletedPrerequisitesFor(Course $course): bool
    {
        foreach ($course->prerequisites() as $prerequisite) {
            $completed = false;
            foreach ($this->completedCourses as $completedCourse) {
                if ($completedCourse->courseId()->equals($prerequisite->courseId)) {
                    $completed = true;
                    break;
                }
            }
            if (!$completed) {
                return false;
            }
        }
        return true;
    }

    public function completeCourse(CourseId $courseId): void
    {
        $this->completedCourses[] = new CompletedCourse(
            $courseId,
            new \DateTimeImmutable()
        );
    }

    public function id(): StudentId { return $this->id; }
    public function name(): string { return $this->name; }
    public function email(): string { return $this->email; }
    public function nim(): string { return $this->nim; }
}

class CompletedCourse
{
    public function __construct(
        private CourseId $courseId,
        private \DateTimeImmutable $completedAt,
    ) {}

    public function courseId(): CourseId { return $this->courseId; }
    public function completedAt(): \DateTimeImmutable { return $this->completedAt; }
}

class Course
{
    /** @param Prerequisite[] $prerequisites */
    private array $prerequisites;

    private function __construct(
        private CourseId $id,
        private string $code,
        private string $title,
        private int $capacity,
    ) {
        $this->prerequisites = [];
    }

    public static function create(
        CourseId $id,
        string $code,
        string $title,
        int $capacity,
    ): self {
        return new self($id, $code, $title, $capacity);
    }

    public function addPrerequisite(CourseId $courseId): void
    {
        $this->prerequisites[] = new Prerequisite($courseId);
    }

    /** @return Prerequisite[] */
    public function prerequisites(): array { return $this->prerequisites; }

    public function id(): CourseId { return $this->id; }
    public function code(): string { return $this->code; }
    public function title(): string { return $this->title; }
    public function capacity(): int { return $this->capacity; }
}

class Prerequisite
{
    public function __construct(
        private CourseId $courseId,
    ) {}

    public function requiredCourseId(): CourseId { return $this->courseId; }
}

Step 3 — The Enrolment Aggregate (Domain layer):

<?php

class Enrolment
{
    private function __construct(
        private EnrolmentId $id,
        private StudentId $studentId,
        private CourseId $courseId,
        private EnrolmentStatus $status,
        private \DateTimeImmutable $createdAt,
    ) {}

    public static function create(
        EnrolmentId $id,
        StudentId $studentId,
        CourseId $courseId,
    ): self {
        return new self(
            $id,
            $studentId,
            $courseId,
            EnrolmentStatus::Pending,
            new \DateTimeImmutable()
        );
    }

    public function confirm(int $currentEnrolmentCount, int $maxCapacity): void
    {
        if ($this->status !== EnrolmentStatus::Pending) {
            throw new \DomainException(
                "Only pending enrolments can be confirmed. Current status: {$this->status->value}."
            );
        }

        if ($currentEnrolmentCount >= $maxCapacity) {
            throw new \DomainException(
                "Cannot confirm enrolment. Course capacity {$maxCapacity} has been reached."
            );
        }

        $this->status = EnrolmentStatus::Confirmed;
    }

    public function cancel(): void
    {
        if ($this->status === EnrolmentStatus::Cancelled) {
            throw new \DomainException("Enrolment is already cancelled.");
        }
        if ($this->status === EnrolmentStatus::Completed) {
            throw new \DomainException("Cannot cancel a completed enrolment.");
        }

        $this->status = EnrolmentStatus::Cancelled;
    }

    public function markAsCompleted(): void
    {
        if ($this->status !== EnrolmentStatus::Confirmed) {
            throw new \DomainException(
                "Only confirmed enrolments can be marked as completed."
            );
        }

        $this->status = EnrolmentStatus::Completed;
    }

    public function id(): EnrolmentId { return $this->id; }
    public function studentId(): StudentId { return $this->studentId; }
    public function courseId(): CourseId { return $this->courseId; }
    public function status(): EnrolmentStatus { return $this->status; }
    public function createdAt(): \DateTimeImmutable { return $this->createdAt; }
}

Step 4 — Repository Interfaces (Domain layer):

<?php

interface EnrolmentRepository
{
    public function save(Enrolment $enrolment): void;
    public function findByStudentAndCourse(StudentId $studentId, CourseId $courseId): ?Enrolment;
    public function countConfirmedForCourse(CourseId $courseId): int;
}

Step 5 — Application Use Case (Application layer):

<?php

class EnrolStudentUseCase
{
    public function __construct(
        private EnrolmentRepository $enrolmentRepository,
        private StudentRepository $studentRepository,
        private CourseRepository $courseRepository,
    ) {}

    public function execute(EnrolStudentCommand $command): EnrolmentResult
    {
        $student = $this->studentRepository->findById($command->studentId);
        if (!$student) {
            return EnrolmentResult::studentNotFound();
        }

        $course = $this->courseRepository->findById($command->courseId);
        if (!$course) {
            return EnrolmentResult::courseNotFound();
        }

        $existing = $this->enrolmentRepository->findByStudentAndCourse(
            $command->studentId,
            $command->courseId
        );
        if ($existing && $existing->status() !== EnrolmentStatus::Cancelled) {
            return EnrolmentResult::alreadyEnrolled();
        }

        if (!$student->hasCompletedPrerequisitesFor($course)) {
            return EnrolmentResult::prerequisitesNotMet();
        }

        $enrolment = Enrolment::create(
            EnrolmentId::generate(),
            $command->studentId,
            $command->courseId,
        );

        $currentCount = $this->enrolmentRepository->countConfirmedForCourse(
            $command->courseId
        );
        $enrolment->confirm($currentCount, $course->capacity());

        $this->enrolmentRepository->save($enrolment);

        return EnrolmentResult::success($enrolment);
    }
}

class EnrolStudentCommand
{
    public function __construct(
        public readonly StudentId $studentId,
        public readonly CourseId $courseId,
    ) {}
}

class EnrolmentResult
{
    private function __construct(
        public readonly bool $success,
        public readonly ?Enrolment $enrolment,
        public readonly ?string $error,
    ) {}

    public static function success(Enrolment $enrolment): self
    {
        return new self(true, $enrolment, null);
    }

    public static function studentNotFound(): self
    {
        return new self(false, null, 'Student not found.');
    }

    public static function courseNotFound(): self
    {
        return new self(false, null, 'Course not found.');
    }

    public static function alreadyEnrolled(): self
    {
        return new self(false, null, 'Student is already enrolled in this course.');
    }

    public static function prerequisitesNotMet(): self
    {
        return new self(false, null, 'Student has not completed all prerequisites.');
    }
}

Step 6 — Infrastructure Implementation (Infrastructure layer):

<?php

class PdoEnrolmentRepository implements EnrolmentRepository
{
    public function __construct(private \PDO $pdo) {}

    public function save(Enrolment $enrolment): void
    {
        $stmt = $this->pdo->prepare(
            'INSERT INTO enrolments (id, student_id, course_id, status, created_at)
             VALUES (?, ?, ?, ?, ?)
             ON CONFLICT (id) DO UPDATE SET status = excluded.status'
        );
        $stmt->execute([
            $enrolment->id()->toString(),
            $enrolment->studentId()->toString(),
            $enrolment->courseId()->toString(),
            $enrolment->status()->value,
            $enrolment->createdAt()->format('Y-m-d H:i:s'),
        ]);
    }

    public function findByStudentAndCourse(
        StudentId $studentId,
        CourseId $courseId
    ): ?Enrolment {
        $stmt = $this->pdo->prepare(
            'SELECT * FROM enrolments WHERE student_id = ? AND course_id = ?'
        );
        $stmt->execute([$studentId->toString(), $courseId->toString()]);
        $row = $stmt->fetch(\PDO::FETCH_ASSOC);

        return $row ? $this->hydrate($row) : null;
    }

    public function countConfirmedForCourse(CourseId $courseId): int
    {
        $stmt = $this->pdo->prepare(
            'SELECT COUNT(*) FROM enrolments
             WHERE course_id = ? AND status = ?'
        );
        $stmt->execute([$courseId->toString(), EnrolmentStatus::Confirmed->value]);
        return (int) $stmt->fetchColumn();
    }

    private function hydrate(array $row): Enrolment
    {
        return new Enrolment(
            EnrolmentId::fromString($row['id']),
            StudentId::fromString($row['student_id']),
            CourseId::fromString($row['course_id']),
            EnrolmentStatus::from($row['status']),
            new \DateTimeImmutable($row['created_at']),
        );
    }
}

Step 7 — Controller (User Interface layer):

<?php

class EnrolmentController
{
    public function __construct(
        private EnrolStudentUseCase $enrolStudent,
    ) {}

    public function enrol(Request $request): Response
    {
        try {
            $command = new EnrolStudentCommand(
                StudentId::fromString($request->json('student_id')),
                CourseId::fromString($request->json('course_id')),
            );

            $result = $this->enrolStudent->execute($command);

            if (!$result->success) {
                return Response::json(['error' => $result->error], 400);
            }

            return Response::json([
                'id' => $result->enrolment->id()->toString(),
                'status' => $result->enrolment->status()->value,
            ], 201);
        } catch (\DomainException $e) {
            return Response::json(['error' => $e->getMessage()], 422);
        }
    }
}

Before vs After Comparison

Hands-On: Dari Anemic CRUD (Create, Read, Update, Delete) ke Domain Model DDD

Mari kita terapkan semuanya dengan me-refactor contoh nyata. Kita mulai dengan anemic domain model: anti-pola umum di mana kelas “domain” adalah data bag dengan getter dan setter, dan semua logika bisnis tinggal di service atau controller.

Before: Anemic CRUD untuk Pendaftaran Mata Kuliah

<?php

// "Model" — hanya data bag
class Student
{
    public int $id;
    public string $name;
    public string $email;
    public string $nim;
}

class Course
{
    public int $id;
    public string $code;
    public string $title;
    public int $capacity;
    public array $prerequisiteIds; // array course ID
}

class Enrolment
{
    public int $id;
    public int $studentId;
    public int $courseId;
    public string $status; // 'pending', 'confirmed', 'cancelled'
    public string $createdAt;
}

// Semua logika bisnis di kelas "service"
class RegistrationService
{
    private \PDO $db;
    private Mailer $mailer;

    public function __construct(\PDO $db, Mailer $mailer)
    {
        $this->db = $db;
        $this->mailer = $mailer;
    }

    public function registerStudentForCourse(
        int $studentId,
        int $courseId
    ): array {
        // Ambil data mentah
        $student = $this->findStudent($studentId);
        if (!$student) {
            return ['error' => 'Mahasiswa tidak ditemukan'];
        }

        $course = $this->findCourse($courseId);
        if (!$course) {
            return ['error' => 'Mata kuliah tidak ditemukan'];
        }

        // Periksa duplikat
        $existing = $this->db->prepare(
            'SELECT COUNT(*) FROM enrolments
             WHERE student_id = ? AND course_id = ? AND status != ?'
        );
        $existing->execute([$studentId, $courseId, 'cancelled']);
        if ($existing->fetchColumn() > 0) {
            return ['error' => 'Sudah terdaftar'];
        }

        // Periksa prasyarat — logika ini di sini, bukan di model
        foreach ($course['prerequisite_ids'] as $prereqId) {
            $completed = $this->db->prepare(
                'SELECT COUNT(*) FROM enrolments
                 WHERE student_id = ? AND course_id = ? AND status = ?'
            );
            $completed->execute([$studentId, $prereqId, 'completed']);
            if ($completed->fetchColumn() === 0) {
                return ['error' => "Mata kuliah prasyarat {$prereqId} belum selesai"];
            }
        }

        // Periksa kapasitas — pengecekan SQL mentah
        $count = $this->db->prepare(
            'SELECT COUNT(*) FROM enrolments
             WHERE course_id = ? AND status = ?'
        );
        $count->execute([$courseId, 'confirmed']);
        if ($count->fetchColumn() >= $course['capacity']) {
            return ['error' => 'Mata kuliah penuh'];
        }

        // Insert — status string, tanpa domain event
        $stmt = $this->db->prepare(
            'INSERT INTO enrolments (student_id, course_id, status, created_at)
             VALUES (?, ?, ?, ?)'
        );
        $stmt->execute([$studentId, $courseId, 'confirmed', date('Y-m-d H:i:s')]);

        // Efek samping langsung di service
        $this->mailer->send(
            $student['email'],
            'Pendaftaran Dikonfirmasi',
            "Anda telah terdaftar di {$course['title']}."
        );

        return [
            'id' => (int) $this->db->lastInsertId(),
            'status' => 'confirmed',
        ];
    }

    private function findStudent(int $id): ?array
    {
        $stmt = $this->db->prepare('SELECT * FROM students WHERE id = ?');
        $stmt->execute([$id]);
        $row = $stmt->fetch(\PDO::FETCH_ASSOC);
        return $row ?: null;
    }

    private function findCourse(int $id): ?array
    {
        $stmt = $this->db->prepare('SELECT * FROM courses WHERE id = ?');
        $stmt->execute([$id]);
        $row = $stmt->fetch(\PDO::FETCH_ASSOC);
        if ($row) {
            $row['prerequisite_ids'] = json_decode($row['prerequisite_ids'], true) ?? [];
        }
        return $row ?: null;
    }
}

// Penggunaan
$service = new RegistrationService($pdo, $mailer);
$result = $service->registerStudentForCourse(42, 7);
print_r($result);