jpie 2.1.5 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e03bce6fffc1ed66774e89f660afda17460b6d837b07f549b8c17698d252dccd
-  data.tar.gz: 7a8ea2397e9ebfab913bfd7a4e13cab637b4e7fcc7829e7e16e37da019c5fd3e
+  metadata.gz: 23bcdb19123ced67be175eeeaace99cdfed44f3ce2dcd07134ec9742cf9c1af2
+  data.tar.gz: 38d365327b7991a82512e33dac60dc2649d0bef1ac03fcd5d999519015e72dda
 SHA512:
-  metadata.gz: 27dc32299a441b790c9ae4f3890ad5f12f492d5a2027f1f4a0929923a79cbbaf1b1d78746e29d033c2ee85e4d9bf5c1dae24051d2f447eff5bea50a2a36c28b9
-  data.tar.gz: 7fc2d6613e25d73ec7abaafc7dfe5066c9a7a4b79ea0ffc326964f114a3203909382ee68a62ee507617302309ad7517eb01f92ef4e28f2facd208e9cda769dad
+  metadata.gz: baf7cdcb438c6991aee5ca8b6181f5c4ff7ee84fc920be7777679f4ae00c22c06471860aaa40b3eac34affd82d2c509b8cd481866b37c69dbbca595155bfe2e2
+  data.tar.gz: 832ca3fb1eba8783e4bf006cb5e891650ffe711c19144dd7397aef2fd874eee7e5882e7a981d4e43e17ff666353ccf731b04ae0d1ea6945a52d2418d2d224ac9

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    jpie (2.1.4)
+    jpie (2.1.5)
       actionpack (~> 8.1, >= 8.1.0)
       pg_query (>= 4)
       prosopite (>= 1)

data/lib/json_api/controllers/base_controller.rb

@@ -7,9 +7,14 @@ module JSONAPI
 
     rescue_from JSONAPI::AuthorizationError, with: :render_jsonapi_authorization_error
     rescue_from Pundit::NotAuthorizedError, with: :render_jsonapi_authorization_error if defined?(Pundit)
+    rescue_from JSONAPI::Support::Sort::InvalidFieldError, with: :render_invalid_sort_field_error
 
     private
 
