declare_schema 1.4.0.colin.7 → 1.4.0.colin.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f8226540260a887af839da5afcb4641217c03ac5a6eb2d7a00da2806188f1ce
-  data.tar.gz: 7eeb464b5bfc9b1fbf88446696ede88b8ea582060658421cf2772e62a6205797
+  metadata.gz: 7e20de5eeec8ea9436d2fd674f5ff33f20888cfb87e17456fd278a38504bbede
+  data.tar.gz: 259d8dd463292836e40d3fe07261743e714d588440d8a988183daa32f0c8a4d9
 SHA512:
-  metadata.gz: 2294e94f2165ec156807fbf9ba98dea10f191bfda1b4c630f5444ab08ee7f80323e86a9af80e968e20e579e21ba24ddef520312a7f0a146d850b6f8927aa50aa
-  data.tar.gz: 2742ce98af1fb6ef8eb4ba1fa40563a635abb584cc1860efd373a474c6dce9fc1a27b630141f94ea6a23f36602d8381b08d6a33b13b6fd3d352b40df85f37daf
+  metadata.gz: 18dc843b60c81ace18bc692f1e8d76038d50695081ab846b14f0653aa4d6a755666417f4d7190429aa83e9eb9fffba02d61c71b2a5c44ef7dbf69baf401e7e31
+  data.tar.gz: 94bf1af85ecdc252e08f6453018edc6a2f216e65aa6d7fce0ab7399058097d6a0e1a834e02d350789e8e6fb3485050979dde543e2036e048cc914dd6ffb5cdad

data/CHANGELOG.md

@@ -10,6 +10,16 @@ Note: this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0
 ### Changed
 - Deprecate index: 'name' and unique: true|false in favor of index: { name: 'name', unique: true|false }.
 
+## [1.3.4] - 2024-01-18
+### Fixed
+- Add test for migrating `has_and_belongs_to_many` associations and fix them to properly declare their
+  2 foreign keys as the primary key of the join table, rather than just a unique index.
+
+## [1.3.3] - 2024-01-17
+### Fixed
+- Fix a MySQL 8 bug where MySQL 8+ renames charset 'utf8' to 'utf8mb3' and collation 'utf8_general_ci' to
+  'utf8mb3_unicode_ci'.
+
 ## [1.3.2] - 2024-01-12
 ### Fixed
 - Fix bug in migrator when table option definitions differ

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    declare_schema (1.4.0.colin.7)
+    declare_schema (1.4.0.colin.9)
       rails (>= 5.0)
 
 GEM

data/README.md

@@ -176,7 +176,7 @@ DeclareSchema.clear_default_schema
 ```
 
 ### Global Configuration
-Configurations can be set at globally to customize default declaration for the following values:
+Configurations can be set globally to customize default declaration for the following values:
 
 #### Text Limit
 The default text limit can be set using the `DeclareSchema.default_text_limit=` method.
@@ -256,6 +256,9 @@ turn all tables into `utf8mb4` supporting tables:
 DeclareSchema.default_charset   = "utf8mb4"
 DeclareSchema.default_collation = "utf8mb4_bin"
 ```
+Note: MySQL 8+ aliases charset 'utf8' to 'utf8mb3', and 'utf8_general_ci' to 'utf8mb3_unicode_ci',
+so when running on MySQL 8+, those aliases will be applied by `DeclareSchema`.
+
 #### db:migrate Command
 `declare_schema` can run the migration once it is generated, if the `--migrate` option is passed.
 If not, it will display the command to run later. By default this command is

data/lib/declare_schema/model/field_spec.rb

@@ -107,7 +107,9 @@ module DeclareSchema
         if @type.in?([:text, :string])
           if ActiveRecord::Base.connection.class.name.match?(/mysql/i)
             @options[:charset]   ||= model._table_options&.[](:charset)   || ::DeclareSchema.default_charset
+            @options[:charset] = DeclareSchema.normalize_charset(@options[:charset])
             @options[:collation] ||= model._table_options&.[](:collation) || ::DeclareSchema.default_collation
+            @options[:collation] = DeclareSchema.normalize_collation(@options[:collation])
           else
             @options.delete(:charset)
             @options.delete(:collation)

data/lib/declare_schema/model/foreign_key_definition.rb

