forest_admin_datasource_mambu_payments 1.33.1

data/lib/forest_admin_datasource_mambu_payments/plugins/relations/link_incoming_payment_to_transactions.rb

@@ -0,0 +1,20 @@
+module ForestAdminDatasourceMambuPayments
+  module Plugins
+    module Relations
+      # IncomingPayment <-> Transaction through the Reconciliation pivot
+      # (Reconciliation.payment_id + payment_type = incoming_payment).
+      # Install at the datasource level: @agent.use(plugin, {}).
+      class LinkIncomingPaymentToTransactions < TwoStepLinkPlugin
+        link owner: 'MambuIncomingPayment', filtered: 'MambuTransaction',
+             name: 'transactions', foreign_key: 'incoming_payment_id'
+
+        def install_source_filter(collection)
+          TwoStepReconciliationFilter.install(collection,
+                                              fk_name: 'incoming_payment_id',
+                                              payment_type: 'incoming_payment',
+                                              target_field: 'id')
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mambu_payments/plugins/relations/link_internal_account_to_balances.rb

@@ -0,0 +1,17 @@
+module ForestAdminDatasourceMambuPayments
+  module Plugins
+    module Relations
+      # InternalAccount <-> Balance, transitive via
+      # InternalAccount.connected_account_ids vs Balance.connected_account_id.
+      # Install at the datasource level: @agent.use(plugin, {}).
+      class LinkInternalAccountToBalances < TwoStepLinkPlugin
+        link owner: 'MambuInternalAccount', filtered: 'MambuBalance',
+             name: 'balances', foreign_key: 'internal_account_id'
+
+        def install_source_filter(collection)
+          TwoStepConnectedAccountFilter.install(collection, target_field: 'connected_account_id')
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mambu_payments/plugins/relations/link_internal_account_to_incoming_payments.rb

@@ -0,0 +1,13 @@
+module ForestAdminDatasourceMambuPayments
+  module Plugins
+    module Relations
+      # Reciprocal OneToMany on MambuInternalAccount for the native
+      # IncomingPayment.internal_account ManyToOne.
+      # Install at the datasource level: @agent.use(plugin, {}).
+      class LinkInternalAccountToIncomingPayments < OneToManyLinkPlugin
+        link host: 'MambuInternalAccount', to: 'MambuIncomingPayment',
+             name: 'incoming_payments', origin_key: 'internal_account_id'
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mambu_payments/plugins/relations/link_internal_account_to_payment_orders.rb

@@ -0,0 +1,17 @@
+module ForestAdminDatasourceMambuPayments
+  module Plugins
+    module Relations
+      # InternalAccount <-> PaymentOrder, transitive via
+      # InternalAccount.connected_account_ids vs PaymentOrder.connected_account_id.
+      # Install at the datasource level: @agent.use(plugin, {}).
+      class LinkInternalAccountToPaymentOrders < TwoStepLinkPlugin
+        link owner: 'MambuInternalAccount', filtered: 'MambuPaymentOrder',
+             name: 'payment_orders', foreign_key: 'internal_account_id'
+
+        def install_source_filter(collection)
+          TwoStepConnectedAccountFilter.install(collection, target_field: 'connected_account_id')
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mambu_payments/plugins/relations/link_payment_order_to_events.rb

@@ -0,0 +1,13 @@
+module ForestAdminDatasourceMambuPayments
+  module Plugins
+    module Relations
+      # OneToMany on MambuPaymentOrder over Event.related_object_id
+      # (events emitted for this payment order).
+      # Install at the datasource level: @agent.use(plugin, {}).
+      class LinkPaymentOrderToEvents < OneToManyLinkPlugin
+        link host: 'MambuPaymentOrder', to: 'MambuEvent',
+             name: 'events', origin_key: 'related_object_id'
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mambu_payments/plugins/relations/link_payment_order_to_receiving_account_holder.rb

