lago-ruby-client 1.40.0 → 1.43.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37c60d46c38643113860ccaa8eea0beb2e9ff735c84c494575458729ba4e1340
-  data.tar.gz: 17259c33488215f546afb8d5a0fd4541a67a3812486233a417223d1e484a6a6c
+  metadata.gz: 1cd4e9ed7d1b0f3eac5940fb37ea3b7b2616ceda00c5e3e4e42e0e80b0d0b3ba
+  data.tar.gz: 761ed874e1fb31e466ae0a5309132853ded262940f0504fcb6dc827a3af05c87
 SHA512:
-  metadata.gz: c85b6545df50a21700f6392ee592944cc873961c9ecb7b553c0447b26a40de6697c634f14a0a2e1cfabd3ade4e76026bf1c14c32ead3de3e02e55fc6ce9ef13c
-  data.tar.gz: a36624870091a68b739c7e112a7c8be41bb79b36a51800fae1b06c17c0bb73145451785c99f5bc40e97b75fb3a6a46d1136b12b645dea782110ee6dbdd297716
+  metadata.gz: 21a3cb1cd0b107edb3ac23e4a08738dd4c9f6ae96a8dee6ed07267a72b48cafdeb5d580afc631519961974c761dc44da151358ad9e3951f88c8a8f42e57f7c65
+  data.tar.gz: 87d47fc5d9f9039ca63975f697b30f1300314bc2448967e180944c1e68c0fc8576f8ddef53055e8c092cd0f28581fad43640ffeac638f3dcc3c6ca2f79f8d13d

data/lib/lago/api/client.rb

@@ -15,6 +15,7 @@ require 'lago/api/resources/customers/applied_coupon'
 require 'lago/api/resources/customers/credit_note'
 require 'lago/api/resources/customers/invoice'
 require 'lago/api/resources/customers/payment'
+require 'lago/api/resources/customers/payment_method'
 require 'lago/api/resources/customers/payment_request'
 require 'lago/api/resources/customers/subscription'
 require 'lago/api/resources/customers/wallet'
@@ -122,6 +123,10 @@ module Lago
         Resources::Customers::Payment.new(self, resource_id)
       end
 
+      def customer_payment_methods(resource_id)
+        Resources::Customers::PaymentMethod.new(self, resource_id)
+      end
+
       def customer_payment_requests(resource_id)
         Resources::Customers::PaymentRequest.new(self, resource_id)
       end

data/lib/lago/api/resources/customers/payment_method.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'lago/api/resources/customers/base'
+
+module Lago
+  module Api
+    module Resources
+      module Customers
+        class PaymentMethod < Base
+          def api_resource
+            "#{base_api_resource}/payment_methods"
+          end
+
+          def root_name
+            'payment_method'
+          end
+
+          def destroy(id, options: nil)
+            response = connection.destroy(identifier: id, options:)[root_name]
+
+            JSON.parse(response.to_json, object_class: OpenStruct)
+          end
+
+          # rubocop:disable Naming/AccessorMethodName
+          def set_as_default(payment_method_id)
+            path = "/api/v1/#{api_resource}/#{payment_method_id}/set_as_default"
+            response = connection.put(path, identifier: nil, body: {})[root_name]
+
+            JSON.parse(response.to_json, object_class: OpenStruct)
+          end
+          # rubocop:enable Naming/AccessorMethodName
+        end
+      end
+    end
+  end
+end

data/lib/lago/api/resources/invoice.rb

@@ -59,9 +59,12 @@ module Lago
           JSON.parse(response.to_json, object_class: OpenStruct).invoice
         end
 
-        def retry_payment(invoice_id)
+        def retry_payment(invoice_id, params = {})
           path = "/api/v1/invoices/#{invoice_id}/retry_payment"
-          response = connection.post({}, path)
+          payment_method_params = whitelist_payment_method_params(params[:payment_method])
+          payload = { payment_method: payment_method_params }.compact
+
+          response = connection.post(payload, path)
 
           JSON.parse(response.to_json, object_class: OpenStruct)
         end
@@ -128,6 +131,9 @@ module Lago
           fees = whitelist_fees(params[:fees])
           result[:fees] = fees unless fees.empty?
 
+          payment_method_params = whitelist_payment_method_params(params[:payment_method])
+          result[:payment_method] = payment_method_params if payment_method_params.present?
+
           { root_name => result }
         end
 
