// Use Case layer — defines what it needs (Port)
interface OrdersRepository {
  findById(id: string): Promise<Order | null>;
  save(order: Order): Promise<void>;
  findByUserId(userId: string): Promise<Order[]>;
}

// Use Case — depends only on interface, not implementation
class CreateOrderUseCase {
  constructor(
    private ordersRepo: OrdersRepository,  // Port — abstract
    private usersRepo: UsersRepository,    // Port — abstract
    private notifier: OrderNotifier        // Port — abstract
  ) {}

  async execute(command: CreateOrderCommand): Promise<CreateOrderResult> {
    const user = await this.usersRepo.findById(command.userId);
    if (!user) throw new UserNotFoundError(command.userId);
    if (!user.canPlaceOrders()) throw new UserSuspendedError(command.userId);

    const order = Order.create({
      userId: command.userId,
      items: command.items,
    });

    await this.ordersRepo.save(order);
    await this.notifier.orderCreated(order);

    return { orderId: order.id, total: order.total };
  }
}

// Infrastructure layer — implements Port (Adapter)
class PostgresOrdersRepository implements OrdersRepository {
  constructor(private db: Pool) {}

  async findById(id: string): Promise<Order | null> {
    const result = await this.db.query(
      "SELECT * FROM orders WHERE id = $1",
      [id]
    );
    return result.rows[0] ? Order.fromPersistence(result.rows[0]) : null;
  }

  async save(order: Order): Promise<void> {
    await this.db.query(
      "INSERT INTO orders (id, user_id, items, total, status, created_at) VALUES ($1, $2, $3, $4, $5, $6) ON CONFLICT (id) DO UPDATE SET ...",
      [order.id, order.userId, JSON.stringify(order.items), order.total, order.status, order.createdAt]
    );
  }

  async findByUserId(userId: string): Promise<Order[]> {
    const result = await this.db.query(
      "SELECT * FROM orders WHERE user_id = $1 ORDER BY created_at DESC",
      [userId]
    );
    return result.rows.map(Order.fromPersistence);
  }
}

// For tests — in-memory implementation of the same Port
class InMemoryOrdersRepository implements OrdersRepository {
  private orders: Map<string, Order> = new Map();

  async findById(id: string): Promise<Order | null> {
    return this.orders.get(id) ?? null;
  }

  async save(order: Order): Promise<void> {
    this.orders.set(order.id, order);
  }

  async findByUserId(userId: string): Promise<Order[]> {
    return Array.from(this.orders.values()).filter(o => o.userId === userId);
  }
}
Clean Architecture — ארכיטקטורה נקייה

Clean Architecture — ארכיטקטורה נקייה

Clean Architecture — ארכיטקטורה נקייה
