3dealer/app/Catalog/ProductListingPage.php

<?php

namespace App\Catalog;

use Closure;
use Modules\Core\Catalog\Enums\ProductSort;
use Modules\Core\Catalog\Services\ProductSearchService;
use Modules\Core\Catalog\Services\ProductService;

/**
 * Assembles the data the shared shop listing body (shop/partials/listing.blade.php)
 * needs — the product page, price-slider bounds, sort links and the "clear price"
 * link. Used by the category page (scoped to a collection), the all-products
 * page, and the search page (scoped to a query — see $query below); the `$url`
 * closure turns a query-param array into a URL for whichever page is calling,
 * so this class never has to know the route.
 */
final class ProductListingPage
{
    private const PER_PAGE = 40;

    /** Category pages rarely have enough products to fill a page, so this
     * ceiling is high enough to act as "no pagination" in practice — the
     * pagination component self-hides via hasPages() when everything fits.
     * If a category ever exceeds it, pagination reappears as a safety net
     * rather than silently truncating results. */
    private const CATEGORY_PER_PAGE = 200;

    public function __construct(
        private readonly ProductService $products,
        private readonly ProductSearchService $search,
    ) {}

    /**
     * @param  Closure(array<string, string|int>): string  $url
     * @param  ?int  $collectionId  scope to a collection, or null for every product
     * @param  ?string  $query  scope to a text search — when given, calls
     * @return array<string, mixed>
     */
    public function build(ProductListing $listing, Closure $url, ?int $collectionId = null, ?string $query = null): array
    {
        $filters = $listing->filters($collectionId);
        $perPage = $collectionId !== null ? self::CATEGORY_PER_PAGE : self::PER_PAGE;

        // Listing reads from the Meilisearch index via ProductService/
        // ProductSearchService, not Eloquent. Both return a
        // ProductListingResult — the product page plus the price-slider
        // bounds (and available tags) from one call; the controller no
        // longer stitches list()/search() + priceRange() together itself.
        // Sort/filter/page all come from $listing (the query string).
        $result = $query !== null
            ? $this->search->search(
                query: $query,
                filters: $filters,
                sort: $listing->sort,
                perPage: $perPage,
                page: $listing->page,
            )
            : $this->products->list(
                filters: $filters,
                perPage: $perPage,
                page: $listing->page,
                sort: $listing->sort,
            );

        $products = $result->products
            ->through(ProductCard::fromIndexed(...))
            ->appends($listing->query(['page' => null]));

        // Slider bounds — the price span of everything matching the *other*
        // filters, rounded to whole euros, plus whether the current price params
        // actually narrow that span. All computed in core
        $priceBounds = $result->priceBounds;

        return [
            'listing' => $listing,
            'products' => $products,
            'listingAction' => $url([]),
            'priceFloor' => $priceBounds->floor,
            'priceCeil' => $priceBounds->ceil,
            'clearPriceUrl' => $priceBounds->filtered
                ? $url($listing->query(['price_min' => null, 'price_max' => null, 'page' => null]))
                : null,
            'sortOptions' => ProductSortOptions::build(
                $listing->sort,
                fn (?ProductSort $sort) => $url($listing->query(['sort' => $sort?->value, 'page' => null])),
            ),
        ];
    }
}