declare_schema 3.0.0 → 3.1.0.colin.2

data/lib/declare_schema/model.rb

@@ -100,6 +100,7 @@ module DeclareSchema
         _add_validations_for_field(name, type, args, options)
         _add_index_for_field(name, args, **options)
         _add_scopes_for_field(name, type, **options)
+        name.to_s == _declared_primary_key and raise ArgumentError, "no need to declare a field spec for the primary key #{name.inspect}"
         field_specs[name] = ::DeclareSchema::Model::FieldSpec.new(self, name, type, position: field_specs.size, **options)
         attr_order << name unless attr_order.include?(name)
       end
@@ -201,62 +202,105 @@ module DeclareSchema
         super
 
         reflection = reflections[name.to_s] or raise "Couldn't find reflection #{name} in #{reflections.keys}"
-        foreign_key_column = reflection.foreign_key or raise "Couldn't find foreign_key for #{name} in #{reflection.inspect}"
-        foreign_key_column_options = column_options.dup
-
-        # Note: the foreign key limit: should match the primary key limit:. (If there is a foreign key constraint,
-        # those limits _must_ match.) We'd like to call _infer_fk_limit and get the limit right from the PK.
-        # But we can't here, because that will mess up the autoloader to follow every belongs_to association right
-        # when it is declared. So instead we assume :bigint (integer limit: 8) below, while also registering this
-        # pre_migration: callback to double-check that assumption Just In Time--right before we generate a migration.
-        #
-        # The one downside of this approach is that application code that asks the field_spec for the declared
-        # foreign key limit: will always get 8 back even if this is a grandfathered foreign key that points to
-        # a limit: 4 primary key. It seems unlikely that any application code would do this.
-        foreign_key_column_options[:pre_migration] = ->(field_spec) do
-          if (inferred_limit = _infer_fk_limit(foreign_key_column, reflection))
-            field_spec.sql_options[:limit] = inferred_limit
-          end
-        end
+        foreign_key_column_name = reflection.foreign_key or raise "Couldn't find foreign_key for #{name} in #{reflection.inspect}"
 
-        declare_field(foreign_key_column.to_sym, :bigint, **foreign_key_column_options)
+        field_specs[foreign_key_column_name] = _infer_foreign_key_field_spec(foreign_key_column_name, reflection, column_options)
 
         if reflection.options[:polymorphic]
           foreign_type = options[:foreign_type] || "#{name}_type"
           _declare_polymorphic_type_field(foreign_type, column_options)
           if ::DeclareSchema.default_generate_indexing && index_options
-            index([foreign_type, foreign_key_column], **index_options)
+            index([foreign_type, foreign_key_column_name], **index_options)
           end
         else
           if ::DeclareSchema.default_generate_indexing && index_options
-            index([foreign_key_column], **index_options)
+            index([foreign_key_column_name], **index_options)
           end
 
           if ::DeclareSchema.default_generate_foreign_keys && constraint_name != false
-            constraint(foreign_key_column, constraint_name: constraint_name || index_options&.[](:name), parent_class_name: reflection.class_name, dependent: dependent_delete)
+            constraint(foreign_key_column_name,
+                       constraint_name: constraint_name || index_options&.[](:name),
+                       parent_class_name: reflection.class_name,
+                       dependent: dependent_delete)
           end
         end
       end
 
-      def _infer_fk_limit(foreign_key_column, reflection)
+      # Returns a FieldSpec for the foreign key column of a belongs_to association.
+      # - For a polymorphic association, the FK uses `DeclareSchema.default_generated_primary_key_type`
+      #   (mirroring `config.generators.primary_key_type`, default :bigint), or :integer with the
+      #   existing column's limit if the column already exists in the database.
+      # - For a non-polymorphic association, the FK should mirror the primary key it points
+      #   at (same data type, same options like limit:, charset:, etc.). However we cannot
+      #   load the parent model right now (at `belongs_to` time) without risking dependency
+      #   cycles between models, so we install a `resolver:` callback. The migration
+      #   generator calls that resolver at generation time -- after all models are
+      #   eager-loaded -- and the resolver returns a fully-mirrored FieldSpec that the
+      #   generator swaps in for this default_spec.
+      def _infer_foreign_key_field_spec(foreign_key_column_name, reflection, column_options)
         if reflection.options[:polymorphic]
