feat(catalog): exclude out-of-stock items and update variant visibility logic

app/Domains/Catalog/Controllers/CatalogController.php

@@ -123,10 +123,6 @@ class CatalogController extends Controller
             $variantId === null ? null : (int) $variantId,
         );
         $allowances->attach(collect([$item]), $this->userId($request));
-        abort_unless($allowances->availability(
-            $item->availableStock(),
-            $item->getAttribute('remaining_user_quota'),
-        )->isVisible(), 404);
 
         return CatalogItemDetailResource::make($item);
     }

app/Domains/Catalog/Enums/AvailabilityEffect.php

@@ -1,10 +0,0 @@
-<?php
-
-namespace App\Domains\Catalog\Enums;
-
-enum AvailabilityEffect: string
-{
-    case Hide = 'hide';
-    case Restrict = 'restrict';
-    case Notice = 'notice';
-}

app/Domains/Catalog/Enums/CatalogAction.php

@@ -1,11 +0,0 @@
-<?php
-
-namespace App\Domains\Catalog\Enums;
-
-enum CatalogAction: string
-{
-    case SelectVariant = 'select_variant';
-    case ChangeQuantity = 'change_quantity';
-    case AddToCart = 'add_to_cart';
-    case BuyNow = 'buy_now';
-}

app/Domains/Catalog/Models/CatalogItem.php

@@ -172,18 +172,30 @@ class CatalogItem extends Model
     }
 
     /** @param Builder<CatalogItem> $query */
-    public function scopeWhereVariantsAvailable(Builder $query): Builder
+    public function scopeWhereAvailable(Builder $query): Builder
     {
         return $query->where(function (Builder $query): void {
             $query
-                ->whereDoesntHave('variants')
+                ->where('catalog_items.inventory_policy', InventoryPolicy::Unlimited->value)
-                ->orWhere('catalog_items.inventory_policy', InventoryPolicy::Unlimited->value)
                 ->orWhereHas(
                     'variants.inventory',
                     fn (Builder $inventoryQuery): Builder => $inventoryQuery
                         ->whereColumn('inventories.real_stock', '>', 'inventories.reserved_stock')
+                )
+                ->orWhere(function (Builder $directItemQuery): void {
+                    $directItemQuery
+                        ->whereDoesntHave('variants')
+                        ->where(function (Builder $inventoryQuery): void {
+                            $inventoryQuery
+                                ->whereNull('catalog_items.inventory_id')
+                                ->orWhereHas(
+                                    'inventory',
+                                    fn (Builder $availableInventoryQuery): Builder => $availableInventoryQuery
+                                        ->whereColumn('inventories.real_stock', '>', 'inventories.reserved_stock')
                                 );
                         });
+                });
+        });
     }
 
     /** @return Collection<int, Variant> */

app/Domains/Catalog/Resources/CatalogFeaturedItemResource.php

@@ -38,13 +38,19 @@ class CatalogFeaturedItemResource extends JsonResource
             'nombre' => $catalogItem->nombre,
             'descripcion' => $catalogItem->descripcion,
             'precio' => $catalogItem->precio,
-            'availability' => $this->availability($availableStock, $remainingUserQuota),
+            'maximum_addable_quantity' => $this->maximumAddable(
-            'variants' => $catalogItem->variants
+                $availableStock,
-                ->map(function (Variant $variant) use ($catalogItem): array {
+                $remainingUserQuota,
+            ),
+            'unavailable_message' => $this->unavailableMessage(
+                $availableStock,
+                $remainingUserQuota,
+            ),
+            'variants' => $catalogItem->visibleVariants()
+                ->map(function (Variant $variant) use ($catalogItem, $remainingUserQuota): array {
                     $variantStock = $catalogItem->inventory_policy === InventoryPolicy::Unlimited
                         ? null
                         : $variant->inventory->availableStock();
-                    $availability = $this->availability($variantStock, null);
 
                     return [
                         'id' => $variant->id,
@@ -54,11 +60,17 @@ class CatalogFeaturedItemResource extends JsonResource
                         'event_dates' => $variant->selectedEventDates()->map(fn ($eventDate): string => $eventDate->date->format('Y-m-d'))->values(),
                         'descripcion' => $variant->getDescription(),
                         'precio' => number_format($variant->getPrice(), 2, '.', ''),
-                        'availability' => $availability,
+                        'maximum_addable_quantity' => $this->maximumAddable(
+                            $variantStock,
+                            $remainingUserQuota,
+                        ),
+                        'unavailable_message' => $this->unavailableMessage(
+                            $variantStock,
+                            $remainingUserQuota,
+                        ),
                         'values' => $variant->selectorOptions($catalogItem->itemAttributes),
                     ];
                 })
-                ->filter(fn (array $variant): bool => $variant['availability']['state'] === 'visible')
                 ->values(),
         ];
 
@@ -78,7 +90,8 @@ class CatalogFeaturedItemResource extends JsonResource
             'descripcion' => $catalogItem->descripcion,
             'precio' => $catalogItem->precio,
             'image' => $this->firstImageUrl($catalogItem),
-            'availability' => $this->availability($availableStock, $remainingUserQuota),
+            'maximum_addable_quantity' => $this->maximumAddable($availableStock, $remainingUserQuota),
+            'unavailable_message' => $this->unavailableMessage($availableStock, $remainingUserQuota),
         ];
     }
 
@@ -94,27 +107,30 @@ class CatalogFeaturedItemResource extends JsonResource
             'nombre' => $catalogItem->nombre,
             'precio' => $catalogItem->precio,
             'image' => $this->firstImageUrl($catalogItem),
-            'availability' => $this->availability($availableStock, $remainingUserQuota),
+            'maximum_addable_quantity' => $this->maximumAddable($availableStock, $remainingUserQuota),
+            'unavailable_message' => $this->unavailableMessage($availableStock, $remainingUserQuota),
         ];
     }
 
     private function firstImageUrl(CatalogItem $catalogItem): ?string
     {
         $attachment = $catalogItem->attachments->first()
-            ?? $catalogItem->variants
+            ?? $catalogItem->visibleVariants()
                 ->flatMap(fn (Variant $variant) => $variant->attachments)
                 ->first();
 
         return $attachment?->getTemporaryUrl(1440);
     }
 
-    /** @return array<string, mixed> */
+    private function maximumAddable(?int $stock, ?int $remainingUserQuota): ?int
-    private function availability(
+    {
-        ?int $stock,
-        ?int $remainingUserQuota,
-    ): array {
         return app(CatalogItemAllowanceService::class)
-            ->availability($stock, $remainingUserQuota)
+            ->maximumAddableQuantity($stock, $remainingUserQuota);
-            ->toArray();
+    }
+
+    private function unavailableMessage(?int $stock, ?int $remainingUserQuota): ?string
+    {
+        return app(CatalogItemAllowanceService::class)
+            ->unavailableMessage($stock, $remainingUserQuota);
     }
 }

app/Domains/Catalog/Resources/CatalogItemDetailResource.php

@@ -38,14 +38,20 @@ class CatalogItemDetailResource extends JsonResource
             'max_units_per_user' => $this->max_units_per_user,
             'has_tickets' => $this->has_tickets,
             'attributes' => $this->attributesData(),
-            'availability' => $this->availability($this->availableStock()),
+            'maximum_addable_quantity' => $this->when(
+                $selectedVariant === null,
+                fn () => $this->maximumAddable($this->availableStock()),
+            ),
+            'unavailable_message' => $this->when(
+                $selectedVariant === null,
+                fn () => $this->unavailableMessage($this->availableStock()),
+            ),
             'images' => $this->when(
                 $selectedVariant === null,
                 fn () => $this->imageUrls($this->attachments),
             ),
             'variants' => $this->variants
                 ->map(fn (Variant $variant): array => $this->variantData($variant))
-                ->filter(fn (array $variant): bool => $variant['availability']['state'] === 'visible')
                 ->values(),
             'selected_variant' => $this->when(
                 $selectedVariant !== null,
@@ -158,10 +164,6 @@ class CatalogItemDetailResource extends JsonResource
         $values = $variant->selectionOptions($this->itemAttributes);
         $eventDates = $variant->selectedEventDates();
         $variantStock = $this->variantStock($variant);
-        $availability = $this->availability(
-            $variantStock,
-            false,
-        );
 
         return [
             'id' => $variant->id,
@@ -171,7 +173,8 @@ class CatalogItemDetailResource extends JsonResource
             'event_dates' => $eventDates->map(fn ($eventDate): string => $eventDate->date->format('Y-m-d'))->values(),
             'descripcion' => $variant->getDescription(),
             'precio' => number_format($variant->getPrice(), 2, '.', ''),
-            'availability' => $availability,
+            'maximum_addable_quantity' => $this->maximumAddable($variantStock),
+            'unavailable_message' => $this->unavailableMessage($variantStock),
             'values' => $values,
         ];
     }
@@ -191,14 +194,19 @@ class CatalogItemDetailResource extends JsonResource
             : $variant->inventory->availableStock();
     }
 
-    /** @return array<string, mixed> */
+    private function maximumAddable(?int $stock): ?int
-    private function availability(
+    {
-        ?int $stock,
+        return app(CatalogItemAllowanceService::class)->maximumAddableQuantity(
-        bool $includeUserQuota = true,
-    ): array {
-        return app(CatalogItemAllowanceService::class)->availability(
             $stock,
-            $includeUserQuota ? $this->getAttribute('remaining_user_quota') : null,
+            $this->getAttribute('remaining_user_quota'),
-        )->toArray();
+        );
+    }
+
+    private function unavailableMessage(?int $stock): ?string
+    {
+        return app(CatalogItemAllowanceService::class)->unavailableMessage(
+            $stock,
+            $this->getAttribute('remaining_user_quota'),
+        );
     }
 }

app/Domains/Catalog/Resources/CatalogSearchItemResource.php

@@ -16,8 +16,9 @@ class CatalogSearchItemResource extends JsonResource
     public function toArray(Request $request): array
     {
         $availableStock = $this->availableStock();
+        $visibleVariants = $this->visibleVariants();
         $attachment = $this->attachments->first()
-            ?? $this->variants
+            ?? $visibleVariants
                 ->flatMap(fn (Variant $variant) => $variant->attachments)
                 ->first();
 
@@ -28,16 +29,13 @@ class CatalogSearchItemResource extends JsonResource
             'descripcion' => $this->descripcion,
             'precio' => $this->precio,
             'image' => $attachment?->getTemporaryUrl(1440),
-            'availability' => $this->availability($availableStock),
+            'maximum_addable_quantity' => $this->maximumAddable($availableStock),
-            'variants' => $this->variants
+            'unavailable_message' => $this->unavailableMessage($availableStock),
+            'variants' => $visibleVariants
                 ->map(function (Variant $variant): array {
                     $variantStock = $this->inventory_policy === InventoryPolicy::Unlimited
                         ? null
                         : $variant->inventory?->availableStock();
-                    $availability = $this->availability(
-                        $variantStock,
-                        false,
-                    );
 
                     return [
                         'id' => $variant->id,
@@ -47,23 +45,28 @@ class CatalogSearchItemResource extends JsonResource
                         'event_dates' => $variant->selectedEventDates()->map(fn ($eventDate): string => $eventDate->date->format('Y-m-d'))->values(),
                         'descripcion' => $variant->getDescription(),
                         'precio' => number_format($variant->getPrice(), 2, '.', ''),
-                        'availability' => $availability,
+                        'maximum_addable_quantity' => $this->maximumAddable($variantStock),
+                        'unavailable_message' => $this->unavailableMessage($variantStock),
                         'values' => $variant->selectorOptions($this->itemAttributes),
                     ];
                 })
-                ->filter(fn (array $variant): bool => $variant['availability']['state'] === 'visible')
                 ->values(),
         ];
     }
 
-    /** @return array<string, mixed> */
+    private function maximumAddable(?int $stock): ?int
-    private function availability(
+    {
-        ?int $stock,
+        return app(CatalogItemAllowanceService::class)->maximumAddableQuantity(
-        bool $includeUserQuota = true,
-    ): array {
-        return app(CatalogItemAllowanceService::class)->availability(
             $stock,
-            $includeUserQuota ? $this->getAttribute('remaining_user_quota') : null,
+            $this->getAttribute('remaining_user_quota'),
-        )->toArray();
+        );
+    }
+
+    private function unavailableMessage(?int $stock): ?string
+    {
+        return app(CatalogItemAllowanceService::class)->unavailableMessage(
+            $stock,
+            $this->getAttribute('remaining_user_quota'),
+        );
     }
 }

app/Domains/Catalog/Services/AvailabilityDecision.php

@@ -1,63 +0,0 @@
-<?php
-
-namespace App\Domains\Catalog\Services;
-
-use App\Domains\Catalog\Enums\CatalogAction;
-
-final readonly class AvailabilityDecision
-{
-    /**
-     * @param  list<CatalogAction>  $allowedActions
-     * @param  list<array{code: string, message: string}>  $reasons
-     */
-    private function __construct(
-        private bool $visible,
-        private ?int $maximumQuantity,
-        private array $allowedActions,
-        private array $reasons,
-    ) {}
-
-    /** @param list<array{code: string, message: string}> $reasons */
-    public static function hidden(array $reasons): self
-    {
-        return new self(false, null, [], $reasons);
-    }
-
-    /**
-     * @param  list<CatalogAction>  $allowedActions
-     * @param  list<array{code: string, message: string}>  $reasons
-     */
-    public static function visible(
-        ?int $maximumQuantity,
-        array $allowedActions,
-        array $reasons,
-    ): self {
-        return new self(true, $maximumQuantity, $allowedActions, $reasons);
-    }
-
-    public function isVisible(): bool
-    {
-        return $this->visible;
-    }
-
-    /** @return array<string, mixed> */
-    public function toArray(): array
-    {
-        if (! $this->visible) {
-            return [
-                'state' => 'hidden',
-                'reasons' => $this->reasons,
-            ];
-        }
-
-        return [
-            'state' => 'visible',
-            'maximum_quantity' => $this->maximumQuantity,
-            'allowed_actions' => array_map(
-                fn (CatalogAction $action): string => $action->value,
-                $this->allowedActions,
-            ),
-            'reasons' => $this->reasons,
-        ];
-    }
-}

app/Domains/Catalog/Services/AvailabilityPolicyResolver.php

@@ -1,26 +0,0 @@
-<?php
-
-namespace App\Domains\Catalog\Services;
-
-use App\Domains\Catalog\Enums\AvailabilityEffect;
-use App\Domains\Catalog\Enums\CatalogAction;
-
-final class AvailabilityPolicyResolver
-{
-    /** @return array{effect: AvailabilityEffect, denied_actions: list<CatalogAction>} */
-    public function resolve(string $restrictionCode): array
-    {
-        /** @var array{effect?: string, denied_actions?: list<string>} $configured */
-        $configured = config("catalog.availability.rules.{$restrictionCode}", []);
-
-        return [
-            'effect' => AvailabilityEffect::from(
-                $configured['effect'] ?? AvailabilityEffect::Notice->value,
-            ),
-            'denied_actions' => array_map(
-                fn (string $action): CatalogAction => CatalogAction::from($action),
-                $configured['denied_actions'] ?? [],
-            ),
-        ];
-    }
-}

app/Domains/Catalog/Services/CatalogItemAllowanceService.php

@@ -2,8 +2,6 @@
 
 namespace App\Domains\Catalog\Services;
 
-use App\Domains\Catalog\Enums\AvailabilityEffect;
-use App\Domains\Catalog\Enums\CatalogAction;
 use App\Domains\Catalog\Models\CatalogItem;
 use App\Domains\Purchase\Services\UserPurchaseLimitService;
 use Illuminate\Support\Collection;
@@ -16,7 +14,6 @@ class CatalogItemAllowanceService
 
     public function __construct(
         private readonly UserPurchaseLimitService $purchaseLimits,
-        private readonly AvailabilityPolicyResolver $policies,
     ) {}
 
     /** @param Collection<int, CatalogItem> $catalogItems */
@@ -45,82 +42,16 @@ class CatalogItemAllowanceService
         return min($availableStock, $remainingUserQuota);
     }
 
-    public function availability(
+    public function unavailableMessage(?int $availableStock, ?int $remainingUserQuota): ?string
-        ?int $availableStock,
+    {
-        ?int $remainingUserQuota,
-    ): AvailabilityDecision {
-        $reasons = [];
-
         if ($remainingUserQuota !== null && $remainingUserQuota <= 0) {
-            $reasons[] = [
+            return self::USER_QUOTA_REACHED_MESSAGE;
-                'code' => 'user_quota_reached',
-                'message' => self::USER_QUOTA_REACHED_MESSAGE,
-            ];
         }
 
         if ($availableStock !== null && $availableStock <= 0) {
-            $reasons[] = [
+            return self::OUT_OF_STOCK_MESSAGE;
-                'code' => 'out_of_stock',
-                'message' => self::OUT_OF_STOCK_MESSAGE,
-            ];
         }
 
-        return $this->decision(
+        return null;
-            $this->maximumAddableQuantity($availableStock, $remainingUserQuota),
-            $reasons,
-        );
-    }
-
-    public function purchaseLimitExceededAvailability(
-        int $maximumQuantity,
-        string $message,
-    ): AvailabilityDecision {
-        $reasons = [];
-
-        if ($maximumQuantity <= 0) {
-            $reasons[] = [
-                'code' => 'user_quota_reached',
-                'message' => self::USER_QUOTA_REACHED_MESSAGE,
-            ];
-        } else {
-            $reasons[] = [
-                'code' => 'requested_quantity_exceeds_user_quota',
-                'message' => $message,
-            ];
-        }
-
-        return $this->decision($maximumQuantity, $reasons);
-    }
-
-    /**
-     * @param  list<array{code: string, message: string}>  $reasons
-     */
-    private function decision(?int $maximumQuantity, array $reasons): AvailabilityDecision
-    {
-        /** @var list<string> $configuredActions */
-        $configuredActions = config('catalog.availability.default_actions', []);
-        $allowedActions = collect($configuredActions)
-            ->map(fn (string $action): CatalogAction => CatalogAction::from($action));
-
-        foreach ($reasons as $reason) {
-            $policy = $this->policies->resolve($reason['code']);
-
-            if ($policy['effect'] === AvailabilityEffect::Hide) {
-                return AvailabilityDecision::hidden($reasons);
-            }
-
-            if ($policy['effect'] === AvailabilityEffect::Restrict) {
-                $deniedActions = $policy['denied_actions'];
-                $allowedActions = $allowedActions->reject(
-                    fn (CatalogAction $action): bool => in_array($action, $deniedActions, true),
-                );
-            }
-        }
-
-        return AvailabilityDecision::visible(
-            $maximumQuantity,
-            $allowedActions->values()->all(),
-            $reasons,
-        );
     }
 }

