jsonapi-query_builder 0.2.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f47ebd86badc968ef8a79333f49ac496c067ad6a26c6563cca0257c1e8cdeba2
-  data.tar.gz: ff874753c9a7ba077bf7876a8a598dd01058a0e2f7a2a982dde2fc579342a5d0
+  metadata.gz: e9ea254260274b96b7d2374e9b1b6940467f86d619b2507abcffc9a592fbd1e6
+  data.tar.gz: 21d0c563ed3593a7ff198b645e92fae84a5fbe144309a71d14c0799c09e21bf6
 SHA512:
-  metadata.gz: fc7168dad1ea652617381662a8e75cadbb132addb9b78d6af052b15b590d3f031fa143a6508e6f2feb52f82ee9f333892551378fa5a969ac5232bb48ca8b0c8e
-  data.tar.gz: 6ead187ee07d7d9db557c2010b3d2c992c01d05c888ad6a777716380fa565fc9aff54fb39db54120131bbb544418f789f53cade618c55db86d2aec3d03c08a61
+  metadata.gz: ec7b08f99bd292f0c33105e22be664f92832efee849785cc4f5da9dab1d9575993b546c10722eafd9d2e8472e4ae6d6bc23d9cff3cb48c9bdf4faa0815a9bbc8
+  data.tar.gz: 30f6711fab7a8be90960417e545dd2bbf7b3778a4997fceab15f56587fad040018f0a9d3f6f4f845c890e7a8ea2985771823160ff18d9e2672f93dbc59cfedf6

data/.github/workflows/lint.yml

@@ -8,7 +8,7 @@ on:
 
 jobs:
   standardrb:
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-24.04
 
     steps:
       - uses: actions/checkout@v2
@@ -19,7 +19,7 @@ jobs:
         run: bundle exec standardrb
 
   rubocop-rspec:
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-24.04
 
     steps:
       - uses: actions/checkout@v2

data/.github/workflows/spec.yml

@@ -8,10 +8,10 @@ on:
 
 jobs:
   rake-spec:
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-24.04
     strategy:
       matrix:
-        ruby: [2.5, 2.6, 2.7, 3.0]
+        ruby: ['3.2', '3.3', '3.4']
 
     steps:
       - uses: actions/checkout@v2

data/.ruby-version

@@ -1 +1 @@
-3.0.2
+3.4.5

data/CHANGELOG.md

@@ -1,20 +1,46 @@
 # Change log
 
+## 0.4.0 (2025-11-03)
+
+### Enhancements
+- Added support for dynamic (prefix-based) sorting [#31](https://github.com/infinum/jsonapi-query_builder/pull/31)
+- Added Pagy countless paginator [#26](https://github.com/infinum/jsonapi-query_builder/pull/26)
+
+### Changes
+- Dropped support for Ruby < 3.2
+- Dropped Rails < 7.2 support
+
+## 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,42 +1,56 @@
 PATH
   remote: .
   specs:
-    jsonapi-query_builder (0.2.1)
-      activerecord (>= 5)
+    jsonapi-query_builder (0.4.0)
+      activerecord (>= 7.2)
       pagy (>= 3.5)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    actionview (6.1.4.1)
-      activesupport (= 6.1.4.1)
+    actionview (8.0.2.1)
+      activesupport (= 8.0.2.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)
+      erubi (~> 1.11)
+      rails-dom-testing (~> 2.2)
+      rails-html-sanitizer (~> 1.6)
+    activemodel (8.0.2.1)
+      activesupport (= 8.0.2.1)
+    activerecord (8.0.2.1)
+      activemodel (= 8.0.2.1)
+      activesupport (= 8.0.2.1)
+      timeout (>= 0.4.0)
+    activesupport (8.0.2.1)
+      base64
+      benchmark (>= 0.3)
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.3.1)
+      connection_pool (>= 2.2.5)
+      drb
       i18n (>= 1.6, < 2)
+      logger (>= 1.4.2)
       minitest (>= 5.1)
-      tzinfo (~> 2.0)
-      zeitwerk (~> 2.3)
+      securerandom (>= 0.3)
+      tzinfo (~> 2.0, >= 2.0.5)
+      uri (>= 0.13.1)
     ast (2.4.2)
+    base64 (0.3.0)
+    benchmark (0.4.1)
+    bigdecimal (3.2.3)
     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)
