Layered Architecture (계층형 아키텍처)

┌──────────────────────────────┐
│  Presentation (Controller)   │  HTTP 요청/응답 처리
├──────────────────────────────┤
│  Application / Business      │  유스케이스, 비즈니스 규칙
│  (Service)                   │
├──────────────────────────────┤
│  Persistence (Repository)    │  DB 읽기/쓰기
├──────────────────────────────┤
│  Database                    │
└──────────────────────────────┘
        요청은 위에서 아래로 흐른다

// 계층이 없는 코드: 요청 파싱, 규칙, SQL이 한 곳에 섞여 있다
@Post('orders')
async create(@Body() body: any) {
  if (!body.items?.length) throw new BadRequestException('상품이 없습니다');

  const total = body.items.reduce((s, i) => s + i.price * i.quantity, 0);
  if (total < 10000) throw new BadRequestException('최소 주문 금액은 10,000원입니다');

  const result = await this.dataSource.query(
    'INSERT INTO orders (user_id, total) VALUES ($1, $2) RETURNING id',
    [body.userId, total],
  );
  return { id: result[0].id };
}

src/order/
├── order.controller.ts      # Presentation
├── dto/create-order.dto.ts  # Presentation
├── order.service.ts         # Business
├── order.repository.ts      # Persistence
├── order.entity.ts          # 데이터 모델
└── order.module.ts

// dto/create-order.dto.ts
export class CreateOrderDto {
  @IsInt()
  userId: number;

  @ValidateNested({ each: true })
  @Type(() => OrderItemDto)
  @ArrayNotEmpty()
  items: OrderItemDto[];
}

// order.controller.ts
@Controller('orders')
export class OrderController {
  constructor(private readonly orderService: OrderService) {}

  @Post()
  async create(@Body() dto: CreateOrderDto) {
    const orderId = await this.orderService.createOrder(dto.userId, dto.items);
    return { id: orderId };
  }
}

// order.service.ts
@Injectable()
export class OrderService {
  private static readonly MIN_ORDER_AMOUNT = 10_000;

  constructor(private readonly orderRepository: OrderRepository) {}

  async createOrder(userId: number, items: OrderItemDto[]): Promise<number> {
    const total = items.reduce((sum, i) => sum + i.price * i.quantity, 0);

    if (total < OrderService.MIN_ORDER_AMOUNT) {
      throw new MinimumOrderAmountException(total);
    }

    const order = await this.orderRepository.save({ userId, total, status: 'PENDING' });
    return order.id;
  }
}

// order.repository.ts
@Injectable()
export class OrderRepository {
  constructor(
    @InjectRepository(OrderEntity)
    private readonly repo: Repository<OrderEntity>,
  ) {}

  save(data: Partial<OrderEntity>): Promise<OrderEntity> {
    return this.repo.save(data);
  }

  findByUserId(userId: number): Promise<OrderEntity[]> {
    return this.repo.find({ where: { userId }, order: { createdAt: 'DESC' } });
  }
}

Controller ──> Service ──> Repository ──> DB
   (O) 위가 아래를 안다
   (X) 아래가 위를 안다: Repository가 Controller를 import 하면 안 된다

// Service가 TypeORM 엔티티를 그대로 쓰고 있다
async createOrder(...) {
  const order = await this.orderRepository.save({ ... }); // OrderEntity = TypeORM 엔티티
  // order.items 를 쓰려면 relations 설정을 신경 써야 한다 → DB 사정이 비즈니스 코드로 새어 나온다
}

// 엔티티는 데이터만 가진다
class Order {
  status: string;
  total: number;
}

// 규칙은 전부 서비스에
class OrderService {
  cancel(order: Order) {
    if (order.status === 'SHIPPED') throw new Error('배송 후 취소 불가');
    order.status = 'CANCELLED';
  }
}

class Order {
  private status: OrderStatus;

  cancel() {
    if (this.status === OrderStatus.SHIPPED) {
      throw new CannotCancelShippedOrderException();
    }
    this.status = OrderStatus.CANCELLED;
  }
}

// (X) 엔티티를 그대로 반환
return this.userRepository.findOne({ where: { id } });

// (O) 응답 DTO로 변환
const user = await this.userService.getUser(id);
return UserResponseDto.from(user);