spree_cm_commissioner 2.12.7.pre.pre1 → 2.12.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f4e6fad42b4e85ffc7259488c4594acea3dd6949dfbbd5dca113cff65740f7f
-  data.tar.gz: 81a670727506c0b79c5b18789c0b88bd042cc7a5b94318d49616251389b88129
+  metadata.gz: 742162ce28f156432f76f071c6538e682fecfa8008758acc698d283cb2a3742c
+  data.tar.gz: bfafd91f275bc28a16234e3153ee8d83aa5b5040be06acca7850770b2573fe01
 SHA512:
-  metadata.gz: 16e72d5ccf30ad000ba4377824ce84a8245104f55835a8e298ca5d93117fdaf06f0a1f6adeef544dae996e5cf527980669129f6230068f7eb6a445d021dcd2b2
-  data.tar.gz: 1688cbabe227af883abc06175772c009ecf138433ff180a197f668010db60298c49ac113eb33027c9c63bd14a2d7b80e403ab246961b8c3af94381d40763b668
+  metadata.gz: f8c8857a35fe48099949496f9e69c0741ca32a18a05fbc05afafdc1cb5cd7feb3394b3b0158cbb27dea96f585e378f9a4a14c0d2fbac1b8cee6e54c8a51be443
+  data.tar.gz: d8e013c7a5172fabbfea21e83ac52d5231351ed380960e1308b458ad1e7b6cd960bb2ca7a6204b82448f3d494c17cb3eb3ebb9a5d704228b901c789dacef09f2

data/Gemfile.lock

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

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

@@ -23,14 +23,13 @@ module SpreeCmCommissioner
         "line_item:#{options[:line_item_ids].compact.uniq.sort.join(':')}"
       end
 
-      # :line_item_ids, :inventory_id_and_quantities, :caller_source, :correlation_id
+      # :line_item_ids, :inventory_id_and_quantities, :caller_source
       #
       # :caller_source is a string like "ClassName#method" identifying who enqueued the job.
       def bulk_adjust_quantities!(options = {})
         SpreeCmCommissioner::InventoryItems::BulkAdjustQuantities.call!(
           inventory_id_and_quantities: options[:inventory_id_and_quantities],
-          caller_source: options[:caller_source],
-          correlation_id: options[:correlation_id]
+          caller_source: options[:caller_source]
         )
       end
     end

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

@@ -32,15 +32,14 @@ module SpreeCmCommissioner
           .join(',')
       end
 
-      # :order_id, :inventory_id_and_quantities, :caller_source, :correlation_id
+      # :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],
-          correlation_id: options[:correlation_id]
+          caller_source: options[:caller_source]
         )
       end
     end

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

@@ -38,7 +38,7 @@ module SpreeCmCommissioner
           .join(',')
       end
 
-      # :order_id, :inventory_id_and_quantities, :caller_source, :correlation_id
+      # :order_id, :inventory_id_and_quantities, :caller_source
       #
       # :order_id is used for unique idempotency key generation to prevent duplicate
       # processing, though it's not used in the adjustment itself.
@@ -49,8 +49,7 @@ module SpreeCmCommissioner
 
         SpreeCmCommissioner::InventoryItems::BulkAdjustQuantitiesOnHold.call(
           inventory_id_and_quantities: options[:inventory_id_and_quantities],
-          caller_source: options[:caller_source],
-          correlation_id: options[:correlation_id]
+          caller_source: options[:caller_source]
         )
       end
     end

data/app/models/spree_cm_commissioner/inventory_item.rb

@@ -107,10 +107,7 @@ module SpreeCmCommissioner
     end
 
     # This method is only used when admin update stock
-    def adjust_quantity!(quantity, correlation_id: nil)
-      correlation_id ||= SecureRandom.uuid
-      quantity_available_before = redis_quantity_after = nil
-
+    def adjust_quantity!(quantity)
       with_lock do
         # IMPORTANT: Apply quantity changes directly without defensive clamping.
         # The model validation will catch any attempts to go negative, surfacing bugs
@@ -121,8 +118,6 @@ module SpreeCmCommissioner
         #
         # Why? Clamping masks bugs. Validation errors are better than silent data loss.
         # See: /docs/lessons-learned/inventory-consistency-issues.md#lesson-learned-async-job-validation-strategy
-        quantity_available_before = quantity_available
-
         self.max_capacity = max_capacity + quantity
         self.quantity_available = quantity_available + quantity
         save!
@@ -132,23 +127,8 @@ module SpreeCmCommissioner
         # high-contention hot path, so keeping it in the same transaction as `save!` means a
         # Redis failure rolls the DB change back too, instead of leaving the DB and Redis counts
         # out of sync with nothing to reconcile them.
-        redis_quantity_after = adjust_quantity_in_redis(quantity)
+        adjust_quantity_in_redis(quantity)
       end
-
-      # Logged after with_lock releases: I/O here would otherwise extend how long the row's
-      # SELECT ... FOR UPDATE is held under high-traffic contention — same reasoning as the other
-      # Bulk* adjusters in this gem.
-      CmAppLogger.log(
-        label: "#{self.class.name}#adjust_quantity!",
-        data: {
-          correlation_id: correlation_id,
-          inventory_item_id: id,
-          delta: quantity,
-          quantity_available_before: quantity_available_before,
-          quantity_available_after: quantity_available,
-          redis_quantity_after: redis_quantity_after
-        }
-      )
     end
 
     # Stock and hold keys. `locked: true` addresses the withheld pool — see LineItem#locked_stock?,

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

@@ -13,10 +13,6 @@ module SpreeCmCommissioner
       AcquireLimitExceededError = Class.new(StandardError)
 
       def call(order:, expires_at:)
-        # One id per acquire attempt, threaded through the Redis-mutation log below and into the
-        # DB-sync job's own log (enqueue_sync_inventory_on_hold) — greppable end-to-end trail from
-        # "Redis hold counter changed" to "DB row actually caught up", independent of async timing.
-        correlation_id = SecureRandom.uuid
         line_items = order.line_items.select(&:should_hold_inventory?)
         return success(nil) if line_items.empty?
 
