// Presentation Layer — HTTP Controller
@Controller("orders")
export class OrdersController {
  constructor(private ordersService: OrdersApplicationService) {}

  @Post()
  async createOrder(
    @Body() dto: CreateOrderDto,
    @CurrentUser() user: AuthUser
  ): Promise<OrderResponseDto> {
    const order = await this.ordersService.createOrder(user.id, dto);
    return OrderResponseDto.fromDomain(order);
  }

  @Get(":id")
  async getOrder(@Param("id") id: string): Promise<OrderResponseDto> {
    const order = await this.ordersService.getOrder(id);
    return OrderResponseDto.fromDomain(order);
  }
}

// Application Layer — Use Case Orchestration
@Injectable()
export class OrdersApplicationService {
  constructor(
    private ordersRepo: OrdersRepository,
    private usersRepo: UsersRepository,
    private paymentsService: PaymentsDomainService,
    private eventBus: EventBus
  ) {}

  async createOrder(userId: string, dto: CreateOrderDto): Promise<Order> {
    const user = await this.usersRepo.findById(userId);
    if (!user) throw new NotFoundException("User not found");

    // Business logic lives in Domain Service
    const order = await this.paymentsService.processNewOrder(user, dto.items, dto.paymentMethod);

    await this.ordersRepo.save(order);
    await this.eventBus.publish({ type: "ORDER_CREATED", payload: order });

    return order;
  }
}

// Business Logic Layer — Domain Service
@Injectable()
export class PaymentsDomainService {
  async processNewOrder(user: User, items: OrderItem[], paymentMethod: PaymentMethod): Promise<Order> {
    if (!user.isActive) throw new BusinessError("INACTIVE_USER");
    if (items.length === 0) throw new BusinessError("EMPTY_ORDER");

    const total = items.reduce((sum, item) => sum + item.price * item.quantity, 0);
    if (total > user.creditLimit) throw new BusinessError("CREDIT_LIMIT_EXCEEDED");

    return new Order({
      userId: user.id,
      items,
      total,
      status: "pending",
      createdAt: new Date(),
    });
  }
}

// Data Access Layer — Repository
@Injectable()
export class OrdersRepository {
  constructor(private db: DatabaseService) {}

  async save(order: Order): Promise<Order> {
    const row = await this.db.query(
      "INSERT INTO orders (id, user_id, items, total, status, created_at) VALUES ($1, $2, $3, $4, $5, $6) RETURNING *",
      [order.id, order.userId, JSON.stringify(order.items), order.total, order.status, order.createdAt]
    );
    return Order.fromRow(row);
  }

  async findById(id: string): Promise<Order | null> {
    const row = await this.db.query("SELECT * FROM orders WHERE id = $1", [id]);
    return row ? Order.fromRow(row) : null;
  }
}
Layered Architecture — ארכיטקטורת שכבות

Layered Architecture — ארכיטקטורת שכבות

Layered Architecture — ארכיטקטורת שכבות
