jsonapi-query_builder 0.1.8 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f89df14f0f1eed338eb90d946c537cd6230fdbcd6ae964368b00d534660f1a8
-  data.tar.gz: dd5d5e405d2d2742d72e2fa3699acf111b4ee73a8a7eab9fd264469fde6affb0
+  metadata.gz: c0bbac3427e5cd55ee1f3528925a7d5f06817bef89e232a668821450a8cbedf0
+  data.tar.gz: 622b993193db4a2644187a99099ed5470380dae1d4f576efccf0465d84a8e7f3
 SHA512:
-  metadata.gz: a0b4d6e6cfadf99f3ba968842d5860f663bd34734992757b59cf7c0c9ce0ecae883775c85d6e98f0fc8c394412ae636c712ccba31440a5eb3bd76372ea69cbd0
-  data.tar.gz: e884df70fc9c0e51489b8be4256ed1192757781b003dd53e1e9a317a3b340a6de910d05289c8e3b3fa9869680873e6405367d9c4b2c929ab34d8f664eedb69c8
+  metadata.gz: 5719e6ab6411803bd98cc6aa06ce8471a19c90f713c4b1c014106338bde1b7d7495bcac4be216349524c92489d5873327ba31cc7d4e99c075249ce6db149a54f
+  data.tar.gz: 6151a1cd285f11ed2f48c7c140442a3f67ba85f656d601d8a5ad4c2c686c973aad0526340a37271194e9400642db951d071d43993f7d37095fc47861ae89daf0

data/.github/workflows/lint.yml

@@ -0,0 +1,31 @@
+name: lint
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  standardrb:
+    runs-on: ubuntu-18.04
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+      - name: standardrb
+        run: bundle exec standardrb
+
+  rubocop-rspec:
+    runs-on: ubuntu-18.04
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+
+      - name: rubocop
+        run: bundle exec rubocop --only RSpec

data/.github/workflows/spec.yml

@@ -0,0 +1,23 @@
+name: spec
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  rake-spec:
+    runs-on: ubuntu-18.04
+    strategy:
+      matrix:
+        ruby: [2.5, 2.6, 2.7, 3.0]
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - name: rake spec
+        run: bundle exec rake spec

data/.rubocop.yml

@@ -4,5 +4,8 @@ require:
 RSpec/NestedGroups:
   Max: 4
 
+RSpec/MultipleMemoizedHelpers:
+  Max: 7
+
 AllCops:
   NewCops: enable

data/.ruby-version

@@ -1 +1 @@
-2.6.6
+3.0.2

data/CHANGELOG.md

@@ -1,6 +1,36 @@
 # Change log
 