@@ -33,25 +29,21 @@ module SpreeCmCommissioner
           raise AcquireLimitExceededError, result.error.to_s unless result.success?
         end
 
-        hold = with_advisory_lock!(order) do
-          h = acquire_hold_for_order!(order, line_items, expires_at, correlation_id)
+        with_advisory_lock!(order) do
+          hold = acquire_hold_for_order!(order, line_items, expires_at)
 
-          enqueue_release_job(h)
-          enqueue_sync_inventory_on_hold(order, correlation_id)
+          enqueue_release_job(hold)
+          enqueue_sync_inventory_on_hold(order)
 
-          h
-        end
-
-        # Logged after the advisory lock releases (see with_advisory_lock!'s ensure) — never while
-        # held — so a slow log write can't extend how long other requests for this order wait on it.
-        CmAppLogger.log(
-          label: "#{self.class.name}#call success",
-          data: { correlation_id: correlation_id, order_id: order.id, hold_id: hold.id }
-        )
+          CmAppLogger.log(
+            label: "#{self.class.name}#call success",
+            data: { order_id: order.id, hold_id: hold.id }
+          )
 
-        success(hold)
+          success(hold)
+        end
       rescue StandardError => e
-        error = { error_type: e.class.name.demodulize, correlation_id: correlation_id, order_id: order.id, message: e.message }
+        error = { error_type: e.class.name.demodulize, order_id: order.id, message: e.message }
         CmAppLogger.error(label: "#{self.class.name}#call failed", data: error)
         failure(nil, e.message)
       end
@@ -81,71 +73,45 @@ module SpreeCmCommissioner
       #
       # Risk: Redis deduction could orphan if exception raised after Redis commit but before DB.
       # Accepted—advisory lock ensures single process per order prevents impact.
-      # AcquireInsufficientStockError (not ActiveRecord::Rollback) is what rolls hold.save! back on
-      # insufficient stock — any exception, not just Rollback, unwinds a `transaction do` block and
-      # rolls it back; Rollback is just the one case ActiveRecord swallows instead of re-raising.
-      # Using our own error class means it still propagates out normally (real transaction or a
-      # plain `.and_yield` test double alike) so the rescue below can log, then re-raise it.
-      #
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      def acquire_hold_for_order!(order, line_items, expires_at, correlation_id)
+      def acquire_hold_for_order!(order, line_items, expires_at)
         hold = SpreeCmCommissioner::InventoryHold.find_or_initialize_by(order: order)
         return hold if hold.persisted? && hold.active?
         return hold if hold.persisted? && hold.payment_locked?
 
-        redis_rows = nil
-
-        begin
-          SpreeCmCommissioner::InventoryHold.transaction do
-            begin
-              hold.assign_attributes(
-                user: order.user,
-                status: :active,
-                held_at: hold.held_at || Time.current,
-                expires_at: expires_at,
-                payment_locked_at: nil,
-                release_reason: nil,
-                total_quantity_on_hold: line_items.sum(&:quantity),
-                ip_address: order.last_ip_address
-              )
-
-              hold.save!
-            rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique
-              raise AcquireHoldSaveError, I18n.t('inventory_hold.acquire.db_save_error')
-            end
-
-            begin
-              redis_rows, redis_applied = acquire_redis_stock!(line_items)
-            rescue Redis::BaseError, Redis::CommandError, IOError
-              raise AcquireRedisDeductionError, I18n.t('inventory_hold.acquire.redis_error')
-            end
-
-            raise AcquireInsufficientStockError, I18n.t('inventory_hold.acquire.insufficient_stock') unless redis_applied
+        SpreeCmCommissioner::InventoryHold.transaction do
+          begin
+            hold.assign_attributes(
+              user: order.user,
+              status: :active,
+              held_at: hold.held_at || Time.current,
+              expires_at: expires_at,
+              payment_locked_at: nil,
+              release_reason: nil,
+              total_quantity_on_hold: line_items.sum(&:quantity),
+              ip_address: order.last_ip_address
+            )
+
+            hold.save!
+          rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique
+            raise AcquireHoldSaveError, I18n.t('inventory_hold.acquire.db_save_error')
           end
-        rescue AcquireInsufficientStockError => e
-          # Logged after the transaction has already rolled back and released its row lock — never
-          # while held — so a slow log write can't extend how long other requests wait on this hold.
-          log_redis_hold_mutation(order: order, hold: hold, correlation_id: correlation_id, rows: redis_rows, applied: false) if redis_rows
-          raise e
-        end
 
-        # Logged after the transaction commits and releases its row lock — never while held.
-        log_redis_hold_mutation(order: order, hold: hold, correlation_id: correlation_id, rows: redis_rows, applied: true) if redis_rows
+          begin
+            positive = acquire_redis_stock!(line_items)
+            raise AcquireInsufficientStockError, I18n.t('inventory_hold.acquire.insufficient_stock') unless positive
+          rescue Redis::BaseError, Redis::CommandError, IOError
+            raise AcquireRedisDeductionError, I18n.t('inventory_hold.acquire.redis_error')
+          end
 
-        hold
+          hold
+        end
       end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-      # Pure Redis I/O — no logging in here (that happens after acquire_hold_for_order!'s
-      # transaction closes). Returns [rows, applied] rather than logging directly, so the mutation
-      # detail survives even on the insufficient-stock path where the caller rolls back and
-      # re-raises.
       def acquire_redis_stock!(line_items)
         stock_keys = []
         hold_keys = []
         quantities = []
         warmable_items = []
-        locked_flags = []
 
         line_items.each do |li|
           # A locked-stock line reserves from the locked pool's own key pair. The Lua below is
@@ -161,57 +127,26 @@ module SpreeCmCommissioner
             hold_keys << item.redis_hold_key(locked: locked)
             quantities << li.quantity
             warmable_items << item
-            locked_flags << locked
           end
         end
 
-        return [nil, true] if hold_keys.empty?
+        return true if hold_keys.empty?
 
-        # Captured (not discarded) so the mutation log (logged later, after the transaction) can
-        # report exactly what Redis held a moment before this eval — zero extra Redis round trips,
-        # the warm already reads it.
-        cached_items = SpreeCmCommissioner::RedisStock::CachedInventoryItemsBuilder.new(warmable_items).call
+        SpreeCmCommissioner::RedisStock::CachedInventoryItemsBuilder.new(warmable_items).call
         interleaved_keys = stock_keys.zip(hold_keys).flatten
 
         result = SpreeCmCommissioner.inventory_redis_pool.with do |redis|
           redis.eval(acquire_lua_script, keys: interleaved_keys, argv: quantities)
         end
 
-        rows = cached_items.each_with_index.map { |cached_item, i| [cached_item, quantities[i], locked_flags[i]] }
-        [rows, result.positive?]
-      end
-
-      # `quantity_on_hold`/`quantity_locked_on_hold` on each cached item is exactly what Redis held
-      # immediately before this eval (the warm above just read it). `applied: false` means the eval
-      # rejected the whole batch (insufficient stock) — nothing was written, so there is no "after".
-      # `rows` is [cached_item, quantity_delta, locked?] per inventory item, in eval order.
-      def log_redis_hold_mutation(order:, hold:, correlation_id:, rows:, applied:)
-        CmAppLogger.log(
-          label: "#{self.class.name}#acquire_redis_stock!",
-          data: {
-            correlation_id: correlation_id,
-            order_id: order.id,
-            hold_id: hold.id,
-            applied: applied,
-            items: rows.map do |cached_item, delta, locked|
-              before = locked ? cached_item.quantity_locked_on_hold : cached_item.quantity_on_hold
-              {
-                inventory_item_id: cached_item.inventory_item_id,
-                locked: locked,
-                quantity_on_hold_before: before,
-                delta: delta,
-                quantity_on_hold_after: applied ? before + delta : before
-              }
-            end
-          }
-        )
+        result.positive?
       end
 
       def enqueue_release_job(hold)
         SpreeCmCommissioner::InventoryHolds::ReleaseJob.set(wait_until: hold.expires_at).perform_later(hold_id: hold.id)
       end
 
-      def enqueue_sync_inventory_on_hold(order, correlation_id)
+      def enqueue_sync_inventory_on_hold(order)
         inventory_id_and_quantities = order.line_items.flat_map do |line_item|
           next [] unless line_item.should_hold_inventory?
 
@@ -229,7 +164,6 @@ module SpreeCmCommissioner
         SpreeCmCommissioner::InventoryItems::BulkAdjustQuantitiesOnHoldJob.perform_later(
           order_id: order.id,
           caller_source: "#{self.class.name}#enqueue_sync_inventory_on_hold",
-          correlation_id: correlation_id,
           inventory_id_and_quantities: inventory_id_and_quantities
         )
       end

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

@@ -4,59 +4,30 @@ module SpreeCmCommissioner
       prepend ::Spree::ServiceModule::Base
       extend SpreeCmCommissioner::ServiceModuleThrowable
 
-      HoldExpiredError = Class.new(StandardError)
-
       def call(order:)
-        # One id per conversion attempt, threaded into the Redis-mutation log below and the DB-sync
-        # job's own log — same purpose as Acquire's correlation_id.
-        correlation_id = SecureRandom.uuid
         hold = InventoryHold.find_by(order: order)
         return success(order) if hold.nil?
-        return success(order) if hold.converted?
-        return failure(nil, hold_expired_message) if hold.finalized?
-
-        redis_rows = nil
+        return success(order) if hold.finalized?
 
         InventoryHold.transaction do
           hold.lock!
 
-          raise HoldExpiredError, hold_expired_message if hold.finalized?
-
-          # Finalized (converted or released) between the check above and acquiring this lock —
-          # e.g. ReleaseJob won the race, or a concurrent completion attempt for the same order
-          # converted it first. Strict: fail either way rather than silently treating "someone
-          # else already converted it" as success — a losing duplicate request should surface as
-          # a failure, not a false success for work it didn't do.
-
-          hold.update!(status: :converted)
-          redis_rows = convert_hold_redis!(order)
-          enqueue_sync_inventory(order, correlation_id)
+          unless hold.finalized?
+            hold.update!(status: :converted)
+            convert_hold_redis!(order)
+            enqueue_sync_inventory(order)
+          end
         end
 
-        # Logged after the transaction commits and hold.lock! releases its row lock — never while
-        # held — so a slow log write can't extend how long other requests wait on this hold.
-        log_redis_convert_mutation(order: order, hold: hold, correlation_id: correlation_id, rows: redis_rows) if redis_rows
-
         success(order)
       rescue StandardError => e
-        error = { error_type: e.class.name.demodulize, correlation_id: correlation_id, order_id: order.id, message: e.message }
+        error = { error_type: e.class.name.demodulize, order_id: order.id, message: e.message }
         CmAppLogger.error(label: "#{self.class.name}#call failed", data: error)
         failure(nil, e.message)
       end
 
       private
 
-      # A hold that is `released` (any reason — expiry, payment timeout, cancellation) by the time
-      # the order tries to complete means its reservation already expired and the unit may have
-      # been reallocated to someone else. Completion must not silently treat that as "already
-      # handled" the way an already-`converted` hold correctly is (idempotent re-entry). Failing
-      # here surfaces as UnableToConvertInventoryError from OrderHolds::Reserve, which rolls back
-      # the :complete transition — the same rollback path a genuine insufficient-stock failure in
-      # RedisStock::Unstock already takes.
-      def hold_expired_message
-        I18n.t('inventory_hold.convert.hold_expired')
-      end
-
       # 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
@@ -67,14 +38,11 @@ module SpreeCmCommissioner
       #
       # 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.
-      # Pure Redis I/O — no logging in here (that happens after the caller's transaction closes).
-      # Returns the rows the mutation log needs, or nil when there was nothing to convert.
       def convert_hold_redis!(order)
         stock_keys = []
         hold_keys = []
         quantities = []
         warmable_items = []
-        locked_flags = []
 
         order.line_items.each do |li|
           next unless li.should_hold_inventory?
@@ -89,51 +57,17 @@ module SpreeCmCommissioner
             hold_keys << item.redis_hold_key(locked: locked)
             quantities << li.quantity
             warmable_items << item
-            locked_flags << locked
           end
         end
 
         return if hold_keys.empty?
 
-        # Captured (not discarded) — the warm already reads both counters this eval is about to
-        # decrement, so the mutation log (logged later, after the transaction) needs no extra Redis
-        # round trip.
-        cached_items = SpreeCmCommissioner::RedisStock::CachedInventoryItemsBuilder.new(warmable_items).call
+        SpreeCmCommissioner::RedisStock::CachedInventoryItemsBuilder.new(warmable_items).call
 
         interleaved_keys = stock_keys.zip(hold_keys).flatten
         SpreeCmCommissioner.inventory_redis_pool.with do |redis|
           redis.eval(convert_hold_lua_script, keys: interleaved_keys, argv: quantities)
         end
-
-        cached_items.each_with_index.map { |cached_item, i| [cached_item, quantities[i], locked_flags[i]] }
-      end
-
-      # This script always applies (no insufficiency check — the unit was already validated and
-      # reserved at Acquire time), so every item here has a real "after": both the stock and hold
-      # counters drop by the same delta. `rows` is [cached_item, quantity_delta, locked?] per
-      # inventory item, in eval order.
-      def log_redis_convert_mutation(order:, hold:, correlation_id:, rows:)
-        CmAppLogger.log(
-          label: "#{self.class.name}#convert_hold_redis!",
-          data: {
-            correlation_id: correlation_id,
-            order_id: order.id,
-            hold_id: hold.id,
-            items: rows.map do |cached_item, delta, locked|
-              stock_before = locked ? cached_item.quantity_locked : cached_item.quantity_available
-              hold_before = locked ? cached_item.quantity_locked_on_hold : cached_item.quantity_on_hold
-              {
-                inventory_item_id: cached_item.inventory_item_id,
-                locked: locked,
-                delta: delta,
-                quantity_available_before: stock_before,
-                quantity_available_after: stock_before - delta,
-                quantity_on_hold_before: hold_before,
-                quantity_on_hold_after: hold_before - delta
-              }
-            end
-          }
-        )
       end
 
       def convert_hold_lua_script
@@ -152,7 +86,7 @@ module SpreeCmCommissioner
       # 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, correlation_id)
+      def enqueue_sync_inventory(order)
         adjustments = order.line_items.flat_map do |line_item|
           next [] unless line_item.should_hold_inventory?
 
@@ -171,7 +105,6 @@ module SpreeCmCommissioner
         SpreeCmCommissioner::InventoryItems::BulkAdjustQuantitiesOnConvertJob.perform_later(
           order_id: order.id,
           caller_source: "#{self.class.name}#enqueue_sync_inventory",
-          correlation_id: correlation_id,
           inventory_id_and_quantities: adjustments
         )
       end

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

@@ -9,11 +9,7 @@ module SpreeCmCommissioner
       def call(hold:, reason: :hold_expired, scheduled_release: false)
         return success(hold) if hold.finalized?
 
-        # One id per release attempt, threaded into the Redis-mutation log below and the DB-sync
-        # job's own log — same purpose as Acquire's/Convert's correlation_id.
-        correlation_id = SecureRandom.uuid
         released = false
-        redis_rows = nil
 
         InventoryHold.transaction do
           hold.lock!
@@ -27,15 +23,11 @@ module SpreeCmCommissioner
           next if scheduled_release && hold.expires_at > Time.current
 
           hold.update!(status: :released, release_reason: reason)
-          redis_rows = restock_redis!(hold)
-          enqueue_sync_inventory_on_hold(hold.order, correlation_id)
+          restock_redis!(hold)
+          enqueue_sync_inventory_on_hold(hold.order)
           released = true
         end
 
-        # Logged after the transaction commits and hold.lock! releases its row lock — never while
-        # held — so a slow log write can't extend how long other requests wait on this hold.
-        log_redis_release_mutation(hold: hold, correlation_id: correlation_id, rows: redis_rows) if redis_rows
-
         # Notify AFTER the transaction commits (deliver_later must not be enqueued inside an open
         # transaction), and only when THIS invocation performed the release — the `next` guards above
         # commit without releasing, so this keeps notifications idempotent across stale/concurrent jobs.
@@ -63,10 +55,8 @@ module SpreeCmCommissioner
         SpreeCmCommissioner::ReleaseInventoryItemNotificationSender.call(notificable: hold.order)
       end
 
-      # Pure Redis I/O — no logging in here (that happens after the caller's transaction closes).
-      # Returns the rows the mutation log needs, or nil when there was nothing to release.
       def restock_redis!(hold)
-        keys, quantities, warmable_items, locked_flags = hold_keys_and_quantities(hold.order)
+        keys, quantities, warmable_items = hold_keys_and_quantities(hold.order)
         return if keys.empty?
 
         release_hold_lua_script = <<~LUA
@@ -78,46 +68,16 @@ module SpreeCmCommissioner
           return 1
         LUA
 
-        # Captured (not discarded) — the warm already reads the hold counter this eval is about to
-        # decrement, so the mutation log (logged later, after the transaction) needs no extra Redis
-        # round trip.
-        cached_items = SpreeCmCommissioner::RedisStock::CachedInventoryItemsBuilder.new(warmable_items).call
+        SpreeCmCommissioner::RedisStock::CachedInventoryItemsBuilder.new(warmable_items).call
         SpreeCmCommissioner.inventory_redis_pool.with do |redis|
           redis.eval(release_hold_lua_script, keys: keys, argv: quantities)
         end