-          if (foreign_key_column = _column(foreign_key_column)) && foreign_key_column.type == :integer
-            foreign_key_column.limit
+          if (foreign_key_column = _column(foreign_key_column_name)) && foreign_key_column.type == :integer
+            # grandfather foreign key column to match what's in the database
+            column_options = column_options.merge(limit: foreign_key_column.limit)
           end
+          FieldSpec.new(self, foreign_key_column_name, DeclareSchema.default_generated_primary_key_type, position: field_specs.size, **column_options)
         else
-          klass = reflection.klass or raise "Couldn't find belongs_to klass for #{name} in #{reflection.inspect}"
-          if (pk_id_type = klass._table_options&.[](:id))
-            if pk_id_type == :integer
-              4
-            end
-          else
-            if klass.table_exists? && (pk_column = klass.columns_hash[klass._declared_primary_key])
-              pk_id_type = pk_column.type
-              if pk_id_type == :integer
-                pk_column.limit
-              end
-            end
+          # Capture only what we need from `reflection` (no `reflection.klass` here -- that
+          # would force the parent model to load, which is exactly the cycle we are avoiding).
+          # `reflection.klass` is resolved lazily inside the block below.
+          resolver = ->(default_spec) do
+            _resolve_belongs_to_foreign_key_field_spec(reflection, default_spec)
           end
+          FieldSpec.new(self, foreign_key_column_name, DeclareSchema.default_generated_primary_key_type,
+                        position: field_specs.size, resolver:, **column_options)
+        end
+      end
+
+      # Called at migration generation time to mirror the parent model's primary key.
+      # Always returns a FieldSpec: the default_spec unchanged when the parent class is not
+      # a declare_schema model (we can't ask for its PK spec, so the configured default PK
+      # type is the best we can offer without inspecting the DB), otherwise a fully mirrored
+      # FieldSpec.
+      #
+      # Reconciliation with the live DB: if the parent's PK column already exists in the
+      # database with the same Rails type but a different :limit (e.g. a legacy table where
+      # `id` is INT(4) but the model now declares the default :bigint), prefer the live
+      # column's :limit so the FK matches what's actually on disk. This preserves the
+      # behavior of the old DB-column lookup (formerly `fk_field_options`) without
+      # overriding intentional type changes.
+      def _resolve_belongs_to_foreign_key_field_spec(reflection, default_spec)
+        klass = reflection.klass or
+          raise "Couldn't find belongs_to klass for #{reflection.name} on #{name} in #{reflection.inspect}"
+
+        if klass.respond_to?(:_primary_key_field_spec)
+          _mirror_parent_primary_key(klass, default_spec)
+        else
+          default_spec
+        end
+      end
+
+      # Build a FieldSpec for the FK by mirroring the parent's declared primary key,
+      # then reconciling against the live DB column when it differs only in :limit
+      # (see _resolve_belongs_to_foreign_key_field_spec for the full rationale).
+      def _mirror_parent_primary_key(klass, default_spec)
+        spec = klass._primary_key_field_spec.foreign_key_field_spec(
+          default_spec.model, default_spec.name,
+          position: default_spec.position, null: default_spec.null
+        )
+
+        # Look up the parent's live PK column directly (not via _column, whose
+        # @table_exists memoization can pin to a stale value when the parent table
+        # is created after the model class is first defined). The rescue covers
+        # the table-doesn't-exist-yet case (greenfield migration).
+        live_pk_column = klass.columns_hash[klass._declared_primary_key.to_s] rescue nil
+        if live_pk_column && live_pk_column.type == spec.type && live_pk_column.limit && live_pk_column.limit != spec.limit
+          FieldSpec.new(
+            spec.model, spec.name, spec.type,
+            position: spec.position,
+            **spec.options.merge(limit: live_pk_column.limit)
+          )
+        else
+          spec
         end
       end
 
@@ -273,8 +317,42 @@ module DeclareSchema
         end
       end
 
