PHPとレイヤードアーキテクチャの相性 — 言語特性・フレームワーク別の適合度と導入判断

// Domain層: app/Domain/Repository/UserRepositoryInterface.php
namespace App\Domain\Repository;

use App\Domain\Entity\User;

interface UserRepositoryInterface
{
    public function findById(int $id): ?User;
    public function save(User $user): void;
}

// Infrastructure層: app/Infrastructure/Persistence/EloquentUserRepository.php
namespace App\Infrastructure\Persistence;

use App\Domain\Entity\User;
use App\Domain\Repository\UserRepositoryInterface;
use App\Infrastructure\Persistence\Eloquent\UserModel;

class EloquentUserRepository implements UserRepositoryInterface
{
    public function findById(int $id): ?User
    {
        $record = UserModel::find($id);
        if ($record === null) {
            return null;
        }
        return new User($record->id, $record->name, $record->email);
    }

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

// PHP 8.2: readonly クラスで値オブジェクトを定義
readonly class Money
{
    public function __construct(
        public int $amount,
        public Currency $currency,
    ) {
        if ($amount < 0) {
            throw new \InvalidArgumentException('金額は0以上を指定してください');
        }
    }

    public function add(Money $other): self
    {
        if (!$this->currency->equals($other->currency)) {
            throw new \DomainException('異なる通貨同士は加算できません');
        }
        return new self($this->amount + $other->amount, $this->currency);
    }
}

// composer.json
{
    "autoload": {
        "psr-4": {
            "App\\Presentation\\": "src/Presentation/",
            "App\\Application\\": "src/Application/",
            "App\\Domain\\": "src/Domain/",
            "App\\Infrastructure\\": "src/Infrastructure/"
        }
    }
}

// app/Providers/RepositoryServiceProvider.php
namespace App\Providers;

use App\Domain\Repository\UserRepositoryInterface;
use App\Infrastructure\Persistence\EloquentUserRepository;
use Illuminate\Support\ServiceProvider;

class RepositoryServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        $this->app->bind(
            UserRepositoryInterface::class,
            EloquentUserRepository::class
        );
    }
}

// Doctrine: Domain EntityはPOPO（ORMアノテーション不要、XML/YAMLマッピング可）
namespace App\Domain\Entity;

class Order
{
    private int $id;
    private array $items = [];
    private OrderStatus $status;

    public function __construct(OrderStatus $status = OrderStatus::Draft)
    {
        $this->status = $status;
    }

    public function confirm(): void
    {
        if ($this->status !== OrderStatus::Draft) {
            throw new \DomainException('下書き状態の注文のみ確定できます');
        }
        $this->status = OrderStatus::Confirmed;
    }
}

src/
├── Controller/        # CakePHP規約に従う（Presentation層）
├── Model/
│   └── Table/         # CakePHP規約に従う（Infrastructure層）
├── Domain/            # プレーンPHP（Domain層）
│   ├── Entity/
│   ├── ValueObject/
│   └── Repository/    # インターフェース定義のみ
├── Application/       # UseCase（Application層）
│   └── UseCase/
└── Infrastructure/    # Repository実装（CakePHP Table を利用）
    └── Persistence/

app/
├── Presentation/
│   ├── Http/
│   │   ├── Controllers/
│   │   │   └── OrderController.php
│   │   ├── Requests/
│   │   │   └── CreateOrderRequest.php
│   │   └── Resources/
│   │       └── OrderResource.php
│   └── Console/
│       └── Commands/
├── Application/
│   ├── UseCase/
│   │   ├── CreateOrderUseCase.php
│   │   └── GetOrderUseCase.php
│   └── DTO/
│       ├── CreateOrderInput.php
│       └── OrderOutput.php
├── Domain/
│   ├── Entity/
│   │   └── Order.php
│   ├── ValueObject/
│   │   ├── OrderId.php
│   │   └── Money.php
│   ├── Repository/
│   │   └── OrderRepositoryInterface.php
│   └── Service/
│       └── OrderPricingService.php
└── Infrastructure/
    ├── Persistence/
    │   ├── Eloquent/
    │   │   └── OrderModel.php
    │   └── EloquentOrderRepository.php
    └── External/
        └── PaymentGatewayClient.php

namespace App\Application\UseCase;

use App\Application\DTO\CreateOrderInput;
use App\Application\DTO\OrderOutput;
use App\Domain\Entity\Order;
use App\Domain\Repository\OrderRepositoryInterface;
use App\Domain\ValueObject\Money;

final class CreateOrderUseCase
{
    public function __construct(
        private readonly OrderRepositoryInterface $orderRepository,
    ) {}

    public function execute(CreateOrderInput $input): OrderOutput
    {
        $totalPrice = new Money($input->totalAmount, $input->currency);
        $order = Order::create(
            customerId: $input->customerId,
            totalPrice: $totalPrice,
        );
        $this->orderRepository->save($order);

        return OrderOutput::fromEntity($order);
    }
}

// Domain層: インターフェース
namespace App\Domain\Repository;

use App\Domain\Entity\Order;
use App\Domain\ValueObject\OrderId;

interface OrderRepositoryInterface
{
    public function findById(OrderId $id): ?Order;
    public function save(Order $order): void;
    public function delete(OrderId $id): void;
}

// Infrastructure層: Eloquent実装
namespace App\Infrastructure\Persistence;

use App\Domain\Entity\Order;
use App\Domain\Repository\OrderRepositoryInterface;
use App\Domain\ValueObject\OrderId;
use App\Infrastructure\Persistence\Eloquent\OrderModel;

class EloquentOrderRepository implements OrderRepositoryInterface
{
    public function findById(OrderId $id): ?Order
    {
        $model = OrderModel::find($id->value());
        return $model ? $this->toEntity($model) : null;
    }

    public function save(Order $order): void
    {
        OrderModel::updateOrCreate(
            ['id' => $order->getId()->value()],
            $order->toArray()
        );
    }

    public function delete(OrderId $id): void
    {
        OrderModel::destroy($id->value());
    }

    private function toEntity(OrderModel $model): Order
    {
        // Eloquent Model → Domain Entity への変換
        return Order::reconstruct(
            id: new OrderId($model->id),
            customerId: $model->customer_id,
            totalPrice: new \App\Domain\ValueObject\Money(
                $model->total_amount,
                $model->currency,
            ),
            status: \App\Domain\Entity\OrderStatus::from($model->status),
        );
    }
}

# deptrac.yaml の設定例
deptrac:
  paths:
    - ./src
  layers:
    - name: Presentation
      collectors:
        - type: directory
          value: src/Presentation/.*
    - name: Application
      collectors:
        - type: directory
          value: src/Application/.*
    - name: Domain
      collectors:
        - type: directory
          value: src/Domain/.*
    - name: Infrastructure
      collectors:
        - type: directory
          value: src/Infrastructure/.*
  ruleset:
    Presentation:
      - Application
    Application:
      - Domain
    Domain: []
    Infrastructure:
      - Domain