misc: Refactor Customer::UpdateService

app/graphql/mutations/customers/update.rb

@@ -21,7 +21,8 @@ class Update < BaseMutation
       type Types::Customers::Object
 
       def resolve(**args)
-        result = ::Customers::UpdateService.new(context[:current_user]).update(**args)
+        customer = context[:current_user].customers.find_by(id: args[:id])
+        result = ::Customers::UpdateService.call(customer:, args:)
 
         result.success? ? result.customer : result_error(result)
       end

app/graphql/mutations/customers/update_invoice_grace_period.rb

@@ -18,7 +18,8 @@ class UpdateInvoiceGracePeriod < BaseMutation
       type Types::Customers::Object
 
       def resolve(id:, invoice_grace_period:)
-        result = ::Customers::UpdateService.new(context[:current_user]).update(id:, invoice_grace_period:)
+        customer = context[:current_user].customers.find_by(id:)
+        result = ::Customers::UpdateService.call(customer:, args: {invoice_grace_period:})
 
         result.success? ? result.customer : result_error(result)
       end

app/services/applied_coupons/create_service.rb

@@ -27,11 +27,9 @@ def call
 
       if coupon.fixed_amount?
         ActiveRecord::Base.transaction do
-          currency_result = Customers::UpdateService.new(nil).update_currency(
-            customer:,
-            currency: params[:amount_currency] || coupon.amount_currency
-          )
-          currency_result.raise_if_error!
+          Customers::UpdateCurrencyService
+            .call(customer:, currency: params[:amount_currency] || coupon.amount_currency)
+            .raise_if_error!
 
           applied_coupon.save!
         end

app/services/customers/create_service.rb

@@ -63,12 +63,9 @@ def create_from_api(organization:, params:)
         assign_premium_attributes(customer, params)
 
         if params.key?(:currency)
-          currency_result = Customers::UpdateService.new(nil).update_currency(
-            customer:,
-            currency: params[:currency],
-            customer_update: true
-          )
-          currency_result.raise_if_error!
+          Customers::UpdateCurrencyService
+            .call(customer:, currency: params[:currency], customer_update: true)
+            .raise_if_error!
         end
 
         customer.save!

app/services/customers/update_currency_service.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Customers
+  class UpdateCurrencyService < BaseService
+    def initialize(customer:, currency:, customer_update: false)
+      @customer = customer
+      @currency = currency
+      @customer_update = customer_update
+
+      super
+    end
+
+    def call
+      return result.not_found_failure!(resource: "customer") unless customer
+      return result if customer.currency == currency
+
+      if customer_update
+        # NOTE: direct update of the customer currency
+        unless customer.editable?
+          return result.single_validation_failure!(
+            field: :currency,
+            error_code: "currencies_does_not_match"
+          )
+        end
+      elsif customer.currency.present? || !customer.editable?
+        # NOTE: Assign currency from another resource
+        return result.single_validation_failure!(
+          field: :currency,
+          error_code: "currencies_does_not_match"
+        )
+      end
+
+      customer.update!(currency:)
+      result
+    rescue ActiveRecord::RecordInvalid => e
+      result.record_validation_failure!(record: e.record)
+    end
+
+    private
+
+    attr_reader :customer, :currency, :customer_update
+  end
+end

app/services/customers/update_service.rb

@@ -4,8 +4,14 @@ module Customers
   class UpdateService < BaseService
     include Customers::PaymentProviderFinder
 
-    def update(**args)
-      customer = result.user.customers.find_by(id: args[:id])
+    def initialize(customer:, args:)
+      @customer = customer
+      @args = args
+
+      super
+    end
+
+    def call
       return result.not_found_failure!(resource: 'customer') unless customer
 
       unless valid_metadata_count?(metadata: args[:metadata])
@@ -22,8 +28,9 @@ def update(**args)
         shipping_address = args[:shipping_address]&.to_h || {}
 
         if args.key?(:currency)
-          update_currency(customer:, currency: args[:currency], customer_update: true)
-          result.raise_if_error!
+          Customers::UpdateCurrencyService
+            .call(customer:, currency: args[:currency], customer_update: true)
+            .raise_if_error!
         end
 
         customer.name = args[:name] if args.key?(:name)
@@ -94,7 +101,7 @@ def update(**args)
         end
 
         customer.save!
-        customer = customer.reload
+        customer.reload
 
         if customer.organization.eu_tax_management
           eu_tax_code = Customers::EuAutoTaxesService.call(customer:)
@@ -136,33 +143,10 @@ def update(**args)
       e.result
     end
 
-    def update_currency(customer:, currency:, customer_update: false)
-      return result if customer.currency == currency
-
-      if customer_update
-        # NOTE: direct update of the customer currency
-        unless customer.editable?
-          return result.single_validation_failure!(
-            field: :currency,
-            error_code: 'currencies_does_not_match'
-          )
-        end
-      elsif customer.currency.present? || !customer.editable?
-        # NOTE: Assign currency from another resource
-        return result.single_validation_failure!(
-          field: :currency,
-          error_code: 'currencies_does_not_match'
-        )
-      end
-
-      customer.update!(currency:)
-      result
-    rescue ActiveRecord::RecordInvalid => e
-      result.record_validation_failure!(record: e.record)
-    end
-
     private
 