+    def render_invalid_sort_field_error(error)
+      render_sort_errors(error.invalid_fields)
+    end
+
     def render_jsonapi_authorization_error(error)
       detail = error&.message.presence || "You are not authorized to perform this action"
       render json: {

data/lib/json_api/controllers/concerns/controller_helpers/parsing.rb

@@ -110,15 +110,13 @@ module JSONAPI
         params[:page].permit(:number, :size).to_h
       end
 
-      def invalid_sort_fields_for_columns(sorts, available_columns)
-        sorts.filter_map do |sort_field|
-          field = JSONAPI::RelationshipHelpers.extract_sort_field_name(sort_field)
-          field unless available_columns.include?(field.to_s)
-        end
-      end
-
-      def valid_sort_fields_for_resource(resource_class)
-        resource_class.permitted_sortable_fields.map(&:to_s)
+      def render_sort_errors(invalid)
+        render_parameter_errors(
+          invalid,
+          title: "Invalid Sort Field",
+          detail_proc: ->(f) { "Invalid sort field requested: #{f}" },
+          source_proc: ->(_) { { parameter: "sort" } },
+        )
       end
     end
   end

data/lib/json_api/controllers/concerns/relationships/sorting.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "json_api/support/sort_value_comparison"
+require "json_api/support/sort"
 
 module JSONAPI
   module Relationships
@@ -13,99 +13,8 @@ module JSONAPI
         sorts = parse_sort_param
         return related if sorts.empty?
 
-        related_model = association.klass
-        db_sorts, virtual_sorts = partition_sorts_by_type(sorts, related_model)
-
-        related = apply_db_sorts(related, db_sorts)
-        apply_virtual_sorts_if_needed(related, virtual_sorts, related_model)
-      end
-
-      def partition_sorts_by_type(sorts, related_model)
-        sorts.partition do |sort_field|
-          field = RelationshipHelpers.extract_sort_field_name(sort_field)
-          related_model.column_names.include?(field.to_s)
-        end
-      end
-
-      def apply_db_sorts(related, db_sorts)
-        db_sorts.each do |sort_field|
-          direction = RelationshipHelpers.extract_sort_direction(sort_field)
-          field = RelationshipHelpers.extract_sort_field_name(sort_field)
-          related = related.order(field => direction)
-        end
-        related
-      end
-
-      def apply_virtual_sorts_if_needed(related, virtual_sorts, related_model)
-        return related unless virtual_sorts.any?
-
-        resource_class = ResourceLoader.find_for_model(related_model)
-        sort_records_by_virtual_attributes(related.to_a, virtual_sorts, resource_class)
-      end
-
-      def sort_records_by_virtual_attributes(records, virtual_sorts, resource_class)
-        records.sort do |a, b|
-          compare_records(a, b, virtual_sorts, resource_class)
-        end
-      end
-
-      def compare_records(record_a, record_b, virtual_sorts, resource_class)
-        virtual_sorts.each do |sort_field|
-          comparison = compare_by_field(record_a, record_b, sort_field, resource_class)
-          return comparison unless comparison.zero?
-        end
-        0
-      end
-
-      def compare_by_field(record_a, record_b, sort_field, resource_class)
-        direction = RelationshipHelpers.extract_sort_direction(sort_field)
-        field = RelationshipHelpers.extract_sort_field_name(sort_field)
-
-        value_a = get_virtual_value(record_a, field, resource_class)
-        value_b = get_virtual_value(record_b, field, resource_class)
-
-        comparison = compare_values(value_a, value_b)
-        direction == :desc ? -comparison : comparison
-      end
-
-      def get_virtual_value(record, field, resource_class)
-        resource_instance = resource_class.new(record, {})
-        field_sym = field.to_sym
-        return resource_instance.public_send(field_sym) if resource_instance.respond_to?(field_sym, false)
-
-        nil
-      end
-
-      def compare_values(value_a, value_b)
-        JSONAPI::Support::SortValueComparison.compare(value_a, value_b)
-      end
-
-      def validate_sort_param
-        sorts = parse_sort_param
-        return if sorts.empty?
-
-        association = @resource.class.reflect_on_association(@relationship_name)
-        return unless association&.collection?
-
-        validate_sort_fields_for_association(sorts, association)
-      end
-
-      def validate_sort_fields_for_association(sorts, association)
         resource_class = ResourceLoader.find_for_model(association.klass)
-        valid_fields = valid_sort_fields_for_resource(resource_class)
-        invalid_fields = invalid_sort_fields_for_columns(sorts, valid_fields)
-        return if invalid_fields.empty?
-
-        render_invalid_sort_fields(invalid_fields)
-      end
-
-      def render_invalid_sort_fields(invalid_fields)
-        render_parameter_errors(
-          invalid_fields,
-          title: "Invalid Sort Field",
-          detail_proc: ->(field) { "Invalid sort field requested: #{field}" },
-          source_proc: ->(_field) { { parameter: "sort" } },
-        )
+        Support::Sort.new(sort_params: sorts, resource_class:).apply(related)
       end
     end
   end

data/lib/json_api/controllers/concerns/resource_actions/field_validation.rb

@@ -13,15 +13,6 @@ module JSONAPI
         render_field_error(error) if error
       end
 
-      def validate_sort_param
-        sorts = parse_sort_param
-        return if sorts.empty?
-
-        valid = valid_sort_fields_for_resource(@resource_class)
-        invalid = invalid_sort_fields_for_columns(sorts, valid)
-        render_sort_errors(invalid) if invalid.any?
-      end
-
       private
 
       def first_invalid_field(fields)
@@ -61,15 +52,6 @@ module JSONAPI
           source_proc: ->(f) { { parameter: "fields[#{error[:type]}]=#{f}" } },
         )
       end
-
-      def render_sort_errors(invalid)
-        render_parameter_errors(
-          invalid,
-          title: "Invalid Sort Field",
-          detail_proc: ->(f) { "Invalid sort field requested: #{f}" },
-          source_proc: ->(_) { { parameter: "sort" } },
-        )
-      end
     end
   end
 end

data/lib/json_api/controllers/concerns/resource_actions.rb

@@ -29,7 +29,6 @@ module JSONAPI
       before_action :load_jsonapi_resource
       before_action :validate_fields_param, only: %i[index show]
       before_action :validate_filter_param, only: [:index]
-      before_action :validate_sort_param, only: [:index]
       before_action :validate_include_param, only: %i[index show]
       before_action :validate_resource_type!, only: %i[create update]
       before_action :validate_resource_id!, only: [:update]

data/lib/json_api/controllers/relationships_controller.rb

@@ -25,8 +25,6 @@ module JSONAPI
     before_action :set_resource
     before_action :set_relationship_name
     before_action :validate_relationship_exists
-    before_action :validate_sort_param, only: [:show]
-
     def show
       authorize_resource_action!(@resource, action: :show, context: { relationship: @relationship_name })
       render json: build_show_response, status: :ok

data/lib/json_api/resources/concerns/sortable_fields_dsl.rb

