Bump version to 0.12.1

Fix: Small update to label parsing
Feat: Updates to Product Indexer, Shopify Importer, Adding cascade delete on reviews
2026-09-03 13:23:50 +03:00 · 2026-09-03 13:22:09 +03:00 · 2026-09-03 12:26:00 +03:00 · 2026-09-03 11:44:36 +03:00 · 2026-09-03 11:44:23 +03:00 · 2026-09-03 11:04:19 +03:00
48 changed files with 2276 additions and 98 deletions
@@ -4,6 +4,52 @@ 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.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
 - **Breaking:** `Modules\Core\Catalog\Services\ProductService::list()` now returns `Modules\Core\Catalog\DTOs\ProductListingResult` (`->products`: the same `Illuminate\Pagination\LengthAwarePaginator` as before, `->priceBounds`: a new `Modules\Core\Catalog\DTOs\PriceSliderBounds`) instead of returning the paginator directly. A caller doing `$service->list(...)->items()`/`->through(...)` must update to `$service->list(...)->products->items()`/`->through(...)`. This collapses what used to be two separate calls a controller had to orchestrate itself (`list()` for products, `priceRange()` + manual floor/ceil/"is this actually filtered" math for the slider) into one.
 - **Breaking:** `Modules\Core\Catalog\Services\ProductSearchService::search()`'s signature changed from `search(string $query, ?string $locale = null)` to `search(string $query, ?ProductFilters $filters = null, ?ProductSort $sort = null)` — the `$locale` parameter is gone (see "every configured language, always" below); `$filters`/`$sort` apply the same `Modules\Core\Catalog\Support\ProductFilterBuilder`/`ProductSort::toMeilisearchSort()` semantics `ProductService::list()` already used, so a text search can now be narrowed by price/brand/stock and sorted the same way a category listing can.
 - `ProductSearchService` now targets every configured store language's fields on every search (`Lunar\Models\Language::all()`), not just the current request locale plus the store's default language. The old `{current, default}` pairing silently stopped catching anything outside those two locales whenever they were equal (a single-language store, or a shopper browsing in the default language) — always searching every configured language closes that gap in both directions. See `docs/product-search.md`.
 - Extracted `Modules\Core\Catalog\Services\ProductService`'s private `buildFilter()` into a new standalone `Modules\Core\Catalog\Support\ProductFilterBuilder`, so `ProductSearchService` can apply the exact same Meilisearch filter-clause semantics to a text query, instead of reimplementing filter-building a second time.
 ### Added
 - `Modules\Core\Catalog\Services\ProductService::priceSliderBounds()` — `priceRange()` rounded to whole currency units (floor/ceil) plus whether the given selected min/max actually narrows it, returned as a `PriceSliderBounds` DTO. Used internally by `list()` now; also callable directly for a caller (e.g. a text-search results page) that needs slider bounds without a full `list()` call.
 - `Modules\Core\Catalog\Services\ProductService::priceRange()` gained an optional `string $query = ''` parameter, so a caller can scope the price range to a text search's own matches (pass the shopper's search text) instead of always spanning the whole catalog.
 - `Modules\Core\Catalog\Services\ProductService::random(int $limit)` — random products still scoped to the Meilisearch index's own channel/status visibility, unlike a raw `Product::inRandomOrder()` (which has no notion of that filtering). Meilisearch has no `ORDER BY RANDOM()` equivalent, so this fetches every matching id only (`attributesToRetrieve: ['id']`), shuffles in PHP, then fetches the full localized documents for just the ids picked, restoring the shuffled order afterward (Meilisearch's `id IN [...]` filter doesn't preserve list order on its own).
 - `Modules\Core\Catalog\Services\ProductService::variantSummaries(array $product)` — the id/price/image of every variant on a product document, for a variant picker/swatch list, without a caller reaching into `$product['variants'][n]['prices'][0]`/`['media'][0]` itself.
 - `Modules\Core\Catalog\Services\ProductSearchService::search()` now also targets `variants.options.value` — a variant's own option value (e.g. "Κάπτεν Γαμέρικα" on a "Name" option) is matchable by search even when that text never appears in the product's own name or description.
 - `php artisan lunar:meilisearch:tune-product-search` (`Modules\Core\Command\TuneProductSearchCommand`) — tightens `minWordSizeForTypos` (1 typo only at 8+ characters, 2 typos only at 12+) and disables Meilisearch's `prefixSearch` on the product index. Meilisearch's defaults for both were loose enough to produce bad matches on short Greek words (confirmed the specific case was `prefixSearch`'s default `indexingTime` behavior on a shared word-start, not typo tolerance, via `showMatchesPosition`). Consuming apps should run this after `lunar:meilisearch:setup` whenever the product index needs (re)provisioning — **requires Meilisearch v1.12+** (`prefixSearch` didn't exist as a configurable setting before then).
 ## [0.11.1] - 2026-09-01
 ### Fixed
 - `Modules\Core\Catalog\Services\RecommendationService::recommend()` built its result with the base `Illuminate\Support\Collection` (`collect()`) instead of `Illuminate\Database\Eloquent\Collection`, even though every element is a `Product` model. `ProductIndexer::toSearchableArray()` calling `->load(['media', 'variants.prices'])` on that result threw `BadMethodCallException: Method Illuminate\Support\Collection::load does not exist` — silently failing every `MakeSearchable` queue job for a saved product (visible only as `FAIL` in the queue log, with the real exception in `storage/logs/laravel.log`). Fixed by having `RecommendationService` accumulate into a real `Eloquent\Collection` from the start.
 ## [0.11.0] - 2026-09-01
 ### Added
 - `Modules\Core\Catalog\Services\RecommendationService` — computes "related products" for a given product as a configurable, ordered chain of strategies (`config('catalog.recommendation_rules')`), not one hardcoded rule. Tops up from each successive rule until the limit (default 4) is reached or every rule is exhausted — e.g. 3 products from a same-category rule plus 1 from a random fallback — deduplicated across rules so the same product is never returned twice. Ships with `Modules\Core\Catalog\Recommendations\SameCategoryRule` (other products sharing the source product's first collection) and `RandomRule` (the universal fallback, placed last in the default chain). A new rule is just a class implementing `Modules\Core\Catalog\Contracts\RecommendationRule`. Documented in `docs/product-recommendations.md`.
 - `Modules\Core\Catalog\Services\ProductIndexer` embeds the result directly into each product's own Meilisearch document as `recommendations: [{id, name, price, image}, ...]` (`recommendations.id` filterable) — a product detail page renders its "related products" section with zero extra queries, same reasoning as the existing `collections` field. Deliberately embeds an `id` for the view to build a locale-correct URL from, not a resolved `href` — `product.show` is locale-prefixed, so a URL baked in at index time would only be correct for whichever locale happened to be active during that index run.
 - `Modules\Core\Catalog\Events\ProductSaved`/`ProductDeleted`, dispatched from `Product::saved()`/`Product::deleted()` in `CatalogServiceProvider` (the latter fires for both a soft delete and a force delete, matching Scout's own `unsearchable()` trigger point) — feed `Modules\Core\Catalog\Listeners\ReindexProductsRecommendingProduct`, which reverse-searches Meilisearch for every product currently recommending the changed/deleted one (`recommendations.id = "..."` — there's no Postgres relation for this, a recommendation only exists inside the index) and re-indexes them via Scout's own `->searchable()`. Product creation is deliberately not hooked into this: a new product not yet appearing as a recommendation elsewhere is an accepted staleness window, the same tradeoff already documented for `in_stock`/`price` — see `docs/product-recommendations.md`.
 - `CatalogServiceProvider` schedules `lunar:search:index "Lunar\Models\Product" --refresh` daily at 03:00 — a safety net on top of the event-driven reindexing above, covering a newly-created product not yet appearing as a recommendation and any other drift already accepted between reindexes. `--refresh` also re-syncs filterable/sortable index settings, not just documents.
 ## [0.10.1] - 2026-09-01
 ### Added
 - `Modules\Core\Localization\Services\StorefrontLabels::all()` gains three keys found missing from `3dealer`'s actual `storefront.*` translation usage: `shop.price_min`, `shop.price_max`, `shop.reset` (the price-filter sidebar's min/max labels and its reset link). Picked up by `InstallLunarCommand`'s existing per-key upsert — re-running `lunar:install` on an already-installed store adds only these three rows, leaving everything already seeded or admin-edited untouched.
 ## [0.10.0] - 2026-08-31
 ### Changed
@@ -2,7 +2,7 @@
  "name": "boboko/core",
  "description": "Core module — authentication and shared panel behaviour",
  "type": "library",
-  "version": "0.10.0",
+  "version": "0.12.1",
  "autoload": {
    "psr-4": {
      "Modules\\Core\\": "src/"
@@ -42,7 +42,8 @@
        "Modules\\Core\\Providers\\CatalogServiceProvider",
        "Modules\\Core\\Providers\\CartServiceProvider",
        "Modules\\Core\\Providers\\ReviewServiceProvider",
-        "Modules\\Core\\Providers\\ShippingServiceProvider"
+        "Modules\\Core\\Providers\\ShippingServiceProvider",
        "Modules\\Core\\Providers\\OrderServiceProvider"
      ]
    }
  },
@@ -0,0 +1,25 @@
 <?php
 use Modules\Core\Catalog\Recommendations\RandomRule;
 use Modules\Core\Catalog\Recommendations\SameCategoryRule;
 return [
    /*
    |--------------------------------------------------------------------------
    | Product recommendation rules
    |--------------------------------------------------------------------------
    |
    | Tried in order by Modules\Core\Catalog\Services\RecommendationService —
    | the first rule that returns at least one product wins. The order here IS
    | the fallback chain: SameCategoryRule first, then RandomRule as a
    | last-resort so a product page is never left with zero recommendations
    | (as long as the store has more than one product). A consuming app can
    | reorder, add, or remove rules freely — nothing about the chain shape is
    | hardcoded in the service itself.
    |
    */
    'recommendation_rules' => [
        SameCategoryRule::class,
        RandomRule::class,
    ],
 ];
@@ -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');
        });
    }
 };
@@ -1,8 +1,9 @@
 # Product Listing
 `Modules\Core\Catalog\Services\ProductService` provides catalog browsing/filtering AND single-product
-lookup for a storefront — `list()`, `getById()`, `getBySlug()` — all reading directly from the
+lookup for a storefront — `list()`, `getById()`, `getBySlug()`, `random()`, `variantSummaries()` —
-Meilisearch index rather than the database. One data source for everything this service does.
+all reading directly from the Meilisearch index rather than the database. One data source for
 everything this service does.
 This is separate from `Modules\Core\Catalog\Services\ProductSearchService` (see `product-search.md`), which
 handles free-text query search. `ProductService` is for browsing/lookup without a search term.
@@ -28,13 +29,14 @@ use Modules\Core\Catalog\Enums\ProductSort;
 $service = app(ProductService::class);
-// List everything, paginated — returns a real Illuminate\Pagination\LengthAwarePaginator,
+// One call for everything a listing page needs — products AND the price slider's
-// built from the localized Meilisearch hits (not Scout's own paginateRaw() result — see
+// bounds together, as a Modules\Core\Catalog\DTOs\ProductListingResult. A caller
-// "Meilisearch driver quirk" below), so it behaves like any other Laravel paginator.
+// used to have to call list() and priceSliderBounds() (or the older priceRange())
-$products = $service->list(perPage: 24, page: 1);
+// separately and glue the results together itself; that's now list()'s own job.
 $listing = $service->list(perPage: 24, page: 1);
 // Filter by collection, brand, price range, and/or stock
