feat(products): add product item filter API endpoints

Add /api/v1/product_items/:product_item_id/filters CRUD endpoints backed by
the filter services: create with the key/value pairs, update replacing the
value set wholesale (code is immutable and not permitted), show, paginated
index scoped to the parent item, and soft delete.

Author: rsempe

app/controllers/api/v1/product_items/filters_controller.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Api
+  module V1
+    module ProductItems
+      class FiltersController < Api::BaseController
+        before_action :find_product_item
+        before_action :find_product_item_filter, only: %i[show update destroy]
+
+        def index
+          filters = product_item.filters
+            .includes(values: :billable_metric_filter)
+            .page(params[:page])
+            .per(params[:per_page] || PER_PAGE)
+
+          render(
+            json: ::CollectionSerializer.new(
+              filters,
+              ::V1::ProductItemFilterSerializer,
+              collection_name: "filters",
+              meta: pagination_metadata(filters)
+            )
+          )
+        end
+
+        def show
+          render_filter(product_item_filter)
+        end
+
+        def create
+          result = ::ProductItemFilters::CreateService.call(
+            product_item:,
+            params: input_params.to_h.deep_symbolize_keys
+          )
+
+          if result.success?
+            render_filter(result.product_item_filter)
+          else
+            render_error_response(result)
+          end
+        end
+
+        def update
+          result = ::ProductItemFilters::UpdateService.call(
+            product_item_filter:,
+            params: update_params.to_h.deep_symbolize_keys
+          )
+
+          if result.success?
+            render_filter(result.product_item_filter)
+          else
+            render_error_response(result)
+          end
+        end
+
+        def destroy
+          result = ::ProductItemFilters::DestroyService.call(product_item_filter:)
+
+          if result.success?
+            render_filter(result.product_item_filter)
+          else
+            render_error_response(result)
+          end
+        end
+
+        private
+
+        attr_reader :product_item, :product_item_filter
+
+        def find_product_item
+          @product_item = current_organization.product_items.find_by(id: params[:product_item_id])
+
+          not_found_error(resource: "product_item") unless product_item
+        end
+
+        def find_product_item_filter
+          @product_item_filter = product_item.filters.find_by(id: params[:id])
+
+          not_found_error(resource: "product_item_filter") unless product_item_filter
+        end
+
+        def input_params
+          params.require(:filter).permit(
+            :name,
+            :code,
+            :description,
+            :invoice_display_name,
+            values: %i[billable_metric_filter_id value]
+          )
+        end
+
+        def update_params
+          params.require(:filter).permit(
+            :name,
+            :description,
+            :invoice_display_name,
+            values: %i[billable_metric_filter_id value]
+          )
+        end
+
+        def render_filter(filter)
+          render(json: ::V1::ProductItemFilterSerializer.new(filter, root_name: "filter"))
+        end
+
+        def resource_name
+          "product_item"
+        end
+      end
+    end
+  end
+end

app/controllers/api/v1/product_items_controller.rb

@@ -4,7 +4,7 @@ module Api
   module V1
     class ProductItemsController < Api::BaseController
       def create