+    concurrent-ruby (1.3.5)
+    connection_pool (2.5.4)
     crass (1.0.6)
     diff-lcs (1.4.4)
-    erubi (1.10.0)
+    drb (2.2.3)
+    erubi (1.13.1)
     i18n (1.8.10)
       concurrent-ruby (~> 1.0)
+    json (2.13.2)
     kaminari (1.2.1)
       activesupport (>= 4.1.0)
       kaminari-actionview (= 1.2.1)
@@ -49,33 +63,39 @@ GEM
       activerecord
       kaminari-core (= 1.2.1)
     kaminari-core (1.2.1)
+    language_server-protocol (3.17.0.5)
     lefthook (0.7.6)
-    loofah (2.12.0)
+    lint_roller (1.1.0)
+    logger (1.7.0)
+    loofah (2.24.1)
       crass (~> 1.0.2)
-      nokogiri (>= 1.5.9)
+      nokogiri (>= 1.12.0)
     method_source (1.0.0)
-    mini_portile2 (2.6.1)
+    mini_portile2 (2.8.9)
     minitest (5.14.4)
-    nokogiri (1.12.5)
-      mini_portile2 (~> 2.6.1)
+    nokogiri (1.18.9)
+      mini_portile2 (~> 2.8.2)
       racc (~> 1.4)
     pagy (3.11.0)
     parallel (1.21.0)
-    parser (3.0.2.0)
+    parser (3.3.9.0)
       ast (~> 2.4.1)
+      racc
+    prism (1.4.0)
     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)
+    rails-dom-testing (2.3.0)
+      activesupport (>= 5.0.0)
+      minitest
       nokogiri (>= 1.6)
-    rails-html-sanitizer (1.4.2)
-      loofah (~> 2.3)
+    rails-html-sanitizer (1.6.2)
+      loofah (~> 2.21)
+      nokogiri (>= 1.15.7, != 1.16.7, != 1.16.6, != 1.16.5, != 1.16.4, != 1.16.3, != 1.16.2, != 1.16.1, != 1.16.0.rc1, != 1.16.0)
     rainbow (3.0.0)
     rake (13.0.6)
-    regexp_parser (2.1.1)
-    rexml (3.2.5)
+    regexp_parser (2.11.2)
     rspec (3.10.0)
       rspec-core (~> 3.10.0)
       rspec-expectations (~> 3.10.0)
@@ -89,34 +109,52 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.10.0)
     rspec-support (3.10.2)
-    rubocop (1.20.0)
+    rubocop (1.80.2)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
       parallel (~> 1.10)
-      parser (>= 3.0.0.0)
+      parser (>= 3.3.0.2)
       rainbow (>= 2.2.2, < 4.0)
-      regexp_parser (>= 1.8, < 3.0)
-      rexml
-      rubocop-ast (>= 1.9.1, < 2.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.46.0, < 2.0)
       ruby-progressbar (~> 1.7)
-      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)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.46.0)
+      parser (>= 3.3.7.2)
+      prism (~> 1.4)
+    rubocop-performance (1.25.0)
+      lint_roller (~> 1.1)
+      rubocop (>= 1.75.0, < 2.0)
+      rubocop-ast (>= 1.38.0, < 2.0)
     rubocop-rspec (2.5.0)
       rubocop (~> 1.19)
     ruby-progressbar (1.11.0)
-    sqlite3 (1.4.2)
-    standard (1.3.0)
-      rubocop (= 1.20.0)
-      rubocop-performance (= 1.11.5)
+    securerandom (0.4.1)
+    sqlite3 (2.7.3)
+      mini_portile2 (~> 2.8.0)
+    standard (1.51.0)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.80.2)
+      standard-custom (~> 1.0.0)
+      standard-performance (~> 1.8)
+    standard-custom (1.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.50)
+    standard-performance (1.8.0)
+      lint_roller (~> 1.1)
+      rubocop-performance (~> 1.25.0)
     standardrb (1.0.0)
       standard
