forest_admin_datasource_active_record 1.16.9 → 1.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3d7858615439239405b2c39e52b56fe0fc4ec32dbd1ce8c9d2b902d1e0ed7a5
-  data.tar.gz: 026d96c201dca2ae860fdde30d6c605c4d6753cee4491a1e9dab867f8c5b8358
+  metadata.gz: e00cc2f088fdd7d8b437b9395464ac0c1f6a4057157958f3f8cd1ad1cc52d2a2
+  data.tar.gz: 783e29f8db7acd0559ad94a511a1f0a190d8a8fb976afc42d868bcf6f0e9a956
 SHA512:
-  metadata.gz: 36a156812b7639a6c3ea9ed2193c8eeee9408f2c9194b5e7edcbf3ae097ff96583b3eedbaf97db44648c6fa9913a798f863a9b913c9562ba2dfd9f65b7888374
-  data.tar.gz: aa7807b3a7bfff76822288af6b1c95b7ff9dc9cb0465b042c61b0a5bc9ccceb20f4aa3d111f5fd5f21400f470fb96b8c850fb53eab297df439dcb216a5e88e9f
+  metadata.gz: e681e4a30ce970148e801618591f8735b8de807dbe1a24e203d592772bf32ee330a316c998f70b470d6bde0f3e1d18c67af18c7b2e477744e05396b7d150d2ee
+  data.tar.gz: 0b0bedbc604bb097caddd27d3b3de01248314d61d41dbc575e9b3120165dacc05ddb595ee07fc97ce23332ce850e9447bd8d925a56411a95ad9550f215531458

data/lib/forest_admin_datasource_active_record/utils/query.rb

@@ -37,8 +37,8 @@ module ForestAdminDatasourceActiveRecord
 
       def apply_sort(sort)
         sort.each do |sort_clause|
-          field = format_field(sort_clause[:field])
-          @query = @query.order(field => sort_clause[:ascending] ? :asc : :desc)
+          resolved = resolve_field(sort_clause[:field])
+          @query = @query.order(resolved[:formatted] => sort_clause[:ascending] ? :asc : :desc)
         end
 
         @query
@@ -65,7 +65,9 @@ module ForestAdminDatasourceActiveRecord
       end
 
       def compute_main_operator(condition_tree, aggregator)
-        field = format_field(condition_tree.field)
+        resolved = resolve_field(condition_tree.field)
+        field = resolved[:formatted]
+        arel_attr = resolved[:arel_attr]
         value = condition_tree.value
         aggregator = aggregator.to_sym
 
@@ -93,45 +95,45 @@ module ForestAdminDatasourceActiveRecord
         when Operators::NOT_EQUAL, Operators::NOT_IN
           @query = query_aggregator(aggregator, @collection.model.where.not({ field => value }))
         when Operators::GREATER_THAN
-          @query = query_aggregator(aggregator, build_comparison_query(condition_tree.field, field, value, :gt))
+          @query = query_aggregator(aggregator, build_comparison_query(condition_tree.field, arel_attr, value, :gt))
         when Operators::GREATER_THAN_OR_EQUAL
-          @query = query_aggregator(aggregator, build_comparison_query(condition_tree.field, field, value, :gteq))
+          @query = query_aggregator(aggregator, build_comparison_query(condition_tree.field, arel_attr, value, :gteq))
         when Operators::LESS_THAN
-          @query = query_aggregator(aggregator, build_comparison_query(condition_tree.field, field, value, :lt))
+          @query = query_aggregator(aggregator, build_comparison_query(condition_tree.field, arel_attr, value, :lt))
         when Operators::LESS_THAN_OR_EQUAL
-          @query = query_aggregator(aggregator, build_comparison_query(condition_tree.field, field, value, :lteq))
+          @query = query_aggregator(aggregator, build_comparison_query(condition_tree.field, arel_attr, value, :lteq))
         when Operators::CONTAINS
           @query = query_aggregator(aggregator,
-                                    @collection.model.where(@arel_table[field.to_sym].matches("%#{value}%")))
+                                    @collection.model.where(arel_attr.matches("%#{value}%")))
         when Operators::I_CONTAINS
