forest_admin_datasource_mambu_payments 1.33.1

data/lib/forest_admin_datasource_mambu_payments/collections/internal_account.rb

@@ -0,0 +1,136 @@
+# rubocop:disable Metrics/ClassLength, Metrics/MethodLength
+module ForestAdminDatasourceMambuPayments
+  module Collections
+    class InternalAccount < BaseCollection
+      ManyToOneSchema = ForestAdminDatasourceToolkit::Schema::Relations::ManyToOneSchema
+
+      client_resource :internal_account
+
+      def initialize(datasource)
+        super(datasource, 'MambuInternalAccount')
+        define_schema
+        define_relations
+        reconcile_filter_operators!
+      end
+
+      def create(_caller, data)
+        serialize(datasource.client.create_internal_account(build_payload(data)))
+      end
+
+      def update(caller, filter, patch)
+        payload = build_payload(patch)
+        ids_for(caller, filter).each { |id| datasource.client.update_internal_account(id, payload) }
+      end
+
+      def delete(caller, filter)
+        ids_for(caller, filter).each { |id| datasource.client.delete_internal_account(id) }
+      end
+
+      def serialize(record)
+        a = attrs_of(record)
+        {
+          'id' => a['id'],
+          'object' => a['object'],
+          'status' => a['status'],
+          'status_details' => a['status_details'],
+          'type' => a['type'],
+          'name' => a['name'],
+          'holder_name' => a['holder_name'],
+          'alternative_holder_names' => a['alternative_holder_names'],
+          'connected_account_ids' => a['connected_account_ids'],
+          'account_number' => a['account_number'],
+          'account_number_format' => a['account_number_format'],
+          'bank_code' => a['bank_code'],
+          'bank_name' => a['bank_name'],
+          'bank_address' => a['bank_address'],
+          'bank_code_format' => a['bank_code_format'],
+          'holder_address' => a['holder_address'],
+          'account_holder_id' => a['account_holder_id'],
+          'creditor_identifier' => a['creditor_identifier'],
+          'organization_identification' => a['organization_identification'],
+          'customer_bic' => a['customer_bic'],
+          'distinguished_name' => a['distinguished_name'],
+          'currencies' => a['currencies'],
+          'cbs_source' => a['cbs_source'],
+          'cbs_account_id' => a['cbs_account_id'],
+          'cbs_account_type' => a['cbs_account_type'],
+          'synchronized_with_bank' => a['synchronized_with_bank'],
+          'metadata' => a['metadata'],
+          'bank_data' => a['bank_data'],
+          'custom_fields' => a['custom_fields'],
+          'created_at' => a['created_at']
+        }
+      end
+
+      protected
+
+      def collection_filters
+        {
+          'account_holder_id' => { ops: [Operators::EQUAL, Operators::IN] }
+        }
+      end
+
+      def many_to_one_embeds
+        [
+          { foreign_key: 'account_holder_id', relation_name: 'account_holder',
+            collection: 'MambuAccountHolder' }
+        ]
+      end
+
+      private
+
+      def define_schema
+        add_field('id', ColumnSchema.new(column_type: 'String', is_primary_key: true,
+                                         is_read_only: true, is_sortable: true))
+        add_field('object', ColumnSchema.new(column_type: 'String', is_read_only: true, is_sortable: false))
+        add_field('status', ColumnSchema.new(column_type: 'String', is_read_only: true, is_sortable: true))
+        add_field('status_details', ColumnSchema.new(column_type: 'String', is_read_only: true, is_sortable: false))
+        add_field('type', ColumnSchema.new(column_type: 'String', is_read_only: false, is_sortable: true))
+        add_field('name', ColumnSchema.new(column_type: 'String', is_read_only: false, is_sortable: true))
+        add_field('holder_name', ColumnSchema.new(column_type: 'String', is_read_only: false, is_sortable: false))
+        add_field('alternative_holder_names', ColumnSchema.new(column_type: 'Json', is_read_only: false,
+                                                               is_sortable: false))
+        add_field('connected_account_ids', ColumnSchema.new(column_type: 'Json', is_read_only: false,
+                                                            is_sortable: false))
+        add_field('account_number', ColumnSchema.new(column_type: 'String', is_read_only: false, is_sortable: false))
+        add_field('account_number_format', ColumnSchema.new(column_type: 'String', is_read_only: false,
+                                                            is_sortable: false))
+        add_field('bank_code', ColumnSchema.new(column_type: 'String', is_read_only: false, is_sortable: false))
+        add_field('bank_name', ColumnSchema.new(column_type: 'String', is_read_only: false, is_sortable: false))
+        add_field('bank_address', ColumnSchema.new(column_type: 'Json', is_read_only: false, is_sortable: false))
+        add_field('bank_code_format', ColumnSchema.new(column_type: 'String', is_read_only: false,
+                                                       is_sortable: false))
+        add_field('holder_address', ColumnSchema.new(column_type: 'Json', is_read_only: false, is_sortable: false))
+        add_field('account_holder_id', ColumnSchema.new(column_type: 'String', is_read_only: false,
+                                                        is_sortable: true))
+        add_field('creditor_identifier', ColumnSchema.new(column_type: 'String', is_read_only: false,
+                                                          is_sortable: false))
+        add_field('organization_identification', ColumnSchema.new(column_type: 'Json', is_read_only: false,
+                                                                  is_sortable: false))
+        add_field('customer_bic', ColumnSchema.new(column_type: 'String', is_read_only: false, is_sortable: false))
+        add_field('distinguished_name', ColumnSchema.new(column_type: 'String', is_read_only: false,
+                                                         is_sortable: false))
+        add_field('currencies', ColumnSchema.new(column_type: 'Json', is_read_only: false, is_sortable: false))
+        add_field('cbs_source', ColumnSchema.new(column_type: 'String', is_read_only: false, is_sortable: false))
+        add_field('cbs_account_id', ColumnSchema.new(column_type: 'String', is_read_only: false, is_sortable: false))
+        add_field('cbs_account_type', ColumnSchema.new(column_type: 'String', is_read_only: false,
+                                                       is_sortable: false))
+        add_field('synchronized_with_bank', ColumnSchema.new(column_type: 'Boolean', is_read_only: false,
+                                                             is_sortable: false))
+        add_field('metadata', ColumnSchema.new(column_type: 'Json', is_read_only: false, is_sortable: false))
+        add_field('bank_data', ColumnSchema.new(column_type: 'Json', is_read_only: true, is_sortable: false))
+        add_field('custom_fields', ColumnSchema.new(column_type: 'Json', is_read_only: false, is_sortable: false))
+        add_field('created_at', ColumnSchema.new(column_type: 'Date', is_read_only: true, is_sortable: true))
+      end
+
+      def define_relations
+        add_field('account_holder', ManyToOneSchema.new(
+                                      foreign_collection: 'MambuAccountHolder',
+                                      foreign_key: 'account_holder_id',
+                                      foreign_key_target: 'id'
+                                    ))
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/ClassLength, Metrics/MethodLength

data/lib/forest_admin_datasource_mambu_payments/collections/payee_verification_request.rb

@@ -0,0 +1,88 @@
+module ForestAdminDatasourceMambuPayments
+  module Collections
+    # Payee Verification Requests are emitted by Numeral when an outgoing
+    # verification is sent (via the `Trigger payee verification` smart
+    # action on external accounts) or when an incoming verification arrives
+    # from the network. From Forest's perspective they are read-only: send
+    # and simulate are lifecycle operations exposed as smart-action plugins
+    # (see TriggerPayeeVerification) rather than collection writes.
+    class PayeeVerificationRequest < BaseCollection
+      ENUM_STATUS          = %w[completed failed].freeze
+      ENUM_FAILURE_CODE    = %w[business_error technical_error psp_technical_error].freeze
+      ENUM_DIRECTION       = %w[outgoing incoming].freeze
+      ENUM_SCHEME          = %w[vop].freeze
+      ENUM_MATCHING_RESULT = %w[match close_match no_match impossible_match].freeze
+
+      client_resource :payee_verification_request
+
+      def initialize(datasource)
+        super(datasource, 'MambuPayeeVerificationRequest')
+        define_schema
+        reconcile_filter_operators!
+      end
+
+      def serialize(record)
+        a = attrs_of(record)
+        {
+          'id' => a['id'],
+          'object' => a['object'],
+          'status' => a['status'],
+          'failure_code' => a['failure_code'],
+          'status_details' => a['status_details'],
+          'direction' => a['direction'],
+          'scheme' => a['scheme'],
+          'request' => a['request'],
+          'matching_result' => a['matching_result'],
+          'payee_suggested_name' => a['payee_suggested_name'],
+          'matching_details' => a['matching_details'],
+          'scheme_data' => a['scheme_data'],
+          'metadata' => a['metadata'],
+          'response_received_at' => a['response_received_at'],
+          'created_at' => a['created_at']
+        }
+      end
+
+      protected
+
+      def collection_filters
+        {
+          'status' => { ops: [Operators::EQUAL, Operators::IN] },
+          'direction' => { ops: [Operators::EQUAL, Operators::IN] },
+          'scheme' => { ops: [Operators::EQUAL, Operators::IN] },
+          'matching_result' => { ops: [Operators::EQUAL, Operators::IN] }
+        }
+      end
+
+      private
+
+      def define_schema
+        add_field('id', ColumnSchema.new(column_type: 'String', is_primary_key: true,
+                                         is_read_only: true, is_sortable: true))
+        add_field('object', ColumnSchema.new(column_type: 'String', is_read_only: true, is_sortable: false))
+        add_field('status', ColumnSchema.new(column_type: 'Enum', enum_values: ENUM_STATUS,
+                                             is_read_only: true, is_sortable: true))
+        add_field('failure_code', ColumnSchema.new(column_type: 'Enum', enum_values: ENUM_FAILURE_CODE,
+                                                   is_read_only: true, is_sortable: false))
+        add_field('status_details', ColumnSchema.new(column_type: 'String', is_read_only: true, is_sortable: false))
+        add_field('direction', ColumnSchema.new(column_type: 'Enum', enum_values: ENUM_DIRECTION,
+                                                is_read_only: true, is_sortable: true))
+        add_field('scheme', ColumnSchema.new(column_type: 'Enum', enum_values: ENUM_SCHEME,
+                                             is_read_only: true, is_sortable: true))
+        # request, matching_details, scheme_data are nested objects with their
+        # own sub-fields (payee_identification, scheme_request_id, ...). Forest
+        # can't model nested columns natively, so we expose them as Json
+        # snapshots — matches how IncomingPayment handles originating_account.
+        add_field('request', ColumnSchema.new(column_type: 'Json', is_read_only: true, is_sortable: false))
+        add_field('matching_result', ColumnSchema.new(column_type: 'Enum', enum_values: ENUM_MATCHING_RESULT,
+                                                      is_read_only: true, is_sortable: true))
+        add_field('payee_suggested_name', ColumnSchema.new(column_type: 'String', is_read_only: true,
+                                                           is_sortable: false))
+        add_field('matching_details', ColumnSchema.new(column_type: 'Json', is_read_only: true, is_sortable: false))
+        add_field('scheme_data', ColumnSchema.new(column_type: 'Json', is_read_only: true, is_sortable: false))
+        add_field('metadata', ColumnSchema.new(column_type: 'Json', is_read_only: true, is_sortable: false))
+        add_field('response_received_at', ColumnSchema.new(column_type: 'Date', is_read_only: true, is_sortable: true))
+        add_field('created_at', ColumnSchema.new(column_type: 'Date', is_read_only: true, is_sortable: true))
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mambu_payments/collections/payment_capture.rb

