spree_vpago 2.4.2 → 2.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af2ee300102ba9c6ca000d69c338ec7b2775d6b367dd0b38ea7c9ae65ccb47f1
-  data.tar.gz: f28c459ecab0f6ec6053342a525ad8b4d525ae840aa6a8fb902ddee246edec98
+  metadata.gz: c60cd32b8e9acf6a13c8f3190521841f2305566a750750dd8ae050eb65728859
+  data.tar.gz: 0c7dfd54ac257faa8ec0690cb529d2c42ac74dfe4f4103daf16f39a95794818d
 SHA512:
-  metadata.gz: d468af9361fc9c5055d3523e23df57d24a55d62a14cfc2f3d769e59817c92cff9233f70cd54e49c2d618ebe6ee165205c39278afaaf7c43490a1db9fef4656e1
-  data.tar.gz: 3bb37aade93a26049c3aba23a230fc5f337dea599418690583ea774f0c9a0f26b55041ef1414745dc5c3b5c63f97cc78525ce64bf35ef1a8a2721093137d020b
+  metadata.gz: 7306bfdaa203f43b7bd28e1f8237efb3b4c6c72dc98160d6e1ec6afdddace2871ca790fc133b5dde2cc6b7e4703fdcdbf0ed99b2d3f5e258f2a3be20b7a38657
+  data.tar.gz: da6a16929e7b9b11427e922ceb8dafdc236ec876e9047666eb062700b767b0030b75ee2fa15543fe3f03ed5a9920ad2efe79add77f4fc3c5471aa918f2081ac1

data/.github/workflows/test_and_publish_gem.yml

@@ -15,7 +15,9 @@ on:
         - "*"
 jobs:
   test_and_publish_gem:
-    runs-on: ubuntu-latest
+    # Pinned: ubuntu-latest moved to 26.04, where setup-ruby only ships the latest patch of each series, so
+    # ruby 3.2.0 below 404s. Bump both together.
+    runs-on: ubuntu-24.04
 
     services:
       db:

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    spree_vpago (2.4.2)
+    spree_vpago (2.4.3)
       faraday
       google-cloud-firestore
       spree_api (>= 4.5)

data/Rakefile

@@ -18,4 +18,11 @@ desc 'Generates a dummy app for testing'
 task :test_app do
   ENV['LIB_NAME'] = 'spree_vpago'
   Rake::Task['extension:test_app'].invoke
+
+  # spree_backend 4.5's installer runs an unpinned `yarn add @spree/dashboard`, which now resolves to Spree 6's
+  # React dashboard that this dummy app's esbuild can't bundle. spree-dashboard.js is then never built and every
+  # spec rendering a page fails, so pin the last 4.x-compatible release and rebuild.
+  Dir.chdir(File.expand_path('spec/dummy', __dir__)) do
+    system('yarn add @spree/dashboard@0.2.1 && yarn build && bundle exec rake assets:precompile', exception: true)
+  end
 end

data/app/assets/javascripts/vpago/vpago_payments/user_informers/firebase.js

@@ -13689,6 +13689,11 @@ This typically indicates that your device does not have a healthy Internet conne
   };
 
   // app/javascripts/vpago/vpago_payments/user_informers/firebase.js