@@ -7,53 +7,61 @@ module DeclareSchema
     class ForeignKeyDefinition
       include Comparable
 
-      attr_reader :constraint_name, :model, :foreign_key, :foreign_key_name, :child_table_name, :options, :on_delete_cascade
-
-
-      def initialize(model, foreign_key, **options)
-        @model = model
-        @foreign_key = foreign_key.to_s.presence or raise ArgumentError "Foreign key must not be empty: #{foreign_key.inspect}"
-        @options = options
-
-        @child_table_name = model.table_name # unless a table rename, which would happen when a class is renamed??
-        @parent_table_name = options[:parent_table]&.to_s
-        @foreign_key_name = options[:foreign_key]&.to_s || @foreign_key
-
+      attr_reader :foreign_key_column, :constraint_name, :child_table_name, :parent_class_name, :dependent
+
+      # Caller needs to pass either constraint_name or child_table_name, and
+      # either parent_class_name or parent_table_name.
+      def initialize(foreign_key_column, constraint_name: nil, child_table_name: nil, parent_class_name: nil, parent_table_name: nil, dependent: nil)
+        @foreign_key_column = foreign_key_column&.to_s or raise ArgumentError "foreign key must not be empty: #{foreign_key_column.inspect}"
+        @constraint_name = constraint_name&.to_s.presence || ::DeclareSchema::Model::IndexDefinition.default_index_name(child_table_name, [@foreign_key_column])
+        @child_table_name = child_table_name&.to_s or raise ArgumentError, "child_table_name must not be nil"
         @parent_class_name =
-          case class_name = options[:class_name]
+          case parent_class_name
           when String, Symbol
-            class_name.to_s
+            parent_class_name.to_s
           when Class
-            @parent_class = class_name
+            @parent_class = parent_class_name
             @parent_class.name
           when nil
-            @foreign_key.sub(/_id\z/, '').camelize
+            @foreign_key_column.sub(/_id\z/, '').camelize
           end
-
-        @constraint_name = options[:constraint_name]&.to_s.presence ||
-                             model.connection.index_name(model.table_name, column: @foreign_key_name)
-        @on_delete_cascade = options[:dependent] == :delete
+        @parent_table_name = parent_table_name
+        dependent.in?([nil, :delete]) or raise ArgumentError, "dependent: must be nil or :delete"
+        @dependent = dependent
       end
 
       class << self
-        def for_model(model, old_table_name)
-          show_create_table = model.connection.select_rows("show create table #{model.connection.quote_table_name(old_table_name)}").first.last
+        def for_table(child_table_name, connection, dependent: nil)
+          show_create_table = connection.select_rows("show create table #{connection.quote_table_name(child_table_name)}").first.last
           constraints = show_create_table.split("\n").map { |line| line.strip if line['CONSTRAINT'] }.compact
 
           constraints.map do |fkc|
