forest_admin_datasource_active_record 1.35.0 → 1.35.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04e8352c5b26a43ce466ea857586a38f235d32b38b252c4c37e51bef43e2f4f4
-  data.tar.gz: ffcfe8fd892725000f743ac15323015a35d06238680fb80b2c2467ee45b16afc
+  metadata.gz: df0d3da32f3e5533efcd50c768ed24a103f7b442e956b48c7a359c07b3d3c721
+  data.tar.gz: 1af868e9ed17dc80de89648eb262c9fe960a2e35af5aa2515d7d802bd129557f
 SHA512:
-  metadata.gz: c8995e225a4300c5a25737a74715c35ddf991c4fdf8bef82722d25b89836cd2e2a1e42c35aabf905aa3bf538413e6e164e18f12f0effcb6a4211bfd2390c0c09
-  data.tar.gz: ad3209330ba9e93b06d98fafc26648b06eda6f80309f5b3373d5ff2c0fe28609430c63d9a3f93d75500edde838bae1fc476d43a2cca6009ac2868c9a86b0f1a6
+  metadata.gz: 415b589ca9918863682926543313e9c2917baf7736eb4333e876c9aafa9873580ddc6b4c15e9e9c64e7fdefbcea2a4617d9b9212479652d75d1855a277b82615
+  data.tar.gz: 7acfbd16b68262aca27a07e52cf2c76d1145f6e0fffc53d923a11a295475c171014d81c615469f6f738f79752475c7475a1fdc5cd36d16595b9beeb92ad58848

data/lib/forest_admin_datasource_active_record/utils/active_record_serializer.rb

@@ -13,6 +13,7 @@ module ForestAdminDatasourceActiveRecord
         # root keeps all its selected columns (attributes + FKs); a related record is restricted to
         # its projected columns, matching the JOINed hydration
         hash = path.empty? || projection.nil? ? base_attributes(object) : projected_columns(object, projection)
+        hash = normalize_polymorphic_types(object.class, hash)
 
         serialize_associations(object, projection, hash, path) if projection
 
@@ -65,6 +66,7 @@ module ForestAdminDatasourceActiveRecord
 
         hash = {}
         projection.columns.each { |column| hash[column] = object[meta[:columns][column]] }
+        hash = normalize_polymorphic_types(target_model(relation_path), hash)
         projection.relations.each_key do |nested_name|
           hash[nested_name] = hash_joined_relation(projection.relations[nested_name], relation_path + [nested_name])
         end
@@ -72,8 +74,43 @@ module ForestAdminDatasourceActiveRecord
         hash
       end
 
+      def normalize_polymorphic_types(model_class, hash)
+        return hash if model_class.nil?
+
+        polymorphic_belongs_to(model_class).each do |association|
+          stored = hash[association.foreign_type]
+          next if stored.nil?
+
+          hash = hash.merge(association.foreign_type => model_class.polymorphic_class_for(stored).name)
+        rescue NameError => e
+          warn_unable(association.name, model_class, e)
+        end
+        hash
+      end
+
+      # Target model of a JOINed relation path (only belongs_to / has_one :through are ever JOINed).
+      def target_model(relation_path)
+        relation_path.reduce(object.class) do |model, name|
+          model&.reflect_on_association(name.to_sym)&.klass
+        end
+      rescue NameError
+        nil
+      end
+
       private
 
+      def polymorphic_belongs_to(model_class)
+        (@polymorphic_belongs_to ||= {})[model_class] ||=
+          model_class.reflect_on_all_associations(:belongs_to).select(&:polymorphic?)
+      end
+
+      def warn_unable(name, model_class, error)
+        ActiveSupport::Logger.new($stdout).warn(
+          "[ForestAdmin] Unable to normalize polymorphic type of '#{name}' " \
+          "in model '#{model_class.name}': #{error.message}. Keeping the stored value."
+        )
+      end
+
       def joined_relation?(relation_path)
         !joined_relations.nil? && joined_relations.key?(relation_path.join('.'))
       end

data/lib/forest_admin_datasource_active_record/utils/query.rb

@@ -229,12 +229,13 @@ module ForestAdminDatasourceActiveRecord
       def split_relations
         join_tree = {}
         preload_tree = {}