@@ -14,22 +14,15 @@ module JSONAPI
 
         def permitted_sortable_fields
           sort_fields = @sortable_fields || []
-          sort_fields = inherited_sort_only_fields + sort_fields if should_inherit_sortable_fields?
-          (permitted_attributes + sort_fields).uniq
+          sort_fields = superclass.permitted_sortable_fields + sort_fields if should_inherit_sortable_fields?
+          sort_fields.uniq
         end
 
         def should_inherit_sortable_fields?
           !instance_variable_defined?(:@sortable_fields) &&
-            !instance_variable_defined?(:@attributes) &&
             superclass != JSONAPI::Resource &&
             superclass.respond_to?(:permitted_sortable_fields)
         end
-
-        def inherited_sort_only_fields
-          parent_sort_fields = superclass.permitted_sortable_fields
-          parent_attributes = superclass.permitted_attributes
-          parent_sort_fields - parent_attributes
-        end
       end
     end
   end

data/lib/json_api/support/collection_query.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "concerns/sorting"
+require_relative "sort"
 require_relative "concerns/regular_filters"
 require_relative "concerns/nested_filters"
 require_relative "concerns/polymorphic_filters"
@@ -9,7 +9,6 @@ require_relative "concerns/pagination"
 
 module JSONAPI
   class CollectionQuery
-    include Support::Sorting
     include Support::RegularFilters
     include Support::NestedFilters
     include Support::PolymorphicFilters
@@ -30,8 +29,9 @@ module JSONAPI
 
     def execute
       @scope = apply_filtering
+      @sort = Support::Sort.new(sort_params:, resource_class: definition)
       compute_total_count_if_needed
-      @scope = apply_sorting(@scope)
+      @scope = @sort.apply(@scope)
       @scope = apply_pagination
       self
     end
@@ -43,8 +43,7 @@ module JSONAPI
     def compute_total_count_if_needed
       return unless pagination_applied
 
-      has_virtual_sort = sort_params.any? { |sort_field| virtual_attribute_sort?(sort_field) }
-      @total_count = @scope.count if !has_virtual_sort || @scope.is_a?(Array)
+      @total_count = @scope.count if !@sort.virtual_fields? || @scope.is_a?(Array)
     end
 
     def apply_filtering

data/lib/json_api/support/relationship_helpers.rb

@@ -17,15 +17,6 @@ module JSONAPI
       TypeConversion.resource_type_name(definition_class)
     end
 
