spree_doordash 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11ea8c9082c5f3a17fb5e7ad172eab82c717d17af077bee7d0df14c92a75fba6
-  data.tar.gz: 5e435d16a2bef4e610760fb993533cf54f31a81343b1f5ade02f7889f8eb622c
+  metadata.gz: 6a028415e34fd065f59a11e00034d88ef6ea2dfa8155538bf61f63ba26cf16ed
+  data.tar.gz: f0425700d9f63218ee14eae64ce30d6e444c46b2eefae2fe4d3854f38426e13a
 SHA512:
-  metadata.gz: bcee352d7bc9b0a6eeb877d5cd112cf40de922de796739f607058ad92735c787f665641d981d501e3d21af5b82b7e8f4e289b4a96cc6351d659d9f78eed95174
-  data.tar.gz: 99e77a1d48d37fe6f1573341a0e93d90f4d7a68690ede1f1ecdfc43c508340ef9b60aec101f9c4b7aea32fca25109dc94e8f13f8712124802f8b4e64e7866295
+  metadata.gz: 25f7dc0b927d237844b908072f4b3f9fa738fe3db1c6b4036280e51d739c6b5eea92c2578dc730dbd5c89b33de5a10318f9898ee91e295a55deafcdf3426ae5b
+  data.tar.gz: b32fb99c09cb7344185f06ca15c72c60253669b0d5ea5374de62490c4a62e007ce39589b6df4a491bcfd8a54e71c4caf266ea348c0b8d9abf1355b01c03dcd23

data/CHANGELOG.md

@@ -2,6 +2,64 @@
 
 All notable changes to this project are documented here.
 