@@ -161,6 +167,12 @@ module Lago
             credit_amount: params[:credit_amount]
           }.compact
         end
+
+        private
+
+        def whitelist_payment_method_params(payment_method_param)
+          payment_method_param&.slice(:payment_method_type, :payment_method_id)
+        end
       end
     end
   end

data/lib/lago/api/resources/plan.rb

@@ -54,6 +54,117 @@ module Lago
           JSON.parse(response.to_json, object_class: OpenStruct).entitlement
         end
 
+        # Charges
+        def get_all_charges(plan_code, options = {})
+          response = connection.get_all(options, charges_uri(plan_code))
+          JSON.parse(response.to_json, object_class: OpenStruct)
+        end
+
+        def get_charge(plan_code, charge_code)
+          response = connection.get(charges_uri(plan_code, charge_code), identifier: nil)
+          JSON.parse(response.to_json, object_class: OpenStruct).charge
+        end
+
+        def create_charge(plan_code, params)
+          response = connection.post(
+            whitelist_charge_params(params),
+            charges_uri(plan_code),
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).charge
+        end
+
+        def update_charge(plan_code, charge_code, params)
+          response = connection.put(
+            charges_uri(plan_code, charge_code),
+            identifier: nil,
+            body: whitelist_charge_params(params),
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).charge
+        end
+
+        def destroy_charge(plan_code, charge_code, params = {})
+          response = connection.destroy(
+            charges_uri(plan_code, charge_code),
+            identifier: nil,
+            options: params.empty? ? nil : params,
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).charge
+        end
+
+        # Fixed Charges
+        def get_all_fixed_charges(plan_code, options = {})
+          response = connection.get_all(options, fixed_charges_uri(plan_code))
+          JSON.parse(response.to_json, object_class: OpenStruct)
+        end
+
+        def get_fixed_charge(plan_code, fixed_charge_code)
+          response = connection.get(fixed_charges_uri(plan_code, fixed_charge_code), identifier: nil)
+          JSON.parse(response.to_json, object_class: OpenStruct).fixed_charge
+        end
+
+        def create_fixed_charge(plan_code, params)
+          response = connection.post(
+            whitelist_fixed_charge_params(params),
+            fixed_charges_uri(plan_code),
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).fixed_charge
+        end
+
+        def update_fixed_charge(plan_code, fixed_charge_code, params)
+          response = connection.put(
+            fixed_charges_uri(plan_code, fixed_charge_code),
+            identifier: nil,
+            body: whitelist_fixed_charge_params(params),
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).fixed_charge
+        end
+
+        def destroy_fixed_charge(plan_code, fixed_charge_code, params = {})
+          response = connection.destroy(
+            fixed_charges_uri(plan_code, fixed_charge_code),
+            identifier: nil,
+            options: params.empty? ? nil : params,
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).fixed_charge
+        end
+
+        # Charge Filters
+        def get_all_charge_filters(plan_code, charge_code, options = {})
+          response = connection.get_all(options, charge_filters_uri(plan_code, charge_code))
+          JSON.parse(response.to_json, object_class: OpenStruct)
+        end
+
+        def get_charge_filter(plan_code, charge_code, filter_id)
+          response = connection.get(charge_filters_uri(plan_code, charge_code, filter_id), identifier: nil)
+          JSON.parse(response.to_json, object_class: OpenStruct).filter
+        end
+
+        def create_charge_filter(plan_code, charge_code, params)
+          response = connection.post(
+            whitelist_charge_filter_params(params),
+            charge_filters_uri(plan_code, charge_code),
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).filter
+        end
+
+        def update_charge_filter(plan_code, charge_code, filter_id, params)
+          response = connection.put(
+            charge_filters_uri(plan_code, charge_code, filter_id),
+            identifier: nil,
+            body: whitelist_charge_filter_params(params),
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).filter
+        end
+
+        def destroy_charge_filter(plan_code, charge_code, filter_id, params = {})
+          response = connection.destroy(
+            charge_filters_uri(plan_code, charge_code, filter_id),
+            identifier: nil,
+            options: params.empty? ? nil : params,
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).filter
+        end
+
         def whitelist_params(params)
           result_hash = {
             name: params[:name],
@@ -119,6 +230,7 @@ module Lago
               :filters,
               :tax_codes,
               :applied_pricing_unit,
+              :accepts_target_wallet,
             )
 
             processed_charges << result unless result.empty?
