jsonapi-query_builder 0.1.4.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cfe8817a1796e39ffa45d7ca78ea92fb476b8b114e59f058bf94509996fd72c7
+  data.tar.gz: b321a790c6cb02112b90cb458e498705ed66227506fc76ae8790a04fdb603e54
+SHA512:
+  metadata.gz: 1e418da7f6940422f315202f10bc603a138144787b5e97168a6e40b85719e624d2e862fb460dc4eb754e8890ee55ec53ad2e66a75cc27b1427252f1c8e8fd502
+  data.tar.gz: c6acc4f51df8f314fd2bb650e54160c0c4b549059a16964f8814d103abbd4f0eae1f666f02a59564f9efaf7e960f7e08c21874769bdf0f33ccb86973788f2cff

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+Gemfile.lock
+*.gem

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,8 @@
+require:
+  - rubocop-rspec
+
+RSpec/NestedGroups:
+  Max: 4
+
+AllCops:
+  NewCops: enable

data/.ruby-version

@@ -0,0 +1 @@
+2.6.6

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in jsonapi-query_builder.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Jure Cindro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,164 @@
+# Jsonapi::QueryBuilder
+
+`Jsonapi::QueryBuilder` serves the purpose of adding the json api query related SQL conditions to the already scoped
+collection, usually used in controller index actions. 
+
+With the query builder we can easily define logic for query filters, attributes by which we can sort, and delegate
+pagination parameters to the underlying paginator. Included relationships are automatically included via the
+`ActiveRecord::QueryMethods#includes`, to prevent N+1 query problems.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'jsonapi-query_builder'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install jsonapi-query_builder
+
+## Usage
+
+```ruby
+class UserQuery < Jsonapi::QueryBuilder::BaseQuery
+  ## sorting
+  default_sort created_at: :desc
+  sorts_by :first_name, :last_name, :email
+
+  ## filtering
+  filters_by :first_name
+  filters_by :last_name
+  filters_by :email, ->(collection, query) { collection.where('email ilike ?', "%#{query}%") }
+  filters_by :type, TypeFilter
+  filters_by :mrn, MrnInMemoryFilter
+end
+
+class UsersController < ApplicationController
+  def index
+    user_query = UserQuery.new(User, params.to_unsafe_hash)
+
+    render json: user_query.results, status: :ok
+  end
+end
+```
+
+The query class is initialized using a collection and query parameters. Since query parameters are referenced explicitly
+we can pass them as an unsafe hash. `Jsonapi::QueryBuilder::BaseQuery` should not be responsible for scoping records based on
+current user permissions, or for any other type of scoping. It's only responsibility is to support the `json:api`
+querying. Use `pundit` or similar for policy scoping, custom query objects for other scoping, and then pass the scoped
+collection to the `Jsonapi::QueryBuilder::BaseQuery` object.
+
+### Sorting
+#### Ensuring deterministic results
+Sorting has a fallback to an unique attribute which defaults to the `id` attribute. This ensures deterministic paginated
+collection responses. You can override the `unique_sort_attribute` in the query object.
+```ruby
+# set the unique sort attribute
+unique_sort_attribute :email
+# use compound unique sort attributes
+unique_sort_attributes :created_at, :email
+````
+#### Default sort options
+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.
+```ruby
+default_sort created_at: :desc
+```
+#### Enabling 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 }`
+```ruby
+sorts_by :first_name, :email
+```
+
+### Filtering
+
+#### Simple exact match filters
+```ruby
+filters_by :first_name
+# => collection.where(first_name: params.dig(:filter, :first_name)) if params.dig(:filter, :first_name).present?
+```
+
+#### Lambda as a filter
+```ruby
+filters_by :email, ->(collection, query) { collection.where('email ilike ?', "%#{query}%") }
+# => collection.where('email ilike ?', "%#{params.dig(:filter, :email)}%") if params.dig(:filter, :email).present?
+```
+
+#### 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.
+```ruby
+filters_by :type, TypeFilter
+```
+The filter class could look something like
+```ruby
+class TypeFilter < Jsonapi::QueryBuilder::BaseFilter
+  def results
+    collection.where(type: query.split(','))
+  end
+end
+```
+Sometimes you need to perform in-memory filtering, for example when database attributes are encrypted. In that case,
+those filters should be applied last, the order of definition in the query object matters.
+```ruby
+class MrnFilter < Jsonapi::QueryBuilder::BaseFilter
+  def results
+    collection.select { |record| /#{query}/.match?(record.mrn) }
+  end
+end
+```
+
+#### Additional Options
+You can override the filter query parameter name by passing the `query_parameter` option.
+```ruby
+filters_by :first_name, query_parameter: 'name'
+# => collection.where(first_name: params.dig(:filter, :name)) if params.dig(:filter, :name).present?
+```
+`allow_nil` option changes the filter conditional to allow explicit checks for an attribute null value.
+```ruby
+filters_by :first_name, allow_nil: true
+# => collection.where(first_name: params.dig(:filter, :first_name)) if params[:filter]&.key?(:first_name)
+```
+The conditional when the filter is applied can also be defined explicitly. Note that these options override the
+`allow_nil` option, as the condition if defined explicitly and you should handle `nil` explicitly as well.
+```ruby
+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
+```
+When you're using a filter class you can pass a symbol to the `:if` and `:unless` options which invokes the method on
+the filter class.
+```ruby
+filters_by :type, TypeFilter, if: :correct_type?
+# => type_filter = TypeFilter.new(collection, query); type_filter.results if type_filter.correct_type?
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can
+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).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/infinum/jsonapi-query_builder.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "jsonapi/query_builder"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/jsonapi-query_builder.gemspec

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "jsonapi/query_builder/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "jsonapi-query_builder"
+  spec.version = Jsonapi::QueryBuilder::VERSION
+  spec.authors = ["Jure Cindro"]
+  spec.email = ["jure.cindro@infinum.co"]
+
+  spec.summary = "Support `json:api` querying with ease!"
+  spec.description = <<~MD
+    `Jsonapi::QueryBuilder` serves the purpose of adding the json api query related SQL conditions to the already scoped collection, usually used in controller index actions.
+
+    With the query builder we can easily define logic for query filters, attributes by which we can sort, and delegate pagination parameters to the underlying paginator. Included relationships are automatically included via the `ActiveRecord::QueryMethods#includes`, to prevent N+1 query problems.
+  MD
+  spec.homepage = "https://github.com/infinum/jsonapi-query_builder"
+  spec.license = "MIT"
+
+  if spec.respond_to?(:metadata)
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/infinum/jsonapi-query_builder"
+    spec.metadata["changelog_uri"] = "https://github.com/infinum/jsonapi-query_builder/blob/master/CHANGELOG.md"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = "~> 2.5"
+
+  spec.add_runtime_dependency "activerecord", ">= 5", "<= 6.1"
+  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 "rubocop-rspec"
+  spec.add_development_dependency "lefthook"
+end

