forest_admin_datasource_active_record 1.16.8 → 1.16.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3e8b30ef3f95fc128694705efcd7509c6a1afd990d074eb3ce09a8cfd1d56de
-  data.tar.gz: f6b623bff7a10521c6dc576f38b208cd6037b6f7f4f105bd60c17b8a51bccd6a
+  metadata.gz: 6396b9a1d0e2de94e373c7db9e4c8fbb300698db9ec16724fe1d130bd182ba9f
+  data.tar.gz: 1da6eb7faf485ddb8739efee58c3ec7764d6b481ca7fac4e7e065272be74c0f2
 SHA512:
-  metadata.gz: 2ab6cb755bd266907e7a01328e181c4925dea18be178ff259021dc4a38be564def1d05097dc505c8ba6acc280406481feb4cdc031a9db47e20a964fdaa2a7cd6
-  data.tar.gz: c4cf3ef5321bf3f4a076f368fccd2461a7a262d3e5d206f781fa70b8bdd7575ab7f25244fb885610c93637abe1b026fb6fb2528af272c777e0b9d00c9d5bbdd7
+  metadata.gz: 60ce959c8c390eb61e2f21a8049198d099bc0957669195ee0f44dbd7f845b75ce205da27b31234950b9bc94af171b0e14aa7419fd4fd0b7a529bc8bd15dc043a
+  data.tar.gz: 528dc9598f86d83713975ee9b63f444bb47cd0c3f5f0176122ddc5084814a918c9a59c30f3330513bc5e45cbe69587c9e1aaf2630d50038ea3eed6d2d3f6bff2

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.8"
+  VERSION = "1.16.10"
 end

metadata

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