refactor(catalog): extract visible items query

app/Domains/Catalog/Models/CatalogItem.php

@@ -186,59 +186,6 @@ class CatalogItem extends Model
         });
     }
 
-    /** @param Builder<CatalogItem> $query */
-    public function scopeWhereAvailableInCatalog(Builder $query): Builder
-    {
-        return $query->where(function (Builder $query): void {
-            $query
-                ->where(function (Builder $standardQuery): void {
-                    $standardQuery
-                        ->where('catalog_items.type', CatalogItemType::Standard->value)
-                        ->where(function (Builder $inventoryQuery): void {
-                            $inventoryQuery
-                                ->where('catalog_items.inventory_policy', InventoryPolicy::Unlimited->value)
-                                ->orWhereHas(
-                                    'inventory',
-                                    fn (Builder $query): Builder => $query
-                                        ->whereColumn('inventories.real_stock', '>', 'inventories.reserved_stock'),
-                                )
-                                ->orWhereHas(
-                                    'variants.inventory',
-                                    fn (Builder $query): Builder => $query
-                                        ->whereColumn('inventories.real_stock', '>', 'inventories.reserved_stock'),
-                                );
-                        });
-                })
-                ->orWhere(function (Builder $bundleQuery): void {
-                    $bundleQuery
-                        ->where('catalog_items.type', CatalogItemType::Bundle->value)
-                        ->whereRaw(<<<'SQL'
-                            NOT EXISTS (
-                                SELECT 1
-                                FROM bundle_components AS availability_components
-                                INNER JOIN catalog_items AS availability_items
-                                    ON availability_items.id = availability_components.component_catalog_item_id
-                                LEFT JOIN variantes AS availability_variants
-                                    ON availability_variants.id = availability_components.component_variant_id
-                                INNER JOIN inventories AS availability_inventories
-                                    ON availability_inventories.id = COALESCE(
-                                        availability_variants.inventory_id,
-                                        availability_items.inventory_id
-                                    )
-                                WHERE availability_components.bundle_catalog_item_id = catalog_items.id
-                                    AND availability_items.inventory_policy = ?
-                                GROUP BY availability_inventories.id,
-                                    availability_inventories.real_stock,
-                                    availability_inventories.reserved_stock
-                                HAVING availability_inventories.real_stock
-                                    - availability_inventories.reserved_stock
-                                    < SUM(availability_components.quantity)
-                            )
-                            SQL, [InventoryPolicy::Tracked->value]);
-                });
-        });
-    }
-
     /** @return Collection<int, Variant> */
     public function visibleVariants(?int $includedVariantId = null): Collection
     {

app/Domains/Catalog/Services/CatalogService.php

@@ -24,7 +24,7 @@ class CatalogService
 {
     public function __construct(
         protected AttachmentService $attachmentService,
-        private readonly CatalogItemAllowanceService $allowances,
+        private readonly VisibleCatalogItemsQuery $visibleCatalogItems,
     ) {}
 
     /**
@@ -262,8 +262,8 @@ class CatalogService
                 'bundleComponents.variant.catalogItem',
             ]);
 
-        $paginator = $this->allowances
+        $paginator = $this->visibleCatalogItems
-            ->applyProductVisibilityPolicy($query)
+            ->apply($query)
             ->orderByRaw(
                 'CASE WHEN LOWER(nombre) = ? THEN 0 WHEN LOWER(nombre) LIKE ? THEN 1 ELSE 2 END',
                 [$normalizedTerm, $startsWithPattern],
@@ -299,8 +299,8 @@ class CatalogService
                 'bundleComponents.variant.catalogItem',
             ]);
 
-        return $this->allowances
+        return $this->visibleCatalogItems
-            ->applyProductVisibilityPolicy($query)
+            ->apply($query)
             ->orderBy('nombre')
             ->paginate(perPage: $perPage, pageName: 'page', page: $page);
     }

app/Domains/Catalog/Services/FeaturedGroupService.php

@@ -17,6 +17,7 @@ class FeaturedGroupService
     /** @return array<array-key, mixed> */
     public function __construct(
         private readonly CatalogItemAllowanceService $allowances,
+        private readonly VisibleCatalogItemsQuery $visibleCatalogItems,
     ) {}
 
     public function itemsResponse(FeaturedGroup $featuredGroup, int $page, ?int $userId = null): array
@@ -71,7 +72,7 @@ class FeaturedGroupService
                 'bundleComponents.variant.catalogItem',
             ]);
 