-        result = ProductItems::CreateService.call(
+        result = ::ProductItems::CreateService.call(
           organization: current_organization,
           params: input_params.to_h.symbolize_keys
         )
@@ -18,7 +18,7 @@ def create
 
       def update
         product_item = current_organization.product_items.find_by(id: params[:id])
-        result = ProductItems::UpdateService.call(product_item:, params: update_params.to_h.symbolize_keys)
+        result = ::ProductItems::UpdateService.call(product_item:, params: update_params.to_h.symbolize_keys)
 
         if result.success?
           render_product_item(result.product_item)
@@ -29,7 +29,7 @@ def update
 
       def destroy
         product_item = current_organization.product_items.find_by(id: params[:id])
-        result = ProductItems::DestroyService.call(product_item:)
+        result = ::ProductItems::DestroyService.call(product_item:)
 
         if result.success?
           render_product_item(result.product_item)
@@ -47,7 +47,7 @@ def show
       end
 
       def index
-        result = ProductItemsQuery.call(
+        result = ::ProductItemsQuery.call(
           organization: current_organization,
           pagination: {
             page: params[:page],

app/controllers/api/v1/products_controller.rb

@@ -4,7 +4,7 @@ module Api
   module V1
     class ProductsController < Api::BaseController
       def create
-        result = Products::CreateService.call(
+        result = ::Products::CreateService.call(
           organization: current_organization,
           params: input_params.to_h.symbolize_keys
         )
@@ -18,7 +18,7 @@ def create
 
       def update
         product = current_organization.products.find_by(code: params[:code])
-        result = Products::UpdateService.call(product:, params: update_params.to_h.symbolize_keys)
+        result = ::Products::UpdateService.call(product:, params: update_params.to_h.symbolize_keys)
 
         if result.success?
           render_product(result.product)
@@ -29,7 +29,7 @@ def update
 
       def destroy
         product = current_organization.products.find_by(code: params[:code])
-        result = Products::DestroyService.call(product:)
+        result = ::Products::DestroyService.call(product:)
 
         if result.success?
           render_product(result.product)
@@ -47,7 +47,7 @@ def show
       end
 
       def index
-        result = ProductsQuery.call(
+        result = ::ProductsQuery.call(
           organization: current_organization,
           pagination: {
             page: params[:page],

config/routes.rb

@@ -165,7 +165,9 @@
           end
         end
       end
-      resources :product_items, only: %i[index show create update destroy]
+      resources :product_items, only: %i[index show create update destroy] do
+        resources :filters, only: %i[index show create update destroy], controller: "product_items/filters"
+      end
       resources :products, param: :code, code: /.*/, only: %i[index show create update destroy]
       resources :taxes, param: :code, code: /.*/
       resources :wallet_transactions, only: %i[create show] do

spec/requests/api/v1/product_items/filters_controller_spec.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Api::V1::ProductItems::FiltersController do
+  let(:organization) { create(:organization) }
+  let(:billable_metric) { create(:billable_metric, organization:) }
+  let(:product_item) { create(:product_item, organization:, billable_metric:) }
+  let(:region_filter) { create(:billable_metric_filter, organization:, billable_metric:, key: "region", values: %w[us eu]) }
+
+  describe "POST /api/v1/product_items/:product_item_id/filters" do
+    subject { post_with_token(organization, "/api/v1/product_items/#{product_item.id}/filters", {filter: create_params}) }
+
+    let(:create_params) do
+      {
+        name: "US",
+        code: "us",
+        values: [{billable_metric_filter_id: region_filter.id, value: "us"}]
+      }
+    end
+
+    include_examples "requires API permission", "product_item", "write"
+
+    it "creates a filter with its values" do
+      subject
+
+      expect(response).to have_http_status(:success)
+      expect(json[:filter][:lago_id]).to be_present
+      expect(json[:filter][:name]).to eq("US")
+      expect(json[:filter][:code]).to eq("us")
+      expect(json[:filter][:values].map { [it[:key], it[:value]] }).to eq([%w[region us]])
+    end
+
+    context "when values are missing" do
+      let(:create_params) { {name: "US", code: "us", values: []} }
+
+      it "returns a validation error" do
+        subject
+
+        expect(response).to have_http_status(:unprocessable_entity)
+      end
+    end
+
+    context "when the product item does not exist" do
+      subject { post_with_token(organization, "/api/v1/product_items/#{SecureRandom.uuid}/filters", {filter: create_params}) }
+
+      it "returns a not found error" do
+        subject
+
+        expect(response).to be_not_found_error("product_item")
+      end
+    end
+  end
+
+  describe "PUT /api/v1/product_items/:product_item_id/filters/:id" do
+    subject do
+      put_with_token(
+        organization,
+        "/api/v1/product_items/#{product_item.id}/filters/#{filter.id}",
+        {filter: update_params}
+      )
+    end
+
+    let(:filter) do
+      record = create(:product_item_filter, organization:, product_item:, name: "Before")
+      create(:product_item_filter_value, organization:, product_item_filter: record, billable_metric_filter: region_filter, value: "us")
+      record
+    end
+
+    let(:update_params) { {name: "After", values: [{billable_metric_filter_id: region_filter.id, value: "eu"}]} }
+
+    include_examples "requires API permission", "product_item", "write"
+
+    it "updates the filter and replaces its values" do
+      subject
+
+      expect(response).to have_http_status(:success)
+      expect(json[:filter][:name]).to eq("After")
+      expect(json[:filter][:values].map { [it[:key], it[:value]] }).to eq([%w[region eu]])
+    end
+
+    context "when the filter does not exist" do
+      subject { put_with_token(organization, "/api/v1/product_items/#{product_item.id}/filters/#{SecureRandom.uuid}", {filter: update_params}) }
+
+      it "returns a not found error" do
+        subject
+
+        expect(response).to be_not_found_error("product_item_filter")
+      end
+    end
+  end
+
+  describe "GET /api/v1/product_items/:product_item_id/filters/:id" do
+    subject { get_with_token(organization, "/api/v1/product_items/#{product_item.id}/filters/#{filter.id}") }
+
+    let(:filter) { create(:product_item_filter, :with_values, organization:, product_item:) }
+
+    include_examples "requires API permission", "product_item", "read"
+
+    it "returns the filter" do
+      subject
+
+      expect(response).to have_http_status(:success)
+      expect(json[:filter][:lago_id]).to eq(filter.id)
+      expect(json[:filter][:values].count).to eq(1)
+    end
+  end
+
+  describe "GET /api/v1/product_items/:product_item_id/filters" do
+    subject { get_with_token(organization, "/api/v1/product_items/#{product_item.id}/filters") }
+
+    before do
+      create(:product_item_filter, organization:, product_item:)
+      create(:product_item_filter, organization:)
+    end
+
+    include_examples "requires API permission", "product_item", "read"
+
+    it "returns only the filters of the product item" do
+      subject
+
+      expect(response).to have_http_status(:success)
+      expect(json[:filters].count).to eq(1)
+      expect(json[:meta][:total_count]).to eq(1)
+    end
+  end
+
+  describe "DELETE /api/v1/product_items/:product_item_id/filters/:id" do
+    subject { delete_with_token(organization, "/api/v1/product_items/#{product_item.id}/filters/#{filter.id}") }
+
+    let(:filter) { create(:product_item_filter, :with_values, organization:, product_item:) }
+
+    include_examples "requires API permission", "product_item", "write"
+
+    it "soft deletes the filter" do
+      subject
+
+      expect(response).to have_http_status(:success)
+      expect(json[:filter][:lago_id]).to eq(filter.id)
+      expect(filter.reload).to be_discarded
+    end
+  end
+end