Merge pull request #336 from chiliburger/add-filter-group

Added filter_group DSL:

Author: wadetandy

lib/graphiti.rb

@@ -142,6 +142,7 @@ def self.setup!
 require "graphiti/scoping/paginate"
 require "graphiti/scoping/extra_attributes"
 require "graphiti/scoping/filterable"
+require "graphiti/scoping/filter_group_validator"
 require "graphiti/scoping/default_filter"
 require "graphiti/scoping/filter"
 require "graphiti/stats/dsl"

lib/graphiti/errors.rb

@@ -816,5 +816,34 @@ def message
 
     class ConflictRequest < InvalidRequest
     end
+
+    class FilterGroupInvalidRequirement < Base
+      def initialize(resource, valid_required_values)
+        @resource = resource
+        @valid_required_values = valid_required_values
+      end
+
+      def message
+        <<-MSG.gsub(/\s+/, " ").strip
+          The filter group required: value on resource #{@resource.class} must be one of the following:
+          #{@valid_required_values.join(", ")}
+        MSG
+      end
+    end
+
+    class FilterGroupMissingRequiredFilters < Base
+      def initialize(resource, filter_names, required)
+        @resource = resource
+        @filter_names = filter_names
+        @required_label = required == :all ? "All" : "One"
+      end
+
+      def message
+        <<-MSG.gsub(/\s+/, " ").strip
+          #{@required_label} of the following filters must be provided on resource #{@resource.type}:
+          #{@filter_names.join(", ")}
+        MSG
+      end
+    end
   end
 end

lib/graphiti/resource/configuration.rb

