jpie 1.0.0 → 1.0.1

data/lib/json_api/support/active_storage_support.rb

@@ -17,19 +17,16 @@ module JSONAPI
     end
 
     def active_storage_attachment?(association_name, model_class = nil)
-      return self.class.active_storage_attachment?(association_name, model_class) if model_class
-
-      resolved_model_class = if respond_to?(:model_class, true)
-                               send(:model_class)
-                             elsif respond_to?(:resource_model_class, true)
-                               send(:resource_model_class)
-                             elsif respond_to?(:resource, true) && (res = send(:resource)) && res.respond_to?(:class)
-                               res.class
-                             else
-                               raise NotImplementedError,
-                                     "Must implement resource_model_class or provide model_class parameter"
-                             end
-      self.class.active_storage_attachment?(association_name, resolved_model_class)
+      resolved = model_class || resolve_model_class_for_attachment
+      self.class.active_storage_attachment?(association_name, resolved)
+    end
+
+    def resolve_model_class_for_attachment
+      return send(:model_class) if respond_to?(:model_class, true)
+      return send(:resource_model_class) if respond_to?(:resource_model_class, true)
+      return send(:resource).class if respond_to?(:resource, true) && send(:resource).respond_to?(:class)
+
+      raise NotImplementedError, "Must implement resource_model_class or provide model_class parameter"
     end
 
     def extract_active_storage_params_from_hash(params_hash, model_class)

data/lib/json_api/support/collection_query.rb

@@ -1,7 +1,21 @@
 # frozen_string_literal: true
 
+require_relative "concerns/sorting"
+require_relative "concerns/regular_filters"
+require_relative "concerns/nested_filters"
+require_relative "concerns/polymorphic_filters"
+require_relative "concerns/condition_building"
+require_relative "concerns/pagination"
+
 module JSONAPI
   class CollectionQuery
+    include Support::Sorting
+    include Support::RegularFilters
+    include Support::NestedFilters
+    include Support::PolymorphicFilters
+    include Support::ConditionBuilding
+    include Support::Pagination
+
     attr_reader :scope, :total_count, :pagination_applied
 
     def initialize(scope, definition:, model_class:, filter_params:, sort_params:, page_params:)
@@ -15,23 +29,12 @@ module JSONAPI
     end
 
     def execute
-      # Apply filtering
       @scope = apply_filtering
-
-      # Get total count before sorting (for virtual attributes, we need to load records)
-      # If we have virtual attribute sorting, we'll recalculate after sorting
       has_virtual_sort = sort_params.any? { |sort_field| virtual_attribute_sort?(sort_field) }
       @total_count = @scope.count unless has_virtual_sort
-
-      # Apply sorting (may convert scope to array if virtual attributes are involved)
       @scope = apply_sorting(@scope)
-
-      # Recalculate total count if we converted to array for virtual sorting
       @total_count = @scope.count if has_virtual_sort && @scope.is_a?(Array)
-
-      # Apply pagination
       @scope = apply_pagination
-
       self
     end
 
@@ -40,367 +43,8 @@ module JSONAPI
     attr_reader :definition, :model_class, :filter_params, :sort_params, :page_params
 
     def apply_filtering
-      # Apply nested relationship filters first (they require joins)
       scope = apply_nested_relationship_filters(@scope)
-
-      # Then apply regular filters (column-aware operators or model scopes)
       apply_regular_filters(scope)
     end