@@ -216,6 +328,76 @@ module Lago
           url += "/#{action}" if action
           URI(url)
         end
+
+        def charges_uri(plan_code, charge_code = nil)
+          url = "#{client.base_api_url}#{api_resource}/#{plan_code}/charges"
+          url += "/#{charge_code}" if charge_code
+          URI(url)
+        end
+
+        def fixed_charges_uri(plan_code, fixed_charge_code = nil)
+          url = "#{client.base_api_url}#{api_resource}/#{plan_code}/fixed_charges"
+          url += "/#{fixed_charge_code}" if fixed_charge_code
+          URI(url)
+        end
+
+        def charge_filters_uri(plan_code, charge_code, filter_id = nil)
+          url = "#{client.base_api_url}#{api_resource}/#{plan_code}/charges/#{charge_code}/filters"
+          url += "/#{filter_id}" if filter_id
+          URI(url)
+        end
+
+        def whitelist_charge_params(params)
+          {
+            charge: (params || {}).slice(
+              :billable_metric_id,
+              :code,
+              :invoice_display_name,
+              :charge_model,
+              :pay_in_advance,
+              :prorated,
+              :invoiceable,
+              :regroup_paid_fees,
+              :min_amount_cents,
+              :accepts_target_wallet,
+              :properties,
+              :filters,
+              :tax_codes,
+              :applied_pricing_unit,
+              :cascade_updates,
+            ),
+          }
+        end
+
+        def whitelist_fixed_charge_params(params)
+          {
+            fixed_charge: (params || {}).slice(
+              :add_on_id,
+              :add_on_code,
+              :code,
+              :invoice_display_name,
+              :charge_model,
+              :pay_in_advance,
+              :prorated,
+              :units,
+              :apply_units_immediately,
+              :properties,
+              :tax_codes,
+              :cascade_updates,
+            ),
+          }
+        end
+
+        def whitelist_charge_filter_params(params)
+          {
+            filter: (params || {}).slice(
+              :invoice_display_name,
+              :properties,
+              :values,
+              :cascade_updates,
+            ),
+          }
+        end
       end
     end
   end

data/lib/lago/api/resources/subscription.rb

@@ -86,14 +86,6 @@ module Lago
           JSON.parse(response.to_json, object_class: OpenStruct).alerts
         end
 