+  var CAPTURE_PENDING_CODES = [
+    "payment_is_capturing",
+    "payment_capture_retrying",
+    "payment_capture_unconfirmed"
+  ];
   async function listenToProcessingState({
     firebaseConfigs,
     documentReferencePath,
@@ -13696,6 +13701,9 @@ This typically indicates that your device does not have a healthy Internet conne
     onPaymentIsRetrying,
     onOrderIsProcessing,
     onOrderIsCompleted,
+    onPaymentIsCapturing,
+    onPaymentCaptureRetrying,
+    onPaymentCaptureUnconfirmed,
     onOrderProcessFailed,
     onPaymentProcessFailed,
     onCompleted
@@ -13716,7 +13724,7 @@ This typically indicates that your device does not have a healthy Internet conne
       if (window.parent !== window) {
         window.parent.postMessage(messageCode, "*");
       }
-      let orderCompleted = orderState === "complete";
+      let orderCompleted = orderState === "complete" && !CAPTURE_PENDING_CODES.includes(messageCode);
       if (orderCompleted) {
         queueProcessor.queueStateChange({
           minDelayInMs: 1500,
@@ -13788,6 +13796,48 @@ This typically indicates that your device does not have a healthy Internet conne
             }
           });
           break;
+        case "payment_is_capturing":
+          queueProcessor.queueStateChange({
+            minDelayInMs: 1500,
+            callback: async () => {
+              await onPaymentIsCapturing?.(
+                orderState,
+                paymentState,
+                processing,
+                reasonCode,
+                reasonMessage
+              );
+            }
+          });
+          break;
+        case "payment_capture_retrying":
+          queueProcessor.queueStateChange({
+            minDelayInMs: 1500,
+            callback: async () => {
+              await onPaymentCaptureRetrying?.(
+                orderState,
+                paymentState,
+                processing,
+                reasonCode,
+                reasonMessage
+              );
+            }
+          });
+          break;
+        case "payment_capture_unconfirmed":
+          queueProcessor.queueStateChange({
+            minDelayInMs: 1500,
+            callback: async () => {
+              await onPaymentCaptureUnconfirmed?.(
+                orderState,
+                paymentState,
+                processing,
+                reasonCode,
+                reasonMessage
+              );
+            }
+          });
+          break;
         case "order_process_failed":
           queueProcessor.queueStateChange({
             minDelayInMs: 1500,

data/app/controllers/spree/admin/suspicious_orders_controller.rb

@@ -4,7 +4,7 @@ module Spree
       around_action :set_writing_role, only: %i[check_transaction]
 
       def index
-        params[:q] = { completed_at_not_null: 1, payment_state_eq: 'balance_due', s: 'completed_at desc' }.dup if params[:q].blank?
+        params[:q] = default_query if params[:q].blank?
 
         @search = exclude_request_bookings(scope).ransack(params[:q])
         @orders = @search.result(distinct: true)
@@ -60,6 +60,12 @@ module Spree
         current_store.orders.accessible_by(current_ability, :index)
       end
 
+      # `failed` too: a pre-auth capture that failed under the old flow left its order `failed`
+      # (its only payment is invalid), which `balance_due` alone never listed.
+      def default_query
+        { completed_at_not_null: 1, payment_state_in: %w[balance_due failed], s: 'completed_at desc' }
+      end
+
       # Request bookings complete before the vendor confirms and the customer
       # pays, so balance_due is expected there rather than a lost payment.
       # `request_state` is added by spree_cm_commissioner, hence the column check.

data/app/controllers/spree/vpago_payments_controller.rb

@@ -32,7 +32,10 @@ module Spree
       # checker often completes the order before the browser lands here. Skipping this page
       # also skips its Firebase listener, so success must post order_is_completed itself
       # (render_success_script) or an embedding iframe modal never closes.
-      return redirect_to @payment.success_url, allow_other_host: true if @order.completed?
+      #
+      # A pre-auth payment is the exception: its order completes on the hold, so the user (often just back
+      # from the bank app) stays here on "verifying" until PaymentCapturerJob captures it.
+      return redirect_to @payment.success_url, allow_other_host: true if @order.completed? && !@payment.awaiting_pre_auth_capture?
 
       VpagoLogger.log(label: 'Spree::VpagoPaymentsController#processing', data: vpago_log_context)
       render 'spree/vpago_shared/processing'

data/app/javascripts/vpago/vpago_payments/user_informers/firebase.js

@@ -2,6 +2,12 @@ import { initializeApp } from "firebase/app";
 import { getFirestore, doc, onSnapshot, setDoc } from "firebase/firestore";
 import QueueProcessor from "../../../queue_processor.js";
 
+const CAPTURE_PENDING_CODES = [
+  "payment_is_capturing",
+  "payment_capture_retrying",
+  "payment_capture_unconfirmed",
+];
+
 async function listenToProcessingState({
   firebaseConfigs,
   documentReferencePath,
@@ -9,6 +15,9 @@ async function listenToProcessingState({
   onPaymentIsRetrying,
   onOrderIsProcessing,
   onOrderIsCompleted,
+  onPaymentIsCapturing,
+  onPaymentCaptureRetrying,
+  onPaymentCaptureUnconfirmed,
   onOrderProcessFailed,
   onPaymentProcessFailed,
   onCompleted,
@@ -35,7 +44,10 @@ async function listenToProcessingState({
       window.parent.postMessage(messageCode, "*");
     }
 
-    let orderCompleted = orderState === "complete";
+    // A pre-auth order completes on the hold, before the money is captured, so it isn't a success yet:
+    // the server sends these capture codes until PaymentCapturerJob reports order_is_completed.
+    let orderCompleted =
+      orderState === "complete" && !CAPTURE_PENDING_CODES.includes(messageCode);
     if (orderCompleted) {
       queueProcessor.queueStateChange({
         minDelayInMs: 1500,
@@ -108,6 +120,49 @@ async function listenToProcessingState({
           },
         });
         break;
+      case "payment_is_capturing":
+        queueProcessor.queueStateChange({
+          minDelayInMs: 1500,
+          callback: async () => {
+            // Optional: pages built before this message existed don't pass it.
+            await onPaymentIsCapturing?.(
+              orderState,
+              paymentState,
+              processing,
+              reasonCode,
+              reasonMessage,
+            );
+          },
+        });
+        break;
+      case "payment_capture_retrying":
+        queueProcessor.queueStateChange({
+          minDelayInMs: 1500,
+          callback: async () => {
+            await onPaymentCaptureRetrying?.(
+              orderState,
+              paymentState,
+              processing,
+              reasonCode,
+              reasonMessage,
+            );
+          },
+        });
+        break;
+      case "payment_capture_unconfirmed":
+        queueProcessor.queueStateChange({
+          minDelayInMs: 1500,
+          callback: async () => {
+            await onPaymentCaptureUnconfirmed?.(
+              orderState,
+              paymentState,
+              processing,
+              reasonCode,
+              reasonMessage,
+            );
+          },
+        });
+        break;
       case "order_process_failed":
         queueProcessor.queueStateChange({
           minDelayInMs: 1500,

data/app/jobs/concerns/vpago/sidekiq_retry_callbacks.rb

@@ -0,0 +1,46 @@
+module Vpago
+  # Callbacks for a job retried by Sidekiq itself. ActiveJob's `retry_on` isn't an option for a job with an
+  # `until_executed` lock: each retry is a new enqueue, which the job's own lock refuses.
+  #
+  #   after_failed_attempt Spree::Core::GatewayError, with: :notify_retrying # each failed run; the error is re-raised
+  #   after_retries_exhausted with: :notify_gave_up                          # once Sidekiq stops retrying
+  #
+  # Handlers are private instance methods that read the job's `arguments`. A handler error is logged and never
+  # replaces the job's own error, so Sidekiq still retries on the original failure.
+  module SidekiqRetryCallbacks
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def after_failed_attempt(*errors, with:)
+        around_perform do |job, block|
+          block.call
+        rescue *errors => e
+          job.send(:run_retry_callback, with)
+          raise e
+        end
+      end
+
+      # Sidekiq-only, so a no-op where the host app doesn't run Sidekiq (e.g. this gem's specs). Sidekiq passes
+      # its own payload, which wraps the serialized ActiveJob.
+      def after_retries_exhausted(with:)
+        return unless respond_to?(:sidekiq_retries_exhausted)
+
+        sidekiq_retries_exhausted do |sidekiq_job, _error|
+          serialized_job = sidekiq_job['args'].first
+          new(*ActiveJob::Arguments.deserialize(serialized_job['arguments'])).send(:run_retry_callback, with)
+        end
+      end
+    end
+
+    private
+
+    def run_retry_callback(method_name)
+      send(method_name)
+    rescue StandardError => e
+      VpagoLogger.error(
+        label: "#{self.class.name}##{method_name} failed",
+        data: { arguments: arguments, error_class: e.class.name, error_message: e.message }
+      )
+    end
+  end
+end

data/app/jobs/vpago/payment_capturer_job.rb

@@ -1,11 +1,60 @@
 # Put :payment_processing at a higher priority in your project: config/sidekiq.yml
 module Vpago
   class PaymentCapturerJob < ::ApplicationUniqueJob
+    include Vpago::SidekiqRetryCallbacks
+
     queue_as :payment_processing
 
+    # A failed capture raises, so Sidekiq retries it. Pinned here rather than left to the host app's
+    # max_retries, because the count sets how long the processing page says "taking a little longer"
+    # before "not confirmed": 5 retries run for ~8 minutes with Sidekiq's default backoff.
+    sidekiq_options retry: 5 if respond_to?(:sidekiq_options)
+
+    # The default 1-day lock outlives a job that exhausted its retries and would silently refuse every
+    # re-enqueue for this payment (ABA pushback, a repair run) until the next day; 30 minutes covers the
+    # retry window above. The host app's ApplicationUniqueJob provides `unique`, spree_vpago doesn't.
+    unique :until_executed, lock_ttl: 30.minutes, on_conflict: :log if respond_to?(:unique)
+
+    # Keeps the processing page honest while Sidekiq retries a pre-auth capture.
+    after_failed_attempt Spree::Core::GatewayError, with: :notify_capture_retrying
+    after_retries_exhausted with: :give_up_capture
+
     def perform(payment_id)
-      payment = Spree::Payment.find(payment_id)
+      @payment = Spree::Payment.find(payment_id)
       payment.capture! if payment.actions.include?('capture')
+
+      # The processing page holds a pre-auth payment on "verifying" until this message arrives (see
+      # PaymentProcessor#notify_order_completed). Keyed on the result rather than on this run's capture,
+      # so a retry after a failed Firestore write still sends it.
+      payment.user_informer.order_is_completed(processing: false) if payment.payment_method.enable_pre_auth? && payment.completed?
+    end
+
+    private
+
+    def notify_capture_retrying
+      return unless payment&.awaiting_pre_auth_capture?
+
+      payment.user_informer.payment_capture_retrying(processing: true)
+    end
+
+    # Frees the lock now rather than at its TTL, so the page's reload (or ABA pushback) can start a new
+    # capture straight away. Released after the page is told, so a reload racing this can't have its
+    # "verifying" overwritten by "not confirmed".
+    def give_up_capture
+      notify_capture_unconfirmed
+    ensure
+      self.class.unlock!(*arguments) if self.class.respond_to?(:unlock!)
+    end
+
+    # Skipped when the capture itself succeeded and only the later Firestore write kept failing.
+    def notify_capture_unconfirmed
+      return unless payment&.awaiting_pre_auth_capture?
+
+      payment.user_informer.payment_capture_unconfirmed(processing: false)
+    end
+
+    def payment
+      @payment ||= Spree::Payment.find_by(id: arguments.first)
     end
   end
 end

data/app/models/vpago/payment_decorator.rb

@@ -12,6 +12,8 @@
 #
 # This allows process! or capture! to be retried by Sidekiq or by admin via /fire after connection errors
 # or other transient gateway failures.
+#
+# Pre-auth capture! is the exception: it never leaves `pending` on failure, see #pre_auth_capture!.
 module Vpago
   module PaymentDecorator
     def self.prepended(base)
@@ -55,6 +57,8 @@ module Vpago
 
     # override
     def capture!(amount = nil)
+      return pre_auth_capture!(amount) if payment_method&.enable_pre_auth?
+
       reset_for_retry! if failed?
 
       super
@@ -97,6 +101,12 @@ module Vpago
       pre_auth_status == 'CANCELLED'
     end
 
+    # Authorized (ABA holds the money) but not captured yet: the order may already be complete,
+    # yet nothing has been charged.
+    def awaiting_pre_auth_capture?
+      payment_method.enable_pre_auth? && (pending? || processing?)
+    end
+
     def true_money_payment?
       payment_method.type_true_money?
     end
@@ -124,6 +134,42 @@ module Vpago
     def can_redirect_to_app?
       payment_method.can_redirect_to_app?
     end
+
+    private
+
+    # Spree's capture! moves the payment to processing and, when the gateway fails, to failed.
+    # For a pre-auth payment that is wrong: ABA still holds the money, and `failed` hides the
+    # capture/void actions (VpagoPaymentSource requires `pending`), so PaymentCapturerJob's
+    # Sidekiq retries found nothing to do and the capture was attempted only once.
+    #
+    # Here only a confirmed capture changes the state (pending -> completed). A failed attempt
+    # writes nothing, so the payment stays retryable and a slow failing call can't overwrite a
+    # concurrent success. The capture event is also written only when money actually moved
+    # (Spree writes it before knowing the result).
+    def pre_auth_capture!(amount)
+      return true if completed?
+
+      # A `failed` pre-auth payment was left by the old flow; its hold may or may not still be
+      # active, so it must be checked with ABA and repaired before capturing again.
+      gateway_error("Cannot capture pre-auth payment #{number} in state #{state}") unless pending? || processing?
+
+      amount ||= money.amount_in_cents
+      response = begin
+        payment_method.capture(amount, response_code, gateway_options)
+      rescue ActiveMerchant::ConnectionError, Faraday::Error => e
+        # Spree logs nothing for a connection error; record it so the payment's log shows every attempt.
+        record_response(ActiveMerchant::Billing::Response.new(false, "Payway Gateway: #{e.class}: #{e.message}", {}))
+        gateway_error(ActiveMerchant::ConnectionError.new(e.message, e))
+      end
+
+      record_response(response)
+      gateway_error(response) unless response.success?
+
+      capture_events.create!(amount: ::Money.new(amount, currency).to_f)
+      split_uncaptured_amount
+      self.response_code = response.authorization if response.authorization.present?
+      complete!
+    end
   end
 end
 

data/app/services/vpago/payment_processor.rb

@@ -49,7 +49,9 @@ module Vpago
     # which will enqueue a capture payment if available.
     def process_order!
       log_process('process_order!') do
-        user_informer.order_is_processing(processing: true)
+        # On a re-run for a completed pre-auth order (ABA pushback, page reload) this message would carry
+        # order_state=complete, which the processing page treats as success before the money is captured.
+        user_informer.order_is_processing(processing: true) unless awaiting_pre_auth_capture?
         completer = Spree::Checkout::Complete.new.call(order: @payment.order)
 
         if completer.success?
@@ -63,11 +65,27 @@ module Vpago
 
     def handle_order_process_completed
       log_process('handle_order_process_completed') do
+        # Notify before enqueueing: PaymentCapturerJob reports order_is_completed when the capture lands,
+        # and that message must not be overwritten by a later payment_is_capturing.
+        notify_order_completed
         enqueue_capture_payment_if_available!
+      end
+    end
+
+    # A pre-auth order completes on the hold, but the money only moves at capture, so the processing
+    # page keeps showing "verifying" until PaymentCapturerJob sends order_is_completed.
+    def notify_order_completed
+      if awaiting_pre_auth_capture?
+        user_informer.payment_is_capturing(processing: true)
+      else
         user_informer.order_is_completed(processing: false)
       end
     end
 
+    def awaiting_pre_auth_capture?
+      @payment.reload.awaiting_pre_auth_capture? && @payment.order.complete?
+    end
+
     def handle_order_process_failure(reason_code, reason_message = nil)
       log_process('handle_order_process_failure', reason_code, reason_message) do
         user_informer.order_process_failed(

data/app/services/vpago/user_informers/firebase.rb

@@ -13,6 +13,9 @@ module Vpago
       def payment_is_retrying(processing:) = notify(:payment_is_retrying, processing)
       def order_is_processing(processing:) = notify(:order_is_processing, processing)
       def order_is_completed(processing:) = notify(:order_is_completed, processing)
+      def payment_is_capturing(processing:) = notify(:payment_is_capturing, processing)
+      def payment_capture_retrying(processing:) = notify(:payment_capture_retrying, processing)
+      def payment_capture_unconfirmed(processing:) = notify(:payment_capture_unconfirmed, processing)
       def order_process_failed(processing:, reason_code:, reason_message: nil) = notify(:order_process_failed, processing, reason_code, reason_message)
       def payment_process_failed(processing:, reason_code:, reason_message: nil) = notify(:payment_process_failed, processing, reason_code, reason_message)
 

data/lib/spree_vpago/version.rb

@@ -1,7 +1,7 @@
 module SpreeVpago
   module_function
 
-  VERSION = '2.4.2'.freeze
+  VERSION = '2.4.3'.freeze
 
   def version
     Gem::Version.new VERSION

data/lib/vpago/payway_v2/pre_auth_canceler.rb

@@ -5,11 +5,7 @@ module Vpago
     class PreAuthCanceler < PreAuthCompleter
       # override
       def pre_auth_response
-        conn = Faraday::Connection.new do |faraday|
-          faraday.request :url_encoded
-        end
-
-        conn.post(cancel_url, request_data)
+        connection.post(cancel_url, request_data)
       end
 
       def request_data

data/lib/vpago/payway_v2/pre_auth_completer.rb

@@ -18,11 +18,17 @@ module Vpago
       end
 
       def pre_auth_response
-        conn = Faraday::Connection.new do |faraday|
+        connection.post(complete_url, request_data)
+      end
+
+      # Without timeouts Net::HTTP waits up to 60s to connect and 60s to read, holding the
+      # payment_processing worker thread that also completes every other customer's checkout.
+      def connection
+        Faraday::Connection.new do |faraday|
           faraday.request :url_encoded
+          faraday.options.open_timeout = Vpago::HttpTimeouts::OPEN_TIMEOUT
+          faraday.options.timeout = Vpago::HttpTimeouts::TIMEOUT
         end
-
-        conn.post(complete_url, request_data)
       end
 
       def request_data
@@ -61,8 +67,11 @@ module Vpago
         "#{host}/api/merchant-portal/merchant-access/online-transaction/pre-auth-completion"
       end
 
+      # A non-JSON body (e.g. an HTML 502 page) must be a normal failure. Raising here would skip
+      # Spree's failure handling and leave the payment without any log entry.
       def success?
-        json_response['status']['code'] == '00'
+        status = json_response.is_a?(Hash) ? json_response['status'] : nil
+        status.is_a?(Hash) && status['code'].to_s == '00'
       end
 
       def json_response
@@ -71,7 +80,8 @@ module Vpago
         @json_response ||= begin
           JSON.parse(@response.body)
         rescue JSON::ParserError
-          {}
+          # Kept so the payment's log entry shows what the gateway actually returned.
+          { 'raw_body' => @response.body.to_s[0, 2000], 'http_status' => @response.status }
         end
       end
     end