feat(products): filter plans by product

## Context

The product detail page has a Plans tab listing the plans that include a
given product. The plans link to products through plan_products.

## Description

Add an optional product_id filter to PlansQuery and the plans resolver so
the collection can be scoped to a single product, reusing the existing
pagination, ordering and search. Filtering is done through a plan_products
subquery to avoid join duplicates.

Author: rsempe

app/graphql/resolvers/plans_resolver.rb

@@ -11,17 +11,19 @@ class PlansResolver < Resolvers::BaseResolver
 
     argument :limit, Integer, required: false
     argument :page, Integer, required: false
+    argument :product_id, ID, required: false
     argument :search_term, String, required: false
     argument :with_deleted, Boolean, required: false
 
     type Types::Plans::Object.collection_type, null: false
 
-    def resolve(page: nil, limit: nil, search_term: nil, with_deleted: nil)
+    def resolve(page: nil, limit: nil, search_term: nil, with_deleted: nil, product_id: nil)
       result = PlansQuery.call(
         organization: current_organization,
         search_term:,
         filters: {
-          with_deleted:
+          with_deleted:,
+          product_id:
         },
         pagination: {
           page:,

app/queries/plans_query.rb

@@ -2,7 +2,7 @@
 
 class PlansQuery < BaseQuery
   Result = BaseResult[:plans]
-  Filters = BaseFilters[:with_deleted, :include_pending_deletion]
+  Filters = BaseFilters[:with_deleted, :include_pending_deletion, :product_id]
 
   def call
     plans = base_scope.result
@@ -19,7 +19,15 @@ def call
   private
 
   def base_scope
-    Plan.parents.where(organization:).ransack(search_params)
+    scope = Plan.parents.where(organization:)
+    scope = with_product(scope)
+    scope.ransack(search_params)
+  end
+
+  def with_product(scope)
+    return scope if filters.product_id.blank?
+
+    scope.where(id: PlanProduct.where(product_id: filters.product_id).select(:plan_id))
   end
 
   def search_params

schema.graphql

@@ -77,4 +77,38 @@
       expect(plans_response["metadata"]["totalCount"]).to eq(2)
     end
   end
+
+  context "when filtering by product_id" do
+    let(:product) { create(:product, organization:) }
+    let(:other_plan) { create(:plan, organization:) }
+    let(:query) do
+      <<~GQL
+        query($productId: ID!) {
+          plans(limit: 5, productId: $productId) {
+            collection { id }
+            metadata { totalCount }
+          }
+        }
+      GQL
+    end
+
+    before do
+      other_plan
+      create(:plan_product, organization:, plan:, product:)
+    end
+
+    it "returns only the plans linked to the product" do
+      result = execute_graphql(
+        current_user: membership.user,
+        current_organization: organization,
+        permissions: required_permission,
+        query:,
+        variables: {productId: product.id}
+      )
+
+      plans_response = result["data"]["plans"]
+      expect(plans_response["collection"].map { |p| p["id"] }).to eq([plan.id])
+      expect(plans_response["metadata"]["totalCount"]).to eq(1)
+    end
+  end
 end

schema.json

@@ -89,4 +89,16 @@
       expect(returned_ids).not_to include(plan_third.id)
     end
   end
+
+  context "when filtering by product_id" do
+    let(:product) { create(:product, organization:) }
+    let(:filters) { {product_id: product.id} }
+
+    before { create(:plan_product, organization:, plan: plan_first, product:) }
+
+    it "returns only the plans linked to the product" do
+      expect(result).to be_success
+      expect(returned_ids).to eq([plan_first.id])
+    end
+  end
 end