-        $query = $this->allowances->applyProductVisibilityPolicy($query);
+        $query = $this->visibleCatalogItems->apply($query);
 
         return match ($featuredGroup->source_type) {
             FeaturedGroupSource::Manual => $query

app/Domains/Catalog/Services/VisibleCatalogItemsQuery.php

@@ -0,0 +1,81 @@
+<?php
+
+namespace App\Domains\Catalog\Services;
+
+use App\Domains\Catalog\Enums\AvailabilityEffect;
+use App\Domains\Catalog\Enums\CatalogItemType;
+use App\Domains\Catalog\Enums\InventoryPolicy;
+use App\Domains\Catalog\Models\CatalogItem;
+use Illuminate\Database\Eloquent\Builder;
+
+final class VisibleCatalogItemsQuery
+{
+    public function __construct(
+        private readonly AvailabilityPolicyResolver $policies,
+    ) {}
+
+    /** @param Builder<CatalogItem> $query */
+    public function apply(Builder $query): Builder
+    {
+        if ($this->policies->resolve('out_of_stock')['effect'] !== AvailabilityEffect::Hide) {
+            return $query;
+        }
+
+        return $query->where(function (Builder $query): void {
+            $query
+                ->where(fn (Builder $query) => $this->applyStandardItemAvailability($query))
+                ->orWhere(fn (Builder $query) => $this->applyBundleAvailability($query));
+        });
+    }
+
+    /** @param Builder<CatalogItem> $query */
+    private function applyStandardItemAvailability(Builder $query): Builder
+    {
+        return $query
+            ->where('catalog_items.type', CatalogItemType::Standard->value)
+            ->where(function (Builder $query): void {
+                $query
+                    ->where('catalog_items.inventory_policy', InventoryPolicy::Unlimited->value)
+                    ->orWhereHas(
+                        'inventory',
+                        fn (Builder $query): Builder => $query
+                            ->whereColumn('inventories.real_stock', '>', 'inventories.reserved_stock'),
+                    )
+                    ->orWhereHas(
+                        'variants.inventory',
+                        fn (Builder $query): Builder => $query
+                            ->whereColumn('inventories.real_stock', '>', 'inventories.reserved_stock'),
+                    );
+            });
+    }
+
+    /** @param Builder<CatalogItem> $query */
+    private function applyBundleAvailability(Builder $query): Builder
+    {
+        return $query
+            ->where('catalog_items.type', CatalogItemType::Bundle->value)
+            ->whereRaw(<<<'SQL'
+                NOT EXISTS (
+                    SELECT 1
+                    FROM bundle_components AS availability_components
+                    INNER JOIN catalog_items AS availability_items
+                        ON availability_items.id = availability_components.component_catalog_item_id
+                    LEFT JOIN variantes AS availability_variants
+                        ON availability_variants.id = availability_components.component_variant_id
+                    INNER JOIN inventories AS availability_inventories
+                        ON availability_inventories.id = COALESCE(
+                            availability_variants.inventory_id,
+                            availability_items.inventory_id
+                        )
+                    WHERE availability_components.bundle_catalog_item_id = catalog_items.id
+                        AND availability_items.inventory_policy = ?
+                    GROUP BY availability_inventories.id,
+                        availability_inventories.real_stock,
+                        availability_inventories.reserved_stock
+                    HAVING availability_inventories.real_stock
+                        - availability_inventories.reserved_stock
+                        < SUM(availability_components.quantity)
+                )
+                SQL, [InventoryPolicy::Tracked->value]);
+    }
+}