-          lower_field = Arel::Nodes::NamedFunction.new('LOWER', [@arel_table[field.to_sym]])
+          lower_field = Arel::Nodes::NamedFunction.new('LOWER', [arel_attr])
           @query = query_aggregator(aggregator,
                                     @collection.model.where(lower_field.matches("%#{value.to_s.downcase}%")))
         when Operators::NOT_CONTAINS
           @query = query_aggregator(aggregator,
-                                    @collection.model.where.not(@arel_table[field.to_sym].matches("%#{value}%")))
+                                    @collection.model.where.not(arel_attr.matches("%#{value}%")))
         when Operators::NOT_I_CONTAINS
-          lower_field = Arel::Nodes::NamedFunction.new('LOWER', [@arel_table[field.to_sym]])
+          lower_field = Arel::Nodes::NamedFunction.new('LOWER', [arel_attr])
           @query = query_aggregator(aggregator,
                                     @collection.model.where.not(lower_field.matches("%#{value.to_s.downcase}%")))
         when Operators::STARTS_WITH
           @query = query_aggregator(aggregator,
-                                    @collection.model.where(@arel_table[field.to_sym].matches("#{value}%")))
+                                    @collection.model.where(arel_attr.matches("#{value}%")))
         when Operators::I_STARTS_WITH
-          lower_field = Arel::Nodes::NamedFunction.new('LOWER', [@arel_table[field.to_sym]])
+          lower_field = Arel::Nodes::NamedFunction.new('LOWER', [arel_attr])
           @query = query_aggregator(aggregator,
                                     @collection.model.where(lower_field.matches("#{value.to_s.downcase}%")))
         when Operators::ENDS_WITH
           @query = query_aggregator(aggregator,
-                                    @collection.model.where(@arel_table[field.to_sym].matches("%#{value}")))
+                                    @collection.model.where(arel_attr.matches("%#{value}")))
         when Operators::I_ENDS_WITH
-          lower_field = Arel::Nodes::NamedFunction.new('LOWER', [@arel_table[field.to_sym]])
+          lower_field = Arel::Nodes::NamedFunction.new('LOWER', [arel_attr])
           @query = query_aggregator(aggregator,
                                     @collection.model.where(lower_field.matches("%#{value.to_s.downcase}")))
         when Operators::LIKE
-          @query = query_aggregator(aggregator, @collection.model.where(@arel_table[field.to_sym].matches(value)))
+          @query = query_aggregator(aggregator, @collection.model.where(arel_attr.matches(value)))
         when Operators::I_LIKE
-          lower_field = Arel::Nodes::NamedFunction.new('LOWER', [@arel_table[field.to_sym]])
+          lower_field = Arel::Nodes::NamedFunction.new('LOWER', [arel_attr])
           @query = query_aggregator(aggregator,
                                     @collection.model.where(lower_field.matches(value.to_s.downcase)))
         when Operators::MATCH
@@ -148,23 +150,24 @@ module ForestAdminDatasourceActiveRecord
 
           # Use database-specific regex syntax
           adapter_name = @collection.model.connection.adapter_name.downcase
+          table_and_column = "#{arel_attr.relation.name}.#{arel_attr.name}"
           regex_clause = case adapter_name
                          when 'postgresql'
-                           "#{@arel_table.name}.#{field} ~ ?"
+                           "#{table_and_column} ~ ?"
                          when 'mysql2', 'mysql', 'sqlite', 'sqlite3'
-                           "#{@arel_table.name}.#{field} REGEXP ?"
+                           "#{table_and_column} REGEXP ?"
                          else
                            raise ArgumentError, "Match operator is not supported for database adapter '#{adapter_name}'"
                          end
 
           @query = query_aggregator(aggregator, @collection.model.where(regex_clause, pattern))
         when Operators::INCLUDES_ALL
-          @query = query_aggregator(aggregator, @collection.model.where(@arel_table[field.to_sym].matches_all(value)))
+          @query = query_aggregator(aggregator, @collection.model.where(arel_attr.matches_all(value)))
         when Operators::SHORTER_THAN