+      # Returns a FieldSpec for a foreign key pointing to the primary key of this model.
+      # Exactly matches the primary key type.
+      def _foreign_key_field_spec(model, foreign_key, position:, null:)
+        _primary_key_field_spec.foreign_key_field_spec(model, foreign_key, position:, null:)
+      end
+
+      def _primary_key_field_spec
+        declared_primary_key = _declared_primary_key
+        field_specs[declared_primary_key] || _primary_key_field_spec_from_table_options(declared_primary_key) or
+          raise "Declared primary key #{declared_primary_key.inspect} not found in field_specs or _table_options #{_table_options.inspect} for #{name}"
+      end
+
+      def _primary_key_field_spec_from_table_options(declared_primary_key)
+        # _table_options is nil on STI subclasses that never call `declare_schema` themselves:
+        # they inherit `field_specs` etc. via `inheriting_cattr_reader`, but `@_table_options`
+        # is a plain class-instance variable on each class, so the subclass's reader returns
+        # nil. Treat that the same as an empty options hash and fall through to
+        # `default_generated_primary_key_type` below.
+        type, options = _parse_pk_table_options(_table_options&.[](declared_primary_key.to_sym))
+        type ||= DeclareSchema.default_generated_primary_key_type
+        FieldSpec.new(self, declared_primary_key, type, **options)
+      end
+
       private
 
+      # `declare_schema id: ...` accepts either a Hash (`id: { type: :integer, limit: 4 }`)
+      # or a bare type Symbol (`id: :integer`). Returns [type, options_hash], with type == nil
+      # when value is neither (caller falls back to a default).
+      def _parse_pk_table_options(value)
+        case value
+        when Hash   then [value[:type], value.except(:type)]
+        when Symbol then [value, {}]
+        else             [nil, {}]
+        end
+      end
+
       # if this is a derived class, returns the base class's _declared_primary_key
       # otherwise, returns 'id'
       def _default_declared_primary_key

data/lib/declare_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeclareSchema
-  VERSION = "3.0.0"
+  VERSION = "3.1.0.colin.2"
 end

data/lib/declare_schema.rb

@@ -162,17 +162,21 @@ module DeclareSchema
     end
 
     def current_adapter(model_class = ActiveRecord::Base)
-      if Rails::VERSION::MAJOR >= 6.1
-        model_class.connection_db_config.adapter
-      else
-        model_class.connection_config[:adapter]
-      end
+      model_class.connection_db_config.adapter
+    end
+
+    # Default primary key type for generated foreign keys when we have no parent
+    # model to mirror (e.g. polymorphic FKs, non-declare_schema parents). Mirrors
+    # `config.generators.primary_key_type` so apps that override the Rails default
+    # get consistent behavior. Memoized — Rails config is set at boot.
+    def default_generated_primary_key_type
+      @default_generated_primary_key_type ||=
+        Rails.application.config.generators.options.dig(:active_record, :primary_key_type) || :bigint
     end
   end
 end
 
 require 'declare_schema/extensions/active_record/fields_declaration'
-require 'declare_schema/field_declaration_dsl'
 require 'declare_schema/model'
 require 'declare_schema/model/field_spec'
 require 'declare_schema/model/index_definition'

data/lib/generators/declare_schema/migration/migrator.rb

@@ -80,15 +80,13 @@ module Generators
           self.class.native_types
         end
 
-        # list habtm join tables
+        # return habtm reflections keyed by join table name (so that habtm from each side has just one entry)
         def habtm_tables
-          reflections = Hash.new { |h, k| h[k] = [] }
-          ActiveRecord::Base.send(:descendants).map do |c|
+          ActiveRecord::Base.send(:descendants).each_with_object({}) do |c, result|
             c.reflect_on_all_associations(:has_and_belongs_to_many).each do |a|
-              reflections[a.join_table] << a
+              result[a.join_table] ||= a
             end
           end
-          reflections
         end
 
         # Returns an array of model classes and an array of table names
@@ -189,11 +187,7 @@ module Generators
           models, db_tables = models_and_tables
           models_by_table_name = {}
           models.each do |m|
