forest_admin_datasource_active_record 1.39.4 → 1.40.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b449c8be1d6a6e9cc36ee341a071615ee75d85854d1c706608fcdbd98d48c58f
-  data.tar.gz: 59d19e7d934051127d598120ceb879d1cd2e6b673f43f9c1c04ade23c60ca8e0
+  metadata.gz: b924a7fc6ab865fa83285d4dc554e0d2124b26c2b998d6c06c3dcfcd357d313d
+  data.tar.gz: dfd941d070ddb69f934b43db627d83ed0dac8af12fcf3dbf5f6594bdfaae617d
 SHA512:
-  metadata.gz: 1167b2f625cbf6efe207d802cd722d2c66c412e086eab826b1ba0ccc41278cee545e60f44bcd0ccbf179ed8c4485f9634d527fa6eb5694dce21ba0ddac4f9cce
-  data.tar.gz: a8878e3b5ca60b90fa06b6de164467ee6d3ba7beeff68523b60cb3fb86bb95e4290fde648311f60812362bd4727093ae440b9d19f13c0b16614f378df94ed982
+  metadata.gz: 13177d23d5702e9a93d282e09c213c8b99fb2d5ba47828712e3fc67b84a198e67bf65848af806ce58f084c8465bda80ad282c29da73b0413a3e50aac6b38bf0c
+  data.tar.gz: 297df24c7a0e70780552f7f0b4712860171930f57cce1c0a7a602732e73ace9ce187e41dde2e8e9048c5796c7674b8a23dd077895bcb05b64cdb96de6e4bc456

data/lib/forest_admin_datasource_active_record/collection.rb

@@ -88,6 +88,69 @@ module ForestAdminDatasourceActiveRecord
       %i[destroy destroy_async delete_all].include?(association.options[:dependent])
     end
 
+    # join_foreign_key can fall back to the through model's own PK (see
+    # valid_many_to_many_source? below); that PK usually still exists as a column, so
+    # "column missing" alone doesn't catch every unrepresentable case -- a composite key is
+    # unrepresentable too, even when every individual column exists: GeneratorField looks
+    # fields up by the raw key, so a composite key never resolves. A composite key can reach
+    # us either as a real Array, or (via an explicit primary_key: option on the source)
+    # already flattened by Rails into a mangled String like '["a", "b"]' -- neither is ever a
+    # real column name, so checking column membership catches both forms uniformly, on
+    # whichever collection each key is actually resolved against downstream (#370).
+    def unrepresentable_many_to_many?(association, through_reflection)
+      [
+        [association.join_foreign_key, through_reflection.klass],
+        [through_reflection.foreign_key, through_reflection.klass],
+        [association.association_primary_key, association.klass]
+      ].any? { |key, klass| !klass.column_names.include?(key) }
+    end
+
+    # True only for a belongs_to source: ThroughReflection#join_foreign_key delegates to
+    # the source reflection, and only belongs_to overrides it to return a real FK column.
+    # Any other source macro falls back to AssociationReflection#active_record_primary_key
+    # -- the through model's own primary key column (honoring a custom primary_key:, and
+    # possibly composite), not a genuine join column (#370).
+    def valid_many_to_many_source?(association)
+      association.source_reflection&.belongs_to?
+    end
+
+    # Same criterion as unrepresentable_many_to_many?: a composite primary key can arrive as a
+    # real Array or already flattened by Rails into a mangled String -- checking column
+    # membership catches both forms, plus a custom primary_key pointing at a non-column, all of
+    # which would otherwise hit nil.column_type in build_one_to_one_schema (#379).
+    def unrepresentable_one_to_one?(association)
+      !association.klass.column_names.include?(association.klass.primary_key) ||
+        !@model.column_names.include?(@model.primary_key)
+    end
+
+    def build_many_to_many_field(association, through_reflection, is_polymorphic, source_polymorphic)
+      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
+      )
+    end
+
+    def add_many_to_many_field(association, through_reflection, is_polymorphic, source_polymorphic)
+      if unrepresentable_many_to_many?(association, through_reflection)
+        warn_unrepresentable_many_to_many(association, through_reflection)
+        return
+      end
+
+      add_field(
+        association.name.to_s,
+        build_many_to_many_field(association, through_reflection, is_polymorphic, source_polymorphic)
+      )
+      warn_identity_join(association, through_reflection) unless valid_many_to_many_source?(association)
+    end
+
     # rubocop:disable Metrics/BlockNesting
     def fetch_associations
       associations(@model, support_polymorphic_relations: @support_polymorphic_relations).each do |association|
@@ -99,32 +162,23 @@ module ForestAdminDatasourceActiveRecord
               is_polymorphic = through_reflection.options[:as].present?
               source_polymorphic = association.source_reflection&.polymorphic? &&
                                    association.options[:source_type].present?
