fix: improve product mapping filteringfix: improve

Author: endenis

app/graphql/sources/integration_mappings_by_mappable.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Sources
+  class IntegrationMappingsByMappable < GraphQL::Dataloader::Source
+    def initialize(integration_id = nil)
+      @integration_id = integration_id
+    end
+
+    def fetch(mappables)
+      mappings = IntegrationMappings::BaseMapping.where(mappable: mappables)
+      mappings = mappings.where(integration_id: @integration_id) if @integration_id
+      mappings_by_mappable = mappings.group_by { [it.mappable_type, it.mappable_id] }
+
+      mappables.map do |mappable|
+        mappings_by_mappable.fetch([mappable.class.polymorphic_name, mappable.id], [])
+      end
+    end
+  end
+end

app/graphql/types/products/object.rb

@@ -38,10 +38,7 @@ def filters_count
       end
 
       def integration_mappings(integration_id: nil)
-        mappings = dataloader.with(Sources::ActiveRecordAssociation, :integration_mappings).load(object)
-        return mappings unless integration_id
-
-        mappings.select { |mapping| mapping.integration_id == integration_id }
+        dataloader.with(Sources::IntegrationMappingsByMappable, integration_id).load(object)
       end
     end
   end

spec/graphql/resolvers/products_resolver_spec.rb

@@ -46,20 +46,26 @@
 
   context "with integration mappings" do
     let(:integration) { create(:anrok_integration, organization:) }
+    let(:other_integration) { create(:xero_integration, organization:) }
     let!(:usage_mapping) { create(:anrok_mapping, integration:, organization:, mappable: usage_item) }
     let!(:fixed_mapping) { create(:anrok_mapping, integration:, organization:, mappable: fixed_item) }
+    let(:variables) { {integrationId: integration.id} }
 
     let(:query) do
       <<~GQL
-        query {
+        query($integrationId: ID) {
           products(limit: 5) {
-            collection { id integrationMappings { id } }
+            collection { id integrationMappings(integrationId: $integrationId) { id } }
           }
         }
       GQL
     end
 
-    it "loads mappings for all Products in one query" do
+    before do
+      create(:xero_mapping, integration: other_integration, organization:, mappable: usage_item)
+    end
+
+    it "loads filtered mappings for all Products in one query" do
       query_count = 0
       counter = lambda do |_name, _start, _finish, _id, payload|
         query_count += 1 if payload[:sql]&.include?('FROM "integration_mappings"')

spec/graphql/sources/integration_mappings_by_mappable_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Sources::IntegrationMappingsByMappable do
+  subject(:source) { described_class.new(integration_id) }
+
+  let(:organization) { create(:organization) }
+  let(:integration) { create(:anrok_integration, organization:) }
+  let(:other_integration) { create(:xero_integration, organization:) }
+  let(:integration_id) { integration.id }
+  let(:product) { create(:product, organization:) }
+  let(:other_product) { create(:product, organization:) }
+  let!(:mapping) { create(:anrok_mapping, integration:, organization:, mappable: product) }
+  let!(:other_mapping) { create(:anrok_mapping, integration:, organization:, mappable: other_product) }
+  let!(:mapping_for_other_integration) do
+    create(:xero_mapping, integration: other_integration, organization:, mappable: product)
+  end
+
+  describe "#fetch" do
+    it "returns mappings for the requested integration grouped by mappable" do
+      expect(source.fetch([product, other_product])).to eq([[mapping], [other_mapping]])
+    end
+
+    context "without an integration ID" do
+      let(:integration_id) { nil }
+
+      it "returns all mappings grouped by mappable" do
+        result = source.fetch([product, other_product])
+
+        expect(result.first).to match_array([mapping, mapping_for_other_integration])
+        expect(result.second).to eq([other_mapping])
+      end
+    end
+  end
+end

spec/services/integrations/aggregator/base_payload_spec.rb

@@ -10,7 +10,7 @@
   let(:integration) { create(:anrok_integration, organization:) }
   let(:product) { create(:product, organization:) }
 
-  describe "Product mapping fallback" do
+  describe "Product mapping lookup" do
     let!(:fallback_mapping) do
       create(
         :anrok_collection_mapping,
@@ -25,5 +25,17 @@
 
       expect(mapping).to eq(fallback_mapping)
     end
+
+    context "when the Product has a mapping" do
+      let!(:product_mapping) do
+        create(:anrok_mapping, integration:, organization:, mappable: product)
+      end
+
+      it "returns the Product mapping" do
+        mapping = payload.send(:lookup_mapping, "Product", product.id)
+
+        expect(mapping).to eq(product_mapping)
+      end
+    end
   end
 end