-            m.try(:field_specs)&.each do |_name, field_spec|
-              if (pre_migration = field_spec.options.delete(:pre_migration))
-                pre_migration.call(field_spec)
-              end
-            end
+            m.try(:field_specs)&.transform_values!(&:resolve)
 
             if !models_by_table_name.has_key?(m.table_name)
               models_by_table_name[m.table_name] = m
@@ -204,8 +198,8 @@ module Generators
             end
           end
           # generate shims for HABTM models
-          habtm_tables.each do |name, reflections|
-            models_by_table_name[name] = ::DeclareSchema::Model::HabtmModelShim.from_reflection(reflections.first)
+          habtm_tables.each do |name, reflection|
+            models_by_table_name[name] = ::DeclareSchema::Model::HabtmModelShim.from_reflection(reflection)
           end
           model_table_names = models_by_table_name.keys
 
@@ -376,21 +370,26 @@ module Generators
             ::DeclareSchema::SchemaChange::ColumnRename.new(new_table_name, old_name, new_name)
           end
 
-          to_add.sort_by! { |c| model.field_specs[c]&.position || 0 }
+          to_add.sort_by! { model.field_specs[_1]&.position || 0 }
 
-          adds = to_add.map do |c|
+          adds = to_add.map do |col_name_to_add|
             type, options =
-              if (spec = model.field_specs[c])
-                [spec.type, spec.sql_options.merge(fk_field_options(model, c)).compact]
+              if (spec = model.field_specs[col_name_to_add])
+                [spec.type, spec.sql_options.compact]
               else
-                [:integer, {}]
+                # No FieldSpec for this column: it's the declared PK appended at line 366
+                # because it isn't in the DB yet. Use the configured default PK type so
+                # apps that override config.generators.primary_key_type get consistent
+                # behavior; the actual PRIMARY KEY designation is added separately by
+                # PrimaryKeyChange.
+                [::DeclareSchema.default_generated_primary_key_type, {}]
               end
-            ::DeclareSchema::SchemaChange::ColumnAdd.new(new_table_name, c, type, **options)
+            ::DeclareSchema::SchemaChange::ColumnAdd.new(new_table_name, col_name_to_add, type, **options)
           end
 
-          removes = to_remove.map do |c|
-            old_type, old_options = add_column_back(model, current_table_name, c)
-            ::DeclareSchema::SchemaChange::ColumnRemove.new(new_table_name, c, old_type, **old_options)
+          removes = to_remove.map do |col_name_to_remove|
+            old_type, old_options = add_column_back(model, current_table_name, col_name_to_remove)
+            ::DeclareSchema::SchemaChange::ColumnRemove.new(new_table_name, col_name_to_remove, old_type, **old_options)
           end
 
           old_names = to_rename.invert
@@ -402,13 +401,12 @@ module Generators
             spec_attrs         = spec.schema_attributes(column)
             column_declaration = ::DeclareSchema::Model::Column.new(model, current_table_name, column)
             col_attrs          = column_declaration.schema_attributes
-            normalized_schema_attrs = spec_attrs.merge(fk_field_options(model, col_name_to_change))
 
-            if !::DeclareSchema::Model::Column.equivalent_schema_attributes?(normalized_schema_attrs, col_attrs)
-              type = normalized_schema_attrs.delete(:type) or raise "no :type found in #{normalized_schema_attrs.inspect}"
+            if !::DeclareSchema::Model::Column.equivalent_schema_attributes?(spec_attrs, col_attrs)
+              type = spec_attrs.delete(:type) or raise "no :type found in #{spec_attrs.inspect}"
               old_type, old_options = change_column_back(model, current_table_name, orig_col_name)
               changes << ::DeclareSchema::SchemaChange::ColumnChange.new(new_table_name, col_name_to_change,
-                                                                         new_type: type, new_options: normalized_schema_attrs,
+                                                                         new_type: type, new_options: spec_attrs,
                                                                          old_type: old_type, old_options: old_options)
             end
           end
@@ -546,22 +544,6 @@ module Generators
           end
         end
 