@@ -0,0 +1,15 @@
+module ForestAdminDatasourceMambuPayments
+  module Plugins
+    module Relations
+      # PaymentOrder <-> AccountHolder of the receiving external account.
+      # Named `receiving_account_holder` to disambiguate from the originating side.
+      # Install at the datasource level: @agent.use(plugin, {}).
+      class LinkPaymentOrderToReceivingAccountHolder < HolderLinkPlugin
+        link host: 'MambuPaymentOrder', name: 'payment_orders',
+             local_fk: 'receiving_account_id', intermediate: 'MambuExternalAccount',
+             import_path: 'external_account:account_holder_id',
+             many_to_one_name: 'receiving_account_holder'
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mambu_payments/plugins/relations/link_payment_order_to_returns.rb

@@ -0,0 +1,12 @@
+module ForestAdminDatasourceMambuPayments
+  module Plugins
+    module Relations
+      # OneToMany on MambuPaymentOrder over Return.related_payment_id.
+      # Install at the datasource level: @agent.use(plugin, {}).
+      class LinkPaymentOrderToReturns < OneToManyLinkPlugin
+        link host: 'MambuPaymentOrder', to: 'MambuReturn',
+             name: 'returns', origin_key: 'related_payment_id'
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mambu_payments/plugins/relations/link_payment_order_to_transactions.rb

@@ -0,0 +1,51 @@
+module ForestAdminDatasourceMambuPayments
+  module Plugins
+    module Relations
+      # Exposes a navigable PaymentOrder <-> Transaction link.
+      # Transaction has no native payment_order_id; the relation is mediated by
+      # MambuReconciliation (Reconciliation.payment_id + payment_type discriminator).
+      # See TwoStepReconciliationFilter for the OneToMany filter rewrite.
+      #
+      # Install at the datasource level:
+      #   @agent.use(
+      #     ForestAdminDatasourceMambuPayments::Plugins::Relations::LinkPaymentOrderToTransactions,
+      #     {}
+      #   )
+      class LinkPaymentOrderToTransactions < ForestAdminDatasourceCustomizer::Plugins::Plugin
+        ComputedDefinition = ForestAdminDatasourceCustomizer::Decorators::Computed::ComputedDefinition
+
+        PAYMENT_ORDER    = 'MambuPaymentOrder'.freeze
+        TRANSACTION      = 'MambuTransaction'.freeze
+        FK_NAME          = 'payment_order_id'.freeze
+        PAYMENT_TYPE     = 'payment_order'.freeze
+        ONE_TO_MANY_NAME = 'transactions'.freeze
+
+        def run(datasource_customizer, _collection_customizer = nil, _options = {})
+          Plugins::Helpers.require_datasource!(datasource_customizer, self.class)
+
+          datasource_customizer.customize_collection(TRANSACTION) do |c|
+            # Virtual column: Transaction has no native payment_order_id.
+            # Reverse lookup would require scanning all reconciliations — kept
+            # nil per record; only EQUAL/IN filters are rewritten via the
+            # TwoStepReconciliationFilter below.
+            c.add_field(FK_NAME, ComputedDefinition.new(
+                                   column_type: 'String',
+                                   dependencies: ['id'],
+                                   values: proc { |records, _ctx| records.map { nil } }
+                                 ))
+            TwoStepReconciliationFilter.install(c,
+                                                fk_name: FK_NAME,
+                                                payment_type: PAYMENT_TYPE,
+                                                target_field: 'id')
+          end
+
+          datasource_customizer.customize_collection(PAYMENT_ORDER) do |c|
+            c.add_one_to_many_relation(ONE_TO_MANY_NAME, TRANSACTION,
+                                       origin_key: FK_NAME,
+                                       origin_key_target: 'id')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mambu_payments/plugins/relations/one_to_many_link_plugin.rb