+              many_to_many_shape = is_polymorphic || source_polymorphic
 
-              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
-                  )
-                )
+              if many_to_many_shape
+                add_many_to_many_field(association, through_reflection, is_polymorphic, source_polymorphic)
+              elsif unrepresentable_one_to_one?(association)
+                warn_unrepresentable_one_to_one(association, through_reflection)
               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
+                    origin_key_target: @model.primary_key,
+                    is_read_only: true
                   )
                 )
+                warn_readonly_identity_join(association, through_reflection)
               end
             elsif association.inverse_of&.polymorphic?
               add_field(
@@ -186,21 +240,7 @@ 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
-                )
-              )
+              add_many_to_many_field(association, through_reflection, is_polymorphic, source_polymorphic)
             elsif association.inverse_of&.polymorphic?
               add_field(
                 association.name.to_s,
@@ -303,6 +343,65 @@ module ForestAdminDatasourceActiveRecord
       klass
     end
 
+    def warn_unrepresentable_many_to_many(association, through_reflection)
+      logger = ActiveSupport::Logger.new($stdout)
+      logger.warn(
+        "[ForestAdmin] ⚠️  Skipping association '#{association.name}' in model '#{@model.name}': " \
+        'this relation cannot be represented as a Forest Admin many-to-many -- its join keys must ' \
+        'each be a single existing column, on the through collection ' \
+        "'#{format_model_name(through_reflection.klass.name)}' or the foreign collection " \
+        "'#{format_model_name(association.klass.name)}' (composite/query_constraints keys are " \
+        'not supported).'
+      )
+    end
+
+    # join_foreign_key/association_primary_key are guaranteed to be single, real, existing
+    # columns here: unrepresentable_many_to_many? above already checks column membership for
+    # both (and for origin_key) before this is ever called.
+    #
+    # Deliberately a diagnostic, not a deprecation notice: this shape is common (any
+    # has_many/has_one :through sourced from a plain has_one/has_many, not just polymorphic
+    # ones) and the relation is kept published to avoid narrowing the schema -- see #370.
+    # No removal is promised or planned.
+    def warn_identity_join(association, through_reflection)
+      logger = ActiveSupport::Logger.new($stdout)
+      logger.warn(
+        "[ForestAdmin] ⚠️  Association '#{association.name}' in model '#{@model.name}' is published " \
+        "as a many-to-many joining '#{format_model_name(through_reflection.klass.name)}'." \
+        "'#{association.join_foreign_key}' to " \
+        "'#{format_model_name(association.klass.name)}'.'#{association.association_primary_key}': " \
+        "its source association is not a belongs_to, so this join uses each side's own identifier " \
+        'rather than a dedicated foreign key column -- see #370 for background.'
+      )
+    end
+
+    def warn_unrepresentable_one_to_one(association, through_reflection)
+      logger = ActiveSupport::Logger.new($stdout)
+      logger.warn(
+        "[ForestAdmin] ⚠️  Skipping association '#{association.name}' in model '#{@model.name}': " \
+        "this has_one :through (via '#{format_model_name(through_reflection.klass.name)}') can't be " \
+        'represented as a Forest Admin one-to-one -- one of its endpoints has a composite primary key.'
+      )
+    end
+
+    # OneToOneSchema has no through_collection, so this publishes each side's own primary key
+    # as a placeholder join -- the columns exist on both sides, so GeneratorField's field
+    # lookups don't raise, but the join isn't meaningful data (it matches two unrelated
+    # sequences), which is exactly why it's marked read-only rather than left writable through
+    # what's really the foreign collection's own primary key (#379).
+    def warn_readonly_identity_join(association, through_reflection)
+      logger = ActiveSupport::Logger.new($stdout)
+      foreign_key = association.klass.primary_key
+      origin_key = @model.primary_key
+      logger.warn(
+        "[ForestAdmin] ⚠️  Association '#{association.name}' in model '#{@model.name}' is published " \
+        "as a read-only one-to-one joining '#{format_model_name(association.klass.name)}'.'#{foreign_key}' " \
+        "to this model's own '#{origin_key}': it's a has_one chained through " \
+        "'#{format_model_name(through_reflection.klass.name)}', which OneToOneSchema can't express as a " \
+        'real two-hop join -- see #379 for background.'
+      )
+    end
+
     def warn_missing_polymorphic_columns(association)
       missing_columns = []
       missing_columns << association.foreign_key unless schema[:fields][association.foreign_key]

data/lib/forest_admin_datasource_active_record/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminDatasourceActiveRecord
-  VERSION = "1.39.4"
+  VERSION = "1.40.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_datasource_active_record
 version: !ruby/object:Gem::Version
-  version: 1.39.4
+  version: 1.40.1
 platform: ruby
 authors:
 - Matthieu
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-26 00:00:00.000000000 Z
+date: 2026-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord