jsonapi-query_builder 0.1.6.pre → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: edcba945298b8eadf8c9eb952ee3fed13ba3c8c822afa15dea5126102b689584
-  data.tar.gz: acb2b63e334270e21874c4985467c29953faa2abda3af6065aac26b0963767af
+  metadata.gz: e613355258e5be273292baacd4b8c8aecba03b29005212749868412857feb678
+  data.tar.gz: 46f0f548604944cb9572b90c44a9e3ca5f15e1f8a47985cb588135f8cade2794
 SHA512:
-  metadata.gz: d80d0e5ac1d07327c1f8737eb5b52439022914238a650ee926175c9f2e3b6f1bf0abecb15812e3e8f8241f8d607a5c2a8b9094169a1ba2e869363a4ecc588a0e
-  data.tar.gz: a17154de4293836988b82af81fef9e2a925f9a153d5ba1ae161178e75ad7b6571a0c5f38b2f0f3b96661f001ec3442191b70cdc85754489ebbd80cee78a4bb21
+  metadata.gz: 58546d6561f997295a4505780acb1ad9ff210bd8f1c1390638283d9af62cb1f4d4e89b69e646a902851a1840590b49ce3480ef42f1fff6861a0b7d92f3f27e80
+  data.tar.gz: 851a87dab11ee9194318f4fc5ea437d842ae561b2d5e10448adf796050cc0abb866a73c16ddde0e4b5f3d9757b583498344137d11ecdeaa793dc101a285af5f7

data/README.md

@@ -29,7 +29,9 @@ Or install it yourself as:
 class UserQuery < Jsonapi::QueryBuilder::BaseQuery
   ## sorting
   default_sort created_at: :desc
-  sorts_by :first_name, :last_name, :email
+  sorts_by :last_name
+  sorts_by :first_name, ->(collection, direction) { collection.order(name: direction) }
+  sorts_by :email, EmailSort
 
   ## filtering
   filters_by :first_name
@@ -71,14 +73,26 @@ are passed directly to the underlying active record relation, so the usual order
 ```ruby
 default_sort created_at: :desc
 ```
-#### Enabling sorting for attributes
+#### Enabling simple sorting for attributes
 `sorts_by` denotes which attributes can be used for sorting. Sorting parameters are usually parsed from the
-`json:api` sort query parameter in order they are given. So `sort=-first_name,email` would translate to 
-`{ first_name: :desc, email: :asc }`
+`json:api` sort query parameter in the order they are given. So `sort=-first_name,email` would translate to
+`{ first_name: :desc, email: :asc }` 
 ```ruby
-sorts_by :first_name, :email
+sorts_by :first_name
+sorts_by :email
+```
+#### Sorting with lambdas
+`sorts_by` also supports passing a lambda to implement a custom order or reorder function. The parameters passed to the 
+lamdba are collection and the direction of the order, which is either `:desc` or `:asc`.
+```ruby
+sorts_by :first_name, ->(collection, direction) { collection.order(name: direction) }
 ```
 
+#### Sorting with sort classes
+But since we're devout followers of the SOLID principles, we can define a sort class that responds to
+`#results` method, which returns the sorted collection. Under the hood the sort class is initialized with
+the current scope and the direction parameter.
+
 ### Filtering
 
 #### Simple exact match filters