+## 0.1.3
+
+A real bug found live: the `doordash_quote_unavailable` warning added in 0.1.2 never actually
+worked in production. `Spree::Calculator::Shipping::DoordashQuote#compute_package` pushed it onto
+`package.order.warnings` — but `package.order` is **not** the same in-memory object as the order
+the caller (`Spree::Order#create_proposed_shipments`) holds. `spree_core`'s own
+`Spree::Stock::InventoryUnitBuilder#units` builds each inventory unit with `order_id: @order.id`
+but deliberately *not* `order: @order` ("avoid loading the association to order until needed," per
+its own comment) — the first thing that touches `.order` on one of those units triggers a fresh
+`Spree::Order.find`, a brand-new Ruby object. So the warning was mutating a throwaway copy,
+discarded the instant `compute_package` returned, and never reached the order this request
+actually serializes back to the storefront as `cart.warnings`. Confirmed via `object_id` tracing
+against production, not assumed — and confirmed the existing spec suite couldn't have caught it:
+`doordash_quote_spec.rb`'s own `instance_double(Spree::Stock::Package, order: order)` makes
+`package.order` the *same* object as the test's `order` by construction, sidestepping the exact
+boundary that breaks in real Spree core.
+
+Fixed by bridging across that boundary with the order's stable id instead of Ruby object identity
+— `Spree::Calculator::Shipping::DoordashQuote.mark_unavailable(order_id)` sets a thread-local flag
+(chosen over `Rails.cache`: this gem installs into arbitrary host apps, some of which legitimately
+run `config.cache_store = :null_store`, which would silently degrade this back to the original bug
+with zero indication anything was wrong — `compute_package` and `create_proposed_shipments` always
+run synchronously on the same thread within one request, so a thread-local needs no external store
+and no expiry logic). A new `Spree::OrderDecorator#create_proposed_shipments` reads the flag back
+and merges the warning onto `self.warnings` immediately after `super` returns — `self` there *is*
+the real order, since `create_proposed_shipments` is called directly on it by the checkout flow.
+The flag is cleared unconditionally at the *start* of every call (not just after a successful
+merge), so a stale flag left behind by an earlier request that raised before reaching the merge
+step can never leak into a later, unrelated call that happens to reuse the same thread.
+
+New `spec/models/spree/order_decorator_spec.rb` exercises the real
+`order_routing_strategy -> Estimator -> Packer -> InventoryUnitBuilder` path end to end (only
+`SpreeDoordash::Quote.call` is stubbed) — the only way to actually exercise the object-identity
+boundary the fix bridges across, rather than doubling it away. Full suite: 95 examples, 0 failures
+(5 new). Coverage: 94.14%. Brakeman clean.
+
+## 0.1.2
+
+A real bug found live during checkout-validation work: a blank phone on the dropoff address used
+to fall back to a fake placeholder number (`+10000000000`) that DoorDash's API rejected anyway —
+the request was doomed before it was even built, and (same as the E.164 issue fixed in 0.1.1) the
+DoorDash Delivery rate just silently vanished with no error anywhere in the UI.
+
+- `SpreeDoordash::Quote#call` now returns early (no API call at all) when the ship address has no
+  phone, instead of building a request known to fail. `format_phone`'s placeholder fallback is
+  removed entirely.
+- `Spree::Calculator::Shipping::DoordashQuote#compute_package` now pushes a
+  `doordash_quote_unavailable` warning onto `Spree::Order#warnings` whenever `SpreeDoordash::Quote`
+  returns `nil` — generic to *why* the quote failed (bad/missing phone, an address DoorDash
+  genuinely can't serve, DoorDash API down), confirmed live for two different real causes.
+  `Spree::Order#warnings` is the same transient mechanism core's own
+  `ensure_available_shipping_rates` already uses for the identical class of problem, and flows
+  through to the Store API's `cart.warnings` with no new API surface. A storefront reference
+  implementation now renders this as a real, non-blocking banner instead of silence — see
+  `spree_storefront_web`'s `DeliveryMethodSection.tsx`.
+
+Full suite: 90 examples, 0 failures (2 new). Coverage: 94.14% (241/256 lines). Brakeman clean.
+
 ## 0.1.1
 
 Two real production bugs, both invisible to the full spec suite and to every prior "live

data/app/models/spree/calculator/shipping/doordash_quote.rb

@@ -20,11 +20,62 @@ module Spree
 
       def compute_package(package)
         result = SpreeDoordash::Quote.call(package.order)
-        return nil unless result
+        if result.nil?
+          # A real bug found live: a nil Result here (bad/missing phone, an
+          # address DoorDash genuinely can't serve, DoorDash API down —
+          # SpreeDoordash::Quote#call collapses all of these to the same
+          # "unavailable" nil, deliberately, so this stays generic to *why*)
+          # used to just make the rate silently vanish with zero signal
+          # anywhere in the UI. Spree::Order#warnings is the same
+          # transient, request-scoped mechanism core's own
+          # `ensure_available_shipping_rates` already uses for the
+          # identical class of problem (a line item that can't ship at
+          # all) — it flows through to the Store API's `cart.warnings`
+          # with no new API surface needed. The storefront renders its own
+          # localized copy for this code; `message` here is English-only,
+          # a fallback for any other API consumer, not the UI text itself.
+          #
+          # A SECOND real bug found live (v0.1.2, this fix is v0.1.3):
+          # package.order is not the same object as the order the caller
+          # holds (spree_core's InventoryUnitBuilder deliberately defers
+          # loading that association — see the Spree::OrderDecorator this
+          # gem ships for the full story), so pushing the warning directly
+          # onto package.order.warnings here mutated a throwaway copy that
+          # never reached the real order. Thread.current bridges across
+          # that boundary via the order's id instead of Ruby object
+          # identity — chosen over Rails.cache deliberately: this gem
+          # installs into arbitrary host apps, some of which run
+          # `config.cache_store = :null_store` (the Rails test-env
+          # default, and a legitimate production choice too), which would
+          # silently degrade this back to the original bug with no
+          # indication anything was wrong. compute_package and
+          # create_proposed_shipments always run synchronously on the same
+          # thread within one request (confirmed: this is the exact call
+          # chain reproduced live to root-cause the original bug), so a
+          # thread-local flag needs no external store and no expiry logic
+          # — Spree::OrderDecorator clears it unconditionally at the start
+          # of every create_proposed_shipments call, so a stale flag from
+          # an earlier request that errored out before consuming it can
+          # never leak into a later, unrelated one.
+          self.class.mark_unavailable(package.order.id)
+          return nil
+        end
 
         result.fee_cents / 100.0
       end
 
+      def self.mark_unavailable(order_id)
+        (Thread.current[:spree_doordash_quote_unavailable_order_ids] ||= []) << order_id
+      end
+
+      def self.unavailable?(order_id)
+        Thread.current[:spree_doordash_quote_unavailable_order_ids]&.include?(order_id) || false
+      end
+
+      def self.clear_unavailable(order_id)
+        Thread.current[:spree_doordash_quote_unavailable_order_ids]&.delete(order_id)
+      end
+
       # Called by Estimator to filter which shipping methods even attempt
       # a compute_package call. Skips the DoorDash API round-trip entirely
       # for an order with no ship address yet (early checkout, before

data/app/models/spree/order_decorator.rb

@@ -0,0 +1,54 @@
+module Spree
+  # Bridges Spree::Calculator::Shipping::DoordashQuote#compute_package's
+  # doordash_quote_unavailable warning back onto the real order object.
+  #
+  # A real bug found live (confirmed via object_id tracing against
+  # production, not assumed): `compute_package` receives a
+  # `Spree::Stock::Package`, and `package.order` is NOT the same in-memory
+  # object as `self` in `create_proposed_shipments` below. spree_core's own
+  # `Spree::Stock::InventoryUnitBuilder#units` builds each inventory unit
+  # with `order_id: @order.id` but deliberately *not* `order: @order` — its
+  # own comment says why: "avoid loading the association to order until
+  # needed." The first thing that touches `.order` on one of those units (or
+  # a Package built from them) triggers a fresh `Spree::Order.find`, a
+  # brand-new Ruby object. So `package.order.warnings |= [...]` inside the
+  # calculator was mutating a throwaway copy that's discarded the instant
+  # `compute_package` returns — the warning never reached the order object
+  # this request actually serializes back to the storefront as
+  # `cart.warnings`. `spree_doordash` v0.1.2's warning never worked in
+  # production despite passing its own specs (the dummy app's specs call
+  # the calculator directly against a single order instance, which can't
+  # exhibit this — it only shows up through the real
+  # create_proposed_shipments -> order_routing_strategy -> Estimator path).
+  #
+  # Fix: since Ruby object identity doesn't survive that boundary, bridge
+  # across it with the order's stable id instead, via a thread-local flag
+  # (see DoordashQuote.mark_unavailable/unavailable?/clear_unavailable for
+  # why Thread.current was chosen over Rails.cache). Cleared unconditionally
+  # at the *start* of every call — not just after a successful merge — so a
+  # stale flag left behind by an earlier request that raised before
+  # reaching the merge step can never leak into a later, unrelated
+  # create_proposed_shipments call that happens to reuse the same thread.
+  module OrderDecorator
+    def create_proposed_shipments
+      Spree::Calculator::Shipping::DoordashQuote.clear_unavailable(id)
+      result = super
+      merge_doordash_quote_warning!
+      result
+    end
+
+    private
+
+    def merge_doordash_quote_warning!
+      return unless Spree::Calculator::Shipping::DoordashQuote.unavailable?(id)
+
+      Spree::Calculator::Shipping::DoordashQuote.clear_unavailable(id)
+      self.warnings |= [{
+        code: 'doordash_quote_unavailable',
+        message: 'We could not get a DoorDash delivery quote for this address.'
+      }]
+    end
+  end
+
+  Order.prepend OrderDecorator
+end

data/app/services/spree_doordash/quote.rb

@@ -17,6 +17,16 @@ module SpreeDoordash
     def call(order)
       location_mapping = location_mapping_for(order)
       return nil unless location_mapping && order.ship_address
+      # A real bug found live: with no phone on the ship address,
+      # `format_phone` used to fall back to a fake placeholder number that
+      # DoorDash's API correctly rejects with a 400 — the request was
+      # doomed before it was even built. `Spree::Config[:address_requires_phone]`
+      # (spree_host) should make this unreachable in the normal storefront
+      # checkout flow, but this guard stays as defense in depth for any
+      # other path that can create an order (admin, API, migrated data)
+      # — same "unavailable, not exceptional" nil-return shape as every
+      # other unserviceable case below.
+      return nil if order.ship_address.phone.blank?
 
       client = SpreeDoordash::Client.for_store(order.store || Spree::Store.default)
       # A random suffix per attempt, not just order.number — confirmed live
@@ -93,11 +103,17 @@ module SpreeDoordash
     # US-only, matching the rest of this demo (every address here is a US
     # address) — strips everything but digits, assumes a bare 10-digit
     # number is domestic and prepends the country code.
+    #
+    # No blank-phone fallback here (a prior version faked one as
+    # "+10000000000" — DoorDash rejected it too, just as uninformatively as
+    # a missing one; better to let a genuinely blank pickup phone fail
+    # DoorDash's own validation loudly than paper over it with fake data).
+    # `call` above already guards the dropoff phone specifically; this
+    # method is also reused for the pickup (StockLocation) phone, which is
+    # real business data expected to always be set.
     def format_phone(raw)
       digits = raw.to_s.gsub(/\D/, '')
       digits = "1#{digits}" if digits.length == 10
-      return '+10000000000' if digits.blank?
-
       "+#{digits}"
     end
 

data/lib/spree_doordash/version.rb

@@ -1,5 +1,5 @@
 module SpreeDoordash
-  VERSION = '0.1.1'.freeze
+  VERSION = '0.1.3'.freeze
 
   def gem_version
     Gem::Version.new(VERSION)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spree_doordash
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Amit Solanki
@@ -120,6 +120,7 @@ files:
 - app/jobs/spree_doordash/delivery_dispatch_job.rb
 - app/jobs/spree_doordash/delivery_webhook_job.rb
 - app/models/spree/calculator/shipping/doordash_quote.rb
+- app/models/spree/order_decorator.rb
 - app/models/spree_doordash/credential.rb
 - app/models/spree_doordash/delivery_mapping.rb
 - app/models/spree_doordash/location_mapping.rb