+## 0.3.0 (2021-12-07)
+
+### Enhancements
+
+- Add support for proc and object default
+  sorts [a167f90](https://github.com/infinum/jsonapi-query_builder/commit/a167f90ca718fe62c0899520cd4c5c859f89035b)
+
+## 0.2.1 (2021-10-04)
+
+### Bugfixes
+
+- [#22](https://github.com/infinum/jsonapi-query_builder/pull/22): Bump allowed pagy version.
+
+## 0.2.0 (2021-09-29)
+
+### Enhancements
+
+Added support for Kaminari and Keyset pagination strategies in addition to Pagy.
+
+- [#21](https://github.com/infinum/jsonapi-query_builder/pull/21): Extract paginators.
+
+## 0.1.9 (2021-05-07)
+
+### Enhancements
+
+- [#18](https://github.com/infinum/jsonapi-query_builder/pull/18): Remove Ruby `to` version.
+- [#9](https://github.com/infinum/jsonapi-query_builder/pull/9): added github actions
+
 ## 0.1.8 (2021-01-25)
 
+### Enhancements
+
 - [#8](https://github.com/infinum/jsonapi-query_builder/pull/8): add support for ruby 3.0
 

data/Gemfile.lock

@@ -1,39 +1,81 @@
 PATH
   remote: .
   specs:
-    jsonapi-query_builder (0.1.8)
+    jsonapi-query_builder (0.3.0)
       activerecord (>= 5)
-      pagy (~> 3.5)
+      pagy (>= 3.5)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (6.1.1)
-      activesupport (= 6.1.1)
-    activerecord (6.1.1)
-      activemodel (= 6.1.1)
-      activesupport (= 6.1.1)
-    activesupport (6.1.1)
+    actionview (6.1.4.1)
+      activesupport (= 6.1.4.1)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    activemodel (6.1.4.1)
+      activesupport (= 6.1.4.1)
+    activerecord (6.1.4.1)
+      activemodel (= 6.1.4.1)
+      activesupport (= 6.1.4.1)
+    activesupport (6.1.4.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
       tzinfo (~> 2.0)
       zeitwerk (~> 2.3)
-    ast (2.4.1)
-    concurrent-ruby (1.1.7)
+    ast (2.4.2)
+    builder (3.2.4)
+    bundler-audit (0.9.0.1)
+      bundler (>= 1.2.0, < 3)
+      thor (~> 1.0)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.9)
+    crass (1.0.6)
     diff-lcs (1.4.4)
-    i18n (1.8.7)
+    erubi (1.10.0)
+    i18n (1.8.10)
       concurrent-ruby (~> 1.0)
-    lefthook (0.7.2)
-    minitest (5.14.3)
-    pagy (3.10.0)
-    parallel (1.20.1)
-    parser (3.0.0.0)
+    kaminari (1.2.1)
+      activesupport (>= 4.1.0)
+      kaminari-actionview (= 1.2.1)
+      kaminari-activerecord (= 1.2.1)
+      kaminari-core (= 1.2.1)
+    kaminari-actionview (1.2.1)
+      actionview
+      kaminari-core (= 1.2.1)
+    kaminari-activerecord (1.2.1)
+      activerecord
+      kaminari-core (= 1.2.1)
+    kaminari-core (1.2.1)
+    lefthook (0.7.6)
+    loofah (2.12.0)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    method_source (1.0.0)
+    mini_portile2 (2.6.1)
+    minitest (5.14.4)
+    nokogiri (1.12.5)
+      mini_portile2 (~> 2.6.1)
+      racc (~> 1.4)
+    pagy (3.11.0)
+    parallel (1.21.0)
+    parser (3.0.2.0)
       ast (~> 2.4.1)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    racc (1.5.2)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.4.2)
+      loofah (~> 2.3)
     rainbow (3.0.0)
-    rake (13.0.3)
-    regexp_parser (2.0.3)
-    rexml (3.2.4)
+    rake (13.0.6)
+    regexp_parser (2.1.1)
+    rexml (3.2.5)
     rspec (3.10.0)
       rspec-core (~> 3.10.0)
       rspec-expectations (~> 3.10.0)
@@ -43,50 +85,56 @@ GEM
     rspec-expectations (3.10.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.10.0)
-    rspec-mocks (3.10.1)
+    rspec-mocks (3.10.2)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.10.0)
-    rspec-support (3.10.1)
-    rubocop (1.7.0)
+    rspec-support (3.10.2)
+    rubocop (1.20.0)
       parallel (~> 1.10)
-      parser (>= 2.7.1.5)
+      parser (>= 3.0.0.0)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml
-      rubocop-ast (>= 1.2.0, < 2.0)
+      rubocop-ast (>= 1.9.1, < 2.0)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 1.4.0, < 2.0)
-    rubocop-ast (1.4.0)
-      parser (>= 2.7.1.5)
-    rubocop-performance (1.9.2)
-      rubocop (>= 0.90.0, < 2.0)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.12.0)
+      parser (>= 3.0.1.1)
+    rubocop-performance (1.11.5)
+      rubocop (>= 1.7.0, < 2.0)
       rubocop-ast (>= 0.4.0)
-    rubocop-rspec (2.1.0)
-      rubocop (~> 1.0)
-      rubocop-ast (>= 1.1.0)
+    rubocop-rspec (2.5.0)
+      rubocop (~> 1.19)
     ruby-progressbar (1.11.0)
-    standard (0.11.0)
-      rubocop (= 1.7.0)
-      rubocop-performance (= 1.9.2)
+    sqlite3 (1.4.2)
+    standard (1.3.0)
+      rubocop (= 1.20.0)
+      rubocop-performance (= 1.11.5)
     standardrb (1.0.0)
       standard
+    thor (1.1.0)
     tzinfo (2.0.4)
       concurrent-ruby (~> 1.0)
-    unicode-display_width (1.7.0)
+    unicode-display_width (2.1.0)
     zeitwerk (2.4.2)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  activerecord
   bundler (~> 2.0)
+  bundler-audit
   jsonapi-query_builder!
+  kaminari (~> 1.2)
   lefthook
+  pry
   rake (~> 13.0)
   rspec (~> 3.0)
   rubocop-rspec
+  sqlite3
   standard
   standardrb
 
 BUNDLED WITH
-   2.1.4
+   2.2.22

data/README.md

@@ -1,7 +1,7 @@
-# Jsonapi::QueryBuilder
+# Jsonapi::QueryBuilder ![lint](https://github.com/infinum/jsonapi-query_builder/workflows/lint/badge.svg)![spec](https://github.com/infinum/jsonapi-query_builder/workflows/spec/badge.svg)
 
 `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. 
+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
@@ -27,6 +27,9 @@ Or install it yourself as:
 
 ```ruby
 class UserQuery < Jsonapi::QueryBuilder::BaseQuery
+  ## pagination 
+  paginator Jsonapi::QueryBuilder::Paginator::Pagy # default paginator
+
   ## sorting
   default_sort created_at: :desc
   sorts_by :last_name
@@ -51,63 +54,112 @@ 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.
+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.
+
+### Pagination
+
+Pagination support is configurable using the `paginator` method to define the paginator. It defaults to the `Pagy`
+paginator, a lightweight and fast paginator. Other paginators currently supported are `Kaminari` and an implementation
+of keyset pagination. Before using these paginators we need to explicitly require the gems in our Gemfile and the
+paginator file in question. Additionally one can implement it's own paginator by inheriting
+from `Jsonapi::QueryBuilder::Paginator::BasePaginator`. The minimum required implementation is a `#paginate` method that
+receives page params and returns a page of the collection. It can return the pagination details as the second item of
+the returned array, that can be used in the serializer for pagination metadata.
+
+#### Using the Kaminari Paginator
+
+```ruby
+require "jsonapi/query_builder/paginator/kaminari"
+
+paginator Jsonapi::QueryBuilder::Paginator::Kaminari
+```
+
+#### Using the Keyset Paginator
+
+```ruby
+require "jsonapi/query_builder/paginator/keyset"
+
+paginator Jsonapi::QueryBuilder::Paginator::Keyset
+```
 
 ### 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.
+are passed directly to the underlying active record relation, so the usual ordering options are possible. It is also
+possible to define the default sort with a lambda or by passing a sort object.
+
 ```ruby
+default_sort :created_at
+# or
 default_sort created_at: :desc
+# or
+default_sort ->(collection) { collection.order(created_at: :desc) }
+# or
+default_sort SortObject
 ```
+
 #### 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 the order they are given. So `sort=-first_name,email` would translate to
-`{ first_name: :desc, email: :asc }` 
+`{ first_name: :desc, email: :asc }`
+
 ```ruby
 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 
+
+`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.
+
+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
+
 ```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
+
 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
@@ -116,17 +168,23 @@ query objects for ActiveRecord scopes, you can easily use them to filter with as
 ```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) }