@@ -0,0 +1,35 @@
+module ForestAdminDatasourceMambuPayments
+  module Plugins
+    module Relations
+      # Base for the "simple" reciprocal OneToMany links: the target already
+      # carries a native foreign key, so the plugin only declares the relation
+      # on the host. Subclasses configure it declaratively:
+      #
+      #   class LinkExternalAccountToIncomingPayments < OneToManyLinkPlugin
+      #     link host: 'MambuExternalAccount', to: 'MambuIncomingPayment',
+      #          name: 'incoming_payments', origin_key: 'external_account_id'
+      #   end
+      #
+      # Install at the datasource level: @agent.use(plugin, {}).
+      class OneToManyLinkPlugin < ForestAdminDatasourceCustomizer::Plugins::Plugin
+        class << self
+          attr_reader :config
+        end
+
+        def self.link(host:, to:, name:, origin_key:)
+          @config = { host: host, to: to, name: name, origin_key: origin_key }
+        end
+
+        def run(datasource_customizer, _collection_customizer = nil, _options = {})
+          Plugins::Helpers.require_datasource!(datasource_customizer, self.class)
+
+          cfg = self.class.config
+          datasource_customizer.customize_collection(cfg[:host]) do |c|
+            c.add_one_to_many_relation(cfg[:name], cfg[:to],
+                                       origin_key: cfg[:origin_key], origin_key_target: 'id')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mambu_payments/plugins/relations/pivot_resolution.rb

@@ -0,0 +1,73 @@
+module ForestAdminDatasourceMambuPayments
+  module Plugins
+    module Relations
+      # Shared machinery for the "two-step" relation filters. Forest's native
+      # OneToMany navigation emits a leaf on a virtual foreign key; these filters
+      # pre-resolve that key against an intermediate collection and rewrite the
+      # predicate as `target_field IN [resolved ids]`.
+      #
+      # Centralising it here keeps the four concrete filters in sync: the
+      # match-nothing sentinel, the EQUAL/IN normalisation, and — crucially —
+      # the *paginated* intermediate read all live in one place. A single
+      # un-paginated `list` would silently cap resolution at one API page and
+      # drop matching records for large relations.
+      module PivotResolution
+        Operators           = ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Operators
+        ConditionTreeLeaf   = ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Nodes::ConditionTreeLeaf
+        ConditionTreeBranch = ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Nodes::ConditionTreeBranch
+        Filter              = ForestAdminDatasourceToolkit::Components::Query::Filter
+        Projection          = ForestAdminDatasourceToolkit::Components::Query::Projection
+        Page                = ForestAdminDatasourceToolkit::Components::Query::Page
+
+        # All-zero UUID: guaranteed not to exist in Numeral, so the native list
+        # returns []. Expresses "match nothing" without tripping the empty-IN
+        # guard in ConditionTreeTranslator.
+        NO_MATCH_SENTINEL = '00000000-0000-0000-0000-000000000000'.freeze
+
+        # Only EQUAL/IN are rewritten — the operators Forest's OneToMany
+        # navigation actually emits.
+        SUPPORTED_OPS = [Operators::EQUAL, Operators::IN].freeze
+
+        # Upper bound on resolved ids. The host collection walks Numeral's cursor
+        # pages under the hood; we ask for one large window so it fetches them all
+        # in O(n / page) rather than re-walking per offset. A relation resolving
+        # to more than this is logged rather than silently truncated.
+        MAX_RESOLVED = 10_000
+
+        module_function
+
+        def normalize(value, operator)
+          values = operator == Operators::IN ? Array(value) : [value]
+          values.compact.reject { |v| v.to_s.empty? }.uniq
+        end
+
+        def no_match(target_field)
+          ConditionTreeLeaf.new(target_field, Operators::EQUAL, NO_MATCH_SENTINEL)
+        end
+
+        def and_branch(*leaves)
+          ConditionTreeBranch.new('And', leaves)
+        end
+
+        # Lists every row of `collection_name` matching `condition_tree` and
+        # returns the unique non-empty values of `field` (handles both scalar
+        # columns and array columns such as InternalAccount.connected_account_ids).
+        # One large-window request lets the collection's cursor pagination fetch
+        # all matching rows in a single forward walk.
+        def collect(context, collection_name, condition_tree, field)
+          rows = context.datasource.get_collection(collection_name).list(
+            Filter.new(condition_tree: condition_tree, page: Page.new(offset: 0, limit: MAX_RESOLVED)),
+            Projection.new([field])
+          )
+          if rows.size >= MAX_RESOLVED
+            ForestAdminDatasourceMambuPayments.logger.warn(
+              "[forest_admin_datasource_mambu_payments] #{collection_name} relation resolution hit the " \
+              "#{MAX_RESOLVED}-row cap on '#{field}'; results may be truncated."
+            )
+          end
+          rows.flat_map { |row| Array(row[field]) }.compact.reject { |v| v.to_s.empty? }.uniq
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mambu_payments/plugins/relations/two_step_connected_account_filter.rb

@@ -0,0 +1,38 @@
+module ForestAdminDatasourceMambuPayments
+  module Plugins
+    module Relations
+      # Two-step pre-resolution for `internal_account_id` filters on host
+      # collections that link to InternalAccount transitively via the array
+      # column `InternalAccount.connected_account_ids` (not a scalar FK).
+      # Resolves the holder ids to the set of connected_account ids, then
+      # rewrites the predicate against a real field on the host collection
+      # (`id` for ConnectedAccount, `connected_account_id` for resources
+      # scoped by connected account).
+      module TwoStepConnectedAccountFilter
+        Operators         = ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Operators
+        ConditionTreeLeaf = ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Nodes::ConditionTreeLeaf
+
+        INTERNAL_ACCOUNT = 'MambuInternalAccount'.freeze
+        ARRAY_FIELD      = 'connected_account_ids'.freeze
+        FK_NAME          = 'internal_account_id'.freeze
+
+        def self.install(collection_customizer, target_field:)
+          PivotResolution::SUPPORTED_OPS.each do |operator|
+            collection_customizer.replace_field_operator(FK_NAME, operator) do |value, context|
+              ia_ids = PivotResolution.normalize(value, operator)
+              next PivotResolution.no_match(target_field) if ia_ids.empty?
+
+              ca_ids = PivotResolution.collect(
+                context, INTERNAL_ACCOUNT,
+                ConditionTreeLeaf.new('id', Operators::IN, ia_ids), ARRAY_FIELD
+              )
+              next PivotResolution.no_match(target_field) if ca_ids.empty?
+
+              ConditionTreeLeaf.new(target_field, Operators::IN, ca_ids)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mambu_payments/plugins/relations/two_step_cross_reconciliation_filter.rb

@@ -0,0 +1,55 @@
+module ForestAdminDatasourceMambuPayments
+  module Plugins
+    module Relations
+      # Resolves "matched payment" filters that cross the Reconciliation pivot
+      # twice via the shared transaction. Used when two payment resources only
+      # know about each other through reconciliations against the same
+      # Transaction (e.g. IncomingPayment <-> ExpectedPayment).
+      #
+      # Chain (for a `matched_X_id` filter installed on host collection Y):
+      #   Reconciliation WHERE payment_id IN [x_ids]    AND payment_type = src
+      #     -> transaction_ids
+      #   Reconciliation WHERE transaction_id IN [tx_ids] AND payment_type = dst
+      #     -> y_ids
+      # The predicate is then rewritten as `target_field IN y_ids` on the host.
+      module TwoStepCrossReconciliationFilter
+        Operators         = ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Operators
+        ConditionTreeLeaf = ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Nodes::ConditionTreeLeaf
+
+        RECONCILIATION = 'MambuReconciliation'.freeze
+
+        def self.install(collection_customizer, fk_name:, src_payment_type:, dst_payment_type:, target_field:)
+          PivotResolution::SUPPORTED_OPS.each do |operator|
+            collection_customizer.replace_field_operator(fk_name, operator) do |value, context|
+              src_ids = PivotResolution.normalize(value, operator)
+              next PivotResolution.no_match(target_field) if src_ids.empty?
+
+              tx_ids = TwoStepCrossReconciliationFilter.resolve(context, 'payment_id', src_ids,
+                                                                src_payment_type, 'transaction_id')
+              next PivotResolution.no_match(target_field) if tx_ids.empty?
+
+              dst_ids = TwoStepCrossReconciliationFilter.resolve(context, 'transaction_id', tx_ids,
+                                                                 dst_payment_type, 'payment_id')
+              next PivotResolution.no_match(target_field) if dst_ids.empty?
+
+              ConditionTreeLeaf.new(target_field, Operators::IN, dst_ids)
+            end
+          end
+        end
+
+        # One hop across the reconciliation pivot: rows where `where_field IN ids`
+        # and `payment_type = type`, projected onto `select_field`.
+        def self.resolve(context, where_field, ids, payment_type, select_field)
+          PivotResolution.collect(
+            context, RECONCILIATION,
+            PivotResolution.and_branch(
+              ConditionTreeLeaf.new(where_field, Operators::IN, ids),
+              ConditionTreeLeaf.new('payment_type', Operators::EQUAL, payment_type)
+            ),
+            select_field
+          )
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mambu_payments/plugins/relations/two_step_holder_filter.rb