data/lefthook.yml

@@ -0,0 +1,36 @@
+lint:
+  commands: &lint
+    lint-frozen-strings:
+      glob: "*.rb"
+      run: bundle exec rubocop {staged_files} --only Style/FrozenStringLiteralComment,Layout/EmptyLineAfterMagicComment --format quiet --auto-correct
+
+rubocop:
+  commands: &rubocop
+    rubocop-rspec:
+      glob: "spec/*"
+      run: bundle exec rubocop {staged_files} --only RSpec --format quiet
+
+pre-commit:
+  parallel: true
+  commands:
+    <<: *lint
+    <<: *rubocop
+    standardrb:
+      glob: "*.rb"
+      run: bundle exec standardrb {staged_files}
+    rspec:
+      glob: "*_spec.rb"
+      run: bundle exec rspec {staged_files} --format failures
+
+post-checkout:
+  commands:
+    bundle-install:
+      run: bundle check || bundle install
+
+pre-push:
+  parallel: true
+  commands:
+    bundler-audit:
+      run: bundle audit --update --quiet
+    rspec:
+      run: bundle exec rspec --format failures

data/lib/jsonapi/query_builder.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "active_support/core_ext/array/conversions"
+require "active_support/core_ext/hash/keys"
+require "active_support/core_ext/string/inflections"
+require "pagy"
+require "pagy/extras/items"
+
+require "jsonapi/query_builder/version"
+require "jsonapi/query_builder/base_query"
+require "jsonapi/query_builder/base_filter"

data/lib/jsonapi/query_builder/base_filter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Jsonapi
+  module QueryBuilder
+    class BaseFilter
+      attr_reader :collection, :query
+
+      def initialize(collection, query)
+        @collection = collection
+        @query = query
+      end
+
+      def results
+        raise NotImplementedError, "#{self.class} should implement #results"
+      end
+    end
+  end
+end

data/lib/jsonapi/query_builder/base_query.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "jsonapi/query_builder/mixins/filtering"
+require "jsonapi/query_builder/mixins/include"
+require "jsonapi/query_builder/mixins/paginate"
+require "jsonapi/query_builder/mixins/sort"
+
+module Jsonapi
+  module QueryBuilder
+    class BaseQuery
+      include Mixins::Filtering
+      include Mixins::Include
+      include Mixins::Paginate
+      include Mixins::Sort
+
+      attr_reader :collection, :params
+
+      def initialize(collection, params)
+        @collection = collection
+        @params = params.deep_symbolize_keys
+      end
+
+      def results
+        collection
+          .yield_self(&method(:sort))
+          .yield_self(&method(:add_includes))
+          .yield_self(&method(:filter))
+          .yield_self(&method(:paginate))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# 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

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Jsonapi
+  module QueryBuilder
+    module Mixins
+      module Include
+        def add_includes(collection, include_params = send(:include_params))
+          collection.includes(formatted_include_params(include_params))
+        end
+
+        private
+
+        def include_params
+          params[:include]
+        end
+
+        def formatted_include_params(include_params)
+          return [] unless include_params
+
+          include_params
+            .split(",")
+            .map(&:strip)
+            .map(&method(:formatted_includes_relationship))
+        end
+
+        def formatted_includes_relationship(relationship)
+          parent, children = relationship.split(".", 2)
+
+          return parent.to_sym unless children
+
+          {parent.to_sym => formatted_includes_relationship(children)}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Jsonapi
+  module QueryBuilder
+    module Mixins
+      module Paginate
+        include Pagy::Backend
+
+        attr_reader :pagination_details
+
+        def paginate(collection, page_params = send(:page_params))
+          @pagination_details, records = pagy collection, page: page_params[:number],
+                                                          items: page_params[:size],
+                                                          outset: page_params[:offset]
+
+          records
+        end
+
+        private
+
+        def page_params
+          {number: 1, **params.fetch(:page, {})}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Jsonapi
+  module QueryBuilder
+    module Mixins
+      module Sort
+        extend ActiveSupport::Concern
+
+        UnpermittedSortParameters = Class.new ArgumentError
+
+        class_methods do
+          attr_reader :_default_sort
+
+          def _unique_sort_attributes
+            @_unique_sort_attributes || [id: :asc]
+          end
+
+          def _sort_attributes
+            @_sort_attributes || []
+          end
+
+          def unique_sort_attributes(*attributes)
+            @_unique_sort_attributes = attributes
+          end
+          alias_method :unique_sort_attribute, :unique_sort_attributes
+
+          def default_sort(options)
+            @_default_sort = options
+          end
+
+          def sorts_by(*attributes)
+            @_sort_attributes = _sort_attributes + attributes
+          end
+        end
+
+        def sort(collection, sort_params = send(:sort_params))
+          collection
+            .reorder(sort_params.nil? ? self.class._default_sort : formatted_sort_params(sort_params))
+            .tap(&method(:add_unique_order_attributes))
+        end
+
+        private
+
+        def sort_params
+          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?
+
+          raise UnpermittedSortParameters, [
+            unpermitted_parameters.to_sentence,
+            unpermitted_parameters.count == 1 ? "is not a" : "are not",
+            "permitted sort attribute".pluralize(unpermitted_parameters.count)
+          ].join(" ")
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/query_builder/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Jsonapi
+  module QueryBuilder
+    VERSION = "0.1.4.pre"
+  end
+end

metadata

@@ -0,0 +1,188 @@
+--- !ruby/object:Gem::Specification
+name: jsonapi-query_builder
+version: !ruby/object:Gem::Version
+  version: 0.1.4.pre
+platform: ruby
+authors:
+- Jure Cindro
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2020-08-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: pagy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: standardrb
+  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
+    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: lefthook
+  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'
+description: |
+  `Jsonapi::QueryBuilder` serves the purpose of adding the json api query related SQL conditions to the already scoped collection, usually used in controller index actions.
+
+  With the query builder we can easily define logic for query filters, attributes by which we can sort, and delegate pagination parameters to the underlying paginator. Included relationships are automatically included via the `ActiveRecord::QueryMethods#includes`, to prevent N+1 query problems.
+email:
+- jure.cindro@infinum.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- jsonapi-query_builder.gemspec
+- lefthook.yml
+- 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/mixins/include.rb
+- lib/jsonapi/query_builder/mixins/paginate.rb
+- lib/jsonapi/query_builder/mixins/sort.rb
+- lib/jsonapi/query_builder/version.rb
+homepage: https://github.com/infinum/jsonapi-query_builder
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/infinum/jsonapi-query_builder
+  source_code_uri: https://github.com/infinum/jsonapi-query_builder
+  changelog_uri: https://github.com/infinum/jsonapi-query_builder/blob/master/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.0.3
+signing_key:
+specification_version: 4
+summary: Support `json:api` querying with ease!
+test_files: []