-    thor (1.1.0)
-    tzinfo (2.0.4)
+    thor (1.4.0)
+    timeout (0.4.3)
+    tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
-    unicode-display_width (2.1.0)
-    zeitwerk (2.4.2)
+    unicode-display_width (3.2.0)
+      unicode-emoji (~> 4.1)
+    unicode-emoji (4.1.0)
+    uri (1.0.4)
 
 PLATFORMS
   ruby
@@ -137,4 +175,4 @@ DEPENDENCIES
   standardrb
 
 BUNDLED WITH
-   2.2.22
+   2.7.2

data/README.md

@@ -1,7 +1,7 @@
 # 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,9 +27,9 @@ Or install it yourself as:
 
 ```ruby
 class UserQuery < Jsonapi::QueryBuilder::BaseQuery
-  ## pagination 
+  ## pagination
   paginator Jsonapi::QueryBuilder::Paginator::Pagy # default paginator
-  
+
   ## sorting
   default_sort created_at: :desc
   sorts_by :last_name
@@ -54,21 +54,23 @@ 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.
+paginator, a lightweight and fast paginator. Other paginators currently supported are `Kaminari`, `PagyCountless` 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"
 
@@ -76,64 +78,128 @@ paginator Jsonapi::QueryBuilder::Paginator::Kaminari
 ```
 
 #### Using the Keyset Paginator
+
 ```ruby
 require "jsonapi/query_builder/paginator/keyset"
 
 paginator Jsonapi::QueryBuilder::Paginator::Keyset
 ```
 
+#### Using the Pagy Countless Paginator
+
+```ruby
+require "jsonapi/query_builder/paginator/pagy_countless"
+
+paginator Jsonapi::QueryBuilder::Paginator::PagyCountless
+```
+
 ### 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.
+
+#### Dynamic sorting (prefix-based)
+
+Sometimes you want to allow sorting by a dynamic subset of attributes that share a common prefix (e.g., JSON/JSONB keys, translated columns, join records). You can register a dynamic sort by attribute prefix using `dynamically_sorts_by`.
+
+- The configured prefix is matched against each parsed sort attribute.
+- The prefix is stripped and only the dynamic part is passed to your sort handler.
+- You can provide either a lambda/proc or a class. The callable receives `(collection, dynamic_attribute, direction)`.
+
+Example with a lambda (PostgreSQL JSONB text value):
+
+```ruby
+# Allows sorting by any key in the `data` column: e.g. sort=-data.name,data.created_at
+dynamically_sorts_by :'data.', ->(collection, attribute, direction) {
+  # attribute is the part after the prefix, e.g. "name" or "created_at"
+  quoted_attribute = ActiveRecord::Base.connection.quote(attribute)
+  collection.order(Arel.sql("(data->>#{quoted_attribute}) #{direction}"))
+}
+```
+
+Example with a sort class (PostgreSQL JSONB text value):
+
+```ruby
+class DataSort < Jsonapi::QueryBuilder::DynamicSort
+  def results
+    quoted_attribute = ActiveRecord::Base.connection.quote(dynamic_attribute)
+    collection.order(Arel.sql("(data->>#{quoted_attribute}) #{direction}"))
+  end
+end
+
+dynamically_sorts_by :'data.', DataSort
+```
 
 ### 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
@@ -142,17 +208,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) }
@@ -161,26 +233,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?
@@ -202,7 +282,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,9 +36,9 @@ 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"
+  spec.required_ruby_version = ">= 3.2"
 
-  spec.add_runtime_dependency "activerecord", ">= 5"
+  spec.add_runtime_dependency "activerecord", ">= 7.2"
   spec.add_runtime_dependency "pagy", ">= 3.5"
 
   spec.add_development_dependency "bundler", "~> 2.0"