@@ -0,0 +1,136 @@
+# rubocop:disable Metrics/ClassLength, Metrics/MethodLength
+module ForestAdminDatasourceMambuPayments
+  module Collections
+    class PaymentCapture < BaseCollection
+      ManyToOneSchema = ForestAdminDatasourceToolkit::Schema::Relations::ManyToOneSchema
+
+      ENUM_TYPE                  = %w[charge chargeback refund].freeze
+      ENUM_SOURCE                = %w[api reporting_file].freeze
+      ENUM_RECONCILIATION_STATUS = %w[unreconciled reconciled partially_reconciled].freeze
+
+      client_resource :payment_capture
+
+      def initialize(datasource)
+        super(datasource, 'MambuPaymentCapture')
+        define_schema
+        define_relations
+        reconcile_filter_operators!
+      end
+
+      def serialize(record)
+        a = attrs_of(record)
+        {
+          'id' => a['id'],
+          'object' => a['object'],
+          'idempotency_key' => a['idempotency_key'],
+          'connected_account_id' => a['connected_account_id'],
+          'type' => a['type'],
+          'source' => a['source'],
+          'amount' => a['amount'],
+          'original_payment_amount' => a['original_payment_amount'],
+          'currency' => a['currency'],
+          'date' => a['date'],
+          'value_date' => a['value_date'],
+          'remittance_date' => a['remittance_date'],
+          'remittance_reference' => a['remittance_reference'],
+          'transaction_reference' => a['transaction_reference'],
+          'authorization_id' => a['authorization_id'],
+          'payment_reference' => a['payment_reference'],
+          'network' => a['network'],
+          'merchant_id' => a['merchant_id'],
+          'fee_amount' => a['fee_amount'],
+          'fee_amount_currency' => a['fee_amount_currency'],
+          'net_amount' => a['net_amount'],
+          'net_amount_currency' => a['net_amount_currency'],
+          'reconciliation_status' => a['reconciliation_status'],
+          'reconciled_amount' => a['reconciled_amount'],
+          'cbs_data' => a['cbs_data'],
+          'lending' => a['lending'],
+          'metadata' => a['metadata'],
+          'canceled_at' => a['canceled_at'],
+          'updated_at' => a['updated_at'],
+          'created_at' => a['created_at']
+        }
+      end
+
+      protected
+
+      def collection_filters
+        {
+          'connected_account_id' => { ops: [Operators::EQUAL, Operators::IN] },
+          'type' => { ops: [Operators::EQUAL, Operators::IN] },
+          'source' => { ops: [Operators::EQUAL, Operators::IN] },
+          'reconciliation_status' => { ops: [Operators::EQUAL, Operators::IN] }
+        }
+      end
+
+      def many_to_one_embeds
+        [
+          { foreign_key: 'connected_account_id', relation_name: 'connected_account',
+            collection: 'MambuConnectedAccount' }
+        ]
+      end
+
+      private
+
+      # Payment captures are emitted by PSPs (or registered manually via API
+      # to reconcile reporting files). From Forest's perspective they're
+      # read-only: create / update / cancel exist on the Numeral API but are
+      # lifecycle operations better expressed as smart-action plugins later
+      # (same approach as payment_orders' approve/cancel).
+      def define_schema
+        add_field('id', ColumnSchema.new(column_type: 'String', is_primary_key: true,
+                                         is_read_only: true, is_sortable: true))
+        add_field('object', ColumnSchema.new(column_type: 'String', is_read_only: true, is_sortable: false))
+        add_field('idempotency_key', ColumnSchema.new(column_type: 'String', is_read_only: true, is_sortable: false))
+        add_field('connected_account_id', ColumnSchema.new(column_type: 'String',
+                                                           is_read_only: true, is_sortable: true))
+        add_field('type', ColumnSchema.new(column_type: 'Enum', enum_values: ENUM_TYPE,
+                                           is_read_only: true, is_sortable: true))
+        add_field('source', ColumnSchema.new(column_type: 'Enum', enum_values: ENUM_SOURCE,
+                                             is_read_only: true, is_sortable: true))
+        add_field('amount', ColumnSchema.new(column_type: 'Number', is_read_only: true, is_sortable: false))
+        add_field('original_payment_amount', ColumnSchema.new(column_type: 'Number', is_read_only: true,
+                                                              is_sortable: false))
+        add_field('currency', ColumnSchema.new(column_type: 'String', is_read_only: true, is_sortable: false))
+        add_field('date', ColumnSchema.new(column_type: 'Date', is_read_only: true, is_sortable: true))
+        add_field('value_date', ColumnSchema.new(column_type: 'Date', is_read_only: true, is_sortable: true))
+        add_field('remittance_date', ColumnSchema.new(column_type: 'Date', is_read_only: true, is_sortable: true))
+        add_field('remittance_reference', ColumnSchema.new(column_type: 'String', is_read_only: true,
+                                                           is_sortable: false))
+        add_field('transaction_reference', ColumnSchema.new(column_type: 'String', is_read_only: true,
+                                                            is_sortable: false))
+        add_field('authorization_id', ColumnSchema.new(column_type: 'String', is_read_only: true, is_sortable: false))
+        add_field('payment_reference', ColumnSchema.new(column_type: 'String', is_read_only: true,
+                                                        is_sortable: false))
+        add_field('network', ColumnSchema.new(column_type: 'String', is_read_only: true, is_sortable: false))
+        add_field('merchant_id', ColumnSchema.new(column_type: 'String', is_read_only: true, is_sortable: false))
+        add_field('fee_amount', ColumnSchema.new(column_type: 'Number', is_read_only: true, is_sortable: false))
+        add_field('fee_amount_currency', ColumnSchema.new(column_type: 'String', is_read_only: true,
+                                                          is_sortable: false))
+        add_field('net_amount', ColumnSchema.new(column_type: 'Number', is_read_only: true, is_sortable: false))
+        add_field('net_amount_currency', ColumnSchema.new(column_type: 'String', is_read_only: true,
+                                                          is_sortable: false))
+        add_field('reconciliation_status', ColumnSchema.new(column_type: 'Enum',
+                                                            enum_values: ENUM_RECONCILIATION_STATUS,
+                                                            is_read_only: true, is_sortable: true))
+        add_field('reconciled_amount', ColumnSchema.new(column_type: 'Number', is_read_only: true, is_sortable: false))
+        add_field('cbs_data', ColumnSchema.new(column_type: 'Json', is_read_only: true, is_sortable: false))
+        add_field('lending', ColumnSchema.new(column_type: 'Json', is_read_only: true, is_sortable: false))
+        add_field('metadata', ColumnSchema.new(column_type: 'Json', is_read_only: true, is_sortable: false))
+        add_field('canceled_at', ColumnSchema.new(column_type: 'Date', is_read_only: true, is_sortable: true))
+        add_field('updated_at', ColumnSchema.new(column_type: 'Date', is_read_only: true, is_sortable: true))
+        add_field('created_at', ColumnSchema.new(column_type: 'Date', is_read_only: true, is_sortable: true))
+      end
+
+      def define_relations
+        add_field('connected_account', ManyToOneSchema.new(
+                                         foreign_collection: 'MambuConnectedAccount',
+                                         foreign_key: 'connected_account_id',
+                                         foreign_key_target: 'id'
+                                       ))
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/ClassLength, Metrics/MethodLength

