feat(products): filter product items by a single item_type

## Context

The product items resolver accepted a list of item types while the REST
endpoint only ever filters by one. With just two item types, filtering by
both is equivalent to no filter, so a single value is enough.

## Description

Replace the item_types list filter with a single item_type on
ProductItemsQuery and the resolver, so the GraphQL and REST surfaces are
consistent.

Author: rsempe

app/graphql/resolvers/product_items_resolver.rb

@@ -9,20 +9,20 @@ class ProductItemsResolver < Resolvers::BaseResolver
 
     description "Query product items of an organization"
 
-    argument :item_types, [Types::ProductItems::ItemTypeEnum], required: false
+    argument :item_type, Types::ProductItems::ItemTypeEnum, required: false
     argument :limit, Integer, required: false
     argument :page, Integer, required: false
     argument :product_id, ID, required: false
     argument :search_term, String, required: false
 
     type Types::ProductItems::Object.collection_type, null: false
 
-    def resolve(page: nil, limit: nil, search_term: nil, product_id: nil, item_types: nil)
+    def resolve(page: nil, limit: nil, search_term: nil, product_id: nil, item_type: nil)
       result = ::ProductItemsQuery.call(
         organization: current_organization,
         search_term:,
         pagination: {page:, limit:},
-        filters: {product_id:, item_types:}
+        filters: {product_id:, item_type:}
       )
 
       result.product_items

app/queries/product_items_query.rb

@@ -2,15 +2,15 @@
 
 class ProductItemsQuery < BaseQuery
   Result = BaseResult[:product_items]
-  Filters = BaseFilters[:product_id, :item_types]
+  Filters = BaseFilters[:product_id, :item_type]
 
   def call
     product_items = base_scope.result
     product_items = paginate(product_items)
     product_items = apply_consistent_ordering(product_items)
 
     product_items = with_product(product_items) if filters.product_id.present?
-    product_items = with_item_types(product_items) if filters.item_types.present?
+    product_items = with_item_type(product_items) if filters.item_type.present?
 
     result.product_items = product_items
     result
@@ -36,7 +36,7 @@ def with_product(scope)
     scope.where(product_id: filters.product_id)
   end
 
-  def with_item_types(scope)
-    scope.where(item_type: filters.item_types)
+  def with_item_type(scope)
+    scope.where(item_type: filters.item_type)
   end
 end

schema.graphql

@@ -20,8 +20,8 @@
 
   let(:query) do
     <<~GQL
-      query($searchTerm: String, $itemTypes: [ProductItemTypeEnum!], $productId: ID) {
-        productItems(limit: 5, searchTerm: $searchTerm, itemTypes: $itemTypes, productId: $productId) {
+      query($searchTerm: String, $itemType: ProductItemTypeEnum, $productId: ID) {
+        productItems(limit: 5, searchTerm: $searchTerm, itemType: $itemType, productId: $productId) {
           collection { id name code itemType }
           metadata { currentPage totalCount }
         }
@@ -45,7 +45,7 @@
   end
 
   context "with an item type filter" do
-    let(:variables) { {itemTypes: %w[fixed]} }
+    let(:variables) { {itemType: "fixed"} }
 
     it "returns only matching items" do
       expect(execution["data"]["productItems"]["collection"].map { it["id"] }).to eq([fixed_item.id])

schema.json

@@ -31,10 +31,10 @@
     end
   end
 
-  context "with an item_types filter" do
-    let(:filters) { {item_types: %w[fixed]} }
+  context "with an item_type filter" do
+    let(:filters) { {item_type: "fixed"} }
 
-    it "returns only items of those types" do
+    it "returns only items of that type" do
       expect(result.product_items).to eq([fixed_item])
     end
   end