Feature: Moving Payment Methods to DB, adding fees, Transaction Updates, Refund Updates, General Updates to Payments

src/Checkout/Services/CheckoutService.php

@@ -19,7 +19,8 @@ use Modules\Core\Checkout\Exceptions\InvalidShippingOptionException;
 use Modules\Core\Checkout\Exceptions\UnknownPaymentTypeException;
 use Modules\Core\Payment\DTOs\PaymentResult;
 use Modules\Core\Payment\Models\PaymentMethod;
-use Modules\Core\Payment\Services\PaymentDriverResolver;
+use Modules\Core\Payment\Services\PaymentDriverRegistry;
+use Modules\Core\Payment\Services\PaymentMethodCache;
 
 /**
  * Storefront-facing checkout operations, mirroring
@@ -42,7 +43,8 @@ class CheckoutService
 {
     public function __construct(
         private readonly CartService $cart,
-        private readonly PaymentDriverResolver $paymentDrivers,
+        private readonly PaymentDriverRegistry $paymentDrivers,
+        private readonly PaymentMethodCache $paymentMethods,
     ) {}
 
     public function setShippingAddress(array|Addressable $address): Cart
@@ -100,25 +102,28 @@ class CheckoutService
     }
 
     /**
-     * Every payment type currently offered to the storefront — every key
-     * in config('lunar.payments.types') that is BOTH administratively
-     * enabled (Modules\Core\Payment\Models\PaymentMethod::enabled) AND
-     * whose registered driver reports itself usable right now
-     * (Configurable::isConfigured() — e.g. Stripe with no API key set is
-     * never offered, regardless of the enabled toggle). A type with no
-     * PaymentMethod row at all (never seeded) is treated as not offered,
-     * same as disabled — nothing here creates one; see
-     * InstallLunarCommand::seedPaymentMethods().
+     * Every payment method currently offered to the storefront, ordered by
+     * Modules\Core\Payment\Models\PaymentMethod::position — a row is
+     * offered only when ALL three checks pass, each meaning something
+     * different to an admin diagnosing why a method isn't showing up (see
+     * docs/payments.md):
+     *   1. `enabled` — an admin turned it on.
+     *   2. its `driver` still resolves via PaymentDriverRegistry — the
+     *      driver class hasn't been removed (see the `payment:sync-drivers`
+     *      command, which sets `driver_missing_at` when this fails; a row
+     *      with that set is excluded here regardless of `enabled`, so a
+     *      vanished driver can never silently look "available").
+     *   3. the resolved driver reports Configurable::isConfigured() — its
+     *      own runtime requirements (e.g. an API key) are met.
      *
-     * @return array<string>
+     * @return Collection<int, PaymentMethod>
      */
-    public function getPaymentMethods(): array
+    public function getPaymentMethods(): Collection
     {
-        return PaymentMethod::where('enabled', true)
-            ->pluck('type')
-            ->filter(fn (string $type) => $this->paymentDrivers->resolve($type)?->isConfigured() ?? false)
-            ->values()
-            ->all();
+        return $this->paymentMethods->all()
+            ->filter(fn (PaymentMethod $method) => $method->enabled && $method->driver_missing_at === null)
+            ->filter(fn (PaymentMethod $method) => $this->paymentDrivers->resolve($method->driver)?->isConfigured() ?? false)
+            ->values();
     }
 
     /**
@@ -142,12 +147,11 @@ class CheckoutService
      * as selecting a shipping option happens before placing the order.
      *
      * @throws UnknownPaymentTypeException if $type isn't currently offered
-     *   — see getPaymentMethods() for what that means (registered,
-     *   administratively enabled, and its driver reports itself usable)
+     *   — see getPaymentMethods() for what that means
      */
     public function selectPaymentMethod(string $type): Cart
     {
-        if (! in_array($type, $this->getPaymentMethods(), true)) {
+        if (! $this->getPaymentMethods()->contains('type', $type)) {
             throw new UnknownPaymentTypeException($type);
         }
 
@@ -170,11 +174,9 @@ class CheckoutService
      * Order exists (Cart::createOrder() — confirmed idempotent against a
      * cart's own pre-existing, not-yet-placed-at draft; see
      * vendor/lunarphp/core/src/Actions/Carts/CreateOrder.php), then
-     * resolves the payment type selected by selectPaymentMethod() and
-     * calls pay() or authorize() on its driver, per that type's
-     * config('lunar.payments.types.{type}.capture_mode') — boboko-core's
-     * own types (config/payment.php) are merged into that same Lunar
-     * config key by PaymentServiceProvider::boot().
+     * resolves the payment method selected by selectPaymentMethod() and
+     * calls pay() or authorize() on its driver, per that method's own
+     * `capture_mode` column.
      *
      * Returns the driver's own PaymentResult UNCHANGED — this method does
      * not wait for or resolve anything past what pay()/authorize() itself
@@ -183,14 +185,6 @@ class CheckoutService
      * outcome, not an error — the caller (a storefront controller) is
      * responsible for whatever the gateway needs next.
      *
-     * KNOWN GAP, explicitly out of scope for now: PaymentResult alone does
-     * not carry gateway-specific continuation data (e.g. Stripe's
-     * PaymentIntent client_secret for a Pending result needing frontend
-     * confirmation) — that concept existed on the deleted PaymentInitiation
-     * DTO and was intentionally removed from Payment's abstraction layer.
-     * Nothing here re-introduces it; only OfflinePaymentDriver's
-     * always-Immediate-Succeeded path is fully wired end-to-end today.
-     *
      * The draft order's own $order->total (not the Cart's) is what gets
      * passed as $amount — Order::$total is Lunar's own Price-cast
      * attribute, already resolving the correct Currency via the order's
@@ -210,8 +204,8 @@ class CheckoutService
      *
      * @throws UnknownPaymentTypeException if the cart's selected
      *   payment_method (from selectPaymentMethod()) is no longer offered
-     *   — re-checked here, not just at selection time, since a type could
-     *   be disabled in between
+     *   — re-checked here, not just at selection time, since a method
+     *   could be disabled (or its driver removed) in between
      * @throws FingerprintMismatchException
      * @throws CartException
      */
@@ -221,19 +215,18 @@ class CheckoutService
         $cart->checkFingerprint($fingerprint);
 
         $type = $cart->meta['payment_method'] ?? null;
+        $method = $type !== null ? $this->getPaymentMethods()->firstWhere('type', $type) : null;
 
-        if ($type === null || ! in_array($type, $this->getPaymentMethods(), true)) {
+        if ($method === null) {
             throw new UnknownPaymentTypeException((string) $type);
         }
 
         $order = $cart->createOrder();
 
-        $driver = $this->paymentDrivers->resolve($type);
-        $captureMode = config("lunar.payments.types.{$type}.capture_mode", 'pay');
-
+        $driver = $this->paymentDrivers->resolve($method->driver);
         $context = ['cart_id' => $cart->id, 'order_id' => $order->id];
 
-        return $captureMode === 'authorize'
+        return $method->capture_mode === 'authorize'
             ? $driver->authorize($type, $order->total, $data, $context)
             : $driver->pay($type, $order->total, $data, $context);
     }