-
-    def apply_sorting(scope)
-      return scope if sort_params.empty?
-
-      # Check if any sort fields are virtual attributes
-      has_virtual_sorts = sort_params.any? { |sort_field| virtual_attribute_sort?(sort_field) }
-
-      if has_virtual_sorts
-        # Convert to array and sort by all fields (both DB and virtual) in Ruby
-        records = scope.to_a
-        records = apply_mixed_sorting(records, sort_params)
-        scope = records
-      else
-        # All sorts are database columns - use ActiveRecord ordering
-        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
-      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)
-
-        # Get values - use DB column if available, otherwise use definition getter
-        value_a = fetch_sort_value(record_a, field)
-        value_b = fetch_sort_value(record_b, field)
-
-        # Compare values
-        comparison = compare_values(value_a, value_b)
-        next if comparison.zero? # Equal, check next sort field
-
-        # Apply direction
-        return direction == :desc ? -comparison : comparison
-      end
-
-      0 # All fields equal
-    end
-
-    def fetch_sort_value(record, field)
-      # Try database column first
-      if model_class.column_names.include?(field.to_s)
-        # Use public_send to get the attribute value (handles both string and symbol access)
-        if record.respond_to?(field.to_sym)
-          record.public_send(field.to_sym)
-        elsif record.respond_to?(:attributes) && record.attributes.is_a?(Hash)
-          record.attributes[field.to_s] || record.attributes[field.to_sym]
-        end
-      else
-        # Use definition getter for virtual attributes
-        definition_instance = definition.new(record, {})
-        fetch_virtual_value(definition_instance, field)
-      end
-    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)
-      # Handle nil values
-      return 0 if value_a.nil? && value_b.nil?
-      return -1 if value_a.nil?
-      return 1 if value_b.nil?
-
-      # Compare using standard Ruby comparison
-      value_a <=> value_b
-    end
-
-    def apply_regular_filters(scope)
-      return scope if filter_params.empty?
-
-      # Exclude nested relationship filters (already applied)
-      regular_filters = filter_params.reject { |k, _v| k.to_s.include?(".") }
-      return scope if regular_filters.empty?
-
-      regular_filters.reduce(scope) do |current_scope, (filter_name, filter_value)|
-        apply_regular_filter(current_scope, filter_name.to_s, filter_value)
-      end
-    end
-
-    def apply_regular_filter(scope, filter_name, filter_value)
-      return scope if filter_value.respond_to?(:empty?) ? filter_value.empty? : filter_value.nil?
-
-      column_filter = parse_column_filter(filter_name)
-      if column_filter
-        apply_column_filter(scope, column_filter, filter_value)
-      else
-        apply_scope_fallback(scope, filter_name, filter_value)
-      end
-    end
-
-    def parse_column_filter(filter_name)
-      match = filter_name.match(/\A(.+)_(eq|match|lt|lte|gt|gte)\z/)
-      return nil unless match
-
-      column_name = match[1]
-      operator = match[2].to_sym
-
-      { column: column_name, operator: }
-    end
-
-    def apply_column_filter(scope, column_filter, raw_value)
-      column_name = column_filter[:column]
-      operator = column_filter[:operator]
-
-      column = model_class.column_for_attribute(column_name)
-      return scope unless column
-
-      value = normalize_filter_value(column, raw_value)
-      return scope if value.nil?
-
-      condition = build_condition(column, value, operator)
-      return scope unless condition
-
-      apply_condition(scope, condition)
-    rescue ArgumentError, TypeError, StandardError => e
-      # If casting fails or any other error occurs, skip filter
-      Rails.logger.warn("Filter error for #{column_filter[:column]}_#{operator}: #{e.class} - #{e.message}") if defined?(Rails.logger)
-      scope
-    end
-
-    def normalize_filter_value(column, raw_value)
-      value = raw_value.is_a?(Array) ? raw_value.first : raw_value
-      return nil if value.nil?
-
-      type = model_class.type_for_attribute(column.name)
-      type.cast(value)
-    end
-
-    def build_condition(column, value, operator)
-      attr = model_class.arel_table[column.name]
-
-      case operator
-      when :eq
-        attr.eq(value)
-      when :lt
-        attr.lt(value)
-      when :lte
-        attr.lteq(value)
-      when :gt
-        attr.gt(value)
-      when :gte
-        attr.gteq(value)
-      when :match
-        pattern = "%#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}%"
-        lower_attr = Arel::Nodes::NamedFunction.new("LOWER", [attr])
-        lower_attr.matches(pattern.downcase)
-      end
-    end
-
-    def normalize_filter_value_for_model(model, column, raw_value)
-      return nil unless column
-
-      value = raw_value.is_a?(Array) ? raw_value.first : raw_value
-      return nil if value.nil?
-
-      type = model.type_for_attribute(column.name)
-      type.cast(value)
-    end
-
-    def build_condition_for_model(model, column, value, operator)
-      attr = model.arel_table[column.name]
-
-      case operator
-      when :eq
-        attr.eq(value)
-      when :lt
-        attr.lt(value)
-      when :lte
-        attr.lteq(value)
-      when :gt
-        attr.gt(value)
-      when :gte
-        attr.gteq(value)
-      when :match
-        pattern = "%#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}%"
-        lower_attr = Arel::Nodes::NamedFunction.new("LOWER", [attr])
-        lower_attr.matches(pattern.downcase)
-      end
-    end
-
-    def apply_condition(scope, condition)
-      scope.where(condition)
-    end
-
-    def apply_scope_fallback(scope, filter_name, filter_value)
-      return scope unless model_class.respond_to?(filter_name.to_sym)
-
-      scope.public_send(filter_name.to_sym, filter_value)
-    rescue ArgumentError, NoMethodError
-      scope
-    end
-
-    def apply_nested_relationship_filters(scope)
-      return scope if filter_params.empty?
-
-      nested_filters = filter_params.select { |k, _v| k.to_s.include?(".") }
-      return scope if nested_filters.empty?
-
-      nested_filters.reduce(scope) do |current_scope, (filter_name, filter_value)|
-        apply_filter_for_path(current_scope, filter_name.to_s, filter_value)
-      end
-    end
-
-    def apply_filter_for_path(scope, filter_name, filter_value)
-      parts = filter_name.split(".")
-      return scope if parts.length < 2
-
-      relationship_chain = parts[0..-2]
-      leaf_filter = parts.last
-
-      current_model = model_class
-      current_definition = definition
-
-      relationship_chain.each do |relationship_name|
-        association = current_model.reflect_on_association(relationship_name.to_sym)
-        return scope unless association
-
-        if association.polymorphic?
-          attributes = { leaf_filter => filter_value }
-          return apply_polymorphic_nested_filters(scope, association, relationship_name, attributes)
-        end
-
-        current_model = association.klass
-        current_definition = JSONAPI::Resource.resource_for_model(current_model)
-        return scope unless current_definition
-      end
-
-      join_hash = build_join_hash_for_chain(relationship_chain)
-      scope = scope.joins(join_hash) if join_hash.present?
-
-      apply_filter_on_model(scope, current_model, current_definition, leaf_filter, filter_value)
-    end
-
-    def build_join_hash_for_chain(chain)
-      return nil if chain.empty?
-
-      chain.reverse.reduce(nil) do |acc, name|
-        if acc.nil?
-          name.to_sym
-        else
-          { name.to_sym => acc }
-        end
-      end
-    end
-
-    def apply_filter_on_model(scope, target_model, target_resource, filter_name, filter_value)
-      return scope if filter_value.respond_to?(:empty?) ? filter_value.empty? : filter_value.nil?
-
-      column_filter = parse_column_filter(filter_name)
-      if column_filter
-        column = target_model.column_for_attribute(column_filter[:column])
-        if column
-          value = normalize_filter_value_for_model(target_model, column, filter_value)
-          condition = build_condition_for_model(target_model, column, value, column_filter[:operator]) if value
-          return apply_condition(scope, condition) if condition
-        end
-      end
-
-      if target_model.column_names.include?(filter_name)
-        table_name = target_model.table_name
-        return scope.where(table_name => { filter_name => filter_value })
-      end
-
-      if target_model.respond_to?(filter_name.to_sym)
-        begin
-          return scope.merge(target_model.public_send(filter_name.to_sym, filter_value))
-        rescue ArgumentError, NoMethodError
-          # Fall through to return scope
-        end
-      end
-
-      if target_resource &&
-         target_resource.permitted_filters.map(&:to_s).include?(filter_name) &&
-         target_model.respond_to?(filter_name.to_sym)
-        begin
-          return scope.merge(target_model.public_send(filter_name.to_sym, filter_value))
-        rescue ArgumentError, NoMethodError
-          # Fall through to return scope
-        end
-      end
-
-      scope
-    end
-
-    def apply_polymorphic_nested_filters(scope, association, _relationship_name, attributes)
-      foreign_key = association.foreign_key
-      foreign_type = association.foreign_type
-      fk_column = model_class.column_for_attribute(foreign_key)
-      type_value = attributes["type"] || attributes["type_eq"]
-
-      attributes.each do |attr_name, attr_value|
-        next if attr_value.respond_to?(:empty?) ? attr_value.empty? : attr_value.nil?
-        next if attr_name == "type"
-
-        column_filter = parse_column_filter(attr_name)
-        if column_filter && column_filter[:column] == "id" && fk_column
-          value = normalize_filter_value_for_model(model_class, fk_column, attr_value)
-          condition = build_condition_for_model(model_class, fk_column, value, column_filter[:operator]) if value
-          scope = apply_condition(scope, condition) if condition
-        elsif attr_name == "id"
-          scope = scope.where(foreign_key => attr_value)
-        end
-
-        if foreign_type && association.options[:class_name]
-          scope = scope.where(foreign_type => association.options[:class_name])
-        elsif foreign_type && type_value
-          scope = scope.where(foreign_type => type_value)
-        end
-      end
-
-      if foreign_type && association.options[:class_name].nil? && type_value
-        scope = scope.where(foreign_type => type_value)
-      end
-
-      scope
-    end
-
-    def apply_pagination
-      return @scope if page_params.empty?
-
-      number = page_params["number"]&.to_i || 1
-      size = page_params["size"]&.to_i || JSONAPI.configuration.default_page_size
-
-      # Enforce max page size
-      size = [size, JSONAPI.configuration.max_page_size].min
-
-      offset = (number - 1) * size
-
-      # Handle array (after virtual attribute sorting) vs ActiveRecord relation
-      if @scope.is_a?(Array)
-        @scope.slice(offset, size) || []
-      else
-        @scope.offset(offset).limit(size)
-      end
-    end
   end
 end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Support
+    module ConditionBuilding
+      private
+
+      def build_condition(column, value, operator)
+        build_arel_condition(model_class, column, value, operator)
+      end
+
+      def normalize_filter_value_for_model(model, column, raw_value)
+        return nil unless column
+
+        value = raw_value.is_a?(Array) ? raw_value.first : raw_value
+        return nil if value.nil?
+
+        type = model.type_for_attribute(column.name)
+        type.cast(value)
+      end
+
+      def build_condition_for_model(model, column, value, operator)
+        build_arel_condition(model, column, value, operator)
+      end
+
+      def build_arel_condition(model, column, value, operator)
+        attr = model.arel_table[column.name]
+        build_operator_condition(attr, value, operator)
+      end
+
+      def build_operator_condition(attr, value, operator)
+        case operator
+        when :eq then attr.eq(value)
+        when :lt then attr.lt(value)
+        when :lte then attr.lteq(value)
+        when :gt then attr.gt(value)
+        when :gte then attr.gteq(value)
+        when :match then build_match_condition(attr, value)
+        end
+      end
+
+      def build_match_condition(attr, value)
+        pattern = "%#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}%"
+        lower_attr = Arel::Nodes::NamedFunction.new("LOWER", [attr])
+        lower_attr.matches(pattern.downcase)
+      end
+
+      def apply_condition(scope, condition)
+        scope.where(condition)
+      end
+
+      def empty_filter_value?(filter_value)
+        filter_value.respond_to?(:empty?) ? filter_value.empty? : filter_value.nil?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Support
+    module NestedFilters
+      def apply_nested_relationship_filters(scope)
+        return scope if filter_params.empty?
+
+        nested_filters = filter_params.select { |k, _v| k.to_s.include?(".") }
+        return scope if nested_filters.empty?
+
+        nested_filters.reduce(scope) do |current_scope, (filter_name, filter_value)|
+          apply_filter_for_path(current_scope, filter_name.to_s, filter_value)
+        end
+      end
+
+      private
+
+      def apply_filter_for_path(scope, filter_name, filter_value)
+        parts = filter_name.split(".")
+        return scope if parts.length < 2
+
+        relationship_chain = parts[0..-2]
+        leaf_filter = parts.last
+
+        result = traverse_relationship_chain(scope, relationship_chain, leaf_filter, filter_value)
+        return result[:scope] if result[:early_return]
+
+        apply_joined_filter(scope, result, relationship_chain:, leaf_filter:, filter_value:)
+      end
+
+      def traverse_relationship_chain(scope, relationship_chain, leaf_filter, filter_value)
+        current_model = model_class
+        current_definition = definition
+
+        relationship_chain.each do |relationship_name|
+          result = process_chain_step(scope, current_model, relationship_name, leaf_filter, filter_value)
+          return result if result[:early_return]
+
+          current_model = result[:model]
+          current_definition = result[:definition]
+        end
+
+        { model: current_model, definition: current_definition, early_return: false }
+      end
+
+      def process_chain_step(scope, current_model, relationship_name, leaf_filter, filter_value)
+        association = current_model.reflect_on_association(relationship_name.to_sym)
+        return { scope:, early_return: true } unless association
+
+        if association.polymorphic?
+          attributes = { leaf_filter => filter_value }
+          return { scope: apply_polymorphic_nested_filters(scope, association, relationship_name, attributes),
+                   early_return: true, }
+        end
+
+        next_definition = JSONAPI::Resource.resource_for_model(association.klass)
+        return { scope:, early_return: true } unless next_definition
+
+        { model: association.klass, definition: next_definition, early_return: false }
+      end
+
+      def apply_joined_filter(scope, result, relationship_chain:, leaf_filter:, filter_value:)
+        join_hash = build_join_hash_for_chain(relationship_chain)
+        scope = scope.joins(join_hash) if join_hash.present?
+        apply_filter_on_model(scope, result[:model], result[:definition], leaf_filter, filter_value)
+      end
+
+      def build_join_hash_for_chain(chain)
+        return nil if chain.empty?
+
+        chain.reverse.reduce(nil) do |acc, name|
+          if acc.nil?
+            name.to_sym
+          else
+            { name.to_sym => acc }
+          end
+        end
+      end
+
+      def apply_filter_on_model(scope, target_model, target_resource, filter_name, filter_value)
+        return scope if empty_filter_value?(filter_value)
+
+        apply_column_operator_filter(scope, target_model, filter_name, filter_value) ||
+          apply_direct_column_filter(scope, target_model, filter_name, filter_value) ||
+          apply_scope_method_filter(scope, target_model, target_resource, filter_name, filter_value) ||
+          scope
+      end
+
+      def apply_column_operator_filter(scope, target_model, filter_name, filter_value)
+        column_filter = parse_column_filter(filter_name)
+        return nil unless column_filter
+
+        column = target_model.column_for_attribute(column_filter[:column])
+        return nil unless column
+
+        value = normalize_filter_value_for_model(target_model, column, filter_value)
+        return nil unless value
+
+        condition = build_condition_for_model(target_model, column, value, column_filter[:operator])
+        condition ? apply_condition(scope, condition) : nil
+      end
+
+      def apply_direct_column_filter(scope, target_model, filter_name, filter_value)
+        return nil unless target_model.column_names.include?(filter_name)
+
+        scope.where(target_model.table_name => { filter_name => filter_value })
+      end
+
+      def apply_scope_method_filter(scope, target_model, target_resource, filter_name, filter_value)
+        if target_model.respond_to?(filter_name.to_sym)
+          return try_scope_method(scope, target_model, filter_name,
+                                  filter_value,)
+        end
+
+        return nil unless target_resource
+        return nil unless target_resource.permitted_filters.map(&:to_s).include?(filter_name)
+        return nil unless target_model.respond_to?(filter_name.to_sym)
+
+        try_scope_method(scope, target_model, filter_name, filter_value)
+      end
+
+      def try_scope_method(scope, target_model, filter_name, filter_value)
+        scope.merge(target_model.public_send(filter_name.to_sym, filter_value))
+      rescue ArgumentError, NoMethodError
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Support
+    module Pagination
+      def apply_pagination
+        return @scope if page_params.empty?
+
+        offset, size = calculate_pagination_params
+        paginate_scope(offset, size)
+      end
+
+      private
+
+      def calculate_pagination_params
+        number = page_params["number"]&.to_i || 1
+        size = page_params["size"]&.to_i || JSONAPI.configuration.default_page_size
+        size = [size, JSONAPI.configuration.max_page_size].min
+        offset = (number - 1) * size
+        [offset, size]
+      end
+
+      def paginate_scope(offset, size)
+        return @scope.slice(offset, size) || [] if @scope.is_a?(Array)
+
+        @scope.offset(offset).limit(size)
+      end
+    end
+  end
+end