data/lib/forest_admin_datasource_mambu_payments/collections/payment_order.rb

@@ -0,0 +1,132 @@
+# rubocop:disable Metrics/ClassLength, Metrics/MethodLength
+module ForestAdminDatasourceMambuPayments
+  module Collections
+    class PaymentOrder < BaseCollection
+      ManyToOneSchema = ForestAdminDatasourceToolkit::Schema::Relations::ManyToOneSchema
+
+      ENUM_DIRECTION = %w[debit credit].freeze
+
+      client_resource :payment_order
+
+      def initialize(datasource)
+        super(datasource, 'MambuPaymentOrder')
+        define_schema
+        define_relations
+        reconcile_filter_operators!
+      end
+
+      def create(_caller, data)
+        serialize(datasource.client.create_payment_order(build_payload(data)))
+      end
+
+      def update(caller, filter, patch)
+        payload = build_payload(patch)
+        ids_for(caller, filter).each { |id| datasource.client.update_payment_order(id, payload) }
+      end
+
+      def delete(caller, filter)
+        ids_for(caller, filter).each { |id| datasource.client.delete_payment_order(id) }
+      end
+
+      def serialize(record)
+        a = attrs_of(record)
+        {
+          'id' => a['id'],
+          'connected_account_id' => a['connected_account_id'],
+          'receiving_account_id' => a['receiving_account_id'],
+          'type' => a['type'],
+          'direction' => a['direction'],
+          'status' => a['status'],
+          'amount' => a['amount'],
+          'currency' => a['currency'],
+          'reference' => a['reference'],
+          'purpose' => a['purpose'],
+          'end_to_end_id' => a['end_to_end_id'],
+          'idempotency_key' => a['idempotency_key'],
+          'requested_execution_date' => a['requested_execution_date'],
+          'value_date' => a['value_date'],
+          'initiated_at' => a['initiated_at'],
+          'reconciliation_status' => a['reconciliation_status'],
+          'reconciled_amount' => a['reconciled_amount'],
+          'originating_account' => a['originating_account'],
+          'receiving_account' => a['receiving_account'],
+          'metadata' => a['metadata'],
+          'custom_fields' => a['custom_fields'],
+          'created_at' => a['created_at']
+        }
+      end
+
+      protected
+
+      # NOTE: server-side filters verified against Numeral's `GET /payment_orders` docs.
+      # Add new entries here (status, direction, currency, created_at ranges, …) as
+      # we confirm them — anything not declared raises a clear error rather than
+      # silently returning unfiltered results.
+      def collection_filters
+        {
+          'connected_account_id' => { ops: [Operators::EQUAL, Operators::IN] },
+          # Numeral's list endpoint exposes the receiving external account
+          # under the `external_account_id` query param.
+          'receiving_account_id' => { ops: [Operators::EQUAL, Operators::IN],
+                                      param: 'external_account_id' }
+        }
+      end
+
+      def many_to_one_embeds
+        [
+          { foreign_key: 'connected_account_id', relation_name: 'connected_account',
+            collection: 'MambuConnectedAccount' },
+          { foreign_key: 'receiving_account_id', relation_name: 'external_account',
+            collection: 'MambuExternalAccount' }
+        ]
+      end
+
+      private
+
+      def define_schema
+        add_field('id', ColumnSchema.new(column_type: 'String', is_primary_key: true,
+                                         is_read_only: true, is_sortable: true))
+        add_field('connected_account_id', ColumnSchema.new(column_type: 'String',
+                                                           is_read_only: false, is_sortable: true))
+        add_field('receiving_account_id', ColumnSchema.new(column_type: 'String',
+                                                           is_read_only: true, is_sortable: true))
+        add_field('type', ColumnSchema.new(column_type: 'String', is_read_only: false, is_sortable: true))
+        add_field('direction', ColumnSchema.new(column_type: 'Enum', enum_values: ENUM_DIRECTION,
+                                                is_read_only: false, is_sortable: false))
+        add_field('status', ColumnSchema.new(column_type: 'String', is_read_only: true, is_sortable: true))
+        add_field('amount', ColumnSchema.new(column_type: 'Number', is_read_only: false, is_sortable: false))
+        add_field('currency', ColumnSchema.new(column_type: 'String', is_read_only: false, is_sortable: false))
+        add_field('reference', ColumnSchema.new(column_type: 'String', is_read_only: false, is_sortable: false))
+        add_field('purpose', ColumnSchema.new(column_type: 'String', is_read_only: false, is_sortable: false))
+        add_field('end_to_end_id', ColumnSchema.new(column_type: 'String', is_read_only: false, is_sortable: false))
+        add_field('idempotency_key', ColumnSchema.new(column_type: 'String', is_read_only: false, is_sortable: false))
+        add_field('requested_execution_date', ColumnSchema.new(column_type: 'Date', is_read_only: false,
+                                                               is_sortable: true))
+        add_field('value_date', ColumnSchema.new(column_type: 'Date', is_read_only: true, is_sortable: true))
+        add_field('initiated_at', ColumnSchema.new(column_type: 'Date', is_read_only: true, is_sortable: true))
+        add_field('reconciliation_status', ColumnSchema.new(column_type: 'String', is_read_only: true,
+                                                            is_sortable: false))
+        add_field('reconciled_amount', ColumnSchema.new(column_type: 'Number', is_read_only: true, is_sortable: false))
+        add_field('originating_account', ColumnSchema.new(column_type: 'Json', is_read_only: true, is_sortable: false))
+        add_field('receiving_account', ColumnSchema.new(column_type: 'Json', is_read_only: true, is_sortable: false))
+        add_field('metadata', ColumnSchema.new(column_type: 'Json', is_read_only: false, is_sortable: false))
+        add_field('custom_fields', ColumnSchema.new(column_type: 'Json', is_read_only: false, is_sortable: false))
+        add_field('created_at', ColumnSchema.new(column_type: 'Date', is_read_only: true, is_sortable: true))
+      end
+
+      def define_relations
+        add_field('connected_account', ManyToOneSchema.new(
+                                         foreign_collection: 'MambuConnectedAccount',
+                                         foreign_key: 'connected_account_id',
+                                         foreign_key_target: 'id'
+                                       ))
+        add_field('external_account', ManyToOneSchema.new(
+                                        foreign_collection: 'MambuExternalAccount',
+                                        foreign_key: 'receiving_account_id',
+                                        foreign_key_target: 'id'
+                                      ))
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/ClassLength, Metrics/MethodLength

