Skip to content

armgit / spree

Public Imported from GitHub
0

Open Source Platform for DTC, B2B Commerce, Marketplaces & Omnichannel. REST APIs, TypeScript SDKs, and production-ready Next.js storefront. Self-host it. Own your data. No vendor lock-in. Zero platform fees.

WIP base: uncommitted working-copy state from feature/6-0-core-rewrite

Damian Legawiec45cfaf23e76c
diff --git a/.zed/settings.json b/.zed/settings.json
index 51dd8a0bc4..f82e8dda1b 100644
--- a/.zed/settings.json
+++ b/.zed/settings.json
@@ -7,6 +7,15 @@
"source.fixAll.biome": true,
"source.organizeImports.biome": true
},
+ "lsp": {
+ "ruby-lsp": {
+ "binary": {
+ "env": {
+ "BUNDLE_GEMFILE": "spree/Gemfile"
+ }
+ }
+ }
+ },
"languages": {
"TypeScript": {
"language_servers": ["biome", "vtsls", "!typescript-language-server", "!eslint"]
diff --git a/packages/dashboard-core/src/components/page-header.tsx b/packages/dashboard-core/src/components/page-header.tsx
index 6e9fdd53d1..3ab091cb2e 100644
--- a/packages/dashboard-core/src/components/page-header.tsx
+++ b/packages/dashboard-core/src/components/page-header.tsx
@@ -138,9 +138,9 @@ export function PageHeader({
// the same hairline used elsewhere in the app.
<header
className={cn(
- 'sticky top-header-height z-20 -mx-4 -mt-4 flex items-start gap-3 bg-background px-4 pt-4 pb-3 lg:-mx-6 lg:-mt-6 lg:px-6 lg:pt-6',
+ 'sticky top-header-height z-20 -mx-4 -mt-4 flex items-start gap-3 bg-background/90 backdrop-blur supports-[backdrop-filter]:bg-background/75 px-4 pt-4 pb-3 lg:-mx-6 lg:-mt-6 lg:px-6 lg:pt-6',
'after:pointer-events-none after:absolute after:inset-x-0 after:bottom-0 after:h-px after:bg-border after:opacity-0 after:transition-opacity after:duration-150 after:[mask-image:linear-gradient(to_right,transparent,black_8%,black_92%,transparent)]',
- scrolled && 'after:opacity-100',
+ scrolled && 'after:opacity-100 shadow-xs',
)}
>
{backTo && <BackButton fallback={backTo} />}
diff --git a/packages/dashboard-ui/src/spree/back-button.tsx b/packages/dashboard-ui/src/spree/back-button.tsx
index 8e0800bfcf..97524d8495 100644
--- a/packages/dashboard-ui/src/spree/back-button.tsx
+++ b/packages/dashboard-ui/src/spree/back-button.tsx
@@ -38,7 +38,7 @@ export function BackButton({ fallback, className }: BackButtonProps) {
onClick={handleClick}
className={
className ??
- 'inline-flex items-center justify-center rounded-lg p-1.5 text-muted-foreground hover:bg-accent hover:text-foreground transition-colors'
+ 'inline-flex items-center justify-center rounded-lg p-1.5 text-muted-foreground bg-transparent hover:bg-accent hover:text-foreground transition-colors'
}
aria-label={t('admin.actions.back')}
>
diff --git a/spree/core/app/models/spree/cart.rb b/spree/core/app/models/spree/cart.rb
index 04409054e3..b8f34c2042 100644
--- a/spree/core/app/models/spree/cart.rb
+++ b/spree/core/app/models/spree/cart.rb
@@ -304,9 +304,12 @@ module Spree
def set_fulfillments_cost
fulfillments.each(&:update_amounts)
- calculator = Spree::CartUpdater.new(self)
- calculator.update_delivery_total
- calculator.persist_totals
+ self.delivery_total = fulfillments.reload.to_a.sum(&:cost)
+ update_columns(
+ delivery_total: delivery_total,
+ total: item_total + delivery_total + adjustment_total,
+ updated_at: Time.current
+ )
end
alias set_shipments_cost set_fulfillments_cost
alias create_proposed_fulfillments rebuild_fulfillments!
diff --git a/spree/core/app/models/spree/fulfillment.rb b/spree/core/app/models/spree/fulfillment.rb
index 2632421978..7d97a47001 100644
--- a/spree/core/app/models/spree/fulfillment.rb
+++ b/spree/core/app/models/spree/fulfillment.rb
@@ -632,8 +632,7 @@ module Spree
def update_order_fulfillment_status
return if order.nil?
- new_status = OrderUpdater.new(order).update_fulfillment_status
- order.update_columns(fulfillment_status: new_status, updated_at: Time.current)
+ Spree::Orders::RecomputeStatuses.call(order: order)
end
# publish_shipment_shipped_event, publish_shipment_canceled_event, and
diff --git a/spree/core/app/models/spree/order.rb b/spree/core/app/models/spree/order.rb
index 92f708ccec..85c6412752 100644
--- a/spree/core/app/models/spree/order.rb
+++ b/spree/core/app/models/spree/order.rb
@@ -669,17 +669,14 @@ module Spree
# freeze (OrderUpdater#recalculate_adjustments) once completed — no
# per-row locking needed.
- # update payment and shipment(s) states, and save
- updater.update_payment_state
fulfillments.each do |shipment|
shipment.update!(self)
shipment.finalize!
end
- updater.update_fulfillment_status
self.status = 'placed'
save!
- updater.run_hooks
+ update_hooks.each { |hook| send(hook) }
touch :completed_at
@@ -692,13 +689,15 @@ module Spree
Spree::Fulfillments::AutoFulfill.call(order: self)
+ Spree::Orders::RecomputeStatuses.call(order: self)
+
publish_order_placed_event
end
def fulfill!
fulfillments.each { |shipment| shipment.update!(self) if shipment.persisted? }
- updater.update_fulfillment_status
save!
+ Spree::Orders::RecomputeStatuses.call(order: self)
end
# Helper methods for checkout steps
@@ -900,9 +899,7 @@ module Spree
def set_shipments_cost
fulfillments.each(&:update_amounts)
- updater.update_delivery_total
- updater.update_adjustment_total
- persist_totals
+ recalculate_totals!
end
def shipping_method
@@ -1185,7 +1182,7 @@ module Spree
end
def recalculate_store_credit_payment
- updater.update_adjustment_total if using_store_credit?
+ recalculate_totals! if using_store_credit?
if gift_card.present?
recalculate_gift_card
diff --git a/spree/core/app/models/spree/payment.rb b/spree/core/app/models/spree/payment.rb
index bff511ef0e..f98924cc22 100644
--- a/spree/core/app/models/spree/payment.rb
+++ b/spree/core/app/models/spree/payment.rb
@@ -390,15 +390,10 @@ module Spree
end
def update_order
- owner.updater.update_payment_total if completed? || void?
+ return unless completed? || void? || (owner.is_a?(Spree::Order) && owner.completed?)
- if owner.is_a?(Spree::Order) && owner.completed?
- owner.updater.update_payment_state
- owner.updater.update_fulfillments
- owner.updater.update_fulfillment_status
- end
-
- owner.updater.persist_totals if completed? || (owner.is_a?(Spree::Order) && owner.completed?)
+ owner.recalculate_totals!
+ Spree::Orders::RecomputeStatuses.call(order: owner) if owner.is_a?(Spree::Order) && owner.completed?
end
def create_eligible_credit_event
diff --git a/spree/core/app/services/spree/carts/empty.rb b/spree/core/app/services/spree/carts/empty.rb
index 07e9b84f46..538c94d07c 100644
--- a/spree/core/app/services/spree/carts/empty.rb
+++ b/spree/core/app/services/spree/carts/empty.rb
@@ -24,7 +24,7 @@ module Spree
def empty_order(cart:)
ActiveRecord::Base.transaction do
cart.line_items.destroy_all
- Spree::CartUpdater.new(cart).update_item_count
+ cart.update_columns(total_quantity: 0, updated_at: Time.current)
cart.tax_lines.destroy_all
cart.discounts.destroy_all
cart.fees.destroy_all
diff --git a/spree/core/app/services/spree/orders/add_manual_discount.rb b/spree/core/app/services/spree/orders/add_manual_discount.rb
index 8a7a5305b4..50a0a517e3 100644
--- a/spree/core/app/services/spree/orders/add_manual_discount.rb
+++ b/spree/core/app/services/spree/orders/add_manual_discount.rb
@@ -22,7 +22,7 @@ module Spree
rows = order.with_lock do
created = line_item ? [line_item_row(order, line_item, label, value, value_type)].compact : distributed_rows(order, label, value, value_type)
- order.updater.resum_typed_totals! if created.any?
+ Spree.order_recalculate_totals_workflow.call(order: order) if created.any?
created
end
diff --git a/spree/core/app/services/spree/orders/recompute_statuses.rb b/spree/core/app/services/spree/orders/recompute_statuses.rb
index d73def45ff..48c69e2c53 100644
--- a/spree/core/app/services/spree/orders/recompute_statuses.rb
+++ b/spree/core/app/services/spree/orders/recompute_statuses.rb
@@ -11,6 +11,7 @@ module Spree
PAYMENT_STATUSES = %w[none authorized partially_paid paid partially_refunded refunded overcharged voided].freeze
def call(order:)
+ refresh_fulfillment_states(order)
order.update_columns(
payment_status: payment_status_for(order),
fulfillment_status: fulfillment_status_for(order),
@@ -21,6 +22,14 @@ module Spree
private
+ # A fulfillment's own state depends on payment coverage
+ # (Fulfillment#determine_state) — refresh each before rolling up.
+ def refresh_fulfillment_states(order)
+ order.fulfillments.each do |fulfillment|
+ fulfillment.update!(order) if fulfillment.persisted?
+ end
+ end
+
# Money is quantized to currency precision before comparing, and
# granted refunds are subtracted from the target total — the two rules
# every derivation implementation gets wrong first.
@@ -53,10 +62,27 @@ module Spree
end
end
- # Domain owned by the fulfillment plan (incl. backorder) — same rollup
- # OrderUpdater#update_fulfillment_status computes.
+ # fulfilled when all fulfillments fulfilled; partial when mixed with
+ # fulfilled; ready when all ready (ready_for_pickup rolls up as
+ # ready); backorder when backordered inventory exists; pending when
+ # all pending.
def fulfillment_status_for(order)
- Spree::OrderUpdater.new(order).update_fulfillment_status
+ return 'backorder' if order.backordered?
+
+ statuses = order.fulfillments.states.map { |status| status == 'ready_for_pickup' ? 'ready' : status }.uniq
+
+ if statuses.size > 1
+ if statuses.include?('fulfilled')
+ 'partial'
+ elsif statuses.include?('pending')
+ 'pending'
+ else
+ 'ready'
+ end
+ else
+ # nil when there are no fulfillments
+ statuses.first
+ end
end
def quantize(amount, precision)
diff --git a/spree/core/app/services/spree/shipments/update.rb b/spree/core/app/services/spree/shipments/update.rb
index a1de7b6191..9159934d66 100644
--- a/spree/core/app/services/spree/shipments/update.rb
+++ b/spree/core/app/services/spree/shipments/update.rb
@@ -17,8 +17,7 @@ module Spree
# might change the Order#payment_state)
shipment.update_amounts
- order.updater.update_delivery_total
- order.updater.update_payment_state
+ order.recalculate_totals!
# Update shipment state only after order total is updated because it
# (via Order#paid?) affects the shipment state (YAY)
@@ -27,10 +26,8 @@ module Spree
updated_at: Time.current
)
- # And then it's time to update shipment states and finally persist
- # order changes
- order.updater.update_fulfillment_status
- order.updater.persist_totals
+ # And then derive the order-level statuses from the new state
+ Spree::Orders::RecomputeStatuses.call(order: order)
end
end
success(shipment)
diff --git a/spree/core/app/workflows/spree/carts/recalculate.rb b/spree/core/app/workflows/spree/carts/recalculate.rb
index 22722fb655..bd09f8493c 100644
--- a/spree/core/app/workflows/spree/carts/recalculate.rb
+++ b/spree/core/app/workflows/spree/carts/recalculate.rb
@@ -11,7 +11,9 @@ module Spree
super(cart: cart, line_item: line_item, line_item_created: line_item_created, options: options)
step :unapply_stale_payment_sources
- step :refresh_totals
+ # Totals must be current before the proposal rebuild — delivery
+ # rate calculators (e.g. price sack) read them.
+ step :refresh_totals, with: -> { Spree.cart_recalculate_totals_workflow }
step :rebuild_delivery_proposals
step :activate_promotions
# Typed rows (discounts + tax) are rebuilt by the full recalculation.
@@ -27,15 +29,6 @@ module Spree
cart.payments.store_credits.checkout.destroy_all if cart.payments.store_credits.checkout.any?
end
- # Totals must be current before the proposal rebuild — delivery rate
- # calculators (e.g. price sack) read them.
- def refresh_totals
- calculator = cart.is_a?(Spree::Order) ? Spree::OrderUpdater.new(cart) : Spree::CartUpdater.new(cart)
- calculator.update_item_count
- calculator.update_totals
- calculator.persist_totals
- end
-
def rebuild_delivery_proposals
cart.ensure_updated_fulfillments
end
diff --git a/spree/core/app/workflows/spree/carts/recalculate_totals.rb b/spree/core/app/workflows/spree/carts/recalculate_totals.rb
index 55da908b33..13b1a0b147 100644
--- a/spree/core/app/workflows/spree/carts/recalculate_totals.rb
+++ b/spree/core/app/workflows/spree/carts/recalculate_totals.rb
@@ -1,18 +1,18 @@
module Spree
module Carts
- # Money recalculation — item counts, money totals (with the
- # typed-adjustment two-pass), one update_columns persist. Money ONLY:
- # payment_status/fulfillment_status are written exclusively by
- # Spree::Orders::RecomputeStatuses, triggered from
- # Spree::OrderStatusSubscriber on payment/refund/fulfillment/return
- # events; completed-order fulfillment repricing belongs to the explicit
- # post-placement edit path, never to a totals refresh.
+ # Money recalculation — item counts, money totals, one update_columns
+ # persist. Money ONLY: payment_status/fulfillment_status are written
+ # exclusively by Spree::Orders::RecomputeStatuses, and completed-order
+ # fulfillment repricing belongs to the explicit post-placement edit
+ # path, never to a totals refresh.
#
- # Granular math stays on the calculator objects (Spree::OrderUpdater /
- # Spree::CartUpdater, resolved polymorphically via the model's #updater);
- # this workflow owns the sequence. Callers use it (or the model's
- # #recalculate_totals! convenience) — never the calculator's #update,
- # which is deprecated.
+ # Completed orders are money-frozen one level down: their typed rows
+ # (discounts, fees, tax lines) are never regenerated — no promotion
+ # competition, no tax estimation — but the denormalized sums are always
+ # re-derived from the rows. That makes this the single totals seam for
+ # both live checkout math and post-placement edits (the admin
+ # tax_lines/discounts/fees endpoints write rows directly, then run
+ # this).
class RecalculateTotals < Spree::Workflow
# @param cart [Spree::Cart, Spree::Order]
def perform(cart:)
@@ -20,6 +20,8 @@ module Spree
step :reset_association_caches
step :update_item_count
+ step :regenerate_typed_rows unless money_frozen?
+ step :fold_typed_rows
step :update_money_totals
step :persist_totals
@@ -38,19 +40,124 @@ module Spree
end
def update_item_count
- calculator.update_item_count
+ cart.total_quantity = cart.line_items.sum(:quantity)
+ end
+
+ # Two passes: adjusters persist the discounted taxable base first,
+ # then tax is estimated on it.
+ def regenerate_typed_rows
+ Spree.adjusters.each { |adjuster| adjuster.adjust(cart) }
+ refresh_discount_and_fee_columns
+ Spree.tax_provider.estimate(cart)
+ end
+
+ # Re-derives the denormalized per-adjustable columns and the record's
+ # own sums from the typed rows — safe on frozen orders, where the
+ # rows are the source of truth.
+ def fold_typed_rows
+ refresh_discount_and_fee_columns if money_frozen?
+ refresh_tax_columns
+
+ discounts_sum = cart.discounts.reload.sum(&:amount)
+ fees = cart.fees.reload.to_a
+ tax_sums = cart.tax_lines.reload.group_by(&:included?).transform_values { |lines| lines.sum(&:amount) }
+
+ cart.discount_total = cart.discounts.select(&:promotion?).sum(&:amount)
+ cart.fee_total = fees.sum(&:amount)
+ cart.included_tax_total = tax_sums.fetch(true, 0)
+ cart.additional_tax_total = tax_sums.fetch(false, 0)
+ cart.adjustment_total = discounts_sum + cart.fee_total + cart.additional_tax_total
+
+ # The record's own adjustable columns cover order-level rows only:
+ # discounts distribute to line items, so fees are the only residents.
+ cart.taxable_adjustment_total = 0
+ cart.non_taxable_adjustment_total = fees.select(&:order_level?).sum(&:amount)
end
def update_money_totals
- calculator.update_totals
+ cart.payment_total = cart.payments.completed.includes(:refunds).inject(0) { |sum, payment| sum + payment.amount - payment.refunds.sum(:amount) }
+ cart.item_total = cart.line_items.to_a.sum(&:amount)
+ cart.delivery_total = cart.fulfillments.to_a.sum(&:cost)
+ cart.total = cart.item_total + cart.delivery_total + cart.adjustment_total
end
def persist_totals
- calculator.persist_totals
+ columns = {
+ item_total: cart.item_total,
+ total_quantity: cart.total_quantity,
+ adjustment_total: cart.adjustment_total,
+ included_tax_total: cart.included_tax_total,
+ additional_tax_total: cart.additional_tax_total,
+ taxable_adjustment_total: cart.taxable_adjustment_total,
+ non_taxable_adjustment_total: cart.non_taxable_adjustment_total,
+ payment_total: cart.payment_total,
+ delivery_total: cart.delivery_total,
+ discount_total: cart.discount_total,
+ fee_total: cart.fee_total,
+ total: cart.total,
+ updated_at: Time.current
+ }
+ if cart.is_a?(Spree::Order)
+ columns[:payment_status] = cart.payment_status
+ columns[:fulfillment_status] = cart.fulfillment_status
+ end
+ cart.update_columns(columns)
+ end
+
+ def money_frozen?
+ cart.is_a?(Spree::Order) && cart.completed?
+ end
+
+ # Pass one of the two-pass recalculation: persist per-adjustable
+ # discount and fee sums so the tax provider estimates on the
+ # discounted base.
+ def refresh_discount_and_fee_columns
+ discounts = cart.discounts.reload.to_a
+ fees = cart.fees.reload.to_a
+
+ each_adjustable do |adjustable, key|
+ rows = discounts.select { |row| row.public_send(key) == adjustable.id }
+ fee_rows = fees.select { |row| row.public_send(key) == adjustable.id }
+
+ update_adjustable_columns(
+ adjustable,
+ taxable_adjustment_total: rows.sum(&:amount),
+ non_taxable_adjustment_total: fee_rows.sum(&:amount),
+ promo_total: rows.select(&:promotion?).sum(&:amount)
+ )
+ end
+ end
+
+ # Pass two: fold the freshly estimated (or frozen) tax rows into the
+ # per-adjustable columns.
+ def refresh_tax_columns
+ tax_lines = cart.tax_lines.reload.to_a
+
+ each_adjustable do |adjustable, key|
+ rows = tax_lines.select { |row| row.public_send(key) == adjustable.id }
+ included, additional = rows.partition(&:included?)
+
+ update_adjustable_columns(
+ adjustable,
+ included_tax_total: included.sum(&:amount),
+ additional_tax_total: additional.sum(&:amount),
+ adjustment_total: adjustable.taxable_adjustment_total +
+ adjustable.non_taxable_adjustment_total +
+ additional.sum(&:amount)
+ )
+ end
end
- def calculator
- @calculator ||= cart.is_a?(Spree::Order) ? Spree::OrderUpdater.new(cart) : Spree::CartUpdater.new(cart)
+ def each_adjustable
+ cart.line_items.each { |line_item| yield line_item, :line_item_id }
+ cart.fulfillments.each { |fulfillment| yield fulfillment, :fulfillment_id }
+ end
+
+ def update_adjustable_columns(adjustable, attributes)
+ return unless adjustable.persisted?
+ return if attributes.all? { |key, value| adjustable.public_send(key) == value }
+
+ adjustable.update_columns(attributes.merge(updated_at: Time.current))
end
end
end
diff --git a/spree/core/spec/models/spree/payment_spec.rb b/spree/core/spec/models/spree/payment_spec.rb
index 327e651580..2c2e68932a 100644
--- a/spree/core/spec/models/spree/payment_spec.rb
+++ b/spree/core/spec/models/spree/payment_spec.rb
@@ -817,10 +817,9 @@ describe Spree::Payment, type: :model do
context 'completed orders' do
before { allow(order).to receive_messages completed?: true }
- it 'updates payment_state and shipments' do
- expect(order.updater).to receive(:update_payment_state)
- expect(order.updater).to receive(:update_fulfillment_status)
- Spree::Payment.create(amount: 100, order: order, payment_method: gateway, source: card)
+ it 'recomputes totals and statuses' do
+ expect { Spree::Payment.create(amount: 100, order: order, payment_method: gateway, source: card) }
+ .to change { order.reload.updated_at }
end
end
diff --git a/spree/core/spec/models/spree/shipment_spec.rb b/spree/core/spec/models/spree/shipment_spec.rb
index 6522d14b34..b70e89c7bd 100644
--- a/spree/core/spec/models/spree/shipment_spec.rb
+++ b/spree/core/spec/models/spree/shipment_spec.rb
@@ -874,8 +874,11 @@ describe Spree::Shipment, type: :model do
it 'updates everything around order shipment total and state' do
expect(shipment.cost.to_f).to eq 10
expect(shipment.state).to eq 'pending'
- expect(shipment.order.total.to_f).to eq 110
- expect(shipment.order.payment_state).to eq 'balance_due'
+ # The full recalculation derives item_total from real line items
+ # (fabricated column values don't survive it) and statuses come from
+ # the payment records via RecomputeStatuses.
+ expect(shipment.order.total.to_f).to eq(shipment.order.item_total.to_f + 10)
+ expect(shipment.order.payment_status).to eq('none')
end
end