DDDとクリーンアーキテクチャの各層を理解しよう！責務を明確にして適切な設計を実現

app/
├── Http/Controllers/   # コントローラー（プレゼンテーション層）
├── Models/             # Eloquentモデル（ビジネスロジック＋DB操作）
├── Providers/          # サービスプロバイダ
database/
├── migrations/         # マイグレーション
├── factories/          # データ生成用ファクトリ

app/
├── Domain/             # ドメイン層（エンティティ、値オブジェクト、ドメインサービス）
│   ├── Entities/      # エンティティ（例：User.php）
│   ├── ValueObjects/  # 値オブジェクト（例：Email.php）
│   ├── Services/      # ドメインサービス（例：UserDomainService.php）
│   └── Repositories/  # リポジトリインターフェース（例：UserRepositoryInterface.php）
│
├── Application/        # アプリケーション層（ユースケース）
│   ├── DTOs/          # データ転送オブジェクト（例：UserDTO.php）
│   ├── UseCases/      # ユースケース（例：CreateUserUseCase.php）
│
├── Infrastructure/     # インフラ層（DB・API・外部サービスとの連携）
│   ├── Persistence/   # DBリポジトリ実装（例：UserEloquentRepository.php）
│   ├── Services/      # API通信などの外部連携（例：PaymentService.php）
│
├── Http/              # プレゼンテーション層（リクエストの受付）
│   ├── Controllers/   # コントローラー（例：UserController.php）
│   ├── Requests/      # バリデーション（例：CreateUserRequest.php）
│   ├── Responses/     # レスポンス用クラス

namespace App\Domain\Entities;

class User
{
    private int $id;
    private string $name;
    private string $email;

    public function __construct(int $id, string $name, string $email)
    {
        $this->id = $id;
        $this->name = $name;
        $this->email = $email;
    }

    public function getId(): int
    {
        return $this->id;
    }

    public function getName(): string
    {
        return $this->name;
    }

    public function getEmail(): string
    {
        return $this->email;
    }
}

namespace App\Domain\ValueObjects;

class Email
{
    private string $email;

    public function __construct(string $email)
    {
        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
            throw new \InvalidArgumentException("Invalid email format.");
        }
        $this->email = $email;
    }

    public function getValue(): string
    {
        return $this->email;
    }
}

namespace App\Domain\Services;

use App\Domain\Repositories\UserRepositoryInterface;
use App\Domain\ValueObjects\Email;

class UserDomainService
{
    private UserRepositoryInterface $userRepository;

    public function __construct(UserRepositoryInterface $userRepository)
    {
        $this->userRepository = $userRepository;
    }

    public function isEmailAlreadyTaken(Email $email): bool
    {
        return $this->userRepository->findByEmail($email) !== null;
    }
}

namespace App\Application\DTOs;

class UserDTO
{
    public string $name;
    public string $email;

    public function __construct(string $name, string $email)
    {
        $this->name = $name;
        $this->email = $email;
    }
}

namespace App\Application\UseCases;

use App\Domain\Entities\User;
use App\Domain\Services\UserDomainService;
use App\Domain\Repositories\UserRepositoryInterface;
use App\Application\DTOs\UserDTO;

class CreateUserUseCase
{
    private UserRepositoryInterface $userRepository;
    private UserDomainService $userDomainService;

    public function __construct(
        UserRepositoryInterface $userRepository,
        UserDomainService $userDomainService
    ) {
        $this->userRepository = $userRepository;
        $this->userDomainService = $userDomainService;
    }

    public function execute(UserDTO $userDTO): User
    {
        // メールアドレスの重複チェック
        if ($this->userDomainService->isEmailAlreadyTaken(new \App\Domain\ValueObjects\Email($userDTO->email))) {
            throw new \Exception("This email is already taken.");
        }

        // ユーザー作成
        $user = new User(0, $userDTO->name, $userDTO->email);

        // 永続化
        $this->userRepository->save($user);

        return $user;
    }
}

namespace App\Domain\Repositories;

use App\Domain\Entities\User;
use App\Domain\ValueObjects\Email;

interface UserRepositoryInterface
{
    public function findByEmail(Email $email): ?User;
    public function save(User $user): void;
}

namespace App\Infrastructure\Persistence;

use App\Domain\Repositories\UserRepositoryInterface;
use App\Domain\Entities\User;
use App\Domain\ValueObjects\Email;
use App\Models\User as EloquentUser;

class UserEloquentRepository implements UserRepositoryInterface
{
    public function findByEmail(Email $email): ?User
    {
        $user = EloquentUser::where('email', $email->getValue())->first();
        if (!$user) {
            return null;
        }

        return new User($user->id, $user->name, $user->email);
    }

    public function save(User $user): void
    {
        EloquentUser::updateOrCreate(
            ['id' => $user->getId()],
            ['name' => $user->getName(), 'email' => $user->getEmail()]
        );
    }
}

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class CreateUserRequest extends FormRequest
{
    public function rules(): array
    {
        return [
            'name' => 'required|string|max:255',
            'email' => 'required|email|unique:users,email',
        ];
    }
}

namespace App\Http\Controllers;

use App\Application\UseCases\CreateUserUseCase;
use App\Application\DTOs\UserDTO;
use App\Http\Requests\CreateUserRequest;
use Illuminate\Http\JsonResponse;

class UserController extends Controller
{
    private CreateUserUseCase $createUserUseCase;

    public function __construct(CreateUserUseCase $createUserUseCase)
    {
        $this->createUserUseCase = $createUserUseCase;
    }

    public function store(CreateUserRequest $request): JsonResponse
    {
        $userDTO = new UserDTO($request->name, $request->email);
        $user = $this->createUserUseCase->execute($userDTO);

        return response()->json([
            'id' => $user->getId(),
            'name' => $user->getName(),
            'email' => $user->getEmail(),
        ], 201);
    }
}

use App\Http\Controllers\UserController;
use Illuminate\Support\Facades\Route;

Route::post('/users', [UserController::class, 'store']);