-        used_tables = Set[@collection.model.table_name] | @filter_joined_tables
+        used_joins = { @collection.model.table_name => :root }
+        @filter_joined_tables.each { |table| used_joins[table] ||= :filter } # never reuse a filter/sort join
 
         @projection.relations.each do |relation_name, sub_projection|
-          tables = joinable_tables(@collection, relation_name, sub_projection, used_tables)
-          if tables
-            used_tables |= tables
+          joins = joinable_joins(@collection, relation_name, sub_projection, used_joins)
+          if joins
+            used_joins.merge!(joins)
             join_tree[relation_name.to_sym] = format_relation_projection(sub_projection)
             collect_joined_selects(@collection, relation_name, sub_projection, [relation_name])
           else
@@ -275,22 +276,28 @@ module ForestAdminDatasourceActiveRecord
       end
 
       # Set of tables the subtree adds via JOIN, or nil if any relation in it can't be safely joined.
-      def joinable_tables(collection, relation_name, sub_projection, used_tables)
-        target = joinable_target(collection, relation_name, used_tables)
+      def joinable_joins(collection, relation_name, sub_projection, used_joins)
+        target = joinable_target(collection, relation_name)
         return nil if target.nil?
 
-        tables = Set[target.model.table_name] | through_tables(collection, relation_name)
+        joins = join_signatures(collection, relation_name)
+        return nil if joins.nil? || conflicting?(joins, used_joins)
+
         sub_projection.relations.each do |nested_name, nested_projection|
-          nested = joinable_tables(target, nested_name, nested_projection, used_tables | tables)
+          nested = joinable_joins(target, nested_name, nested_projection, used_joins.merge(joins))
           return nil if nested.nil?
 
-          tables |= nested
+          joins = joins.merge(nested)
         end
-        tables
+        joins
+      end
+
+      def conflicting?(new_joins, used_joins)
+        new_joins.any? { |table, signature| used_joins.key?(table) && used_joins[table] != signature }
       end
 
       # The target collection when this hop is safe to collapse into a JOIN, else nil (-> preload).
-      def joinable_target(collection, relation_name, used_tables)
+      def joinable_target(collection, relation_name)
         relation_schema = collection.schema[:fields][relation_name]
         return unless relation_schema.respond_to?(:foreign_collection)
 
@@ -308,19 +315,29 @@ module ForestAdminDatasourceActiveRecord
         target = local_ar_collection(collection.datasource, relation_schema.foreign_collection)
         return if target.nil? || !target.model.default_scopes.empty? # same risk as a scoped association
         return unless same_database?(collection.model, target.model)
-        return if used_tables.include?(target.model.table_name) # a table joined twice would be aliased by AR
-        return if through_tables(collection, relation_name).intersect?(used_tables)
 
         target
       end
 
-      def through_tables(collection, relation_name)
-        through = collection.model.reflect_on_association(relation_name.to_sym)&.through_reflection
-        return Set[] unless through
-
-        Set[through.table_name]
+      def join_signatures(collection, relation_name)
+        reflection = collection.model.reflect_on_association(relation_name.to_sym)
+        if reflection.through_reflection?
+          { reflection.through_reflection.klass.table_name => signature(reflection.through_reflection),
+            reflection.klass.table_name => signature(reflection.source_reflection) }
+        else
+          { reflection.klass.table_name => signature(reflection) }
+        end
       rescue StandardError
-        Set[]
+        nil
+      end
+
+      def signature(reflection)
+        "#{reflection.active_record.table_name}.#{Array(reflection.foreign_key).join(",")}" \
+          "->#{reflection.klass.table_name}.#{Array(join_key(reflection)).join(",")}"
+      end
+
+      def join_key(reflection)
+        reflection.respond_to?(:join_primary_key) ? reflection.join_primary_key : reflection.association_primary_key
       end
 
       def belongs_to_chain_through?(reflection)

data/lib/forest_admin_datasource_active_record/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminDatasourceActiveRecord
-  VERSION = "1.35.0"
+  VERSION = "1.35.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_datasource_active_record
 version: !ruby/object:Gem::Version
-  version: 1.35.0
+  version: 1.35.1
 platform: ruby
 authors:
 - Matthieu