Bump version to 0.13.1

Feat: Recording Payment Transactions
Bump version to 0.13.0
2026-09-03 18:28:22 +03:00 · 2026-09-03 18:26:48 +03:00 · 2026-09-03 17:44:22 +03:00 · 2026-09-03 17:42:30 +03:00 · 2026-09-03 17:31:39 +03:00 · 2026-09-03 17:27:34 +03:00
58 changed files with 1983 additions and 320 deletions
@@ -4,6 +4,46 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 ## [0.13.0] - 2026-09-03
 ### Changed
 - **Breaking:** `Payment` is now a genuinely standalone module — no direct calls into `Checkout`/`Order`, no reaching into their Eloquent models, communication only via events. The entire old `confirm()`-based flow is gone: `Modules\Core\Payment\Contracts\PaymentDriver` (and the already-stale `Modules\Core\Checkout\Contracts\PaymentDriver` duplicate), `Checkout\Events\PaymentConfirmed`, `Payment\Contracts\InitiatesPayment`, `Payment\DataTransferObjects\PaymentInitiation`, `Payment\Enums\PaymentInitiationMode`, `Payment\Events\PaymentSucceeded`/`PaymentFailed`, `Payment\Events\OrderPaymentStatusResolved`, and `Payment\Exceptions\PaymentNotConfirmedException` are all deleted. This flow was non-functional on `master` before this release — `CheckoutService::confirmPayment()` dispatched an event nothing listened for, so no order was ever placed after payment.
 - **Breaking:** Every payment operation is now its own explicit, opt-in contract, modeled on how real gateways (Stripe, Mastercard's own gateway, Nexi) actually split these operations — see `docs/payments.md`: `Modules\Core\Payment\Contracts\SupportsPay` (atomic authorize+capture), `SupportsAuthorization` (hold only), `SupportsCaptures` (settle a prior hold), `SupportsVoids` (release a prior hold without settling), `SupportsRefunds` (reverse settled funds), `HandlesPaymentCallback` (resolve an async pay()/authorize() later, from a webhook), and `Configurable` (`isConfigured()`, split out of the old single `PaymentDriver` interface). A driver implements only the operations its gateway actually supports.
 - **Breaking:** Every amount flowing through these contracts is `Lunar\DataTypes\Price` (Lunar's own bundled minor-unit-value + `Currency` type) — never a bare `int` paired separately with a `Currency`. Each driver converts at its own boundary (e.g. `StripeManager::toStripeAmount()`/`fromStripeAmount()`); `Payment` itself only ever speaks Lunar's `Price`.
 - **Breaking:** `Modules\Core\Checkout\Services\CheckoutService::placeOrder()` and `confirmPayment()` are both replaced by a single `initiatePayment(string $fingerprint, array $data = []): Modules\Core\Payment\DTOs\PaymentResult`. It creates the draft `Order` (`Cart::createOrder()`, idempotent against an existing draft) and hands off directly to the resolved driver's `pay()`/`authorize()`, per that type's new `config('lunar.payments.types.{type}.capture_mode')` key. `Checkout\Events\OrderPlaced` no longer dispatches from `CheckoutService` — it now fires from `Modules\Core\Order\Listeners\ApplyResolvedPaymentStatus` once a `PaymentCaptured`/`PaymentAuthorized` event actually transitions the order's `placed_at`, since a draft order can now exist well before payment resolves (an async gateway).
 - `Modules\Core\Payment\Services\PaymentDriverResolver::resolve()` now returns `?object` instead of the deleted `PaymentDriver` interface — a driver implements several independent capability interfaces at once, so a caller does its own `instanceof SupportsPay`/`instanceof SupportsAuthorization` check, the same pattern the capability interfaces themselves are designed around.
 - `config/payment.php`'s `cash-on-delivery` entry gains `capture_mode` (`'pay'`, since `OfflinePaymentDriver` only implements `SupportsPay`) and `captured_status` (`'payment-offline'`, replacing the previously dead `'authorized' => 'awaiting-payment'` key, which nothing ever read).
 ### Added
 - `Modules\Core\Payment\DTOs\PaymentResult` — the one return shape every operation (`pay`, `authorize`, `capture`, `void`, `refund`, `handleCallback`) produces, regardless of gateway: `status` (`Modules\Core\Payment\Enums\PaymentResultStatus`: `Succeeded`/`Failed`/`Pending`), `reference`, `amount` (a `Price`), `failureReason`, `retriable` (real on Stripe/Mastercard's own soft-decline classification, always `false` on Nexi — it has no such signal), `raw` (the untouched gateway response, for audit), `meta`, and `continuation` (see below).
 - `Modules\Core\Payment\DTOs\PaymentContinuation` / `Modules\Core\Payment\Enums\PaymentContinuationType` — what a caller does next with a `Pending` `PaymentResult`, gateway-agnostically (`Redirect` or `ClientSecret`), so a storefront controller never needs gateway-specific knowledge of e.g. Stripe's own `PaymentIntent` fields to drive a 3-D Secure/redirect continuation.
 - Eight new events, one terminal pair per operation, replacing the old single `PaymentSucceeded`/`PaymentFailed`: `PaymentAuthorized`/`PaymentAuthorizationFailed`, `PaymentCaptured`/`PaymentCaptureFailed`, `PaymentVoided`/`PaymentVoidFailed`, `PaymentRefunded`/`PaymentRefundFailed`. `PaymentCaptured` is deliberately the same event whether money was taken via `pay()` (one gateway call) or `authorize()`→`capture()` (two calls) — "a payment has been captured" is the same business fact either way. Every event carries `{type, result: PaymentResult, context}` — `context` is an opaque bag the caller hands in and gets back untouched, so `Payment` never needs to know what a `Cart` or `Order` is.
 - `Modules\Core\Order\Listeners\ApplyResolvedPaymentStatus` (rewired, not new — previously listened to the now-deleted `OrderPaymentStatusResolved`) is the only place an `Order`'s `status` column is written in reaction to a payment outcome: it listens to `PaymentCaptured`/`PaymentAuthorized` directly, reads `$event->context['order_id']`, and resolves the new status from `config('lunar.payments.types.{type}.captured_status')`/`authorized_status`.
 - `Modules\Core\Payment\Drivers\StripePaymentDriver` rewritten onto the new contracts — implements all six capability interfaces plus `Configurable`. Solves `handleCallback()`'s async-correlation problem (a webhook is a separate HTTP request from the `pay()`/`authorize()` call that started it) the same way `lunarphp/stripe`'s own `StripePaymentType`/`ProcessStripeWebhook` do: real `cart_id`/`order_id` columns on `Lunar\Stripe\Models\StripePaymentIntent`, plus two new columns this driver needs (`context`, `payment_type`) added by a new migration — `database/migrations/2026_09_03_000002_add_context_to_stripe_payment_intents.php`.
 - `Modules\Core\Payment\Http\Controllers\StripeWebhookController` + `src/Payment/routes/webhooks.php` (`POST /payments/stripe/webhook`, loaded by `PaymentServiceProvider`) — a boboko-owned webhook endpoint, deliberately not `lunarphp/stripe`'s own route (which dispatches into Lunar's own `Payments::driver('stripe')` flow, the flow this driver replaces). Reuses `Lunar\Stripe\Http\Middleware\StripeWebhookMiddleware` and `Stripe\Webhook::constructEvent()` directly — both are genuine Stripe SDK signature verification, safe to reuse without touching the rest of that vendor package's flow. Requires `config('services.stripe.webhooks.lunar')` set in a consuming app; no `stripe` config type entry is added to `config/payment.php` in this release — enabling Stripe for real is a follow-up.
 - `docs/payments.md` — full design notes: the operation/contract table cross-referenced against Mastercard/Stripe/Nexi's real APIs, why `PaymentResult` normalizes only what every gateway can always provide, the async-correlation pattern, and what's explicitly out of scope (a `Transaction`-writing listener, the `stripe` config entry, frontend Stripe Elements integration).
 ### Fixed
 - `Modules\Core\Checkout\Services\CheckoutService::selectPaymentMethod()` crashed (`Call to a member function toArray() on null`) the first time it ran against a cart whose `meta` column was still a genuine SQL `NULL` (any freshly-created cart) — `Cart::$meta`'s `AsArrayObject` cast returns `null`, not an empty array-like object, for a `null` column. Fixed with a null-safe fallback.
 - `Modules\Core\Shipping\Carriers\Acs\AcsRateDriver`/`BoxNowRateDriver` referenced `Lunar\Shipping\DTOs\ShippingOptionRequest`, a namespace that doesn't exist in the installed `lunarphp/table-rate-shipping` version (the real class is `Lunar\Shipping\DataTransferObjects\ShippingOptionRequest`) — crashed `Illuminate\Support\Manager`'s interface-compatibility check the moment anything touched `ShippingManager::getSupportedDrivers()`, including simply adding a line to a cart (via `Modules\Core\Shipping\Listeners\FlushLivePricingCache`).
 ## [0.13.1] - 2026-09-03
 ### Added
 - `Modules\Core\Order\Listeners\RecordPaymentTransaction` — writes the `lunar_transactions` row for a successful `PaymentCaptured`/`PaymentAuthorized`/`PaymentVoided`/`PaymentRefunded` event, via a new `Modules\Core\Order\Services\TransactionRecorder` (moved here from `Payment\Services`, and rewritten to take a `PaymentResult` directly instead of the deleted `CaptureResult`/`RefundResult` DTOs — `Payment` never writes to `Order`'s models, `Transaction.order_id` being required is exactly why this lives in `Order`, same reasoning as `ApplyResolvedPaymentStatus`). Closes a real gap introduced in `0.13.0`: `Order::paymentStatus()` (which derives its answer entirely from `$order->transactions`) always resolved to `PaymentStatus::Offline` — its "no transactions at all" fallback — regardless of what actually happened, since nothing had ever written a row. Verified live: a captured offline payment now produces a `type: capture` transaction and `Order::paymentStatus()` correctly resolves to `captured`.
 ## [0.12.1] - 2026-09-03
 ### Fixed
 - `Modules\Core\MigrateImport\Shopify\ShopifyExportImporter` now attaches a variant's `Variant Image` CSV column to that `ProductVariant`'s own `images()` media pivot (`media_product_variant`, `primary`/`position`). Previously the variant image was never read at all — every image from the CSV, including ones the export clearly scopes to one specific variant, went only into the product's own top-level gallery, so a variant swatch/option change had no way to show its own photo.
 - `Modules\Core\MigrateImport\Shopify\Resolvers\ProductOptionResolver::resolveOption()` now sets `label` (same value as `name`) when creating a `Lunar\Models\ProductOption`, not just `name`. A `ProductOption` with a null `label` crashes Lunar's own `ProductOptionIndexer::toSearchableArray()` (`foreach()` on `null`) the moment that option gets reindexed — every option created by the importer before this fix has a null `label` and needs a wipe-and-reimport (see `docs/shopify-reimport.md`, new in this release) to pick up the fix, since `firstOrCreate()` never revisits an already-existing row.
 - `product_reviews.product_id`'s foreign key had no `ON DELETE` clause, so deleting a reviewed `Product` threw a constraint violation instead of the review going with it, unlike every other product-dependent table. New migration adds `cascadeOnDelete()`.
 ### Added
 - `Modules\Core\Catalog\Services\ProductIndexer::mapVariant()` now embeds `gtin`, `mpn`, `ean`, `backorder`, `unit_quantity`, `shippable`, `tax_ref`, and `dimensions` (length/width/height/weight/volume, each with `value`+`unit`) on every indexed variant — previously only `id`/`sku`/`stock`/`purchasable`/`options`/`prices`/`media` were embedded, so a search result or filter needing any of these had no way to get at them without a separate Postgres query per variant.
 - `ProductIndexer::toSearchableArray()` adds a top-level, filterable `skus` field (every variant's SKU, deduplicated) — filtering/matching by SKU no longer requires reaching into the nested `variants` array.
 - `docs/shopify-reimport.md` — runbook for wiping every imported product (cascading through Lunar so Meilisearch documents go too) and re-running the importer from scratch, needed whenever a fix like the two above only takes effect on newly-created rows.
 ## [0.12.0] - 2026-09-03
 ### Changed
@@ -2,7 +2,7 @@
  "name": "boboko/core",
  "description": "Core module — authentication and shared panel behaviour",
  "type": "library",
-  "version": "0.12.0",
+  "version": "0.13.1",
  "autoload": {
    "psr-4": {
      "Modules\\Core\\": "src/"
@@ -14,18 +14,20 @@ return [
    | Lunar's own config.
    |
    | 'payment_driver' is boboko-owned, alongside Lunar's own 'driver' key —
-    | it's the Modules\Core\Checkout\Contracts\PaymentDriver class
+    | the driver instance Modules\Core\Payment\Services\PaymentDriverResolver
-    | CheckoutService::confirmPayment() resolves via the container and calls
+    | resolves via the container. 'capture_mode' ('pay' or 'authorize') is
-    | confirm() on. Kept on the same row as 'driver' rather than a second,
+    | also boboko-owned — which contract method
-    | separately-keyed map, so a type's full definition — Lunar's driver,
+    | CheckoutService::initiatePayment() calls for this type. Kept on the
-    | its config, and its PaymentDriver — lives in one place.
+    | same row as 'driver' rather than a second, separately-keyed map, so a
    | type's full definition lives in one place.
    |
    */
    'types' => [
        'cash-on-delivery' => [
            'driver' => 'offline',
            'payment_driver' => OfflinePaymentDriver::class,
-            'authorized' => 'awaiting-payment',
+            'capture_mode' => 'pay',
            'captured_status' => 'payment-offline',
            'fee' => 0,
        ],
    ],
@@ -0,0 +1,43 @@
 <?php
 use Illuminate\Database\Migrations\Migration;
 use Illuminate\Database\Schema\Blueprint;
 use Illuminate\Support\Facades\Schema;
 /**
 * product_reviews.product_id's original foreign key (2026_07_10_000001) had
 * no ON DELETE clause, so deleting a Product with reviews throws a
 * constraint violation instead of the review rows going with it — unlike
 * every other Product-dependent table (variants, media, etc.), which does
 * cascade. A review is dependent, disposable data, not something worth
 * blocking a product deletion over.
 */
 return new class extends Migration
 {
    public function up(): void
    {
        Schema::table('product_reviews', function (Blueprint $table) {
            $table->dropForeign(['product_id']);
        });
        Schema::table('product_reviews', function (Blueprint $table) {
            $table->foreign('product_id')
                ->references('id')
                ->on(config('lunar.database.table_prefix').'products')
                ->cascadeOnDelete();
        });
    }
    public function down(): void
    {
        Schema::table('product_reviews', function (Blueprint $table) {
            $table->dropForeign(['product_id']);
        });
        Schema::table('product_reviews', function (Blueprint $table) {
            $table->foreign('product_id')
                ->references('id')
                ->on(config('lunar.database.table_prefix').'products');
        });
    }
 };
@@ -0,0 +1,47 @@
 <?php
 use Illuminate\Database\Schema\Blueprint;
 use Illuminate\Support\Facades\Schema;
 use Lunar\Base\Migration;
 /**
 * lunarphp/stripe's own stripe_payment_intents table already correlates a
 * Stripe intent back to a cart/order via cart_id/order_id — exactly what
 * Modules\Core\Payment\Drivers\StripePaymentDriver needs to recover
 * $context in handleCallback(), a separate request (a webhook) from the
 * pay()/authorize() call that originated it. Two columns this driver
 * needs that the vendor table doesn't have:
 *   - context: the full opaque $context bag pay()/authorize() received,
 *     stored so handleCallback() can dispatch the SAME context the
 *     original call would have, without Payment inventing its own
 *     correlation table — see docs/payments.md "Async resolution".
 *   - payment_type: the payment type key (e.g. 'stripe') pay()/authorize()
 *     were called with — needed to dispatch Payment events with the
 *     correct $type in handleCallback(), which otherwise has no way to
 *     know it (a webhook payload doesn't carry it).
 *
 * Extends Lunar\Base\Migration (not the plain base Migration) so $this->prefix
 * resolves the SAME table-prefix config every Lunar-owned table uses
 * (config('lunar.database.table_prefix')) — the vendor migration that
 * creates this table (lunarphp/stripe's create_stripe_payment_intents_table)
 * already does this, so a store running with a non-default prefix (this
 * one runs with 'lunar_') would otherwise have this migration fail against
 * a table name that doesn't exist.
 */
 return new class extends Migration
 {
    public function up(): void
    {
        Schema::table($this->prefix.'stripe_payment_intents', function (Blueprint $table) {
            $table->json('context')->nullable()->after('status');
            $table->string('payment_type')->nullable()->after('context');
        });
    }
    public function down(): void
    {
        Schema::table($this->prefix.'stripe_payment_intents', function (Blueprint $table) {
            $table->dropColumn(['context', 'payment_type']);
        });
    }
 };
@@ -0,0 +1,189 @@
 # Payment — Design Notes
 **Status: abstraction layer built, drivers/wiring in progress.** `Payment` is designed as a
 standalone module: it never calls into `Checkout` or `Order`, never touches their Eloquent
 models, and communicates only via events. This document is the design spec for that
 abstraction — contracts, DTOs, events — independent of how `Checkout`/`Order` end up consuming
 it (that wiring is a separate, later pass).
 ---
 ## Operations, not gateways
 The driver contracts model the actual operations a payment gateway can perform, not vendor
 terminology. Every real gateway checked while designing this converges on the same small set
 under different names:
 | Operation | Mastercard | Stripe | Nexi |
 |---|---|---|---|
 | Atomic charge (authorize+capture in one call) | `Pay` | `capture_method: automatic` | `ActionType::PAY()` |
 | Hold only, settle/release later | `Authorize` | `capture_method: manual` | `ActionType::PREAUTH()` |
 | Settle a prior hold | `Capture` | `PaymentIntent::capture()` | `CaptureRequest`/`CaptureResponse` |
 | Release a prior hold without settling | `Void`/`Cancel` | `PaymentIntent::cancel()` | `CancelRequest`/`CancelResponse` |
 | Reverse settled funds | `Refund` | `Refund::create()` | (refund endpoint) |
 A driver implements only the interfaces its gateway actually supports:
 - An offline/cash type (`cash-on-delivery`, `cash-in-hand`) only ever settles atomically —
  implements `SupportsPay` alone.
 - A card gateway capable of either mode per-transaction (Stripe, most card processors)
  implements `SupportsPay`, `SupportsAuthorization`, `SupportsCaptures`, `SupportsVoids`, and
  `SupportsRefunds` all at once — which one gets *called* for a given attempt is the caller's
  policy choice (e.g. `config('lunar.stripe.policy')`), not something baked into the driver's
  shape.
 - A redirect/wallet gateway with no separate hold step (Viva/Klarna in typical flows)
  implements `SupportsPay` and `SupportsRefunds`, never `SupportsCaptures`/`SupportsVoids`.
 ### `pay()` and `authorize()` stay separate methods even when a gateway implements both as "the same call with a flag"
 Stripe has no separate `authorize`/`pay` API endpoints — one `PaymentIntent`, confirmed with
 either `capture_method: automatic` or `manual`. Mastercard and Nexi *do* have genuinely
 separate operations. The contract abstracts over both shapes uniformly: every driver capable
 of both exposes two distinct methods, `pay()` and `authorize()`. A Mastercard-style driver
 calls two different endpoints under the hood; a Stripe-style driver calls the same endpoint
 twice with a different flag each time. Neither difference is visible to a caller.
 ### `capture()`/`void()` are only ever valid against a prior `authorize()`
 They are not standalone operations — `capture()` settles a specific hold identified by the
 `reference` `authorize()` returned; `void()` releases that same hold instead. A driver that
 never implements `SupportsAuthorization` never produces a reference either of these methods
 could act on.
 ---
 ## `PaymentResult` — the one return shape, every operation, every driver
 ```php
 enum PaymentResultStatus { case Succeeded; case Failed; case Pending; }
 final class PaymentResult {
    public function __construct(
        public readonly PaymentResultStatus $status,
        public readonly string $reference,
        public readonly int $amount,
        public readonly ?string $failureReason = null,
        public readonly bool $retriable = false,
        public readonly array $raw = [],
        public readonly array $meta = [],
    ) {}
 }
 ```
 Real gateway responses vary wildly in richness — confirmed by reading three SDKs directly:
 - **Stripe's `PaymentIntent`** is rich: `status`, `amount`, `amount_capturable`,
  `amount_received`, `last_payment_error`, a full `getLastResponse()`.
 - **Nexi's `CaptureResponse`/`CancelResponse`** are minimal: just `operationId` +
  `operationTime` — no echoed amount or status at all. Success is inferred from getting a
  response rather than an SDK exception.
 - **Mastercard's** gateway sits in between, with `gatewayCode`/`acquirerCode`/
  `merchantAdviceCode`.
 `PaymentResult` only requires what every driver can always know: `status`, `reference`,
 `amount` (the amount **we** requested — not necessarily echoed back by a sparse gateway like
 Nexi's capture). Everything else is best-effort: `failureReason`/`retriable` are normalized
 only when the gateway has something to normalize from; `raw` is the unconditional escape
 hatch — the untouched gateway response body, always populated, for genuine audit fidelity
 regardless of how sparse the normalized fields ended up.
 ### `retriable` — real on some gateways, absent on others
 Stripe classifies declines as soft (`do_not_honor`, `insufficient_funds` — worth retrying,
 after a delay) vs. hard (`stolen_card`, `expired_card` — never retry the same method).
 Mastercard has the equivalent via `authorizationResponse.merchantAdviceCode` and card-scheme
 soft-decline codes. **Nexi has no such signal at all** — `OperationResult` is just
 `DECLINED`/`DENIED_BY_RISK`/`FAILED`/etc. with no retriability classification. `retriable`
 therefore defaults to `false` (assume not safely retriable) rather than guessing when a
 driver's gateway has nothing to base it on.
 ---
 ## Events — one terminal pair per operation, keyed to the business fact, not the call path
 `Modules\Core\Payment\Events`:
 | Event pair | Dispatched by |
 |---|---|
 | `PaymentAuthorized` / `PaymentAuthorizationFailed` | `SupportsAuthorization::authorize()`, or a later `HandlesPaymentCallback::handleCallback()` resolving it |
 | `PaymentCaptured` / `PaymentCaptureFailed` | `SupportsPay::pay()` **or** `SupportsCaptures::capture()` |
 | `PaymentVoided` / `PaymentVoidFailed` | `SupportsVoids::void()` |
 | `PaymentRefunded` / `PaymentRefundFailed` | `SupportsRefunds::refund()` |
 `PaymentCaptured` is deliberately the *same* event whether money was taken via `pay()` (one
 gateway call) or `authorize()` → `capture()` (two calls) — "a payment has been captured" is
 the same business fact either way, and a listener reacting to it never needs to know which
 path produced it. There is no separate "payment succeeded" wrapper event distinct from
 `PaymentCaptured`.
 Every event carries `{type: string, result: PaymentResult, context: array}`. `Payment` has no
 concept of a `Cart`, an `Order`, or a checkout fingerprint — `$context` is an opaque bag the
 caller hands in on the way down (`pay($type, $data, $context)`) and gets back untouched on
 whichever event that call (or a later `handleCallback()`) produces. Each listener interprets
 `$context` on its own terms, or ignores the event if the keys it needs aren't present —
 `Checkout` is only one possible consumer of these events, not the only one.
 ---
 ## Async resolution — `HandlesPaymentCallback`
 Only implemented by a driver whose `pay()`/`authorize()` can return `PaymentResultStatus::Pending`
 — a redirect the shopper completes elsewhere, a webhook that arrives later. A driver whose
 gateway always resolves synchronously never implements this.
 ```php
 public function handleCallback(string $reference, array $data, array $context = []): PaymentResult;
 ```
 Resolves into the *same* event pair the original `pay()`/`authorize()` call would have
 produced had it resolved synchronously.
 ### The correlation problem: `handleCallback()` runs in a different request
 `$context` passed into the original `pay()`/`authorize()` call does not survive to
 `handleCallback()` on its own — that call is typically a separate HTTP request (a webhook)
 with no memory of the request that started the payment. Something has to persist enough to
 answer "which order/cart does gateway reference X belong to?" between the two calls.
 **Read directly from `lunarphp/stripe`'s own source** (`StripePaymentType::authorize()`,
 `ProcessStripeWebhook`, `WebhookController`) to see how Lunar itself solves this — confirmed
 it does **not** stash a generic opaque blob. It writes the correlating ids as real, typed
 columns on `Lunar\Stripe\Models\StripePaymentIntent` (`cart_id`, `order_id`) at the moment the
 intent is created/first seen, then reads them back the same way when the webhook arrives:
 ```php
 // ProcessStripeWebhook::handle() — falls back through two real lookups,
 // neither of them a generic context blob:
 $cart = StripePaymentIntent::where('intent_id', $this->paymentIntentId)->first()?->cart
    ?: Cart::where('meta->payment_intent', '=', $this->paymentIntentId)->first();
 ```
 **`StripePaymentDriver` follows this exact precedent**: it reads `cart_id`/`order_id` out of
 `$context` at `pay()`/`authorize()` time and writes them onto its own `StripePaymentIntent`
 row (a table already owned by `lunarphp/stripe`, already shaped for exactly this), then reads
 them back the same way in `handleCallback()`. No generic `context` json column, no new table.
 ### This pattern is per-driver, not a shared table
 `stripe_payment_intents` is Stripe-specific — keyed on `intent_id`, typed around
 `Stripe\PaymentIntent`'s own status values. It cannot be reused as-is for a future non-Stripe
 async driver (Nexi, Viva): that driver's own gateway reference has a different shape entirely,
 and shoehorning it into Stripe-named columns would make the table misleading. The **pattern**
 generalizes — *any* driver needing async callback resolution owns a small table keyed by its
 own gateway's reference, storing whatever correlation data that driver specifically needs —
 but each driver gets its own table, matching what it actually needs to correlate, rather than
 a shared generic one.
 ---
 ## Explicitly out of scope for this pass
 - **`Checkout`/`Order` wiring** — how `Checkout` calls into `Payment`, how `Order`/`Checkout`
  react to `Payment`'s events, where a draft `Order` gets created relative to when `Payment` is
  called. Deliberately designed and built separately, after `Payment` itself was complete —
  `Payment` must stand on its own regardless of what ends up consuming it.
 - **`Transaction` persistence** — Lunar's own `transactions` table (`type`: `intent`/`capture`/
  `refund`, `parent_transaction_id` chaining) already models the audit trail these events
  would feed, once a listener is built to write to it. `Payment` itself does not write
  `Transaction` rows — see the events table above; that is a listener's job, in whichever
  module ends up owning the write (likely `Order`, since `Transaction.order_id` is required).
@@ -135,11 +135,12 @@ needs, listing and detail alike:
 | `collections` | `$product->collections` | Array of `{id, name}` — directly assigned collections only, `name` is the translated collection name. Not filterable — see `collection_ids`. |
 | `collection_ids` | `$product->collections` + `->ancestors` | Filterable. Flat array of every directly-assigned collection's id, unioned with all of its ancestors' ids. `ProductFilters(collectionId: ...)` filters against this field, not `collections`, since products are typically attached only to leaf collections — a plain direct-match filter would never return anything for a parent/root category page. |
 | `slugs` | `$product->urls->pluck('slug')` | Filterable. Every locale's `Url::slug` for the product, so `getBySlug()` resolves purely from the index — no database read. |
 | `skus` | `$product->variants->pluck('sku')` | Filterable. Every variant's `sku`, deduplicated, empty ones dropped. Same "resolve from the index alone" reasoning as `slugs`, for a future SKU-based lookup/filter. |
 | `price` | Cheapest variant's base price | Filterable. Float in major units (e.g. `19.99`, not `1999`). Base price only — no customer group, default currency (`Currency::getDefault()`) only. `null` if the product has no priced variant yet, so it's excluded from range filters rather than treated as free. |
 | `brand` | Already indexed by Lunar's base indexer | Newly marked **filterable** — it existed in the document already, just wasn't usable in a `filter` clause. |
 | `tags` | `$product->tags->pluck('value')` | Display only. |
 | `media` | `$product->media` | Full gallery (id/url/thumb per image), not just the single thumbnail Lunar's base indexer sends. |
-| `variants` | `$product->variants` | Per variant: `id`, `sku`, `stock`, `purchasable`, `options` (option/value names, in the current locale), `prices` (per currency/customer group), `media` (variant-specific images). |
+| `variants` | `$product->variants` | Per variant: `id`, `sku`, `gtin`, `mpn`, `ean`, `stock`, `backorder`, `unit_quantity`, `purchasable`, `shippable`, `tax_ref`, `dimensions` (`length`/`width`/`height`/`weight`/`volume`, each `{value, unit}`), `options` (option/value names, in the current locale), `prices` (per currency/customer group), `media` (the variant's own images — `ProductVariant::images()`, a separate pivot from the product's own gallery above, populated by `ShopifyExportImporter` from Shopify's `Variant Image` CSV column). |
 | `reviews` | `Modules\Core\Review\Models\ProductReview` | `{items, count, average_rating}` — see "Reviews" below. |
 | `in_stock` | `$model->variants` | Filterable boolean. `true` if ANY variant currently passes `ProductVariant::canBeFulfilledAtQuantity(1)` — Lunar's own purchasability rule (`purchasable === 'always'` ignores stock entirely; `in_stock` checks `stock` alone; anything else checks `stock + backorder`). Only as fresh as the last reindex — see "Stock goes stale" below. |
@@ -2,6 +2,9 @@
 Findings from comparing a real Shopify product export CSV against Lunar's schema (`vendor/lunarphp/core`), plus the resulting implementation plan for `MigrateImport\Shopify\ShopifyExportImporter`.
 Need to discard everything and re-import from scratch (e.g. after a schema/indexer change that
 only applies to newly-created rows)? See `docs/shopify-reimport.md`.
 ## Idempotency problem
 Nothing in Lunar tracks "this record came from external system X, ID Y." Re-running an import with no external-ID tracking would duplicate every product on each run.
@@ -0,0 +1,149 @@
 # Wiping products before a clean Shopify re-import
 A runbook for discarding every imported product (and everything that hangs off one —
 variants, prices, media, reviews, options/values, the Meilisearch documents) and re-running
 `ShopifyExportImporter` from scratch. Useful after a schema/indexer change that only applies to
 newly-created rows (see "Why a wipe, not an update" below), or when the export CSV itself changed
 enough that stale products need to go, not just be updated in place.
 Every command below is a `tinker --execute=` one-liner run inside the app container — adjust the
 exec prefix (`./bin/dc-core.sh exec app ...`, `docker compose exec app ...`, etc.) for your setup.
 ---
 ## Why a wipe, not an update
 `ShopifyExportImporter`'s resolvers are mostly `firstOrCreate` — re-running the importer against
 an *existing* database updates matched rows but leaves already-created ones exactly as they were.
 That's the right behavior for routine re-imports (an updated price, a new variant), but it means a
 change to what gets set **at creation time only** — e.g. `ProductOptionResolver` now also setting
 `label`, not just `name`, on a `ProductOption` — never reaches a `ProductOption` row that already
 exists. A wipe forces every row to go through creation again, picking up such fixes.
 ---
 ## 1. Delete every product
 Cascades to `ProductVariant`, prices, and Spatie media rows — verified live (see
 `shopify-import.md`'s own history/commit log for context). Also removes each product's Meilisearch
 document automatically, via Scout's own delete hook fired on `forceDelete()` — no separate
 `scout:flush` needed.
 ```php
 \Lunar\Models\Product::withTrashed()->get()->each->forceDelete();
 ```
 **Let this run to completion.** Interrupting it mid-loop (e.g. Ctrl+C on the tinker session) stops
 after whichever product it was on, leaving the rest undeleted — safe to just re-run the same
 command again afterward, since already-deleted products are simply skipped.
 Verify:
 ```php
 \Lunar\Models\Product::withTrashed()->count(); // 0
 ```
 ### Requires: `product_reviews.product_id` cascades on delete
 `product_reviews` (boboko-core's own table, not Lunar's) originally had no `ON DELETE` clause on
 its `product_id` foreign key — deleting a reviewed product threw a constraint violation instead of
 the review going with it. Fixed by
 `database/migrations/2026_09_03_000001_add_cascade_delete_to_product_reviews_product_id.php`. Make
 sure this migration has actually run (`php artisan migrate`) before step 1, or a product with
 reviews will fail to delete.
 ---
 ## 2. Delete product options and values
 Not touched by step 1 (`ProductOption`/`ProductOptionValue` aren't scoped to one product — they're
 shared across the catalog, per `ProductOptionResolver::resolveOption()`'s `shared: true`). Safe to
 delete in full once every product (and therefore every variant referencing an option value via the
 `product_option_value_product_variant` pivot) is gone — deleting values while variants still
 reference them throws the same kind of FK violation step 1 guards against.
 ```php
 \Lunar\Models\ProductOptionValue::query()->delete();
 \Lunar\Models\ProductOption::query()->delete();
 ```
 Verify:
 ```php
 \Lunar\Models\ProductOption::count();      // 0
 \Lunar\Models\ProductOptionValue::count(); // 0
 ```
 ---
 ## 3. Clear the import mappings
 Without this, the importer's `ImportMapping::resolve(...)` calls still find the (now-deleted)
 mappings' rows absent, so this step is really about not leaving stale mapping rows pointing at
 nothing — `ImportMapping` rows aren't foreign-keyed to the models they map (`morphTo`, no
 constraint), so leaving them wouldn't break the re-import, but a stale mapping for a product that
 no longer exists is dead weight.
 ```php
 \Modules\Core\MigrateImport\Models\ImportMapping::where('source', 'shopify')->delete();
 ```
 Verify:
 ```php
 \Modules\Core\MigrateImport\Models\ImportMapping::where('source', 'shopify')->count(); // 0
 ```
 ---
 ## 4. Re-run the importer
 `boboko:migrate:import` dispatches `RunMigrateImportJob` onto the queue — **not synchronous** —
 so a queue worker must actually be running (`php artisan queue:work`, or your dev queue container)
 or the job just sits queued.
 ```bash
 php artisan boboko:migrate:import --source=shopify --type=export --file=<absolute path to the CSV>
 ```
 The `--file` value must be an **absolute path** inside the container (e.g.
 `/var/www/html/storage/app/private/imports/shopify/products_export.csv`) when running
 non-interactively — a path relative to `storage/app/private/imports` only resolves correctly when
 the command can fall back to its interactive prompt, which isn't available in a scripted/non-TTY
 run.
 Watch the queue worker's own log output for `FAIL` entries (see `docs/lunar.md` or your compose
 setup for how logs are routed to `docker compose logs`) — a clean run shows every
 `Laravel\Scout\Jobs\MakeSearchable` / `Spatie\MediaLibrary\Conversions\Jobs\PerformConversionsJob`
 line ending `DONE`, never `FAIL`.
 ---
 ## 5. Re-sync Meilisearch and reindex
 ```bash
 php artisan lunar:meilisearch:setup
 php artisan lunar:meilisearch:tune-product-search
 php artisan lunar:search:index "Lunar\Models\Product" --refresh
 ```
 `--refresh` re-syncs filterable/sortable index settings *and* reindexes every document — it does
 not reset `typoTolerance`/`prefixSearch` (confirmed live: both survived a `--refresh` run
 unchanged), so `tune-product-search` only needs re-running here for completeness/if it hadn't
 already been applied, not because `--refresh` would have clobbered it.
 ---
 ## Verifying the result
 ```php
 // Product count should match the CSV's actual unique `Handle` count, not
 // whatever the database held before the wipe — those aren't the same number
 // if stale/manually-added products existed alongside the CSV-sourced ones.
 \Lunar\Models\Product::count();
 // Spot-check that at least one variant picked up its own image (see
 // shopify-import.md's "Images" section) — 0 is only correct if the CSV
 // genuinely has no `Variant Image` values populated.
 \Lunar\Models\ProductVariant::has('images')->count();
 ```
@@ -17,10 +17,12 @@ class ProductFilters
     *   not a direct-assignment-only match) — the right semantics for "products on
     *   this category page", since products are typically attached only to leaf
     *   collections.
     * @param $tag exactly one tag — no multi-select yet.
     */
    public function __construct(
        public readonly ?int $collectionId = null,
        public readonly ?string $brand = null,
        public readonly ?string $tag = null,
        public readonly ?float $minPrice = null,
        public readonly ?float $maxPrice = null,
        public readonly bool $inStockOnly = false,
@@ -6,18 +6,28 @@ use Illuminate\Pagination\LengthAwarePaginator;
 /**
 * Everything a listing page needs from one ProductService::list() call —
- * the product page itself plus the price slider's bounds, so a controller
+ * the product page itself, the price slider's bounds, and the set of tags
- * makes one service call instead of orchestrating list() and
+ * actually present on matching products (for a tag filter sidebar) — so a
- * priceSliderBounds() separately. list() still issues two Meilisearch
+ * controller makes one service call instead of orchestrating list(),
- * requests internally (the product search and the price facet stats — see
+ * priceSliderBounds(), and facets('tags', ...) separately. list() still
- * priceSliderBounds()'s own docblock for why they can't be merged into one
+ * issues multiple Meilisearch requests internally (the product search, the
- * without changing the slider's UX), but that's this DTO's job to hide,
+ * price facet stats, the tag facet distribution — see priceSliderBounds()'s
- * not the controller's to know about.
+ * own docblock for why the price ones can't be merged into one without
 * changing the slider's UX), but that's this DTO's job to hide, not the
 * controller's to know about.
 */
 class ProductListingResult
 {
    /**
     * @param  array<int, string>  $availableTags  every distinct tag value
     *   present on at least one product matching the listing's OTHER
     *   filters (collection/price/stock — never the tag filter itself, so
     *   selecting a tag doesn't collapse the list down to just that tag).
     *   Sorted alphabetically. Empty if no product in scope has any tag.
     */
    public function __construct(
        public readonly LengthAwarePaginator $products,
        public readonly PriceSliderBounds $priceBounds,
        public readonly array $availableTags = [],
    ) {}
 }
@@ -27,8 +27,14 @@ use Spatie\MediaLibrary\MediaCollections\Models\Media;
 *   - slugs (every locale's Url::slug for the product, filterable) — lets
 *     ProductService::getBySlug() resolve a product from the index directly, with
 *     no database read at all
 *   - skus (every variant's sku, deduplicated, filterable) — same "resolve from the
 *     index alone" reasoning as slugs, for a future SKU-based lookup/filter
 *   - price (cheapest variant, filterable) and full per-variant pricing
- *   - variants: sku, stock, purchasable, option values, prices, media
+ *   - variants: sku, gtin, mpn, ean, stock, backorder, unit_quantity, purchasable,
 *     shippable, tax_ref, dimensions (length/width/height/weight/volume, each
 *     {value, unit}), option values, prices, media — the variant's own images
 *     (ProductVariant::images(), separate from the product's gallery below), not
 *     the product's own media repeated per variant
 *   - the full media gallery (not just the single thumbnail Lunar's base indexer sends)
 *   - tags
 *   - reviews: {items: [...], count, average_rating} — items are public-safe fields
@@ -83,6 +89,8 @@ class ProductIndexer extends BaseProductIndexer
            'channel_ids',
            'in_stock',
            'recommendations.id',
            'skus',
            'tags',
        ];
    }
@@ -126,6 +134,7 @@ class ProductIndexer extends BaseProductIndexer
            ->values()
            ->all();
        $data['slugs'] = $model->urls->pluck('slug')->unique()->values()->all();
        $data['skus'] = $model->variants->pluck('sku')->filter()->unique()->values()->all();
        $data['tags'] = $model->tags->pluck('value')->all();
        $data['media'] = $model->media->map(fn (Media $media) => $this->mapMedia($media))->all();
        $data['variants'] = $model->variants->map(fn (ProductVariant $variant) => $this->mapVariant($variant, $currency))->all();
@@ -161,8 +170,22 @@ class ProductIndexer extends BaseProductIndexer
        return [
            'id' => $variant->id,
            'sku' => $variant->sku,
            'gtin' => $variant->gtin,
            'mpn' => $variant->mpn,
            'ean' => $variant->ean,
            'stock' => $variant->stock,
            'backorder' => $variant->backorder,
            'unit_quantity' => $variant->unit_quantity,
            'purchasable' => $variant->purchasable,
            'shippable' => $variant->shippable,
            'tax_ref' => $variant->tax_ref,
            'dimensions' => [
                'length' => ['value' => $variant->length_value, 'unit' => $variant->length_unit],
                'width' => ['value' => $variant->width_value, 'unit' => $variant->width_unit],
                'height' => ['value' => $variant->height_value, 'unit' => $variant->height_unit],
                'weight' => ['value' => $variant->weight_value, 'unit' => $variant->weight_unit],
                'volume' => ['value' => $variant->volume_value, 'unit' => $variant->volume_unit],
            ],
            'options' => $variant->values->map(fn ($value) => [
                'option' => $this->translatedName($value->option->name),
                'handle' => $value->option->handle,
@@ -78,8 +78,27 @@ class ProductService
        );
        $priceBounds = $this->priceSliderBounds($filters, $filters?->minPrice, $filters?->maxPrice);
        $availableTags = $this->availableTags($filters);
-        return new ProductListingResult($products, $priceBounds);
+        return new ProductListingResult($products, $priceBounds, $availableTags);
    }
    /**
     * Every distinct `tags` value present on a product matching $filters,
     * excluding $filters->tag itself — same "scoped but not self-collapsing"
     * reasoning as priceRange() excluding `price` — so selecting a tag
     * doesn't shrink the sidebar down to just that one tag. Sorted
     * alphabetically; Meilisearch's facetDistribution has no defined order
     * of its own.
     *
     * @return array<int, string>
     */
    private function availableTags(?ProductFilters $filters): array
    {
        $filter = $this->filterBuilder->build($filters, exclude: ['tag']);
        $tags = $this->rawFacets('tags', $filter)['facetDistribution']['tags'] ?? [];
        return collect($tags)->keys()->sort()->values()->all();
    }
    /**
@@ -93,9 +112,12 @@ class ProductService
     * apply that field's own filter separately in the UI/query layer.
     *
     * `$field` must be one of ProductIndexer's filterable fields; only discrete-value
-     * fields make sense here (`brand`, `in_stock`) — a numeric field like `price`
+     * fields make sense here (`brand`, `tags`, `in_stock`) — a numeric field like
-     * would return one "facet" per exact price, not a usable range bucket. Use
+     * `price` would return one "facet" per exact price, not a usable range bucket.
-     * `priceRange()` for `price` instead.
+     * Use `priceRange()` for `price` instead. `facets('tags', $filters)` is how a
     * category page gets "which tags actually appear on products in this category" —
     * pass a $filters that omits `tag` (see `build()`'s $exclude) so the tag list
     * itself doesn't collapse to whichever tag is already selected.
     *
     * @return array<string, int> facet value => matching product count
     */
@@ -14,7 +14,7 @@ use Modules\Core\Catalog\DTOs\ProductFilters;
 class ProductFilterBuilder
 {
    /**
-     * @param  array<int, 'collectionId'|'brand'|'price'|'inStockOnly'>  $exclude
+     * @param  array<int, 'collectionId'|'brand'|'tag'|'price'|'inStockOnly'>  $exclude
     *   filter fields to leave out even if set on $filters — e.g.
     *   ProductService::priceRange() excludes 'price' so a price slider's own
     *   bounds don't shrink to whatever range is already selected on it.
@@ -28,6 +28,7 @@ class ProductFilterBuilder
        $clauses = Collection::make([
            'collectionId' => $filters->collectionId !== null ? "collection_ids = \"{$filters->collectionId}\"" : null,
            'brand' => $filters->brand !== null ? 'brand = "'.addcslashes($filters->brand, '"\\').'"' : null,
            'tag' => $filters->tag !== null ? 'tags = "'.addcslashes($filters->tag, '"\\').'"' : null,
            'price' => Collection::make([
                $filters->minPrice !== null ? "price >= {$filters->minPrice}" : null,
                $filters->maxPrice !== null ? "price <= {$filters->maxPrice}" : null,
@@ -1,62 +0,0 @@
 <?php
 namespace Modules\Core\Checkout\Contracts;
 use Lunar\Exceptions\FingerprintMismatchException;
 use Lunar\Exceptions\Carts\CartException;
 use Lunar\Models\Cart;
 use Lunar\Models\Order;
 /**
 * A boboko-owned payment driver — wraps a payment gateway's own confirmation
 * mechanics (Stripe's synchronous authorize() call, a redirect-based
 * provider's async callback/webhook, anything else) behind one uniform
 * moment: "payment is confirmed, place the order."
 *
 * confirm() is the only thing a driver is required to do: once it has,
 * by whatever mechanism is native to that gateway, independently decided
 * the payment succeeded, it calls Modules\Core\Checkout\Services\
 * CheckoutService::placeOrder($fingerprint) itself — no driver ever calls
 * Lunar\Models\Cart::createOrder() directly. This is what lets the
 * storefront checkout sequence stay uniform regardless of which provider is
 * active: set addresses, select shipping, hand off to whichever driver is
 * configured, and the driver decides when (or whether) the order actually
 * gets created. See docs/checkout.md / docs/payments.md.
 */
 interface PaymentDriver
 {
    /**
     * Whether this driver can actually be used right now — e.g. Stripe
     * checking its own API key is present, an offline-style driver always
     * returning true since it has no external dependency. Independent of
     * Modules\Core\Payment\Models\PaymentMethod::enabled (the admin
     * on/off toggle) — CheckoutService::getPaymentMethods() combines both:
     * a type is only offered to the storefront if it's administratively
     * enabled AND its driver reports itself configured.
     */
    public function isConfigured(): bool;
    /**
     * $type is the payment type key being confirmed (e.g. 'cash-in-hand',
     * 'cash-on-delivery', 'stripe') — passed through even though most
     * drivers only ever serve one type, because a driver shared across
     * several types (e.g. one "no real confirmation" offline driver behind
     * both cash-in-hand and cash-on-delivery) needs it to look up that
     * type's own config (e.g. its 'authorized' status) rather than another
     * type's.
     *
     * $data carries whatever the gateway needs to confirm this specific
     * payment (Stripe: ['payment_intent' => $id], a redirect-based
     * provider: its callback payload) — passed explicitly by the caller
     * (a controller, a webhook job) rather than a driver reaching into the
     * global request(), so confirm() works the same whether it's called
     * from a synchronous HTTP request or an async webhook/job with no
     * active request at all.
     *
     * @param  array<string, mixed>  $data
     *
     * @throws FingerprintMismatchException
     * @throws CartException
     */
    public function confirm(Cart $cart, string $type, string $fingerprint, array $data): Order;
 }
@@ -5,13 +5,17 @@ namespace Modules\Core\Checkout\Events;
 use Lunar\Models\Order;
 /**
- * Dispatched by CheckoutService::placeOrder() the moment an Order exists —
+ * Dispatched once an Order's placed_at is set — the handoff point between
- * the handoff point between Checkout and Order (see docs/checkout.md's
+ * Checkout/Payment and Order (see docs/checkout.md's "Three-stage
- * "Three-stage lifecycle"). Checkout has no opinion about what happens
+ * lifecycle"). Fired by Modules\Core\Order\Listeners\
- * after this fires; Order's own listeners (not built yet — Order is a
+ * ApplyResolvedPaymentStatus once it resolves a PaymentCaptured/
- * named-but-unscoped concern, same status Recovery had before it existed)
+ * PaymentAuthorized event into an actual order status change, not by
- * would be what reacts to it — e.g. a confirmation email, initializing
+ * CheckoutService directly — a draft Order can exist (via
- * order status tracking.
+ * CheckoutService::initiatePayment()) well before this fires, if payment
 * resolves asynchronously (e.g. a redirect-based gateway). Checkout has no
 * opinion about what happens after this fires; Order's own listeners are
 * what react to it — e.g. a confirmation email, initializing order status
 * tracking.
 */
 class OrderPlaced
 {
@@ -10,17 +10,16 @@ use Lunar\Base\Addressable;
 use Lunar\DataTypes\ShippingOption;
 use Lunar\Facades\ShippingManifest;
 use Lunar\Models\Cart;
 use Lunar\Models\Order;
 use Modules\Core\Cart\Services\CartService;
 use Modules\Core\Checkout\Contracts\PaymentDriver;
 use Modules\Core\Checkout\Events\BillingAddressSet;
 use Modules\Core\Checkout\Events\OrderPlaced;
 use Modules\Core\Checkout\Events\PaymentMethodSelected;
 use Modules\Core\Checkout\Events\ShippingAddressSet;
 use Modules\Core\Checkout\Events\ShippingOptionSelected;
 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;
 /**
 * Storefront-facing checkout operations, mirroring
@@ -29,9 +28,11 @@ use Modules\Core\Payment\Models\PaymentMethod;
 * implementation detail. See docs/checkout.md for the full design —
 * Checkout is the middle of a three-stage lifecycle (Cart → Checkout →
 * Order): it owns the placement moment itself (address, shipping selection,
- * placeOrder()) and ends the instant an Order exists. What happens to that
+ * ensuring a draft Order exists) and hands off to Payment the instant that
- * Order afterward (status transitions, fulfillment) is deliberately out of
+ * draft exists — see initiatePayment(). What happens to that Order
- * scope here — see OrderPlaced's docblock.
+ * afterward (status transitions, fulfillment) is deliberately out of
 * scope here — see docs/payments.md and Checkout\Events\OrderPlaced's
 * docblock for where that now lives.
 *
 * Depends on CartService for cart access rather than reaching into
 * Lunar\Facades\CartSession directly a second time, so Checkout stays
@@ -41,6 +42,7 @@ class CheckoutService
 {
    public function __construct(
        private readonly CartService $cart,
        private readonly PaymentDriverResolver $paymentDrivers,
    ) {}
    public function setShippingAddress(array|Addressable $address): Cart
@@ -97,47 +99,12 @@ class CheckoutService
        return $cart;
    }
    /**
     * $fingerprint is mandatory, not optional — the caller must prove the
     * cart total the shopper last saw (Cart::fingerprint()) still matches
     * before an order is placed. Cart::checkFingerprint() throws Lunar's own
     * FingerprintMismatchException on a mismatch (a line's price changed,
     * stock adjusted the total, another tab modified the cart) rather than
     * silently placing an order at a different total than what was shown.
     *
     * Not called directly by a storefront — see confirmPayment(), which is
     * the only caller and supplies the fingerprint captured in
     * selectPaymentMethod(), not one the storefront has to obtain itself.
     *
     * No exception wrapping: Lunar\Validation\Cart\ValidateCartForOrderCreation
     * (run inside Cart::createOrder()) already throws
     * Lunar\Exceptions\Carts\CartException with a field-keyed MessageBag
     * ($exception->errors()) for address/shipping-option validation and the
     * duplicate-order guard — already the right shape for a storefront to
     * render as form errors directly. FingerprintMismatchException
     * propagates the same way, for the same reason.
     *
     * @throws FingerprintMismatchException
     * @throws CartException
     */
    public function placeOrder(string $fingerprint): Order
    {
        $cart = $this->cart->currentOrCreate();
        $cart->checkFingerprint($fingerprint);
        $order = $cart->createOrder();
        Event::dispatch(new OrderPlaced($order));
        return $order;
    }
    /**
     * 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 PaymentDriver reports itself usable right now
+     * whose registered driver reports itself usable right now
-     * (PaymentDriver::isConfigured() — e.g. Stripe with no API key set is
+     * (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
@@ -149,7 +116,7 @@ class CheckoutService
    {
        return PaymentMethod::where('enabled', true)
            ->pluck('type')
-            ->filter(fn (string $type) => $this->resolvePaymentDriver($type)?->isConfigured() ?? false)
+            ->filter(fn (string $type) => $this->paymentDrivers->resolve($type)?->isConfigured() ?? false)
            ->values()
            ->all();
    }
@@ -165,13 +132,13 @@ class CheckoutService
     * including any payment-type-specific adjustment (e.g. a COD
     * surcharge), which only exists once payment_method is set and the
     * cart recalculates. Captured here, server-side, rather than asked of
-     * the storefront: this is the last moment before confirmPayment() that
+     * the storefront: this is the last moment before initiatePayment() that
-     * the shopper's reviewed total is known, and confirmPayment() reads it
+     * the shopper's reviewed total is known, and initiatePayment() reads it
     * back internally instead of taking a fingerprint parameter — a
     * storefront should never need to know Cart::fingerprint() exists.
     *
-     * Does not itself call a PaymentDriver — selecting a method and
+     * Does not itself call a payment driver — selecting a method and
-     * confirming payment against it are deliberately separate steps, same
+     * initiating payment against it are deliberately separate steps, same
     * as selecting a shipping option happens before placing the order.
     *
     * @throws UnknownPaymentTypeException if $type isn't currently offered
@@ -185,11 +152,11 @@ class CheckoutService
        }
        $cart = $this->cart->currentOrCreate();
-        $cart->meta = [...$cart->meta->toArray(), 'payment_method' => $type];
+        $cart->meta = [...($cart->meta?->toArray() ?? []), 'payment_method' => $type];
        $cart->save();
        $cart = $cart->calculate();
-        $cart->meta = [...$cart->meta->toArray(), 'checkout_fingerprint' => $cart->fingerprint()];
+        $cart->meta = [...($cart->meta?->toArray() ?? []), 'checkout_fingerprint' => $cart->fingerprint()];
        $cart->save();
        Event::dispatch(new PaymentMethodSelected($cart, $type));
@@ -198,51 +165,76 @@ class CheckoutService
    }
    /**
-     * Resolves $type's registered PaymentDriver and calls confirm() —
+     * The one storefront-facing "place this order and pay for it" call —
-     * the driver decides whether/when the order actually gets placed (see
+     * the point where Checkout hands off to Payment. Ensures a draft
-     * Modules\Core\Checkout\Contracts\PaymentDriver's docblock). $data
+     * Order exists (Cart::createOrder() — confirmed idempotent against a
-     * carries whatever that driver needs (Stripe's payment_intent id, a
+     * cart's own pre-existing, not-yet-placed-at draft; see
-     * future redirect-based provider's callback payload).
+     * 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().
     *
-     * The fingerprint passed to the driver is the one captured by
+     * Returns the driver's own PaymentResult UNCHANGED — this method does
-     * selectPaymentMethod(), not supplied by the caller — see that
+     * not wait for or resolve anything past what pay()/authorize() itself
-     * method's docblock. Throws the same FingerprintMismatchException a
+     * returns synchronously. A Pending result (an async gateway like
-     * caller-supplied one would if the cart's total has since changed;
+     * Stripe requiring 3-D Secure/a redirect) is a normal, expected
-     * missing entirely (selectPaymentMethod() was never called for this
+     * outcome, not an error — the caller (a storefront controller) is
-     * cart) is treated the same as a mismatch, not a different error.
+     * responsible for whatever the gateway needs next.
     *
-     * @param  array<string, mixed>  $data
+     * 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.
     *
-     * @throws UnknownPaymentTypeException if $type isn't currently offered
+     * The draft order's own $order->total (not the Cart's) is what gets
-     *   (see getPaymentMethods()) — re-checked here, not just in
+     * passed as $amount — Order::$total is Lunar's own Price-cast
-     *   selectPaymentMethod(), since a type could be disabled between
+     * attribute, already resolving the correct Currency via the order's
-     *   selection and confirmation
+     * own currency_code, and is the authoritative total once the draft
-     * @throws \Lunar\Exceptions\FingerprintMismatchException
+     * row exists.
-     * @throws \Lunar\Exceptions\Carts\CartException
+     *
     * $context passed to the driver is {cart_id, order_id} — the exact
     * keys Modules\Core\Payment\Drivers\StripePaymentDriver::
     * rememberIntent() already reads.
     *
     * Same fingerprint precondition the old placeOrder() had: mandatory,
     * not optional, checked before the draft is created.
     *
     * @param  array<string, mixed>  $data  passed through untouched to
     *   the driver's pay()/authorize() — e.g. Stripe's payment_method
     *   token.
     *
     * @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
     * @throws FingerprintMismatchException
     * @throws CartException
     */
-    public function confirmPayment(string $type, array $data = []): Order
+    public function initiatePayment(string $fingerprint, array $data = []): PaymentResult
    {
-        if (! in_array($type, $this->getPaymentMethods(), true)) {
+        $cart = $this->cart->currentOrCreate();
-            throw new UnknownPaymentTypeException($type);
+        $cart->checkFingerprint($fingerprint);
        $type = $cart->meta['payment_method'] ?? null;
        if ($type === null || ! in_array($type, $this->getPaymentMethods(), true)) {
            throw new UnknownPaymentTypeException((string) $type);
        }
-        $cart = $this->cart->currentOrCreate();
+        $order = $cart->createOrder();
        $fingerprint = $cart->meta['checkout_fingerprint'] ?? '';
-        return $this->resolvePaymentDriver($type)->confirm($cart, $type, $fingerprint, $data);
+        $driver = $this->paymentDrivers->resolve($type);
-    }
+        $captureMode = config("lunar.payments.types.{$type}.capture_mode", 'pay');
-    /**
+        $context = ['cart_id' => $cart->id, 'order_id' => $order->id];
     * Resolves $type's registered PaymentDriver, or null if $type has no
     * 'payment_driver' registered in config('lunar.payments.types.<type>')
     * at all — deliberately non-throwing so getPaymentMethods() can filter
     * unresolvable types silently rather than treating "not registered"
     * as an error condition when just checking availability.
     */
    private function resolvePaymentDriver(string $type): ?PaymentDriver
    {
        $driverClass = config("lunar.payments.types.{$type}.payment_driver");
-        return $driverClass ? app($driverClass) : null;
+        return $captureMode === 'authorize'
            ? $driver->authorize($type, $order->total, $data, $context)
            : $driver->pay($type, $order->total, $data, $context);
    }
 }
@@ -16,10 +16,16 @@ class ProductOptionResolver
        // the same option instead of creating a near-duplicate.
        $handle = Str::slug($name) ?: 'option';
        // 'label' must be set even though nothing here reads it back — a null
        // label crashes Lunar's own ProductOptionIndexer::toSearchableArray()
        // (foreach (null as ...)) the moment this option gets reindexed, since
        // it assumes every ProductOption always has one. Same value as 'name'
        // is a reasonable default; Shopify's CSV has no separate "label" concept.
        return ProductOption::query()->firstOrCreate(
            ['handle' => $handle],
            [
                'name' => [DefaultLocale::code() => $name],
                'label' => [DefaultLocale::code() => $name],
                'shared' => true,
            ],
        );
@@ -25,6 +25,7 @@ use Modules\Core\MigrateImport\Shopify\Resolvers\ProductOptionResolver;
 use Modules\Core\MigrateImport\Shopify\Resolvers\ProductTypeResolver;
 use Modules\Core\MigrateImport\Shopify\Resolvers\TagResolver;
 use Modules\Core\MigrateImport\Shopify\Resolvers\TaxClassResolver;
 use Spatie\MediaLibrary\MediaCollections\Models\Media;
 class ShopifyExportImporter implements Importer
 {
@@ -113,7 +114,7 @@ class ShopifyExportImporter implements Importer
        $options = $this->attachOptions($product, $row);
        foreach ($group->variantRows as $index => $variantRow) {
-            $this->importVariant($product, $group->handle, $index, $variantRow, $taxClass, $currency, $options);
+            $this->importVariant($product, $group->handle, $index, $variantRow, $taxClass, $currency, $options, $imagesPath);
        }
        foreach ($group->imageRows as $index => $imageRow) {
@@ -151,6 +152,7 @@ class ShopifyExportImporter implements Importer
        TaxClass $taxClass,
        Currency $currency,
        array $options,
        string $imagesPath,
    ): void {
        $externalId = "{$handle}#{$index}";
        $existing = ImportMapping::resolve(self::SOURCE, 'variant', $externalId);
@@ -182,6 +184,26 @@ class ShopifyExportImporter implements Importer
            : null;
        $this->priceResolver->resolve($variant, $currency, $price, $comparePrice);
        // Shopify's own "Variant Image" column — the one image a variant picker
        // actually swaps to when that variant is selected — distinct from the
        // product's full gallery (imageRows below). Often the same file as one
        // of the product's own image rows, sometimes not yet imported at all
        // (e.g. a variant-only image never listed as its own image row) — either
        // way resolveOrImportImage() handles both via the same Image Src dedup
        // key, so whichever of importVariant()/importImage() runs first for a
        // given src does the actual import.
        $variantImageSrc = trim((string) ($row['Variant Image'] ?? ''));
        if ($variantImageSrc !== '') {
            $media = $this->resolveOrImportImage($product, $handle, $variantImageSrc, 1, $imagesPath);
            if ($media) {
                $variant->images()->syncWithoutDetaching([
                    $media->id => ['primary' => true, 'position' => 1],
                ]);
            }
        }
    }
    private function importImage(
@@ -191,29 +213,54 @@ class ShopifyExportImporter implements Importer
        array $row,
        string $imagesPath,
    ): void {
        $externalId = $row['Image Src'] ?: "{$handle}#image-{$index}";
        $position = (int) ($row['Image Position'] ?? $index + 1);
-        if (ImportMapping::resolve(self::SOURCE, 'image', $externalId)) {
+        $this->resolveOrImportImage($product, $handle, $row['Image Src'], $position, $imagesPath);
-            return;
+    }
    /**
     * Resolves the Media already imported for $imageSrc (recorded under
     * source_type 'image', keyed by Image Src — the same URL Shopify repeats
     * across a product's own image rows and any variant's "Variant Image"
     * column), importing it via AssetResolver if this is the first time this
     * src has been seen. Shared by importImage() (product gallery) and
     * importVariant() (variant-specific image) so the same physical file is
     * never uploaded to Spatie MediaLibrary twice just because Shopify's flat
     * CSV format repeats the URL on multiple rows.
     */
    private function resolveOrImportImage(
        Product $product,
        string $handle,
        string $imageSrc,
        int $position,
        string $imagesPath,
    ): ?Media {
        $externalId = $imageSrc ?: "{$handle}#image-{$position}";
        $existing = ImportMapping::resolve(self::SOURCE, 'image', $externalId);
        if ($existing instanceof Media) {
            return $existing;
        }
-        $localFile = $this->findLocalFile($imagesPath, $row['Image Src']);
+        $localFile = $this->findLocalFile($imagesPath, $imageSrc);
        if ($localFile === null) {
            Log::warning('Shopify import: image file not found', [
                'handle' => $handle,
-                'image_src' => $row['Image Src'],
+                'image_src' => $imageSrc,
            ]);
-            return;
+            return null;
        }
        $media = $this->assetResolver->resolve($product, $localFile, $position);
        if ($media) {
-            ImportMapping::record(self::SOURCE, 'image', $externalId, $product);
+            ImportMapping::record(self::SOURCE, 'image', $externalId, $media);
        }
        return $media;
    }
    private function findLocalFile(string $imagesPath, string $imageSrc): ?string
@@ -0,0 +1,63 @@
 <?php
 namespace Modules\Core\Order\Listeners;
 use Illuminate\Support\Facades\Event;
 use Lunar\Models\Order;
 use Modules\Core\Checkout\Events\OrderPlaced;
 use Modules\Core\Payment\Events\PaymentAuthorized;
 use Modules\Core\Payment\Events\PaymentCaptured;
 /**
 * The only place an Order's status column is written in reaction to a
 * payment outcome. Registered against BOTH PaymentCaptured and
 * PaymentAuthorized (see OrderServiceProvider) — same handler either way,
 * since both carry the same {type, result, context} shape and only differ
 * in which config key decides the resulting status.
 *
 * Reads $event->context['order_id'] to find which Order this outcome
 * belongs to — Payment has no concept of an Order, so this is the one
 * place that context key gets consumed on the Order side (Payment's own
 * StripePaymentDriver reads $context['order_id'] independently, for its
 * own unrelated correlation need — see that class's rememberIntent()).
 *
 * Loads and saves the model (not a bulk ::whereKey()->update()) so
 * Order::observe()'s updated() hook fires and OrderStatusUpdated goes out
 * the same as any other status write — see that event's own docblock for
 * why it's meant to fire "regardless of what wrote it."
 *
 * Dispatches Checkout\Events\OrderPlaced itself, once placed_at is set —
 * see that event's own docblock for why this, not CheckoutService, is now
 * the dispatch point.
 */
 class ApplyResolvedPaymentStatus
 {
    public function handle(PaymentCaptured|PaymentAuthorized $event): void
    {
        $orderId = $event->context['order_id'] ?? null;
        if ($orderId === null) {
            return;
        }
        $order = Order::findOrFail($orderId);
        $configKey = $event instanceof PaymentCaptured ? 'captured_status' : 'authorized_status';
        $status = config("lunar.payments.types.{$event->type}.{$configKey}");
        if ($status === null) {
            return;
        }
        $wasPlaced = ! blank($order->placed_at);
        $order->update([
            'status' => $status,
            'placed_at' => $order->placed_at ?? now(),
        ]);
        if (! $wasPlaced) {
            Event::dispatch(new OrderPlaced($order));
        }
    }
 }
@@ -0,0 +1,57 @@
 <?php
 namespace Modules\Core\Order\Listeners;
 use Lunar\Models\Order;
 use Modules\Core\Order\Services\TransactionRecorder;
 use Modules\Core\Payment\Events\PaymentAuthorized;
 use Modules\Core\Payment\Events\PaymentCaptured;
 use Modules\Core\Payment\Events\PaymentRefunded;
 use Modules\Core\Payment\Events\PaymentVoided;
 /**
 * Writes the Transaction row for a successful payment outcome — the
 * "record what happened" half of reacting to Payment's events, separate
 * from Modules\Core\Order\Listeners\ApplyResolvedPaymentStatus's "update
 * the order's status" half. Both listen to the same events for the same
 * reason: two independent reactions to one payment outcome, neither
 * calling the other (see docs/payments.md).
 *
 * Only registered against the SUCCESS events (PaymentCaptured,
 * PaymentAuthorized, PaymentVoided, PaymentRefunded) — a Failed event
 * never reaches here, since a failed attempt moved no money and settled
 * nothing worth auditing as a Transaction row (see OrderServiceProvider's
 * registration and docs/payments.md's "Explicitly out of scope" section
 * on why no Failed-side Order reaction exists at all).
 *
 * Same defensive $context['order_id'] ?? null early-return as
 * ApplyResolvedPaymentStatus — $context is caller-supplied and optional,
 * and this listener must not crash for a future non-Checkout caller of
 * pay()/authorize() with no order_id in its context.
 */
 class RecordPaymentTransaction
 {
    public function __construct(
        private readonly TransactionRecorder $transactions,
    ) {}
    public function handle(PaymentCaptured|PaymentAuthorized|PaymentVoided|PaymentRefunded $event): void
    {
        $orderId = $event->context['order_id'] ?? null;
        if ($orderId === null) {
            return;
        }
        $order = Order::findOrFail($orderId);
        $type = match ($event::class) {
            PaymentAuthorized::class => 'intent',
            PaymentCaptured::class => 'capture',
            PaymentRefunded::class => 'refund',
            PaymentVoided::class => 'void',
        };
        $this->transactions->record($order, $type, $event->type, $event->result);
    }
 }
@@ -0,0 +1,55 @@
 <?php
 namespace Modules\Core\Order\Services;
 use Lunar\Models\Order;
 use Lunar\Models\Transaction;
 use Modules\Core\Payment\DTOs\PaymentResult;
 use Modules\Core\Payment\Enums\PaymentResultStatus;
 /**
 * Writes the Transaction row a Payment operation's PaymentResult becomes —
 * the one place that translates Payment's gateway-agnostic result into
 * Lunar's own transactions table, in the same shape lunarphp/stripe's own
 * StoreCharges already writes (type, success, amount, reference, driver).
 * Lives in Order, not Payment — Transaction.order_id is required, and
 * Payment never writes to another module's models (see docs/payments.md);
 * this is the "read the event, do the write" half of that boundary, same
 * shape as Modules\Core\Order\Listeners\ApplyResolvedPaymentStatus.
 *
 * Kept as its own class (not inlined into the listener that calls it) so a
 * future admin action (a manually-triggered capture/refund from Filament)
 * can write a row the same way, without going through an event at all.
 */
 class TransactionRecorder
 {
    /**
     * $type is Lunar's own transaction type string — 'intent' (an
     * authorize()-produced hold), 'capture' (settled funds, whether via
     * pay() directly or capture() settling a prior intent), 'refund',
     * 'void' is NOT one of Lunar's three built-in types (Order::
     * paymentStatus() only ever reads 'intent'/'capture'/'refund' — see
     * Modules\Core\Order\Support\OrderStatus::payment()) — a void never
     * moved money, so it's still recorded for audit but $success reflects
     * whether the RELEASE succeeded, not a captured amount.
     *
     * $driver is the payment type key (e.g. 'stripe', 'cash-on-delivery'),
     * not a class name — matches the $type PaymentCaptured/etc. events
     * themselves carry, and what Transaction.driver already means
     * elsewhere in this codebase (see the old, now-removed
     * TransactionRecorder this replaces).
     */
    public function record(Order $order, string $type, string $driver, PaymentResult $result): Transaction
    {
        return $order->transactions()->create([
            'success' => $result->status === PaymentResultStatus::Succeeded,
            'type' => $type,
            'driver' => $driver,
            'amount' => $result->amount->value,
            'reference' => $result->reference,
            'status' => $result->status->name,
            'notes' => $result->failureReason,
            'meta' => $result->meta,
        ]);
    }
 }
@@ -0,0 +1,22 @@
 <?php
 namespace Modules\Core\Payment\Contracts;
 /**
 * Every driver implements this, orthogonal to which payment operations
 * (SupportsPay, SupportsAuthorization, ...) it supports — whether a driver
 * can actually be used right now is a separate question from what it's
 * capable of when it can be. An offline driver has no external dependency
 * to be missing and always returns true; a gateway driver checks its own
 * credentials/API key.
 */
 interface Configurable
 {
    /**
     * Independent of any admin-facing enabled/disabled toggle a caller
     * might also apply on top — this is only about whether the driver
     * itself is usable right now (e.g. Stripe with no API key configured
     * is never usable, regardless of any such toggle).
     */
    public function isConfigured(): bool;
 }
@@ -0,0 +1,50 @@
 <?php
 namespace Modules\Core\Payment\Contracts;
 use Modules\Core\Payment\DTOs\PaymentResult;
 /**
 * The async counterpart to SupportsPay::pay()/SupportsAuthorization::
 * authorize() — implemented only by a driver whose gateway can't resolve
 * one of those synchronously (a redirect the shopper completes elsewhere,
 * a webhook that arrives later). A driver whose pay()/authorize() always
 * returns a terminal PaymentResult (Succeeded/Failed) in the same call
 * never implements this — there is nothing left to call back.
 *
 * Resolves into the SAME events the original pay()/authorize() call would
 * have produced had it resolved synchronously — PaymentCaptured/
 * PaymentCaptureFailed for a pending pay(), PaymentAuthorized/
 * PaymentAuthorizationFailed for a pending authorize(). Which pair
 * applies is up to the driver to track (e.g. against whatever it stored
 * when the original call returned Pending), not something this method's
 * signature can express generically.
 */
 interface HandlesPaymentCallback
 {
    /**
     * $reference is the gateway's own identifier for the pending attempt
     * (the same value the original pay()/authorize() call returned via
     * PaymentResult::$reference) — how the driver finds which attempt
     * this callback belongs to.
     *
     * $data carries whatever the callback/webhook payload contains
     * (Stripe: ['payment_intent' => $id], a redirect-based provider: its
     * query params or POST body) — passed explicitly by the caller rather
     * than the driver reaching into the global request(), so this works
     * the same whether it's called from a synchronous HTTP request or an
     * async webhook job with no active request at all.
     *
     * $context is opaque to the driver, carried through untouched into
     * whichever Payment event this callback produces — see SupportsPay::
     * pay()'s own $context param for the full reasoning. A driver that
     * needs the ORIGINAL context from the pay()/authorize() call (a
     * webhook's own payload carries none of its own) must have persisted
     * it itself when that call returned Pending — Payment provides no
     * storage for this.
     *
     * @param  array<string, mixed>  $data
     * @param  array<string, mixed>  $context
     */
    public function handleCallback(string $reference, array $data, array $context = []): PaymentResult;
 }
@@ -0,0 +1,37 @@
 <?php
 namespace Modules\Core\Payment\Contracts;
 use Lunar\DataTypes\Price;
 use Modules\Core\Payment\DTOs\PaymentResult;
 /**
 * A driver's hold-only operation (Mastercard's "Authorize", Nexi's
 * ActionType::PREAUTH(), Stripe's capture_method=manual) — places a hold
 * on the customer's payment method without moving any funds. Only a
 * driver that also implements SupportsCaptures/SupportsVoids can do
 * anything with the resulting hold afterward; implementing this alone
 * with neither of those would leave the hold to simply expire
 * (typically ~7 days, gateway-dependent) with no way to settle or release
 * it early.
 *
 * A driver capable of both authorize-then-settle AND an atomic charge
 * (most card gateways) implements this alongside SupportsPay — which one
 * gets called for a given payment attempt is the CALLER's choice (a
 * policy decision), not something this driver decides for itself.
 *
 * Dispatches Modules\Core\Payment\Events\PaymentAuthorized or
 * PaymentAuthorizationFailed based on the returned PaymentResult's status,
 * unless $result->status is Pending — see SupportsPay's docblock for the
 * same async-resolution note.
 */
 interface SupportsAuthorization
 {
    /**
     * Same $type/$amount/$data/$context reasoning as SupportsPay::pay().
     *
     * @param  array<string, mixed>  $data
     * @param  array<string, mixed>  $context
     */
    public function authorize(string $type, Price $amount, array $data = [], array $context = []): PaymentResult;
 }
@@ -0,0 +1,39 @@
 <?php
 namespace Modules\Core\Payment\Contracts;
 use Lunar\DataTypes\Price;
 use Modules\Core\Payment\DTOs\PaymentResult;
 /**
 * Settles a PRIOR SupportsAuthorization::authorize() hold — only ever
 * valid against a reference that call (or a HandlesPaymentCallback
 * resolving it) produced, never called standalone. A driver with no
 * authorize-then-settle model at all (most redirect/wallet gateways, any
 * offline driver) never implements this — it settles everything through
 * SupportsPay::pay() in one step instead.
 *
 * Dispatches Modules\Core\Payment\Events\PaymentCaptured or
 * PaymentCaptureFailed — the same terminal events SupportsPay::pay()
 * produces, since "money has been captured" is the same business fact
 * regardless of which path reached it.
 */
 interface SupportsCaptures
 {
    /**
     * $reference is the identifier SupportsAuthorization::authorize()
     * returned (PaymentResult::$reference) for the hold being settled.
     *
     * $amount is Lunar's own Price (never a gateway's own minor-unit
     * scale — see PaymentResult's docblock), and lets a driver capture
     * less than the full authorized amount (e.g. shipping less than
     * ordered) — up to the driver/gateway whether a partial capture also
     * releases the remainder or leaves it capturable again later
     * (multicapture-style gateways). Required explicitly, not derived by
     * the driver from a live gateway lookup — the caller (whatever placed
     * the original authorize() call) already knows it.
     *
     * @param  array<string, mixed>  $context
     */
    public function capture(string $reference, Price $amount, array $context = []): PaymentResult;
 }
@@ -0,0 +1,52 @@
 <?php
 namespace Modules\Core\Payment\Contracts;
 use Lunar\DataTypes\Price;
 use Modules\Core\Payment\DTOs\PaymentResult;
 /**
 * A driver's atomic charge — authorize and capture in one gateway call
 * (Mastercard's own "Pay" operation, Nexi's ActionType::PAY(), Stripe's
 * capture_method=automatic, or an offline driver with no gateway at all).
 * Distinct from SupportsAuthorization: a driver that only ever settles in
 * one step implements this and nothing else — there is no separate hold
 * to later capture() or void().
 *
 * Dispatches Modules\Core\Payment\Events\PaymentCaptured or
 * PaymentCaptureFailed based on the returned PaymentResult's status,
 * unless $result->status is Pending (an async gateway that hasn't
 * resolved yet — see HandlesPaymentCallback for how that gets resolved
 * later, from a separate call this method's return value does not wait
 * on).
 */
 interface SupportsPay
 {
    /**
     * $type is the payment type key being charged (e.g. 'cash-on-delivery',
     * 'stripe') — passed through even though most drivers only ever serve
     * one type, because a driver shared across several types needs it to
     * look up that type's own config.
     *
     * $amount is required, not optional data a caller might omit — there
     * is no way to process a payment without knowing what to charge.
     * Lunar's own Price (bundling its own currency) — the same money
     * representation every other Payment contract method takes/returns,
     * see PaymentResult's own docblock.
     *
     * $data carries whatever ELSE the gateway needs (customer details, a
     * payment method token) — the caller's responsibility to assemble,
     * since a driver has no notion of a cart or order to pull them from
     * itself.
     *
     * $context is opaque to the driver — carried through untouched into
     * whichever Payment event this call (or a later handleCallback()
     * resolving it) produces, so the caller can correlate the result back
     * to whatever it needs, without Payment ever needing to know what
     * that is.
     *
     * @param  array<string, mixed>  $data
     * @param  array<string, mixed>  $context
     */
    public function pay(string $type, Price $amount, array $data = [], array $context = []): PaymentResult;
 }
@@ -0,0 +1,35 @@
 <?php
 namespace Modules\Core\Payment\Contracts;
 use Lunar\DataTypes\Price;
 use Modules\Core\Payment\DTOs\PaymentResult;
 /**
 * Reverses settled funds — independent of SupportsCaptures/SupportsVoids:
 * a driver that only ever settles via SupportsPay::pay() (no separate
 * authorize step) can still implement this, since a refund targets money
 * already taken regardless of how it got taken. A driver implements this
 * whenever its gateway exposes any refund capability at all, whether or
 * not it also supports authorize-then-capture.
 *
 * Dispatches Modules\Core\Payment\Events\PaymentRefunded or
 * PaymentRefundFailed.
 */
 interface SupportsRefunds
 {
    /**
     * $reference is the identifier the original SupportsPay::pay() or
     * SupportsCaptures::capture() call returned for the settled funds
     * being refunded.
     *
     * $amount is Lunar's own Price (never a gateway's own minor-unit
     * scale — see PaymentResult's docblock), allowing a partial refund; a
     * gateway may allow multiple partial refunds against one settlement,
     * up to its own total. Required explicitly, same reasoning as
     * SupportsCaptures::capture()'s own $amount.
     *
     * @param  array<string, mixed>  $context
     */
    public function refund(string $reference, Price $amount, array $context = []): PaymentResult;
 }
@@ -0,0 +1,35 @@
 <?php
 namespace Modules\Core\Payment\Contracts;
 use Lunar\DataTypes\Price;
 use Modules\Core\Payment\DTOs\PaymentResult;
 /**
 * Cancels a PRIOR SupportsAuthorization::authorize() hold WITHOUT
 * settling it — the "actually, never mind" exit SupportsCaptures::capture()
 * doesn't take. No funds ever moved, so this is not a refund: there is
 * nothing to give back, only a hold to release early (rather than letting
 * it simply expire on its own).
 *
 * Dispatches Modules\Core\Payment\Events\PaymentVoided or
 * PaymentVoidFailed.
 */
 interface SupportsVoids
 {
    /**
     * $reference is the identifier SupportsAuthorization::authorize()
     * returned for the hold being released.
     *
     * $amount is the authorized amount being released — Lunar's own
     * Price, same as every other Payment contract method (see
     * PaymentResult's own docblock). Required explicitly: the caller
     * (whatever placed the original authorize() call) already knows it,
     * same reasoning as SupportsCaptures::capture()'s own $amount — a
     * driver shouldn't need a live gateway lookup just to know what it's
     * releasing.
     *
     * @param  array<string, mixed>  $context
     */
    public function void(string $reference, Price $amount, array $context = []): PaymentResult;
 }
@@ -0,0 +1,20 @@
 <?php
 namespace Modules\Core\Payment\DTOs;
 use Modules\Core\Payment\Enums\PaymentContinuationType;
 /**
 * What a caller does next with a Pending PaymentResult, gateway-agnostic —
 * see PaymentContinuationType for the two shapes. Deliberately minimal:
 * this is NOT a return to the deleted PaymentInitiation DTO (which also
 * carried mode/reference/meta) — reference already lives on PaymentResult
 * itself, and mode is now this DTO's own $type.
 */
 final class PaymentContinuation
 {
    public function __construct(
        public readonly PaymentContinuationType $type,
        public readonly string $value,
    ) {}
 }
@@ -0,0 +1,66 @@
 <?php
 namespace Modules\Core\Payment\DTOs;
 use Lunar\DataTypes\Price;
 use Modules\Core\Payment\Enums\PaymentResultStatus;
 /**
 * The one shape every Payment operation (pay, authorize, capture, void,
 * refund, handleCallback) returns, regardless of driver — a caller never
 * writes gateway-specific branching to read the outcome.
 *
 * Deliberately not one-size-fits-all in richness underneath: a gateway's
 * own response can be as sparse as Nexi's capture (just an operation id +
 * timestamp, no echoed amount or status) or as rich as Stripe's
 * PaymentIntent (status, amounts, decline classification, full error
 * detail). $status/$reference/$amount are the only fields every driver can
 * always populate — $amount from what WE requested, not necessarily
 * echoed by the gateway. Everything else is best-effort normalization;
 * $raw is the unconditional escape hatch for genuine audit fidelity
 * (the untouched gateway response), so nothing is ever lost even when a
 * gateway has no field to normalize into $failureReason/$retriable.
 */
 final class PaymentResult
 {
    /**
     * @param  $amount  Lunar's own money type (Lunar\DataTypes\Price —
     *   integer minor units bundled with its Currency), the SAME
     *   representation every contract method takes/returns — never a
     *   gateway's own minor-unit scale. Each driver converts at its own
     *   boundary (e.g. StripeManager::toStripeAmount()/fromStripeAmount())
     *   before calling out to, or after reading back from, its gateway —
     *   Payment itself only ever speaks Lunar's Price.
     * @param  $failureReason  a human-readable reason, only meaningful
     *   when $status is Failed — the driver's own normalization of
     *   whatever the gateway called it (Stripe's decline_code message,
     *   Nexi's ErrorsInner::$description, ...).
     * @param  $retriable  whether the caller should offer "try again" with
     *   the SAME payment method, vs. "use a different one" — real,
     *   gateway-native distinction on Stripe (decline_code soft/hard) and
     *   Mastercard (merchantAdviceCode / scheme soft-decline codes), but
     *   Nexi's OperationResult has no such signal at all. Defaults to
     *   false (assume not safely retriable) rather than guessing when a
     *   driver's gateway has no such classification.
     * @param  $raw  the untouched gateway response body — always
     *   populated, even when the gateway's own fields were too sparse to
     *   normalize into anything above.
     * @param  $meta  driver-specific extras that don't fit the normalized
     *   fields above (e.g. a card's last four digits).
     * @param  $continuation  only meaningful when $status is Pending —
     *   what the caller does next (a redirect URL, a client secret for
     *   frontend JS), gateway-agnostic. Null for every other status, and
     *   for any driver whose pay()/authorize() never returns Pending
     *   (e.g. OfflinePaymentDriver).
     */
    public function __construct(
        public readonly PaymentResultStatus $status,
        public readonly string $reference,
        public readonly Price $amount,
        public readonly ?string $failureReason = null,
        public readonly bool $retriable = false,
        public readonly array $raw = [],
        public readonly array $meta = [],
        public readonly ?PaymentContinuation $continuation = null,
    ) {}
 }
@@ -2,35 +2,28 @@
 namespace Modules\Core\Payment\Drivers;
-use Lunar\Exceptions\Carts\CartException;
+use Illuminate\Support\Str;
-use Lunar\Exceptions\DisallowMultipleCartOrdersException;
+use Lunar\DataTypes\Price;
-use Lunar\Exceptions\FingerprintMismatchException;
+use Modules\Core\Payment\Contracts\Configurable;
-use Lunar\Models\Cart;
+use Modules\Core\Payment\Contracts\SupportsPay;
-use Lunar\Models\Order;
+use Modules\Core\Payment\DTOs\PaymentResult;
-use Modules\Core\Checkout\Contracts\PaymentDriver;
+use Modules\Core\Payment\Enums\PaymentResultStatus;
-use Modules\Core\Checkout\Services\CheckoutService;
+use Modules\Core\Payment\Events\PaymentCaptured;
 /**
 * Shared by every payment type with no real gateway to confirm against —
 * cash-in-hand, cash-on-delivery — where the shopper pays at pickup/on
- * delivery, not at checkout. confirm() has nothing to wait on, so it places
+ * delivery, not at checkout. There is no separate hold-then-settle model
- * the order immediately, same as Lunar's own OfflinePayment would, but
+ * (SupportsAuthorization/SupportsCaptures/SupportsVoids) and no async
- * through CheckoutService::placeOrder() so it goes through the same
+ * resolution (HandlesPaymentCallback) — pay() decides success immediately
- * fingerprint check every other driver does. $data is unused: nothing about
+ * and dispatches PaymentCaptured before returning.
 * this confirmation depends on gateway-specific payload.
 *
- * Sets the order status to config("lunar.payments.types.{$type}.authorized")
+ * $reference is generated here (not supplied by a gateway, since there is
- * afterward, using the type actually confirmed — not a hardcoded key —
+ * none) purely so PaymentCaptured, and anything downstream keying on it,
- * since this one driver is shared across multiple types.
+ * have something to identify this attempt by.
 * placeOrder() itself leaves the order at Lunar's configured draft_status,
 * same as every driver is responsible for moving it on from.
 */
-class OfflinePaymentDriver implements PaymentDriver
+class OfflinePaymentDriver implements Configurable, SupportsPay
 {
    public function __construct(
        private readonly CheckoutService $checkout,
    ) {}
    /**
     * Always true — no external dependency to be missing.
     */
@@ -39,19 +32,18 @@ class OfflinePaymentDriver implements PaymentDriver
        return true;
    }
-    /**
+    public function pay(string $type, Price $amount, array $data = [], array $context = []): PaymentResult
     * @throws FingerprintMismatchException
     * @throws CartException
     * @throws DisallowMultipleCartOrdersException
     */
    public function confirm(Cart $cart, string $type, string $fingerprint, array $data): Order
    {
-        $order = $this->checkout->placeOrder($fingerprint);
+        $reference = 'offline-'.Str::uuid();
-        $order->update([
+        $result = new PaymentResult(
-            'status' => config("lunar.payments.types.{$type}.authorized", $order->status),
+            status: PaymentResultStatus::Succeeded,
-        ]);
+            reference: $reference,
            amount: $amount,
        );
-        return $order->refresh();
+        PaymentCaptured::dispatch($type, $result, $context);
        return $result;
    }
-}
+}
@@ -2,43 +2,69 @@
 namespace Modules\Core\Payment\Drivers;
-use Lunar\Exceptions\FingerprintMismatchException;
+use Lunar\DataTypes\Price;
-use Lunar\Exceptions\Carts\CartException;
+use Lunar\Models\Currency;
 use Lunar\Exceptions\DisallowMultipleCartOrdersException;
 use Lunar\Models\Cart;
 use Lunar\Models\Order;
 use Lunar\Stripe\Actions\UpdateOrderFromIntent;
 use Lunar\Stripe\Facades\Stripe;
 use Lunar\Stripe\Managers\StripeManager;
 use Lunar\Stripe\Models\StripePaymentIntent;
-use Modules\Core\Checkout\Contracts\PaymentDriver;
+use Modules\Core\Payment\Contracts\Configurable;
-use Modules\Core\Checkout\Services\CheckoutService;
+use Modules\Core\Payment\Contracts\HandlesPaymentCallback;
-use Modules\Core\Payment\Exceptions\PaymentNotConfirmedException;
+use Modules\Core\Payment\Contracts\SupportsAuthorization;
 use Modules\Core\Payment\Contracts\SupportsCaptures;
 use Modules\Core\Payment\Contracts\SupportsPay;
 use Modules\Core\Payment\Contracts\SupportsRefunds;
 use Modules\Core\Payment\Contracts\SupportsVoids;
 use Modules\Core\Payment\DTOs\PaymentContinuation;
 use Modules\Core\Payment\DTOs\PaymentResult;
 use Modules\Core\Payment\Enums\PaymentContinuationType;
 use Modules\Core\Payment\Enums\PaymentResultStatus;
 use Modules\Core\Payment\Events\PaymentAuthorizationFailed;
 use Modules\Core\Payment\Events\PaymentAuthorized;
 use Modules\Core\Payment\Events\PaymentCaptureFailed;
 use Modules\Core\Payment\Events\PaymentCaptured;
 use Modules\Core\Payment\Events\PaymentRefundFailed;
 use Modules\Core\Payment\Events\PaymentRefunded;
 use Modules\Core\Payment\Events\PaymentVoidFailed;
 use Modules\Core\Payment\Events\PaymentVoided;
 use Stripe\Exception\ApiErrorException;
 use Stripe\PaymentIntent;
 /**
- * Wraps Lunar\Stripe\StripePaymentType::authorize() to satisfy
+ * Talks to Stripe's PaymentIntent API directly — deliberately NOT via
- * Modules\Core\Checkout\Contracts\PaymentDriver — calls
+ * Lunar\Stripe\Facades\Stripe::createIntent()/fetchOrCreateIntent(), which
- * CheckoutService::placeOrder($fingerprint) at the moment Stripe confirms
+ * take a Lunar\Models\Cart and derive amount/currency from it. Payment
- * payment, instead of the vendor's own Cart::createOrder() call.
+ * must never receive a Cart (see docs/payments.md) — pay()/authorize()
 * already receive $amount explicitly as their own required Lunar Price
 * parameter (see PaymentResult's own docblock), the caller's job to
 * assemble, same as every other driver.
 *
- * This is a fork, not a decoration: StripePaymentType::authorize() is
+ * Every amount that crosses this class's own boundary is converted right
- * `final` and calls Cart::createOrder() directly with no seam to redirect
+ * there: Lunar's Price -> Stripe's minor-unit int going INTO a gateway
- * that one call — so this class reimplements authorize()'s logic (intent
+ * call (StripeManager::toStripeAmount()), Stripe's response amount ->
- * retrieval, capture-on-policy, status mapping via UpdateOrderFromIntent)
+ * Lunar's Price coming back OUT (StripeManager::fromStripeAmount()).
- * rather than wrapping the vendor method. Kept deliberately close to the
+ * Nothing outside this class ever sees a Stripe-scaled integer.
- * original so a lunarphp/stripe upgrade is easy to diff against. See
+ *
- * docs/payments.md.
+ * Correlating a later handleCallback() (a separate request — a webhook)
 * back to whatever $context identified this attempt is solved the same
 * way lunarphp/stripe's own StripePaymentType/ProcessStripeWebhook solve
 * it: real cart_id/order_id columns on Lunar\Stripe\Models\
 * StripePaymentIntent (a table already owned by lunarphp/stripe, already
 * shaped for exactly this), not a generic context blob. See
 * docs/payments.md "Async resolution" for the full reasoning.
 */
-class StripePaymentDriver implements PaymentDriver
+class StripePaymentDriver implements
    Configurable,
    SupportsPay,
    SupportsAuthorization,
    SupportsCaptures,
    SupportsVoids,
    SupportsRefunds,
    HandlesPaymentCallback
 {
    public function __construct(
        private readonly CheckoutService $checkout,
    ) {}
    /**
     * Same key lunarphp/stripe's own StripeManager reads its API key from
-     * (Stripe::setApiKey(config('services.stripe.key')) in
+     * (Stripe::setApiKey(config('services.stripe.key'))) — no key, no
-     * StripeManager::__construct()) — no key, no usable driver.
+     * usable driver.
     */
    public function isConfigured(): bool
    {
@@ -46,66 +72,312 @@ class StripePaymentDriver implements PaymentDriver
    }
    /**
-     * @throws PaymentNotConfirmedException if Stripe hasn't confirmed the
+     * Atomic charge — capture_method: automatic. Stripe still frequently
-     *   payment intent (wrong intent id, already processed, order already
+     * confirms into requires_action/requires_confirmation rather than
-     *   placed, or the gateway call itself fails) — nothing here should be
+     * succeeded in the same call (3-D Secure, most real cards) — Pending
-     *   treated as "place the order anyway."
+     * is a normal outcome here, not an edge case, resolved later via
-     * @throws FingerprintMismatchException
+     * handleCallback().
     * @throws CartException
     */
-    public function confirm(Cart $cart, string $type, string $fingerprint, array $data): Order
+    public function pay(string $type, Price $amount, array $data = [], array $context = []): PaymentResult
    {
-        $paymentIntentId = $data['payment_intent'];
+        return $this->createAndConfirm($type, $amount, $data, $context, captureMethod: 'automatic');
    }
-        $paymentIntentModel = StripePaymentIntent::where('intent_id', $paymentIntentId)->first();
+    /**
     * Hold only — capture_method: manual. Resolves to Pending or an
     * authorized (requires_capture) intent, never succeeded directly:
     * Stripe never captures on its own for a manual intent.
     */
    public function authorize(string $type, Price $amount, array $data = [], array $context = []): PaymentResult
    {
        return $this->createAndConfirm($type, $amount, $data, $context, captureMethod: 'manual');
    }
-        if ($paymentIntentModel && ! $paymentIntentModel->isActive()) {
+    private function createAndConfirm(string $type, Price $amount, array $data, array $context, string $captureMethod): PaymentResult
-            throw new PaymentNotConfirmedException('Payment intent already processed.');
+    {
-        }
+        try {
-
+            $paymentIntent = Stripe::getClient()->paymentIntents->create([
-        if (! $paymentIntentModel) {
+                'amount' => StripeManager::toStripeAmount($amount->value, $amount->currency),
-            $paymentIntentModel = StripePaymentIntent::create([
+                'currency' => $amount->currency->code,
-                'intent_id' => $paymentIntentId,
+                'capture_method' => $captureMethod,
-                'cart_id' => $cart->id,
+                'confirm' => true,
                'payment_method' => $data['payment_method'] ?? null,
                'automatic_payment_methods' => isset($data['payment_method'])
                    ? null
                    : ['enabled' => true],
            ]);
        } catch (ApiErrorException $e) {
            return $this->declined($type, $amount, $e, $context, authorizing: $captureMethod === 'manual');
        }
-        $paymentIntentModel->update(['processing_at' => now()]);
+        $this->rememberIntent($paymentIntent, $type, $context);
-        $stripe = Stripe::getClient();
+        return $this->resultFromIntent($type, $paymentIntent, $amount, $context, authorizing: $captureMethod === 'manual');
-        $paymentIntent = $stripe->paymentIntents->retrieve($paymentIntentId);
+    }
-        if (! $paymentIntent) {
+    public function handleCallback(string $reference, array $data, array $context = []): PaymentResult
-            throw new PaymentNotConfirmedException('Unable to locate payment intent.');
+    {
        [$intentModel, $type, $context] = $this->resolveIntentModel($reference, $context, $data['type'] ?? '');
        $paymentIntent = Stripe::getClient()->paymentIntents->retrieve($reference);
        $authorizing = $paymentIntent->capture_method === PaymentIntent::CAPTURE_METHOD_MANUAL;
        if ($paymentIntent->status === PaymentIntent::STATUS_REQUIRES_CAPTURE && ! $authorizing) {
            // automatic capture_method, but Stripe stopped short of
            // capturing (rare, but the API contract allows it) — finish
            // the job pay() started.
            $paymentIntent = Stripe::getClient()->paymentIntents->capture($reference);
        }
-        $policy = config('lunar.stripe.policy', 'automatic');
+        $intentModel?->update(['status' => $paymentIntent->status]);
-        if ($paymentIntent->status === PaymentIntent::STATUS_REQUIRES_CAPTURE && $policy === 'automatic') {
+        $amount = $this->priceFromIntent($paymentIntent);
            $paymentIntent = $stripe->paymentIntents->capture($paymentIntentId);
        }
-        if ($paymentIntent->status !== PaymentIntent::STATUS_SUCCEEDED) {
+        return $this->resultFromIntent($type, $paymentIntent, $amount, $context, $authorizing);
-            $paymentIntentModel->update(['status' => $paymentIntent->status]);
+    }
-            throw new PaymentNotConfirmedException(
+    public function capture(string $reference, Price $amount, array $context = []): PaymentResult
-                $paymentIntent->last_payment_error->message ?? "Payment intent status: {$paymentIntent->status}."
+    {
-            );
+        [$intentModel, $type, $context] = $this->resolveIntentModel($reference, $context);
        }
        try {
-            $order = $this->checkout->placeOrder($fingerprint);
+            $paymentIntent = Stripe::getClient()->paymentIntents->capture($reference, [
-        } catch (DisallowMultipleCartOrdersException|CartException $e) {
+                'amount_to_capture' => StripeManager::toStripeAmount($amount->value, $amount->currency),
-            throw new PaymentNotConfirmedException($e->getMessage(), previous: $e);
+            ]);
        } catch (ApiErrorException $e) {
            $result = $this->failure($amount, $e, $reference);
            PaymentCaptureFailed::dispatch($type, $result, $context);
            return $result;
        }
-        $paymentIntentModel->order_id = $order->id;
+        $intentModel?->update(['status' => $paymentIntent->status]);
        $paymentIntentModel->status = $paymentIntent->status;
        $paymentIntentModel->processed_at = now();
        $paymentIntentModel->save();
-        UpdateOrderFromIntent::execute($order, $paymentIntent);
+        $result = new PaymentResult(
            status: $paymentIntent->status === PaymentIntent::STATUS_SUCCEEDED
                ? PaymentResultStatus::Succeeded
                : PaymentResultStatus::Failed,
            reference: $paymentIntent->id,
            amount: $amount,
            raw: $paymentIntent->toArray(),
        );
-        return $order->refresh();
+        $paymentIntent->status === PaymentIntent::STATUS_SUCCEEDED
            ? PaymentCaptured::dispatch($type, $result, $context)
            : PaymentCaptureFailed::dispatch($type, $result, $context);
        return $result;
    }
    public function void(string $reference, Price $amount, array $context = []): PaymentResult
    {
        [$intentModel, $type, $context] = $this->resolveIntentModel($reference, $context);
        try {
            $paymentIntent = Stripe::getClient()->paymentIntents->cancel($reference);
        } catch (ApiErrorException $e) {
            $result = $this->failure($amount, $e, $reference);
            PaymentVoidFailed::dispatch($type, $result, $context);
            return $result;
        }
        $intentModel?->update(['status' => $paymentIntent->status]);
        $result = new PaymentResult(
            status: $paymentIntent->status === PaymentIntent::STATUS_CANCELED
                ? PaymentResultStatus::Succeeded
                : PaymentResultStatus::Failed,
            reference: $paymentIntent->id,
            amount: $amount,
            raw: $paymentIntent->toArray(),
        );
        $paymentIntent->status === PaymentIntent::STATUS_CANCELED
            ? PaymentVoided::dispatch($type, $result, $context)
            : PaymentVoidFailed::dispatch($type, $result, $context);
        return $result;
    }
    public function refund(string $reference, Price $amount, array $context = []): PaymentResult
    {
        [$intentModel, $type, $context] = $this->resolveIntentModel($reference, $context);
        try {
            $refund = Stripe::getClient()->refunds->create([
                'payment_intent' => $reference,
                'amount' => StripeManager::toStripeAmount($amount->value, $amount->currency),
            ]);
        } catch (ApiErrorException $e) {
            $result = $this->failure($amount, $e, $reference);
            PaymentRefundFailed::dispatch($type, $result, $context);
            return $result;
        }
        $result = new PaymentResult(
            status: $refund->status !== 'failed' ? PaymentResultStatus::Succeeded : PaymentResultStatus::Failed,
            reference: $refund->id,
            amount: $amount,
            raw: $refund->toArray(),
        );
        $refund->status !== 'failed'
            ? PaymentRefunded::dispatch($type, $result, $context)
            : PaymentRefundFailed::dispatch($type, $result, $context);
        return $result;
    }
    private function rememberIntent(PaymentIntent $paymentIntent, string $type, array $context): ?StripePaymentIntent
    {
        if (! ($context['cart_id'] ?? null)) {
            return null;
        }
        return StripePaymentIntent::create([
            'intent_id' => $paymentIntent->id,
            'cart_id' => $context['cart_id'],
            'order_id' => $context['order_id'] ?? null,
            'status' => $paymentIntent->status,
            'payment_type' => $type,
            'context' => json_encode($context),
        ]);
    }
    /**
     * The one lookup every method past initiate() shares: find the
     * StripePaymentIntent row this $reference belongs to, then recover
     * $type/$context from it — the original context, if any, always
     * takes precedence over whatever the caller passed in (see
     * handleCallback()'s own note: a webhook caller usually has none of
     * its own).
     *
     * $typeFallback only matters when there's no $intentModel to read
     * payment_type from — handleCallback() has its own $data['type'] to
     * fall back to; capture()/void()/refund() have nothing better than ''.
     *
     * @return array{0: ?StripePaymentIntent, 1: string, 2: array<string, mixed>}
     */
    private function resolveIntentModel(string $reference, array $context, string $typeFallback = ''): array
    {
        $intentModel = StripePaymentIntent::where('intent_id', $reference)->first();
        return [
            $intentModel,
            $intentModel?->payment_type ?? $typeFallback,
            $this->decodeContext($intentModel) ?? $context,
        ];
    }
    /**
     * StripePaymentIntent is a vendor model (lunarphp/stripe) with no cast
     * declared for our own 'context' column (added by boboko-core's own
     * migration, see database/migrations/..._add_context_to_stripe_
     * payment_intents.php) — we can't edit the vendor model to add one, so
     * decode manually here instead of assuming Eloquent already did it.
     *
     * @return array<string, mixed>|null
     */
    private function decodeContext(?StripePaymentIntent $intentModel): ?array
    {
        if (! $intentModel || ! $intentModel->context) {
            return null;
        }
        return json_decode($intentModel->context, associative: true) ?: null;
    }
    /**
     * Converts a live Stripe PaymentIntent's own amount/currency back
     * into Lunar's Price — the one place this class reads a Stripe
     * response's amount without already holding the Price that produced
     * it (handleCallback() has no $data['amount'] to fall back on, unlike
     * pay()/authorize()).
     */
    private function priceFromIntent(PaymentIntent $paymentIntent): Price
    {
        $currency = Currency::whereRaw('lower(code) = ?', [strtolower($paymentIntent->currency)])->firstOrFail();
        return new Price(
            (int) StripeManager::fromStripeAmount($paymentIntent->amount, $currency),
            $currency,
        );
    }
    private function resultFromIntent(
        string $type,
        PaymentIntent $paymentIntent,
        Price $amount,
        array $context,
        bool $authorizing,
    ): PaymentResult {
        $status = match ($paymentIntent->status) {
            PaymentIntent::STATUS_SUCCEEDED => PaymentResultStatus::Succeeded,
            PaymentIntent::STATUS_REQUIRES_CAPTURE => $authorizing ? PaymentResultStatus::Succeeded : PaymentResultStatus::Pending,
            PaymentIntent::STATUS_CANCELED => PaymentResultStatus::Failed,
            default => PaymentResultStatus::Pending,
        };
        $continuation = $status === PaymentResultStatus::Pending
            ? new PaymentContinuation(PaymentContinuationType::ClientSecret, $paymentIntent->client_secret)
            : null;
        $result = new PaymentResult(
            status: $status,
            reference: $paymentIntent->id,
            amount: $amount,
            failureReason: $paymentIntent->last_payment_error->message ?? null,
            raw: $paymentIntent->toArray(),
            continuation: $continuation,
        );
        if ($status === PaymentResultStatus::Pending) {
            return $result;
        }
        $succeeded = $status === PaymentResultStatus::Succeeded;
        if ($authorizing) {
            $succeeded
                ? PaymentAuthorized::dispatch($type, $result, $context)
                : PaymentAuthorizationFailed::dispatch($type, $result, $context);
        } else {
            $succeeded
                ? PaymentCaptured::dispatch($type, $result, $context)
                : PaymentCaptureFailed::dispatch($type, $result, $context);
        }
        return $result;
    }
    private function declined(string $type, Price $amount, ApiErrorException $e, array $context, bool $authorizing): PaymentResult
    {
        $result = $this->failure($amount, $e);
        $authorizing
            ? PaymentAuthorizationFailed::dispatch($type, $result, $context)
            : PaymentCaptureFailed::dispatch($type, $result, $context);
        return $result;
    }
    private function failure(Price $amount, ApiErrorException $e, string $reference = ''): PaymentResult
    {
        $stripeError = $e->getError();
        return new PaymentResult(
            status: PaymentResultStatus::Failed,
            reference: $reference ?: ($stripeError->payment_intent->id ?? ''),
            amount: $amount,
            failureReason: $e->getMessage(),
            retriable: in_array($stripeError->decline_code ?? null, [
                'do_not_honor', 'insufficient_funds', 'card_velocity_exceeded',
                'processing_error', 'try_again_later', 'issuer_not_available',
            ], true),
            raw: $stripeError?->toArray() ?? [],
        );
    }
 }
@@ -0,0 +1,17 @@
 <?php
 namespace Modules\Core\Payment\Enums;
 /**
 * What a caller of a Pending PaymentResult needs to do next, gateway-
 * agnostically. Only meaningful when PaymentResult::$continuation is not
 * null (status === Pending).
 */
 enum PaymentContinuationType
 {
    /** Send the shopper to $continuation->value (a URL) — a redirect-based gateway. */
    case Redirect;
    /** Hand $continuation->value (a client secret) to frontend JS — Stripe Elements-style. */
    case ClientSecret;
 }
@@ -0,0 +1,24 @@
 <?php
 namespace Modules\Core\Payment\Enums;
 /**
 * The normalized outcome of a single gateway operation (pay, authorize,
 * capture, void, refund) — never the gateway's own raw status string
 * (Stripe's "succeeded", Nexi's "EXECUTED", Mastercard's own codes), so a
 * caller never needs gateway-specific knowledge to know what happened.
 */
 enum PaymentResultStatus
 {
    case Succeeded;
    case Failed;
    /**
     * The gateway hasn't resolved this operation yet and won't in the same
     * call — e.g. Stripe's requires_action, a redirect the shopper hasn't
     * completed. A driver returning this from initiate()/handleCallback()
     * has not yet dispatched a terminal event; something else (a later
     * callback) is expected to resolve it.
     */
    case Pending;
 }
@@ -0,0 +1,27 @@
 <?php
 namespace Modules\Core\Payment\Events;
 use Illuminate\Foundation\Events\Dispatchable;
 use Modules\Core\Payment\DTOs\PaymentResult;
 /**
 * Dispatched when SupportsAuthorization::authorize() (or a
 * HandlesPaymentCallback::handleCallback() resolving it later) determines
 * the gateway did not grant the requested hold. $result->retriable is how
 * a listener knows whether "try again with the same method" is reasonable
 * — see PaymentResult's own docblock.
 */
 class PaymentAuthorizationFailed
 {
    use Dispatchable;
    /**
     * @param  array<string, mixed>  $context
     */
    public function __construct(
        public readonly string $type,
        public readonly PaymentResult $result,
        public readonly array $context = [],
    ) {}
 }
@@ -0,0 +1,32 @@
 <?php
 namespace Modules\Core\Payment\Events;
 use Illuminate\Foundation\Events\Dispatchable;
 use Modules\Core\Payment\DTOs\PaymentResult;
 /**
 * Dispatched by a driver's SupportsAuthorization::authorize() (or, for an
 * async gateway, HandlesPaymentCallback::handleCallback() resolving that
 * same authorize() call later) once a hold has been placed — no funds have
 * moved yet, see SupportsCaptures/SupportsVoids for what happens next.
 *
 * Carries $result (the full PaymentResult, not just a reference) plus
 * $type and $context — same reasoning throughout Payment's events: Payment
 * has no concept of a cart, an order, or a checkout fingerprint, so
 * whatever a listener needs to react travels through $context untouched,
 * opaque to Payment itself.
 */
 class PaymentAuthorized
 {
    use Dispatchable;
    /**
     * @param  array<string, mixed>  $context
     */
    public function __construct(
        public readonly string $type,
        public readonly PaymentResult $result,
        public readonly array $context = [],
    ) {}
 }
@@ -0,0 +1,29 @@
 <?php
 namespace Modules\Core\Payment\Events;
 use Illuminate\Foundation\Events\Dispatchable;
 use Modules\Core\Payment\DTOs\PaymentResult;
 /**
 * Dispatched when SupportsPay::pay() or SupportsCaptures::capture() (or a
 * HandlesPaymentCallback::handleCallback() resolving either later) fails
 * to take the money — whether that's a sale-mode gateway declining the
 * charge outright, or a capture call against an existing authorization
 * being rejected. Same terminal-event symmetry as PaymentCaptured: this is
 * the one "capture attempt failed" event regardless of which path
 * produced it.
 */
 class PaymentCaptureFailed
 {
    use Dispatchable;
    /**
     * @param  array<string, mixed>  $context
     */
    public function __construct(
        public readonly string $type,
        public readonly PaymentResult $result,
        public readonly array $context = [],
    ) {}
 }
@@ -0,0 +1,31 @@
 <?php
 namespace Modules\Core\Payment\Events;
 use Illuminate\Foundation\Events\Dispatchable;
 use Modules\Core\Payment\DTOs\PaymentResult;
 /**
 * The one "money has actually been taken" event, dispatched from either of
 * two different call paths that end at the same business fact:
 *   - SupportsPay::pay() — an atomic authorize+capture gateway call
 *     (Mastercard's "Pay", Stripe's capture_method=automatic, an offline
 *     driver's immediate success).
 *   - SupportsCaptures::capture() — settling a PRIOR authorize() hold.
 * Whether the money moved in one gateway call or two is a driver-internal
 * detail; a listener reacting to "a payment has been captured" never
 * needs to know or care which path produced this event.
 */
 class PaymentCaptured
 {
    use Dispatchable;
    /**
     * @param  array<string, mixed>  $context
     */
    public function __construct(
        public readonly string $type,
        public readonly PaymentResult $result,
        public readonly array $context = [],
    ) {}
 }
@@ -0,0 +1,24 @@
 <?php
 namespace Modules\Core\Payment\Events;
 use Illuminate\Foundation\Events\Dispatchable;
 use Modules\Core\Payment\DTOs\PaymentResult;
 /**
 * Dispatched when SupportsRefunds::refund() fails to return settled funds
 * — e.g. the gateway rejects refunding more than was originally captured.
 */
 class PaymentRefundFailed
 {
    use Dispatchable;
    /**
     * @param  array<string, mixed>  $context
     */
    public function __construct(
        public readonly string $type,
        public readonly PaymentResult $result,
        public readonly array $context = [],
    ) {}
 }
@@ -0,0 +1,27 @@
 <?php
 namespace Modules\Core\Payment\Events;
 use Illuminate\Foundation\Events\Dispatchable;
 use Modules\Core\Payment\DTOs\PaymentResult;
 /**
 * Dispatched by SupportsRefunds::refund() once settled funds (from a prior
 * pay() or capture()) have actually been returned — full or partial.
 * Independent of whether the original settlement was a sale or an
 * authorize-then-capture: a refund only ever targets money that was
 * genuinely taken, regardless of how it got taken.
 */
 class PaymentRefunded
 {
    use Dispatchable;
    /**
     * @param  array<string, mixed>  $context
     */
    public function __construct(
        public readonly string $type,
        public readonly PaymentResult $result,
        public readonly array $context = [],
    ) {}
 }
@@ -0,0 +1,25 @@
 <?php
 namespace Modules\Core\Payment\Events;
 use Illuminate\Foundation\Events\Dispatchable;
 use Modules\Core\Payment\DTOs\PaymentResult;
 /**
 * Dispatched when SupportsVoids::void() fails to release a prior
 * authorization — e.g. the hold already expired or was already captured,
 * so there was nothing left to void.
 */
 class PaymentVoidFailed
 {
    use Dispatchable;
    /**
     * @param  array<string, mixed>  $context
     */
    public function __construct(
        public readonly string $type,
        public readonly PaymentResult $result,
        public readonly array $context = [],
    ) {}
 }
@@ -0,0 +1,27 @@
 <?php
 namespace Modules\Core\Payment\Events;
 use Illuminate\Foundation\Events\Dispatchable;
 use Modules\Core\Payment\DTOs\PaymentResult;
 /**
 * Dispatched by SupportsVoids::void() once a prior authorization hold has
 * been released without ever settling — the "actually, never mind" exit
 * from an authorize() that SupportsCaptures::capture() would otherwise
 * have settled. No funds ever moved, so this is distinct from
 * PaymentRefunded (which reverses money that was actually taken).
 */
 class PaymentVoided
 {
    use Dispatchable;
    /**
     * @param  array<string, mixed>  $context
     */
    public function __construct(
        public readonly string $type,
        public readonly PaymentResult $result,
        public readonly array $context = [],
    ) {}
 }
@@ -1,22 +0,0 @@
 <?php
 namespace Modules\Core\Payment\Exceptions;
 use RuntimeException;
 use Throwable;
 /**
 * Thrown by a Modules\Core\Checkout\Contracts\PaymentDriver when the
 * gateway has not confirmed payment — wrong/expired intent, already
 * processed, or the gateway itself rejects the confirmation. A driver
 * throws this instead of silently placing the order: CheckoutService::
 * placeOrder() must only ever be called once a driver has positively
 * confirmed payment, never as a fallback.
 */
 class PaymentNotConfirmedException extends RuntimeException
 {
    public function __construct(string $message, ?Throwable $previous = null)
    {
        parent::__construct($message, previous: $previous);
    }
 }
@@ -0,0 +1,46 @@
 <?php
 namespace Modules\Core\Payment\Http\Controllers;
 use Illuminate\Http\JsonResponse;
 use Illuminate\Http\Request;
 use Illuminate\Routing\Controller;
 use Modules\Core\Payment\Drivers\StripePaymentDriver;
 use Stripe\Webhook;
 /**
 * A boboko-owned webhook endpoint for Stripe — deliberately NOT
 * lunarphp/stripe's own route (vendor/lunarphp/stripe/routes/webhooks.php),
 * which dispatches into Lunar's own Payments::driver('stripe') flow (the
 * flow StripePaymentDriver was built to replace, see that class's own
 * docblock). Signature verification is handled by
 * Lunar\Stripe\Http\Middleware\StripeWebhookMiddleware, registered on this
 * route (see src/Payment/routes/webhooks.php) — pure Stripe SDK
 * verification + event-type filtering, safe to reuse even though this
 * controller never touches the rest of that vendor package's flow. This
 * controller verifies the signature again itself (Webhook::constructEvent())
 * to get the constructed Event object — the middleware doesn't stash one
 * anywhere reusable, it only gates the request through.
 *
 * Resolves the driver directly by class, not via
 * Modules\Core\Payment\Services\PaymentDriverResolver — this endpoint is
 * inherently Stripe-specific (Stripe's own webhook payload carries no
 * boboko payment-type key, only its own payment_intent id), and
 * StripePaymentDriver::handleCallback() already recovers $type itself
 * from the StripePaymentIntent row pay()/authorize() wrote.
 */
 class StripeWebhookController extends Controller
 {
    public function __invoke(Request $request, StripePaymentDriver $driver): JsonResponse
    {
        $event = Webhook::constructEvent(
            $request->getContent(),
            $request->header('Stripe-Signature'),
            config('services.stripe.webhooks.lunar'),
        );
        $driver->handleCallback($event->data->object->id, $event->data->object->toArray());
        return response()->json(['webhook_successful' => true]);
    }
 }
@@ -0,0 +1,34 @@
 <?php
 namespace Modules\Core\Payment\Services;
 /**
 * Resolves a payment type key (e.g. 'stripe', 'cash-on-delivery') to its
 * registered driver instance — extracted out of CheckoutService so both it
 * and anything else needing the same lookup share one implementation
 * instead of duplicating this config read.
 *
 * Returns a plain object, not a shared interface — Payment's own drivers
 * implement several independent, orthogonal capability interfaces at once
 * (Configurable, SupportsPay, SupportsAuthorization, ...; see
 * StripePaymentDriver implementing all six). There is no single common
 * "PaymentDriver" contract to type this against; a caller checks
 * `instanceof SupportsPay` / `instanceof SupportsAuthorization` itself,
 * the same way Payment's own contracts are designed to be consumed.
 */
 class PaymentDriverResolver
 {
    /**
     * Null if $type has no 'payment_driver' registered in
     * config('lunar.payments.types.<type>') at all — deliberately
     * non-throwing so a caller like CheckoutService::getPaymentMethods()
     * can filter unresolvable types silently rather than treating "not
     * registered" as an error condition when just checking availability.
     */
    public function resolve(string $type): ?object
    {
        $driverClass = config("lunar.payments.types.{$type}.payment_driver");
        return $driverClass ? app($driverClass) : null;
    }
 }
@@ -0,0 +1,14 @@
 <?php
 use Illuminate\Foundation\Http\Middleware\VerifyCsrfToken;
 use Illuminate\Support\Facades\Route;
 use Lunar\Stripe\Http\Middleware\StripeWebhookMiddleware;
 use Modules\Core\Payment\Http\Controllers\StripeWebhookController;
 Route::post(
    config('payment.stripe.webhook_path', 'payments/stripe/webhook'),
    StripeWebhookController::class
 )
    ->middleware([StripeWebhookMiddleware::class, 'api'])
    ->withoutMiddleware([VerifyCsrfToken::class])
    ->name('payment.stripe.webhook');
@@ -7,7 +7,9 @@ use Illuminate\Support\ServiceProvider;
 use Lunar\Models\Order;
 use Lunar\Models\Transaction;
 use Modules\Core\Notification\NotificationRegistry;
 use Modules\Core\Order\Listeners\ApplyResolvedPaymentStatus;
 use Modules\Core\Order\Listeners\DeriveOrderDeliveredFromShipment;
 use Modules\Core\Order\Listeners\RecordPaymentTransaction;
 use Modules\Core\Order\Notifications\OrderCapturedNotification;
 use Modules\Core\Order\Notifications\OrderDeliveredNotification;
 use Modules\Core\Order\Notifications\OrderRefundedNotification;
@@ -15,6 +17,10 @@ use Modules\Core\Order\Notifications\OrderStatusUpdatedNotification;
 use Modules\Core\Order\Observers\OrderObserver;
 use Modules\Core\Order\Observers\TransactionObserver;
 use Modules\Core\Order\Support\OrderStatus;
 use Modules\Core\Payment\Events\PaymentAuthorized;
 use Modules\Core\Payment\Events\PaymentCaptured;
 use Modules\Core\Payment\Events\PaymentRefunded;
 use Modules\Core\Payment\Events\PaymentVoided;
 use Modules\Core\Shipping\Events\ShipmentStatusUpdatedByCarrier;
 class OrderServiceProvider extends ServiceProvider
@@ -28,6 +34,12 @@ class OrderServiceProvider extends ServiceProvider
        Order::macro('fulfillmentStatus', fn () => OrderStatus::fulfillment($this));
        Event::listen(ShipmentStatusUpdatedByCarrier::class, DeriveOrderDeliveredFromShipment::class);
        Event::listen(PaymentCaptured::class, ApplyResolvedPaymentStatus::class);
        Event::listen(PaymentAuthorized::class, ApplyResolvedPaymentStatus::class);
        Event::listen(PaymentCaptured::class, RecordPaymentTransaction::class);
        Event::listen(PaymentAuthorized::class, RecordPaymentTransaction::class);
        Event::listen(PaymentVoided::class, RecordPaymentTransaction::class);
        Event::listen(PaymentRefunded::class, RecordPaymentTransaction::class);
        NotificationRegistry::get()->register([
            OrderDeliveredNotification::class,
@@ -38,5 +38,7 @@ class PaymentServiceProvider extends ServiceProvider
        }
        config(['lunar.cart.pipelines.cart' => $cartPipeline]);
        $this->loadRoutesFrom(__DIR__ . '/../Payment/routes/webhooks.php');
    }
 }
@@ -10,9 +10,9 @@ use Modules\Core\Shipping\Contracts\CarrierFulfillmentInterface;
 use Modules\Core\Shipping\Contracts\SupportsManifestBatching;
 use Modules\Core\Shipping\Contracts\SupportsTracking;
 use Modules\Core\Shipping\Carriers\Acs\Exceptions\AcsApiException;
-use Modules\Core\Shipping\DataTransferObjects\ManifestResult;
+use Modules\Core\Shipping\DTOs\ManifestResult;
-use Modules\Core\Shipping\DataTransferObjects\ShipmentRequest;
+use Modules\Core\Shipping\DTOs\ShipmentRequest;
-use Modules\Core\Shipping\DataTransferObjects\TrackingCheckpoint;
+use Modules\Core\Shipping\DTOs\TrackingCheckpoint;
 use Modules\Core\Shipping\Enums\TrackingStatus;
 use Modules\Core\Shipping\Models\Shipment;
@@ -8,8 +8,8 @@ use Lunar\Models\Order;
 use Modules\Core\Shipping\Carriers\BoxNow\Exceptions\BoxNowApiException;
 use Modules\Core\Shipping\Contracts\CarrierFulfillmentInterface;
 use Modules\Core\Shipping\Contracts\SupportsTracking;
-use Modules\Core\Shipping\DataTransferObjects\ShipmentRequest;
+use Modules\Core\Shipping\DTOs\ShipmentRequest;
-use Modules\Core\Shipping\DataTransferObjects\TrackingCheckpoint;
+use Modules\Core\Shipping\DTOs\TrackingCheckpoint;
 use Modules\Core\Shipping\Enums\TrackingStatus;
 use Modules\Core\Shipping\Models\Shipment;
@@ -3,7 +3,7 @@
 namespace Modules\Core\Shipping\Contracts;
 use Lunar\Models\Order;
-use Modules\Core\Shipping\DataTransferObjects\ShipmentRequest;
+use Modules\Core\Shipping\DTOs\ShipmentRequest;
 use Modules\Core\Shipping\Models\Shipment;
 interface CarrierFulfillmentInterface
@@ -3,7 +3,7 @@
 namespace Modules\Core\Shipping\Contracts;
 use Illuminate\Support\Collection;
-use Modules\Core\Shipping\DataTransferObjects\ManifestResult;
+use Modules\Core\Shipping\DTOs\ManifestResult;
 /**
 * Optional capability for carriers that batch shipments into a manifest
@@ -3,7 +3,7 @@
 namespace Modules\Core\Shipping\Contracts;
 use Illuminate\Support\Collection;
-use Modules\Core\Shipping\DataTransferObjects\TrackingCheckpoint;
+use Modules\Core\Shipping\DTOs\TrackingCheckpoint;
 use Modules\Core\Shipping\Models\Shipment;
 /**
@@ -1,6 +1,6 @@
 <?php
-namespace Modules\Core\Shipping\DataTransferObjects;
+namespace Modules\Core\Shipping\DTOs;
 use Illuminate\Support\Collection;
@@ -1,6 +1,6 @@
 <?php
-namespace Modules\Core\Shipping\DataTransferObjects;
+namespace Modules\Core\Shipping\DTOs;
 /**
 * Carrier-agnostic input for CarrierFulfillmentInterface::createShipment().
@@ -1,6 +1,6 @@
 <?php
-namespace Modules\Core\Shipping\DataTransferObjects;
+namespace Modules\Core\Shipping\DTOs;
 use Carbon\CarbonInterface;
 use Modules\Core\Shipping\Enums\TrackingStatus;
@@ -14,7 +14,7 @@ use Lunar\Admin\Support\Extending\ViewPageExtension;
 use Lunar\Models\Order;
 use Lunar\Shipping\Models\ShippingMethod;
 use Modules\Core\Shipping\Contracts\CarrierFulfillmentInterface;
-use Modules\Core\Shipping\DataTransferObjects\ShipmentRequest;
+use Modules\Core\Shipping\DTOs\ShipmentRequest;
 class OrderViewExtension extends ViewPageExtension
 {
Author	SHA1	Message	Date
arvanitakis	e9aa08a338	Bump version to 0.13.1	2026-09-03 18:28:22 +03:00
arvanitakis	0676a1f5c7	Feat: Recording Payment Transactions	2026-09-03 18:26:48 +03:00
arvanitakis	8e8ec17d09	Bump version to 0.13.0	2026-09-03 17:44:22 +03:00
arvanitakis	e6f1ca179a	Fix: Fixing various bugs occured on payment lifecycle	2026-09-03 17:42:30 +03:00
arvanitakis	79e525d53f	Fix: Stripe Intents Table is a Lunar Table, so needs a prefix. This is covered by the Lunar\Base\Migration	2026-09-03 17:31:39 +03:00
arvanitakis	456943dc74	Feature: Payment resolver, Payment Provider, Completing Stripe Webhooks, Wiring Payments to checkout service	2026-09-03 17:27:34 +03:00
arvanitakis	35c3334690	Feat: Payment Restructuring to be fully event-driven	2026-09-03 17:00:24 +03:00
arvanitakis	a987a2d57c	Feature: Abstraction on Payments based on their operations	2026-09-03 16:01:33 +03:00
arvanitakis	0fa2188146	Feat: Refactoring Shipping DataTransferObjects to DTOs namespace	2026-09-03 15:58:51 +03:00
arvanitakis	a1301d4b46	Merge branch 'master' into Payments	2026-09-03 13:34:32 +03:00
arvanitakis	215f43f3ef	Feat: Adding tags to product filters	2026-09-03 13:34:04 +03:00
arvanitakis	c439299144	Bump version to 0.12.1	2026-09-03 13:23:50 +03:00
arvanitakis	6963515971	Fix: Small update to label parsing	2026-09-03 13:22:09 +03:00
arvanitakis	f43f72f633	Feat: Updates to Product Indexer, Shopify Importer, Adding cascade delete on reviews	2026-09-03 12:26:00 +03:00
arvanitakis	8cb54e065e	Feat: Updates to Payments, Checkout Services, Payment Events	2026-09-02 16:14:52 +03:00