data/lib/forest_admin_datasource_mambu_payments/collections/reconciliation.rb

@@ -0,0 +1,93 @@
+module ForestAdminDatasourceMambuPayments
+  module Collections
+    class Reconciliation < BaseCollection
+      ManyToOneSchema = ForestAdminDatasourceToolkit::Schema::Relations::ManyToOneSchema
+
+      ENUM_MATCH_TYPE   = %w[manual auto].freeze
+      ENUM_PAYMENT_TYPE = %w[payment_order incoming_payment return expected_payment payment_capture].freeze
+
+      client_resource :reconciliation
+
+      def initialize(datasource)
+        super(datasource, 'MambuReconciliation')
+        define_schema
+        define_relations
+        reconcile_filter_operators!
+      end
+
+      def create(_caller, data)
+        serialize(datasource.client.create_reconciliation(build_payload(data)))
+      end
+
+      def update(caller, filter, patch)
+        payload = build_payload(patch)
+        ids_for(caller, filter).each { |id| datasource.client.update_reconciliation(id, payload) }
+      end
+
+      def serialize(record)
+        a = attrs_of(record)
+        {
+          'id' => a['id'],
+          'object' => a['object'],
+          'transaction_id' => a['transaction_id'],
+          'payment_id' => a['payment_id'],
+          'payment_type' => a['payment_type'],
+          'amount' => a['amount'],
+          'match_type' => a['match_type'],
+          'metadata' => a['metadata'],
+          'canceled_at' => a['canceled_at'],
+          'created_at' => a['created_at']
+        }
+      end
+
+      protected
+
+      def collection_filters
+        {
+          'transaction_id' => { ops: [Operators::EQUAL, Operators::IN] },
+          'payment_id' => { ops: [Operators::EQUAL, Operators::IN] },
+          'payment_type' => { ops: [Operators::EQUAL, Operators::IN] },
+          'match_type' => { ops: [Operators::EQUAL, Operators::IN] }
+        }
+      end
+
+      def many_to_one_embeds
+        [
+          { foreign_key: 'transaction_id', relation_name: 'transaction', collection: 'MambuTransaction' }
+        ]
+      end
+
+      private
+
+      def define_schema
+        add_field('id', ColumnSchema.new(column_type: 'String', is_primary_key: true,
+                                         is_read_only: true, is_sortable: true))
+        add_field('object', ColumnSchema.new(column_type: 'String', is_read_only: true, is_sortable: false))
+        # transaction_id is set on create and never mutated afterwards — Numeral
+        # rejects PATCH on anything besides metadata.
+        add_field('transaction_id', ColumnSchema.new(column_type: 'String', is_read_only: false, is_sortable: true))
+        # payment_id is polymorphic in Numeral (payment_order / incoming_payment /
+        # return / expected_payment / payment_capture, discriminated by
+        # payment_type). Forest can't model that natively, so we expose it as
+        # a plain string column rather than a typed ManyToOne.
+        add_field('payment_id', ColumnSchema.new(column_type: 'String', is_read_only: false, is_sortable: false))
+        add_field('payment_type', ColumnSchema.new(column_type: 'Enum', enum_values: ENUM_PAYMENT_TYPE,
+                                                   is_read_only: true, is_sortable: true))
+        add_field('amount', ColumnSchema.new(column_type: 'Number', is_read_only: false, is_sortable: false))
+        add_field('match_type', ColumnSchema.new(column_type: 'Enum', enum_values: ENUM_MATCH_TYPE,
+                                                 is_read_only: true, is_sortable: true))
+        add_field('metadata', ColumnSchema.new(column_type: 'Json', is_read_only: false, is_sortable: false))
+        add_field('canceled_at', ColumnSchema.new(column_type: 'Date', is_read_only: true, is_sortable: true))
+        add_field('created_at', ColumnSchema.new(column_type: 'Date', is_read_only: true, is_sortable: true))
+      end
+
+      def define_relations
+        add_field('transaction', ManyToOneSchema.new(
+                                   foreign_collection: 'MambuTransaction',
+                                   foreign_key: 'transaction_id',
+                                   foreign_key_target: 'id'
+                                 ))
+      end
+    end
+  end
+end