spree_cm_commissioner 2.12.3 → 2.12.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b375a606aa20cb41edb29f05952ed603df382741dc452a218c55d63c2017e867
-  data.tar.gz: 4752e598b58b115740b2205a50517fabb95617e2cea760f1e7a8e9501823033b
+  metadata.gz: c0228f6ca7b7b92d005af33e616b862a1ca576c9320b70510c7f235fbb058848
+  data.tar.gz: 66e3e4f595da2175c3fd0b06ca0c5712bb340b3fb8b9e1e1f71cd1495559dda9
 SHA512:
-  metadata.gz: c2c18a4eed93d148dc07d07726d1575a5ebb44b5e743f991d452d1ea2754f5772ea20f6c909f729e02907c5d4e5ed8adc4560ae4afee057f38a351bbe87afa91
-  data.tar.gz: 64e3a068061c742b7684adddab10b3984094f5f77ef8a3ba9fbbe9978ba2d34c7ceb7b68c3bde121da8bde8ed4a4f80873d125813df01627cb50ac38d5045953
+  metadata.gz: 3a21bc63b5229c2ab198fa5d1d342b8375ed069d9a4cbee964243310a840a99acf9ab63b426defeca77b8f1f5511fcfa4fa8e5703c72fe580c06d53834452961
+  data.tar.gz: 71f6bd10a265ab1dd8c6ed0b30972105f3d2cfa332a2da3b6dfa347c8899eb1e97bb9962a6ff1c831b5cc3c6e3209409c435154e6cdc4f92a162191990bd2263

data/Gemfile.lock

@@ -34,7 +34,7 @@ GIT
 PATH
   remote: .
   specs:
-    spree_cm_commissioner (2.12.3)
+    spree_cm_commissioner (2.12.5)
       activerecord-multi-tenant
       activerecord_json_validator (~> 2.1, >= 2.1.3)
       aws-sdk-cloudfront

data/app/interactors/spree_cm_commissioner/waiting_guests_caller.rb

@@ -9,8 +9,8 @@ module SpreeCmCommissioner
     # Release at most this many guests per run, even when far more slots are free. A capacity spike
     # (cold start / lull → active_sessions low → available_slots ≈ max_sessions, e.g. 900) would
     # otherwise release every queued guest at once, dumping 900 simultaneous session-token requests
-    # on the server. Capping paces entry at ~MAX_CALLS_PER_RUN/min (the caller runs every minute);
-    # the rest stay queued and drain over the following runs.
+    # on the server. Capping paces entry at ~MAX_CALLS_PER_RUN per run (e.g. 30s, per
+    # config/schedule.yml); the rest stay queued and drain over the following runs.
     MAX_CALLS_PER_RUN = (ENV['WAITING_ROOM_MAX_CALLS_PER_RUN'] || 50).to_i
 
     def call
@@ -59,9 +59,21 @@ module SpreeCmCommissioner
       previous_guests + eligible_guests_in(records_path, remaining_slots)
     end
 
+    # This query requires a composite index (allow_to_enter_room_at ==, position !=, queued_at
+    # order); create it in Firebase beforehand, same as the plain index #fetch_long_waiting_guests
+    # already needed.
+    #
+    # The position != nil filter closes the call-before-stamp race: without it, a doc could be
+    # called here before StampQueuePositions ever assigns it a position, permanently excluding it
+    # from #eligible_guests_in (every future run still sees allow_to_enter_room_at == nil, but the
+    # calling_all write below sets it non-nil for good) while still counting toward
+    # total_exited_queue's unscoped count. Gating on position != nil makes "already stamped" true
+    # by construction before a doc can ever be called, instead of relying on StampQueuePositions
+    # reliably beating this job to it (e.g. 10s vs. 30s — see cm-market-server/config/schedule.yml).
     def eligible_guests_in(records_path, limit)
       firestore.col(records_path)
                .where('allow_to_enter_room_at', '==', nil)
+               .where('position', '!=', nil)
                .order('queued_at')
                .limit(limit)
                .get.to_a

data/app/jobs/spree_cm_commissioner/inventory_items/bulk_adjust_quantities_on_convert_job.rb

