typical_sort 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9039e103d0aab48801238a87171c7b5294780714acc3df4251f3b4e72cab03d1
-  data.tar.gz: 5717da3c8409651f5b96b2627ceeb419228cf1c643347ab7b9df0583406eb362
+  metadata.gz: 00ba97e42f71527115a64ddefd6d292678f9be903dca92dc416a6735f5efc38a
+  data.tar.gz: a62285eca9c248219e50d0ba36b0393a851b67cbc07ca754f1aaf7cf465449e2
 SHA512:
-  metadata.gz: a15dce023ef4db25e7b0b362681db3b7fa95c088141dd9d09c0d3d882b6d9b3f45518901cd7536a3abf3cde629815b4fc8c125b3cee1f0cb74c718f0603d8ab3
-  data.tar.gz: 1947b566ed290db9894688c3025b336b2b98138db56503f8e651c1dea90ce82694a5f9152da03a7baacb1429f038c1db1257689c11bb6ecfbbe0f600775f0d10
+  metadata.gz: 259eccd6a42e98a2b95911874404d264600233c0c4d0220ab042ef9cd549b7778a6cd896a785f04be8e9547f663c265e689af95889f2e6a95c3b1e1eae395612
+  data.tar.gz: a4e3ad12e56cd73c329ea2590fb0fdb770e56ac0832ceded3bf23bd19a6c2120852e09269f1a51935c2722264e4f3970f9a289a509860f5481f2acba46894cba

data/README.md

@@ -104,7 +104,15 @@ Supported aggregate values:
 - `:max`
 - `:sum`
 - `:avg`
-- `:count`
+- `:count` — counts associated records, including records whose declared sort column is null; parents without associated records count as zero
+
+### Aggregate query composition
+
+Aggregate sorting preserves filtering, deduplicates parents, and retains base-table column selections and ordering, readonly state, and preloads. Existing ordering takes priority over requested sorts, as it does for base-column sorting.
+
+Filtering joins remain in an ID subquery. Associations requested through `eager_load` or `includes` are loaded separately with `preload`; these contain the full associated collections, not only the rows matching the filtering join.
+
+Input selections and ordering must use base-table columns (symbols, plain column names, or Arel column/order nodes). Aggregate sorting raises `ArgumentError` for SQL expressions, joined-table projections or ordering, `GROUP BY` / `HAVING`, `DISTINCT`, custom `FROM`, or pagination applied before sorting. Use an explicit sorting scope for unsupported query shapes, and paginate after `sort_records`.
 
 ## Scope sorting
 

data/lib/typical_sort/aggregate_sorter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "typical_sort/ordering"
+
 module TypicalSort
   class AggregateSorter
     VALID_AGGREGATES = %i[min max sum avg count directional].freeze
@@ -8,11 +10,44 @@ module TypicalSort
 
     # Collapse collection joins once, before applying any requested ordering.
     def self.prepare(records)
+      validate_relation!(records)
+
       table = records.klass.arel_table
-      base_ids = records.except(:select, :order).select(table[records.klass.primary_key])
-      records.klass.where(records.klass.primary_key => base_ids)
+      primary_key = records.klass.primary_key
+      base_ids = records.except(:select, :order).select(table[primary_key])
+      prepared = records.except(:where, :joins, :left_outer_joins, :references, :eager_load, :includes)
+      preloads = records.eager_load_values | records.includes_values
+      prepared = prepared.preload(*preloads) unless preloads.empty?
+      prepared.where(primary_key => base_ids)
+    end
+
+    def self.validate_relation!(records)
+      unsupported = records.group_values.any? || !records.having_clause.empty? ||
+        records.distinct_value || records.limit_value || records.offset_value ||
+        !records.from_clause.empty?
+      columns = records.select_values + records.order_values
+      return if !unsupported && columns.all? { |column| base_column?(column, records) }
+
+      raise ArgumentError, "Unsupported aggregate sort relation: use base-table column selections and ordering without grouping, DISTINCT, custom FROM, or pagination; use an explicit sorting scope for other query shapes"
+    end
+
+    def self.base_column?(column, records)
+      case column
+      when Arel::Nodes::Ascending, Arel::Nodes::Descending, Arel::Nodes::NullsFirst, Arel::Nodes::NullsLast
+        base_column?(column.expr, records)
+      when Arel::Attributes::Attribute
+        column.relation == records.klass.arel_table
+      when Symbol, String
+        column = column.to_s
+        names = ["*", *records.klass.column_names]
+        names.any? { |name| column == name || column == "#{records.klass.table_name}.#{name}" }
+      else
+        false
+      end
     end
 