-        def fixed_charges(external_subscription_id)
-          uri = URI(
-            "#{client.base_api_url}#{api_resource}/#{external_subscription_id}/fixed_charges",
-          )
-          response = connection.get(uri, identifier: nil)
-          JSON.parse(response.to_json, object_class: OpenStruct).fixed_charges
-        end
-
         def create_alert(external_subscription_id, params)
           response = connection.post(
             whitelist_alert_create_params(params),
@@ -102,19 +94,110 @@ module Lago
           JSON.parse(response.to_json, object_class: OpenStruct).alert
         end
 
+        def create_alerts(external_subscription_id, params)
+          response = connection.post(
+            whitelist_alert_batch_create_params(params),
+            alert_uri(external_subscription_id),
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).alerts
+        end
+
+        def delete_alerts(external_subscription_id)
+          connection.destroy(alert_uri(external_subscription_id), identifier: nil)
+        end
+
+        # Charges
+        def get_all_charges(external_id, options = {})
+          response = connection.get_all(options, charges_uri(external_id))
+          JSON.parse(response.to_json, object_class: OpenStruct)
+        end
+
+        def get_charge(external_id, charge_code)
+          response = connection.get(charges_uri(external_id, charge_code), identifier: nil)
+          JSON.parse(response.to_json, object_class: OpenStruct).charge
+        end
+
+        def update_charge(external_id, charge_code, params)
+          response = connection.put(
+            charges_uri(external_id, charge_code),
+            identifier: nil,
+            body: whitelist_subscription_charge_params(params),
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).charge
+        end
+
+        # Fixed Charges
+        def get_all_fixed_charges(external_id, options = {})
+          response = connection.get_all(options, fixed_charges_uri(external_id))
+          JSON.parse(response.to_json, object_class: OpenStruct)
+        end
+
+        def get_fixed_charge(external_id, fixed_charge_code)
+          response = connection.get(fixed_charges_uri(external_id, fixed_charge_code), identifier: nil)
+          JSON.parse(response.to_json, object_class: OpenStruct).fixed_charge
+        end
+
+        def update_fixed_charge(external_id, fixed_charge_code, params)
+          response = connection.put(
+            fixed_charges_uri(external_id, fixed_charge_code),
+            identifier: nil,
+            body: whitelist_subscription_fixed_charge_params(params),
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).fixed_charge
+        end
+
+        # Charge Filters
+        def get_all_charge_filters(external_id, charge_code, options = {})
+          response = connection.get_all(options, charge_filters_uri(external_id, charge_code))
+          JSON.parse(response.to_json, object_class: OpenStruct)
+        end
+
+        def get_charge_filter(external_id, charge_code, filter_id)
+          response = connection.get(charge_filters_uri(external_id, charge_code, filter_id), identifier: nil)
+          JSON.parse(response.to_json, object_class: OpenStruct).filter
+        end
+
+        def create_charge_filter(external_id, charge_code, params)
+          response = connection.post(
+            whitelist_subscription_charge_filter_params(params),
+            charge_filters_uri(external_id, charge_code),
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).filter
+        end
+
+        def update_charge_filter(external_id, charge_code, filter_id, params)
+          response = connection.put(
+            charge_filters_uri(external_id, charge_code, filter_id),
+            identifier: nil,
+            body: whitelist_subscription_charge_filter_params(params),
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).filter
+        end
+
+        def destroy_charge_filter(external_id, charge_code, filter_id)
+          response = connection.destroy(
+            charge_filters_uri(external_id, charge_code, filter_id),
+            identifier: nil,
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).filter
+        end
+
         def whitelist_params(params)
-          {
-            root_name => {
-              external_customer_id: params[:external_customer_id],
-              plan_code: params[:plan_code],
-              name: params[:name],
-              external_id: params[:external_id],
-              billing_time: params[:billing_time],
-              subscription_at: params[:subscription_at],
-              ending_at: params[:ending_at],
-              plan_overrides: params[:plan_overrides],
-            }.compact,
-          }
+          result = {
+            external_customer_id: params[:external_customer_id],
+            plan_code: params[:plan_code],
+            name: params[:name],
+            external_id: params[:external_id],
+            billing_time: params[:billing_time],
+            subscription_at: params[:subscription_at],
+            ending_at: params[:ending_at],
+            plan_overrides: params[:plan_overrides],
+          }.compact
+
+          payment_method_params = whitelist_payment_method_params(params[:payment_method])
+          result[:payment_method] = payment_method_params if payment_method_params.present?
+
+          { root_name => result }
         end
 
         def whitelist_lifetime_usage_params(params)
@@ -137,6 +220,20 @@ module Lago
           }
         end
 
