usage_credits 0.1.1 → 0.2.0

data/lib/usage_credits/models/concerns/pay_charge_extension.rb

@@ -2,6 +2,10 @@
 
 module UsageCredits
   # Extends Pay::Charge with credit pack functionality
+  #
+  # This extension integrates with the Pay gem (https://github.com/pay-rails/pay)
+  # to automatically fulfill credit packs when charges succeed and handle refunds
+  # when charges are refunded.
   module PayChargeExtension
     extend ActiveSupport::Concern
 
@@ -20,14 +24,18 @@ module UsageCredits
       case type
       when "Pay::Stripe::Charge"
         status = data["status"] || data[:status]
+        # Explicitly check for failure states
+        return false if status == "failed"
+        return false if status == "pending"
+        return false if status == "canceled"
         return true if status == "succeeded"
-        return true if data["amount_captured"].to_i == amount.to_i
+        # Fallback: check if amount was actually captured
+        return data["amount_captured"].to_i == amount.to_i && amount.to_i.positive?
       end
 
-      # Are Pay::Charge objects guaranteed to be created only after a successful payment?
-      # Is the existence of a Pay::Charge object in the database a guarantee that the payment went through?
-      # I'm implementing this `succeeded?` method just out of precaution
-      # TODO: Implement for more payment processors? Or just drop this method if it's unnecessary
+      # For non-Stripe charges, we assume Pay only creates charges after successful payment
+      # This is a reasonable assumption based on Pay gem's behavior
+      # TODO: Implement for more payment processors if needed
       true
     end
 
@@ -39,10 +47,14 @@ module UsageCredits
     private
 
     # Returns true if the charge has a valid credit wallet to operate on
+    # NOTE: We use original_credit_wallet to avoid auto-creating a wallet via ensure_credit_wallet
     def has_valid_wallet?
       return false unless customer&.owner&.respond_to?(:credit_wallet)
-      return false unless customer.owner.credit_wallet.present?
-      true
+      # Check for existing wallet without triggering auto-creation
+      if customer.owner.respond_to?(:original_credit_wallet)
+        return customer.owner.original_credit_wallet.present?
+      end
+      customer.owner.credit_wallet.present?
     end
 
     def credit_wallet
@@ -124,7 +136,8 @@ module UsageCredits
       end
 
       begin
