declare_schema 1.4.0.colin.7 → 1.4.0.colin.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f8226540260a887af839da5afcb4641217c03ac5a6eb2d7a00da2806188f1ce
-  data.tar.gz: 7eeb464b5bfc9b1fbf88446696ede88b8ea582060658421cf2772e62a6205797
+  metadata.gz: ca0ed75221c664e2a5c59bff495a971495922f7f31ea0fb548fb67f0ad0eb639
+  data.tar.gz: fc76669be291fff9da61353f7f040ba14327e1359f712a963e5865ed948034c8
 SHA512:
-  metadata.gz: 2294e94f2165ec156807fbf9ba98dea10f191bfda1b4c630f5444ab08ee7f80323e86a9af80e968e20e579e21ba24ddef520312a7f0a146d850b6f8927aa50aa
-  data.tar.gz: 2742ce98af1fb6ef8eb4ba1fa40563a635abb584cc1860efd373a474c6dce9fc1a27b630141f94ea6a23f36602d8381b08d6a33b13b6fd3d352b40df85f37daf
+  metadata.gz: 47b53d7e5306a3b2ada9296494af897738056c1c5e14e35e0b3967daf3176e07cf48c74560e2ccd659d0c1b8bc466e6d29f632f86b25bff568bcc4b6dcf672af
+  data.tar.gz: 9af422633cae00b32e94bf64d0e6e9445aee83849e4898633384af679b61c877a22ce14f1b20c225d17f4a1546ee3c3a1867e0661516f186717895a658d4b2eb

data/CHANGELOG.md

@@ -10,6 +10,11 @@ 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.3] - 2023-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.8)
       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

@@ -5,28 +5,21 @@ module DeclareSchema
     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)
+          new(refl.join_table, [refl.foreign_key, refl.association_foreign_key],
+                               [refl.active_record.table_name, refl.class_name.constantize.table_name])
         end
       end
 
-      attr_reader :join_table, :foreign_keys, :foreign_key_classes, :connection
+      attr_reader :join_table, :foreign_keys, :parent_table_names
 
-      def initialize(join_table, foreign_keys, foreign_key_classes, connection)
+      def initialize(join_table, foreign_keys, parent_table_names)
+        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
-        @connection = connection
+        @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
       end
 
       def _table_options
@@ -38,8 +31,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
 
@@ -53,8 +46,8 @@ module DeclareSchema
 
       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
+          IndexDefinition.new(foreign_keys, name: Model::IndexDefinition::PRIMARY_KEY_NAME, table_name: table_name, unique: true), # creates a primary composite key on both foreign keys
+          IndexDefinition.new(foreign_keys.last,                                            table_name: table_name, unique: false) # index for queries where we only have the last foreign key
         ])
       end
 
@@ -64,10 +57,10 @@ module DeclareSchema
         @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,78 @@ 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)
+      # Caller needs to pass either name or table_name. The table_name is not remembered; it is just used to compute the
+      # default name if no name is given.
+      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)
+        @name.to_s == 'index_adverts_on_Advert' and binding.pry
+        @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 = length
       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)
+            length =
+              case lengths = index.lengths
+              when {}
+                nil
+              when Hash
+                lengths.size == 1 ? lengths.values.first : lengths
+              else
+                lengths
+              end
+            new(index.columns, name: index.name, table_name: table_name, unique: index.unique, where: index.where, length: length)
           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
@@ -115,12 +128,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 +149,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 = {}
 
@@ -112,14 +119,14 @@ module DeclareSchema
         # 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 = {}
+          index_options = {} # truthy iff we want an index
           case index_value
-          when String
+          when String, Symbol
             Kernel.warn("belongs_to index: 'name' is deprecated; use index: { name: 'name' } instead (in #{name})")
-            index_options[:name] = index_value
-          when true
+            index_options[:name] = index_value.to_s
           when false
             raise ArgumentError, "belongs_to index: false contradicts others options #{options.inspect} (in #{name})"
+          when true
           when nil
           when Hash
             index_options = index_value
@@ -135,23 +142,20 @@ module DeclareSchema
           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 +166,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.klass, 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 +235,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 +306,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
 

data/lib/declare_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeclareSchema
-  VERSION = "1.4.0.colin.7"
+  VERSION = "1.4.0.colin.8"
 end