-$products = $service->list(
+$listing = $service->list(
    filters: new ProductFilters(collectionId: 17, minPrice: 10.0, maxPrice: 50.0, inStockOnly: true),
    perPage: 24,
    page: 1,
@@ -42,8 +44,13 @@ $products = $service->list(
 // Sort — cheapest/priciest first, or newest first. Omit for Meilisearch's default
 // relevance ordering (irrelevant here since the query is always empty).
-$products = $service->list(perPage: 24, page: 1, sort: ProductSort::PriceAsc);
+$listing = $service->list(perPage: 24, page: 1, sort: ProductSort::PriceAsc);
 $products = $listing->products;  // a real Illuminate\Pagination\LengthAwarePaginator,
                                  // built from the localized Meilisearch hits (not Scout's
                                  // own paginateRaw() result — see "Meilisearch driver
                                  // quirk" below), so it behaves like any other Laravel
                                  // paginator.
 $products->items();            // array of Meilisearch documents (plain arrays, not models)
 $products->total();
 $products->perPage();
@@ -51,12 +58,32 @@ $products->currentPage();
 $products->lastPage();
 $products->links();            // in a Blade view — renders pagination links as usual
 $bounds = $listing->priceBounds;  // Modules\Core\Catalog\DTOs\PriceSliderBounds
 $bounds->floor;    // ?int — floor() of the matching range's minimum, in whole currency units
 $bounds->ceil;     // ?int — ceil() of the matching range's maximum
 $bounds->filtered; // bool — whether the applied filters' minPrice/maxPrice actually
                   // narrow the slider below/above these bounds (drives whether a
                   // "clear filter" control should show)
 // Single product, by primary key
 $product = $service->getById(367);   // array, or null if not found
 // Single product, by URL slug (any locale — slugs are indexed across all languages)
 $product = $service->getBySlug('erotika-mprelok');   // array, or null if not found
 // $limit random products — still scoped to the index's own default channel/status
 // visibility, unlike Eloquent's Product::inRandomOrder() (which has no notion of
 // that filtering at all). Meilisearch has no ORDER BY RANDOM() equivalent, so this
 // pulls every matching id only, shuffles in PHP, then fetches the full localized
 // documents for just the ids picked — see random()'s own docblock.
 $randomProducts = $service->random(13);   // array of documents, same shape as list()'s items
 // The id/price/image of every variant on a product document — the base price and
 // thumbnail a variant picker/swatch list needs, without reaching into
 // $product['variants'][n]['prices'][0]/['media'][0] yourself.
 $variants = $service->variantSummaries($product);
 // [['id' => 1204, 'price' => 19.99, 'image' => 'https://.../thumb.jpg'], ...]
 // Facet counts for a sidebar — value => matching product count, scoped to whatever
 // $filters is passed. Does NOT exclude the faceted field itself from $filters — see
 // facets()'s docblock for why, and how to build a standard "every option's count,
@@ -64,11 +91,13 @@ $product = $service->getBySlug('erotika-mprelok');   // array, or null if not fo
 $brandCounts = $service->facets('brand', filters: new ProductFilters(collectionId: 17));
 // ['3Dealer.gr - 3D printed creations' => 48, 'Kraniou Topos - 3D printed creations' => 135]
-// Min/max price across matching products, for sizing a price-range slider.
+// Min/max price across matching products — the raw, unrounded values list() itself
-// minPrice/maxPrice are ALWAYS excluded from the filter driving this (unlike
+// uses to build priceBounds above. minPrice/maxPrice are ALWAYS excluded from the
-// facets(), which doesn't auto-exclude) — the slider's own bounds shouldn't shrink
+// filter driving this (unlike facets(), which doesn't auto-exclude) — the slider's
-// to whatever range is currently selected on it. Other filters (collectionId,
+// own bounds shouldn't shrink to whatever range is currently selected on it. Other
-// brand, inStockOnly) still apply normally.
+// filters (collectionId, brand, inStockOnly) still apply normally. Pass $query too
 // to scope the range to a text search's own matches (see product-search.md) rather
 // than the whole catalog.
 $range = $service->priceRange(new ProductFilters(collectionId: 17));
 // ['min' => 0.0, 'max' => 120.0]
 ```
@@ -77,8 +106,8 @@ All `ProductFilters` fields are optional; only the ones set are added to the Mei
 `facets()` only makes sense on discrete-value filterable fields (`brand`, `in_stock`) — a numeric
 field like `price` would return one "facet" per exact price, not a usable range bucket. Use
-`priceRange()` for `price` instead, which reads Meilisearch's `facetStats` (min/max), a different
+`priceRange()` (or `list()`'s own `priceBounds`) for `price` instead, which reads Meilisearch's
-feature from `facetDistribution`.
+`facetStats` (min/max), a different feature from `facetDistribution`.
 ---
@@ -106,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. |
@@ -0,0 +1,155 @@
 # Product Recommendations
 `Modules\Core\Catalog\Services\RecommendationService` computes "related products" for a given
 product — a same-category pick today, with a random fallback, but built as a configurable chain of
 strategies rather than one hardcoded rule. `Modules\Core\Catalog\Services\ProductIndexer` embeds
 the result directly into each product's own Meilisearch document, so a product detail page renders
 its recommendations with zero extra queries — same reasoning as `collections` (see
 `docs/product-listing.md`).
 ---
 ## The rule chain
 ```php
 use Modules\Core\Catalog\Services\RecommendationService;
 $recommendations = app(RecommendationService::class)->recommend($product, limit: 4);
 // Illuminate\Support\Collection<int, Lunar\Models\Product>
 ```
 `recommend()` walks `config('catalog.recommendation_rules')` in order, **topping up** from each
 successive rule until `$limit` distinct products are collected or every rule is exhausted — it does
 not stop at the first rule that returns *something*. If a product's category only has 3 other
 products, `SameCategoryRule` contributes those 3 and `RandomRule` fills the last slot. A rule is
 handed the ids already collected (`$exclude`, always including the source product's own id) so it
 never wastes its own `$limit` budget re-suggesting something already picked, and the same product
 is never returned twice even if two rules would both suggest it.
 Default chain (`config/catalog.php`):
 ```php
 'recommendation_rules' => [
    SameCategoryRule::class,   // other products sharing $product's first collection
    RandomRule::class,          // universal fallback — always returns something as
                                 // long as the store has more than one product
 ],
 ```
 A consuming app publishes and edits this config to reorder, add, or remove rules — nothing about
 the chain shape is hardcoded in `RecommendationService` itself. A new rule (same tag, best sellers,
 "frequently bought together", ...) is a class implementing `Modules\Core\Catalog\Contracts\
 RecommendationRule`, added to the array:
 ```php
 interface RecommendationRule
 {
    /**
     * @param  array<int>  $exclude  ids to never return — the source product's own
     *   id, plus every id an earlier rule in the chain already picked
     * @return Collection<int, Product>  at most $limit products
     */
    public function recommend(Product $product, int $limit, array $exclude): Collection;
 }
 ```
 Rules query Eloquent directly (`$product->collections->first()->products()`, `Product::query()`),
 not `Modules\Core\Catalog\Services\ProductService` — see "Why not `ProductService`" below.
 ---
 ## Why not `ProductService`
 Every other read path in `Modules\Core\Catalog` goes through `ProductService`, which reads
 Meilisearch and resolves translated fields to whatever locale the *current request* is in (see
 `docs/product-listing.md`, "Locale resolution"). Recommendation rules deliberately don't use it:
 they run inside `ProductIndexer::toSearchableArray()`, at **index time** — there is no request, no
 meaningful "current locale" to resolve against, and Meilisearch itself may be mid-write for the very
 product being indexed. Rules return raw `Lunar\Models\Product` models instead; `ProductIndexer`
 resolves what it embeds (`name` via `translateAttribute()`, `price` via the indexer's own
 `cheapestPrice()`, `image` via its own `mapMedia()`) the same way it already does for the embedded
 `collections` field — including that field's same accepted index-time-locale tradeoff (a
 recommendation's embedded `name` reflects whatever locale was active when *that* product was last
 indexed, not the viewer's current locale).
 ---
 ## What's embedded, and why not just an id
 `ProductIndexer` embeds full card data per recommendation, not just an id:
 ```php
 $data['recommendations'] = [
    ['id' => 42, 'name' => 'Espresso Cup', 'price' => 12.5, 'image' => 'https://.../thumb.jpg'],
    // ...
 ];
 ```
 This shape is deliberately exactly what `x-ui.product-card`/`x-product-grid` (3dealer's storefront
 components) need — `name`, `price`, `image`, and an `id` the view resolves to a URL itself via
 `route('product.show', ['id' => $rec['id']])`. A resolved `href` is **not** embedded: `product.show`
 is locale-prefixed (`{locale}/products/{id}`), so a URL baked in at index time would be correct only
 for whichever locale happened to be active during that index run — wrong for every other locale.
 Building the URL is left to the view, which knows the current request's locale.
 `recommendations.id` is marked **filterable** — not for the storefront, but for the reverse-lookup
 reindexing below.
 ---
 ## Keeping it fresh: `ProductSaved` / `ProductDeleted`
 A recommendation is computed once, at index time, and embedded — it does not update itself when the
 recommended product later changes name, price, or image, or is deleted. Unlike `Modules\Core\Catalog\
 Observers\ProductOptionReindexObserver`'s equivalent problem (which product option value is used by),
 there is no Postgres relation for "which products currently recommend product X" — a recommendation
 only exists inside Meilisearch. The fix is a reverse Meilisearch filter query, not a database join,
 wired through a real event → listener pair (`Modules\Core\Providers\CatalogServiceProvider`):
 - `Product::saved()` dispatches `Modules\Core\Catalog\Events\ProductSaved`.
 - `Product::deleted()` dispatches `Modules\Core\Catalog\Events\ProductDeleted` — fires for both a
  soft delete and a force delete (`Lunar\Models\Product` uses `SoftDeletes`), the same model event
  Laravel Scout's own `ModelObserver` hooks to make a deleted product `unsearchable()`.
 - `Modules\Core\Catalog\Listeners\ReindexProductsRecommendingProduct` handles both: it searches the
  product index for `recommendations.id = "{id}"`, finds every referencing product, and calls
  `->searchable()` on each — which recomputes their `recommendations` field fresh, picking up the
  changed name/price/image, or (for a delete) dropping the now-gone product and topping back up to
  the configured limit via the rule chain, same as any other reindex.
 `->searchable()` dispatches Scout's own reindex job, queued if `SCOUT_QUEUE` is configured — this
 listener does no synchronous Meilisearch writing itself.
 **Product creation is deliberately not hooked into this.** A brand-new product has no
 `recommendations` of its own until Scout's existing create-triggered indexing runs (already correct
 — nothing to add). What's *not* immediate is other products picking the new one up as a fresh
 recommendation candidate — that happens on their own next natural reindex (a save, or the nightly
 full reindex below), the same accepted staleness window `docs/product-listing.md` already documents
 for `in_stock`/`price`. A full proactive "who could now recommend this new product" pass was
 considered and rejected as unnecessary cost for a cosmetic delay.
 ---
 ## Nightly full reindex
 `Modules\Core\Providers\CatalogServiceProvider` schedules `lunar:search:index "Lunar\Models\Product"
 --refresh` daily at 03:00 — a safety net on top of the event-driven reindexing above, not a
 replacement for it. Catches what event-driven reindexing deliberately doesn't cover: a newly-created
 product not yet appearing as a recommendation elsewhere, and any other drift already accepted
 between reindexes (see `docs/product-listing.md`, "Stock goes stale between orders"). `--refresh`
 also re-syncs filterable/sortable index *settings*, not just documents, so a deploy that changed
 `ProductIndexer`'s field list self-heals overnight even if `lunar:meilisearch:setup` wasn't run
 manually right after that deploy.
 ---
 ## Re-syncing after this change
 Same as any other `ProductIndexer` field change (see `docs/product-listing.md`):
 ```bash
 php artisan lunar:meilisearch:setup
 php artisan lunar:search:index "Lunar\Models\Product" --refresh
 ```
 Restart the queue worker if `SCOUT_QUEUE=true` — see `docs/product-listing.md`'s "Re-syncing after
 this change" for why a running worker won't otherwise pick up the new indexer code.
@@ -24,36 +24,62 @@ merges `$builder->options` directly into the search request).
 ## Usage
 ```php
 use Modules\Core\Catalog\DTOs\ProductFilters;
 use Modules\Core\Catalog\Enums\ProductSort;
 use Modules\Core\Catalog\Services\ProductSearchService;
 $results = app(ProductSearchService::class)->search('running shoes');
-// or an explicit locale, bypassing App::getLocale():
+
-$results = app(ProductSearchService::class)->search('running shoes', 'el');
+// Filters/sort apply the exact same semantics ProductService::list() uses for
 // collection browsing (same ProductFilterBuilder, same ProductSort) — a shopper
 // narrowing a text search by price/brand/stock gets identical filter behavior
 // to narrowing a category listing.
 $results = app(ProductSearchService::class)->search(
    'running shoes',
    filters: new ProductFilters(brand: 'Acme', minPrice: 20.0, inStockOnly: true),
    sort: ProductSort::PriceAsc,
 );
 ```
 Returns an `Illuminate\Database\Eloquent\Collection` of `Lunar\Models\Product` — Scout's
 `->get()` hydrates real models from the database after the Meilisearch query, so relations
 (`variants`, `brand`, `media`, etc.) are available on the results as normal.
-`$locale` defaults to `App::getLocale()` — already set correctly on every storefront request by
+There is no `$locale` parameter — see "Field list is dynamic, not hardcoded" below for why
-`Modules\Core\Localization\Middleware\LocaleMiddleware` (see `localization.md`), so callers in controllers
+every configured store language is always searched, regardless of the current request locale.
 don't need to pass it explicitly.
 ---
-## Missing-translation fallback
+## Missing-translation fallback, in both directions
 If a product was only ever given an English name, `name_el` doesn't exist on that document at
 all (Lunar's indexer only writes a `{handle}_{locale}` field for locales actually present in the
 attribute's stored data — see `ScoutIndexer::mapSearchableAttributes()`). Searching strictly
-against `name_el` would make that product invisible to Greek-locale search, even though it's a
+against the current request's locale field would make that product invisible whenever a shopper's
-real catalog item.
+locale doesn't match the language it happens to be translated into.
-To avoid silently hiding incompletely-translated products, `ProductSearchService` targets **both**
+`ProductSearchService` avoids this by targeting **every configured store language's fields**
-the resolved locale's fields **and** the default language's fields
+(`Lunar\Models\Language::all()`) on every search, not just the current request locale plus the
-(`Lunar\Models\Language::getDefault()->code`) — e.g. searching in `el` targets `name_el`,
+store default — e.g. with `el`/`en` configured, every search targets `name_el`, `name_en`,
-`name_en`, `description_el`, `description_en` together (assuming `en` is the default language).
+`description_el`, `description_en` together, regardless of which locale the shopper is browsing
-A product missing an `el` translation still matches via its `en` fields.
+in. This is deliberately not scoped to "current locale + default locale": if the current locale
 already equals the default (a single-language store, or a shopper browsing in the default
 language), that pairing collapses to one locale and stops catching anything else — always
 searching every configured language avoids that gap in both directions, at the cost of a larger
 `attributesToSearchOn` list as the store's language count grows.
 ---
 ## Variant option values are searched too
 Alongside the locale-suffixed attribute fields, every search also targets
 `variants.options.value` directly — e.g. a variant named "Κάπτεν Γαμέρικα" on a "Name" option
 matches a search for that text, even though it never appears in the product's own name or
 description. This isn't one of Lunar's own attributes (`AttributeManifest` has no entry for it),
 so it can't be discovered the way `name`/`description` are — it's a structural field of
 `Modules\Core\Catalog\Services\ProductIndexer`'s own document shape (see `ProductIndexer::mapVariant()`),
 added here directly. Not locale-suffixed — each option value is stored as one already-resolved
 string per variant.
 ---
@@ -0,0 +1,450 @@
 <title>Order Feature Survey</title>
 <style>
  :root {
    --paper: #FAFAF7;
    --ink: #1C1C1A;
    --muted: #6B6B63;
    --accent: #2F5D50;
    --accent-soft: #E4EDE9;
    --good: #3F7A5C;
    --good-soft: #E6F0EA;
    --warn: #B8863B;
    --warn-soft: #F5ECDC;
    --miss: #A14B3B;
    --miss-soft: #F5E5E0;
    --hairline: #E4E2DB;
    --card: #FFFFFF;
  }
  :root:not([data-theme="light"]) {
    @media (prefers-color-scheme: dark) {
      --paper: #17181A;
      --ink: #EDEBE4;
      --muted: #9B9A90;
      --accent: #7FBFA8;
      --accent-soft: #1E2C27;
      --good: #6FBF97;
      --good-soft: #1B2A22;
      --warn: #D9A85C;
      --warn-soft: #2C2418;
      --miss: #D97C68;
      --miss-soft: #2E1E1A;
      --hairline: #2C2D2E;
      --card: #1E1F21;
    }
  }
  :root[data-theme="dark"] {
    --paper: #17181A;
    --ink: #EDEBE4;
    --muted: #9B9A90;
    --accent: #7FBFA8;
    --accent-soft: #1E2C27;
    --good: #6FBF97;
    --good-soft: #1B2A22;
    --warn: #D9A85C;
    --warn-soft: #2C2418;
    --miss: #D97C68;
    --miss-soft: #2E1E1A;
    --hairline: #2C2D2E;
    --card: #1E1F21;
  }
  * { box-sizing: border-box; }
  body {
    background: var(--paper);
    color: var(--ink);
    font-family: "IBM Plex Sans", ui-sans-serif, system-ui, sans-serif;
    font-size: 15.5px;
    line-height: 1.55;
    margin: 0;
    padding: 4.5rem 1.5rem 6rem;
  }
  .wrap {
    max-width: 780px;
    margin: 0 auto;
  }
  header.page {
    margin-bottom: 3.25rem;
  }
  .eyebrow {
    font-family: "IBM Plex Mono", ui-monospace, monospace;
    font-size: 0.72rem;
    letter-spacing: 0.12em;
    text-transform: uppercase;
    color: var(--accent);
    margin-bottom: 0.9rem;
  }
  h1 {
    font-family: "Fraunces", Georgia, serif;
    font-weight: 560;
    font-size: clamp(2.1rem, 4.5vw, 2.65rem);
    line-height: 1.08;
    letter-spacing: -0.01em;
    margin: 0 0 0.9rem;
    text-wrap: balance;
  }
  .dek {
    color: var(--muted);
    max-width: 60ch;
    font-size: 1.02rem;
  }
  .dek strong {
    color: var(--ink);
    font-weight: 600;
  }
  .legend {
    display: flex;
    flex-wrap: wrap;
    gap: 0.6rem;
    margin-top: 1.6rem;
  }
  .chip {
    display: inline-flex;
    align-items: center;
    gap: 0.4rem;
    font-family: "IBM Plex Mono", ui-monospace, monospace;
    font-size: 0.72rem;
    letter-spacing: 0.04em;
    padding: 0.28rem 0.6rem;
    border-radius: 3px;
  }
  .chip.have { background: var(--good-soft); color: var(--good); }
  .chip.partial { background: var(--warn-soft); color: var(--warn); }
  .chip.missing { background: var(--miss-soft); color: var(--miss); }
  section.category {
    margin-top: 3rem;
  }
  .cat-head {
    display: flex;
    align-items: baseline;
    gap: 0.85rem;
    border-bottom: 1px solid var(--hairline);
    padding-bottom: 0.7rem;
    margin-bottom: 1.1rem;
  }
  .cat-num {
    font-family: "Fraunces", Georgia, serif;
    font-size: 1.05rem;
    color: var(--accent);
    font-variant-numeric: tabular-nums;
    min-width: 1.6rem;
  }
  .cat-head h2 {
    font-family: "Fraunces", Georgia, serif;
    font-weight: 500;
    font-size: 1.28rem;
    margin: 0;
    letter-spacing: -0.005em;
  }
  .cat-note {
    color: var(--muted);
    font-size: 0.86rem;
    margin: 0 0 1.2rem;
    max-width: 62ch;
  }
  .feature {
    display: grid;
    grid-template-columns: 1fr auto;
    gap: 0.3rem 1rem;
    padding: 1.05rem 0;
    border-bottom: 1px solid var(--hairline);
    align-items: start;
  }
  .feature:last-child { border-bottom: none; }
  .f-name {
    font-weight: 600;
    font-size: 0.98rem;
  }
  .f-status {
    font-family: "IBM Plex Mono", ui-monospace, monospace;
    font-size: 0.68rem;
    letter-spacing: 0.06em;
    text-transform: uppercase;
    padding: 0.22rem 0.55rem;
    border-radius: 3px;
    white-space: nowrap;
    height: fit-content;
  }
  .f-status.have { background: var(--good-soft); color: var(--good); }
  .f-status.partial { background: var(--warn-soft); color: var(--warn); }
  .f-status.missing { background: var(--miss-soft); color: var(--miss); }
  .f-note {
    grid-column: 1 / -1;
    color: var(--muted);
    font-size: 0.87rem;
    margin-top: 0.15rem;
    max-width: 66ch;
  }
  .f-note code {
    font-family: "IBM Plex Mono", ui-monospace, monospace;
    font-size: 0.82em;
    background: var(--accent-soft);
    color: var(--accent);
    padding: 0.08em 0.35em;
    border-radius: 3px;
  }
  footer.page {
    margin-top: 4rem;
    padding-top: 1.5rem;
    border-top: 1px solid var(--hairline);
    color: var(--muted);
    font-size: 0.82rem;
    display: flex;
    justify-content: space-between;
    gap: 1rem;
    flex-wrap: wrap;
  }
  footer.page a { color: var(--accent); }
  @media (max-width: 560px) {
    body { padding: 3rem 1.1rem 4rem; }
    .feature { grid-template-columns: 1fr; }
    .f-status { justify-self: start; }
  }
 </style>
 <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Fraunces:opsz,wght@9..144,400..600&family=IBM+Plex+Sans:wght@400;500;600&family=IBM+Plex+Mono:wght@400;500&display=swap">
 <div class="wrap">
  <header class="page">
    <div class="eyebrow">boboko / order · competitive survey</div>
    <h1>What order management elsewhere can do that boboko can't yet</h1>
    <p class="dek">
      Where the Checkout survey stopped — the instant <code>Order</code> exists — this
      one starts. A feature-by-feature pass across Shopify, WooCommerce, PrestaShop, and
      (briefly) Magento's post-placement order layer — sourced, not recalled from memory —
      checked against what <strong>Lunar's <code>Order</code> model and the
      already-shipped Filament <code>ManageOrder</code> page</strong> actually support
      today. For deciding what the new <code>Order</code> module needs to own, not a
      build order.
    </p>
    <div class="legend">
      <span class="chip have">● have</span>
      <span class="chip partial">◐ partial</span>
      <span class="chip missing">○ missing</span>
    </div>
  </header>
  <section class="category">
    <div class="cat-head">
      <span class="cat-num">01</span>
      <h2>Status model</h2>
    </div>
    <p class="cat-note">One field, or several axes — and who's allowed to move it.</p>
    <div class="feature">
      <div class="f-name">Payment status independent of a single overall status</div>
      <span class="f-status partial">partial</span>
      <div class="f-note">The data exists — <code>ManageOrder::paymentStatus()</code> derives a real value from <code>transactions()</code>/<code>captureTotal()</code>/<code>refundTotal()</code>/<code>intentTotal()</code> — but it's a computed display value on the admin page, not a stored column or something the rest of the system (mailers, automations) can key off. Shopify and Magento both make payment status a first-class, independently-queryable dimension; here it's derived on the fly, once, in one Filament page.</div>
    </div>
    <div class="feature">
      <div class="f-name">Fulfillment status independent of overall status</div>
      <span class="f-status missing">missing</span>
      <div class="f-note">No equivalent of <code>paymentStatus()</code> exists for shipment/fulfillment state — <code>Order</code> has no <code>shipments()</code> relation of its own at all; it's added dynamically by <code>Modules\Core\Shipping\Providers\ShippingServiceProvider::resolveRelationUsing()</code>, outside Order's own boundary (see docs/checkout.md, "Where Order would likely absorb work"). Every platform researched (Shopify, Woo, PrestaShop, Magento) treats "has this shipped" as derivable from child records, not a manually-set field — Lunar has the child records (<code>Shipment</code>) but no derived status method reading them.</div>
    </div>
    <div class="feature">
      <div class="f-name">Staff-editable order status with a picker/action</div>
      <span class="f-status have">have</span>
      <div class="f-note"><code>ManageOrder</code> ships a working <code>UpdateStatusAction</code> out of the box, backed by <code>config('lunar.orders.statuses')</code> — a flat, merchant-configured list, each entry carrying a <code>label</code>/<code>color</code>/<code>favourite</code> flag. Closer to WooCommerce's single linear field than Shopify's multi-axis split.</div>
    </div>
    <div class="feature">
      <div class="f-name">Status rows carry behavior (auto-send email, generate invoice, restock)</div>
      <span class="f-status partial">partial</span>
      <div class="f-note">Each status entry in <code>config('lunar.orders.statuses')</code> already declares <code>mailers</code> and <code>notifications</code> arrays — the PrestaShop-style shape is there in config — but per the Checkout survey's finding, nothing in core actually reads and dispatches from those keys on a transition. The data model for "status carries behavior" exists; the behavior doesn't.</div>
    </div>
    <div class="feature">
      <div class="f-name">Order-status-changed event other code can react to</div>
      <span class="f-status missing">missing</span>
      <div class="f-note">Same gap the Checkout survey flagged for order creation: no <code>OrderStatusUpdated</code>/equivalent exists anywhere in core. <code>UpdateStatusAction</code> just writes the column. Anything wanting to react to a status change — a confirmation email, a webhook, re-deriving payment/fulfillment status — has to hook the raw Eloquent <code>Order::updated()</code> event and diff <code>status</code> itself.</div>
    </div>
  </section>
  <section class="category">
    <div class="cat-head">
      <span class="cat-num">02</span>
      <h2>Fulfillment &amp; shipment tracking</h2>
    </div>
    <p class="cat-note">Turning a placed order into a package that moves.</p>
    <div class="feature">
      <div class="f-name">Shipment as its own record, separate from the order</div>
      <span class="f-status have">have</span>
      <div class="f-note"><code>Modules\Core\Shipping\Models\Shipment</code> (carrier, tracking reference, label-printed timestamp, manifest reference) already exists and belongs to <code>Order</code>. Built this session, ahead of most gaps in this survey — the record shape is closer to Magento's per-shipment entity than Woo's "no shipment entity at all."</div>
    </div>
    <div class="feature">
      <div class="f-name">Multiple shipments per order (partial/split fulfillment)</div>
      <span class="f-status partial">partial</span>
      <div class="f-note"><code>Shipment</code> has no <code>quantity</code>-per-line or <code>order_line_id</code> concept — it's one shipment record per carrier voucher, with a <code>parent_reference</code> for ACS's own multipart-voucher case (one physical order split into multiple packages by the carrier), not a per-line-item fulfillment split decided by staff. Closer to "multiple packages for one shipment" than Magento's true per-line partial-shipment model.</div>
    </div>
    <div class="feature">
      <div class="f-name">Create-shipment action from the order admin screen</div>
      <span class="f-status have">have</span>
      <div class="f-note"><code>Modules\Core\Shipping\Extensions\OrderViewExtension</code> adds a working "Create Shipment" header action to <code>ManageOrder</code>, resolving a <code>CarrierFulfillmentInterface</code> by the order's chosen shipping method and calling <code>createShipment()</code> — genuinely wired, not a stub. Currently lives under <code>Shipping</code>, flagged in docs/checkout.md as conceptually an <code>Order</code> concern.</div>
    </div>
    <div class="feature">
      <div class="f-name">Tracking number + carrier surfaced on the order itself</div>
      <span class="f-status have">have</span>
      <div class="f-note"><code>Shipment.tracking_reference</code>/<code>carrier</code> exist and are populated by <code>createShipment()</code>; <code>PollShipmentTrackingJob</code> (scheduled every 30 minutes) keeps <code>ShipmentInfo</code> checkpoints current via <code>CarrierFulfillmentInterface::trackShipment()</code>. Genuinely ahead of PrestaShop's thin <code>order_carrier.tracking_number</code> field — this has a real checkpoint history, not just one string.</div>
    </div>
    <div class="feature">
      <div class="f-name">"Shipped"/"delivered" status auto-derived from tracking</div>
      <span class="f-status missing">missing</span>
      <div class="f-note">The tracking checkpoints exist (<code>ShipmentInfo</code>, <code>TrackingStatus</code> enum including <code>Delivered</code>) but nothing writes them back onto <code>Order.status</code> — a delivered shipment doesn't move the order out of whatever status it was already in. Every platform researched treats "delivered" as a status a customer/staff can see on the order, not something buried one relation away.</div>
    </div>
    <div class="feature">
      <div class="f-name">Shipping/delivery notification emails (shipped, out-for-delivery, delivered)</div>
      <span class="f-status missing">missing</span>
      <div class="f-note">Research: Shopify fires four separate templated notifications across this window alone (shipping confirmation, out-for-delivery, delivered, plus edited-order). None of the pieces exist here — no order-status-changed event (01) to trigger from, and no mailer wired to <code>PollShipmentTrackingJob</code>'s own status updates either.</div>
    </div>
  </section>
  <section class="category">
    <div class="cat-head">
      <span class="cat-num">03</span>
      <h2>Payments: capture, refund, cancellation</h2>
    </div>
    <p class="cat-note">Money moving back out, and orders that never should have been placed.</p>
    <div class="feature">
      <div class="f-name">Refund action from the order screen, amount-scoped</div>
      <span class="f-status have">have</span>
      <div class="f-note"><code>ManageOrder</code>'s <code>refund</code> action already exists — picks a transaction, an amount (validated against <code>availableToRefund()</code>), and notes, then calls the driver's own <code>Transaction::refund()</code>. This is genuinely native, matching Woo/Magento's line-item-adjacent (if not line-item-exact) refund UX.</div>
    </div>
    <div class="feature">
      <div class="f-name">Capture action for auth-then-capture payment flows</div>
      <span class="f-status have">have</span>
      <div class="f-note"><code>ManageOrder</code>'s <code>capture</code> action + <code>requiresCapture()</code>/<code>canBeRefunded()</code> guard methods already exist, delegating to <code>Transaction::capture()</code> — this is the Stripe "authorize now, capture later" flow's admin-side half, already built ahead of most gaps here.</div>
    </div>
    <div class="feature">
      <div class="f-name">Refund tied to specific line items (not just a dollar amount)</div>
      <span class="f-status missing">missing</span>
      <div class="f-note">The refund action takes a transaction + amount, with no line-item selection or restock decision — WooCommerce and Magento both make "which items, how many, restock or not" the primary refund UI; here it's one number against one transaction, closer to a manual adjustment than a structured partial return.</div>
    </div>
    <div class="feature">
      <div class="f-name">Order cancellation as a distinct action (vs. just changing status)</div>
      <span class="f-status missing">missing</span>
      <div class="f-note">No dedicated "cancel" action exists on <code>ManageOrder</code> — a cancellation today would just be picking a "cancelled"-labeled entry from the generic status dropdown (01), with no automatic refund trigger, no stock-release logic, and no distinction from any other manual status edit.</div>
    </div>
    <div class="feature">
      <div class="f-name">Refund/capture reflected back into an order-level payment status</div>
      <span class="f-status partial">partial</span>
      <div class="f-note">Same gap as 01's payment-status finding — <code>paymentStatus()</code> recomputes correctly from transactions when the admin page loads, but a refund doesn't push the order into a <code>refunded</code>/<code>partially-refunded</code> overall status the way Shopify's <code>displayFinancialStatus</code> does automatically.</div>
    </div>
  </section>
  <section class="category">
    <div class="cat-head">
      <span class="cat-num">04</span>
      <h2>Returns (RMA)</h2>
    </div>
    <p class="cat-note">The one area every researched platform treats as optional, not core.</p>
    <div class="feature">
      <div class="f-name">Return-merchandise-authorization flow (customer requests, staff approves)</div>
      <span class="f-status missing">missing</span>
      <div class="f-note">No <code>Return</code>/RMA model, status set, or request flow exists anywhere in this codebase. Consistent with the research: Shopify is the only platform of the four with this genuinely native; PrestaShop ships it off-by-default; Magento gates it behind the paid Adobe Commerce tier; WooCommerce lacks it entirely. Safe to treat as a real gap, not an urgent one.</div>
    </div>
    <div class="feature">
      <div class="f-name">Return shipping label generation</div>
      <span class="f-status missing">missing</span>
      <div class="f-note">Depends entirely on the RMA flow above existing first — <code>CarrierFulfillmentInterface</code> already has the label-printing primitive (<code>printLabel()</code>) a return label would reuse, so the carrier-side plumbing isn't the blocker, the RMA request/approval model is.</div>
    </div>
  </section>
  <section class="category">
    <div class="cat-head">
      <span class="cat-num">05</span>
      <h2>Order editing</h2>
    </div>
    <p class="cat-note">Changing a placed order — and where every platform draws the line.</p>
    <div class="feature">
      <div class="f-name">Editing guardrails keyed to fulfillment state</div>
      <span class="f-status missing">missing</span>
      <div class="f-note">No line-item add/remove exists on a placed order at all today (unlike Shopify/Woo/PrestaShop, which all allow it up to some fulfillment-keyed cutoff, then force a return instead) — so there's no guardrail to speak of yet because there's no editing to guard. Whatever gets built here should key the cutoff to <code>Shipment</code> existing, per the pattern all four researched platforms converge on.</div>
    </div>
    <div class="feature">
      <div class="f-name">Editable shipping/billing address after placement</div>
      <span class="f-status missing">missing</span>
      <div class="f-note"><code>OrderAddress</code> rows are snapshotted at creation (see Checkout survey, 02) and nothing in <code>ManageOrder</code> exposes editing them afterward — every platform researched treats address edits as lower-risk than line-item edits and allows them more freely; this codebase currently allows neither.</div>
    </div>
    <div class="feature">
      <div class="f-name">Tag editing on a placed order</div>
      <span class="f-status have">have</span>
      <div class="f-note"><code>ManageOrder</code>'s <code>edit_tags</code> action already works — the one piece of native post-placement editing that exists today, via <code>HasTags</code> on the <code>Order</code> model.</div>
    </div>
  </section>
  <section class="category">
    <div class="cat-head">
      <span class="cat-num">06</span>
      <h2>Notes &amp; audit trail</h2>
    </div>
    <p class="cat-note">The one thing every researched platform treats as non-negotiable.</p>
    <div class="feature">
      <div class="f-name">Append-only change history (who changed what, when)</div>
      <span class="f-status have">have</span>
      <div class="f-note"><code>Order</code> already uses Spatie's <code>LogsActivity</code> trait — every save is recorded with a diff, same underlying mechanism already relied on elsewhere in this codebase (staff activity log, translation history). Structurally equivalent to PrestaShop's <code>order_history</code> table, just via a different package.</div>
    </div>
    <div class="feature">
      <div class="f-name">Internal staff notes, separate from system-generated log entries</div>
      <span class="f-status missing">missing</span>
      <div class="f-note">The activity log above captures field changes automatically, but there's no free-text "leave a note for the next person" field — every platform researched has this as a distinct feed from the automatic history (Woo's Order Notes, Shopify's Timeline comments, Magento's Comments History), usually with a private-vs-customer-visible toggle. Nothing here yet.</div>
    </div>
    <div class="feature">
      <div class="f-name">Customer-visible note-to-customer, sent as a message</div>
      <span class="f-status missing">missing</span>
      <div class="f-note">Depends on both the internal-notes feature above and a working mailer (01/02) — genuinely blocked on more foundational gaps, not just unbuilt on its own.</div>
    </div>
  </section>
  <footer class="page">
    <span>Compiled 2026-09-01 — sources cited inline; <code>vendor/lunarphp/lunar</code> and this codebase's own <code>src/</code> reads are marked by file/class name, Shopify/WooCommerce/PrestaShop/Magento claims are marked "Research."</span>
    <span>boboko-core / docs</span>
  </footer>
 </div>
@@ -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();
 ```
@@ -0,0 +1,3 @@
 <p>Hi,</p>
 <p>Payment of <strong>{{ $amount }}</strong> for your order <strong>{{ $reference }}</strong> has been captured.</p>
@@ -0,0 +1,3 @@
 <p>Hi,</p>
 <p>Good news — your order <strong>{{ $reference }}</strong> has been delivered.</p>
@@ -0,0 +1,3 @@
 <p>Hi,</p>
 <p>A refund of <strong>{{ $amount }}</strong> has been issued for your order <strong>{{ $reference }}</strong>.</p>
@@ -0,0 +1,3 @@
 <p>Hi,</p>
 <p>Your order <strong>{{ $reference }}</strong> is now: <strong>{{ $statusLabel }}</strong></p>
@@ -0,0 +1,39 @@
 <?php
 namespace Modules\Core\Catalog\Contracts;
 use Illuminate\Support\Collection;
 use Lunar\Models\Product;
 /**
 * One strategy for producing recommended products for a given product —
 * e.g. same category, same tag, best sellers, random. Modules\Core\Catalog\
 * Services\RecommendationService runs rules registered in
 * config('catalog.recommendation_rules') in order, topping up from each
 * successive rule until $limit distinct products are collected or every
 * rule is exhausted (e.g. 3 from SameCategoryRule + 1 from RandomRule) —
 * nothing here decides that accumulation itself; a store composes its own
 * chain by ordering rules in config (e.g. [SameCategoryRule::class,
 * RandomRule::class]).
 *
 * Returns raw Product models, not ProductService::list()'s locale-resolved
 * array output — this runs at index time (ProductIndexer::toSearchableArray()),
 * where "the current locale" isn't a meaningful concept the way it is for a
 * storefront request. ProductIndexer resolves translated fields itself via
 * translateAttribute(), same as it already does for the embedded `collections`
 * field — same known index-time-locale tradeoff, not a new one.
 */
 interface RecommendationRule
 {
    /**
     * $exclude carries $product's own id plus every id already picked by an
     * earlier rule this call — RecommendationService never shows the same
     * product twice even when two rules would both suggest it, and a rule
     * shouldn't spend its $limit budget re-returning something already
     * collected.
     *
     * @param  array<int>  $exclude
     * @return Collection<int, Product> at most $limit products
     */
    public function recommend(Product $product, int $limit, array $exclude): Collection;
 }
@@ -0,0 +1,19 @@
 <?php
 namespace Modules\Core\Catalog\DTOs;
 /**
 * A price range slider's bounds and whether it's currently narrowed —
 * built by ProductService::priceSliderBounds(), which owns the floor/ceil
 * rounding and "is this actually a meaningful filter" comparison, so a
 * controller (CategoryController, SearchController, ...) doesn't have to
 * reimplement that rule itself.
 */
 class PriceSliderBounds
 {
    public function __construct(
        public readonly ?int $floor,
        public readonly ?int $ceil,
        public readonly bool $filtered,
    ) {}
 }
@@ -0,0 +1,23 @@
 <?php
 namespace Modules\Core\Catalog\DTOs;
 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
 * makes one service call instead of orchestrating list() and
 * priceSliderBounds() separately. list() still issues two Meilisearch
 * requests internally (the product search and the price facet stats — see
 * priceSliderBounds()'s own docblock for why they 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
 {
    public function __construct(
        public readonly LengthAwarePaginator $products,
        public readonly PriceSliderBounds $priceBounds,
    ) {}
 }
@@ -0,0 +1,23 @@
 <?php
 namespace Modules\Core\Catalog\Events;
 /**
 * Dispatched whenever a Product is deleted (see CatalogServiceProvider,
 * which wires this to the model's own deleted() hook — fires for both a
 * soft delete and a force delete, same as Laravel Scout's own
 * ModelObserver::deleted() that triggers unsearchable() for the product
 * itself). Same purpose as Modules\Core\Catalog\Events\ProductSaved: lets
 * Modules\Core\Catalog\Listeners\ReindexProductsRecommendingProduct find
 * and re-index every OTHER product that currently embeds this one in its
 * `recommendations` field, so a deleted product doesn't linger as a dead
 * reference elsewhere. Carries only the id, not the Product model — by the
 * time this fires the model may already be gone (force delete), and the
 * reverse lookup only ever needs the id to filter on.
 */
 class ProductDeleted
 {
    public function __construct(
        public readonly int $productId,
    ) {}
 }
@@ -0,0 +1,24 @@
 <?php
 namespace Modules\Core\Catalog\Events;
 use Lunar\Models\Product;
 /**
 * Dispatched whenever a Product is saved (see CatalogServiceProvider,
 * which wires this to the model's own saved() hook) — exists specifically
 * so Modules\Core\Catalog\Listeners\ReindexProductsRecommendingProduct can
 * find and re-index every OTHER product that currently embeds this one in
 * its own `recommendations` field (see ProductIndexer). Those products
 * have no direct database relationship to this one — a recommendation is
 * computed and stored only inside Meilisearch (Modules\Core\Catalog\
 * Services\RecommendationService) — so nothing about their own save
 * lifecycle would otherwise pick up this product's changed name/price/
 * image.
 */
 class ProductSaved
 {
    public function __construct(
        public readonly Product $product,
    ) {}
 }
@@ -0,0 +1,64 @@
 <?php
 namespace Modules\Core\Catalog\Listeners;
 use Lunar\Models\Product;
 use Modules\Core\Catalog\Events\ProductDeleted;
 use Modules\Core\Catalog\Events\ProductSaved;
 /**
 * Keeps every product's embedded `recommendations` field (see
 * ProductIndexer) in sync when a product they recommend changes or is
 * removed. Unlike Modules\Core\Catalog\Observers\ProductOptionReindexObserver's
 * equivalent ("who references this option value"), there is no Postgres
 * table to query here — a recommendation only exists inside Meilisearch,
 * computed by RecommendationService at index time — so the reverse lookup
 * is a Meilisearch filter query against `recommendations.id`, not a
 * database join.
 *
 * Handles both ProductSaved (name/price/image changed — referencing
 * products' embedded copy is stale) and ProductDeleted (the recommended
 * product no longer exists at all — referencing products need to drop it
 * and, since RecommendationService tops up to its limit, naturally pick up
 * a replacement on reindex). Same reverse lookup either way, just a
 * different source for the id being searched for.
 *
 * Re-indexing via ->searchable() dispatches Scout's own (queued, if
 * SCOUT_QUEUE is configured) reindex job per matched product — this
 * listener itself does no synchronous Meilisearch writing.
 */
 class ReindexProductsRecommendingProduct
 {
    public function handleSaved(ProductSaved $event): void
    {
        $this->reindexReferencingProducts($event->product->id);
    }
    public function handleDeleted(ProductDeleted $event): void
    {
        $this->reindexReferencingProducts($event->productId);
    }
    private function reindexReferencingProducts(int $productId): void
    {
        $hits = Product::search('')
            ->options([
                'filter' => "recommendations.id = \"{$productId}\"",
                'attributesToRetrieve' => ['id'],
                // Meilisearch's own hitsPerPage default (20) would silently
                // drop referencing products past that count — this is a
                // reverse lookup, not a paginated storefront result, so it
                // needs every match, up to Meilisearch's hard limit.
                'hitsPerPage' => 1000,
            ])
            ->raw()['hits'] ?? [];
        $ids = collect($hits)->pluck('id')->unique()->values();
        if ($ids->isEmpty()) {
            return;
        }
        Product::whereIn('id', $ids)->get()->each->searchable();
    }
 }
@@ -0,0 +1,27 @@
 <?php
 namespace Modules\Core\Catalog\Recommendations;
 use Illuminate\Support\Collection;
 use Lunar\Models\Product;
 use Modules\Core\Catalog\Contracts\RecommendationRule;
 /**
 * The universal fallback — always returns something as long as the store
 * has more than one product, since it has no eligibility condition of its
 * own to come up empty on. Meant to be placed last in
 * config('catalog.recommendation_rules'), not first: every store using
 * the default chain gets a real fallback, but one that only kicks in once
 * more specific rules (same category, same tag, ...) have had a chance.
 */
 class RandomRule implements RecommendationRule
 {
    public function recommend(Product $product, int $limit, array $exclude): Collection
    {
        return Product::query()
            ->whereKeyNot($exclude)
            ->inRandomOrder()
            ->limit($limit)
            ->get();
    }
 }
@@ -0,0 +1,39 @@
 <?php
 namespace Modules\Core\Catalog\Recommendations;
 use Illuminate\Support\Collection;
 use Lunar\Models\Product;
 use Modules\Core\Catalog\Contracts\RecommendationRule;
 /**
 * Recommends other products sharing at least one of $product's directly-
 * assigned collections — takes $product's first collection (a product
 * usually has one primary category; if it has several, the first is as
 * good a choice as any without a "primary collection" concept to prefer).
 * Returns nothing if $product has no collection at all, letting the next
 * rule in the chain (see RecommendationRule's docblock) take over.
 *
 * Queries Eloquent directly rather than going through Modules\Core\Catalog\
 * Services\ProductService — this runs at index time (see
 * RecommendationRule's docblock), where Meilisearch may be mid-reindex for
 * this very product and ProductService::list()'s locale-resolution has no
 * meaningful "current locale" to resolve against anyway.
 */
 class SameCategoryRule implements RecommendationRule
 {
    public function recommend(Product $product, int $limit, array $exclude): Collection
    {
        $collection = $product->collections->first();
        if ($collection === null) {
            return collect();
        }
        return $collection->products()
            ->whereKeyNot($exclude)
            ->inRandomOrder()
            ->limit($limit)
            ->get();
    }
 }
@@ -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
@@ -44,6 +50,21 @@ use Spatie\MediaLibrary\MediaCollections\Models\Media;
 *     Reflects stock as of the last reindex only — nothing currently reindexes a
 *     product when an order decrements its stock (see docs/product-listing.md).
 *
 *   - recommendations (recommendations.id filterable): [{id, name, price, image}, ...]
 *     up to 4 other products to show alongside this one (a "related products"
 *     section), sourced from Modules\Core\Catalog\Services\RecommendationService's
 *     configured rule chain (config('catalog.recommendation_rules')). Embedded
 *     card data, not just ids, same reasoning as `collections`: renders
 *     directly with zero extra Meilisearch calls. `name` is resolved via
 *     translateAttribute() at index time (not through ProductService's
 *     per-request locale resolution, since indexing has no "current locale"
 *     the way a storefront request does) — same known index-time-locale
 *     tradeoff `collections` already has. `recommendations.id` is filterable
 *     specifically so Modules\Core\Catalog\Listeners\
 *     ReindexProductsRecommendingProduct can find every product currently
 *     recommending a given one, when that one changes — there's no Postgres
 *     relation for this, a recommendation only exists inside the index.
 *
 * A review is created/edited independently of its product (Modules\Core\Providers\
 * ReviewServiceProvider re-indexes the product on review create/update/delete), so
 * this data doesn't go stale between full reindexes.
@@ -67,6 +88,8 @@ class ProductIndexer extends BaseProductIndexer
            'slugs',
            'channel_ids',
            'in_stock',
            'recommendations.id',
            'skus',
        ];
    }
@@ -110,6 +133,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();
@@ -126,6 +150,16 @@ class ProductIndexer extends BaseProductIndexer
        $data['in_stock'] = $model->variants->contains(
            fn (ProductVariant $variant) => $variant->canBeFulfilledAtQuantity(1)
        );
        $data['recommendations'] = app(RecommendationService::class)
            ->recommend($model)
            ->load(['media', 'variants.prices'])
            ->map(fn (Product $recommendation) => [
                'id' => $recommendation->id,
                'name' => $recommendation->translateAttribute('name'),
                'price' => $this->cheapestPrice($recommendation, $currency),
                'image' => $recommendation->media->first() ? $this->mapMedia($recommendation->media->first())['thumb'] : null,
            ])
            ->all();
        return $data;
    }
@@ -135,8 +169,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,
@@ -3,10 +3,12 @@
 namespace Modules\Core\Catalog\Services;
 use Illuminate\Database\Eloquent\Collection;
 use Illuminate\Support\Facades\App;
 use Lunar\Facades\AttributeManifest;
 use Lunar\Models\Language;
 use Lunar\Models\Product;
 use Modules\Core\Catalog\DTOs\ProductFilters;
 use Modules\Core\Catalog\Enums\ProductSort;
 use Modules\Core\Catalog\Support\ProductFilterBuilder;
 /**
 * Lunar's Meilisearch indexer flattens translated attributes into locale-suffixed
@@ -17,39 +19,69 @@ use Lunar\Models\Product;
 */
 class ProductSearchService
 {
    public function __construct(
        private readonly ProductFilterBuilder $filterBuilder,
    ) {}
    /**
     * $filters/$sort apply the exact same semantics ProductService::list()
     * uses for collection browsing (same ProductFilterBuilder, same
     * ProductSort::toMeilisearchSort()) — a shopper narrowing a text search
     * by price/brand/stock gets identical filter behavior to narrowing a
     * category listing, since both go through the same Meilisearch `filter`
     * clause underneath.
     *
     * @return Collection<int, Product>
     */
-    public function search(string $query, ?string $locale = null): Collection
+    public function search(string $query, ?ProductFilters $filters = null, ?ProductSort $sort = null): Collection
    {
-        $locale ??= App::getLocale();
+        $options = [
-        $defaultLocale = Language::getDefault()->code;
+            'attributesToSearchOn' => $this->searchableFields(),
            'filter' => $this->filterBuilder->build($filters),
        ];
        if ($sort !== null) {
            $options['sort'] = [$sort->toMeilisearchSort()];
        }
        return Product::search($query)
-            ->options([
+            ->options($options)
                'attributesToSearchOn' => $this->searchableFields($locale, $defaultLocale),
            ])
            ->get();
    }
    /**
-     * Target the resolved locale's fields plus the default locale's fields, so a
+     * Targets every configured store language's fields, not just the current
-     * product that's only ever been translated into the default language still
+     * request locale plus the store default — a shopper browsing in Greek
-     * surfaces when searched in another locale, instead of becoming invisible
+     * typing an English word (or vice versa) should still match a product
-     * until every product is fully translated.
+     * whose only translation for that text happens to be in a third
     * language. There's no per-request "current locale" concept in this
     * method any more: which fields exist to search on is a property of the
     * store's configured languages, not of who's asking.
     *
     * Also targets variants.options.value directly — a variant's option
     * value (e.g. "Κάπτεν Γαμέρικα" on a "Name" option) is how ProductIndexer
     * already indexes it (see mapVariant()), but it isn't one of Lunar's own
     * attributes, so it can't come from AttributeManifest the way name/
     * description do; it's a structural field of the document, added here
     * directly instead. Not locale-suffixed like the attribute-manifest
     * fields — option values are stored as one already-resolved string per
     * variant (see ProductIndexer::translatedName()), not per-locale.
     *
     * @return array<int, string>
     */
-    private function searchableFields(string $locale, string $defaultLocale): array
+    private function searchableFields(): array
    {
        $handles = AttributeManifest::getSearchableAttributes(Product::morphName())
            ->pluck('handle');
-        $locales = array_unique([$locale, $defaultLocale]);
+        $locales = Language::all()->pluck('code');
-        return $handles
+        $attributeFields = $handles
            ->crossJoin($locales)
-            ->map(fn (array $pair) => "{$pair[0]}_{$pair[1]}")
+            ->map(fn (array $pair) => "{$pair[0]}_{$pair[1]}");
        return $attributeFields
            ->push('variants.options.value')
            ->values()
            ->all();
    }
@@ -4,14 +4,16 @@ namespace Modules\Core\Catalog\Services;
 use Illuminate\Contracts\Pagination\LengthAwarePaginator as LengthAwarePaginatorContract;
 use Illuminate\Pagination\LengthAwarePaginator;
 use Illuminate\Support\Collection;
 use Illuminate\Support\Facades\App;
 use Lunar\Base\AttributeManifest;
 use Lunar\FieldTypes\TranslatedText;
 use Lunar\Models\Product;
 use Modules\Core\Localization\Services\LanguageCache;
 use Modules\Core\Catalog\DTOs\PriceSliderBounds;
 use Modules\Core\Catalog\DTOs\ProductFilters;
 use Modules\Core\Catalog\DTOs\ProductListingResult;
 use Modules\Core\Catalog\Enums\ProductSort;
 use Modules\Core\Catalog\Support\ProductFilterBuilder;
 /**
 * Storefront product listing/filtering AND single-product lookup, all reading directly
@@ -27,17 +29,33 @@ class ProductService
    public function __construct(
        private readonly LanguageCache $languages,
        private readonly AttributeManifest $attributes,
        private readonly ProductFilterBuilder $filterBuilder,
    ) {}
    /**
-     * Returns a real LengthAwarePaginator (not Scout's own paginateRaw() result -
+     * One call for everything a listing page needs: the product page AND
-     * see "Meilisearch driver quirk" below) so a controller/view gets normal
+     * the price slider's bounds — a controller used to have to call this
-     * pagination behaviour ($products->links(), JSON serialization, etc.)
+     * plus priceSliderBounds() separately and glue the results together
-     * without ever touching the raw Meilisearch response directly.
+     * itself; that orchestration now happens in here instead. Still issues
     * two Meilisearch requests under the hood (the product search, and a
     * separate price-facet-stats query — see priceSliderBounds()'s
     * docblock for why they can't be merged into one without changing the
     * slider's own UX), but the caller only ever makes one call.
     *
     * $filters->minPrice/$filters->maxPrice double as both the applied
     * product filter AND the "is the slider actually narrowed" comparison
     * in priceSliderBounds() — the same values, used two ways, so nothing
     * new needs to be threaded through separately.
     *
     * The paginator itself is a real LengthAwarePaginator (not Scout's own
     * paginateRaw() result - see "Meilisearch driver quirk" below) so a
     * controller/view gets normal pagination behaviour ($products->links(),
     * JSON serialization, etc.) without ever touching the raw Meilisearch
     * response directly.
     */
-    public function list(?ProductFilters $filters = null, int $perPage = 24, int $page = 1, ?ProductSort $sort = null): LengthAwarePaginator
+    public function list(?ProductFilters $filters = null, int $perPage = 24, int $page = 1, ?ProductSort $sort = null): ProductListingResult
    {
-        $options = ['filter' => $this->buildFilter($filters)];
+        $options = ['filter' => $this->filterBuilder->build($filters)];
        if ($sort !== null) {
            $options['sort'] = [$sort->toMeilisearchSort()];
@@ -51,13 +69,17 @@ class ProductService
            ->map(fn (array $product) => $this->withLocalizedFields($product))
            ->all();
-        return new LengthAwarePaginator(
+        $products = new LengthAwarePaginator(
            items: $data,
            total: $paginator->total(),
            perPage: $paginator->perPage(),
            currentPage: $paginator->currentPage(),
            options: ['path' => LengthAwarePaginator::resolveCurrentPath()],
        );
        $priceBounds = $this->priceSliderBounds($filters, $filters?->minPrice, $filters?->maxPrice);
        return new ProductListingResult($products, $priceBounds);
    }
    /**
@@ -79,7 +101,7 @@ class ProductService
     */
    public function facets(string $field, ?ProductFilters $filters = null): array
    {
-        return $this->rawFacets($field, $this->buildFilter($filters))['facetDistribution'][$field] ?? [];
+        return $this->rawFacets($field, $this->filterBuilder->build($filters))['facetDistribution'][$field] ?? [];
    }
    /**
@@ -90,12 +112,17 @@ class ProductService
     * not `facetDistribution` — the right feature for a numeric field's range,
     * where `facets('price')` would otherwise return one entry per exact price.
     *
     * $query defaults to '' (every product, same as list()'s own default text
     * query) — pass the shopper's search text here too so a search page's own
     * price slider spans only the products that search actually matched,
     * rather than the whole catalog's price range.
     *
     * @return array{min: ?float, max: ?float} null/null if no product matches
     */
-    public function priceRange(?ProductFilters $filters = null): array
+    public function priceRange(?ProductFilters $filters = null, string $query = ''): array
    {
-        $filter = $this->buildFilter($filters, exclude: ['price']);
+        $filter = $this->filterBuilder->build($filters, exclude: ['price']);
-        $stats = $this->rawFacets('price', $filter)['facetStats']['price'] ?? null;
+        $stats = $this->rawFacets('price', $filter, $query)['facetStats']['price'] ?? null;
        return [
            'min' => $stats['min'] ?? null,
@@ -103,9 +130,36 @@ class ProductService
        ];
    }
-    private function rawFacets(string $field, ?string $filter): array
+    /**
     * priceRange() rounded to whole euros (floor/ceil, so the slider's ends
     * are never tighter than what's actually in range) plus whether
     * $selectedMinPrice/$selectedMaxPrice actually narrow it — the same
     * "floor/ceil + is this a real filter" rule CategoryController and
     * SearchController each used to duplicate inline. $selectedMinPrice/
     * $selectedMaxPrice are the currently-applied filter values (e.g.
     * CategoryListing::$minPrice), not part of $filters itself, since
     * $filters here must already exclude price the way priceRange() expects.
     */
    public function priceSliderBounds(
        ?ProductFilters $filters,
        ?float $selectedMinPrice,
        ?float $selectedMaxPrice,
        string $query = '',
    ): PriceSliderBounds {
        $priceRange = $this->priceRange($filters, $query);
        $floor = $priceRange['min'] !== null ? (int) floor($priceRange['min']) : null;
        $ceil = $priceRange['max'] !== null ? (int) ceil($priceRange['max']) : null;
        $filtered = ($selectedMinPrice !== null && $selectedMinPrice > ($floor ?? PHP_INT_MIN))
            || ($selectedMaxPrice !== null && $selectedMaxPrice < ($ceil ?? PHP_INT_MAX));
        return new PriceSliderBounds($floor, $ceil, $filtered);
    }
    private function rawFacets(string $field, ?string $filter, string $query = ''): array
    {
-        return Product::search('')
+        return Product::search($query)
            ->options([
                'filter' => $filter,
                'facets' => [$field],
@@ -133,15 +187,87 @@ class ProductService
        return $this->findOneWhere("id = \"{$id}\"");
    }
    /**
     * The id/price/image of every variant on a product document (from
     * getById()/getBySlug()'s own 'variants' array) — the base price and
     * thumbnail a variant picker/swatch list needs, without a caller
     * reaching into $product['variants'][n]['prices'][0]/['media'][0]
     * itself. Domain shaping (which price/image represents a variant),
     * not presentation — a card's href/layout stays a storefront concern
     * (e.g. App\Catalog\ProductCard in 3dealer), but "the variant's price
     * is its first price row" is a rule about the data, true regardless of
     * which app renders it.
     *
     * @param  array  $product  A document from getById()/getBySlug().
     * @return array<int, array{id: int, price: ?float, image: ?string}>
     */
    public function variantSummaries(array $product): array
    {
        return collect($product['variants'] ?? [])
            ->map(fn (array $variant) => [
                'id' => $variant['id'],
                'price' => $variant['prices'][0]['price'] ?? null,
                'image' => $variant['media'][0]['url'] ?? null,
            ])
            ->values()
            ->all();
    }
    /**
     * $limit random products, still scoped to the index's own default
     * visibility (channel/status), unlike Eloquent's Product::inRandomOrder()
     * which has no notion of that filtering at all — a random pick can never
     * surface a hidden/unpublished product this way. Meilisearch itself has
     * no ORDER BY RANDOM() equivalent, so this pulls every matching id only
     * (attributesToRetrieve: ['id'], the lightest possible request — no
     * name/media/variants/etc. for documents that will mostly be discarded),
     * shuffles in PHP, then fetches the full localized documents for just
     * the $limit ids actually picked.
     *
     * @return array<int, array>
     */
    public function random(int $limit): array
    {
        $raw = Product::search('')
            ->options(['attributesToRetrieve' => ['id']])
            ->raw();
        $ids = collect($raw['hits'] ?? [])->pluck('id')->shuffle()->take($limit)->values();
        if ($ids->isEmpty()) {
            return [];
        }
        // Meilisearch's `id IN [...]` doesn't preserve the given order — it's
        // an unordered set filter, not a list to iterate — so the shuffle
        // above would otherwise be silently undone by whatever order the
        // re-fetch comes back in. Re-sort the fetched documents back into
        // $ids's already-shuffled order instead of trusting the response's.
        $products = collect($this->findAllWhere('id IN ['.$ids->implode(', ').']'))
            ->keyBy('id');
        return $ids->map(fn ($id) => $products->get($id))->filter()->values()->all();
    }
    private function findOneWhere(string $filter): ?array
    {
        $products = $this->findAllWhere($filter, limit: 1);
        return $products[0] ?? null;
    }
    /**
     * @return array<int, array>
     */
    private function findAllWhere(string $filter, int $limit = 1000): array
    {
        $paginator = Product::search('')
            ->options(['filter' => $filter])
-            ->paginateRaw(perPage: 1, page: 1);
+            ->paginateRaw(perPage: $limit, page: 1);
-        $product = $this->hitsFrom($paginator)[0] ?? null;
+        return collect($this->hitsFrom($paginator))
-
+            ->map(fn (array $product) => $this->withLocalizedFields($product))
-        return $product !== null ? $this->withLocalizedFields($product) : null;
+            ->all();
    }
    /**
@@ -204,28 +330,4 @@ class ProductService
        return collect($rawResponse['hits'] ?? [])->values()->all();
    }
    /**
     * @param array<int, 'collectionId'|'brand'|'price'|'inStockOnly'> $exclude filter
     *   fields to leave out even if set on $filters — e.g. priceRange() excludes
     *   'price' so a price slider's own bounds don't shrink to whatever range is
     *   already selected on it.
     */
    private function buildFilter(?ProductFilters $filters, array $exclude = []): ?string
    {
        if ($filters === null) {
            return null;
        }
        $clauses = Collection::make([
            'collectionId' => $filters->collectionId !== null ? "collection_ids = \"{$filters->collectionId}\"" : null,
            'brand' => $filters->brand !== null ? 'brand = "'.addcslashes($filters->brand, '"\\').'"' : null,
            'price' => Collection::make([
                $filters->minPrice !== null ? "price >= {$filters->minPrice}" : null,
                $filters->maxPrice !== null ? "price <= {$filters->maxPrice}" : null,
            ])->filter()->join(' AND ') ?: null,
            'inStockOnly' => $filters->inStockOnly ? 'in_stock = true' : null,
        ])->except($exclude)->filter();
        return $clauses->isEmpty() ? null : $clauses->join(' AND ');
    }
 }
@@ -0,0 +1,47 @@
 <?php
 namespace Modules\Core\Catalog\Services;
 use Illuminate\Database\Eloquent\Collection;
 use Lunar\Models\Product;
 use Modules\Core\Catalog\Contracts\RecommendationRule;
 /**
 * Runs each rule in config('catalog.recommendation_rules'), in order,
 * topping up from each successive rule until $limit distinct products are
 * collected or every rule is exhausted — e.g. 3 from SameCategoryRule
 * (the product's category only has 3 other products) + 1 from RandomRule.
 * No rule is special-cased as "the fallback" here; a store gets fallback
 * behaviour purely by how it orders its own config (e.g. SameCategoryRule
 * before RandomRule). Never returns the same product twice even if two
 * rules would both suggest it (see RecommendationRule's $exclude), and
 * never returns fewer than $limit unless the store genuinely doesn't have
 * that many other products at all.
 */
 class RecommendationService
 {
    /**
     * @return Collection<int, Product>
     */
    public function recommend(Product $product, int $limit = 4): Collection
    {
        $recommendations = new Collection();
        foreach (config('catalog.recommendation_rules', []) as $ruleClass) {
            if ($recommendations->count() >= $limit) {
                break;
            }
            $exclude = [$product->id, ...$recommendations->pluck('id')];
            $remaining = $limit - $recommendations->count();
            /** @var RecommendationRule $rule */
            $rule = app($ruleClass);
            $recommendations = $recommendations->merge(
                $rule->recommend($product, $remaining, $exclude)
            );
        }
        return $recommendations->take($limit)->values();
    }
 }
@@ -0,0 +1,40 @@
 <?php
 namespace Modules\Core\Catalog\Support;
 use Illuminate\Support\Collection;
 use Modules\Core\Catalog\DTOs\ProductFilters;
 /**
 * Builds a Meilisearch `filter` clause from a ProductFilters DTO — extracted
 * out of ProductService (where it originated, scoped to browsing/filtering
 * without a search term) so ProductSearchService can apply the exact same
 * filter semantics to a text query too, rather than reimplementing it.
 */
 class ProductFilterBuilder
 {
    /**
     * @param  array<int, 'collectionId'|'brand'|'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.
     */
    public function build(?ProductFilters $filters, array $exclude = []): ?string
    {
        if ($filters === null) {
            return null;
        }
        $clauses = Collection::make([
            'collectionId' => $filters->collectionId !== null ? "collection_ids = \"{$filters->collectionId}\"" : null,
            'brand' => $filters->brand !== null ? 'brand = "'.addcslashes($filters->brand, '"\\').'"' : null,
            'price' => Collection::make([
                $filters->minPrice !== null ? "price >= {$filters->minPrice}" : null,
                $filters->maxPrice !== null ? "price <= {$filters->maxPrice}" : null,
            ])->filter()->join(' AND ') ?: null,
            'inStockOnly' => $filters->inStockOnly ? 'in_stock = true' : null,
        ])->except($exclude)->filter();
        return $clauses->isEmpty() ? null : $clauses->join(' AND ');
    }
 }
@@ -0,0 +1,67 @@
 <?php
 namespace Modules\Core\Command;
 use Illuminate\Console\Command;
 use Laravel\Scout\EngineManager;
 use Laravel\Scout\Engines\MeilisearchEngine;
 use Lunar\Models\Product;
 /**
 * lunarphp/meilisearch's own `lunar:meilisearch:setup` only pushes
 * filterableAttributes/sortableAttributes (see MeilisearchSetup::handle())
 * — it has no notion of typo tolerance or prefix search, and Meilisearch's
 * defaults for both are loose enough to produce bad matches on short Greek
 * words. Confirmed via showMatchesPosition that a query for "Κάπτεν" was
 * matching "κανένας" purely through prefixSearch's default 'indexingTime'
 * behavior (their edit distance is far past anything typo tolerance would
 * bridge) — fixed by disabling prefix search below, verified afterward with
 * "Super"/"Superheroes"-style prefix probes returning no results for a
 * partial word. minWordSizeForTypos is tightened defensively alongside it
 * so short words in general get less typo-tolerant fuzzing, even though a
 * separate short-word collision case ("Κάπτεν" vs "κάποτε", high letter
 * overlap despite real edit distance) persisted after both settings were
 * confirmed live and wasn't fully root-caused — treated as a known,
 * narrow edge case rather than a blocker. Run this after
 * `lunar:meilisearch:setup`, whenever Product's index needs
 * (re)provisioning.
 *
 * Disabling prefix search here is a deliberate tradeoff: it also turns off
 * legitimate partial-word matching (typing "car" matching "cart" before
 * you finish the word) — useful for a future autocomplete/search-as-you-
 * type UI. If that's built later, re-enable prefixSearch deliberately then,
 * informed by real UX needs, rather than leaving it on by accident today.
 */
 class TuneProductSearchCommand extends Command
 {
    protected $signature = 'lunar:meilisearch:tune-product-search';
    protected $description = 'Tighten typo-tolerance and disable prefix search on the product search index';
    public function handle(EngineManager $engineManager): void
    {
        /** @var MeilisearchEngine $engine */
        $engine = $engineManager->createMeilisearchDriver();
        $index = $engine->getIndex((new Product)->searchableAs());
        $this->components->info('Updating typo tolerance for product search...');
        $task = $index->updateTypoTolerance([
            'minWordSizeForTypos' => [
                'oneTypo' => 8,
                'twoTypos' => 12,
            ],
        ]);
        $engine->waitForTask($task['taskUid']);
        $this->components->info('Disabling prefix search for product search...');
        $task = $index->updatePrefixSearch('disabled');
        $engine->waitForTask($task['taskUid']);
        $this->components->info('Product search index tuned.');
    }
 }
@@ -76,6 +76,9 @@ class StorefrontLabels
            'shop.search_label' => ['en' => 'Search products', 'el' => 'Αναζήτηση προϊόντων'],
            'shop.search_placeholder' => ['en' => 'Search products…', 'el' => 'Αναζήτησε προϊόντα…'],
            'shop.filter_price' => ['en' => 'Filter by price', 'el' => 'Φίλτρο τιμής'],
            'shop.price_min' => ['en' => 'Min price', 'el' => 'Ελάχιστη τιμή'],
            'shop.price_max' => ['en' => 'Max price', 'el' => 'Μέγιστη τιμή'],
            'shop.reset' => ['en' => 'Reset', 'el' => 'Επαναφορά'],
            'shop.apply' => ['en' => 'Apply', 'el' => 'Εφαρμογή'],
            'shop.availability' => ['en' => 'Availability', 'el' => 'Διαθεσιμότητα'],
            'shop.in_stock_only' => ['en' => 'In-stock products only', 'el' => 'Μόνο διαθέσιμα προϊόντα'],
@@ -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,15 @@
 <?php
 namespace Modules\Core\Order\Enums;
 /**
 * Derived from Shipment/ShipmentInfo — no equivalent existed anywhere in
 * Lunar or this codebase before OrderStatus::fulfillment().
 */
 enum FulfillmentStatus: string
 {
    case Unfulfilled = 'unfulfilled';
    case Shipped = 'shipped';
    case PartiallyShipped = 'partially-shipped';
    case Delivered = 'delivered';
 }
@@ -0,0 +1,17 @@
 <?php
 namespace Modules\Core\Order\Enums;
 /**
 * Same states/logic as Lunar's own ManageOrder::paymentStatus(), which
 * only exists as a Filament-page Livewire #[Computed] method — this is
 * that same derivation, reusable from anywhere via Order::paymentStatus().
 */
 enum PaymentStatus: string
 {
    case Offline = 'offline';
    case Uncaptured = 'uncaptured';
    case Captured = 'captured';
    case PartialRefund = 'partial-refund';
    case Refunded = 'refunded';
 }
@@ -0,0 +1,24 @@
 <?php
 namespace Modules\Core\Order\Events;
 use Illuminate\Foundation\Events\Dispatchable;
 use Lunar\Models\Order;
 use Lunar\Models\Transaction;
 /**
 * Dispatched by TransactionObserver::saved() when a Transaction's type
 * changes to 'capture' (from 'intent') and succeeds. Unlike refunds,
 * Lunar's Stripe driver (StoreCharges) reuses the same Transaction row
 * across intent -> capture rather than creating a new one, so this can't
 * key off `wasRecentlyCreated` the way OrderRefunded does.
 */
 class OrderCaptured
 {
    use Dispatchable;
    public function __construct(
        public readonly Order $order,
        public readonly Transaction $transaction,
    ) {}
 }
@@ -0,0 +1,24 @@
 <?php
 namespace Modules\Core\Order\Events;
 use Illuminate\Foundation\Events\Dispatchable;
 use Lunar\Models\Order;
 use Modules\Core\Shipping\Models\ShipmentInfo;
 /**
 * Dispatched by Order's DeriveOrderDeliveredFromShipment listener, which
 * reacts to Shipping's ShipmentStatusUpdatedByCarrier — delivery is a
 * tracking checkpoint, not a manual status write, so it never goes through
 * OrderStatusUpdated. Order.status itself is left untouched here; this is
 * only the signal for delivery notifications and similar reactions.
 */
 class OrderDelivered
 {
    use Dispatchable;
    public function __construct(
        public readonly Order $order,
        public readonly ShipmentInfo $shipmentInfo,
    ) {}
 }
@@ -0,0 +1,25 @@
 <?php
 namespace Modules\Core\Order\Events;
 use Illuminate\Foundation\Events\Dispatchable;
 use Lunar\Models\Order;
 use Lunar\Models\Transaction;
 /**
 * Dispatched by TransactionObserver::saved() whenever a successful
 * type=refund Transaction row is written — every payment driver (Lunar's
 * own StripePaymentType::refund(), or a future boboko-owned driver for a
 * provider Lunar doesn't ship) creates a new row for each refund, so
 * `created` alone (filtered to type+success) is enough here, unlike
 * captures which can reuse an existing row.
 */
 class OrderRefunded
 {
    use Dispatchable;
    public function __construct(
        public readonly Order $order,
        public readonly Transaction $transaction,
    ) {}
 }
@@ -0,0 +1,25 @@
 <?php
 namespace Modules\Core\Order\Events;
 use Illuminate\Foundation\Events\Dispatchable;
 use Lunar\Models\Order;
 /**
 * Dispatched by OrderObserver::updated() whenever an Order's status column
 * changes, regardless of what wrote it — Filament's UpdateStatusAction,
 * artisan tinker, a future API. Lunar's own UpdatesOrderStatus trait fires
 * mailers inline, but only for that one admin action; this event is the
 * general-purpose hook everything else (our own mailers, automations,
 * derived payment/fulfillment status) should listen to instead.
 */
 class OrderStatusUpdated
 {
    use Dispatchable;
    public function __construct(
        public readonly Order $order,
        public readonly ?string $previousStatus,
        public readonly string $newStatus,
    ) {}
 }
@@ -0,0 +1,31 @@
 <?php
 namespace Modules\Core\Order\Listeners;
 use Modules\Core\Order\Events\OrderDelivered;
 use Modules\Core\Shipping\Enums\TrackingStatus;
 use Modules\Core\Shipping\Events\ShipmentStatusUpdatedByCarrier;
 /**
 * Translates a carrier tracking checkpoint into OrderDelivered — the event
 * OrderDeliveredNotification (via NotificationRegistry) actually listens
 * to. Kept separate from the notification itself so the "is this checkpoint
 * a delivery" filtering doesn't leak into notification code.
 */
 class DeriveOrderDeliveredFromShipment
 {
    public function handle(ShipmentStatusUpdatedByCarrier $event): void
    {
        if ($event->shipmentInfo->status !== TrackingStatus::Delivered) {
            return;
        }
        $order = $event->shipmentInfo->shipment->order;
        if (! $order) {
            return;
        }
        OrderDelivered::dispatch($order, $event->shipmentInfo);
    }
 }
@@ -0,0 +1,50 @@
 <?php
 namespace Modules\Core\Order\Notifications;
 use Illuminate\Notifications\AnonymousNotifiable;
 use Illuminate\Notifications\Messages\MailMessage;
 use Illuminate\Support\Facades\Notification as NotificationFacade;
 use Modules\Core\Notification\BaseNotification;
 use Modules\Core\Order\Events\OrderCaptured;
 class OrderCapturedNotification extends BaseNotification
 {
    public function __construct(private readonly OrderCaptured $event) {}
    public static function getKey(): string
    {
        return 'order.captured.customer.mail';
    }
    public static function listensTo(): string
    {
        return OrderCaptured::class;
    }
    public function via(object $notifiable): array
    {
        return ['mail'];
    }
    public function notifiable(): AnonymousNotifiable
    {
        $order = $this->event->order;
        $email = $order->billingAddress?->contact_email ?? $order->shippingAddress?->contact_email;
        return NotificationFacade::route('mail', $email);
    }
    public function toMail(object $notifiable): MailMessage
    {
        $order = $this->event->order;
        return (new MailMessage)
            ->subject(__('Payment captured for your order :reference', ['reference' => $order->reference]))
            ->view('core::order.notifications.captured', [
                'reference' => $order->reference,
                'amount' => $this->event->transaction->amount->formatted,
            ]);
    }
 }
@@ -0,0 +1,49 @@
 <?php
 namespace Modules\Core\Order\Notifications;
 use Illuminate\Notifications\AnonymousNotifiable;
 use Illuminate\Notifications\Messages\MailMessage;
 use Illuminate\Support\Facades\Notification as NotificationFacade;
 use Modules\Core\Notification\BaseNotification;
 use Modules\Core\Order\Events\OrderDelivered;
 class OrderDeliveredNotification extends BaseNotification
 {
    public function __construct(private readonly OrderDelivered $event) {}
    public static function getKey(): string
    {
        return 'order.delivered.customer.mail';
    }
    public static function listensTo(): string
    {
        return OrderDelivered::class;
    }
    public function via(object $notifiable): array
    {
        return ['mail'];
    }
    public function notifiable(): AnonymousNotifiable
    {
        $order = $this->event->order;
        $email = $order->billingAddress?->contact_email ?? $order->shippingAddress?->contact_email;
        return NotificationFacade::route('mail', $email);
    }
    public function toMail(object $notifiable): MailMessage
    {
        $order = $this->event->order;
        return (new MailMessage)
            ->subject(__('Your order :reference has been delivered', ['reference' => $order->reference]))
            ->view('core::order.notifications.delivered', [
                'reference' => $order->reference,
            ]);
    }
 }
@@ -0,0 +1,50 @@
 <?php
 namespace Modules\Core\Order\Notifications;
 use Illuminate\Notifications\AnonymousNotifiable;
 use Illuminate\Notifications\Messages\MailMessage;
 use Illuminate\Support\Facades\Notification as NotificationFacade;
 use Modules\Core\Notification\BaseNotification;
 use Modules\Core\Order\Events\OrderRefunded;
 class OrderRefundedNotification extends BaseNotification
 {
    public function __construct(private readonly OrderRefunded $event) {}
    public static function getKey(): string
    {
        return 'order.refunded.customer.mail';
    }
    public static function listensTo(): string
    {
        return OrderRefunded::class;
    }
    public function via(object $notifiable): array
    {
        return ['mail'];
    }
    public function notifiable(): AnonymousNotifiable
    {
        $order = $this->event->order;
        $email = $order->billingAddress?->contact_email ?? $order->shippingAddress?->contact_email;
        return NotificationFacade::route('mail', $email);
    }
    public function toMail(object $notifiable): MailMessage
    {
        $order = $this->event->order;
        return (new MailMessage)
            ->subject(__('A refund has been issued for your order :reference', ['reference' => $order->reference]))
            ->view('core::order.notifications.refunded', [
                'reference' => $order->reference,
                'amount' => $this->event->transaction->amount->formatted,
            ]);
    }
 }
@@ -0,0 +1,50 @@
 <?php
 namespace Modules\Core\Order\Notifications;
 use Illuminate\Notifications\AnonymousNotifiable;
 use Illuminate\Notifications\Messages\MailMessage;
 use Illuminate\Support\Facades\Notification as NotificationFacade;
 use Modules\Core\Notification\BaseNotification;
 use Modules\Core\Order\Events\OrderStatusUpdated;
 class OrderStatusUpdatedNotification extends BaseNotification
 {
    public function __construct(private readonly OrderStatusUpdated $event) {}
    public static function getKey(): string
    {
        return 'order.status_updated.customer.mail';
    }
    public static function listensTo(): string
    {
        return OrderStatusUpdated::class;
    }
    public function via(object $notifiable): array
    {
        return ['mail'];
    }
    public function notifiable(): AnonymousNotifiable
    {
        $order = $this->event->order;
        $email = $order->billingAddress?->contact_email ?? $order->shippingAddress?->contact_email;
        return NotificationFacade::route('mail', $email);
    }
    public function toMail(object $notifiable): MailMessage
    {
        $order = $this->event->order;
        return (new MailMessage)
            ->subject(__('Your order :reference has been updated', ['reference' => $order->reference]))
            ->view('core::order.notifications.status-updated', [
                'reference' => $order->reference,
                'statusLabel' => config("lunar.orders.statuses.{$order->status}.label", $order->status),
            ]);
    }
 }
@@ -0,0 +1,22 @@
 <?php
 namespace Modules\Core\Order\Observers;
 use Lunar\Models\Order;
 use Modules\Core\Order\Events\OrderStatusUpdated;
 class OrderObserver
 {
    public function updated(Order $order): void
    {
        if (! $order->wasChanged('status')) {
            return;
        }
        OrderStatusUpdated::dispatch(
            $order,
            $order->getOriginal('status'),
            $order->status,
        );
    }
 }
@@ -0,0 +1,27 @@
 <?php
 namespace Modules\Core\Order\Observers;
 use Lunar\Models\Transaction;
 use Modules\Core\Order\Events\OrderCaptured;
 use Modules\Core\Order\Events\OrderRefunded;
 class TransactionObserver
 {
    public function saved(Transaction $transaction): void
    {
        if (! $transaction->success) {
            return;
        }
        if ($transaction->type === 'refund' && $transaction->wasRecentlyCreated) {
            OrderRefunded::dispatch($transaction->order, $transaction);
            return;
        }
        if ($transaction->type === 'capture' && $transaction->wasChanged('type')) {
            OrderCaptured::dispatch($transaction->order, $transaction);
        }
    }
 }
@@ -0,0 +1,93 @@
 <?php
 namespace Modules\Core\Order\Support;
 use Lunar\Models\Order;
 use Modules\Core\Order\Enums\FulfillmentStatus;
 use Modules\Core\Order\Enums\PaymentStatus;
 use Modules\Core\Shipping\Enums\TrackingStatus;
 /**
 * Payment/fulfillment state, derived on read from transactions and
 * shipments rather than stored — mirrors the logic Lunar's own
 * ManageOrder::paymentStatus() computes as a Livewire #[Computed] method
 * (Filament-page-only, not reusable), reimplemented here as a plain,
 * queryable value any code can call via Order::macro() in
 * OrderServiceProvider.
 */
 class OrderStatus
 {
    public static function payment(Order $order): PaymentStatus
    {
        $transactions = $order->transactions;
        $intentTotal = $transactions
            ->filter(fn ($t) => $t->type === 'intent' && $t->success)
            ->sum('amount.value');
        $captureTotal = $transactions
            ->filter(fn ($t) => $t->type === 'capture' && $t->success)
            ->sum('amount.value');
        $refundTotal = $transactions
            ->filter(fn ($t) => $t->type === 'refund' && $t->success)
            ->sum('amount.value');
        $total = $intentTotal ?: $captureTotal;
        if (! $total) {
            return PaymentStatus::Offline;
        }
        if (
            ($refundTotal && $refundTotal < $total) ||
            ($captureTotal && $captureTotal < $intentTotal)
        ) {
            return PaymentStatus::PartialRefund;
        }
        if ($refundTotal >= $total) {
            return PaymentStatus::Refunded;
        }
        if ($captureTotal >= $intentTotal) {
            return PaymentStatus::Captured;
        }
        return PaymentStatus::Uncaptured;
    }
    /**
     * Reads shipments.shipmentInfo if already eager-loaded (the caller's
     * job — e.g. Order::with('shipments.shipmentInfo')) and picks the
     * latest checkpoint in PHP, instead of Shipment::latestShipmentInfo()'s
     * per-shipment query — calling this across a list of orders would
     * otherwise be an extra query per shipment.
     */
    public static function fulfillment(Order $order): FulfillmentStatus
    {
        $shipments = $order->shipments->reject(fn ($shipment) => $shipment->cancelled_at !== null);
        if ($shipments->isEmpty()) {
            return FulfillmentStatus::Unfulfilled;
        }
        $latestStatuses = $shipments->map(function ($shipment) {
            $latest = $shipment->relationLoaded('shipmentInfo')
                ? $shipment->shipmentInfo->sortByDesc('occurred_at')->first()
                : $shipment->latestShipmentInfo();
            return $latest?->status ?? TrackingStatus::Pending;
        });
        if ($latestStatuses->every(fn (TrackingStatus $status) => $status === TrackingStatus::Delivered)) {
            return FulfillmentStatus::Delivered;
        }
        if ($latestStatuses->contains(fn (TrackingStatus $status) => $status === TrackingStatus::Delivered)) {
            return FulfillmentStatus::PartiallyShipped;
        }
        return FulfillmentStatus::Shipped;
    }
 }
@@ -2,17 +2,32 @@
 namespace Modules\Core\Providers;
 use Illuminate\Console\Scheduling\Schedule;
 use Illuminate\Support\Facades\Event;
 use Illuminate\Support\ServiceProvider;
 use Lunar\Models\Product;
 use Lunar\Models\ProductOption;
 use Lunar\Models\ProductOptionValue;
 use Modules\Core\Catalog\Events\ProductDeleted;
 use Modules\Core\Catalog\Events\ProductSaved;
 use Modules\Core\Catalog\Listeners\ReindexProductsRecommendingProduct;
 use Modules\Core\Catalog\Observers\ProductOptionReindexObserver;
 use Modules\Core\Catalog\OptionTypes\ColorOptionType;
 use Modules\Core\Catalog\Services\ProductOptionTypeManager;
 class CatalogServiceProvider extends ServiceProvider
 {
    public function register(): void
    {
        $this->mergeConfigFrom(__DIR__ . '/../../config/catalog.php', 'catalog');
    }
    public function boot(): void
    {
        $this->publishes([
            __DIR__ . '/../../config/catalog.php' => config_path('catalog.php'),
        ], 'core-config');
        ProductOptionTypeManager::get()->register([
            ColorOptionType::class,
        ]);
@@ -24,5 +39,28 @@ class CatalogServiceProvider extends ServiceProvider
        ProductOptionValue::saved(fn (ProductOptionValue $value) => $observer->valueSaved($value));
        ProductOptionValue::deleted(fn (ProductOptionValue $value) => $observer->valueDeleted($value));
        Product::saved(fn (Product $product) => Event::dispatch(new ProductSaved($product)));
        Product::deleted(fn (Product $product) => Event::dispatch(new ProductDeleted($product->id)));
        Event::listen(ProductSaved::class, [ReindexProductsRecommendingProduct::class, 'handleSaved']);
        Event::listen(ProductDeleted::class, [ReindexProductsRecommendingProduct::class, 'handleDeleted']);
        $this->app->booted(function () {
            // A full nightly reindex, on top of the per-event reindexing
            // above — catches everything event-driven reindexing
            // deliberately doesn't cover: a newly-created product not yet
            // appearing as a recommendation elsewhere, in_stock/price
            // drifting from an order decrementing stock outside a product
            // save, and any other staleness ProductIndexer's own docblock
            // already documents as accepted between reindexes. --refresh
            // re-syncs filterable/sortable field settings too, not just
            // documents, so a deploy that changed ProductIndexer's field
            // list self-heals here even if `lunar:meilisearch:setup`
            // wasn't run manually after that deploy.
            $this->app->make(Schedule::class)
                ->command('lunar:search:index', ['Lunar\\Models\\Product', '--refresh'])
                ->dailyAt('03:00');
        });
    }
 }
@@ -10,6 +10,7 @@ use Modules\Core\Command\ExportCommand;
 use Modules\Core\Command\ImportCommand;
 use Modules\Core\Command\InstallLunarCommand;
 use Modules\Core\Command\MigrateImportCommand;
 use Modules\Core\Command\TuneProductSearchCommand;
 class CoreServiceProvider extends ServiceProvider
 {
@@ -35,7 +36,7 @@ class CoreServiceProvider extends ServiceProvider
        ], 'core-assets');
        if ($this->app->runningInConsole()) {
-            $this->commands([AnonymizeCommand::class, ExportCommand::class, ExportCleanupCommand::class, ImportCommand::class, MigrateImportCommand::class]);
+            $this->commands([AnonymizeCommand::class, ExportCommand::class, ExportCleanupCommand::class, ImportCommand::class, MigrateImportCommand::class, TuneProductSearchCommand::class]);
            //Overriding lunar:install
            $this->app->booted(fn () => $this->commands([InstallLunarCommand::class]));
@@ -0,0 +1,47 @@
 <?php
 namespace Modules\Core\Providers;
 use Illuminate\Support\Facades\Event;
 use Illuminate\Support\ServiceProvider;
 use Lunar\Models\Order;
 use Lunar\Models\Transaction;
 use Modules\Core\Notification\NotificationRegistry;
 use Modules\Core\Order\Listeners\DeriveOrderDeliveredFromShipment;
 use Modules\Core\Order\Notifications\OrderCapturedNotification;
 use Modules\Core\Order\Notifications\OrderDeliveredNotification;
 use Modules\Core\Order\Notifications\OrderRefundedNotification;
 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\Shipping\Events\ShipmentStatusUpdatedByCarrier;
 class OrderServiceProvider extends ServiceProvider
 {
    public function boot(): void
    {
        Order::observe(OrderObserver::class);
        Transaction::observe(TransactionObserver::class);
        Order::macro('paymentStatus', fn () => OrderStatus::payment($this));
        Order::macro('fulfillmentStatus', fn () => OrderStatus::fulfillment($this));
        Event::listen(ShipmentStatusUpdatedByCarrier::class, DeriveOrderDeliveredFromShipment::class);
        NotificationRegistry::get()->register([
            OrderDeliveredNotification::class,
            OrderStatusUpdatedNotification::class,
            OrderRefundedNotification::class,
            OrderCapturedNotification::class,
        ]);
        // Lets the consuming app override copy/markup without forking core
        // — published into resources/views/vendor/core/order/notifications,
        // which loadViewsFrom() (CoreServiceProvider) already resolves
        // ahead of the package's own views for the `core::` namespace.
        $this->publishes([
            __DIR__ . '/../../resources/views/order/notifications' => resource_path('views/vendor/core/order/notifications'),
        ], 'core-views');
    }
 }
Author	SHA1	Message	Date
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	448da869a9	Bump version to 0.12.0	2026-09-03 11:44:36 +03:00
arvanitakis	1287b513cd	Feat: Updating Product Service with new Methods, DTOs for ListingResult And Slider Bounds	2026-09-03 11:44:23 +03:00
arvanitakis	b2919f1f4b	Feature: Product Search Service Updates	2026-09-03 11:04:19 +03:00
arvanitakis	3497553b41	Feature: Order Service Provider, Order Events Observers	2026-09-01 14:04:12 +03:00
arvanitakis	29e77a973b	Feat: Orders Feature Survey	2026-09-01 13:34:37 +03:00
arvanitakis	026ab5bc2d	BUmp version to 0.11.1	2026-09-01 13:04:54 +03:00
arvanitakis	483c0ce00f	Fix: Recommendations are an eloquent collection, not an Generic Collection	2026-09-01 13:03:39 +03:00
arvanitakis	ce405d20e6	Bump Version to 0.11.0	2026-09-01 12:08:47 +03:00
arvanitakis	0f07751559	Feature: Recommendation Service This commit introduces a RecommendationService that is used when indexing products. The service is utilizing a recommendation rules interface, so many rules can be created and applied during indexing the products	2026-09-01 12:06:29 +03:00
arvanitakis	53d8a5aefe	Bump Version to 0.10.1	2026-09-01 12:04:06 +03:00
arvanitakis	380e860386	Feat: Adding Translations to the Seeder	2026-09-01 10:52:56 +03:00
		`@@ -0,0 +1,3 @@`
							`<p>Hi,</p>`

							`<p>Payment of <strong>{{ $amount }}</strong> for your order <strong>{{ $reference }}</strong> has been captured.</p>`
		`@@ -0,0 +1,3 @@`
							`<p>Hi,</p>`

							`<p>Good news — your order <strong>{{ $reference }}</strong> has been delivered.</p>`
		`@@ -0,0 +1,3 @@`
							`<p>Hi,</p>`

							`<p>A refund of <strong>{{ $amount }}</strong> has been issued for your order <strong>{{ $reference }}</strong>.</p>`
		`@@ -0,0 +1,3 @@`
							`<p>Hi,</p>`

							`<p>Your order <strong>{{ $reference }}</strong> is now: <strong>{{ $statusLabel }}</strong></p>`