-    # Delegate to SortParsing
-    def extract_sort_field_name(sort_field)
-      SortParsing.extract_sort_field_name(sort_field)
-    end
-
-    def extract_sort_direction(sort_field)
-      SortParsing.extract_sort_direction(sort_field)
-    end
-
     # Delegate to ResourceIdentifier
     # rubocop:disable Lint/UnusedMethodArgument
     def serialize_resource_identifier(

data/lib/json_api/support/sort/compare.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Support
+    class Sort
+      # Compares two values for stable sort ordering. Ruby 3.4+ TrueClass#<=> returns nil
+      # when operands differ (true <=> false), so booleans are normalized before <=>.
+      module Compare
+        module_function
+
+        def compare(value_a, value_b)
+          return 0 if value_a.nil? && value_b.nil?
+          return -1 if value_a.nil?
+          return  1 if value_b.nil?
+
+          comparable(value_a) <=> comparable(value_b) ||
+            raise_incomparable(value_a, value_b)
+        end
+
+        def comparable(value)
+          return value ? 1 : 0 if value in TrueClass | FalseClass
+
+          value
+        end
+
+        def raise_incomparable(value_a, value_b)
+          detail = "#{value_a.class.name} (#{value_a.inspect}), #{value_b.class.name} (#{value_b.inspect})"
+          raise ArgumentError, "incomparable sort values: #{detail}"
+        end
+      end
+    end
+  end
+end

data/lib/json_api/support/sort/field.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Support
+    class Sort
+      class Field
+        class Error < StandardError; end
+
+        attr_reader :name, :direction
+
+        def initialize(model_class, sort_field)
+          @model_class = model_class
+          @name = sort_field.delete_prefix("-")
+          @direction = sort_field.start_with?("-") ? :desc : :asc
+        end
+
+        def virtual? = !(column? || scope?)
+
+        def apply(scope)
+          raise Error, "cannot chain a virtual sort" if virtual?
+
+          if column?
+            scope.order(name => direction)
+          else
+            scope.public_send(name.to_sym, direction)
+          end
+        end
+
+        private
+
+        def column? = @model_class.column_names.include?(name.to_s)
+        def scope?  = @model_class.respond_to?(name.to_sym)
+      end
+    end
+  end
+end

data/lib/json_api/support/sort.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative "sort/field"
+require_relative "sort/compare"
+
+module JSONAPI
+  module Support
+    # Applies sort parameters to a scope, handling database column sorts,
+    # scope-based sorts, and virtual attribute sorts (in-memory).
+    #
+    # Validates sort_params against resource_class.permitted_sortable_fields
+    # eagerly in the constructor. Raises InvalidFieldError if any fields are
+    # not permitted — callers never need to validate separately.
+    #
+    # Virtual sorts (resource instance methods) cannot be applied at the
+    # database level, so they are collected and applied last as an in-memory
+    # sort over the materialised result set. This means virtual sorts always
+    # take precedence over column/scope sorts regardless of the order the
+    # user specified them in.
+    class Sort
+      class InvalidFieldError < JSONAPI::Error
+        attr_reader :invalid_fields
+
+        def initialize(invalid_fields)
+          @invalid_fields = invalid_fields
+          super("Invalid sort fields: #{invalid_fields.join(", ")}")
+        end
+      end
+
+      def initialize(sort_params:, resource_class:)
+        @fields = build_fields(sort_params, resource_class)
+      end
+
+      def apply(scope)
+        return scope if @fields.empty?
+
+        virtual, db = @fields.partition(&:virtual?)
+        scope = db.reduce(scope) { |acc, field| field.apply(acc) }
+        virtual.any? ? apply_virtual_sorting(scope, virtual) : scope
+      end
+
+      def virtual_fields?
+        @fields.any?(&:virtual?)
+      end
+
+      private
+
+      attr_reader :resource_class
+
+      def build_fields(sort_params, resource_class)
+        return [] if sort_params.empty?
+
+        @resource_class = resource_class
+        validate!(sort_params, resource_class)
+        sort_params.map { Field.new(resource_class.model_class, it) }
+      end
+
+      def validate!(sort_params, resource_class)
+        permitted = resource_class.permitted_sortable_fields.map(&:to_s)
+        invalid = sort_params.filter_map do |sort_field|
+          name = sort_field.delete_prefix("-")
+          name unless permitted.include?(name.to_s)
+        end
+        raise InvalidFieldError, invalid if invalid.any?
+      end
+
+      def apply_virtual_sorting(scope, virtual_fields)
+        scope.to_a.sort { |a, b| compare_by_fields(a, b, virtual_fields) }
+      end
+
+      def compare_by_fields(record_a, record_b, fields)
+        fields.each do |field|
+          value_a = virtual_value(record_a, field.name)
+          value_b = virtual_value(record_b, field.name)
+          comparison = Compare.compare(value_a, value_b)
+          next if comparison.zero?
+
+          return field.direction == :desc ? -comparison : comparison
+        end
+        0
+      end
+
+      def virtual_value(record, field_name)
+        instance = resource_class.new(record, {})
+        field_sym = field_name.to_sym
+        instance.respond_to?(field_sym, false) ? instance.public_send(field_sym) : nil
+      end
+    end
+  end
+end

data/lib/json_api/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JSONAPI
-  VERSION = "2.1.5"
+  VERSION = "3.0.0"
 end

data/lib/json_api.rb

@@ -28,7 +28,6 @@ end
 require "json_api/resources/resource"
 require "json_api/resources/resource_loader"
 require "json_api/support/type_conversion"
-require "json_api/support/sort_parsing"
 require "json_api/support/resource_identifier"
 require "json_api/support/relationship_helpers"
 require "json_api/support/param_helpers"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jpie
 version: !ruby/object:Gem::Version
-  version: 2.1.5
+  version: 3.0.0
 platform: ruby
 authors:
 - Emil Kampp
@@ -178,7 +178,6 @@ files:
 - lib/json_api/support/concerns/pagination.rb
 - lib/json_api/support/concerns/polymorphic_filters.rb
 - lib/json_api/support/concerns/regular_filters.rb
-- lib/json_api/support/concerns/sorting.rb
 - lib/json_api/support/correlation_id.rb
 - lib/json_api/support/filter_parsing.rb
 - lib/json_api/support/header_warning_subscriber.rb
@@ -192,8 +191,9 @@ files:
 - lib/json_api/support/relationship_helpers.rb
 - lib/json_api/support/resource_identifier.rb
 - lib/json_api/support/responders.rb
-- lib/json_api/support/sort_parsing.rb
-- lib/json_api/support/sort_value_comparison.rb
+- lib/json_api/support/sort.rb
+- lib/json_api/support/sort/compare.rb
+- lib/json_api/support/sort/field.rb
 - lib/json_api/support/type_conversion.rb
 - lib/json_api/testing.rb
 - lib/json_api/testing/rspec.rb

data/lib/json_api/support/concerns/sorting.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-require "json_api/support/sort_value_comparison"
-
-module JSONAPI
-  module Support
-    module Sorting
-      def apply_sorting(scope)
-        return scope if sort_params.empty?
-
-        has_virtual_sorts = sort_params.any? { |sort_field| virtual_attribute_sort?(sort_field) }
-        has_virtual_sorts ? apply_virtual_sorting(scope) : apply_db_sorting(scope)
-      end
-
-      private
-
-      def apply_virtual_sorting(scope)
-        records = scope.to_a
-        apply_mixed_sorting(records, sort_params)
-      end
-
-      def apply_db_sorting(scope)
-        sort_params.each do |sort_field|
-          direction = RelationshipHelpers.extract_sort_direction(sort_field)
-          field = RelationshipHelpers.extract_sort_field_name(sort_field)
-          scope = scope.order(field => direction)
-        end
-        scope
-      end
-
-      def virtual_attribute_sort?(sort_field)
-        field = RelationshipHelpers.extract_sort_field_name(sort_field)
-        !model_class.column_names.include?(field.to_s)
-      end
-
-      def apply_mixed_sorting(records, all_sorts)
-        records.sort do |a, b|
-          compare_by_sort_criteria(a, b, all_sorts)
-        end
-      end
-
-      def compare_by_sort_criteria(record_a, record_b, all_sorts)
-        all_sorts.each do |sort_field|
-          direction = RelationshipHelpers.extract_sort_direction(sort_field)
-          field = RelationshipHelpers.extract_sort_field_name(sort_field)
-          value_a = fetch_sort_value(record_a, field)
-          value_b = fetch_sort_value(record_b, field)
-          comparison = compare_values(value_a, value_b)
-          next if comparison.zero?
-
-          return direction == :desc ? -comparison : comparison
-        end
-        0
-      end
-
-      def fetch_sort_value(record, field)
-        return fetch_column_value(record, field) if model_class.column_names.include?(field.to_s)
-
-        fetch_virtual_attribute_value(record, field)
-      end
-
-      def fetch_column_value(record, field)
-        return record.public_send(field.to_sym) if record.respond_to?(field.to_sym)
-        return nil unless record.respond_to?(:attributes) && record.attributes.is_a?(Hash)
-
-        record.attributes[field.to_s] || record.attributes[field.to_sym]
-      end
-
-      def fetch_virtual_attribute_value(record, field)
-        definition_instance = definition.new(record, {})
-        fetch_virtual_value(definition_instance, field)
-      end
-
-      def fetch_virtual_value(definition_instance, field)
-        field_sym = field.to_sym
-        return definition_instance.public_send(field_sym) if definition_instance.respond_to?(field_sym, false)
-
-        nil
-      end
-
-      def compare_values(value_a, value_b)
-        SortValueComparison.compare(value_a, value_b)
-      end
-    end
-  end
-end

data/lib/json_api/support/sort_parsing.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module JSONAPI
-  module SortParsing
-    module_function
-
-    def parse_sort_field(sort_field)
-      descending = sort_field.start_with?("-")
-      field = descending ? sort_field[1..] : sort_field
-      { field:, direction: descending ? :desc : :asc }
-    end
-
-    def extract_sort_field_name(sort_field)
-      parse_sort_field(sort_field)[:field]
-    end
-
-    def extract_sort_direction(sort_field)
-      parse_sort_field(sort_field)[:direction]
-    end
-  end
-end

data/lib/json_api/support/sort_value_comparison.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module JSONAPI
-  module Support
-    # Compares two values for stable sort ordering. Ruby 3.4+ TrueClass#<=> returns nil
-    # when operands differ (true <=> false), so booleans are normalized before <=>.
-    module SortValueComparison
-      module_function
-
-      def compare(value_a, value_b)
-        return 0 if value_a.nil? && value_b.nil?
-        return -1 if value_a.nil?
-        return 1 if value_b.nil?
-
-        value_a = value_a ? 1 : 0 if value_a in TrueClass | FalseClass
-        value_b = value_b ? 1 : 0 if value_b in TrueClass | FalseClass
-
-        result = value_a <=> value_b
-        return result unless result.nil?
-
-        detail = "#{value_a.class.name} (#{value_a.inspect}), #{value_b.class.name} (#{value_b.inspect})"
-        raise ArgumentError, "incomparable sort values: #{detail}"
-      end
-    end
-  end
-end