forest_admin_datasource_active_record 1.34.2 → 1.35.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 144849075d84ddc59403e90f55215ff673e7a499ea2a4e9c7bde79b92bedf560
-  data.tar.gz: 718e037d8de68a33682f00a4c47579f04d63aa8346c2bf2fe33057697adb58d7
+  metadata.gz: df0d3da32f3e5533efcd50c768ed24a103f7b442e956b48c7a359c07b3d3c721
+  data.tar.gz: 1af868e9ed17dc80de89648eb262c9fe960a2e35af5aa2515d7d802bd129557f
 SHA512:
-  metadata.gz: 3481314773b0f72bd27df1af19a36bda78698f697b427d463a99d2868399890b37cd5ada815a58713d4b09715928c98a2a8895f3c386e6d1fe1f58bbf88e00ca
-  data.tar.gz: 83bf7e9db1113e836ec18686f718dff66cc13fee0a485b91e09e44b913d04b9da57c539d1a329fcc6eeb93f5a43666bdd38bd77168ce29fb26f9c374f51c1055
+  metadata.gz: 415b589ca9918863682926543313e9c2917baf7736eb4333e876c9aafa9873580ddc6b4c15e9e9c64e7fdefbcea2a4617d9b9212479652d75d1855a277b82615
+  data.tar.gz: 7acfbd16b68262aca27a07e52cf2c76d1145f6e0fffc53d923a11a295475c171014d81c615469f6f738f79752475c7475a1fdc5cd36d16595b9beeb92ad58848

data/lib/forest_admin_datasource_active_record/collection.rb

@@ -100,21 +100,32 @@ module ForestAdminDatasourceActiveRecord
               source_polymorphic = association.source_reflection&.polymorphic? &&
                                    association.options[:source_type].present?
 
-              add_field(
-                association.name.to_s,
-                ForestAdminDatasourceToolkit::Schema::Relations::ManyToManySchema.new(
-                  foreign_collection: format_model_name(association.klass.name),
-                  origin_key: through_reflection.foreign_key,
-                  origin_key_target: through_reflection.join_foreign_key,
-                  foreign_key: association.join_foreign_key,
-                  foreign_key_target: association.association_primary_key,
-                  through_collection: format_model_name(through_reflection.klass.name),
-                  origin_type_field: is_polymorphic ? through_reflection.type : nil,
-                  origin_type_value: is_polymorphic ? @model.name : nil,
-                  foreign_type_field: source_polymorphic ? association.source_reflection.foreign_type : nil,
-                  foreign_type_value: source_polymorphic ? association.options[:source_type] : nil
+              if is_polymorphic || source_polymorphic
+                add_field(
+                  association.name.to_s,
+                  ForestAdminDatasourceToolkit::Schema::Relations::ManyToManySchema.new(
+                    foreign_collection: format_model_name(association.klass.name),
+                    origin_key: through_reflection.foreign_key,
+                    origin_key_target: through_reflection.join_foreign_key,
+                    foreign_key: association.join_foreign_key,
+                    foreign_key_target: association.association_primary_key,
+                    through_collection: format_model_name(through_reflection.klass.name),
+                    origin_type_field: is_polymorphic ? through_reflection.type : nil,
+                    origin_type_value: is_polymorphic ? @model.name : nil,
+                    foreign_type_field: source_polymorphic ? association.source_reflection.foreign_type : nil,
+                    foreign_type_value: source_polymorphic ? association.options[:source_type] : nil
+                  )
                 )
-              )
+              else
+                add_field(
+                  association.name.to_s,
+                  ForestAdminDatasourceToolkit::Schema::Relations::OneToOneSchema.new(
+                    foreign_collection: format_model_name(association.klass.name),
+                    origin_key: association.klass.primary_key,
+                    origin_key_target: @model.primary_key
+                  )
+                )
+              end
             elsif association.inverse_of&.polymorphic?
               add_field(
                 association.name.to_s,

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

@@ -196,6 +196,10 @@ module ForestAdminDatasourceActiveRecord
           if collection.model.table_name == @collection.model.table_name
             if one_to_one_relations.include?(relation_schema.type)
               @select << "#{collection.model.table_name}.#{relation_schema.origin_key_target}"
+              # foreign_key is an array for a composite-key belongs_to through hop
+              Array(root_through_foreign_key(collection, relation_name)).each do |through_fk|
+                @select << "#{collection.model.table_name}.#{through_fk}"
+              end
             elsif many_to_one_relations.include?(relation_schema.type)
               @select << "#{collection.model.table_name}.#{relation_schema.foreign_key}"
             end
@@ -225,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
@@ -271,40 +276,83 @@ 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]
+        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]
-        # belongs_to only: it joins on the target's primary key, so it can't duplicate the parent
-        # (a has_one child may not be unique)
-        return unless relation_schema.type == 'ManyToOne' && relation_schema.respond_to?(:foreign_collection)
+        return unless relation_schema.respond_to?(:foreign_collection)
 
         # a scoped association applies its scope to the JOIN and may inject raw/unqualified SQL or
         # extra joins (e.g. `belongs_to :x, -> { where('id > ?', 1) }`)
         reflection = collection.model.reflect_on_association(relation_name.to_sym)
         return if reflection.nil? || reflection.scope
 
+        case relation_schema.type
+        when 'ManyToOne' then nil
+        when 'OneToOne' then return unless belongs_to_chain_through?(reflection)
+        else return
+        end
+
         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
 
         target
       end
 
+      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
+        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)
+        return false unless reflection.through_reflection?
+
+        through = reflection.through_reflection
+        source = reflection.source_reflection
+
+        through && source && through.belongs_to? && source.belongs_to? &&
+          through.scope.nil? && source.scope.nil? && through.klass.default_scopes.empty? &&
+          same_database?(reflection.active_record, through.klass)
+      rescue StandardError
+        false
+      end
+
       def same_database?(model_a, model_b)
         # compare the pools, not connection_specification_name (only an owner class name, shared across shards)
         model_a.connection_pool == model_b.connection_pool
@@ -330,6 +378,15 @@ module ForestAdminDatasourceActiveRecord
         @query
       end
 
+      def root_through_foreign_key(collection, relation_name)
+        through = collection.model.reflect_on_association(relation_name.to_sym)&.through_reflection
+        return unless through&.belongs_to?
+
+        through.foreign_key
+      rescue StandardError
+        nil
+      end
+
       def resolve_field(original_field)
         if original_field.include?(':')
           relation_name, column_name = original_field.split(':')

data/lib/forest_admin_datasource_active_record/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminDatasourceActiveRecord
-  VERSION = "1.34.2"
+  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.34.2
+  version: 1.35.1
 platform: ruby
 authors:
 - Matthieu