@@ -0,0 +1,32 @@
+module ForestAdminDatasourceMambuPayments
+  module Plugins
+    module Relations
+      # Two-step pre-resolution for `account_holder_id` filters on host
+      # collections that link to AccountHolder transitively. Default
+      # `import_field` would emit a nested leaf the native list rejects;
+      # we pre-list the intermediate collection and rewrite as
+      # `local_fk IN (ids)`.
+      module TwoStepHolderFilter
+        Operators         = ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Operators
+        ConditionTreeLeaf = ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Nodes::ConditionTreeLeaf
+
+        def self.install(collection_customizer, fk_name:, local_fk:, intermediate_collection:)
+          PivotResolution::SUPPORTED_OPS.each do |operator|
+            collection_customizer.replace_field_operator(fk_name, operator) do |value, context|
+              holder_ids = PivotResolution.normalize(value, operator)
+              next PivotResolution.no_match(local_fk) if holder_ids.empty?
+
+              fk_ids = PivotResolution.collect(
+                context, intermediate_collection,
+                ConditionTreeLeaf.new(fk_name, Operators::IN, holder_ids), 'id'
+              )
+              next PivotResolution.no_match(local_fk) if fk_ids.empty?
+
+              ConditionTreeLeaf.new(local_fk, Operators::IN, fk_ids)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mambu_payments/plugins/relations/two_step_link_plugin.rb

@@ -0,0 +1,64 @@
+module ForestAdminDatasourceMambuPayments
+  module Plugins
+    module Relations
+      # Base for relations whose foreign key is not native: the `filtered`
+      # collection gets a virtual (always-nil) FK column plus a two-step
+      # operator filter that rewrites EQUAL/IN predicates, and the `owner`
+      # collection gets the reciprocal OneToMany. Subclasses declare the shape
+      # and provide the concrete filter install:
+      #
+      #   class LinkInternalAccountToBalances < TwoStepLinkPlugin
+      #     link owner: 'MambuInternalAccount', filtered: 'MambuBalance',
+      #          name: 'balances', fk: 'internal_account_id'
+      #     def install_source_filter(collection)
+      #       TwoStepConnectedAccountFilter.install(collection, target_field: 'connected_account_id')
+      #     end
+      #   end
+      #
+      # Install at the datasource level: @agent.use(plugin, {}).
+      class TwoStepLinkPlugin < ForestAdminDatasourceCustomizer::Plugins::Plugin
+        ComputedDefinition = ForestAdminDatasourceCustomizer::Decorators::Computed::ComputedDefinition
+
+        class << self
+          attr_reader :config
+        end
+
+        def self.link(owner:, filtered:, name:, foreign_key:)
+          @config = { owner: owner, filtered: filtered, name: name, fk: foreign_key }
+        end
+
+        # The virtual FK is nil per record: a reverse lookup would require
+        # scanning the pivot/intermediate collection. Only EQUAL/IN filters are
+        # meaningful, and those are rewritten by the source filter.
+        def self.virtual_fk
+          ComputedDefinition.new(
+            column_type: 'String',
+            dependencies: ['id'],
+            values: proc { |records, _ctx| records.map { nil } }
+          )
+        end
+
+        def run(datasource_customizer, _collection_customizer = nil, _options = {})
+          Plugins::Helpers.require_datasource!(datasource_customizer, self.class)
+
+          cfg = self.class.config
+          plugin = self
+          datasource_customizer.customize_collection(cfg[:filtered]) do |c|
+            c.add_field(cfg[:fk], TwoStepLinkPlugin.virtual_fk)
+            plugin.install_source_filter(c)
+          end
+
+          datasource_customizer.customize_collection(cfg[:owner]) do |c|
+            c.add_one_to_many_relation(cfg[:name], cfg[:filtered],
+                                       origin_key: cfg[:fk], origin_key_target: 'id')
+          end
+        end
+
+        # Installs the operator filter that rewrites the virtual FK predicate.
+        def install_source_filter(_collection)
+          raise NotImplementedError, "#{self.class} must implement #install_source_filter"
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mambu_payments/plugins/relations/two_step_reconciliation_filter.rb