-          length_func = Arel::Nodes::NamedFunction.new('LENGTH', [@arel_table[field.to_sym]])
+          length_func = Arel::Nodes::NamedFunction.new('LENGTH', [arel_attr])
           @query = query_aggregator(aggregator, @collection.model.where(length_func.lt(value)))
         when Operators::LONGER_THAN
-          length_func = Arel::Nodes::NamedFunction.new('LENGTH', [@arel_table[field.to_sym]])
+          length_func = Arel::Nodes::NamedFunction.new('LENGTH', [arel_attr])
           @query = query_aggregator(aggregator, @collection.model.where(length_func.gt(value)))
         end
 
@@ -213,35 +216,43 @@ module ForestAdminDatasourceActiveRecord
         @query
       end
 
-      def format_field(field)
-        if field.include?(':')
-          relation_name, field = field.split(':')
+      def resolve_field(original_field)
+        if original_field.include?(':')
+          relation_name, column_name = original_field.split(':')
           relation = @collection.schema[:fields][relation_name]
-          table_name = @collection.datasource.get_collection(relation.foreign_collection).model.table_name
+          related_collection = @collection.datasource.get_collection(relation.foreign_collection)
           add_join_relation(relation_name)
 
-          return "#{table_name}.#{field}"
+          {
+            formatted: "#{related_collection.model.table_name}.#{column_name}",
+            arel_attr: related_collection.model.arel_table[column_name.to_sym]
+          }
+        else
+          {
+            formatted: original_field,
+            arel_attr: @arel_table[original_field.to_sym]
+          }
         end
-
-        field
       end
 
-      def build_comparison_query(original_field, formatted_field, value, operator)
+      def build_comparison_query(original_field, arel_attr, value, operator)
         # When comparing a String field with a numeric value, compare the length of the string
         # Otherwise, do a lexicographic comparison
         if value.is_a?(Numeric)
           field_schema = ForestAdminDatasourceToolkit::Utils::Collection.get_field_schema(@collection, original_field)
           if field_schema.column_type == 'String'
-            length_func = Arel::Nodes::NamedFunction.new('LENGTH', [@arel_table[formatted_field.to_sym]])
+            length_func = Arel::Nodes::NamedFunction.new('LENGTH', [arel_attr])
             return @collection.model.where(length_func.send(operator, value))
           end
         end
 
-        @collection.model.where(@arel_table[formatted_field.to_sym].send(operator, value))
+        @collection.model.where(arel_attr.send(operator, value))
       end
 
       def query_aggregator(aggregator, query)
         if !@query.respond_to?(:where_clause) || @query.where_clause.empty?
+          # Preserve includes from @query when replacing with new query
+          query = query.includes(@query.includes_values) if @query.includes_values.any?
           query
         else
           @query.send(aggregator, query)

data/lib/forest_admin_datasource_active_record/utils/query_aggregate.rb

@@ -10,7 +10,7 @@ module ForestAdminDatasourceActiveRecord
         @aggregation = aggregation
         @limit = limit
         @operation = aggregation.operation.downcase
-        @field = aggregation.field.nil? ? '*' : format_field(aggregation.field)
+        @field = aggregation.field.nil? ? '*' : resolve_field(aggregation.field)[:formatted]
       end
 
       def get
@@ -19,7 +19,7 @@ module ForestAdminDatasourceActiveRecord
 
         group_fields = []
         @aggregation.groups.each do |group|
-          field = format_field(group[:field])
+          field = resolve_field(group[:field])[:formatted]
           if group[:operation]
             # Pass original field name for validation before SQL generation
             date_trunc_expression = date_trunc_sql(group[:operation], field, group[:field])

data/lib/forest_admin_datasource_active_record/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminDatasourceActiveRecord
-  VERSION = "1.16.9"
+  VERSION = "1.17.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_datasource_active_record
 version: !ruby/object:Gem::Version
-  version: 1.16.9
+  version: 1.17.0
 platform: ruby
 authors:
 - Matthieu
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-08 00:00:00.000000000 Z
+date: 2025-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord