feat(catalog): model availability as global decisions

app/Domains/Catalog/Services/CatalogItemAllowanceService.php

@@ -2,10 +2,10 @@
 
 namespace App\Domains\Catalog\Services;
 
-use App\Domains\Catalog\Enums\AvailabilitySubject;
+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\Database\Eloquent\Builder;
 use Illuminate\Support\Collection;
 
 class CatalogItemAllowanceService
@@ -16,6 +16,7 @@ class CatalogItemAllowanceService
 
     public function __construct(
         private readonly UserPurchaseLimitService $purchaseLimits,
+        private readonly AvailabilityPolicyResolver $policies,
     ) {}
 
     /** @param Collection<int, CatalogItem> $catalogItems */
@@ -44,102 +45,82 @@ class CatalogItemAllowanceService
         return min($availableStock, $remainingUserQuota);
     }
 
-    /** @param Builder<CatalogItem> $query */
-    public function applyProductVisibilityPolicy(Builder $query): Builder
-    {
-        return $this->isVisible(
-            0,
-            null,
-            AvailabilitySubject::Product,
-        )
-            ? $query
-            : $query->whereAvailableInCatalog();
-    }
-
-    public function isVisible(
-        ?int $availableStock,
-        ?int $remainingUserQuota,
-        AvailabilitySubject $subject,
-    ): bool {
-        return $this->availability(
-            $availableStock,
-            $remainingUserQuota,
-            $subject,
-        )['capabilities']['display'];
-    }
-
-    /**
-     * @return array{
-     *     subject: string,
-     *     maximum_quantity: int|null,
-     *     restrictions: list<array{code: string, message: string}>,
-     *     capabilities: array{display: bool, select_variant: bool, change_quantity: bool, add_to_cart: bool, buy_now: bool}
-     * }
-     */
     public function availability(
         ?int $availableStock,
         ?int $remainingUserQuota,
-        AvailabilitySubject $subject = AvailabilitySubject::Product,
-    ): array {
-        $restrictions = [];
+    ): AvailabilityDecision {
+        $reasons = [];
 
         if ($remainingUserQuota !== null && $remainingUserQuota <= 0) {
-            $restrictions[] = [
+            $reasons[] = [
                 'code' => 'user_quota_reached',
                 'message' => self::USER_QUOTA_REACHED_MESSAGE,
             ];
         }
 
         if ($availableStock !== null && $availableStock <= 0) {
-            $restrictions[] = [
+            $reasons[] = [
                 'code' => 'out_of_stock',
                 'message' => self::OUT_OF_STOCK_MESSAGE,
             ];
         }
 
-        $capabilities = [
-            'display' => true,
-            'select_variant' => true,
-            'change_quantity' => true,
-            'add_to_cart' => true,
-            'buy_now' => true,
-        ];
-
-        foreach ($restrictions as $restriction) {
-            /** @var array<string, bool> $policy */
-            $policy = config(
-                "catalog.availability_policies.{$restriction['code']}.{$subject->value}",
-                [],
-            );
-
-            foreach ($capabilities as $capability => $allowed) {
-                $capabilities[$capability] = $allowed && ($policy[$capability] ?? true);
-            }
-        }
-
-        return [
-            'subject' => $subject->value,
-            'maximum_quantity' => $this->maximumAddableQuantity(
-                $availableStock,
-                $remainingUserQuota,
-            ),
-            'restrictions' => $restrictions,
-            'capabilities' => $capabilities,
-        ];
+        return $this->decision(
+            $this->maximumAddableQuantity($availableStock, $remainingUserQuota),
+            $reasons,
+        );
     }
 
-    /** @return array<string, mixed> */
-    public function purchaseLimitExceededAvailability(int $maximumQuantity, string $message): array
-    {
-        $availability = $this->availability(null, $maximumQuantity);
+    public function purchaseLimitExceededAvailability(
+        int $maximumQuantity,
+        string $message,
+    ): AvailabilityDecision {
+        $reasons = [];
 
-        if ($maximumQuantity > 0) {
-            $availability['restrictions'][] = [
+        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 $availability;
+        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,
+        );
     }
 }