Layered Architecture knowledge base. Provides patterns, antipatterns, and PHP-specific guidelines for traditional N-tier/Layered Architecture audits.
한국어 요약은 준비 중입니다. 원문 설명을 표시하고 있습니다.
설치 방법 보기설치하기 전에 에이전트에게 전달되는 지시 내용을 확인할 수 있습니다.
Quick reference for Layered (N-Tier) Architecture patterns and PHP implementation guidelines.
┌─────────────────────────────────────────────────────────────────┐
│ PRESENTATION LAYER │
│ (Controllers, Views, API Endpoints, CLI) │
│ │
│ Responsibilities: │
│ - Handle user input │
│ - Display output │
│ - Validate input format │
│ - Route requests │
└───────────────────────────┬─────────────────────────────────────┘
│ calls
▼
┌─────────────────────────────────────────────────────────────────┐
│ APPLICATION LAYER │
│ (Services, Use Cases, DTOs, Facades) │
│ │
│ Responsibilities: │
│ - Orchestrate business operations │
│ - Transaction management │
│ - Coordinate domain objects │
│ - Map between layers │
└───────────────────────────┬─────────────────────────────────────┘
│ calls
▼
┌─────────────────────────────────────────────────────────────────┐
│ DOMAIN LAYER │
│ (Entities, Value Objects, Domain Services, Rules) │
│ │
│ Responsibilities: │
│ - Business logic │
│ - Business rules and invariants │
│ - Domain events │
│ - Core algorithms │
└───────────────────────────┬─────────────────────────────────────┘
│ calls
▼
┌─────────────────────────────────────────────────────────────────┐
│ INFRASTRUCTURE LAYER │
│ (Repositories, External APIs, Database, Cache) │
│ │
│ Responsibilities: │
│ - Data persistence │
│ - External service integration │
│ - Technical infrastructure │
│ - Framework-specific code │
└─────────────────────────────────────────────────────────────────┘
Core Rule: Each layer only communicates with the layer directly below it.
| From Layer | Can Call | Cannot Call |
|---|---|---|
| Presentation | Application | Domain, Infrastructure |
| Application | Domain, Infrastructure | Presentation |
| Domain | Infrastructure (via interfaces) | Presentation, Application |
| Infrastructure | — | All upper layers |
| Violation | Where to Look | Severity |
|---|---|---|
| Skipping layers | Controller calling DB | Critical |
| Upward dependency | Domain using Application | Critical |
| Business in Controller | if/switch in controllers | Warning |
| Anemic services | Service = simple delegation | Warning |
| Fat repository | Logic in repository | Warning |
<?php
declare(strict_types=1);
namespace Presentation\Api\Order;
use Application\Order\Service\OrderService;
use Application\Order\DTO\CreateOrderDTO;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
final readonly class OrderController
{
public function __construct(
private OrderService $orderService
) {}
public function create(Request $request): JsonResponse
{
$dto = CreateOrderDTO::fromRequest($request);
$result = $this->orderService->createOrder($dto);
return new JsonResponse($result->toArray(), 201);
}
public function show(string $id): JsonResponse
{
$order = $this->orderService->getOrder($id);
return new JsonResponse($order->toArray());
}
}
<?php
declare(strict_types=1);
namespace Application\Order\Service;
use Application\Order\DTO\CreateOrderDTO;
use Application\Order\DTO\OrderDTO;
use Domain\Order\Entity\Order;
use Domain\Order\Repository\OrderRepositoryInterface;
use Domain\Order\ValueObject\OrderId;
final readonly class OrderService
{
public function __construct(
private OrderRepositoryInterface $orderRepository,
private TransactionManagerInterface $transactionManager
) {}
public function createOrder(CreateOrderDTO $dto): OrderDTO
{
return $this->transactionManager->transactional(function () use ($dto) {
$order = Order::create(
id: $this->orderRepository->nextIdentity(),
customerId: $dto->customerId,
lines: $dto->lines
);
$this->orderRepository->save($order);
return OrderDTO::fromEntity($order);
});
}
public function getOrder(string $id): OrderDTO
{
$order = $this->orderRepository->findById(new OrderId($id));
if ($order === null) {
throw new OrderNotFoundException($id);
}
return OrderDTO::fromEntity($order);
}
}
<?php
declare(strict_types=1);
namespace Domain\Order\Entity;
use Domain\Order\ValueObject\OrderId;
use Domain\Order\ValueObject\CustomerId;
use Domain\Order\ValueObject\Money;
use Domain\Order\Enum\OrderStatus;
final class Order
{
private OrderStatus $status;
private array $lines = [];
public function __construct(
private readonly OrderId $id,
private readonly CustomerId $customerId
) {
$this->status = OrderStatus::Draft;
}
public static function create(OrderId $id, CustomerId $customerId, array $lines): self
{
$order = new self($id, $customerId);
foreach ($lines as $line) {
$order->addLine($line);
}
return $order;
}
public function confirm(): void
{
if (!$this->canBeConfirmed()) {
throw new CannotConfirmOrderException();
}
$this->status = OrderStatus::Confirmed;
}
public function total(): Money
{
return array_reduce(
$this->lines,
fn (Money $carry, OrderLine $line) => $carry->add($line->total()),
Money::zero('USD')
);
}
private function canBeConfirmed(): bool
{
return $this->status === OrderStatus::Draft && !empty($this->lines);
}
}
<?php
declare(strict_types=1);
namespace Infrastructure\Persistence\Order;
use Domain\Order\Entity\Order;
use Domain\Order\Repository\OrderRepositoryInterface;
use Domain\Order\ValueObject\OrderId;
use Doctrine\ORM\EntityManagerInterface;
final readonly class DoctrineOrderRepository implements OrderRepositoryInterface
{
public function __construct(
private EntityManagerInterface $em
) {}
public function findById(OrderId $id): ?Order
{
return $this->em->find(Order::class, $id->value);
}
public function save(Order $order): void
{
$this->em->persist($order);
$this->em->flush();
}
public function nextIdentity(): OrderId
{
return OrderId::generate();
}
}
For detailed information, load these reference files:
references/layer-responsibilities.md — Detailed layer responsibilitiesreferences/layer-communication.md — Inter-layer communication patternsreferences/dto-patterns.md — Data Transfer Object patternsreferences/antipatterns.md — Common violations with detection patterns아직 리뷰가 없습니다. 사용해 본 소감을 남겨 주세요.
로그인 없이 쓸 수 있습니다. 사용 후기, 질문, 작동하지 않은 환경 등을 편하게 남겨 주세요.
아직 댓글이 없습니다. 첫 댓글을 남겨 보세요.
Master backend architectures, REST API design, microservices, and server-side development across multiple languages. Use this as a central index to access specialized sub-skills.
한국어 요약은 준비 중입니다. 원문 설명을 표시하고 있습니다.
在每次回复中使用固定前缀并列出本次实际参考的指令/文件，便于校验是否遵循上下文与规则。
한국어 요약은 준비 중입니다. 원문 설명을 표시하고 있습니다.
Automate 21risk tasks via Rube MCP (Composio). Always search tools first for current schemas.
한국어 요약은 준비 중입니다. 원문 설명을 표시하고 있습니다.
Automate 2chat tasks via Rube MCP (Composio). Always search tools first for current schemas.
한국어 요약은 준비 중입니다. 원문 설명을 표시하고 있습니다.
Arquitecto de Soluciones Principal y Consultor Tecnológico de Andru.ia. Diagnostica y traza la hoja de ruta óptima para proyectos de IA en español.
한국어 요약은 준비 중입니다. 원문 설명을 표시하고 있습니다.
[00] META. Orchestrate skills into dynamic chains for complex tasks. Analyzes the task, discovers available skills, builds an optimal chain, explains why each skill is needed, and executes step-by-step with user confirmation. Use for any complex task requiring multiple thinking/research/analysis steps. Triggers on "plan this", "how to approach", "what's the strategy", "build a plan", or any multi-step problem requiring skill orchestration.
한국어 요약은 준비 중입니다. 원문 설명을 표시하고 있습니다.