@@ -0,0 +1,47 @@
+module SpreeCmCommissioner
+  module InventoryItems
+    class BulkAdjustQuantitiesOnConvertJob < ApplicationUniqueJob
+      include SpreeCmCommissioner::IdempotentJob
+
+      queue_as :inventory_item
+
+      def perform(options = {})
+        with_idempotency(idempotency_key_for(options)) do
+          bulk_adjust_quantities_on_convert(options)
+        end
+      end
+
+      private
+
+      # Dedup on the order + the exact adjustment set, same shape as BulkAdjustQuantitiesOnHoldJob.
+      # An explicit key wins; with no order_id we fall back to the per-enqueue job_id (returning
+      # nil lets with_idempotency apply that default).
+      def idempotency_key_for(options)
+        return options[:idempotency_key] if options[:idempotency_key].present?
+        return nil if options[:order_id].blank?
+
+        "order:#{options[:order_id]}:convert:#{adjustments_fingerprint(options[:inventory_id_and_quantities])}"
+      end
+
+      # Readable, order-independent fingerprint of the adjustment payload, e.g. "1=2,2=-1:locked".
+      def adjustments_fingerprint(adjustments)
+        Array(adjustments)
+          .map { |adj| adj.with_indifferent_access.values_at(:inventory_id, :quantity, :locked) }
+          .sort_by { |inventory_id, quantity, locked| [inventory_id.to_s, quantity.to_s, locked.to_s] }
+          .map { |inventory_id, quantity, locked| locked ? "#{inventory_id}=#{quantity}:locked" : "#{inventory_id}=#{quantity}" }
+          .join(',')
+      end
+
+      # :order_id, :inventory_id_and_quantities, :caller_source
+      def bulk_adjust_quantities_on_convert(options = {})
+        raise ArgumentError, 'order_id is required' if options[:order_id].blank?
+        raise ArgumentError, 'inventory_id_and_quantities is required' if options[:inventory_id_and_quantities].blank?
+
+        SpreeCmCommissioner::InventoryItems::BulkAdjustQuantitiesOnConvert.call(
+          inventory_id_and_quantities: options[:inventory_id_and_quantities],
+          caller_source: options[:caller_source]
+        )
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/inventory_holds/convert.rb

@@ -14,8 +14,8 @@ module SpreeCmCommissioner
 
           unless hold.finalized?
             hold.update!(status: :converted)
-            clear_hold_redis!(order)
-            enqueue_sync_inventory_on_hold(order)
+            convert_hold_redis!(order)
+            enqueue_sync_inventory(order)
           end
         end
 
@@ -28,8 +28,19 @@ module SpreeCmCommissioner
 
       private
 
-      def clear_hold_redis!(order)
-        keys = []
+      # Moves a held unit to a permanent sale by decrementing the hold counter AND the stock
+      # counter together, in one atomic Lua call. These used to be two separate Redis round trips
+      # (hold decrement here, stock decrement in RedisStock::Unstock, called a moment later from
+      # OrderStateMachine#unstock_inventory!) — a concurrent Acquire could read Redis in the gap
+      # between them and see the hold count already down but the stock count not yet down, i.e. a
+      # phantom unit of "available" capacity that was never actually freed, letting one order too
+      # many acquire a hold.
+      #
+      # RedisStock::Unstock skips any line item that should_hold_inventory? for exactly this reason
+      # — this method is now the only place their stock key gets decremented.
+      def convert_hold_redis!(order)
+        stock_keys = []
+        hold_keys = []
         quantities = []
         warmable_items = []
 
@@ -42,34 +53,44 @@ module SpreeCmCommissioner
 
           # Skip .active scope: holds on past-dated items must also be cleared (e.g. delayed conversion after trip date).
           li.inventory_items.each do |item|
-            keys << item.redis_hold_key(locked: locked)
+            stock_keys << item.redis_key(locked: locked)
+            hold_keys << item.redis_hold_key(locked: locked)
             quantities << li.quantity
             warmable_items << item
           end
         end
 
-        return if keys.empty?
-
-        clear_hold_lua_script = <<~LUA
-          local keys = KEYS
-          local quantities = ARGV
-          for i, key in ipairs(keys) do
-            redis.call('DECRBY', key, tonumber(quantities[i]))
-          end
-          return 1
-        LUA
+        return if hold_keys.empty?
 
         SpreeCmCommissioner::RedisStock::CachedInventoryItemsBuilder.new(warmable_items).call
+
+        interleaved_keys = stock_keys.zip(hold_keys).flatten
         SpreeCmCommissioner.inventory_redis_pool.with do |redis|
-          redis.eval(clear_hold_lua_script, keys: keys, argv: quantities)
+          redis.eval(convert_hold_lua_script, keys: interleaved_keys, argv: quantities)
         end
       end
 