@@ -94,10 +108,11 @@ filters_by :email, ->(collection, query) { collection.where('email ilike ?', "%#
 ```
 
 #### Filter classes
-But since we're devout followers of the SOLID principles, we can define a filter class that responds to
-`#results` method, which returns the filtered collection results. Under the hood the filter class is initialized with
-the current scope and the query parameter is passed to the call method. This is great if you're using query objects for
-ActiveRecord scopes, you can easily use them to filter as well.
+We can define a filter class that responds to `#results` method, which returns the filtered collection results. Under
+the hood the filter class is initialized with the current scope and the query parameter. However, if the object responds
+to a `call` method it sends the current scope and the query parameter to that instead. This is great if you're using
+query objects for ActiveRecord scopes, you can easily use them to filter with as well.
+
 ```ruby
 filters_by :type, TypeFilter
 ```
@@ -151,8 +166,8 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the
-version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version,
-push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+version number in `version.rb`, and then run `LEFTHOOK=0 bundle exec rake release`, which will create a git tag for the
+version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 

data/jsonapi-query_builder.gemspec

@@ -38,13 +38,14 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = "~> 2.5"
 
-  spec.add_runtime_dependency "activerecord", ">= 5", "<= 6.1"
+  spec.add_runtime_dependency "activerecord", ">= 5"
   spec.add_runtime_dependency "pagy", "~> 3.5"
 
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "standardrb"
+  spec.add_development_dependency "standard"
   spec.add_development_dependency "rubocop-rspec"
   spec.add_development_dependency "lefthook"
 end

data/lib/jsonapi/query_builder.rb

@@ -10,3 +10,4 @@ require "pagy/extras/items"
 require "jsonapi/query_builder/version"
 require "jsonapi/query_builder/base_query"
 require "jsonapi/query_builder/base_filter"
+require "jsonapi/query_builder/base_sort"

data/lib/jsonapi/query_builder/base_filter.rb

@@ -5,11 +5,14 @@ module Jsonapi
     class BaseFilter
       attr_reader :collection, :query
 
+      # @param [ActiveRecord::Relation] collection
+      # @param [String] query the query value used for filtering
       def initialize(collection, query)
         @collection = collection
         @query = query
       end
 
+      # @return [ActiveRecord::Relation] Collection with the filter applied
       def results
         raise NotImplementedError, "#{self.class} should implement #results"
       end

data/lib/jsonapi/query_builder/base_query.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "jsonapi/query_builder/mixins/filtering"
+require "jsonapi/query_builder/mixins/filter"
 require "jsonapi/query_builder/mixins/include"
 require "jsonapi/query_builder/mixins/paginate"
 require "jsonapi/query_builder/mixins/sort"
@@ -8,34 +8,48 @@ require "jsonapi/query_builder/mixins/sort"
 module Jsonapi
   module QueryBuilder
     class BaseQuery
-      include Mixins::Filtering
+      include Mixins::Filter
       include Mixins::Include
       include Mixins::Paginate
       include Mixins::Sort
 
-      attr_reader :collection, :params
+      attr_accessor :collection, :params
 
+      # @param [ActiveRecord::Relation] collection
+      # @param [Hash] params Json:Api query parameters
       def initialize(collection, params)
         @collection = collection
         @params = params.deep_symbolize_keys
       end
 
+      # @return [ActiveRecord::Relation] A collection with eager loaded relationships based on include params, filtered,
+      #   ordered and lastly, paginated.
+      # @note Pagination details are saved to an instance variable and can be accessed via the #pagination_details attribute reader
       def results
         collection
-          .yield_self(&method(:sort))
           .yield_self(&method(:add_includes))
+          .yield_self(&method(:sort))
           .yield_self(&method(:filter))
           .yield_self(&method(:paginate))
       end
 
+      # @param [integer, string] id
+      # @return [Object]
+      # @raise [ActiveRecord::RecordNotFound] if the record by the id is not found
       def find(id)
         find_by! id: id
       end
 
+      # Finds the record by the id parameter the class is instantiated with
+      # @return (see #find)
+      # @raise (see #find)
       def record
         find_by! id: params[:id]
       end
 
+      # @param [Hash] kwargs Attributes with required values
+      # @return (see #find)
+      # @raise [ActiveRecord::RecordNotFound] if the record by the arguments is not found
       def find_by!(**kwargs)
         add_includes(collection).find_by!(kwargs)
       end

data/lib/jsonapi/query_builder/base_sort.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Jsonapi
+  module QueryBuilder
+    class BaseSort
+      attr_reader :collection, :direction
+
+      # @param [ActiveRecord::Relation] collection
+      # @param [Symbol] direction of the ordering, one of :asc or :desc
+      def initialize(collection, direction)
+        @collection = collection
+        @direction = direction
+      end
+
+      # @return [ActiveRecord::Relation] Collection with order applied
+      def results
+        raise NotImplementedError, "#{self.class} should implement #results"
+      end
+    end
+  end
+end

data/lib/jsonapi/query_builder/mixins/filter.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Jsonapi
+  module QueryBuilder
+    module Mixins
+      module Filter
+        extend ActiveSupport::Concern
+
+        class_methods do
+          def supported_filters
+            @supported_filters || {}
+          end
+
+          # Registers an attribute to filter by. Filters are applied in the order they are registered, if they are
+          # applicable, so in-memory filters should be registered last.
+          #
+          # @param [Symbol] attribute The attribute which can be used to filter by
+          # @param [proc, Class] filter A proc or a filter class, defaults to a simple where(attribute => query)
+          # @param [Hash] options Additional filter options
+          # @option options [Symbol] :query_parameter used to override the filter query parameter name
+          # @option options [Boolean] :allow_nil changes the filter conditional to allow explicit checks for an
+          #   attribute null value
+          # @option options [proc, Symbol] :if Define the conditional for applying the filter. If passed a symbol, a
+          #   method with that name is invoked on the instantiated filter object
+          # @option options [proc, Symbol] :unless Define the conditional for applying the filter. If passed a symbol, a
+          #   method with that name is invoked on the instantiated filter object
+          #
+          # @example Change the query parameter name
+          #   filters_by :first_name, query_parameter: 'name'
+          #   # => collection.where(first_name: params.dig(:filter, :name)) if params.dig(:filter, :name).present?
+          #
+          # @example Allow checks for null values
+          #   filters_by :first_name, allow_nil: true
+          #   # => collection.where(first_name: params.dig(:filter, :first_name)) if params[:filter]&.key?(:first_name)
+          #
+          # @example Change the filter condition
+          #   filters_by :first_name, if: ->(query) { query.length >= 2 }
+          #   # => collection.where(first_name: params.dig(:filter, :first_name)) if params.dig(:filter, :first_name) >= 2
+          #   filters_by :first_name, unless: ->(query) { query.length < 2 }
+          #   # => collection.where(first_name: params.dig(:filter, :first_name)) unless params.dig(:filter, :first_name) < 2
+          #   filters_by :type, TypeFilter, if: :correct_type?
+          #   # => TypeFilter.new(collection, query).yield_self { |filter| filter.results if filter.correct_type? }
+          def filters_by(attribute, filter = nil, **options)
+            filter ||= ->(collection, query) { collection.where(attribute => query) }
+            @supported_filters = {**supported_filters, attribute => [filter, options]}
+          end
+        end
+
+        # Filters the passed relation with the default filter params (parsed from the queries params) or with explicitly
+        # passed filter parameters.
+        # Iterates through registered filters so that the filter application order is settable from the backend side
+        # instead of being dependent on the query order from the clients. If the filter condition for the filter
+        # strategy is met, then the filter is applied to the collection. If the strategy responds to a call method it
+        # calls it with the collection and parameter's parsed sort direction, otherwise it instantiates the filter class
+        # with the collection and the parameter's query value and calls for the results.
+        # @param [ActiveRecord::Relation] collection
+        # @param [Object] filter_params Optional explicit filter params
+        # @return [ActiveRecord::Relation, Array] An AR relation is returned unless filters need to resort to in-memory
+        #   filtering strategy, then an array is returned.
+        def filter(collection, filter_params = send(:filter_params))
+          self.class.supported_filters.reduce(collection) do |filtered_collection, supported_filter|
+            filter, options = serialize_filter(supported_filter, collection: filtered_collection, params: filter_params)
+
+            next filtered_collection unless options[:conditions].all? { |type, condition|
+              check_condition(condition, type, filter: filter, query: options[:query])
+            }
+
+            filter.respond_to?(:call) ? filter.call(filtered_collection, options[:query]) : filter.results
+          end
+        end
+
+        private
+
+        def filter_params
+          params[:filter] || {}
+        end
+
+        def serialize_filter(supported_filter, collection:, params:)
+          attribute, (filter, options) = *supported_filter
+
+          options[:query_parameter] = options[:query_parameter]&.to_sym || attribute
+          options[:query] = params[options[:query_parameter]].presence
+          options[:conditions] = options.slice(:if, :unless).presence ||
+            {if: options[:query].present? || options[:allow_nil] && params.key?(options[:query_parameter])}
+
+          filter = filter.new(collection, options[:query]) unless filter.respond_to?(:call)
+
+          [filter, options]
+        end
+
+        def check_condition(condition, type, **opts)
+          (type == :if) == case condition
+          when Proc
+            condition.call(opts[:query])
+          when Symbol
+            opts[:filter].send(condition)
+          else
+            condition
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/query_builder/mixins/include.rb

@@ -4,6 +4,11 @@ module Jsonapi
   module QueryBuilder
     module Mixins
       module Include
+        # Eager loads the relationships that will be included in the response, based on the Json:Api
+        # include query parameter.
+        # @param [ActiveRecord::Relation] collection
+        # @param [Object] include_params Optional explicit include params
+        # @return [ActiveRecord::Relation] Collection with eager loaded included relations
         def add_includes(collection, include_params = send(:include_params))
           collection.includes(formatted_include_params(include_params))
         end

data/lib/jsonapi/query_builder/mixins/paginate.rb

@@ -8,6 +8,11 @@ module Jsonapi
 
         attr_reader :pagination_details
 
+        # Paginates the collection and returns the requested page. Also sets the pagination details that can be used for
+        # displaying metadata in the Json:Api response.
+        # @param [ActiveRecord::Relation] collection
+        # @param [Object] page_params Optional explicit pagination params
+        # @return [ActiveRecord::Relation] Paged collection
         def paginate(collection, page_params = send(:page_params))
           @pagination_details, records = pagy collection, page: page_params[:number],
                                                           items: page_params[:size],

data/lib/jsonapi/query_builder/mixins/sort.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "jsonapi/query_builder/mixins/sort/param"
+
 module Jsonapi
   module QueryBuilder
     module Mixins
@@ -15,28 +17,57 @@ module Jsonapi
             @_unique_sort_attributes || [id: :asc]
           end
 
-          def _sort_attributes
-            @_sort_attributes || []
+          def supported_sorts
+            @supported_sorts || {}
           end
 
+          # Ensures deterministic ordering. Defaults to :id in ascending direction.
+          # @param [Array<Symbol, String, Hash>] attributes An array of attributes or a hash with the attribute and it's
+          #   order direction.
           def unique_sort_attributes(*attributes)
             @_unique_sort_attributes = attributes
           end
+
           alias_method :unique_sort_attribute, :unique_sort_attributes
 
+          # The :default_sort: can be set to sort by any field like `created_at` timestamp or similar. It is only used
+          # if no sort parameter is set, unlike the `unique_sort_attribute` which is always appended as the last sort
+          # attribute. The parameters are passed directly to the underlying active record relation, so the usual
+          # ordering options are possible.
+          # @param [Symbol, Hash] options A default sort attribute or a Hash with the attribute and it's order direction.
           def default_sort(options)
             @_default_sort = options
           end
 
-          def sorts_by(*attributes)
-            @_sort_attributes = _sort_attributes + attributes
+          # Registers attribute that can be used for sorting. Sorting parameters are usually parsed from the `json:api`
+          # sort query parameter in the order they are given.
+          # @param [Symbol] attribute The "sortable" attribute
+          # @param [proc, Class] sort A proc or a sort class, defaults to a simple order(attribute => direction)
+          def sorts_by(attribute, sort = nil)
+            sort ||= ->(collection, direction) { collection.order(attribute => direction) }
+            @supported_sorts = {**supported_sorts, attribute => sort}
           end
         end
 
+        # Sorts the passed relation with the default sort params (parsed from the queries params) or with explicitly
+        # passed sort parameters.
+        # Parses each sort parameter and looks for the sorting strategy for it, if the strategy responds to a call
+        # method it calls it with the collection and parameter's parsed sort direction, otherwise it instantiates the
+        # sort class with the collection and the parameter's parsed sort direction and calls for the results. Finally it
+        # adds the unique sort attributes to enforce deterministic results. If sort params are blank, it adds the
+        # default sort attributes before setting the unique sort attributes.
+        # @param [ActiveRecord::Relation] collection
+        # @param [Object] sort_params Optional explicit sort params
+        # @return [ActiveRecord::Relation] Sorted relation
+        # @raise [Jsonapi::QueryBuilder::Mixins::Sort::UnpermittedSortParameters] if not all sort parameters are
+        #   permitted
         def sort(collection, sort_params = send(:sort_params))
+          sort_params = Param.deserialize_params(sort_params)
+          ensure_permitted_sort_params!(sort_params) if sort_params
+
           collection
-            .reorder(sort_params.nil? ? self.class._default_sort : formatted_sort_params(sort_params))
-            .tap(&method(:add_unique_order_attributes))
+            .yield_self { |c| add_order_attributes(c, sort_params) }
+            .yield_self(&method(:add_unique_order_attributes))
         end
 
         private
@@ -45,21 +76,9 @@ module Jsonapi
           params[:sort]
         end
 
-        def add_unique_order_attributes(collection)
-          collection.order(*self.class._unique_sort_attributes)
-        end
-
-        def formatted_sort_params(sort_params)
-          sort_params
-            .split(",")
-            .map(&:strip)
-            .to_h { |attribute| attribute.start_with?("-") ? [attribute[1..-1], :desc] : [attribute, :asc] }
-            .symbolize_keys
-            .tap(&method(:ensure_permitted_sort_params!))
-        end
-
         def ensure_permitted_sort_params!(sort_params)
-          return if (unpermitted_parameters = sort_params.keys - self.class._sort_attributes.map(&:to_sym)).size.zero?
+          unpermitted_parameters = sort_params.map(&:attribute).map(&:to_sym) - self.class.supported_sorts.keys
+          return if unpermitted_parameters.size.zero?
 
           raise UnpermittedSortParameters, [
             unpermitted_parameters.to_sentence,
@@ -67,6 +86,25 @@ module Jsonapi
             "permitted sort attribute".pluralize(unpermitted_parameters.count)
           ].join(" ")
         end
+
+        def add_order_attributes(collection, sort_params)
+          return collection if self.class._default_sort.nil? && sort_params.blank?
+          return collection.order(self.class._default_sort) if sort_params.blank?
+
+          sort_params.reduce(collection) do |sorted_collection, sort_param|
+            sort = self.class.supported_sorts.fetch(sort_param.attribute.to_sym)
+
+            if sort.respond_to?(:call)
+              sort.call(sorted_collection, sort_param.direction)
+            else
+              sort.new(sorted_collection, sort_param.direction).results
+            end
+          end
+        end
+
+        def add_unique_order_attributes(collection)
+          collection.order(*self.class._unique_sort_attributes)
+        end
       end
     end
   end

data/lib/jsonapi/query_builder/mixins/sort/param.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Jsonapi
+  module QueryBuilder
+    module Mixins
+      module Sort
+        class Param
+          attr_reader :descending, :attribute
+
+          def initialize(param)
+            @descending, @attribute = deserialize(param)
+          end
+
+          class << self
+            def deserialize_params(sort_params)
+              (sort_params || "").split(",").map(&method(:new))
+            end
+          end
+
+          def deserialize(param)
+            _, descending, attribute = param.strip.match(/^(?<descending>-)?(?<attribute>.*)$/).to_a
+
+            [descending, attribute]
+          end
+
+          def serialize
+            [descending, attribute].compact.join
+          end
+
+          def direction
+            descending.present? ? :desc : :asc
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/query_builder/version.rb

@@ -2,6 +2,6 @@
 
 module Jsonapi
   module QueryBuilder
-    VERSION = "0.1.6.pre"
+    VERSION = "0.1.7"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi-query_builder
 version: !ruby/object:Gem::Version
-  version: 0.1.6.pre
+  version: 0.1.7
 platform: ruby
 authors:
 - Jure Cindro
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-09-01 00:00:00.000000000 Z
+date: 2021-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -17,9 +17,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5'
-    - - "<="
-      - !ruby/object:Gem::Version
-        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -27,9 +24,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5'
-    - - "<="
-      - !ruby/object:Gem::Version
-        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: pagy
   requirement: !ruby/object:Gem::Requirement
@@ -100,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -154,10 +162,12 @@ files:
 - lib/jsonapi/query_builder.rb
 - lib/jsonapi/query_builder/base_filter.rb
 - lib/jsonapi/query_builder/base_query.rb
-- lib/jsonapi/query_builder/mixins/filtering.rb
+- lib/jsonapi/query_builder/base_sort.rb
+- lib/jsonapi/query_builder/mixins/filter.rb
 - lib/jsonapi/query_builder/mixins/include.rb
 - lib/jsonapi/query_builder/mixins/paginate.rb
 - lib/jsonapi/query_builder/mixins/sort.rb
+- lib/jsonapi/query_builder/mixins/sort/param.rb
 - lib/jsonapi/query_builder/version.rb
 homepage: https://github.com/infinum/jsonapi-query_builder
 licenses:
@@ -177,9 +187,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.0.3
 signing_key:

data/lib/jsonapi/query_builder/mixins/filtering.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module Jsonapi
-  module QueryBuilder
-    module Mixins
-      module Filtering
-        extend ActiveSupport::Concern
-
-        class_methods do
-          def supported_filters
-            @supported_filters || {}
-          end
-
-          def filters_by(attribute, filter = nil, **options)
-            filter ||= ->(collection, query) { collection.where(attribute => query) }
-            @supported_filters = {**supported_filters, attribute => [filter, options]}
-          end
-        end
-
-        def filter(collection, filter_params = send(:filter_params))
-          self.class.supported_filters.reduce(collection) do |filtered_collection, supported_filter|
-            filter, options = serialize_filter(supported_filter, collection: filtered_collection, params: filter_params)
-
-            next filtered_collection unless options[:conditions].all? { |type, condition|
-              check_condition(condition, type, filter: filter, query: options[:query])
-            }
-
-            filter.respond_to?(:call) ? filter.call(filtered_collection, options[:query]) : filter.results
-          end
-        end
-
-        private
-
-        def filter_params
-          params[:filter] || {}
-        end
-
-        def serialize_filter(supported_filter, collection:, params:)
-          attribute, (filter, options) = *supported_filter
-
-          options[:query_parameter] = options[:query_parameter]&.to_sym || attribute
-          options[:query] = params[options[:query_parameter]].presence
-          options[:conditions] = options.slice(:if, :unless).presence ||
-            {if: options[:query].present? || options[:allow_nil] && params.key?(options[:query_parameter])}
-
-          filter = filter.new(collection, options[:query]) unless filter.respond_to?(:call)
-
-          [filter, options]
-        end
-
-        def check_condition(condition, type, **opts)
-          (type == :if) == case condition
-          when Proc
-            condition.call(opts[:query])
-          when Symbol
-            opts[:filter].send(condition)
-          else
-            condition
-          end
-        end
-      end
-    end
-  end
-end