@@ -199,6 +199,7 @@ def config
           @config ||=
             {
               filters: {},
+              grouped_filters: {},
               default_filters: {},
               stats: {},
               sort_all: nil,
@@ -235,6 +236,10 @@ def filters
           config[:filters]
         end
 
+        def grouped_filters
+          config[:grouped_filters]
+        end
+
         def sorts
           config[:sorts]
         end
@@ -273,6 +278,10 @@ def filters
         self.class.filters
       end
 
+      def grouped_filters
+        self.class.grouped_filters
+      end
+
       def sort_all
         self.class.sort_all
       end

lib/graphiti/resource/dsl.rb

@@ -44,6 +44,17 @@ def filter(name, *args, &blk)
           end
         end
 
+        def filter_group(filter_names, *args)
+          opts = args.extract_options!
+
+          Scoping::FilterGroupValidator.raise_unless_filter_group_requirement_valid!(self, opts[:required])
+
+          config[:grouped_filters] = {
+            names: filter_names,
+            required: opts[:required]
+          }
+        end
+
         def sort_all(&blk)
           if block_given?
             config[:_sort_all] = blk

lib/graphiti/scoping/filter.rb

@@ -3,6 +3,11 @@ class Scoping::Filter < Scoping::Base
     include Scoping::Filterable
 
     def apply
+      Graphiti::Scoping::FilterGroupValidator.new(
+        resource,
+        query_hash
+      ).raise_unless_filter_group_requirements_met!
+
       if missing_required_filters.any? && !@opts[:bypass_required_filters]
         raise Errors::RequiredFilter.new(resource, missing_required_filters)
       end

lib/graphiti/scoping/filter_group_validator.rb

@@ -0,0 +1,78 @@
+module Graphiti
+  class Scoping::FilterGroupValidator
+    VALID_REQUIRED_VALUES = %i[all any]
+
+    def self.raise_unless_filter_group_requirement_valid!(resource, requirement)
+      unless VALID_REQUIRED_VALUES.include?(requirement)
+        raise Errors::FilterGroupInvalidRequirement.new(
+          resource,
+          VALID_REQUIRED_VALUES
+        )
+      end
+
+      true
+    end
+
+    def initialize(resource, query_hash)
+      @resource = resource
+      @query_hash = query_hash
+    end
+
+    def raise_unless_filter_group_requirements_met!
+      return if grouped_filters.empty?
+
+      case filter_group_requirement
+      when :all
+        raise_unless_all_requirements_met!
+      when :any
+        raise_unless_any_requirements_met!
+      end
+
+      true
+    end
+
+    private
+
+    attr_reader :resource, :query_hash
+
+    def raise_unless_all_requirements_met!
+      met = filter_group_names.all? { |filter_name| filter_group_filter_param.key?(filter_name) }
+
+      unless met
+        raise Errors::FilterGroupMissingRequiredFilters.new(
+          resource,
+          filter_group_names,
+          filter_group_requirement
+        )
+      end
+    end
+
+    def raise_unless_any_requirements_met!
+      met = filter_group_names.any? { |filter_name| filter_group_filter_param.key?(filter_name) }
+
+      unless met
+        raise Errors::FilterGroupMissingRequiredFilters.new(
+          resource,
+          filter_group_names,
+          filter_group_requirement
+        )
+      end
+    end
+
+    def filter_group_names
+      grouped_filters.fetch(:names, [])
+    end
+
+    def filter_group_requirement
+      grouped_filters.fetch(:required, :invalid)
+    end
+
+    def grouped_filters
+      resource.grouped_filters
+    end
+
+    def filter_group_filter_param
+      query_hash.fetch(:filter, {})
+    end
+  end
+end

lib/graphiti/version.rb

@@ -1,3 +1,3 @@
 module Graphiti
-  VERSION = "1.2.33"
+  VERSION = "1.2.34"
 end

spec/filter_group_validator_spec.rb

@@ -0,0 +1,129 @@
+require "spec_helper"
+
+RSpec.describe Graphiti::Scoping::FilterGroupValidator do
+  let(:resource) { double(:resource, type: :employees) }
+  let(:query_hash) { {} }
+  let(:validator) { described_class.new(resource, query_hash) }
+
+  describe ".raise_unless_filter_group_requirement_valid!" do
+    subject { described_class.raise_unless_filter_group_requirement_valid!(resource, required) }
+
+    context "when required invalid" do
+      let(:required) { :invalid }
+
+      it "raises an error" do
+        expect {
+          subject
+        }.to raise_error(/The filter group required: value on resource .+ must be one of the following:/)
+      end
+    end
+
+    context "when required valid" do
+      let(:required) { :all }
+
+      it "works" do
+        expect(subject).to be true
+      end
+    end
+  end
+
+  describe "#raise_unless_filter_group_requirements_met!" do
+    subject { validator.raise_unless_filter_group_requirements_met! }
+
+    before do
+      allow(resource).to receive(:grouped_filters).and_return(grouped_filters)
+    end
+
+    context "when all are required" do
+      let(:grouped_filters) do
+        {
+          names: [:first_name, :last_name],
+          required: :all
+        }
+      end
+
+      context "when all are not given in the request" do
+        let(:query_hash) do
+          {
+            filter: {
+              first_name: {}
+            }
+          }
+        end
+
+        it "raises an error" do
+          expect {
+            subject
+          }.to raise_error(/All of the following filters must be provided on resource/)
+        end
+      end
+
+      context "when all are given in the request" do
+        let(:query_hash) do
+          {
+            filter: {
+              first_name: {},
+              last_name: {}
+            }
+          }
+        end
+
+        it "works" do
+          expect(subject).to be true
+        end
+      end
+    end
+
+    context "when any are required" do
+      let(:grouped_filters) do
+        {
+          names: [:first_name, :last_name],
+          required: :any
+        }
+      end
+
+      context "when none are given in the request" do
+        let(:query_hash) do
+          {
+            filter: {}
+          }
+        end
+
+        it "raises an error" do
+          expect {
+            subject
+          }.to raise_error(/One of the following filters must be provided on resource/)
+        end
+      end
+
+      context "when one is given in the request" do
+        let(:query_hash) do
+          {
+            filter: {
+              last_name: {}
+            }
+          }
+        end
+
+        it "works" do
+          expect(subject).to be true
+        end
+      end
+
+      context "when all are given in the request" do
+        let(:query_hash) do
+          {
+            filter: {
+              first_name: {},
+              last_name: {}
+            }
+          }
+        end
+
+        it "works" do
+          expect(subject).to be true
+        end
+      end
+    end
+  end
+end

spec/filtering_spec.rb

@@ -1783,4 +1783,82 @@ def after_filtering(scope)
       expect(records.map(&:id)).to eq([employee2.id])
     end
   end
+
+  context "with filter group" do
+    context "when required invalid" do
+      it "raises an error" do
+        expect {
+          resource.filter_group [:first_name, :last_name], required: :foo
+        }.to raise_error(/The filter group required: value on resource .+ must be one of the following:/)
+      end
+    end
+
+    context "when all are required" do
+      before do
+        resource.filter_group [:first_name, :last_name], required: :all
+      end
+
+      context "when all are not given in the request" do
+        before do
+          params[:filter] = {first_name: "Agatha"}
+        end
+
+        it "raises an error" do
+          expect {
+            records
+          }.to raise_error(/All of the following filters must be provided on resource/)
+        end
+      end
+
+      context "when all are given in the request" do
+        before do
+          params[:filter] = {
+            first_name: "Agatha",
+            last_name: "Christie"
+          }
+        end
+
+        it "works" do
+          expect(records.map(&:id)).to eq([employee2.id])
+        end
+      end
+    end
+
+    context "when any are required" do
+      before do
+        resource.filter_group [:first_name, :last_name], required: :any
+      end
+
+      context "when none are given in the request" do
+        it "raises an error" do
+          expect {
+            records
+          }.to raise_error(/One of the following filters must be provided on resource/)
+        end
+      end
+
+      context "when one is given in the request" do
+        before do
+          params[:filter] = {last_name: "Christie"}
+        end
+
+        it "works" do
+          expect(records.map(&:id)).to eq([employee2.id])
+        end
+      end
+
+      context "when all are given in the request" do
+        before do
+          params[:filter] = {
+            first_name: "Agatha",
+            last_name: "Christie"
+          }
+        end
+
+        it "works" do
+          expect(records.map(&:id)).to eq([employee2.id])
+        end
+      end
+    end
+  end
 end