+    attr_reader :customer, :args
+
     def valid_metadata_count?(metadata:)
       return true if metadata.blank?
       return true if metadata.count <= ::Metadata::CustomerMetadata::COUNT_PER_CUSTOMER

app/services/invoices/create_one_off_service.rb

@@ -17,8 +17,9 @@ def call
       return result.not_found_failure!(resource: 'add_on') unless add_ons.count == add_on_identifiers.count
 
       ActiveRecord::Base.transaction do
-        currency_result = Customers::UpdateService.new(nil).update_currency(customer:, currency:)
-        currency_result.raise_if_error!
+        Customers::UpdateCurrencyService
+          .call(customer:, currency:)
+          .raise_if_error!
 
         create_generating_invoice
 

app/services/subscriptions/create_service.rb

@@ -34,11 +34,9 @@ def call
       customer.save! if api_context?
 
       ActiveRecord::Base.transaction do
-        currency_result = Customers::UpdateService.new(nil).update_currency(
-          customer:,
-          currency: plan.amount_currency
-        )
-        currency_result.raise_if_error!
+        Customers::UpdateCurrencyService
+          .call(customer:, currency: plan.amount_currency)
+          .raise_if_error!
 
         result.subscription = handle_subscription
       end

app/services/wallets/create_service.rb

@@ -25,11 +25,9 @@ def call
       wallet = Wallet.new(attributes)
 
       ActiveRecord::Base.transaction do
-        currency_result = Customers::UpdateService.new(nil).update_currency(
-          customer: result.current_customer,
-          currency: params[:currency]
-        )
-        currency_result.raise_if_error!
+        Customers::UpdateCurrencyService
+          .call(customer: result.current_customer, currency: params[:currency])
+          .raise_if_error!
 
         wallet.currency = wallet.customer.currency
         wallet.save!

spec/services/customers/update_currency_service_spec.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Customers::UpdateCurrencyService do
+  subject(:currency_service) { described_class.new(customer:, currency:, customer_update:) }
+
+  let(:customer) { create(:customer, currency: nil) }
+  let(:currency) { "USD" }
+  let(:customer_update) { false }
+
+  describe "#call" do
+    it 'assigns the currency to the customer' do
+      result = currency_service.call
+
+      expect(result).to be_success
+      expect(customer.reload.currency).to eq(currency)
+    end
+
+    context "when customer is not found" do
+      let(:customer) { nil }
+
+      it "returns a failure" do
+        result = currency_service.call
+
+        expect(result).not_to be_success
+        expect(result.error).to be_a(BaseService::NotFoundFailure)
+        expect(result.error.resource).to eq("customer")
+      end
+    end
+
+    context "when customer currency is the same as the provided one" do
+      let(:customer) { create(:customer, currency: 'EUR') }
+      let(:currency) { customer.currency }
+
+      it "returns a success" do
+        expect(currency_service.call).to be_success
+
+        expect(customer.reload.currency).to eq(currency)
+      end
+    end
+
+    context 'when customer already has a currency' do
+      let(:customer) { create(:customer, currency: 'EUR') }
+
+      it 'returns a failure' do
+        result = currency_service.call
+
+        expect(result).not_to be_success
+        expect(result.error).to be_a(BaseService::ValidationFailure)
+        expect(result.error.messages[:currency]).to eq(["currencies_does_not_match"])
+      end
+
+      context 'when in customer update' do
+        let(:customer_update) { true }
+
+        it 'assigns the currency to the customer' do
+          result = currency_service.call
+
+          expect(result).to be_success
+          expect(customer.reload.currency).to eq(currency)
+        end
+
+        context 'when customer is not editable' do
+          before { create(:subscription, customer:) }
+
+          it 'returns a failure' do
+            result = currency_service.call
+
+            expect(result).not_to be_success
+            expect(result.error).to be_a(BaseService::ValidationFailure)
+            expect(result.error.messages[:currency]).to eq(["currencies_does_not_match"])
+          end
+        end
+      end
+    end
+
+    context 'when customer is not editable' do
+      before { create(:subscription, customer:) }
+
+      it 'returns a failure' do
+        result = currency_service.call
+
+        expect(result).not_to be_success
+        expect(result.error).to be_a(BaseService::ValidationFailure)
+        expect(result.error.messages[:currency]).to eq(["currencies_does_not_match"])
+      end
+    end
+
+    context 'when providing an invalid currency' do
+      let(:currency) { "INVALID" }
+
+      it 'returns a failure' do
+        result = currency_service.call
+
+        expect(result).not_to be_success
+        expect(result.error).to be_a(BaseService::ValidationFailure)
+        expect(result.error.messages[:currency]).to eq(["value_is_invalid"])
+      end
+    end
+  end
+end