app/Domains/Catalog/Services/CatalogService.php

@@ -22,10 +22,7 @@ use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
 
 class CatalogService
 {
-    public function __construct(
+    public function __construct(protected AttachmentService $attachmentService) {}
-        protected AttachmentService $attachmentService,
-        private readonly VisibleCatalogItemsQuery $visibleCatalogItems,
-    ) {}
 
     /**
      * @param  array<string, mixed>  $data
@@ -208,6 +205,13 @@ class CatalogService
         ]);
 
         $visibleVariants = $catalogItem->visibleVariants();
+        if ($catalogItem->type === CatalogItemType::Standard
+            && ($catalogItem->inventory_id !== null || $catalogItem->variants->isNotEmpty())
+            && ! $catalogItem->isAvailable()) {
+            throw new NotFoundHttpException('Catalog item is out of stock.');
+        }
+
+        $catalogItem->setRelation('variants', $visibleVariants);
         $selectedVariant = $variantId === null
             ? $visibleVariants->first()
             : $visibleVariants->firstWhere('id', $variantId);
@@ -232,8 +236,9 @@ class CatalogService
         $containsPattern = "%{$normalizedTerm}%";
         $startsWithPattern = "{$normalizedTerm}%";
 
-        $query = CatalogItem::query()
+        $paginator = CatalogItem::query()
             ->where('tenant_code', $tenant->codigo)
+            ->whereAvailable()
             ->where(function (Builder $query) use ($containsPattern): void {
                 $query
                     ->whereRaw('LOWER(nombre) LIKE ?', [$containsPattern])
@@ -260,10 +265,7 @@ class CatalogService
                 'variants.definitions.itemAttribute.attribute.options',
                 'bundleComponents.catalogItem',
                 'bundleComponents.variant.catalogItem',
-            ]);
+            ])
-
-        $paginator = $this->visibleCatalogItems
-            ->apply($query)
             ->orderByRaw(
                 'CASE WHEN LOWER(nombre) = ? THEN 0 WHEN LOWER(nombre) LIKE ? THEN 1 ELSE 2 END',
                 [$normalizedTerm, $startsWithPattern],
@@ -283,9 +285,10 @@ class CatalogService
         int $perPage,
         int $page,
     ): LengthAwarePaginator {
-        $query = CatalogItem::query()
+        return CatalogItem::query()
             ->where('tenant_code', $tenant->codigo)
             ->where('category_id', $category->id)
+            ->whereAvailable()
             ->with([
                 'attachments',
                 'inventory',
@@ -297,10 +300,7 @@ class CatalogService
                 'variants.definitions.itemAttribute.attribute.options',
                 'bundleComponents.catalogItem',
                 'bundleComponents.variant.catalogItem',
-            ]);
+            ])
-
-        return $this->visibleCatalogItems
-            ->apply($query)
             ->orderBy('nombre')
             ->paginate(perPage: $perPage, pageName: 'page', page: $page);
     }

app/Domains/Catalog/Services/FeaturedGroupService.php

@@ -17,7 +17,6 @@ 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
@@ -50,6 +49,7 @@ class FeaturedGroupService
     {
         $query = CatalogItem::query()
             ->where('catalog_items.tenant_code', $featuredGroup->tenant_code)
+            ->whereAvailable()
             ->where(function (Builder $query): void {
                 $query
                     ->whereDoesntHave('category')
@@ -72,8 +72,6 @@ class FeaturedGroupService
                 'bundleComponents.variant.catalogItem',
             ]);
 
-        $query = $this->visibleCatalogItems->apply($query);
-
         return match ($featuredGroup->source_type) {
             FeaturedGroupSource::Manual => $query
                 ->select('catalog_items.*')

app/Domains/Catalog/Services/VariantSelectionService.php

@@ -10,10 +10,6 @@ use Illuminate\Support\Collection;
 
 class VariantSelectionService
 {
-    public function __construct(
-        private readonly CatalogItemAllowanceService $allowances,
-    ) {}
-
     /**
      * @param  array<string, mixed>  $selectedValues
      * @return array<string, mixed>
@@ -192,17 +188,13 @@ class VariantSelectionService
     /** @return array<string, mixed> */
     private function variantData(CatalogItem $catalogItem, Variant $variant): array
     {
-        $availableStock = $catalogItem->inventory_policy === InventoryPolicy::Unlimited
-            ? null
-            : $variant->inventory?->availableStock();
-
         return [
             'id' => $variant->id,
             'descripcion' => $variant->getDescription(),
             'precio' => number_format($variant->getPrice(), 2, '.', ''),
-            'availability' => $this->allowances
+            'stock_tecnico' => $catalogItem->inventory_policy === InventoryPolicy::Unlimited
-                ->availability($availableStock, null)
+                ? null
-                ->toArray(),
+                : $variant->inventory?->availableStock(),
             'values' => $variant->selectorOptions($catalogItem->itemAttributes),
         ];
     }

app/Domains/Catalog/Services/VisibleCatalogItemsQuery.php

@@ -1,81 +0,0 @@
-<?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]);
-    }
-}

bootstrap/app.php

@@ -1,7 +1,6 @@
 <?php
 
 use App\Domains\Auth\Exceptions\AccountLockedException;
-use App\Domains\Catalog\Services\CatalogItemAllowanceService;
 use App\Domains\Purchase\Exceptions\InsufficientStockException;
 use App\Domains\Purchase\Exceptions\PurchaseExpiredException;
 use App\Domains\Purchase\Exceptions\PurchaseLimitExceededException;
@@ -101,11 +100,7 @@ return Application::configure(basePath: dirname(__DIR__))
                 'errors' => $exception->errors(),
                 'catalog_item_id' => $exception->catalogItemId,
                 'catalog_item_name' => $exception->catalogItemName,
