La clean Architecture avec Laravel... où renvoyer les messages d'erreurs et où effectuer des conditions ?

Bonjour à tous j'essaie de comprendre (la clean architecture en me basant sur l'article de Mathieu Garcia sur Laravel France. Je vais vous présenter ici les couches que j'ai ajouté c'est un exemple qui suis l'article en question, sauf que je ne sais pas où renvoyer une erreur, ou encore ou est ce que je dois effectuer une quelconque condition si besoin étant donné que chaque couche me parait avoir un role strict et dois être independante. Je vais faire mon max pour être très clair peut être je me trompe sur certains points j'essaie justement de comprendre au mieux.

Dans la Clean Architecture (C.A) nous avons 4 couches :

• la couche présentation
• la couche application
• la couche domain
• la couche infrastructure

Je vous renvoie vers l'article pour connaitre le role précis de chacune d'elles.

dans la couche présentation :

function create(Request $request)
  {
      $output = $this->createOrderAction->handle(
          new Input(
              $request->input('product_id'),
              $request->input('quantity'),
              $request->input('discount', null)
          )
      );
 
      return $this->createOrderPresenter->present($output);
  }

mon presenter :

 
public function present(Output $output): JsonResponse
{
        $message = 'Order created successfully with a total amount of '.$output->totalPrice;
 
        return response()->json([$message], 201);
}

dans la couche application :

class CreateOrderAction
{
    /**
     * Create a new class instance.
     */
    public function __construct(private readonly OrderRepository $repository)
    {
    }
 
    public function handle(Input $input): Output
    {
            $order = $this->repository->initiateOrder($input->productId);
 
            $order->defineQuantity($input->quantity);
 
            $order->calculateTotalPrice();
 
            $order->applyCustomerDiscount($input->discount);
 
            $order->addApplicableTaxes();
 
            $this->repository->commitOrder($order);
 
            return new Output($order->totalPrice);
    }
}

dans la couche domain :

class OrderDomain
{
    private bool $taxesApplied = false;
 
    public function __construct(
        public int $price,
        public int $productId,
        public int $quantity,
        public int $totalPrice,
    ) {}
 
    public function defineQuantity(int $quantity): void
    {
        $this->quantity = $quantity;
    }
 
    public function calculateTotalPrice(): void
    {
        $this->totalPrice = $this->price * $this->quantity;
    }
 
    public function applyCustomerDiscount(float $percentage): void
    {
        $this->totalPrice -= $this->totalPrice * ($percentage / 100);
    }
 
    public function addApplicableTaxes(): void
    {
        if ($this->taxesApplied) {
            throw new LogicException("Taxes have already been applied.");
        }
 
        $this->totalPrice *= 1.2;
 
        $this->taxesApplied = true;
    }
}

dans la couche infastructure :

class OrderRepositoryInDatabase implements OrderRepository
{
    public function __construct(
        private readonly Database $database,
    ) {
    }
 
    public function initiateOrder(int $id): Order
    {
        $product = $this->database->table('products')->find($id);
 
        throw_unless($product, ProductNotFoundException::class);
 
        return new Order(
            productId: $product->productId,
            price: $product->price,
        );
    }
 
    public function commitOrder(OrderDomain $order): void
    {
        $this->database->table('orders')->insert([
            'product_id' => $order->productId,
            'quantity' => $order->quantity,
            'total_price' => $order->totalPrice,
        ]);
    }
}

et entre autre mon interface OrderRepository :

interface OrderRepository
{
 
    public function commitOrder(OrderDomain $order);
 
    public function initiateOrder(int $id);
 
 
}

mes DTOs Input et Output :

class Input
{
   /**
    * Create a new class instance.
    */
   public function __construct(
       public $productId,
       public $quantity,
       public $discount
   )
   {
       //
   }
}

class Output
{
    public int $totalPrice = 200;
 
    /**
     * Create a new class instance.
     */
    public function __construct()
    {
        //
    }
 
    public function price(): int
    {
        return 20000;
    }
}

Maintenant moi ma question est par exemple je ne trouve pas l'id du produit dans ma couche infrastructure et que je ne veux pas forcement renvoyer une exception, mais un message ou un not found sur mon api, dans quelle couche je vérifie ça ? initialement je l'aurais fait dans le presenter.. mais le presenter ne doit pas contenir de logique métier, de ce fait est qu'un swtich un if etc.. peut y aller? donc je ne sais pas peut être je suis meme à l'ouest raison pour laquelle je vous demande .. prenez moi comme un petit frère si ma question est bête 😅