-        def fk_field_options(model, field_name)
-          if (foreign_key = model.constraint_definitions.find { |fk| field_name == fk.foreign_key_column })
-            parent_columns = connection.columns(foreign_key.parent_table_name) rescue []
-            pk_limit =
-              if (pk_column = parent_columns.find { |column| column.name.to_s == "id" }) # right now foreign keys assume id is the target
-                pk_column.limit
-              else
-                8
-              end
-
-            { limit: pk_limit }
-          else
-            {}
-          end
-        end
-
         def change_table_options(model, current_table_name)
           old_options_definition = ::DeclareSchema::Model::TableOptionsDefinition.for_model(model, current_table_name)
           new_options_definition = ::DeclareSchema::Model::TableOptionsDefinition.new(model.table_name, **table_options_for_model(model))

data/spec/lib/declare_schema/field_spec_spec.rb

@@ -25,6 +25,38 @@ RSpec.describe DeclareSchema::Model::FieldSpec do
     end
   end
 
+  describe '#resolve' do
+    let(:default_spec) { described_class.new(model, :advertiser_id, :integer, limit: 8, null: false, position: 1) }
+    let(:mirrored_spec) { described_class.new(model, :advertiser_id, :string, limit: 36, null: false, position: 1) }
+
+    context 'when no resolver was supplied' do
+      it 'returns self' do
+        expect(default_spec.resolve).to equal(default_spec)
+      end
+    end
+
+    context 'when a resolver was supplied' do
+      it 'invokes the resolver with self and returns its result' do
+        captured = nil
+        spec_under_test = described_class.new(model, :advertiser_id, :integer, limit: 8, null: false, position: 1,
+                                              resolver: ->(spec) { captured = spec; mirrored_spec })
+
+        expect(spec_under_test.resolve).to equal(mirrored_spec)
+        expect(captured).to equal(spec_under_test)
+      end
+
+      it 'memoizes the resolver result' do
+        call_count = 0
+        spec_under_test = described_class.new(model, :advertiser_id, :integer, limit: 8, null: false, position: 1,
+                                              resolver: ->(_spec) { call_count += 1; mirrored_spec })
+
+        3.times { spec_under_test.resolve }
+
+        expect(call_count).to eq(1)
+      end
+    end
+  end
+
   describe '#schema_attributes' do
     describe 'integer 4' do
       subject { described_class.new(model, :price, :integer, limit: 4, null: false, position: 0) }

data/spec/lib/declare_schema/migration_generator_spec.rb

@@ -988,6 +988,140 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       nuke_model_class(Creative)
     end
 