-
-        cached_items.each_with_index.map { |cached_item, i| [cached_item, quantities[i], locked_flags[i]] }
-      end
-
-      # This script always applies (no insufficiency check — releasing a hold can't oversell), so
-      # every item here has a real "after". `rows` is [cached_item, quantity_delta, locked?] per
-      # inventory item, in eval order.
-      def log_redis_release_mutation(hold:, correlation_id:, rows:)
-        CmAppLogger.log(
-          label: "#{self.class.name}#restock_redis!",
-          data: {
-            correlation_id: correlation_id,
-            order_id: hold.order.id,
-            hold_id: hold.id,
-            items: rows.map do |cached_item, delta, locked|
-              before = locked ? cached_item.quantity_locked_on_hold : cached_item.quantity_on_hold
-              {
-                inventory_item_id: cached_item.inventory_item_id,
-                locked: locked,
-                delta: delta,
-                quantity_on_hold_before: before,
-                quantity_on_hold_after: before - delta
-              }
-            end
-          }
-        )
       end
 
       def hold_keys_and_quantities(order)
         keys = []
         quantities = []
         warmable_items = []
-        locked_flags = []
 
         order.line_items.includes(:variant).find_each do |li|
           next unless li.should_hold_inventory?
@@ -131,14 +91,13 @@ module SpreeCmCommissioner
             keys << item.redis_hold_key(locked: locked)
             quantities << li.quantity
             warmable_items << item
-            locked_flags << locked
           end
         end
 
-        [keys, quantities, warmable_items, locked_flags]
+        [keys, quantities, warmable_items]
       end
 
-      def enqueue_sync_inventory_on_hold(order, correlation_id)
+      def enqueue_sync_inventory_on_hold(order)
         inventory_id_and_quantities = order.line_items.flat_map do |line_item|
           next [] unless line_item.should_hold_inventory?
 
@@ -157,7 +116,6 @@ module SpreeCmCommissioner
         SpreeCmCommissioner::InventoryItems::BulkAdjustQuantitiesOnHoldJob.perform_later(
           order_id: order.id,
           caller_source: "#{self.class.name}#enqueue_sync_inventory_on_hold",
-          correlation_id: correlation_id,
           inventory_id_and_quantities: inventory_id_and_quantities
         )
       end

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

@@ -37,14 +37,14 @@ module SpreeCmCommissioner
         # thing RedisStock::Unstock and InventoryHolds::Convert do before their own Lua scripts.
         warm_redis_key!(inventory_item) if warm_redis
 
-        before = after = redis_after = nil
+        before = after = nil
 
         apply = lambda do
           before = inventory_item.quantity_available
           after = before + delta
 
           inventory_item.update!(quantity_available: after)
-          redis_after = inventory_item.adjust_quantity_in_redis(delta)
+          inventory_item.adjust_quantity_in_redis(delta)
         end
 
         lock ? inventory_item.with_lock(&apply) : apply.call
@@ -59,8 +59,7 @@ module SpreeCmCommissioner
             inventory_item_id: inventory_item.id,
             quantity_available_before: before,
             delta: delta,
-            quantity_available_after: after,
-            redis_quantity_after: redis_after
+            quantity_available_after: after
           }
         )
 

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

@@ -4,10 +4,10 @@ module SpreeCmCommissioner
       prepend ::Spree::ServiceModule::Base
       extend SpreeCmCommissioner::ServiceModuleThrowable
 
-      def call(inventory_id_and_quantities:, caller_source: nil, correlation_id: nil)
+      def call(inventory_id_and_quantities:, caller_source: nil)
         CmAppLogger.log(
           label: "#{self.class.name}#call started",
-          data: { correlation_id: correlation_id, caller_source: caller_source, inventory_id_and_quantities: inventory_id_and_quantities }
+          data: { caller_source: caller_source, inventory_id_and_quantities: inventory_id_and_quantities }
         )
 
         ActiveRecord::Base.transaction do
@@ -17,7 +17,7 @@ module SpreeCmCommissioner
             inventory_item = items_by_id[inventory_id]
             next if inventory_item.nil?
 
-            adjust_quantity_available(inventory_item, quantity, caller_source, correlation_id, locked: locked)
+            adjust_quantity_available(inventory_item, quantity, caller_source, locked: locked)
           end
         end
 
@@ -38,7 +38,7 @@ module SpreeCmCommissioner
       end
 
       # locked defaults to false so the original three-argument signature keeps working.
-      def adjust_quantity_available(inventory_item, quantity, caller_source, correlation_id, locked: false)
+      def adjust_quantity_available(inventory_item, quantity, caller_source, locked: false)
         column = locked ? :quantity_locked : :quantity_available
 
         # IMPORTANT: Apply the quantity change directly without defensive clamping.
