ldc-cocotte/app/Services/ProductDtoAssemblerService.php

145 lines
4.3 KiB
PHP

<?php
declare(strict_types=1);
namespace App\Services;
use App\Dto\ProductDto;
use App\Dto\ProductPricingDto;
use App\Dto\ProductWithPricingDto;
use App\Models\Product;
use Domain\Models\Entities\Product as DomainProduct;
use Domain\Models\ValueObjects\Entities\ProductId;
use Domain\Ports\Repositories\ProductRepository;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Pagination\LengthAwarePaginator;
use Illuminate\Support\Collection as BaseCollection;
use Ramsey\Uuid\Uuid;
use Webmozart\Assert\Assert;
/**
* Point unique d'assemblage des DTOs produit : charge les entités domaine en une
* seule requête (pas de N+1) et en dérive la commandabilité et le pricing, afin
* que les DTOs restent purs (aucun accès au conteneur ni au repository).
*/
final readonly class ProductDtoAssemblerService
{
public function __construct(
private ProductRepository $productRepository,
) {
}
public function toDto(Product $product): ProductDto
{
return $this->toDtos([$product])[0];
}
public function toDtoWithPricing(Product $product): ProductWithPricingDto
{
return $this->toDtosWithPricing([$product])[0];
}
/**
* @param iterable<Product> $products
* @return list<ProductDto>
*/
public function toDtos(iterable $products): array
{
[$models, $entities] = $this->load($products);
return array_values(array_map(
fn (Product $model): ProductDto => ProductDto::fromModel(
$model,
$this->entityOf($entities, $model)->isOrderable(),
),
$models
));
}
/**
* @param iterable<Product> $products
* @return list<ProductWithPricingDto>
*/
public function toDtosWithPricing(iterable $products): array
{
[$models, $entities] = $this->load($products);
return array_values(array_map(
function (Product $model) use ($entities): ProductWithPricingDto {
$entity = $this->entityOf($entities, $model);
return new ProductWithPricingDto(
product: ProductDto::fromModel(
$model,
$entity->isOrderable(),
validDiscountOnly: true,
),
pricing: ProductPricingDto::fromModel($entity->pricing()),
);
},
$models
));
}
/**
* Remplace le contenu d'un paginator de modèles par des DTOs (sans pricing).
*
* @param LengthAwarePaginator<int, Product> $paginator
* @return LengthAwarePaginator<int, ProductDto>
*/
public function paginateDtos(LengthAwarePaginator $paginator): LengthAwarePaginator
{
$dtos = $this->toDtos($paginator->items());
/** @var LengthAwarePaginator<int, ProductDto> $paginator */
$paginator = $paginator->setCollection(new BaseCollection($dtos));
return $paginator;
}
/**
* @param LengthAwarePaginator<int, Product> $paginator
* @return LengthAwarePaginator<int, ProductWithPricingDto>
*/
public function paginateDtosWithPricing(LengthAwarePaginator $paginator): LengthAwarePaginator
{
$dtos = $this->toDtosWithPricing($paginator->items());
/** @var LengthAwarePaginator<int, ProductWithPricingDto> $paginator */
$paginator = $paginator->setCollection(new BaseCollection($dtos));
return $paginator;
}
/**
* @param iterable<Product> $products
* @return array{0: list<Product>, 1: array<string, DomainProduct>}
*/
private function load(iterable $products): array
{
$models = [];
foreach ($products as $product) {
$models[] = $product;
}
(new Collection($models))->loadMissing('range');
$ids = array_map(
static fn (Product $m): ProductId => new ProductId(Uuid::fromString((string) $m->id)),
$models
);
return [$models, $this->productRepository->findMany($ids)];
}
/**
* @param array<string, DomainProduct> $entities
*/
private function entityOf(array $entities, Product $model): DomainProduct
{
$entity = $entities[(string) $model->id] ?? null;
Assert::notNull($entity, "Domain product not found for ID {$model->id}");
return $entity;
}
}