data/lefthook.yml

@@ -2,7 +2,7 @@ lint:
   commands: &lint
     lint-frozen-strings:
       glob: "*.rb"
-      run: bundle exec rubocop --only Style/FrozenStringLiteralComment,Layout/EmptyLineAfterMagicComment --format quiet --auto-correct
+      run: bundle exec rubocop --only Style/FrozenStringLiteralComment,Layout/EmptyLineAfterMagicComment --format quiet --autocorrect
 
 rubocop:
   commands: &rubocop
@@ -13,8 +13,7 @@ rubocop:
 pre-commit:
   parallel: true
   commands:
-    <<: *lint
-    <<: *rubocop
+    <<: [*lint, *rubocop]
     standardrb:
       glob: "*.rb"
       run: bundle exec standardrb {staged_files}

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/dynamic_sort.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "jsonapi/query_builder/base_sort"
+
+module Jsonapi
+  module QueryBuilder
+    class DynamicSort < BaseSort
+      attr_reader :dynamic_attribute
+
+      # @param [ActiveRecord::Relation] collection
+      # @param [Symbol] dynamic_attribute, which attribute to dynamically sort by
+      # @param [Symbol] direction of the ordering, one of :asc or :desc
+      def initialize(collection, dynamic_attribute, direction = :asc)
+        super(collection, direction)
+        @dynamic_attribute = dynamic_attribute
+      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/errors/unpermitted_sort_parameters.rb

@@ -5,11 +5,11 @@ module Jsonapi
     module Errors
       class UnpermittedSortParameters < ArgumentError
         def initialize(unpermitted_parameters)
-          super [
+          super([
             unpermitted_parameters.to_sentence,
-            unpermitted_parameters.count == 1 ? "is not a" : "are not",
+            (unpermitted_parameters.count == 1) ? "is not a" : "are not",
             "permitted sort attribute".pluralize(unpermitted_parameters.count)
-          ].join(" ")
+          ].join(" "))
         end
       end
     end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Jsonapi
+  module QueryBuilder
+    module Mixins
+      module Sort
+        class Dynamic
+          attr_reader :attribute_prefix, :sort
+
+          def initialize(attribute_prefix, sort)
+            @attribute_prefix = attribute_prefix.to_s
+            @sort = sort
+          end
+
+          def matches?(sort_attribute)
+            sort_attribute.to_s.start_with?(attribute_prefix)
+          end
+
+          def results(collection, sort_param)
+            dynamic_attribute = sort_param.attribute.delete_prefix(attribute_prefix)
+            if sort.respond_to?(:call)
+              sort.call(collection, dynamic_attribute, sort_param.direction)
+            else
+              sort.new(collection, dynamic_attribute, sort_param.direction).results
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Jsonapi
+  module QueryBuilder
+    module Mixins
+      module Sort
+        class Static
+          attr_reader :attribute, :sort
+
+          def initialize(attribute, sort)
+            @attribute = attribute
+            @sort = sort || ->(collection, direction) { collection.order(attribute => direction) }
+          end
+
+          def results(collection, sort_param)
+            if sort.respond_to?(:call)
+              sort.call(collection, sort_param.direction)
+            else
+              sort.new(collection, sort_param.direction).results
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "jsonapi/query_builder/mixins/sort/param"
+require "jsonapi/query_builder/mixins/sort/static"
+require "jsonapi/query_builder/mixins/sort/dynamic"
 require "jsonapi/query_builder/errors/unpermitted_sort_parameters"
 
 module Jsonapi
@@ -16,8 +18,14 @@ module Jsonapi
             @_unique_sort_attributes || [id: :asc]
           end
 
+          # @return [Hash<Symbol, Jsonapi::QueryBuilder::Mixins::Sort::Static>] Supported sorts
           def supported_sorts