@@ -63,7 +63,6 @@ module SpreeCmCommissioner
         CmAppLogger.log(
           label: "#{self.class.name}#adjust_quantity_available",
           data: {
-            correlation_id: correlation_id,
             caller_source: caller_source,
             inventory_item_id: inventory_item.id,
             locked: locked,
@@ -77,7 +76,6 @@ module SpreeCmCommissioner
         CmAppLogger.error(
           label: "#{self.class.name}#adjust_quantity_available failed",
           data: {
-            correlation_id: correlation_id,
             caller_source: caller_source,
             inventory_item_id: inventory_item.id,
             locked: locked,

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

@@ -5,18 +5,8 @@ module SpreeCmCommissioner
       extend SpreeCmCommissioner::ServiceModuleThrowable
 
       def call(variant:, quantity:)
-        # One id per batch — every inventory item touched below logs it via
-        # InventoryItem#adjust_quantity!, tying this whole variant-wide adjustment together in a
-        # search, same as the other Bulk* services' correlation_id.
-        correlation_id = SecureRandom.uuid
-
-        CmAppLogger.log(
-          label: "#{self.class.name}#call started",
-          data: { correlation_id: correlation_id, variant_id: variant.id, delta: quantity }
-        )
-
         variant.inventory_items.active.find_each do |inventory_item|
-          inventory_item.adjust_quantity!(quantity, correlation_id: correlation_id)
+          inventory_item.adjust_quantity!(quantity)
         end
 
         success(nil)

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

@@ -10,10 +10,10 @@ module SpreeCmCommissioner
       prepend ::Spree::ServiceModule::Base
       extend SpreeCmCommissioner::ServiceModuleThrowable
 
-      def call(inventory_id_and_quantities:, caller_source: nil, correlation_id: nil)
+      def call(inventory_id_and_quantities:, caller_source: nil)
         CmAppLogger.log(
           label: "#{self.class.name}#call started",
-          data: { correlation_id: correlation_id, caller_source: caller_source, inventory_id_and_quantities: inventory_id_and_quantities }
+          data: { caller_source: caller_source, inventory_id_and_quantities: inventory_id_and_quantities }
         )
 
         ActiveRecord::Base.transaction do
@@ -23,7 +23,7 @@ module SpreeCmCommissioner
             inventory_item = items_by_id[inventory_id]
             next if inventory_item.nil?
 
-            adjust_quantities(inventory_item, quantity, caller_source, correlation_id, locked: locked)
+            adjust_quantities(inventory_item, quantity, caller_source, locked: locked)
           end
         end
 
@@ -40,7 +40,7 @@ module SpreeCmCommissioner
           .transform_values { |entries| entries.sum { |entry| entry[:quantity] } }
       end
 
-      def adjust_quantities(inventory_item, quantity, caller_source, correlation_id, locked: false)
+      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
 
@@ -60,7 +60,6 @@ module SpreeCmCommissioner
         CmAppLogger.log(
           label: "#{self.class.name}#adjust_quantities",
           data: {
-            correlation_id: correlation_id,
             caller_source: caller_source,
             inventory_item_id: inventory_item.id,
             locked: locked,
@@ -77,7 +76,6 @@ module SpreeCmCommissioner
         CmAppLogger.error(
           label: "#{self.class.name}#adjust_quantities failed",
           data: {
-            correlation_id: correlation_id,
             caller_source: caller_source,
             inventory_item_id: inventory_item.id,
             locked: locked,

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

@@ -4,11 +4,10 @@ module SpreeCmCommissioner
       prepend ::Spree::ServiceModule::Base
       extend SpreeCmCommissioner::ServiceModuleThrowable
 
-      def call(inventory_id_and_quantities:, caller_source: nil, correlation_id: nil)
+      def call(inventory_id_and_quantities:, caller_source: nil)
         CmAppLogger.log(
           label: "#{self.class.name}#call started",
           data: {
-            correlation_id: correlation_id,
             caller_source: caller_source,
             inventory_id_and_quantities: inventory_id_and_quantities
           }
@@ -21,7 +20,7 @@ module SpreeCmCommissioner
             inventory_item = items_by_id[inventory_id]
             next if inventory_item.nil?
 
-            adjust_quantity_on_hold(inventory_item, quantity, caller_source, correlation_id, locked: locked)
+            adjust_quantity_on_hold(inventory_item, quantity, caller_source, locked: locked)
           end
         end
 
@@ -45,7 +44,7 @@ module SpreeCmCommissioner
       end
 
       # locked defaults to false so the original three-argument signature keeps working.
-      def adjust_quantity_on_hold(inventory_item, quantity, caller_source, correlation_id, locked: false)
+      def adjust_quantity_on_hold(inventory_item, quantity, caller_source, locked: false)
         column = locked ? :quantity_locked_on_hold : :quantity_on_hold
 
         # IMPORTANT: Apply the quantity change directly without defensive clamping.
@@ -70,7 +69,6 @@ module SpreeCmCommissioner
         CmAppLogger.log(
           label: "#{self.class.name}#adjust_quantity_on_hold",
           data: {
-            correlation_id: correlation_id,
             caller_source: caller_source,
             inventory_item_id: inventory_item.id,
             locked: locked,
@@ -84,7 +82,6 @@ module SpreeCmCommissioner
         CmAppLogger.error(
           label: "#{self.class.name}#adjust_quantity_on_hold failed",
           data: {
-            correlation_id: correlation_id,
             caller_source: caller_source,
             inventory_item_id: inventory_item.id,
             locked: locked,

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

@@ -25,54 +25,39 @@ module SpreeCmCommissioner
         # key could not be warmed and the adjustment would clamp the date to 0 for a year.
         return failure(nil, :inactive_inventory_item) unless inventory_item.active?
 
-        # One id per transfer, tying this call's Redis-mutation log to its DB-value logs below —
-        # there's no async job on this path (row and Redis are written together), but a shared id
-        # still makes the two log lines trivially joinable in a search.
-        correlation_id = SecureRandom.uuid
         outcome = nil
-        redis_mutation = nil
 
         # requires_new, not a bare with_lock: an ActiveRecord::Rollback raised in a nested transaction
         # is swallowed without rolling anything back, so a refused transfer would leave the row already
         # moved. The savepoint makes the rollback real wherever this is called from.
         inventory_item.transaction(requires_new: true) do
           inventory_item.lock!
-          outcome, redis_mutation = transfer!(inventory_item, quantity, caller_source, user)
+          outcome = transfer!(inventory_item, quantity, caller_source, user)
           raise ActiveRecord::Rollback unless outcome == :moved
         end
 
-        # Logged after the transaction commits/rolls back and inventory_item.lock! releases its row
-        # lock — never while held — so a slow log write can't extend how long other requests wait on
-        # this item.
-        log_redis_move_mutation(inventory_item, quantity, redis_mutation, correlation_id) if redis_mutation
-
         return failure(nil, outcome) unless outcome == :moved
 
-        log_adjustment(inventory_item, quantity, caller_source, correlation_id)
-        log(inventory_item, quantity, outcome, correlation_id)
+        log(inventory_item, quantity, outcome)
         success(inventory_item)
       end
 
       private
 
-      # Runs inside the locked transaction. Returns [outcome, redis_mutation] — redis_mutation is
-      # {cached_item:, applied:} once move_stock_in_redis has actually run, else nil. No logging in
-      # here (that happens in `call`, after the transaction closes).
+      # Runs inside the locked transaction. Returns the outcome symbol.
       def transfer!(inventory_item, quantity, caller_source, user)
         new_locked = inventory_item.quantity_locked + quantity
-        return [:quantity_exceeds_lock, nil] if new_locked.negative?
+        return :quantity_exceeds_lock if new_locked.negative?
 
         # Neither column may go negative. The Redis script below is the authoritative check because it
         # is the only one that sees holds, but it runs after the row write — so bound the row here or
         # the update raises RecordInvalid instead of returning a named failure the admin can read.
         new_available = inventory_item.quantity_available - quantity
-        return [insufficient_stock_reason(quantity), nil] if new_available.negative?
+        return insufficient_stock_reason(quantity) if new_available.negative?
 
         # SET-NX both pools from the row before anything is written, so the script below never reads a
-        # cold key as 0 and moves units that were never there. Captured (not discarded) — this is
-        # exactly the pre-mutation Redis snapshot the mutation log (logged later, after the
-        # transaction) needs, no extra round trip.
-        cached_item = warm_pools(inventory_item)
+        # cold key as 0 and moves units that were never there.
+        warm_pools(inventory_item)
 
         # ORDER MATTERS, and not for style. Redis has no rollback, and InventoryItems::Reset cannot
         # recompute quantity_locked — there are no rows to derive it from — so a Redis write that
@@ -80,42 +65,14 @@ module SpreeCmCommissioner
         # it back if the script refuses.
         inventory_item.update!(quantity_locked: new_locked, quantity_available: new_available)
 
-        applied = move_stock_in_redis(inventory_item, quantity)
-        redis_mutation = { cached_item: cached_item, applied: applied }
-        return [insufficient_stock_reason(quantity), redis_mutation] unless applied
+        return insufficient_stock_reason(quantity) unless move_stock_in_redis(inventory_item, quantity)
 
         # Inside the same savepoint as the row update above, so a later failure in this same call would
         # roll this row back with it — the ledger can never disagree with quantity_locked.
         create_movement!(inventory_item, quantity, caller_source, user)
+        log_adjustment(inventory_item, quantity, caller_source)
 
-        [:moved, redis_mutation]
-      end
-
-      # `applied: false` means the script refused (would drain a pool below what's held) — nothing
-      # was written, so there is no "after" for either pool.
-      def log_redis_move_mutation(inventory_item, quantity, redis_mutation, correlation_id)
-        cached_item = redis_mutation[:cached_item]
-        applied = redis_mutation[:applied]
-        locking = quantity.positive?
-        delta = quantity.abs
-        from_before = locking ? cached_item.quantity_available : cached_item.quantity_locked
-        to_before = locking ? cached_item.quantity_locked : cached_item.quantity_available
-
-        CmAppLogger.log(
-          label: "#{self.class.name}#move_stock_in_redis",
-          data: {
-            correlation_id: correlation_id,
-            inventory_item_id: inventory_item.id,
-            applied: applied,
-            from_pool: locking ? 'public' : 'locked',
-            to_pool: locking ? 'locked' : 'public',
-            delta: delta,
-            from_before: from_before,
-            from_after: applied ? from_before - delta : from_before,
-            to_before: to_before,
-            to_after: applied ? to_before + delta : to_before
-          }
-        )
+        :moved
       end
 
       # The one durable record of this transfer — CmAppLogger below is a log line, not a queryable row.
@@ -185,11 +142,10 @@ module SpreeCmCommissioner
       # AdjustAvailableQuantity used to write quantity_available and carry this log line. The script
       # above owns both stock keys now, so the row update is folded into transfer! — but caller_source
       # is threaded from the admin controller specifically so the audit trail names the action.
-      def log_adjustment(inventory_item, quantity, caller_source, correlation_id)
+      def log_adjustment(inventory_item, quantity, caller_source)
         CmAppLogger.log(
           label: "#{self.class.name}#transfer!",
           data: {
-            correlation_id: correlation_id,
             caller_source: caller_source || "#{self.class.name}#transfer!",
             inventory_item_id: inventory_item.id,
             quantity_available: inventory_item.quantity_available,
@@ -199,11 +155,10 @@ module SpreeCmCommissioner
         )
       end
 
-      def log(inventory_item, quantity, outcome, correlation_id)
+      def log(inventory_item, quantity, outcome)
         CmAppLogger.log(
           label: "#{self.class.name}#call",
           data: {
-            correlation_id: correlation_id,
             inventory_item_id: inventory_item.id,
             quantity: quantity,
             quantity_available: inventory_item.quantity_available,

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

@@ -28,12 +28,11 @@ module SpreeCmCommissioner
         SpreeCmCommissioner::RedisStock::CachedInventoryItemsBuilder.new(inventory_items).call
       end
 
-      def schedule_sync_inventory(inventory_id_and_quantities, correlation_id:)
+      def schedule_sync_inventory(inventory_id_and_quantities)
         SpreeCmCommissioner::InventoryItems::BulkAdjustQuantitiesJob.perform_later(
           inventory_id_and_quantities: inventory_id_and_quantities,
           line_item_ids: @line_item_ids,
-          caller_source: "#{self.class.name}#schedule_sync_inventory",
-          correlation_id: correlation_id
+          caller_source: "#{self.class.name}#schedule_sync_inventory"
         )
       end
     end

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

@@ -4,7 +4,6 @@ module SpreeCmCommissioner
       # override
       def call(line_item_ids:)
         @line_item_ids = line_item_ids
-        correlation_id = SecureRandom.uuid
 
         keys = []
         quantities = []
@@ -29,51 +28,20 @@ module SpreeCmCommissioner
           end
         end
 
-        # Captured (not discarded) — the warm already reads the stock counter this eval is about to
-        # increment, so the mutation log below needs no extra Redis round trip.
-        cached_items = warm_redis_keys!(warmable_items)
+        warm_redis_keys!(warmable_items)
 
-        applied = restock(keys, quantities, max_capacities)
-        log_redis_restock_mutation(correlation_id: correlation_id, cached_items: cached_items, quantities: quantities, locked_flags: locked_flags,
-                                   applied: applied
-        )
-        return failure(nil, :unable_to_restock) unless applied
+        return failure(nil, :unable_to_restock) unless restock(keys, quantities, max_capacities)
 
         inventory_id_and_quantities = inventory_ids.map.with_index do |inventory_id, i|
           { inventory_id: inventory_id, quantity: quantities[i], locked: locked_flags[i] }
         end
 
-        schedule_sync_inventory(inventory_id_and_quantities, correlation_id: correlation_id)
+        schedule_sync_inventory(inventory_id_and_quantities)
         success(nil)
       end
 
       private
 
-      # `applied: false` means the eval rejected the whole batch (would exceed max_capacity) —
-      # nothing was written, so there is no "after" for those items.
-      def log_redis_restock_mutation(correlation_id:, cached_items:, quantities:, locked_flags:, applied:)
-        CmAppLogger.log(
-          label: "#{self.class.name}#restock",
-          data: {
-            correlation_id: correlation_id,
-            line_item_ids: @line_item_ids,
-            applied: applied,
-            items: cached_items.each_with_index.map do |cached_item, i|
-              locked = locked_flags[i]
-              before = locked ? cached_item.quantity_locked : cached_item.quantity_available
-              delta = quantities[i]
-              {
-                inventory_item_id: cached_item.inventory_item_id,
-                locked: locked,
-                quantity_available_before: before,
-                delta: delta,
-                quantity_available_after: applied ? before + delta : before
-              }
-            end
-          }
-        )
-      end
-
       # max_capacity is the ceiling for both pools. For :locked it is loose rather than exact — the
       # true ceiling would be the size of the lock, which is not tracked — but it is always an upper
       # bound on what can sit in the locked pool, so it never rejects a legitimate restock. Going

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

@@ -4,7 +4,6 @@ module SpreeCmCommissioner
       # override
       def call(line_item_ids:)
         @line_item_ids = line_item_ids
-        correlation_id = SecureRandom.uuid
 
         keys = []
         quantities = []
@@ -31,51 +30,20 @@ module SpreeCmCommissioner
           end
         end
 
-        # Captured (not discarded) — the warm already reads the stock counter this eval is about to
-        # decrement, so the mutation log below needs no extra Redis round trip.
-        cached_items = warm_redis_keys!(warmable_items)
+        warm_redis_keys!(warmable_items)
 
-        applied = unstock(keys, quantities)
-        log_redis_unstock_mutation(correlation_id: correlation_id, cached_items: cached_items, quantities: quantities, locked_flags: locked_flags,
-                                   applied: applied
-        )
-        return failure(nil, :unable_to_unstock) unless applied
+        return failure(nil, :unable_to_unstock) unless unstock(keys, quantities)
 
         inventory_id_and_quantities = inventory_ids.map.with_index do |inventory_id, i|
           { inventory_id: inventory_id, quantity: -quantities[i], locked: locked_flags[i] }
         end
 
-        schedule_sync_inventory(inventory_id_and_quantities, correlation_id: correlation_id)
+        schedule_sync_inventory(inventory_id_and_quantities)
         success(nil)
       end
 
       private
 
-      # `applied: false` means the eval rejected the whole batch (would go negative) — nothing was
-      # written, so there is no "after" for those items.
-      def log_redis_unstock_mutation(correlation_id:, cached_items:, quantities:, locked_flags:, applied:)
-        CmAppLogger.log(
-          label: "#{self.class.name}#unstock",
-          data: {
-            correlation_id: correlation_id,
-            line_item_ids: @line_item_ids,
-            applied: applied,
-            items: cached_items.each_with_index.map do |cached_item, i|
-              locked = locked_flags[i]
-              before = locked ? cached_item.quantity_locked : cached_item.quantity_available
-              delta = quantities[i]
-              {
-                inventory_item_id: cached_item.inventory_item_id,
-                locked: locked,
-                quantity_available_before: before,
-                delta: delta,
-                quantity_available_after: applied ? before - delta : before
-              }
-            end
-          }
-        )
-      end
-
       def unstock(keys, quantities)
         SpreeCmCommissioner.inventory_redis_pool.with do |redis|
           redis.eval(unstock_redis_script, keys: keys, argv: quantities)

data/config/locales/en.yml

@@ -1006,8 +1006,6 @@ en:
       exceeded_active_holds: "You've reached the limit of reservations you can hold at once. Please complete or cancel one before reserving more."
       ip_rate_limit: "Too many reservation attempts from your network in a short time. Please wait a while and try again."
       hold_cooldown: "Your previous reservation just expired. Please wait a couple of minutes before reserving again."
-    convert:
-      hold_expired: "Your reservation expired before payment completed. Please try booking again."
 
   # Displayed as-is on stock-status badges pushed to Firestore (see
   # SpreeCmCommissioner::Products::PublishStockStatusToFirestore) — not read via I18n at request

data/config/locales/km.yml

@@ -605,8 +605,6 @@ km:
       exceeded_active_holds: "អ្នកកក់ដល់ចំនួនកំណត់អតិបរមាក្នុងពេលតែមួយហើយ។ សូមបញ្ចប់ ឬលុបការកក់មួយ មុនពេលកក់បន្ថែម។"
       ip_rate_limit: "មានការព្យាយាមកក់ច្រើនពេកពីបណ្តាញរបស់អ្នកក្នុងរយៈពេលខ្លី។ សូមរង់ចាំបន្តិច រួចព្យាយាមម្តងទៀត។"
       hold_cooldown: "ការកក់មុនរបស់អ្នកទើបតែផុតកំណត់។ សូមរង់ចាំពីរបីនាទី មុនពេលកក់ម្តងទៀត។"
-    convert:
-      hold_expired: "ការកក់របស់អ្នកបានផុតកំណត់មុនពេលទូទាត់ប្រាក់បានបញ្ចប់។ សូមព្យាយាមកក់ម្តងទៀត។"
 
   stock_status:
     pending_hold: "តម្រូវការខ្ពស់"

data/lib/spree_cm_commissioner/version.rb

@@ -1,5 +1,5 @@
 module SpreeCmCommissioner
-  VERSION = '2.12.7-pre1'.freeze
+  VERSION = '2.12.8'.freeze
 
   module_function
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spree_cm_commissioner
 version: !ruby/object:Gem::Version
-  version: 2.12.7.pre.pre1
+  version: 2.12.8
 platform: ruby
 authors:
 - You
@@ -3781,9 +3781,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements:
 - none
 rubygems_version: 3.4.1