@@ -135,26 +193,34 @@ 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?
@@ -176,7 +242,6 @@ version, push git commits and tags, and push the `.gem` file to [rubygems.org](h
 
 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/jsonapi-query_builder.gemspec

@@ -36,16 +36,21 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = [">= 2.5", "<= 3.0"]
+  spec.required_ruby_version = ">= 2.5"
 
   spec.add_runtime_dependency "activerecord", ">= 5"
-  spec.add_runtime_dependency "pagy", "~> 3.5"
+  spec.add_runtime_dependency "pagy", ">= 3.5"
 
   spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "bundler-audit"
   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"
+  spec.add_development_dependency "kaminari", "~> 1.2"
+  spec.add_development_dependency "activerecord"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "pry"
 end

data/lefthook.yml

@@ -2,13 +2,13 @@ lint:
   commands: &lint
     lint-frozen-strings:
       glob: "*.rb"
-      run: bundle exec rubocop {staged_files} --only Style/FrozenStringLiteralComment,Layout/EmptyLineAfterMagicComment --format quiet --auto-correct
+      run: bundle exec rubocop --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
+      run: bundle exec rubocop --only RSpec --format quiet
 
 pre-commit:
   parallel: true

data/lib/jsonapi/query_builder/base_query.rb

@@ -5,6 +5,8 @@ require "jsonapi/query_builder/mixins/include"
 require "jsonapi/query_builder/mixins/paginate"
 require "jsonapi/query_builder/mixins/sort"
 
+require "jsonapi/query_builder/paginator"
+
 module Jsonapi
   module QueryBuilder
     class BaseQuery

data/lib/jsonapi/query_builder/base_sort.rb

@@ -7,7 +7,7 @@ module Jsonapi
 
       # @param [ActiveRecord::Relation] collection
       # @param [Symbol] direction of the ordering, one of :asc or :desc
-      def initialize(collection, direction)
+      def initialize(collection, direction = :asc)
         @collection = collection
         @direction = direction
       end

data/lib/jsonapi/query_builder/errors/unpermitted_sort_parameters.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Jsonapi
+  module QueryBuilder
+    module Errors
+      class UnpermittedSortParameters < ArgumentError
+        def initialize(unpermitted_parameters)
+          super [
+            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/mixins/paginate.rb

@@ -4,7 +4,20 @@ module Jsonapi
   module QueryBuilder
     module Mixins
       module Paginate
-        include Pagy::Backend
+        extend ActiveSupport::Concern
+
+        class_methods do
+          # Sets the paginator used to page the results. Defaults to Pagy
+          #
+          # @param [Jsonapi::QueryBuilder::Paginator::BasePaginator] paginator A subclass of BasePaginator
+          def paginator(paginator)
+            @paginator = paginator
+          end
+
+          def _paginator
+            @paginator || Paginator::Pagy
+          end
+        end
 
         attr_reader :pagination_details
 
@@ -14,9 +27,7 @@ module Jsonapi
         # @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],
-                                                          outset: page_params[:offset]
+          records, @pagination_details = self.class._paginator.new(collection).paginate(page_params)
 
           records
         end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "jsonapi/query_builder/mixins/sort/param"
+require "jsonapi/query_builder/errors/unpermitted_sort_parameters"
 
 module Jsonapi
   module QueryBuilder
@@ -8,8 +9,6 @@ module Jsonapi
       module Sort
         extend ActiveSupport::Concern
 
-        UnpermittedSortParameters = Class.new ArgumentError
-
         class_methods do
           attr_reader :_default_sort
 
@@ -59,7 +58,7 @@ module Jsonapi
         # @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
+        # @raise [Jsonapi::QueryBuilder::Errors::UnpermittedSortParameters] if not all sort parameters are
         #   permitted
         def sort(collection, sort_params = send(:sort_params))
           sort_params = Param.deserialize_params(sort_params)
@@ -80,16 +79,12 @@ module Jsonapi
           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,
-            unpermitted_parameters.count == 1 ? "is not a" : "are not",
-            "permitted sort attribute".pluralize(unpermitted_parameters.count)
-          ].join(" ")
+          raise Errors::UnpermittedSortParameters, unpermitted_parameters
         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?
+          return sort_by_default(collection) if sort_params.blank?
 
           sort_params.reduce(collection) do |sorted_collection, sort_param|
             sort = self.class.supported_sorts.fetch(sort_param.attribute.to_sym)
@@ -102,6 +97,18 @@ module Jsonapi
           end
         end
 
+        def sort_by_default(collection)
+          default_sort = self.class._default_sort
+
+          if default_sort.is_a?(Symbol) || default_sort.is_a?(Hash)
+            collection.order(default_sort)
+          elsif default_sort.respond_to?(:call)
+            default_sort.call(collection)
+          else
+            default_sort.new(collection).results
+          end
+        end
+
         def add_unique_order_attributes(collection)
           collection.order(*self.class._unique_sort_attributes)
         end

data/lib/jsonapi/query_builder/paginator/base_paginator.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Jsonapi
+  module QueryBuilder
+    module Paginator
+      class BasePaginator
+        attr_reader :collection
+
+        # @param [ActiveRecord::Relation] collection
+        def initialize(collection)
+          @collection = collection
+        end
+
+        # @param [Hash] page_params
+        # @return [[ActiveRecord::Relation, Hash]] Records and pagination details
+        def paginate(page_params)
+          raise NotImplementedError, "#{self.class} should implement ##{__method__}"
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/query_builder/paginator/kaminari.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "kaminari"
+
+module Jsonapi
+  module QueryBuilder
+    module Paginator
+      class Kaminari < BasePaginator
+        def paginate(page_params)
+          paged_collection = collection
+            .page(page_params[:number])
+            .per(page_params[:size])
+            .padding(page_params[:offset])
+
+          [paged_collection, pagination_details(paged_collection, page_params)]
+        end
+
+        private
+
+        def pagination_details(collection, page_params)
+          {
+            number: collection.current_page,
+            size: collection.limit_value,
+            offset: page_params[:offset],
+            total: collection.total_count,
+            total_pages: collection.total_pages,
+            next_page: collection.next_page,
+            prev_page: collection.prev_page
+          }
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/query_builder/paginator/keyset.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module Jsonapi
+  module QueryBuilder
+    module Paginator
+      class Keyset < BasePaginator
+        DEFAULT_DIRECTION = :after
+        DEFAULT_LIMIT = 25
+
+        def paginate(page_params)
+          page_params = extract_pagination_params(page_params)
+          records = apply_pagination(collection, page_params)
+
+          [records, page_params]
+        end
+
+        private
+
+        def extract_pagination_params(params)
+          {
+            column: params.fetch(:column, nil),
+            position: params.fetch(:position, nil),
+            direction: params.fetch(:direction, DEFAULT_DIRECTION),
+            limit: params.fetch(:limit, DEFAULT_LIMIT)
+          }
+        end
+
+        def apply_pagination(collection, pagination_params)
+          column = pagination_params[:column]
+          position = pagination_params[:position]
+          direction = pagination_params[:direction]
+          limit = pagination_params[:limit]
+
+          return collection unless column
+
+          collection = apply_order(collection, column, direction)
+          collection = collection.limit(limit.to_i)
+
+          return collection unless position
+
+          apply_filter(collection, column, position, direction)
+        end
+
+        def apply_order(collection, column, direction)
+          if direction.to_sym == DEFAULT_DIRECTION
+            collection.reorder(collection.arel_table[column].asc)
+          else
+            collection.reorder(collection.arel_table[column].desc)
+          end
+        end
+
+        def apply_filter(collection, column, position, direction)
+          if direction.to_sym == DEFAULT_DIRECTION
+            collection.where(collection.arel_table[column].gt(position))
+          else
+            collection.where(collection.arel_table[column].lt(position))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/query_builder/paginator/pagy.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "pagy"
+require "pagy/extras/items"
+
+module Jsonapi
+  module QueryBuilder
+    module Paginator
+      class Pagy < BasePaginator
+        include ::Pagy::Backend
+
+        def paginate(page_params)
+          @params = {page: page_params}
+
+          pagination_details, records = pagy collection, page: page_params[:number],
+                                                         items: page_params[:size],
+                                                         outset: page_params[:offset]
+          [records, pagination_details]
+        end
+
+        private
+
+        attr_reader :params
+      end
+    end
+  end
+end

data/lib/jsonapi/query_builder/paginator.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "jsonapi/query_builder/paginator/base_paginator"
+require "jsonapi/query_builder/paginator/pagy"

data/lib/jsonapi/query_builder/version.rb

@@ -2,6 +2,6 @@
 
 module Jsonapi
   module QueryBuilder
-    VERSION = "0.1.8"
+    VERSION = "0.3.0"
   end
 end

data/lib/jsonapi/query_builder.rb

@@ -4,8 +4,6 @@ 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"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi-query_builder
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.3.0
 platform: ruby
 authors:
 - Jure Cindro
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-25 00:00:00.000000000 Z
+date: 2021-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -28,14 +28,14 @@ dependencies:
   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
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: bundler-audit
+  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: rake
   requirement: !ruby/object:Gem::Requirement
@@ -136,6 +150,62 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: kaminari
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  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: sqlite3
+  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: pry
+  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.
 
@@ -146,6 +216,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/lint.yml"
+- ".github/workflows/spec.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
@@ -164,11 +236,17 @@ files:
 - lib/jsonapi/query_builder/base_filter.rb
 - lib/jsonapi/query_builder/base_query.rb
 - lib/jsonapi/query_builder/base_sort.rb
+- lib/jsonapi/query_builder/errors/unpermitted_sort_parameters.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/paginator.rb
+- lib/jsonapi/query_builder/paginator/base_paginator.rb
+- lib/jsonapi/query_builder/paginator/kaminari.rb
+- lib/jsonapi/query_builder/paginator/keyset.rb
+- lib/jsonapi/query_builder/paginator/pagy.rb
 - lib/jsonapi/query_builder/version.rb
 homepage: https://github.com/infinum/jsonapi-query_builder
 licenses:
@@ -186,16 +264,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ">="
     - !ruby/object:Gem::Version
       version: '2.5'
-  - - "<="
-    - !ruby/object:Gem::Version
-      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: Support `json:api` querying with ease!