+        def whitelist_alert_batch_create_params(params)
+          {
+            alerts: (params[:alerts] || []).map do |alert|
+              {
+                alert_type: alert[:alert_type],
+                name: alert[:name],
+                code: alert[:code],
+                billable_metric_code: alert[:billable_metric_code],
+                thresholds: alert[:thresholds],
+              }.compact
+            end,
+          }
+        end
+
         def whitelist_alert_update_params(params)
           {
             alert: {
@@ -162,6 +259,10 @@ module Lago
 
         private
 
+        def whitelist_payment_method_params(payment_method_param)
+          payment_method_param&.slice(:payment_method_type, :payment_method_id)
+        end
+
         def entitlements_uri(external_subscription_id, feature_code = nil, action = nil)
           url = "#{client.base_api_url}#{api_resource}/#{external_subscription_id}/entitlements"
           url += "/#{feature_code}" if feature_code
@@ -172,6 +273,59 @@ module Lago
         def alert_uri(external_subscription_id, code = nil)
           URI("#{client.base_api_url}#{api_resource}/#{external_subscription_id}/alerts#{code ? "/#{code}" : ''}")
         end
+
+        def charges_uri(external_id, charge_code = nil)
+          url = "#{client.base_api_url}#{api_resource}/#{external_id}/charges"
+          url += "/#{charge_code}" if charge_code
+          URI(url)
+        end
+
+        def fixed_charges_uri(external_id, fixed_charge_code = nil)
+          url = "#{client.base_api_url}#{api_resource}/#{external_id}/fixed_charges"
+          url += "/#{fixed_charge_code}" if fixed_charge_code
+          URI(url)
+        end
+
+        def charge_filters_uri(external_id, charge_code, filter_id = nil)
+          url = "#{client.base_api_url}#{api_resource}/#{external_id}/charges/#{charge_code}/filters"
+          url += "/#{filter_id}" if filter_id
+          URI(url)
+        end
+
+        def whitelist_subscription_charge_params(params)
+          {
+            charge: (params || {}).slice(
+              :invoice_display_name,
+              :min_amount_cents,
+              :properties,
+              :filters,
+              :tax_codes,
+              :applied_pricing_unit,
+            ),
+          }
+        end
+
+        def whitelist_subscription_fixed_charge_params(params)
+          {
+            fixed_charge: (params || {}).slice(
+              :invoice_display_name,
+              :units,
+              :apply_units_immediately,
+              :properties,
+              :tax_codes,
+            ),
+          }
+        end
+
+        def whitelist_subscription_charge_filter_params(params)
+          {
+            filter: (params || {}).slice(
+              :invoice_display_name,
+              :properties,
+              :values,
+            ),
+          }
+        end
       end
     end
   end

data/lib/lago/api/resources/wallet.rb

@@ -19,6 +19,7 @@ module Lago
             :external_customer_id,
             :rate_amount,
             :name,
+            :code,
             :priority,
             :paid_credits,
             :granted_credits,
@@ -41,6 +42,9 @@ module Lago
           metadata = whitelist_metadata(params[:metadata])
           result_hash[:metadata] = metadata if metadata
 
+          payment_method_params = whitelist_payment_method_params(params[:payment_method])
+          result_hash[:payment_method] = payment_method_params if payment_method_params.present?
+
           { root_name => result_hash }
         end
 
@@ -65,6 +69,9 @@ module Lago
               :ignore_paid_top_up_limits
             )
 
+            payment_method_params = whitelist_payment_method_params(r[:payment_method])
+            result[:payment_method] = payment_method_params if payment_method_params.present?
+
             processed_rules << result unless result.empty?
           end
 
@@ -108,6 +115,12 @@ module Lago
 
           response['metadata']
         end
+
+        private
+
+        def whitelist_payment_method_params(payment_method_param)
+          payment_method_param&.slice(:payment_method_type, :payment_method_id)
+        end
       end
     end
   end

data/lib/lago/api/resources/wallet_transaction.rb

@@ -29,18 +29,27 @@ module Lago
         end
 
         def whitelist_params(params)
-          {
-            'wallet_transaction' => params.compact.slice(
-              :wallet_id,
-              :name,
-              :paid_credits,
-              :granted_credits,
-              :voided_credits,
-              :invoice_requires_successful_payment,
-              :ignore_paid_top_up_limits,
-              :metadata,
-            )
-          }
+          result = params.compact.slice(
+            :wallet_id,
+            :name,
+            :paid_credits,
+            :granted_credits,
+            :voided_credits,
+            :invoice_requires_successful_payment,
+            :ignore_paid_top_up_limits,
+            :metadata,
+          )
+
+          payment_method_params = whitelist_payment_method_params(params[:payment_method])
+          result[:payment_method] = payment_method_params if payment_method_params.present?
+
+          { 'wallet_transaction' => result }
+        end
+
+        private
+
+        def whitelist_payment_method_params(payment_method_param)
+          payment_method_param&.slice(:payment_method_type, :payment_method_id)
         end
       end
     end

data/lib/lago/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lago
-  VERSION = '1.40.0'
+  VERSION = '1.43.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lago-ruby-client
 version: !ruby/object:Gem::Version
-  version: 1.40.0
+  version: 1.43.0
 platform: ruby
 authors:
 - Lovro Colic
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-26 00:00:00.000000000 Z
+date: 2026-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jwt
@@ -302,6 +302,7 @@ files:
 - lib/lago/api/resources/customers/credit_note.rb
 - lib/lago/api/resources/customers/invoice.rb
 - lib/lago/api/resources/customers/payment.rb
+- lib/lago/api/resources/customers/payment_method.rb
 - lib/lago/api/resources/customers/payment_request.rb
 - lib/lago/api/resources/customers/subscription.rb
 - lib/lago/api/resources/customers/wallet.rb