-                'availability' => app(CatalogItemAllowanceService::class)
+                'maximum_addable_quantity' => $exception->maximumAddableQuantity,
-                    ->purchaseLimitExceededAvailability(
-                        $exception->maximumAddableQuantity,
-                        $exception->getMessage(),
-                    )->toArray(),
             ], 422);
         });
         $exceptions->render(function (PurchaseExpiredException $exception, Request $request) {

config/catalog.php

@@ -2,33 +2,4 @@
 
 return [
     'stock_reservation_expiration_minutes' => (int) env('STOCK_RESERVATION_EXPIRATION_MINUTES', 30),
-    'availability' => [
-        'default_actions' => [
-            'select_variant',
-            'change_quantity',
-            'add_to_cart',
-            'buy_now',
-        ],
-        'rules' => [
-            'user_quota_reached' => [
-                'effect' => 'restrict',
-                'denied_actions' => [
-                    'select_variant',
-                    'change_quantity',
-                    'add_to_cart',
-                    'buy_now',
-                ],
-            ],
-            'out_of_stock' => [
-                'effect' => 'hide',
-            ],
-            'requested_quantity_exceeds_user_quota' => [
-                'effect' => 'restrict',
-                'denied_actions' => [
-                    'add_to_cart',
-                    'buy_now',
-                ],
-            ],
-        ],
-    ],
 ];

tests/Feature/Cart/CartControllerTest.php

@@ -246,7 +246,7 @@ class CartControllerTest extends TestCase
             ->assertJsonPath('code', 'purchase.limit_exceeded')
             ->assertJsonPath('catalog_item_id', $item->id)
             ->assertJsonPath('catalog_item_name', $item->nombre)
-            ->assertJsonPath('availability.maximum_quantity', 1)
+            ->assertJsonPath('maximum_addable_quantity', 1)
             ->assertJsonPath(
                 'message',
                 "Podés agregar hasta 1 unidad más de “{$item->nombre}”.",

tests/Feature/Catalog/BundleCatalogItemTest.php

@@ -267,7 +267,7 @@ class BundleCatalogItemTest extends TestCase
         $this->getJson("/api/tenants/{$this->tenant->codigo}/catalog-items/{$bundleId}")
             ->assertOk()
             ->assertJsonPath('data.type', CatalogItemType::Bundle->value)
-            ->assertJsonPath('data.availability.maximum_quantity', 4)
+            ->assertJsonPath('data.maximum_addable_quantity', 4)
             ->assertJsonMissingPath('data.stock_tecnico')
             ->assertJsonCount(1, 'data.components')
             ->assertJsonPath('data.components.0.catalog_item_id', $component->id)

tests/Feature/Catalog/CatalogControllerTest.php

@@ -41,7 +41,7 @@ class CatalogControllerTest extends TestCase
         $directItem = $this->createItem($tenant, 'Direct', $directInventory);
         $row->featuredItems()->create(['catalog_item_id' => $directItem->id]);
 
-        $variantItem = $this->createItem($tenant, 'Variants', withoutInventory: true);
+        $variantItem = $this->createItem($tenant, 'Variants');
         $firstInventory = Inventory::query()->create([
             'real_stock' => 5,
             'reserved_stock' => 1,
@@ -56,7 +56,7 @@ class CatalogControllerTest extends TestCase
         ]);
         $variantItem->variants()->create(['inventory_id' => $firstInventory->id]);
         $variantItem->variants()->create(['inventory_id' => $secondInventory->id]);
-        $variantItem->variants()->create([
+        $unavailableVariant = $variantItem->variants()->create([
             'inventory_id' => $unavailableInventory->id,
         ]);
         $cart->featuredItems()->create(['catalog_item_id' => $variantItem->id]);
@@ -72,16 +72,19 @@ class CatalogControllerTest extends TestCase
             ->assertJsonPath('0.items.0.nombre', 'Variants')
             ->assertJsonPath('0.items.0.descripcion', 'Variants description')
             ->assertJsonPath('0.items.0.precio', '100.00')
-            ->assertJsonPath('0.items.0.availability.state', 'visible')
+            ->assertJsonPath('0.items.0.maximum_addable_quantity', 7)
-            ->assertJsonPath('0.items.0.availability.maximum_quantity', 7)
             ->assertJsonCount(2, '0.items.0.variants')
-            ->assertJsonPath('0.items.0.variants.0.availability.maximum_quantity', 4)
+            ->assertJsonPath('0.items.0.variants.0.maximum_addable_quantity', 4)
-            ->assertJsonPath('0.items.0.variants.0.availability.state', 'visible')
+            ->assertJsonPath('0.items.0.variants.1.maximum_addable_quantity', 3)
-            ->assertJsonPath('0.items.0.variants.1.availability.maximum_quantity', 3)
             ->assertJsonPath('1.title', 'Row')
-            ->assertJsonPath('1.items.data.0.availability.maximum_quantity', 8)
+            ->assertJsonPath('1.items.data.0.maximum_addable_quantity', 8)
             ->assertJsonMissingPath('1.items.data.0.stock_tecnico')
             ->assertJsonCount(0, '1.items.data.0.variants');
+
+        $this->assertNotContains(
+            $unavailableVariant->id,
+            collect($response->json('0.items.0.variants'))->pluck('id')->all(),
+        );
     }
 
     public function test_maximum_addable_quantity_shares_the_authenticated_user_quota_between_variants(): void
@@ -94,7 +97,7 @@ class CatalogControllerTest extends TestCase
             groupLayout: GroupLayout::Simple,
         );
         $user = User::factory()->create();
-        $item = $this->createItem($tenant, 'Limited variants', withoutInventory: true);
+        $item = $this->createItem($tenant, 'Limited variants');
         $item->update(['max_units_per_user' => 3]);
         $firstVariant = $item->variants()->create([
             'inventory_id' => Inventory::query()->create(['real_stock' => 10])->id,
@@ -115,21 +118,21 @@ class CatalogControllerTest extends TestCase
         $this->actingAs($user, 'sanctum')
             ->getJson("/api/tenants/{$tenant->codigo}/catalog")
             ->assertOk()
-            ->assertJsonPath('0.items.0.availability.maximum_quantity', 0)
+            ->assertJsonPath('0.items.0.variants.0.maximum_addable_quantity', 0)
-            ->assertJsonPath('0.items.0.availability.allowed_actions', [])
+            ->assertJsonPath('0.items.0.variants.1.maximum_addable_quantity', 0)
             ->assertJsonPath(
-                '0.items.0.availability.reasons.0.message',
+                '0.items.0.variants.0.unavailable_message',
+                'Alcanzaste el cupo máximo permitido para este producto.',
+            )
+            ->assertJsonPath(
+                '0.items.0.variants.1.unavailable_message',
                 'Alcanzaste el cupo máximo permitido para este producto.',
             )
-            ->assertJsonPath('0.items.0.variants.0.availability.maximum_quantity', 8)
-            ->assertJsonPath('0.items.0.variants.1.availability.maximum_quantity', 9)
-            ->assertJsonCount(0, '0.items.0.variants.0.availability.reasons')
-            ->assertJsonCount(0, '0.items.0.variants.1.availability.reasons')
             ->assertJsonMissingPath('0.items.0.variants.0.stock_tecnico')
             ->assertJsonMissingPath('0.items.0.variants.1.stock_tecnico');
     }
 
-    public function test_it_hides_out_of_stock_items_before_building_the_group_response(): void
+    public function test_it_excludes_out_of_stock_items(): void
     {
         $tenant = $this->createTenant('catalog-available-variants');
         $group = $this->createGroup(
@@ -139,7 +142,7 @@ class CatalogControllerTest extends TestCase
             groupLayout: GroupLayout::SimpleVertical,
         );
 
-        $unavailableItem = $this->createItem($tenant, 'Unavailable', withoutInventory: true);
+        $unavailableItem = $this->createItem($tenant, 'Unavailable');
         $unavailableInventory = Inventory::query()->create([
             'real_stock' => 4,
             'reserved_stock' => 4,
@@ -147,7 +150,7 @@ class CatalogControllerTest extends TestCase
         $unavailableItem->variants()->create(['inventory_id' => $unavailableInventory->id]);
         $group->featuredItems()->create(['catalog_item_id' => $unavailableItem->id]);
 
-        $availableItem = $this->createItem($tenant, 'Available', withoutInventory: true);
+        $availableItem = $this->createItem($tenant, 'Available');
         $availableInventory = Inventory::query()->create([
             'real_stock' => 4,
             'reserved_stock' => 3,
@@ -159,7 +162,8 @@ class CatalogControllerTest extends TestCase
             ->assertOk()
             ->assertJsonCount(1, '0.items')
             ->assertJsonPath('0.items.0.nombre', 'Available')
-            ->assertJsonCount(0, '0.items.0.availability.reasons');
+            ->assertJsonPath('0.items.0.unavailable_message', null)
+            ->assertJsonMissing(['nombre' => 'Unavailable']);
     }
 
     public function test_column_with_image_uses_item_image_then_variant_image_then_null(): void
@@ -176,8 +180,8 @@ class CatalogControllerTest extends TestCase
             'order' => 0,
         ]);
 
-        $variantItem = $this->createItem($tenant, 'Variant image', withoutInventory: true);
+        $variantItem = $this->createItem($tenant, 'Variant image');
-        $variantInventory = Inventory::query()->create(['real_stock' => 1]);
+        $variantInventory = Inventory::query()->create();
         $variant = $variantItem->variants()->create(['inventory_id' => $variantInventory->id]);
         $variantImage = $this->createAttachment('variant');
         $variant->attachments()->attach($variantImage, ['orden' => 0]);
@@ -424,12 +428,7 @@ class CatalogControllerTest extends TestCase
         Tenant $tenant,
         string $name,
         ?Inventory $inventory = null,
-        bool $withoutInventory = false,
     ): CatalogItem {
-        $inventory ??= $withoutInventory
-            ? null
-            : Inventory::query()->create(['real_stock' => 10]);
-
         return CatalogItem::query()->create([
             'tenant_code' => $tenant->codigo,
             'inventory_id' => $inventory?->id,

tests/Feature/Catalog/CatalogItemDetailControllerTest.php

@@ -40,7 +40,7 @@ class CatalogItemDetailControllerTest extends TestCase
 
         $response
             ->assertOk()
-            ->assertJsonPath('data.availability.maximum_quantity', 7)
+            ->assertJsonPath('data.maximum_addable_quantity', 7)
             ->assertJsonMissingPath('data.stock_tecnico')
             ->assertJsonCount(0, 'data.variants')
             ->assertJsonCount(1, 'data.images');
@@ -48,18 +48,7 @@ class CatalogItemDetailControllerTest extends TestCase
         $this->assertStringContainsString($itemImage->path, $response->json('data.images.0'));
     }
 
-    public function test_it_does_not_return_an_out_of_stock_product_detail(): void
+    public function test_it_omits_unavailable_variants_and_selects_the_first_available_one(): void
-    {
-        $tenant = $this->createTenant('detail-hidden');
-        $inventory = Inventory::query()->create(['real_stock' => 0]);
-        $item = $this->createItem($tenant, 'Hidden item', $inventory);
-
-        $this->getJson(
-            "/api/tenants/{$tenant->codigo}/catalog-items/{$item->id}",
-        )->assertNotFound();
-    }
-
-    public function test_it_hides_unavailable_variants_and_selects_the_first_available_one(): void
     {
         Storage::fake('s3');
         $tenant = $this->createTenant('detail-default');
@@ -82,14 +71,17 @@ class CatalogItemDetailControllerTest extends TestCase
             ->assertOk()
             ->assertJsonCount(1, 'data.variants')
             ->assertJsonPath('data.variants.0.id', $secondVariant->id)
-            ->assertJsonPath('data.variants.0.availability.state', 'visible')
             ->assertJsonPath('data.selected_variant.id', $secondVariant->id)
-            ->assertJsonPath('data.selected_variant.availability.maximum_quantity', 6)
+            ->assertJsonPath('data.selected_variant.maximum_addable_quantity', 6)
             ->assertJsonMissingPath('data.selected_variant.stock_tecnico')
             ->assertJsonCount(1, 'data.selected_variant.images');
         $response
             ->assertJsonMissingPath('data.stock_tecnico')
             ->assertJsonMissingPath('data.images');
+        $this->assertNotContains(
+            $firstVariant->id,
+            collect($response->json('data.variants'))->pluck('id')->all(),
+        );
         $this->assertStringContainsString($secondImage->path, $response->json('data.selected_variant.images.0'));
         $this->assertStringNotContainsString($firstImage->path, $response->json('data.selected_variant.images.0'));
         $this->assertStringNotContainsString($itemImage->path, $response->json('data.selected_variant.images.0'));
@@ -99,6 +91,19 @@ class CatalogItemDetailControllerTest extends TestCase
         )->assertNotFound();
     }
 
+    public function test_it_does_not_return_an_out_of_stock_item(): void
+    {
+        $tenant = $this->createTenant('detail-out-of-stock');
+        $inventory = Inventory::query()->create([
+            'real_stock' => 5,
+            'reserved_stock' => 5,
+        ]);
+        $item = $this->createItem($tenant, 'Sold out item', $inventory);
+
+        $this->getJson("/api/tenants/{$tenant->codigo}/catalog-items/{$item->id}")
+            ->assertNotFound();
+    }
+
     public function test_it_selects_the_requested_variant_and_lists_variant_values_and_stock(): void
     {
         Storage::fake('s3');
@@ -139,11 +144,11 @@ class CatalogItemDetailControllerTest extends TestCase
         $response
             ->assertOk()
             ->assertJsonPath('data.variants.0.id', $firstVariant->id)
-            ->assertJsonPath('data.variants.0.availability.maximum_quantity', 4)
+            ->assertJsonPath('data.variants.0.maximum_addable_quantity', 4)
             ->assertJsonPath('data.variants.0.values.size.value', 'S')
             ->assertJsonPath('data.variants.0.values.size.label', 'Small')
             ->assertJsonPath('data.variants.1.id', $secondVariant->id)
-            ->assertJsonPath('data.variants.1.availability.maximum_quantity', 7)
+            ->assertJsonPath('data.variants.1.maximum_addable_quantity', 7)
             ->assertJsonPath('data.variants.1.values.size.value', 'M')
             ->assertJsonPath('data.variants.1.values.size.label', 'Medium')
             ->assertJsonPath('data.attributes.0.codigo', 'size')
@@ -151,7 +156,7 @@ class CatalogItemDetailControllerTest extends TestCase
             ->assertJsonPath('data.attributes.0.options.1.value', 'M')
             ->assertJsonCount(2, 'data.attributes.0.options')
             ->assertJsonPath('data.selected_variant.id', $secondVariant->id)
-            ->assertJsonPath('data.selected_variant.availability.maximum_quantity', 7)
+            ->assertJsonPath('data.selected_variant.maximum_addable_quantity', 7)
             ->assertJsonPath('data.selected_variant.values.size.value', 'M')
             ->assertJsonPath('data.selected_variant.values.size.label', 'Medium')
             ->assertJsonCount(1, 'data.selected_variant.images');
@@ -191,9 +196,9 @@ class CatalogItemDetailControllerTest extends TestCase
         $this->getJson("/api/tenants/{$tenant->codigo}/catalog-items/{$item->id}")
             ->assertOk()
             ->assertJsonPath('data.selected_variant.id', $variant->id)
-            ->assertJsonPath('data.selected_variant.availability.maximum_quantity', null)
+            ->assertJsonPath('data.selected_variant.maximum_addable_quantity', null)
             ->assertJsonMissingPath('data.stock_tecnico')
-            ->assertJsonPath('data.variants.0.availability.maximum_quantity', null)
+            ->assertJsonPath('data.variants.0.maximum_addable_quantity', null)
             ->assertJsonMissingPath('data.selected_variant.stock_tecnico')
             ->assertJsonMissingPath('data.variants.0.stock_tecnico');
     }
@@ -360,9 +365,6 @@ class CatalogItemDetailControllerTest extends TestCase
             ->assertJsonPath('data.resolved_variant', null)
             ->assertJsonCount(3, 'data.variants')
             ->assertJsonPath('data.variants.0.id', $first->id)
-            ->assertJsonPath('data.variants.0.availability.state', 'visible')
-            ->assertJsonPath('data.variants.0.availability.maximum_quantity', 1)
-            ->assertJsonPath('data.variants.0.availability.allowed_actions.2', 'add_to_cart')
             ->assertJsonPath('data.variants.0.values.sector.value', 'A')
             ->assertJsonPath('data.variants.0.values.seat.value', '1')
             ->assertJsonCount(2, 'data.selectors')
@@ -430,9 +432,7 @@ class CatalogItemDetailControllerTest extends TestCase
             ->assertOk()
             ->assertJsonPath('data.selected_values.sector', 'VIP')
             ->assertJsonPath('data.selected_values.seat', 'A-12')
-            ->assertJsonPath('data.resolved_variant.id', $variant->id)
+            ->assertJsonPath('data.resolved_variant.id', $variant->id);
-            ->assertJsonPath('data.resolved_variant.availability.state', 'hidden')
-            ->assertJsonMissingPath('data.resolved_variant.availability.allowed_actions');
     }
 
     private function createItem(

tests/Feature/Catalog/CatalogSearchTest.php

@@ -62,8 +62,24 @@ class CatalogSearchTest extends TestCase
             $this->createCatalogItem($tenant, "Running {$number}");
         }
         $exactMatch = $this->createCatalogItem($tenant, 'Running');
-        $outOfStockMatch = $this->createCatalogItem($tenant, 'Running unavailable');
+        $outOfStock = CatalogItem::query()->create([
-        $outOfStockMatch->inventory->update(['real_stock' => 0]);
+            'tenant_code' => $tenant->codigo,
+            'slug' => 'running-sold-out',
+            'nombre' => 'Running sold out',
+            'descripcion' => 'Running sold out description',
+            'precio' => 100,
+        ]);
+        $outOfStock->variants()->create([
+            'inventory_id' => Inventory::query()->create(['real_stock' => 0])->id,
+        ]);
+        CatalogItem::query()->create([
+            'tenant_code' => $tenant->codigo,
+            'inventory_id' => Inventory::query()->create(['real_stock' => 2, 'reserved_stock' => 2])->id,
+            'slug' => 'running-direct-sold-out',
+            'nombre' => 'Running direct sold out',
+            'descripcion' => 'Running direct sold out description',
+            'precio' => 100,
+        ]);
         $this->createCatalogItem($tenant, 'Unrelated');
         $this->createCatalogItem($otherTenant, 'Running foreign');
 
@@ -78,7 +94,8 @@ class CatalogSearchTest extends TestCase
             ->assertJsonPath('meta.total', 6)
             ->assertJsonCount(4, 'data')
             ->assertJsonPath('data.0.id', $exactMatch->id)
-            ->assertJsonMissing(['nombre' => 'Running unavailable'])
+            ->assertJsonMissing(['nombre' => 'Running sold out'])
+            ->assertJsonMissing(['nombre' => 'Running direct sold out'])
             ->assertJsonMissing(['nombre' => 'Running foreign'])
             ->assertJsonMissing(['nombre' => 'Unrelated']);
     }

tests/Feature/Catalog/CategoryDetailTest.php

@@ -29,6 +29,17 @@ class CategoryDetailTest extends TestCase
         $this->createCatalogItem($tenant, $category, 'Remera C');
         $firstItem = $this->createCatalogItem($tenant, $category, 'Remera A');
         $secondItem = $this->createCatalogItem($tenant, $category, 'Remera B');
+        $outOfStock = CatalogItem::query()->create([
+            'tenant_code' => $tenant->codigo,
+            'category_id' => $category->id,
+            'slug' => 'remera-agotada',
+            'nombre' => 'Remera agotada',
+            'descripcion' => 'Sin stock',
+            'precio' => 100,
+        ]);
+        $outOfStock->variants()->create([
+            'inventory_id' => Inventory::query()->create(['real_stock' => 0])->id,
+        ]);
         $this->createCatalogItem($tenant, $otherCategory, 'Pantalón');
 
         $this->getJson("/api/tenants/{$tenant->codigo}/categories/{$category->id}")
@@ -44,6 +55,7 @@ class CategoryDetailTest extends TestCase
             ->assertJsonCount(2, 'data')
             ->assertJsonPath('data.0.id', $firstItem->id)
             ->assertJsonPath('data.1.id', $secondItem->id)
+            ->assertJsonMissing(['nombre' => 'Remera agotada'])
             ->assertJsonMissing(['nombre' => 'Pantalón']);
     }
 

tests/Feature/Purchase/StorePurchaseTest.php

@@ -394,7 +394,7 @@ class StorePurchaseTest extends TestCase
             ->assertJsonPath('code', 'purchase.limit_exceeded')
             ->assertJsonPath('catalog_item_id', $variant->catalog_item_id)
             ->assertJsonPath('catalog_item_name', $variant->catalogItem->nombre)
-            ->assertJsonPath('availability.maximum_quantity', 1);
+            ->assertJsonPath('maximum_addable_quantity', 1);
 
         $this->actingAs($otherUser, 'sanctum')
             ->postJson('/api/tenants/sonder/compras/start-checkout', [

tests/Unit/Catalog/CatalogItemAllowanceServiceTest.php

@@ -2,73 +2,42 @@
 
 namespace Tests\Unit\Catalog;
 
-use App\Domains\Catalog\Services\AvailabilityPolicyResolver;
 use App\Domains\Catalog\Services\CatalogItemAllowanceService;
-use App\Domains\Purchase\Services\UserPurchaseLimitService;
+use ReflectionClass;
-use Mockery;
 use Tests\TestCase;
 
 class CatalogItemAllowanceServiceTest extends TestCase
 {
-    public function test_a_hidden_decision_only_exposes_its_state_and_reasons(): void
+    private CatalogItemAllowanceService $service;
-    {
-        $availability = $this->service()->availability(0, 0)->toArray();
 
-        $this->assertSame('hidden', $availability['state']);
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->service = (new ReflectionClass(CatalogItemAllowanceService::class))
+            ->newInstanceWithoutConstructor();
+    }
+
+    public function test_it_returns_the_user_quota_message_with_priority_over_stock(): void
+    {
         $this->assertSame(
-            ['user_quota_reached', 'out_of_stock'],
+            'Alcanzaste el cupo máximo permitido para este producto.',
-            array_column($availability['reasons'], 'code'),
+            $this->service->unavailableMessage(0, 0),
         );
-        $this->assertArrayNotHasKey('maximum_quantity', $availability);
-        $this->assertArrayNotHasKey('allowed_actions', $availability);
     }
 
-    public function test_an_available_decision_keeps_all_actions(): void
+    public function test_it_returns_the_out_of_stock_message(): void
     {
-        $availability = $this->service()->availability(5, 3)->toArray();
-
-        $this->assertSame('visible', $availability['state']);
-        $this->assertSame(3, $availability['maximum_quantity']);
-        $this->assertSame([], $availability['reasons']);
-        $this->assertSame([
-            'select_variant',
-            'change_quantity',
-            'add_to_cart',
-            'buy_now',
-        ], $availability['allowed_actions']);
-    }
-
-    public function test_reaching_the_user_quota_keeps_the_product_visible_without_actions(): void
-    {
-        $availability = $this->service()->availability(5, 0)->toArray();
-
-        $this->assertSame('visible', $availability['state']);
-        $this->assertSame([], $availability['allowed_actions']);
-        $this->assertSame('user_quota_reached', $availability['reasons'][0]['code']);
-    }
-
-    public function test_exceeding_the_remaining_quota_allows_the_quantity_to_be_corrected(): void
-    {
-        $availability = $this->service()
-            ->purchaseLimitExceededAvailability(1, 'Solo podés agregar una unidad.')
-            ->toArray();
-
-        $this->assertSame(1, $availability['maximum_quantity']);
         $this->assertSame(
-            'requested_quantity_exceeds_user_quota',
+            'Este producto no tiene stock disponible.',
-            $availability['reasons'][0]['code'],
+            $this->service->unavailableMessage(0, null),
         );
-        $this->assertSame([
-            'select_variant',
-            'change_quantity',
-        ], $availability['allowed_actions']);
     }
 
-    private function service(): CatalogItemAllowanceService
+    public function test_it_returns_no_message_when_the_item_is_available(): void
     {
-        return new CatalogItemAllowanceService(
+        $this->assertNull($this->service->unavailableMessage(1, null));
-            Mockery::mock(UserPurchaseLimitService::class),
+        $this->assertNull($this->service->unavailableMessage(null, 1));
-            new AvailabilityPolicyResolver,
+        $this->assertNull($this->service->unavailableMessage(null, null));
-        );
     }
 }