@@ -0,0 +1,39 @@
+module ForestAdminDatasourceMambuPayments
+  module Plugins
+    module Relations
+      # Two-step pre-resolution for `payment_order_id` / `incoming_payment_id`
+      # / ... virtual filters on Transaction (and other resources that link to
+      # payments via the Reconciliation pivot, not via a native FK).
+      # Resolves the payment ids to the set of transaction_ids through
+      # `Reconciliation.payment_id` + `Reconciliation.payment_type`, then
+      # rewrites the predicate against the host's real id field.
+      module TwoStepReconciliationFilter
+        Operators         = ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Operators
+        ConditionTreeLeaf = ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Nodes::ConditionTreeLeaf
+
+        RECONCILIATION = 'MambuReconciliation'.freeze
+
+        def self.install(collection_customizer, fk_name:, payment_type:, target_field:)
+          PivotResolution::SUPPORTED_OPS.each do |operator|
+            collection_customizer.replace_field_operator(fk_name, operator) do |value, context|
+              payment_ids = PivotResolution.normalize(value, operator)
+              next PivotResolution.no_match(target_field) if payment_ids.empty?
+
+              tx_ids = PivotResolution.collect(
+                context, RECONCILIATION,
+                PivotResolution.and_branch(
+                  ConditionTreeLeaf.new('payment_id', Operators::IN, payment_ids),
+                  ConditionTreeLeaf.new('payment_type', Operators::EQUAL, payment_type)
+                ),
+                'transaction_id'
+              )
+              next PivotResolution.no_match(target_field) if tx_ids.empty?
+
+              ConditionTreeLeaf.new(target_field, Operators::IN, tx_ids)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mambu_payments/plugins/smart_actions/approve_payment_order.rb

@@ -0,0 +1,56 @@
+module ForestAdminDatasourceMambuPayments
+  module Plugins
+    module SmartActions
+      # Approves a payment order in status `pending_approval`. The Numeral API
+      # rejects approval for orders in any other status, so per-id rescue keeps
+      # one bad id from aborting a bulk approval.
+      class ApprovePaymentOrder < ForestAdminDatasourceCustomizer::Plugins::Plugin
+        BaseAction  = ForestAdminDatasourceCustomizer::Decorators::Action::BaseAction
+        ActionScope = ForestAdminDatasourceCustomizer::Decorators::Action::Types::ActionScope
+
+        NAMES = { single: 'Approve Mambu payment order',
+                  bulk: 'Approve selected Mambu payment orders' }.freeze
+
+        def run(_datasource_customizer, collection_customizer = nil, options = {})
+          datasource = options[:datasource]
+          record_id_field = options[:record_id_field]
+          raise ArgumentError, 'ApprovePaymentOrder plugin requires :datasource' unless datasource
+          raise ArgumentError, 'ApprovePaymentOrder plugin requires :record_id_field' unless record_id_field
+          raise ArgumentError, 'ApprovePaymentOrder plugin requires a collection' unless collection_customizer
+
+          Helpers.normalize_scopes(options[:scopes]).each do |scope_key|
+            collection_customizer.add_action(NAMES[scope_key], build_action(datasource, scope_key, record_id_field))
+          end
+        end
+
+        private
+
+        def build_action(datasource, scope_key, record_id_field)
+          BaseAction.new(scope: Helpers::SCOPES[scope_key], &executor(datasource, record_id_field))
+        end
+
+        def executor(datasource, record_id_field)
+          lambda do |context, result_builder|
+            ids = Helpers.resolve_ids(context, record_id_field)
+            next result_builder.error(message: "No Mambu payment order id found in '#{record_id_field}'.") if ids.empty?
+
+            succeeded, failed = Helpers.each_with_rescue(ids, 'approve_payment_order') do |id|
+              datasource.client.approve_payment_order(id)
+            end
+            finalize(result_builder, succeeded, failed)
+          end
+        end
+
+        def finalize(result_builder, succeeded, failed)
+          if succeeded.empty?
+            return result_builder.error(message: Messages.all_failed(failed, noun: 'payment order',
+                                                                             verb: 'approve'))
+          end
+
+          result_builder.success(message: Messages.success(succeeded, failed, noun: 'payment order',
+                                                                              verb_past: 'approved'))
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mambu_payments/plugins/smart_actions/cancel_payment_order.rb