-            name, foreign_key, parent_table = fkc.match(/CONSTRAINT `([^`]*)` FOREIGN KEY \(`([^`]*)`\) REFERENCES `([^`]*)`/).captures
-            options = {
-              constraint_name: name,
-              parent_table:    parent_table,
-              foreign_key:     foreign_key
-            }
-            options[:dependent] = :delete if fkc['ON DELETE CASCADE'] || model.is_a?(DeclareSchema::Model::HabtmModelShim)
-
-            new(model, foreign_key, **options)
+            constraint_name, foreign_key_column, parent_table_name = fkc.match(/CONSTRAINT `([^`]*)` FOREIGN KEY \(`([^`]*)`\) REFERENCES `([^`]*)`/).captures
+            dependent_value = :delete if dependent || fkc['ON DELETE CASCADE']
+
+            new(foreign_key_column,
+                constraint_name: constraint_name,
+                child_table_name: child_table_name,
+                parent_table_name: parent_table_name,
+                dependent: dependent_value)
           end
         end
       end
 
+      def key
+        @key ||= [@child_table_name, @foreign_key_column, @dependent].freeze
+      end
+
+      def <=>(rhs)
+        key <=> rhs.key
+      end
+
+      alias eql? ==
+
+      def equivalent?(rhs)
+        self == rhs
+      end
+
       # returns the parent class as a Class object
       # lazy loaded so that we don't require the parent class until we need it
       def parent_class
@@ -64,21 +72,9 @@ module DeclareSchema
         @parent_table_name ||= parent_class.table_name
       end
 
-      def <=>(rhs)
-        key <=> rhs.send(:key)
-      end
-
-      alias eql? ==
-
       def hash
         key.hash
       end
-
-      private
-
-      def key
-        @key ||= [@child_table_name, @parent_class_name, @foreign_key_name, @on_delete_cascade].map(&:to_s)
-      end
     end
   end
 end

data/lib/declare_schema/model/habtm_model_shim.rb

@@ -4,28 +4,24 @@ module DeclareSchema
   module Model
     class HabtmModelShim
       class << self
-        def from_reflection(refl)
-          join_table = refl.join_table
-          foreign_keys_and_classes = [
-            [refl.foreign_key.to_s, refl.active_record],
-            [refl.association_foreign_key.to_s, refl.class_name.constantize]
-          ].sort { |a, b| a.first <=> b.first }
-          foreign_keys = foreign_keys_and_classes.map(&:first)
-          foreign_key_classes = foreign_keys_and_classes.map(&:last)
-          # this may fail in weird ways if HABTM is running across two DB connections (assuming that's even supported)
-          # figure that anybody who sets THAT up can deal with their own migrations...
-          connection = refl.active_record.connection
-
-          new(join_table, foreign_keys, foreign_key_classes, connection)
+        def from_reflection(reflection)
+          new(reflection.join_table,
+              [reflection.foreign_key, reflection.association_foreign_key],
+              [reflection.active_record.table_name, reflection.klass.table_name],
+              connection: reflection.active_record.connection)
         end
       end
 
-      attr_reader :join_table, :foreign_keys, :foreign_key_classes, :connection
+      attr_reader :join_table, :foreign_keys, :parent_table_names, :connection
 
-      def initialize(join_table, foreign_keys, foreign_key_classes, connection)
+      def initialize(join_table, foreign_keys, parent_table_names, connection:)
+        foreign_keys.is_a?(Array) && foreign_keys.size == 2 or
+          raise ArgumentError, "foreign_keys must be <Array[2]>; got #{foreign_keys.inspect}"
+        parent_table_names.is_a?(Array) && parent_table_names.size == 2 or
+          raise ArgumentError, "parent_table_names must be <Array[2]>; got #{parent_table_names.inspect}"
         @join_table = join_table
-        @foreign_keys = foreign_keys
-        @foreign_key_classes = foreign_key_classes
+        @foreign_keys = foreign_keys.sort # Rails requires these be in alphabetical order
+        @parent_table_names = @foreign_keys == foreign_keys ? parent_table_names : parent_table_names.reverse # match the above sort
         @connection = connection
       end
 
@@ -38,8 +34,8 @@ module DeclareSchema
       end
 
       def field_specs
-        foreign_keys.each_with_index.each_with_object({}) do |(v, position), result|
-          result[v] = ::DeclareSchema::Model::FieldSpec.new(self, v, :bigint, position: position, null: false)
+        foreign_keys.each_with_index.each_with_object({}) do |(foreign_key, i), result|
+          result[foreign_key] = ::DeclareSchema::Model::FieldSpec.new(self, foreign_key, :bigint, position: i, null: false)
         end
       end
 
@@ -48,26 +44,30 @@ module DeclareSchema
       end
 
       def _declared_primary_key
-        false # no single-column primary key declared
+        foreign_keys
       end
 
-      def index_definitions_with_primary_key
-        @index_definitions_with_primary_key ||= Set.new([
-          IndexDefinition.new(self, foreign_keys, unique: true, name: Model::IndexDefinition::PRIMARY_KEY_NAME), # creates a primary composite key on both foreign keys
-          IndexDefinition.new(self, foreign_keys.last) # not unique by itself; combines with primary key to be unique
-        ])
+      def index_definitions
+        [
+          IndexDefinition.new(foreign_keys.last, table_name: table_name, unique: false) # index for queries where we only have the last foreign key
+        ]
       end
 
-      alias_method :index_definitions, :index_definitions_with_primary_key
+      def index_definitions_with_primary_key
+        [
+          *index_definitions,
+          IndexDefinition.new(foreign_keys, table_name: table_name, name: Model::IndexDefinition::PRIMARY_KEY_NAME, unique: true) # creates a primary composite key on both foreign keys
+        ]
+      end
 
       def ignore_indexes
         @ignore_indexes ||= Set.new
       end
 
-      def constraint_specs
-        @constraint_specs ||= Set.new([
-          ForeignKeyDefinition.new(self, foreign_keys.first, parent_table: foreign_key_classes.first.table_name, constraint_name: "#{join_table}_FK1", dependent: :delete),
-          ForeignKeyDefinition.new(self, foreign_keys.last, parent_table: foreign_key_classes.last.table_name, constraint_name: "#{join_table}_FK2", dependent: :delete)
+      def constraint_definitions
+        @constraint_definitions ||= Set.new([
+          ForeignKeyDefinition.new(foreign_keys.first, constraint_name: "#{join_table}_FK1", child_table_name: @join_table, parent_table_name: parent_table_names.first, dependent: :delete),
+          ForeignKeyDefinition.new(foreign_keys.last, constraint_name: "#{join_table}_FK2", child_table_name: @join_table, parent_table_name: parent_table_names.last, dependent: :delete)
         ])
       end
     end

data/lib/declare_schema/model/index_definition.rb

@@ -7,65 +7,66 @@ module DeclareSchema
     class IndexDefinition
       include Comparable
 
-      # TODO: replace `fields` with `columns` and remove alias. -Colin
       OPTIONS = [:name, :unique, :where, :length].freeze
-      attr_reader :table, :fields, :explicit_name, *OPTIONS
-      alias columns fields
+      attr_reader :columns, :explicit_name, :table_name, *OPTIONS
+
+      alias fields columns # TODO: change callers to use columns. -Colin
 
       class IndexNameTooLongError < RuntimeError; end
 
       PRIMARY_KEY_NAME = "PRIMARY"
 
-      def initialize(model, fields, **options)
-        @model = model
-        @table = options.delete(:table_name) || model.table_name
-        @fields = Array.wrap(fields).map(&:to_s)
-        @explicit_name = options[:name] unless options.delete(:allow_equivalent)
-        @name = options.delete(:name) || self.class.default_index_name(@table, @fields)
-        @unique = options.delete(:unique) || name == PRIMARY_KEY_NAME || false
-        @length = options.delete(:length)
+      def initialize(columns, table_name:, name: nil, allow_equivalent: false, unique: false, where: nil, length: nil)
+        @table_name = table_name
+        @name = name || self.class.default_index_name(table_name, columns)
+        @columns = Array.wrap(columns).map(&:to_s)
+        @explicit_name = @name if !allow_equivalent
+        unique.in?([false, true]) or raise ArgumentError, "unique must be true or false: got #{unique.inspect}"
+        if @name == PRIMARY_KEY_NAME
+          unique or raise ArgumentError, "primary key index must be unique"
+        end
+        @unique = unique
 
         if DeclareSchema.max_index_and_constraint_name_length && @name.length > DeclareSchema.max_index_and_constraint_name_length
           raise IndexNameTooLongError, "Index '#{@name}' exceeds configured limit of #{DeclareSchema.max_index_and_constraint_name_length} characters. Give it a shorter name, or adjust DeclareSchema.max_index_and_constraint_name_length if you know your database can accept longer names."
         end
 
-        if (where = options.delete(:where))
+        if where
           @where = where.start_with?('(') ? where : "(#{where})"
         end
 
-        options.any? and warn("ignoring unrecognized option(s): #{options.inspect} for model #{model}")
+        @length = self.class.normalize_index_length(length, columns: @columns)
       end
 
       class << self
         # extract IndexSpecs from an existing table
         # includes the PRIMARY KEY index
-        def for_model(model, old_table_name = nil)
-          t = old_table_name || model.table_name
-
-          primary_key_columns = Array(model.connection.primary_key(t)).presence
-          primary_key_columns or raise "could not find primary key for table #{t} in #{model.connection.columns(t).inspect}"
+        def for_table(table_name, ignore_indexes, connection)
+          primary_key_columns = Array(connection.primary_key(table_name))
+          primary_key_columns.present? or raise "could not find primary key for table #{table_name} in #{connection.columns(table_name).inspect}"
 
           primary_key_found = false
-          index_definitions = model.connection.indexes(t).map do |i|
-            model.ignore_indexes.include?(i.name) and next
-            if i.name == PRIMARY_KEY_NAME
-              i.columns == primary_key_columns && i.unique or
-                raise "primary key on #{t} was not unique on #{primary_key_columns} (was unique=#{i.unique} on #{i.columns})"
+          index_definitions = connection.indexes(table_name).map do |index|
+            next if ignore_indexes.include?(index.name)
+
+            if index.name == PRIMARY_KEY_NAME
+              index.columns == primary_key_columns && index.unique or
+                raise "primary key on #{table_name} was not unique on #{primary_key_columns} (was unique=#{index.unique} on #{index.columns})"
               primary_key_found = true
             end
-            new(model, i.columns, name: i.name, unique: i.unique, where: i.where, table_name: old_table_name)
+            new(index.columns, name: index.name, table_name: table_name, unique: index.unique, where: index.where, length: index.lengths)
           end.compact
 
           if !primary_key_found
-            index_definitions << new(model, primary_key_columns, name: PRIMARY_KEY_NAME, unique: true, where: nil, table_name: old_table_name)
+            index_definitions << new(primary_key_columns, name: PRIMARY_KEY_NAME, table_name: table_name, unique: true)
           end
           index_definitions
         end
 
-        def default_index_name(table, fields)
+        def default_index_name(table_name, columns)
           index_name = nil
           [:long_index_name, :short_index_name].find do |method_name|
-            index_name = send(method_name, table, fields)
+            index_name = send(method_name, table_name, columns)
             if DeclareSchema.max_index_and_constraint_name_length.nil? || index_name.length <= DeclareSchema.max_index_and_constraint_name_length
               break index_name
             end
@@ -73,6 +74,26 @@ module DeclareSchema
                        "Default index name '#{index_name}' exceeds configured limit of #{DeclareSchema.max_index_and_constraint_name_length} characters. Use the `name:` option to give it a shorter name, or adjust DeclareSchema.max_index_and_constraint_name_length if you know your database can accept longer names."
         end
 
+        # This method normalizes the length option to be either nil or a Hash of Symbol column names to lengths,
+        # so that we can safely compare what the user specified with what we get when querying the database schema.
+        # @return [Hash<Symbol, nil>]
+        def normalize_index_length(length, columns:)
+          case length
+          when nil, {}
+            nil
+          when Integer
+            if columns.size == 1
+              { columns.first.to_sym => length }
+            else
+              raise ArgumentError, "Index length of Integer only allowed when exactly one column; got #{length.inspect} for #{columns.inspect}"
+            end
+          when Hash
+            length.transform_keys(&:to_sym)
+          else
+            raise ArgumentError, "Index length must be nil or Integer or a Hash of column names to lengths; got #{length.inspect} for #{columns.inspect}"
+          end
+        end
+
         private
 
         SHA_SUFFIX_LENGTH = 4
@@ -115,12 +136,12 @@ module DeclareSchema
 
       # Unique key for this object. Used for equality checking.
       def to_key
-        @key ||= [table, fields, options].freeze
+        @to_key ||= [name, *settings].freeze
       end
 
       # The index settings for this object. Used for equivalence checking. Does not include the name.
       def settings
-        @settings ||= [table, fields, options.except(:name)].freeze
+        @settings ||= [columns, options.except(:name)].freeze
       end
 
       def hash
@@ -136,7 +157,7 @@ module DeclareSchema
       end
 
       def with_name(new_name)
-        self.class.new(@model, @fields, **{ **options, name: new_name })
+        self.class.new(@columns, name: new_name, table_name: @table_name, unique: @unique, allow_equivalent: @explicit_name.nil?, where: @where, length: @length)
       end
 
       alias eql? ==

data/lib/declare_schema/model/table_options_definition.rb

@@ -50,7 +50,17 @@ module DeclareSchema
 
       def initialize(table_name, **table_options)
         @table_name    = table_name
-        @table_options = table_options
+        @table_options = table_options.each_with_object({}) do |(k, v),result|
+          result[k] =
+            case k
+            when :charset
+              DeclareSchema.normalize_charset(v)
+            when :collation
+              DeclareSchema.normalize_collation(v)
+            else
+              v
+            end
+        end
       end
 
       def to_key

data/lib/declare_schema/model.rb

@@ -28,7 +28,7 @@ module DeclareSchema
           # index_definitions holds IndexDefinition objects for all the declared indexes.
           inheriting_cattr_reader index_definitions: Set.new
           inheriting_cattr_reader ignore_indexes: Set.new
-          inheriting_cattr_reader constraint_specs: Set.new
+          inheriting_cattr_reader constraint_definitions: Set.new
 
           # table_options holds optional configuration for the create_table statement
           # supported options include :charset and :collation
@@ -49,16 +49,23 @@ module DeclareSchema
     end
 
     module ClassMethods
-      def index(fields, **options)
-        index_definitions << ::DeclareSchema::Model::IndexDefinition.new(self, fields, **options)
+      def index(columns, name: nil, allow_equivalent: false, unique: false, where: nil, length: nil)
+        index_definitions << ::DeclareSchema::Model::IndexDefinition.new(
+          columns,
+          name: name, table_name: table_name, allow_equivalent: allow_equivalent, unique: unique, where: where, length: length
+        )
       end
 
-      def primary_key_index(*fields)
-        index(fields.flatten, unique: true, name: ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME)
+      def primary_key_index(*columns)
+        index(columns.flatten, unique: true, name: ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME)
       end
 
-      def constraint(foreign_key, **options)
-        constraint_specs << DeclareSchema::Model::ForeignKeyDefinition.new(self, foreign_key.to_s, **options)
+      def constraint(foreign_key_column, parent_table_name: nil, constraint_name: nil, parent_class_name: nil, dependent: nil)
+        constraint_definitions << ::DeclareSchema::Model::ForeignKeyDefinition.new(
+          foreign_key_column.to_s,
+          constraint_name: constraint_name,
+          child_table_name: table_name, parent_table_name: parent_table_name, parent_class_name: parent_class_name, dependent: dependent
+        )
       end
 
       # tell the migration generator to ignore the named index. Useful for existing indexes, or for indexes
@@ -76,7 +83,7 @@ module DeclareSchema
         _add_serialize_for_field(name, type, options)
         _add_formatting_for_field(name, type)
         _add_validations_for_field(name, type, args, options)
-        _add_index_for_field(name, args, options)
+        _add_index_for_field(name, args, **options)
         field_specs[name] = ::DeclareSchema::Model::FieldSpec.new(self, name, type, position: field_specs.size, **options)
         attr_order << name unless attr_order.include?(name)
       end
@@ -91,8 +98,8 @@ module DeclareSchema
 
       # Extend belongs_to so that it
       # 1. creates a FieldSpec for the foreign key
-      # 2. declares an index on the foreign key
-      # 3. declares a foreign_key constraint
+      # 2. declares an index on the foreign key (optional)
+      # 3. declares a foreign_key constraint (optional)
       def belongs_to(name, scope = nil, **options)
         column_options = {}
 
@@ -104,54 +111,52 @@ module DeclareSchema
         column_options[:default] = options.delete(:default) if options.has_key?(:default)
         if options.has_key?(:limit)
           options.delete(:limit)
-          ActiveSupport::Deprecation.warn("belongs_to limit: is deprecated since it is now inferred")
+          ActiveSupport::Deprecation.warn("belongs_to #{name.inspect}, limit: is deprecated since it is now inferred")
         end
 
         # index: true means create an index on the foreign key
         # index: false means do not create an index on the foreign key
         # index: { ... } means create an index on the foreign key with the given options
         index_value = options.delete(:index)
-        if index_value != false || options.has_key?(:unique) || options.has_key?(:allow_equivalent)
-          index_options = {}
+        if index_value == false # don't create an index
+          options.delete(:unique)
+          options.delete(:allow_equivalent)
+        else
+          index_options = {} # create an index
           case index_value
-          when String
-            Kernel.warn("belongs_to index: 'name' is deprecated; use index: { name: 'name' } instead (in #{name})")
-            index_options[:name] = index_value
+          when String, Symbol
+            ActiveSupport::Deprecation.warn("belongs_to #{name.inspect}, index: 'name' is deprecated; use index: { name: 'name' } instead (in #{self.name})")
+            index_options[:name] = index_value.to_s
           when true
-          when false
-            raise ArgumentError, "belongs_to index: false contradicts others options #{options.inspect} (in #{name})"
           when nil
           when Hash
             index_options = index_value
           else
-            raise ArgumentError, "belongs_to index: must be true or false or a Hash; got #{index_value.inspect} (in #{name})"
+            raise ArgumentError, "belongs_to #{name.inspect}, index: must be true or false or a Hash; got #{index_value.inspect} (in #{self.name})"
           end
 
           if options.has_key?(:unique)
-            Kernel.warn("belongs_to unique: true|false is deprecated; use index: { unique: true|false } instead (in #{name})")
+            ActiveSupport::Deprecation.warn("belongs_to #{name.inspect}, unique: true|false is deprecated; use index: { unique: true|false } instead (in #{self.name})")
             index_options[:unique] = options.delete(:unique)
           end
 
           index_options[:allow_equivalent] = options.delete(:allow_equivalent) if options.has_key?(:allow_equivalent)
         end
 
-        fk_options = options.dup
-        fk_options[:constraint_name] = options.delete(:constraint) if options.has_key?(:constraint)
-        fk_options[:index_name] = index_options&.[](:name)
+        constraint_name = options.delete(:constraint)
 
-        fk = options[:foreign_key]&.to_s || "#{name}_id"
+        dependent_delete = :delete if options.delete(:far_end_dependent) == :delete
 
+        # infer :optional from :null
         if !options.has_key?(:optional)
-          options[:optional] = column_options[:null] # infer :optional from :null
+          options[:optional] = column_options[:null]
         end
 
-        fk_options[:dependent] = options.delete(:far_end_dependent) if options.has_key?(:far_end_dependent)
-
         super
 
         reflection = reflections[name.to_s] or raise "Couldn't find reflection #{name} in #{reflections.keys}"
-        foreign_key = reflection.foreign_key or raise "Couldn't find foreign_key for #{name} in #{reflection.inspect}"
-        foreign_key_id_column_options = column_options.dup
+        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.
@@ -162,27 +167,34 @@ module DeclareSchema
         # 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_id_column_options[:pre_migration] = ->(field_spec) do
-          if (inferred_limit = _infer_fk_limit(foreign_key, reflection))
+        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
 
-        declare_field(foreign_key.to_sym, :bigint, **foreign_key_id_column_options)
+        declare_field(foreign_key_column.to_sym, :bigint, **foreign_key_column_options)
 
         if reflection.options[:polymorphic]
           foreign_type = options[:foreign_type] || "#{name}_type"
           _declare_polymorphic_type_field(foreign_type, column_options)
-          index([foreign_type, foreign_key], **index_options) if index_options
+          if ::DeclareSchema.default_generate_indexing && index_options
+            index([foreign_type, foreign_key_column], **index_options)
+          end
         else
-          index(foreign_key, **index_options) if index_options
-          constraint(foreign_key, **fk_options) if fk_options[:constraint_name] != false
+          if ::DeclareSchema.default_generate_indexing && index_options
+            index([foreign_key_column], **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)
+          end
         end
       end
 
-      def _infer_fk_limit(foreign_key, reflection)
+      def _infer_fk_limit(foreign_key_column, reflection)
         if reflection.options[:polymorphic]
-          if (foreign_key_column = columns_hash[foreign_key.to_s]) && foreign_key_column.type == :integer
+          if (foreign_key_column = columns_hash[foreign_key_column.to_s]) && foreign_key_column.type == :integer
             foreign_key_column.limit
           end
         else
@@ -224,7 +236,7 @@ module DeclareSchema
       end
 
       def _rails_default_primary_key
-        ::DeclareSchema::Model::IndexDefinition.new(self, [_declared_primary_key.to_sym], unique: true, name: DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME)
+        ::DeclareSchema::Model::IndexDefinition.new([_declared_primary_key], name: DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME, table_name: table_name, unique: true)
       end
 
       # Declares the "foo_type" field that accompanies the "foo_id"
@@ -295,15 +307,16 @@ module DeclareSchema
         end
       end
 
-      def _add_index_for_field(name, args, options)
-        if (to_name = options.delete(:index))
+      def _add_index_for_field(column_name, args, **options)
+        if (index_name = options.delete(:index))
           index_opts =
             {
               unique: args.include?(:unique) || !!options.delete(:unique)
             }
+
           # support index: true declaration
-          index_opts[:name] = to_name unless to_name == true
-          index(name, **index_opts)
+          index_opts[:name] = index_name unless index_name == true
+          index([column_name], **index_opts)
         end
       end