-      def enqueue_sync_inventory_on_hold(order)
-        inventory_id_and_quantities = order.line_items.flat_map do |line_item|
+      def convert_hold_lua_script
+        <<~LUA
+          -- KEYS = [stock_key_1, hold_key_1, stock_key_2, hold_key_2, ...]
+          -- ARGV = [qty_1, qty_2, ...]
+          for i = 1, #ARGV do
+            redis.call('DECRBY', KEYS[(i-1)*2+1], tonumber(ARGV[i]))
+            redis.call('DECRBY', KEYS[(i-1)*2+2], tonumber(ARGV[i]))
+          end
+          return 1
+        LUA
+      end
+
+      # Keeps the DB mirrors in sync with both halves of convert_hold_redis! (quantity_on_hold drops
+      # because the hold is gone, quantity_available drops because the unit is permanently sold) via
+      # ONE job that applies both under a single row lock per item — see
+      # InventoryItems::BulkAdjustQuantitiesOnConvert for why this isn't the usual two separate jobs.
+      def enqueue_sync_inventory(order)
+        adjustments = order.line_items.flat_map do |line_item|
           next [] unless line_item.should_hold_inventory?
 
-          # Skip .active scope for the same reason as clear_hold_redis!.
+          # Skip .active scope for the same reason as convert_hold_redis!.
           line_item.inventory_items.map do |inventory_item|
             {
               inventory_id: inventory_item.id,
@@ -79,12 +100,12 @@ module SpreeCmCommissioner
           end
         end
 
-        return if inventory_id_and_quantities.blank?
+        return if adjustments.blank?
 
-        SpreeCmCommissioner::InventoryItems::BulkAdjustQuantitiesOnHoldJob.perform_later(
+        SpreeCmCommissioner::InventoryItems::BulkAdjustQuantitiesOnConvertJob.perform_later(
           order_id: order.id,
-          caller_source: "#{self.class.name}#enqueue_sync_inventory_on_hold",
-          inventory_id_and_quantities: inventory_id_and_quantities
+          caller_source: "#{self.class.name}#enqueue_sync_inventory",
+          inventory_id_and_quantities: adjustments
         )
       end
     end

data/app/services/spree_cm_commissioner/inventory_items/bulk_adjust_quantities_on_convert.rb

@@ -0,0 +1,96 @@
+module SpreeCmCommissioner
+  module InventoryItems
+    # DB mirror of InventoryHolds::Convert#convert_hold_redis!: applies the same delta to
+    # quantity_on_hold and quantity_available together, under ONE row lock per inventory item.
+    # Doing this as two separate jobs (BulkAdjustQuantitiesOnHoldJob + BulkAdjustQuantitiesJob),
+    # each locking and saving independently, left a window between the two locks where a reader
+    # could see one column updated and the other not yet — the same class of gap that made the
+    # Redis side non-atomic. One lock, one update, removes that window on the DB side too.
+    class BulkAdjustQuantitiesOnConvert
+      prepend ::Spree::ServiceModule::Base
+      extend SpreeCmCommissioner::ServiceModuleThrowable
+
+      def call(inventory_id_and_quantities:, caller_source: nil)
+        CmAppLogger.log(
+          label: "#{self.class.name}#call started",
+          data: { caller_source: caller_source, inventory_id_and_quantities: inventory_id_and_quantities }
+        )
+
+        ActiveRecord::Base.transaction do
+          items_by_id = inventory_items(inventory_id_and_quantities).index_by(&:id)
+
+          grouped_deltas(inventory_id_and_quantities).each do |(inventory_id, locked), quantity|
+            inventory_item = items_by_id[inventory_id]
+            next if inventory_item.nil?
+
+            adjust_quantities(inventory_item, quantity, caller_source, locked: locked)
+          end
+        end
+
+        success(nil)
+      end
+
+      private
+
+      # Grouped by pool flag as well as by item, same as BulkAdjustQuantities/OnHold: a mixed cart
+      # can carry a public and a locked adjustment for the same inventory item in one payload.
+      def grouped_deltas(inventory_id_and_quantities)
+        inventory_id_and_quantities
+          .group_by { |entry| [entry[:inventory_id], entry[:locked] || false] }
+          .transform_values { |entries| entries.sum { |entry| entry[:quantity] } }
+      end
+
+      def adjust_quantities(inventory_item, quantity, caller_source, locked: false)
+        available_column = locked ? :quantity_locked : :quantity_available
+        hold_column = locked ? :quantity_locked_on_hold : :quantity_on_hold
+
+        before_available = before_hold = after_available = after_hold = nil
+
+        # IMPORTANT: Apply both quantity changes directly without defensive clamping — model
+        # validation surfaces bugs in upstream Redis deduction logic rather than hiding them.
+        inventory_item.with_lock do
+          before_available = inventory_item[available_column]
+          before_hold = inventory_item[hold_column]
+          after_available = before_available + quantity
+          after_hold = before_hold + quantity
+
+          inventory_item.update!(available_column => after_available, hold_column => after_hold)
+        end
+
+        CmAppLogger.log(
+          label: "#{self.class.name}#adjust_quantities",
+          data: {
+            caller_source: caller_source,
+            inventory_item_id: inventory_item.id,
+            locked: locked,
+            available_column: available_column,
+            quantity_available_before: before_available,
+            quantity_available_after: after_available,
+            hold_column: hold_column,
+            quantity_on_hold_before: before_hold,
+            quantity_on_hold_after: after_hold,
+            delta: quantity
+          }
+        )
+      rescue ActiveRecord::RecordInvalid
+        CmAppLogger.error(
+          label: "#{self.class.name}#adjust_quantities failed",
+          data: {
+            caller_source: caller_source,
+            inventory_item_id: inventory_item.id,
+            locked: locked,
+            delta: quantity,
+            quantity_available_current: inventory_item[available_column],
+            quantity_on_hold_current: inventory_item[hold_column],
+            errors: inventory_item.errors.full_messages
+          }
+        )
+        raise
+      end
+
+      def inventory_items(inventory_id_and_quantities)
+        SpreeCmCommissioner::InventoryItem.where(id: inventory_id_and_quantities.pluck(:inventory_id)).includes(variant: :product)
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/redis_stock/unstock.rb

@@ -12,6 +12,10 @@ module SpreeCmCommissioner
         warmable_items = []
 
         line_items.each do |li|
+          # Already deducted on convert (InventoryHolds::Convert#convert_hold_redis!), so no need to
+          # deduct again here.
+          next if li.should_hold_inventory?
+
           # Each line item deducts from its own pool: a locked-stock line was never counted in public
           # stock, so unstocking it there would either fail the Lua guard on a paid order or, where
           # public stock happens to cover it, oversell silently.

data/lib/spree_cm_commissioner/version.rb

@@ -1,5 +1,5 @@
 module SpreeCmCommissioner
-  VERSION = '2.12.3'.freeze
+  VERSION = '2.12.5'.freeze
 
   module_function
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spree_cm_commissioner
 version: !ruby/object:Gem::Version
-  version: 2.12.3
+  version: 2.12.5
 platform: ruby
 authors:
 - You
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-31 00:00:00.000000000 Z
+date: 2026-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: spree
@@ -1404,6 +1404,7 @@ files:
 - app/jobs/spree_cm_commissioner/inventory_holds/release_job.rb
 - app/jobs/spree_cm_commissioner/inventory_items/bulk_adjust_quantities_by_variant_job.rb
 - app/jobs/spree_cm_commissioner/inventory_items/bulk_adjust_quantities_job.rb
+- app/jobs/spree_cm_commissioner/inventory_items/bulk_adjust_quantities_on_convert_job.rb
 - app/jobs/spree_cm_commissioner/inventory_items/bulk_adjust_quantities_on_hold_job.rb
 - app/jobs/spree_cm_commissioner/inventory_items/bulk_generate_permanent_items_job.rb
 - app/jobs/spree_cm_commissioner/inventory_items/generate_inventory_items_job.rb
@@ -2306,6 +2307,7 @@ files:
 - app/services/spree_cm_commissioner/inventory_items/adjust_available_quantity.rb
 - app/services/spree_cm_commissioner/inventory_items/bulk_adjust_quantities.rb
 - app/services/spree_cm_commissioner/inventory_items/bulk_adjust_quantities_by_variant.rb
+- app/services/spree_cm_commissioner/inventory_items/bulk_adjust_quantities_on_convert.rb
 - app/services/spree_cm_commissioner/inventory_items/bulk_adjust_quantities_on_hold.rb
 - app/services/spree_cm_commissioner/inventory_items/bulk_generate_permanent_items.rb
 - app/services/spree_cm_commissioner/inventory_items/generate_non_permanent_item.rb