Cart Does Not Update Discounts, Shipping, Pricing, or Eligibility Rules Dynamically After Changes

[mezzat11]

Describe the bug
Currently, when a product is added to the cart (draft order), its price, discounts, shipping cost, and eligibility are stored at that moment.
If any of the following are later updated:

Product base price

Discount rules (e.g., promotions, coupons)

Shipping rates or conditions

Eligibility rules (e.g., minimum order value for discount, customer group conditions)

The cart does not reflect these updates.
This leads to outdated and incorrect carts, resulting in incorrect prices, invalid discounts, wrong shipping fees, and eligibility violations at checkout.

Environment details:

@vendure/core version: 3.2.2

Node.js version: 20.18.3

Database: Postgres

To Reproduce

Add a product to the cart with an active promotion (e.g., 10% off if cart > $100).

Change the promotion rule to a different threshold or deactivate it.

Update shipping rules (e.g., free shipping threshold moves from $50 to $75).

View the cart — it still shows the old promotions and shipping, even if the cart no longer meets the new eligibility.

Also can checkout with the old pricing, expired promotion and not eligible update shipping rule!.

Expected behavior
The cart should always reflect the current real-time:

Product pricing

Discount rules and calculations

Shipping options and rates

Tax calculations (if any)

Eligibility rules for discounts, shipping, and other promotions

Eligibility must be re-evaluated dynamically whenever:

The cart is viewed.

Cart items are added, removed, or updated.

The user proceeds to checkout.

Additional context
Without real-time validation:

Users might wrongly receive discounts they should no longer be eligible for.

Orders could be placed under wrong shipping or tax conditions.

Admins could lose revenue due to invalid promotions still applying.

Customers could experience checkout errors if eligibility fails at final payment stage.

How major platforms handle this:

Shopify, Magento, and Saleor all re-calculate prices, shipping, and discounts dynamically in the cart.

Eligibility for promotions is re-checked live each time the cart is loaded, updated, or checkout is started.

Systems often warn users immediately if a cart no longer meets a condition (e.g., "Your discount is no longer available").

Recommended Solutions

Dynamic Cart Recalculation: Refresh product pricing, discounts, shipping, taxes, and eligibility every time the cart is accessed, modified, or checked out.

Validation Hooks: Introduce hooks so custom apps or external promo engines can also validate eligibility live.

Error and Notification System: If a cart becomes invalid (e.g., discount removed), notify the customer in the cart view immediately.

[mezzat11]

Related : https://docs.saleor.io/developer/checkout/lifecycle
Completing Checkout
When checkout is finalized/completed, it is converted into an order.

The following are the requirements to finalize the checkout:

The required addresses are valid, except when skipValidation is used.

Delivery options and addresses are valid. Learn more.

All selected products are in stock (while purchasing, another user could already buy the last available item). See Allocations and Reservations.

The payments are processed unless the Channel setting of the checkout has allowUnpaidOrders setting enabled or checkout's total is 0. If you need to bypass this setting, you use orderCreateFromCheckout.

[mezzat11]

@dlhck i believe this very critical to be done in the core .. i see saleor has good approach for this to run validator / re calculator in checkout before moving from draft state into order state

[mezzat11]

@dlhck Can we consider this as priority

[dlhck]

@mezzat11 I have added it to our v3.5.0 milestone, but there is the possibility that it will be pushed back to v3.6.0 (target end of October)

[mohdbk]

Hi @michaelbromley & @dlhk,

I'd like to suggest a fix for the cart staleness issue described in this issue.

The idea: Event-Driven Pricing Version

Rather than constantly refreshing carts or maintaining complex invalidation logic, we can keep it simple:

1. Add a pricingVersion column to Order
2. Maintain a global counter that increments whenever prices, promotions, shipping, or taxes change
3. When fetching a cart, compare globalVersion with order.pricingVersion
4. If outdated, recalc on the spot
5. Use Vendure's existing events to trigger version increments

Example

// Check for staleness
if (await pricingVersionService.isOrderStale(order)) {
  await smartOrderService.recalculateOrder(ctx, order);
  await pricingVersionService.markOrderCurrent(order.id);
}

// Increment global version on updates
this.eventBus.ofType(ProductVariantEvent).subscribe(async event => {
  if (event.type === 'updated') {
    await this.pricingVersionService.incrementGlobalVersion();
  }
});

Why this works

• Simple integer check, no background jobs
• Reliable and event-driven
• Fits naturally with Vendure's existing services
• Backward-compatible, no API changes required
• Can be toggled via VendureConfig
• Battle-tested pattern (similar to ETags or MVCC)

Would you be open to this approach? The implementation would involve:

• New PricingVersionService
• Event listeners for pricing changes
• Integration with existing OrderService.getActiveOrder()
• Optional GraphQL extensions

I'd be glad to go into more detail or draft a PR if it sounds useful.

[mezzat11]

Related
https://docs.saleor.io/developer/price-freeze-period

[mezzat11]

The stock isn’t updating correctly — when a customer leaves items in their cart and another customer completes checkout, the first customer can still place the order, causing the stock to go negative.

[dlhck]

@mezzat11 happy if you could provide a PR, it is on our roadmap and should be coming in the next couple of months.