+    context 'foreign keys mirror non-default primary key types' do
+      after do
+        nuke_model_class(SpecialOrder)       if defined?(SpecialOrder)
+        nuke_model_class(Order)              if defined?(Order)
+        nuke_model_class(LineItem)           if defined?(LineItem)
+        nuke_model_class(Tag)                if defined?(Tag)
+        nuke_model_class(Product)            if defined?(Product)
+        nuke_model_class(ProductsTagsClass)  if defined?(ProductsTagsClass)
+      end
+
+      it 'belongs_to defers parent class lookup to migration time (no dependency cycle)' do
+        # LineItem.belongs_to :order is allowed to mention :order before Order is loaded.
+        # If we eagerly resolved reflection.klass at belongs_to time this would raise
+        # NameError: uninitialized constant LineItem::Order.
+        expect do
+          class LineItem < ActiveRecord::Base # rubocop:disable Lint/ConstantDefinitionInBlock
+            declare_schema { integer :quantity, null: false }
+            belongs_to :order
+          end
+        end.to_not raise_error
+      end
+
+      it 'belongs_to mirrors the parent primary key type and limit (declared via _table_options)' do
+        # Order has a non-default :string primary key; LineItem.belongs_to :order should
+        # produce a :string foreign key with the same limit -- without forcing Order to
+        # load when LineItem is defined.
+        class LineItem < ActiveRecord::Base # rubocop:disable Lint/ConstantDefinitionInBlock
+          declare_schema do
+            integer :quantity, null: false
+          end
+          belongs_to :order
+        end
+
+        class Order < ActiveRecord::Base # rubocop:disable Lint/ConstantDefinitionInBlock
+          self.primary_key = "id"
+          declare_schema id: { type: :string, limit: 36 } do
+            string :customer_email, limit: 250, null: false
+          end
+        end
+
+        up, _ = Generators::DeclareSchema::Migration::Migrator.run
+
+        expect(up).to match(/t\.string\s+:order_id, limit: 36, null: false/)
+      end
+
+      context 'when belongs_to points at an STI subclass' do
+        # An STI subclass inherits field_specs (via inheriting_cattr_reader) and the
+        # `_primary_key_field_spec` class method (mixed into its parent), but it never
+        # calls `declare_schema` on itself, so its own `@_table_options` is nil. When a
+        # belongs_to points at the STI subclass, the migrator's resolver calls
+        # `klass._primary_key_field_spec`, which previously crashed with
+        # `NoMethodError: undefined method '[]' for nil` because
+        # `_primary_key_field_spec_from_table_options` indexed `_table_options` without
+        # a nil guard.
+        before do
+          class Order < ActiveRecord::Base # rubocop:disable Lint/ConstantDefinitionInBlock
+            declare_schema do
+              string :customer_email, limit: 250, null: false
+            end
+          end
+
+          class SpecialOrder < Order # rubocop:disable Lint/ConstantDefinitionInBlock
+          end
+
+          class LineItem < ActiveRecord::Base # rubocop:disable Lint/ConstantDefinitionInBlock
+            declare_schema do
+              integer :quantity, null: false
+            end
+            belongs_to :special_order
+          end
+        end
+
+        let(:up) { Generators::DeclareSchema::Migration::Migrator.run.first }
+
+        it 'mirrors the base class primary key without crashing' do
+          expect(up).to match(/t\.integer\s+:special_order_id, limit: 8, null: false/)
+        end
+      end
+
+      context 'when a HABTM join table has a parent PK type that drifts from the live column' do
+        before do
+          conn = ActiveRecord::Base.connection
+          conn.create_table(:products) { |t| t.string :name, limit: 100, null: false }
+          conn.create_table(:tags)     { |t| t.string :label, limit: 50, null: false }
+          conn.create_table(:products_tags, primary_key: [:product_id, :tag_id]) do |t|
+            t.bigint :product_id, null: false
+            t.bigint :tag_id,     null: false
+          end
+          conn.schema_cache.clear!
+
+          class Product < ActiveRecord::Base # rubocop:disable Lint/ConstantDefinitionInBlock
+            declare_schema do
+              string :name, limit: 100, null: false
+            end
+            has_and_belongs_to_many :tags
+          end
+
+          class Tag < ActiveRecord::Base # rubocop:disable Lint/ConstantDefinitionInBlock
+            declare_schema id: { type: :string, limit: 36 } do
+              string :label, limit: 50, null: false
+            end
+            has_and_belongs_to_many :products
+          end
+        end
+
+        let(:up) { Generators::DeclareSchema::Migration::Migrator.run.first }
+
+        it 'generates change_column on the join table without crashing' do
+          expect(up).to match(/change_column\s+:products_tags,\s+:tag_id,\s+:string/)
+        end
+      end
+
+      it 'HABTM mirrors both parents primary key types (different non-default types)' do
+        class Product < ActiveRecord::Base # rubocop:disable Lint/ConstantDefinitionInBlock
+          declare_schema id: { type: :string, limit: 36 } do
+            string :name, limit: 100, null: false
+          end
+          has_and_belongs_to_many :tags
+        end
+
+        class Tag < ActiveRecord::Base # rubocop:disable Lint/ConstantDefinitionInBlock
+          declare_schema id: { type: :integer, limit: 4 } do
+            string :label, limit: 50, null: false
+          end
+          has_and_belongs_to_many :products
+        end
+
+        up, _ = Generators::DeclareSchema::Migration::Migrator.run
+
+        expect(up).to match(/t\.string\s+:product_id, limit: 36, null: false/)
+        expect(up).to match(/t\.integer\s+:tag_id, limit: 4, null: false/)
+      end
+    end
+
     context 'models with the same parent foreign key relation' do
       include_context 'skip if' do
         let(:adapter) { 'sqlite3' }

data/spec/lib/declare_schema/model/habtm_model_shim_spec.rb

@@ -41,7 +41,12 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
   end
 
   describe 'instance methods' do
-    subject { described_class.new(join_table, foreign_keys, parent_table_names, connection: connection) }
+    let(:parent_models) { [User, Customer] }
+    let(:parents) { foreign_keys.zip(parent_models) }
+
+    subject do
+      described_class.new(join_table, parents, connection: connection)
+    end
 
     describe '#initialize' do
       it 'stores initialization attributes' do
@@ -88,8 +93,8 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
     end
 
     describe '#primary_key' do
-      it 'returns false because there is no single-column PK for ActiveRecord to use' do
-        expect(subject.primary_key).to eq(false)
+      it 'returns the composite of the two foreign keys (alphabetically sorted)' do
+        expect(subject.primary_key).to eq(["customer_id", "user_id"])
       end
     end
 
@@ -116,14 +121,15 @@ RSpec.describe DeclareSchema::Model::HabtmModelShim do
       let(:foreign_keys_and_table_names) { [["advertiser_id", "advertisers"], ["campaign_id", "campaigns"]] }
       let(:foreign_keys) { foreign_keys_and_table_names.map(&:first) }
       let(:parent_table_names) { foreign_keys_and_table_names.map(&:last) }
+      let(:parent_models) { [Table1, Table2] }
 
       before do
-        class Table1 < ActiveRecord::Base
-          self.table_name = 'advertiser_campaign'
+        class Table1 < ActiveRecord::Base # rubocop:disable Lint/ConstantDefinitionInBlock
+          self.table_name = 'advertisers'
         end
 
-        class Table2 < ActiveRecord::Base
-          self.table_name = 'tracking_pixel'
+        class Table2 < ActiveRecord::Base # rubocop:disable Lint/ConstantDefinitionInBlock
+          self.table_name = 'campaigns'
         end
       end
 

data/spec/lib/generators/declare_schema/migration/migrator_default_pk_type_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'generators/declare_schema/support/thor_shell'
+
+# Verifies that when the migrator has to add a declared primary key column
+# that has no corresponding FieldSpec (because it was appended to `to_add`
+# at lib/generators/declare_schema/migration/migrator.rb:366), the column
+# type is derived from `DeclareSchema.default_generated_primary_key_type`
+# rather than a hardcoded `:integer`. This matters for apps that override
+# `config.generators.primary_key_type`.
+RSpec.describe 'DeclareSchema.default_generated_primary_key_type integration with Migrator' do
+  include_context 'prepare test app'
+
+  before do
+    if current_adapter == 'mysql2'
+      ActiveRecord::Base.connection.execute("CREATE TABLE foos (id int PRIMARY KEY, name varchar(250))")
+    else
+      ActiveRecord::Base.connection.execute("CREATE TABLE foos (id integer PRIMARY KEY AUTOINCREMENT NOT NULL, name varchar(250))")
+    end
+    ActiveRecord::Base.connection.schema_cache.clear!
+
+    allow_any_instance_of(DeclareSchema::Support::ThorShell)
+      .to receive(:ask).with(/one of the rename choices or press enter to keep/) { 'drop id' }
+  end
+
+  it 'derives the new PK column type from DeclareSchema.default_generated_primary_key_type rather than a hardcoded :integer' do
+    allow(::DeclareSchema).to receive(:default_generated_primary_key_type).and_return(:string)
+
+    class Foo < ActiveRecord::Base # rubocop:disable Lint/ConstantDefinitionInBlock
+      declare_schema do
+        string :name, limit: 250
+      end
+      self.primary_key = "foo_id"
+    end
+
+    up, _down = Generators::DeclareSchema::Migration::Migrator.run
+
+    expect(up).to include("add_column :foos, :foo_id, :string")
+    expect(up).not_to include("add_column :foos, :foo_id, :integer")
+  end
+
+  it 'falls through to the configured Rails default (:bigint) when the helper is not stubbed' do
+    class Foo < ActiveRecord::Base # rubocop:disable Lint/ConstantDefinitionInBlock
+      declare_schema do
+        string :name, limit: 250
+      end
+      self.primary_key = "foo_id"
+    end
+
+    up, _down = Generators::DeclareSchema::Migration::Migrator.run
+
+    expect(up).to include("add_column :foos, :foo_id, #{::DeclareSchema.default_generated_primary_key_type.inspect}")
+  end
+end