+    private_class_method :validate_relation!, :base_column?
+
     def initialize(records:, relation_name:, reflection:, column_name:, direction:, definition:, configuration:, table_alias: "typical_sort_scope")
       @records = records
       @relation_name = relation_name.to_sym
@@ -52,8 +87,12 @@ module TypicalSort
         Arel::Nodes::On.new(sort_table[:typical_sort_record_id].eq(records.klass.arel_table[base_pk]))
       )
 
-      records.joins(join)
-        .order(Arel.sql("#{table_alias}.typical_sort_value #{sql_direction} NULLS #{nulls_position}"))
+      ordering = Ordering.build(
+        sort_table[:typical_sort_value],
+        direction: direction,
+        nulls: definition.nulls || configuration.nulls.fetch(direction)
+      )
+      records.joins(join).order(ordering)
     end
 
     private
@@ -71,22 +110,10 @@ module TypicalSort
     end
 
     def value_sql(connection)
-      return "*" if definition.aggregate == :count
-
+      column = (definition.aggregate == :count) ? reflection.klass.primary_key : column_name
       related_table = connection.quote_table_name(reflection.klass.table_name)
-      related_column = connection.quote_column_name(column_name)
+      related_column = connection.quote_column_name(column)
       "#{related_table}.#{related_column}"
     end
-
-    def sql_direction
-      (direction == :desc) ? "DESC" : "ASC"
-    end
-
-    def nulls_position
-      nulls = definition.nulls || configuration.nulls.fetch(direction)
-      raise ArgumentError, "Unsupported nulls position: #{nulls.inspect}" unless %i[first last].include?(nulls)
-
-      nulls.to_s.upcase
-    end
   end
 end

data/lib/typical_sort/ordering.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module TypicalSort
+  module Ordering
+    def self.build(expression, direction:, nulls:)
+      ordered = case direction
+      when :asc then expression.asc
+      when :desc then expression.desc
+      else
+        raise ArgumentError, "Unsupported direction: #{direction.inspect}"
+      end
+
+      case nulls
+      when :first then ordered.nulls_first
+      when :last then ordered.nulls_last
+      else
+        raise ArgumentError, "Unsupported nulls position: #{nulls.inspect}"
+      end
+    end
+  end
+end

data/lib/typical_sort/sort_query.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "typical_sort/sorter"
+
+module TypicalSort
+  class SortQuery
+    def initialize(records:, sorts:, definitions:, configuration:)
+      @records = records
+      @sorts = sorts
+      @definitions = definitions
+      @configuration = configuration
+    end
+
+    def call
+      sorts = resolve_sorts
+      sorted = Sorter.prepare(records: @records, definitions: sorts.map(&:first))
+      sorts.each_with_index do |(definition, direction), index|
+        sorted = Sorter.new(
+          records: sorted,
+          definition: definition,
+          direction: direction,
+          configuration: @configuration,
+          sort_index: index
+        ).call
+      end
+
+      append_tiebreaker(sorted)
+    end
+
+    private
+
+    def resolve_sorts
+      @sorts.filter_map do |attribute, direction|
+        definition = @definitions.fetch(attribute)
+        if definition
+          [definition, direction]
+        elsif @configuration.invalid_sort == :raise
+          raise InvalidSort, "Invalid sort: #{attribute}"
+        end
+      end
+    end
+
+    def append_tiebreaker(records)
+      return records unless @configuration.tie_breaker == :primary_key
+
+      table = records.klass.arel_table
+      records.order(table[records.klass.primary_key].asc)
+    end
+  end
+end

data/lib/typical_sort/sorter.rb

@@ -2,6 +2,7 @@
 
 require "typical_sort/aggregate_sorter"
 require "typical_sort/path_resolver"
+require "typical_sort/ordering"
 
 module TypicalSort
   class Sorter
@@ -55,9 +56,18 @@ module TypicalSort
     end
 
     def sort_relation_association(resolver)
-      table = resolver.reflection.klass.arel_table
-      node = table[resolver.column_name]
-      records.left_outer_joins(resolver.association_name.to_sym).order(order_node(node))
+      tracker = ActiveRecord::Associations::AliasTracker.create(
+        records.klass.connection_pool, records.klass.table_name, records.arel.join_sources
+      )
+      association = ActiveRecord::Associations::JoinDependency::JoinAssociation.new(resolver.reflection, [])
+      joins = association.join_constraints(records.klass.arel_table, records.klass, Arel::Nodes::OuterJoin, tracker) do |reflection, chain|
+        reflection.check_validity!
+        reflection.check_eager_loadable!
+        name = "typical_sort_relation_#{sort_index}_#{chain.length}"
+        [tracker.aliased_table_for(reflection.klass.arel_table, name) { name }, false]
+      end
+
+      records.joins(joins).order(order_node(association.table[resolver.column_name]))
     end
 
     def validate_resolver!(resolver)
@@ -79,21 +89,11 @@ module TypicalSort
     end
 
     def order_node(node)
-      ordered = (direction == :desc) ? node.desc : node.asc
-      nulls = nulls_position
-
-      case nulls
-      when :first
-        ordered.nulls_first
-      when :last
-        ordered.nulls_last
-      else
-        raise ArgumentError, "Unsupported nulls position: #{nulls.inspect}"
-      end
-    end
-
-    def nulls_position
-      definition.nulls || configuration.nulls.fetch(direction)
+      Ordering.build(
+        node,
+        direction: direction,
+        nulls: definition.nulls || configuration.nulls.fetch(direction)
+      )
     end
   end
 end

data/lib/typical_sort/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TypicalSort
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/typical_sort.rb

@@ -6,7 +6,7 @@ require "typical_sort/engine"
 require "typical_sort/configuration"
 require "typical_sort/params"
 require "typical_sort/sort_set"
-require "typical_sort/sorter"
+require "typical_sort/sort_query"
 
 module TypicalSort
   class Error < StandardError; end
@@ -49,53 +49,28 @@ module TypicalSort
   private
 
   def sort_records(records)
-    sort_params = TypicalSort::Params.new(
+    configuration = request_configuration
+    sorts = Params.new(
       params: params,
-      configuration: request_configuration,
+      configuration: configuration,
       default_attribute: default_sorting_attribute,
-      default_direction: default_sorting_direction
-    )
-
-    sorts = sort_params.sorts.filter_map do |attribute, direction|
-      definition = sort_definition_for(attribute)
-      if definition
-        [definition, direction]
-      elsif TypicalSort.configuration.invalid_sort == :raise
-        raise TypicalSort::InvalidSort, "Invalid sort: #{attribute}"
-      end
-    end
-
-    sorted = TypicalSort::Sorter.prepare(records: records, definitions: sorts.map(&:first))
-    sorts.each_with_index do |(definition, direction), index|
-      sorted = TypicalSort::Sorter.new(
-        records: sorted,
-        definition: definition,
-        direction: direction,
-        configuration: request_configuration,
-        sort_index: index
-      ).call
-    end
-
-    append_sort_tiebreaker(sorted)
-  end
-
-  def sort_definition_for(attribute)
-    typical_sort_set.fetch(attribute)
-  end
-
-  def append_sort_tiebreaker(records)
-    return records unless TypicalSort.configuration.tie_breaker == :primary_key
-
-    table = records.klass.arel_table
-    records.order(table[records.klass.primary_key].asc)
+      default_direction: default_sorting_direction(configuration)
+    ).sorts
+
+    SortQuery.new(
+      records: records,
+      sorts: sorts,
+      definitions: typical_sort_set,
+      configuration: configuration
+    ).call
   end
 
   def default_sorting_attribute
     typical_sort_set.default_attribute || :created_at
   end
 
-  def default_sorting_direction
-    typical_sort_set.default_direction || TypicalSort.configuration.default_direction
+  def default_sorting_direction(configuration)
+    typical_sort_set.default_direction || configuration.default_direction
   end
 
   def request_configuration

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typical_sort
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Wyatt Kirby
@@ -192,9 +192,11 @@ files:
 - lib/typical_sort/aggregate_sorter.rb
 - lib/typical_sort/configuration.rb
 - lib/typical_sort/engine.rb
+- lib/typical_sort/ordering.rb
 - lib/typical_sort/params.rb
 - lib/typical_sort/path_resolver.rb
 - lib/typical_sort/sort_definition.rb
+- lib/typical_sort/sort_query.rb
 - lib/typical_sort/sort_set.rb
 - lib/typical_sort/sorter.rb
 - lib/typical_sort/version.rb