-        # Wrap credit addition in a transaction for atomicity
+        # Wrap in transaction to ensure atomicity - if Fulfillment.create! fails,
+        # the credits should NOT be added. This is critical for money handling.
         ActiveRecord::Base.transaction do
           # Add credits to the user's wallet
           credit_wallet.add_credits(
@@ -163,39 +176,64 @@ module UsageCredits
       end
     end
 
-    def credits_already_refunded?
-      # Check if refund was already processed with credits deducted by looking for a refund transaction
-      # Look up transactions for a refund.
+    # Returns the total credits already refunded for this charge
+    # Note: NOT memoized because refunds can happen incrementally within the same request
+    def credits_previously_refunded
       transactions = credit_wallet&.transactions&.where(category: "credit_pack_refund")
-      return false unless transactions.present?
+      return 0 unless transactions.present?
 
+      # Try database-level filtering first (more efficient)
       begin
         adapter = ActiveRecord::Base.connection.adapter_name.downcase
         if adapter.include?("postgres")
-          transactions.exists?(['metadata @> ?', { refunded_purchase_charge_id: id, credits_refunded: true }.to_json])
+          # PostgreSQL supports the @> JSON containment operator
+          filtered = transactions.where(
+            "metadata @> ?",
+            { refunded_purchase_charge_id: id, credits_refunded: true }.to_json
+          )
+          return filtered.sum { |tx| -tx.amount }
         else
-          transactions.exists?(["json_extract(metadata, '$.refunded_purchase_charge_id') = ? AND json_extract(metadata, '$.credits_refunded') = ?", id, true])
+          # SQLite/MySQL with JSON_EXTRACT
+          filtered = transactions.where(
+            "json_extract(metadata, '$.refunded_purchase_charge_id') = ? AND json_extract(metadata, '$.credits_refunded') = ?",
+            id, true
+          )
+          return filtered.sum { |tx| -tx.amount }
         end
-      rescue ActiveRecord::StatementInvalid
-        transactions.any? do |tx|
-          data =
-            if tx.metadata.is_a?(Hash)
-              tx.metadata
-            else
-              JSON.parse(tx.metadata) rescue {}
-            end
-          data["refunded_purchase_charge_id"].to_i == id.to_i && data["credits_refunded"].to_s == "true"
+      rescue ActiveRecord::StatementInvalid => e
+        Rails.logger.warn "JSON query failed, falling back to Ruby filtering: #{e.message}"
+      end
+
+      # Fallback: filter in Ruby (for databases without JSON support)
+      # Sum in a single pass to avoid multiple iterations
+      transactions.sum do |tx|
+        data = tx.metadata.is_a?(Hash) ? tx.metadata : (JSON.parse(tx.metadata) rescue {})
+        if data["refunded_purchase_charge_id"].to_i == id.to_i && data["credits_refunded"].to_s == "true"
+          -tx.amount
+        else
+          0
         end
       end
     end
 
+    def credits_already_refunded?
+      # Check if any refund was already processed for this charge
+      credits_previously_refunded > 0
+    end
+
+    def fully_refunded?
+      # Check if a full refund (100%) has already been processed
+      pack = UsageCredits.find_pack(pack_identifier&.to_sym)
+      return false unless pack
+      credits_previously_refunded >= pack.total_credits
+    end
+
     def handle_refund!
       # Guard clauses for required data and state
       return unless refunded?
       return unless pack_identifier
       return unless has_valid_wallet?
       return unless amount.is_a?(Numeric) && amount.positive?
-      return if credits_already_refunded?
 
       pack_name = pack_identifier.to_sym
       pack = UsageCredits.find_pack(pack_name)
@@ -211,29 +249,39 @@ module UsageCredits
         return
       end
 
-      # Calculate refund ratio and credits to remove
-      # Always use ceil for credit calculations to avoid giving more credits than paid for
+      # Calculate total credits that SHOULD be refunded based on current refund amount
       refund_ratio = amount_refunded.to_f / amount.to_f
-      credits_to_remove = (pack.total_credits * refund_ratio).ceil
+      total_credits_to_refund = (pack.total_credits * refund_ratio).ceil
 
-      begin
-        Rails.logger.info "Processing refund for charge #{id}: #{credits_to_remove} credits (#{(refund_ratio * 100).round(2)}% of #{pack.total_credits})"
+      # Calculate credits already refunded (for incremental/partial refunds)
+      already_refunded = credits_previously_refunded
 
-        # Wrap credit deduction in a transaction for atomicity
-        ActiveRecord::Base.transaction do
-          credit_wallet.deduct_credits(
-            credits_to_remove,
-            category: "credit_pack_refund",
-            metadata: {
-              refunded_purchase_charge_id: id,
-              credits_refunded: true,
-              refunded_at: Time.current,
-              refund_percentage: refund_ratio,
-              refund_amount_cents: amount_refunded,
-              **pack.base_metadata
-            }
-          )
-        end
+      # Only deduct the INCREMENTAL amount (difference between what should be refunded and what's already refunded)
+      credits_to_remove = total_credits_to_refund - already_refunded
+
+      # Skip if nothing new to refund
+      if credits_to_remove <= 0
+        Rails.logger.info "Refund for charge #{id} already processed (#{already_refunded} credits already refunded)"
+        return
+      end
+
+      begin
+        Rails.logger.info "Processing refund for charge #{id}: #{credits_to_remove} credits (incremental from #{already_refunded} to #{total_credits_to_refund})"
+
+        credit_wallet.deduct_credits(
+          credits_to_remove,
+          category: "credit_pack_refund",
+          metadata: {
+            refunded_purchase_charge_id: id,
+            credits_refunded: true,
+            refunded_at: Time.current,
+            refund_percentage: refund_ratio,
+            refund_amount_cents: amount_refunded,
+            incremental_credits: credits_to_remove,
+            total_credits_refunded: total_credits_to_refund,
+            **pack.base_metadata
+          }
+        )
 
         Rails.logger.info "Successfully processed refund for charge #{id}"
       rescue UsageCredits::InsufficientCredits => e