@@ -0,0 +1,66 @@
+module ForestAdminDatasourceMambuPayments
+  module Plugins
+    module SmartActions
+      # Cancels a payment order. The optional `reason` is only used by Numeral
+      # for SEPA direct debit cancelations before settlement; for other payment
+      # types it is accepted and ignored.
+      class CancelPaymentOrder < ForestAdminDatasourceCustomizer::Plugins::Plugin
+        BaseAction  = ForestAdminDatasourceCustomizer::Decorators::Action::BaseAction
+        ActionScope = ForestAdminDatasourceCustomizer::Decorators::Action::Types::ActionScope
+        FieldType   = ForestAdminDatasourceCustomizer::Decorators::Action::Types::FieldType
+
+        NAMES = { single: 'Cancel Mambu payment order',
+                  bulk: 'Cancel selected Mambu payment orders' }.freeze
+
+        def run(_datasource_customizer, collection_customizer = nil, options = {})
+          datasource = options[:datasource]
+          record_id_field = options[:record_id_field]
+          raise ArgumentError, 'CancelPaymentOrder plugin requires :datasource' unless datasource
+          raise ArgumentError, 'CancelPaymentOrder plugin requires :record_id_field' unless record_id_field
+          raise ArgumentError, 'CancelPaymentOrder plugin requires a collection' unless collection_customizer
+
+          Helpers.normalize_scopes(options[:scopes]).each do |scope_key|
+            collection_customizer.add_action(NAMES[scope_key], build_action(datasource, scope_key, record_id_field))
+          end
+        end
+
+        private
+
+        def build_action(datasource, scope_key, record_id_field)
+          BaseAction.new(scope: Helpers::SCOPES[scope_key], form: form, &executor(datasource, record_id_field))
+        end
+
+        def form
+          [{ type: FieldType::STRING, label: 'Reason',
+             description: 'Optional reason code (SEPA direct debit only).' }]
+        end
+
+        def executor(datasource, record_id_field)
+          lambda do |context, result_builder|
+            ids = Helpers.resolve_ids(context, record_id_field)
+            next result_builder.error(message: "No Mambu payment order id found in '#{record_id_field}'.") if ids.empty?
+
+            payload = {}
+            reason = context.form_values['Reason']
+            payload['reason'] = reason if Helpers.present?(reason)
+
+            succeeded, failed = Helpers.each_with_rescue(ids, 'cancel_payment_order') do |id|
+              datasource.client.cancel_payment_order(id, payload)
+            end
+            finalize(result_builder, succeeded, failed)
+          end
+        end
+
+        def finalize(result_builder, succeeded, failed)
+          if succeeded.empty?
+            return result_builder.error(message: Messages.all_failed(failed, noun: 'payment order',
+                                                                             verb: 'cancel'))
+          end
+
+          result_builder.success(message: Messages.success(succeeded, failed, noun: 'payment order',
+                                                                              verb_past: 'canceled'))
+        end
+      end
+    end
+  end
+end