-            @supported_sorts || {}
+            @supported_sorts ||= {}
+          end
+
+          # @return [Array<Jsonapi::QueryBuilder::Mixins::Sort::Dynamic>] Supported dynamic sorts
+          def supported_dynamic_sorts
+            @supported_dynamic_sorts ||= []
           end
 
           # Ensures deterministic ordering. Defaults to :id in ascending direction.
@@ -43,8 +51,14 @@ module Jsonapi
           # @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}
+            supported_sorts[attribute] = Sort::Static.new(attribute, sort)
+          end
+
+          # Registers an attribute prefix that can be dynamically used for sorting. Attribute prefix is stripped from parsed sort parameter and passed to the sort proc or class.
+          # @param [Symbol] attribute_prefix The "sortable" attribute prefix, e.g. `:'data.'` for sorting by `data.name` and `data.created_at`
+          # @param [proc, Class] sort A proc or a sort class, defaults to a simple order(attribute => direction)
+          def dynamically_sorts_by(attribute_prefix, sort)
+            supported_dynamic_sorts << Sort::Dynamic.new(attribute_prefix, sort)
           end
         end
 
@@ -76,7 +90,9 @@ module Jsonapi
         end
 
         def ensure_permitted_sort_params!(sort_params)
-          unpermitted_parameters = sort_params.map(&:attribute).map(&:to_sym) - self.class.supported_sorts.keys
+          unpermitted_parameters = sort_params.map(&:attribute).filter do |attribute|
+            !self.class.supported_sorts.key?(attribute.to_sym) && self.class.supported_dynamic_sorts.none? { |dynamic_sort| dynamic_sort.matches?(attribute) }
+          end
           return if unpermitted_parameters.size.zero?
 
           raise Errors::UnpermittedSortParameters, unpermitted_parameters
@@ -84,16 +100,26 @@ module Jsonapi
 
         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)
-
-            if sort.respond_to?(:call)
-              sort.call(sorted_collection, sort_param.direction)
-            else
-              sort.new(sorted_collection, sort_param.direction).results
+            sort = self.class.supported_sorts.fetch(sort_param.attribute.to_sym) do
+              self.class.supported_dynamic_sorts.find { |dynamic_sort| dynamic_sort.matches?(sort_param.attribute) }
             end
+
+            sort.results(sorted_collection, sort_param)
+          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
 

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

@@ -12,9 +12,8 @@ module Jsonapi
         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]
+          pagination_details, records = pagy(collection, page: page_params[:number], items: page_params[:size], outset: page_params[:offset])
+
           [records, pagination_details]
         end
 

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "pagy"
+require "pagy/extras/items"
+require "pagy/extras/countless"
+
+module Jsonapi
+  module QueryBuilder
+    module Paginator
+      class PagyCountless < BasePaginator
+        include ::Pagy::Backend
+
+        def paginate(page_params)
+          @params = {page: page_params}
+
+          pagination_details, records = pagy_countless(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/version.rb

@@ -2,6 +2,6 @@
 
 module Jsonapi
   module QueryBuilder
-    VERSION = "0.2.1"
+    VERSION = "0.4.0"
   end
 end

data/lib/jsonapi/query_builder.rb

@@ -9,3 +9,4 @@ require "jsonapi/query_builder/version"
 require "jsonapi/query_builder/base_query"
 require "jsonapi/query_builder/base_filter"
 require "jsonapi/query_builder/base_sort"
+require "jsonapi/query_builder/dynamic_sort"

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi-query_builder
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Jure Cindro
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-04 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '7.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '7.2'
 - !ruby/object:Gem::Dependency
   name: pagy
   requirement: !ruby/object:Gem::Requirement
@@ -236,17 +235,21 @@ 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/dynamic_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/dynamic.rb
 - lib/jsonapi/query_builder/mixins/sort/param.rb
+- lib/jsonapi/query_builder/mixins/sort/static.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/paginator/pagy_countless.rb
 - lib/jsonapi/query_builder/version.rb
 homepage: https://github.com/infinum/jsonapi-query_builder
 licenses:
@@ -255,7 +258,6 @@ 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
@@ -263,15 +265,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Support `json:api` querying with ease!
 test_files: []