dynamic_migrations 3.8.2 → 3.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2641592d2902b2b4db711882300e45157cf45df12d3f19ceea84ff97e13f6fab
-  data.tar.gz: d6eb83a0f1d0631acc1474d18305e0828688210f7008dbddb460dc1b2cfaf668
+  metadata.gz: '08737568ccf7605e0a4d404063b7e1708e67c0ed96ab9f091bb72db627c0d50b'
+  data.tar.gz: 404f7bd4816def6c379a9277ec9c06ad4f58d188d3911f4ca9e9c1a38cf301f8
 SHA512:
-  metadata.gz: 48130e442efa9a4e2ab9763fe8e0cb1f35bca56691361e0d3c350813e89c31e1445f59ff76b981e560eb521e8dfb72822ac80c04c738203b62237ccc9690ecc1
-  data.tar.gz: 0a40ea04a41e2f072fe0f8ae9a163a1989c0e8c752b7078491ae5b75bbe18cfc3d3eebd777a61de2b4372297e78c54539d3a449b11a76771c19a86370d5fe588
+  metadata.gz: a403e1da441c1625e89034f07141d48c15fa07953404638795c2c11d58c79e26468f7b4b9070a37d18d6d62a91f069950b4d9ed824c6404071cee59fd3627d35
+  data.tar.gz: 3df74c476b5d84f8b98f774a69223934823670201649bf35f3aa5a6620738c0fba046bb56ac2e8139364a39ac5a6c4cbdcea547b2cf9625bf45f570261038b80

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [3.8.3](https://github.com/craigulliott/dynamic_migrations/compare/v3.8.2...v3.8.3) (2023-10-06)
+
+
+### Bug Fixes
+
+* adding logging ([1387a75](https://github.com/craigulliott/dynamic_migrations/commit/1387a7535db242570b2b9fa60730d6bd73edb265))
+
 ## [3.8.2](https://github.com/craigulliott/dynamic_migrations/compare/v3.8.1...v3.8.2) (2023-10-06)
 
 

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/extensions.rb

@@ -11,15 +11,19 @@ module DynamicMigrations
                 # if the extension exists in the configuration but not in the database
                 # then we have to create it
                 if configuration_extension[:exists] == true && !database_extension[:exists]
+                  log.info "Extension `#{extension_name}` exists in configuration but not in the database"
                   # a migration to create the extension
                   @generator.enable_extension extension_name
 
                 # if the extension exists in the database but not in the configuration
                 # then we need to delete it
                 elsif database_extension[:exists] == true && !configuration_extension[:exists]
+                  log.info "Extension `#{extension_name}` exists in database but not in the configuration"
                   # a migration to drop the extension
                   if Postgres.remove_unused_extensions?
                     @generator.disable_extension extension_name
+                  else
+                    log.warn "Skipping removal of extension `#{extension_name}` due to configuration setting"
                   end
                 end
               end

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/enums.rb

@@ -10,8 +10,10 @@ module DynamicMigrations
               module Enums
                 def process_enums schema_name, configuration_enums, database_enums
                   # process all the enums
+                  log.info "  Processing tables..."
                   enum_names = (configuration_enums.keys + database_enums.keys).uniq
                   enum_names.each do |enum_name|
+                    log.info "  Processing table #{enum_name}..."
                     process_enum schema_name, enum_name, configuration_enums[enum_name] || {}, database_enums[enum_name] || {}
                   end
                 end
@@ -20,6 +22,8 @@ module DynamicMigrations
                   # If the enum exists in the configuration but not in the database
                   # then we have to create it.
                   if configuration_enum[:exists] == true && !database_enum[:exists]
+                    log.info "  Enum `#{enum_name}` exists in configuration but not in the database"
+
                     # a migration to create the enum
                     enum = @database.configured_schema(schema_name).enum(enum_name)
                     @generator.create_enum enum
@@ -31,6 +35,8 @@ module DynamicMigrations
                   # If the schema exists in the database but not in the configuration
                   # then we need to delete it.
                   elsif database_enum[:exists] == true && !configuration_enum[:exists]
+                    log.info "  Enum `#{enum_name}` exists in database but not in the configuration"
+
                     # a migration to create the enum
                     enum = @database.loaded_schema(schema_name).enum(enum_name)
                     @generator.drop_enum enum
@@ -38,6 +44,9 @@ module DynamicMigrations
                   # If the enum exists in both the configuration and database representations
                   # but the values is different then we need to update the values.
                   elsif configuration_enum[:values][:matches] == false
+                    log.info "  Enum `#{enum_name}` exists in both configuration and the database"
+
+                    log.info "    Enum `#{enum_name}` values are different"
                     original_enum = @database.loaded_schema(schema_name).enum(enum_name)
                     updated_enum = @database.configured_schema(schema_name).enum(enum_name)
                     @generator.update_enum original_enum, updated_enum
@@ -45,8 +54,10 @@ module DynamicMigrations
                     if configuration_enum[:description][:matches] == false
                       # if the description was removed
                       if configuration_enum[:description].nil?
+                        log.info "    Enum `#{enum_name}` description exists in database but not in the configuration"
                         @generator.remove_enum_comment updated_enum
                       else
+                        log.info "    Enum `#{enum_name}` description does not match"
                         @generator.set_enum_comment updated_enum
                       end
                     end
@@ -57,8 +68,10 @@ module DynamicMigrations
                     enum = @database.configured_schema(schema_name).enum(enum_name)
                     # if the description was removed
                     if configuration_enum[:description].nil?
+                      log.info "    Enum `#{enum_name}` description exists in database but not in the configuration"
                       @generator.remove_enum_comment enum
                     else
+                      log.info "    Enum `#{enum_name}` description does not match"
                       @generator.set_enum_comment enum
                     end
                   end

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/functions.rb

@@ -10,8 +10,10 @@ module DynamicMigrations
               module Functions
                 def process_functions schema_name, configuration_functions, database_functions
                   # process all the functions
+                  log.info "  Processing Functions..."
                   function_names = (configuration_functions.keys + database_functions.keys).uniq
                   function_names.each do |function_name|
+                    log.info "  Processing Function #{function_name}..."
                     process_function schema_name, function_name, configuration_functions[function_name] || {}, database_functions[function_name] || {}
                   end
                 end
@@ -20,6 +22,8 @@ module DynamicMigrations
                   # If the function exists in the configuration but not in the database
                   # then we have to create it.
                   if configuration_function[:exists] == true && !database_function[:exists]
+                    log.info "  Function `#{function_name}` exists in configuration but not in the database"
+
                     # a migration to create the function
                     function = @database.configured_schema(schema_name).function(function_name)
                     @generator.create_function function
@@ -27,6 +31,8 @@ module DynamicMigrations
                   # If the schema exists in the database but not in the configuration
                   # then we need to delete it.
                   elsif database_function[:exists] == true && !configuration_function[:exists]
+                    log.info "  Function `#{function_name}` exists in database but not in the configuration"
+
                     # a migration to create the function
                     function = @database.loaded_schema(schema_name).function(function_name)
                     @generator.drop_function function
@@ -34,14 +40,19 @@ module DynamicMigrations
                   # If the function exists in both the configuration and database representations
                   # but the definition is different then we need to update the definition.
                   elsif configuration_function[:normalized_definition][:matches] == false
+                    log.info "  Function `#{function_name}` exists in both configuration and the database"
+
+                    log.info "    Function `#{function_name}` definition is different"
                     function = @database.configured_schema(schema_name).function(function_name)
                     @generator.update_function function
                     # does the description also need to be updated
                     if configuration_function[:description][:matches] == false
                       # if the description was removed
                       if configuration_function[:description].nil?
+                        log.info "    Function `#{function_name}` description exists in database but not in the configuration"
                         @generator.remove_function_comment function
                       else
+                        log.info "    Function `#{function_name}` description does not match"
                         @generator.set_function_comment function
                       end
                     end
@@ -49,11 +60,15 @@ module DynamicMigrations
                   # If the function exists in both the configuration and database representations
                   # but the description is different then we need to update the description.
                   elsif configuration_function[:description][:matches] == false
+                    log.info "  Function `#{function_name}` exists in both configuration and the database"
+
                     function = @database.configured_schema(schema_name).function(function_name)
                     # if the description was removed
                     if configuration_function[:description].nil?
+                      log.info "    Function `#{function_name}` description exists in database but not in the configuration"
                       @generator.remove_function_comment function
                     else
+                      log.info "    Function `#{function_name}` description does not match"
                       @generator.set_function_comment function
                     end
                   end

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/columns.rb

@@ -11,8 +11,10 @@ module DynamicMigrations
                 module Columns
                   def process_columns schema_name, table_name, configuration_columns, database_columns
                     # process all the columns
+                    log.info "    Processing Columns..."
                     column_names = (configuration_columns.keys + database_columns.keys).uniq
                     column_names.each do |column_name|
+                      log.info "    Processing Column #{column_name}..."
                       process_column schema_name, table_name, column_name, configuration_columns[column_name] || {}, database_columns[column_name] || {}
                     end
                   end
@@ -21,6 +23,8 @@ module DynamicMigrations
                     # If the column exists in the configuration but not in the database
                     # then we have to create it.
                     if configuration_column[:exists] == true && !database_column[:exists]
+                      log.info "    Column `#{column_name}` exists in configuration but not in the database"
+
                       # a migration to create the column
                       column = @database.configured_schema(schema_name).table(table_name).column(column_name)
                       @generator.add_column column
@@ -28,6 +32,8 @@ module DynamicMigrations
                     # If the schema exists in the database but not in the configuration
                     # then we need to delete it.
                     elsif database_column[:exists] == true && !configuration_column[:exists]
+                      log.info "    Column `#{column_name}` exists in database but not in the configuration"
+
                       # a migration to create the column
                       column = @database.loaded_schema(schema_name).table(table_name).column(column_name)
                       @generator.remove_column column
@@ -36,6 +42,9 @@ module DynamicMigrations
                     # but the definition (except description, which is handled seeprately below) is different
                     # then we need to update the definition.
                     elsif configuration_column.except(:exists, :description).filter { |name, attributes| attributes[:matches] == false }.any?
+                      log.info "    Column `#{column_name}` exists in both configuration and the database"
+
+                      log.info "      Column `#{column_name}` is different"
                       # update the column
                       column = @database.configured_schema(schema_name).table(table_name).column(column_name)
                       @generator.change_column column
@@ -43,8 +52,10 @@ module DynamicMigrations
                       if configuration_column[:description][:matches] == false
                         # if the description was removed
                         if configuration_column[:description].nil?
+                          log.info "      Column `#{column_name}` description exists in database but not in the configuration"
                           @generator.remove_column_comment column
                         else
+                          log.info "      Column `#{column_name}` description does not match"
                           @generator.set_column_comment column
                         end
                       end
@@ -52,11 +63,15 @@ module DynamicMigrations
                     # If the column exists in both the configuration and database representations
                     # but the description is different then we need to update the description.
                     elsif configuration_column[:description][:matches] == false
+                      log.info "    Column `#{column_name}` exists in both configuration and the database"
+
                       column = @database.configured_schema(schema_name).table(table_name).column(column_name)
                       # if the description was removed
                       if configuration_column[:description].nil?
+                        log.info "      Column `#{column_name}` description exists in database but not in the configuration"
                         @generator.remove_column_comment column
                       else
+                        log.info "      Column `#{column_name}` description does not match"
                         @generator.set_column_comment column
                       end
                     end

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/foreign_key_constraints.rb

@@ -11,8 +11,10 @@ module DynamicMigrations
                 module ForeignKeyConstraints
                   def process_foreign_key_constraints schema_name, table_name, configuration_foreign_key_constraints, database_foreign_key_constraints
                     # process all the foreign_key_constraints
+                    log.info "    Processing Foreign Key Constraints..."
                     foreign_key_constraint_names = (configuration_foreign_key_constraints.keys + database_foreign_key_constraints.keys).uniq
                     foreign_key_constraint_names.each do |foreign_key_constraint_name|
+                      log.info "    Processing Foreign Key Constraint #{foreign_key_constraint_name}..."
                       process_foreign_key_constraint schema_name, table_name, foreign_key_constraint_name, configuration_foreign_key_constraints[foreign_key_constraint_name] || {}, database_foreign_key_constraints[foreign_key_constraint_name] || {}
                     end
                   end
@@ -21,6 +23,8 @@ module DynamicMigrations
                     # If the foreign_key_constraint exists in the configuration but not in the database
                     # then we have to create it.
                     if configuration_foreign_key_constraint[:exists] == true && !database_foreign_key_constraint[:exists]
+                      log.info "    Foreign Key Constraint `#{foreign_key_constraint_name}` exists in configuration but not in the database"
+
                       # a migration to create the foreign_key_constraint
                       foreign_key_constraint = @database.configured_schema(schema_name).table(table_name).foreign_key_constraint(foreign_key_constraint_name)
                       @generator.add_foreign_key_constraint foreign_key_constraint
@@ -28,6 +32,8 @@ module DynamicMigrations
                     # If the schema exists in the database but not in the configuration
                     # then we need to delete it.
                     elsif database_foreign_key_constraint[:exists] == true && !configuration_foreign_key_constraint[:exists]
+                      log.info "    Foreign Key Constraint `#{foreign_key_constraint_name}` exists in database but not in the configuration"
+
                       # a migration to create the foreign_key_constraint
                       foreign_key_constraint = @database.loaded_schema(schema_name).table(table_name).foreign_key_constraint(foreign_key_constraint_name)
                       @generator.remove_foreign_key_constraint foreign_key_constraint
@@ -36,6 +42,9 @@ module DynamicMigrations
                     # but the definition (except description, which is handled seeprately below) is different
                     # then we need to update the definition.
                     elsif configuration_foreign_key_constraint.except(:exists, :description).filter { |name, attributes| attributes[:matches] == false }.any?
+                      log.info "    Foreign Key Constraint `#{foreign_key_constraint_name}` exists in both configuration and the database"
+
+                      log.info "      Foreign Key Constraint `#{foreign_key_constraint_name}` is different"
                       # recreate the foreign_key_constraint
                       original_foreign_key_constraint = @database.loaded_schema(schema_name).table(table_name).foreign_key_constraint(foreign_key_constraint_name)
                       updated_foreign_key_constraint = @database.configured_schema(schema_name).table(table_name).foreign_key_constraint(foreign_key_constraint_name)
@@ -44,8 +53,10 @@ module DynamicMigrations
                       if configuration_foreign_key_constraint[:description][:matches] == false
                         # if the description was removed
                         if configuration_foreign_key_constraint[:description].nil?
+                          log.info "      Foreign Key Constraint `#{foreign_key_constraint_name}` description exists in database but not in the configuration"
                           @generator.remove_foreign_key_constraint_comment updated_foreign_key_constraint
                         else
+                          log.info "      Foreign Key Constraint `#{foreign_key_constraint_name}` does not match"
                           @generator.set_foreign_key_constraint_comment updated_foreign_key_constraint
                         end
                       end
@@ -53,11 +64,15 @@ module DynamicMigrations
                     # If the foreign_key_constraint exists in both the configuration and database representations
                     # but the description is different then we need to update the description.
                     elsif configuration_foreign_key_constraint[:description][:matches] == false
+                      log.info "    Foreign Key Constraint `#{foreign_key_constraint_name}` exists in both configuration and the database"
+
                       foreign_key_constraint = @database.configured_schema(schema_name).table(table_name).foreign_key_constraint(foreign_key_constraint_name)
                       # if the description was removed
                       if configuration_foreign_key_constraint[:description].nil?
+                        log.info "      Foreign Key Constraint `#{foreign_key_constraint_name}` description exists in database but not in the configuration"
                         @generator.remove_foreign_key_constraint_comment foreign_key_constraint
                       else
+                        log.info "      Foreign Key Constraint `#{foreign_key_constraint_name}` description does not match"
                         @generator.set_foreign_key_constraint_comment foreign_key_constraint
                       end
                     end

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/indexes.rb

@@ -11,8 +11,10 @@ module DynamicMigrations
                 module Indexes
                   def process_indexes schema_name, table_name, configuration_indexes, database_indexes
                     # process all the indexes
+                    log.info "    Processing Indexes..."
                     index_names = (configuration_indexes.keys + database_indexes.keys).uniq
                     index_names.each do |index_name|
+                      log.info "    Processing Index #{index_name}..."
                       process_index schema_name, table_name, index_name, configuration_indexes[index_name] || {}, database_indexes[index_name] || {}
                     end
                   end
@@ -21,6 +23,8 @@ module DynamicMigrations
                     # If the index exists in the configuration but not in the database
                     # then we have to create it.
                     if configuration_index[:exists] == true && !database_index[:exists]
+                      log.info "    Index `#{index_name}` exists in configuration but not in the database"
+
                       # a migration to create the index
                       index = @database.configured_schema(schema_name).table(table_name).index(index_name)
                       @generator.add_index index
@@ -28,6 +32,8 @@ module DynamicMigrations
                     # If the schema exists in the database but not in the configuration
                     # then we need to delete it.
                     elsif database_index[:exists] == true && !configuration_index[:exists]
+                      log.info "    Index `#{index_name}` exists in database but not in the configuration"
+
                       # a migration to create the index
                       index = @database.loaded_schema(schema_name).table(table_name).index(index_name)
                       @generator.remove_index index
@@ -36,6 +42,9 @@ module DynamicMigrations
                     # but the definition (except description, which is handled seeprately below) is different
                     # then we need to update the definition.
                     elsif configuration_index.except(:exists, :description).filter { |name, attributes| attributes[:matches] == false }.any?
+                      log.info "    Index `#{index_name}` exists in both configuration and the database"
+
+                      log.info "      Index `#{index_name}` is different"
                       # rebild the index
                       original_index = @database.loaded_schema(schema_name).table(table_name).index(index_name)
                       updated_index = @database.configured_schema(schema_name).table(table_name).index(index_name)
@@ -44,8 +53,10 @@ module DynamicMigrations
                       if configuration_index[:description][:matches] == false
                         # if the description was removed
                         if configuration_index[:description].nil?
+                          log.info "      Index `#{index_name}` description exists in database but not in the configuration"
                           @generator.remove_index_comment updated_index
                         else
+                          log.info "      Index `#{index_name}` does not match"
                           @generator.set_index_comment updated_index
                         end
                       end
@@ -53,11 +64,15 @@ module DynamicMigrations
                     # If the index exists in both the configuration and database representations
                     # but the description is different then we need to update the description.
                     elsif configuration_index[:description][:matches] == false
+                      log.info "    Index `#{index_name}` exists in both configuration and the database"
+
                       index = @database.configured_schema(schema_name).table(table_name).index(index_name)
                       # if the description was removed
                       if configuration_index[:description].nil?
+                        log.info "      Index `#{index_name}` description exists in database but not in the configuration"
                         @generator.remove_index_comment index
                       else
+                        log.info "      Index `#{index_name}` description does not match"
                         @generator.set_index_comment index
                       end
                     end

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/primary_key.rb

@@ -10,12 +10,15 @@ module DynamicMigrations
               module Tables
                 module PrimaryKey
                   def process_primary_key schema_name, table_name, configuration_primary_key, database_primary_key
+                    log.info "    Processing Primary Key..."
                     configuration_primary_key_exists = configuration_primary_key && configuration_primary_key[:exists]
                     database_primary_key_exists = database_primary_key && database_primary_key[:exists]
 
                     # If the primary_key exists in the configuration but not in the database
                     # then we have to create it.
                     if configuration_primary_key_exists == true && database_primary_key_exists == false
+                      log.info "    Primary Key exists in configuration but not in the database"
+
                       # a migration to create the primary_key
                       primary_key = @database.configured_schema(schema_name).table(table_name).primary_key
                       @generator.add_primary_key primary_key
@@ -23,19 +26,26 @@ module DynamicMigrations
                     # If the schema exists in the database but not in the configuration
                     # then we need to delete it.
                     elsif configuration_primary_key_exists == false && database_primary_key_exists == true
+                      log.info "    Primary Key exists in database but not in the configuration"
+
                       # a migration to create the primary_key
                       primary_key = @database.loaded_schema(schema_name).table(table_name).primary_key
                       @generator.remove_primary_key primary_key
 
                     # If the primary_key exists in both the configuration and database representations
                     elsif configuration_primary_key_exists == true && database_primary_key_exists == true
+                      log.info "    Primary Key exists in both configuration and the database"
+
                       # If the definition (i.e. the column names) is different then we need to update the primary key.
                       if configuration_primary_key.except(:exists, :description).filter { |name, attributes| attributes[:matches] == false }.any?
+                        log.info "      Primary Key is different"
                         # recreate the primary_key
                         original_primary_key = @database.loaded_schema(schema_name).table(table_name).primary_key
                         updated_primary_key = @database.configured_schema(schema_name).table(table_name).primary_key
                         @generator.recreate_primary_key original_primary_key, updated_primary_key
                       end
+                    else
+                      log.info "    Primary Key does not exist in either configuration or database"
                     end
                   end
                 end

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/triggers.rb

@@ -10,9 +10,11 @@ module DynamicMigrations
               module Tables
                 module Triggers
                   def process_triggers schema_name, table_name, configuration_triggers, database_triggers
+                    log.info "    Processing Triggers..."
                     # process all the triggers
                     trigger_names = (configuration_triggers.keys + database_triggers.keys).uniq
                     trigger_names.each do |trigger_name|
+                      log.info "    Processing Trigger #{trigger_name}..."
                       process_trigger schema_name, table_name, trigger_name, configuration_triggers[trigger_name] || {}, database_triggers[trigger_name] || {}
                     end
                   end
@@ -21,6 +23,8 @@ module DynamicMigrations
                     # If the trigger exists in the configuration but not in the database
                     # then we have to create it.
                     if configuration_trigger[:exists] == true && !database_trigger[:exists]
+                      log.info "    Trigger `#{trigger_name}` exists in configuration but not in the database"
+
                       # a migration to create the trigger
                       trigger = @database.configured_schema(schema_name).table(table_name).trigger(trigger_name)
                       @generator.add_trigger trigger
@@ -28,6 +32,8 @@ module DynamicMigrations
                     # If the schema exists in the database but not in the configuration
                     # then we need to delete it.
                     elsif database_trigger[:exists] == true && !configuration_trigger[:exists]
+                      log.info "    Trigger `#{trigger_name}` exists in database but not in the configuration"
+
                       # a migration to create the trigger
                       trigger = @database.loaded_schema(schema_name).table(table_name).trigger(trigger_name)
                       @generator.remove_trigger trigger
@@ -36,6 +42,9 @@ module DynamicMigrations
                     # but the definition (except description, which is handled seeprately below) is different
                     # then we need to update the definition.
                     elsif configuration_trigger.except(:exists, :description).filter { |name, attributes| attributes[:matches] == false }.any?
+                      log.info "    Trigger `#{trigger_name}` exists in both configuration and the database"
+
+                      log.info "      Trigger `#{trigger_name}` is different"
                       # recreate the trigger
                       original_trigger = @database.loaded_schema(schema_name).table(table_name).trigger(trigger_name)
                       updated_trigger = @database.configured_schema(schema_name).table(table_name).trigger(trigger_name)
@@ -44,8 +53,10 @@ module DynamicMigrations
                       if configuration_trigger[:description][:matches] == false
                         # if the description was removed
                         if configuration_trigger[:description].nil?
+                          log.info "      Trigger `#{trigger_name}` description exists in database but not in the configuration"
                           @generator.remove_trigger_comment updated_trigger
                         else
+                          log.info "      Trigger `#{trigger_name}` description does not match"
                           @generator.set_trigger_comment updated_trigger
                         end
                       end
@@ -53,11 +64,15 @@ module DynamicMigrations
                     # If the trigger exists in both the configuration and database representations
                     # but the description is different then we need to update the description.
                     elsif configuration_trigger[:description][:matches] == false
+                      log.info "    Trigger `#{trigger_name}` exists in both configuration and the database"
+
                       trigger = @database.configured_schema(schema_name).table(table_name).trigger(trigger_name)
                       # if the description was removed
                       if configuration_trigger[:description].nil?
+                        log.info "      Trigger `#{trigger_name}` description exists in database but not in the configuration"
                         @generator.remove_trigger_comment trigger
                       else
+                        log.info "      Trigger `#{trigger_name}` description does not match"
                         @generator.set_trigger_comment trigger
                       end
                     end

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/unique_constraints.rb

@@ -10,9 +10,11 @@ module DynamicMigrations
               module Tables
                 module UniqueConstraints
                   def process_unique_constraints schema_name, table_name, configuration_unique_constraints, database_unique_constraints
+                    log.info "    Processing Unique Constraints..."
                     # process all the unique_constraints
                     unique_constraint_names = (configuration_unique_constraints.keys + database_unique_constraints.keys).uniq
                     unique_constraint_names.each do |unique_constraint_name|
+                      log.info "    Processing Unique Constraint #{unique_constraint_name}..."
                       process_unique_constraint schema_name, table_name, unique_constraint_name, configuration_unique_constraints[unique_constraint_name] || {}, database_unique_constraints[unique_constraint_name] || {}
                     end
                   end
@@ -21,6 +23,8 @@ module DynamicMigrations
                     # If the unique_constraint exists in the configuration but not in the database
                     # then we have to create it.
                     if configuration_unique_constraint[:exists] == true && !database_unique_constraint[:exists]
+                      log.info "    Unique Constraint `#{unique_constraint_name}` exists in configuration but not in the database"
+
                       # a migration to create the unique_constraint
                       unique_constraint = @database.configured_schema(schema_name).table(table_name).unique_constraint(unique_constraint_name)
                       @generator.add_unique_constraint unique_constraint
@@ -28,6 +32,8 @@ module DynamicMigrations
                     # If the schema exists in the database but not in the configuration
                     # then we need to delete it.
                     elsif database_unique_constraint[:exists] == true && !configuration_unique_constraint[:exists]
+                      log.info "    Unique Constraint `#{unique_constraint_name}` exists in database but not in the configuration"
+
                       # a migration to create the unique_constraint
                       unique_constraint = @database.loaded_schema(schema_name).table(table_name).unique_constraint(unique_constraint_name)
                       @generator.remove_unique_constraint unique_constraint
@@ -36,6 +42,9 @@ module DynamicMigrations
                     # but the definition (except description, which is handled seeprately below) is different
                     # then we need to update the definition.
                     elsif configuration_unique_constraint.except(:exists, :description).filter { |name, attributes| attributes[:matches] == false }.any?
+                      log.info "    Unique Constraint `#{unique_constraint_name}` exists in both configuration and the database"
+
+                      log.info "      Unique Constraint `#{unique_constraint_name}` is different"
                       # recreate the unique_constraint
                       original_unique_constraint = @database.loaded_schema(schema_name).table(table_name).unique_constraint(unique_constraint_name)
                       updated_unique_constraint = @database.configured_schema(schema_name).table(table_name).unique_constraint(unique_constraint_name)
@@ -44,8 +53,10 @@ module DynamicMigrations
                       if configuration_unique_constraint[:description][:matches] == false
                         # if the description was removed
                         if configuration_unique_constraint[:description].nil?
+                          log.info "      Unique Constraint `#{unique_constraint_name}` description exists in database but not in the configuration"
                           @generator.remove_unique_constraint_comment updated_unique_constraint
                         else
+                          log.info "      Unique Constraint `#{unique_constraint_name}` description does not match"
                           @generator.set_unique_constraint_comment updated_unique_constraint
                         end
                       end
@@ -53,11 +64,15 @@ module DynamicMigrations
                     # If the unique_constraint exists in both the configuration and database representations
                     # but the description is different then we need to update the description.
                     elsif configuration_unique_constraint[:description][:matches] == false
+                      log.info "    Unique Constraint `#{unique_constraint_name}` exists in both configuration and the database"
+
                       unique_constraint = @database.configured_schema(schema_name).table(table_name).unique_constraint(unique_constraint_name)
                       # if the description was removed
                       if configuration_unique_constraint[:description].nil?
+                        log.info "      Unique Constraint `#{unique_constraint_name}` description exists in database but not in the configuration"
                         @generator.remove_unique_constraint_comment unique_constraint
                       else
+                        log.info "      Unique Constraint `#{unique_constraint_name}` description does not match"
                         @generator.set_unique_constraint_comment unique_constraint
                       end
                     end

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/validations.rb

@@ -11,8 +11,10 @@ module DynamicMigrations
                 module Validations
                   def process_validations schema_name, table_name, configuration_validations, database_validations
                     # process all the validations
+                    log.info "    Processing Validations..."
                     validation_names = (configuration_validations.keys + database_validations.keys).uniq
                     validation_names.each do |validation_name|
+                      log.info "    Processing Validation #{validation_name}..."
                       process_validation schema_name, table_name, validation_name, configuration_validations[validation_name] || {}, database_validations[validation_name] || {}
                     end
                   end
@@ -21,6 +23,8 @@ module DynamicMigrations
                     # If the validation exists in the configuration but not in the database
                     # then we have to create it.
                     if configuration_validation[:exists] == true && !database_validation[:exists]
+                      log.info "    Validation `#{validation_name}` exists in configuration but not in the database"
+
                       # a migration to create the validation
                       validation = @database.configured_schema(schema_name).table(table_name).validation(validation_name)
                       @generator.add_validation validation
@@ -28,6 +32,8 @@ module DynamicMigrations
                     # If the schema exists in the database but not in the configuration
                     # then we need to delete it.
                     elsif database_validation[:exists] == true && !configuration_validation[:exists]
+                      log.info "    Validation `#{validation_name}` exists in database but not in the configuration"
+
                       # a migration to create the validation
                       validation = @database.loaded_schema(schema_name).table(table_name).validation(validation_name)
                       @generator.remove_validation validation
@@ -36,6 +42,9 @@ module DynamicMigrations
                     # but the definition (except description, which is handled seeprately below) is different
                     # then we need to update the definition.
                     elsif configuration_validation.except(:exists, :description).filter { |name, attributes| attributes[:matches] == false }.any?
+                      log.info "    Validation `#{validation_name}` exists in both configuration and the database"
+
+                      log.info "      Validation `#{validation_name}` is different"
                       # recreate the validation
                       original_validation = @database.loaded_schema(schema_name).table(table_name).validation(validation_name)
                       updated_validation = @database.configured_schema(schema_name).table(table_name).validation(validation_name)
@@ -44,8 +53,10 @@ module DynamicMigrations
                       if configuration_validation[:description][:matches] == false
                         # if the description was removed
                         if configuration_validation[:description].nil?
+                          log.info "      Validation `#{validation_name}` description exists in database but not in the configuration"
                           @generator.remove_validation_comment updated_validation
                         else
+                          log.info "      Validation `#{validation_name}` does not match"
                           @generator.set_validation_comment updated_validation
                         end
                       end
@@ -53,11 +64,15 @@ module DynamicMigrations
                     # If the validation exists in both the configuration and database representations
                     # but the description is different then we need to update the description.
                     elsif configuration_validation[:description][:matches] == false
+                      log.info "    Validation `#{validation_name}` exists in both configuration and the database"
+
                       validation = @database.configured_schema(schema_name).table(table_name).validation(validation_name)
                       # if the description was removed
                       if configuration_validation[:description].nil?
+                        log.info "      Validation `#{validation_name}` description exists in database but not in the configuration"
                         @generator.remove_validation_comment validation
                       else
+                        log.info "      Validation `#{validation_name}` does not match"
                         @generator.set_validation_comment validation
                       end
                     end

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables.rb

@@ -10,8 +10,10 @@ module DynamicMigrations
               module Tables
                 def process_tables schema_name, configuration_tables, database_tables
                   # process all the tables
+                  log.info "  Processing Tables..."
                   table_names = (configuration_tables.keys + database_tables.keys).uniq
                   table_names.each do |table_name|
+                    log.info "  Processing Table #{table_name}..."
                     process_table schema_name, table_name, configuration_tables[table_name] || {}, database_tables[table_name] || {}
                   end
                 end
@@ -20,6 +22,8 @@ module DynamicMigrations
                   # If the table exists in the configuration but not in the database
                   # then we have to create it.
                   if configuration_table[:exists] == true && !database_table[:exists]
+                    log.info "  Table `#{table_name}` exists in configuration but not in the database"
+
                     # a migration to create the table
                     table = @database.configured_schema(schema_name).table(table_name)
                     @generator.create_table table
@@ -31,6 +35,8 @@ module DynamicMigrations
                   # If the schema exists in the database but not in the configuration
                   # then we need to delete it.
                   elsif database_table[:exists] == true && !configuration_table[:exists]
+                    log.info "  Table `#{table_name}` exists in database but not in the configuration"
+
                     # we process everything else before we drop the table, because the other
                     # database objects are dependent on the table
                     process_dependents schema_name, table_name, {}, database_table
@@ -42,11 +48,15 @@ module DynamicMigrations
                   # If the table exists in both the configuration and database representations
                   # but the description is different then we need to update the description.
                   elsif configuration_table[:description][:matches] == false
+                    log.info "  Table `#{table_name}` exists in both configuration and the database"
+
                     table = @database.configured_schema(schema_name).table(table_name)
                     # if the description was removed
                     if configuration_table[:description].nil?
+                      log.info "    Table `#{table_name}` description exists in database but not in the configuration"
                       @generator.remove_table_comment table
                     else
+                      log.info "    Table `#{table_name}` description does not match"
                       @generator.set_table_comment table
                     end
 
@@ -54,6 +64,7 @@ module DynamicMigrations
                     process_dependents schema_name, table_name, configuration_table, database_table
 
                   else
+                    log.info "  Table `#{table_name}` exists in both configuration and the database"
                     # process everything else
                     process_dependents schema_name, table_name, configuration_table, database_table
 

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas.rb

@@ -11,6 +11,8 @@ module DynamicMigrations
                 # if the schema exists in the configuration but not in the database
                 # then we have to create it
                 if configuration_schema[:exists] == true && !database_schema[:exists]
+                  log.info "Schema `#{schema_name}` exists in configuration but not in the database"
+
                   # a migration to create the schema
                   schema = @database.configured_schema schema_name
                   @generator.create_schema schema
@@ -24,6 +26,7 @@ module DynamicMigrations
                 # if the schema exists in the database but not in the configuration
                 # then we need to delete it
                 elsif database_schema[:exists] == true && !configuration_schema[:exists]
+                  log.info "Schema `#{schema_name}` exists in database but not in the configuration"
                   # we process the tables and functions before we drop the schema
                   # as this will drop any dependencies on the schema
                   process_functions schema_name, {}, database_schema[:functions]
@@ -37,6 +40,7 @@ module DynamicMigrations
                 # if the schema exists in both the configuration and database representations
                 # then we just need to process the tables and functions
                 else
+                  log.info "Schema `#{schema_name}` exists in both configuration and the database"
                   process_functions schema_name, configuration_schema[:functions], database_schema[:functions]
                   process_enums schema_name, configuration_schema[:enums], database_schema[:enums]
                   process_tables schema_name, configuration_schema[:tables], database_schema[:tables]

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations.rb

@@ -26,6 +26,8 @@ module DynamicMigrations
             include Schemas::Tables::Validations
 
             def initialize database, differences
+              @logger = Logging.logger[self]
+
               raise UnexpectedDatabaseObjectError, database unless database.is_a? Database
               @database = database
 
@@ -38,15 +40,19 @@ module DynamicMigrations
 
             def migrations
               # process all the extensions
+              log.info "Processing Extensions..."
               extension_names = differences[:configuration][:extensions].keys
               extension_names.each do |extension_name|
+                log.info "Processing Extension `#{extension_name}`..."
                 process_extension extension_name, differences[:configuration][:extensions][extension_name], differences[:database][:extensions][extension_name]
               end
 
               # process all the schemas (we can fetch the schema names from either the
               # configuration or the database object)
+              log.info "Processing Schemas..."
               schema_names = differences[:configuration][:schemas].keys
               schema_names.each do |schema_name|
+                log.info "Processing Schema `#{schema_name}`..."
                 process_schema schema_name, differences[:configuration][:schemas][schema_name], differences[:database][:schemas][schema_name]
               end
 
@@ -59,6 +65,10 @@ module DynamicMigrations
             def differences
               @differences_hash ||= @differences.to_h
             end
+
+            def log
+              @logger
+            end
           end
         end
       end

data/lib/dynamic_migrations/postgres/server/database/differences.rb

@@ -18,6 +18,8 @@ module DynamicMigrations
           end
 
           def initialize database
+            @logger = Logging.logger[self]
+
             raise ExpectedDatabaseError, database unless database.is_a? Database
             @database = database
           end
@@ -31,19 +33,28 @@ module DynamicMigrations
           # return a hash representing any differenced betweek the loaded and configured
           # versions of the current database
           def to_h
-            {
-              configuration: {
-                schemas: self.class.compare_schemas(@database.configured_schemas_hash, @database.loaded_schemas_hash),
-                extensions: self.class.compare_extensions(@database.configured_extensions, @database.loaded_extensions)
-              },
-              database: {
-                schemas: self.class.compare_schemas(@database.loaded_schemas_hash, @database.configured_schemas_hash),
-                extensions: self.class.compare_extensions(@database.loaded_extensions, @database.configured_extensions)
-              }
+            log.info "Building differences between configured and loaded database structure..."
+
+            # build progressively, so we can add logging around the two different opperations
+            results = {}
+
+            log.info "Comparing configured database structure to loaded database structure..."
+            results[:configuration] = {
+              schemas: self.class.compare_schemas(@database.configured_schemas_hash, @database.loaded_schemas_hash),
+              extensions: self.class.compare_extensions(@database.configured_extensions, @database.loaded_extensions)
+            }
+
+            log.info "Comparing loaded database structure to configured database structure..."
+            results[:database] = {
+              schemas: self.class.compare_schemas(@database.loaded_schemas_hash, @database.configured_schemas_hash),
+              extensions: self.class.compare_extensions(@database.loaded_extensions, @database.configured_extensions)
             }
+            results
           end
 
           def self.compare_extensions extensions, comparison_extensions
+            log.info "Comparing Extensions..."
+
             result = {}
             # the extensions
             extensions.each do |extension_name|
@@ -65,6 +76,8 @@ module DynamicMigrations
           end
 
           def self.compare_schemas schemas, comparison_schemas
+            log.info "Comparing Schemas..."
+
             result = {}
             # the base schemas
             schemas.each do |schema_name, schema|
@@ -88,6 +101,8 @@ module DynamicMigrations
           def self.compare_schema schema, comparison_schema
             raise SchemaRequiredError if schema.nil?
 
+            log.info "Comparing Schema `#{schema.name}`"
+
             comparison_tables = comparison_schema.nil? ? {} : comparison_schema.tables_hash
             comparison_functions = comparison_schema.nil? ? {} : comparison_schema.functions_hash
             comparison_enums = comparison_schema.nil? ? {} : comparison_schema.enums_hash
@@ -103,6 +118,8 @@ module DynamicMigrations
           # an object which represents the provided `tables` and any differences
           # between it and the `comparison_tables`
           def self.compare_tables tables, comparison_tables
+            log.info "Comparing Tables..."
+
             result = {}
             # the base tables
             tables.each do |table_name, table|
@@ -126,6 +143,8 @@ module DynamicMigrations
           def self.compare_table table, comparison_table
             raise TableRequiredError if table.nil?
 
+            log.info "Comparing Table `#{table.name}`"
+
             primary_key = table.has_primary_key? ? table.primary_key : nil
             if comparison_table
               comparison_primary_key = comparison_table.has_primary_key? ? comparison_table.primary_key : nil
@@ -168,6 +187,8 @@ module DynamicMigrations
           # an object which represents the provided `functions` and any differences
           # between it and the `comparison_functions`
           def self.compare_functions functions, comparison_functions
+            log.info "Comparing Functions..."
+
             result = {}
             # the base functions
             functions.each do |function_name, function|
@@ -191,6 +212,8 @@ module DynamicMigrations
           # an object which represents the provided `enums` and any differences
           # between it and the `comparison_enums`
           def self.compare_enums enums, comparison_enums
+            log.info "Comparing Enums..."
+
             result = {}
             # the base enums
             enums.each do |enum_name, enum|
@@ -214,6 +237,8 @@ module DynamicMigrations
           # an object which represents the provided `columns` and any differences
           # between it and the `comparison_columns`
           def self.compare_columns columns, comparison_columns
+            log.info "Comparing Columns..."
+
             result = {}
             # the base columns
             columns.each do |column_name, column|
@@ -241,6 +266,8 @@ module DynamicMigrations
           # an object which represents the provided `triggers` and any differences
           # between it and the `comparison_triggers`
           def self.compare_triggers triggers, comparison_triggers
+            log.info "Comparing Triggers..."
+
             result = {}
             # the base triggers
             triggers.each do |trigger_name, trigger|
@@ -272,6 +299,8 @@ module DynamicMigrations
           # an object which represents the provided `unique_constraints` and any differences
           # between it and the `comparison_unique_constraints`
           def self.compare_unique_constraints unique_constraints, comparison_unique_constraints
+            log.info "Comparing Unique Constraints..."
+
             result = {}
             # the base unique_constraints
             unique_constraints.each do |name, unique_constraint|
@@ -298,6 +327,8 @@ module DynamicMigrations
           # an object which represents the provided `indexes` and any differences
           # between it and the `comparison_indexes`
           def self.compare_indexes indexes, comparison_indexes
+            log.info "Comparing Indexes..."
+
             result = {}
             # the base indexes
             indexes.each do |name, index|
@@ -327,6 +358,8 @@ module DynamicMigrations
           # an object which represents the provided `validations` and any differences
           # between it and the `comparison_validations`
           def self.compare_validations validations, comparison_validations
+            log.info "Comparing Validations..."
+
             result = {}
             # the base validations
             validations.each do |name, validation|
@@ -354,6 +387,8 @@ module DynamicMigrations
           # an object which represents the provided `foreign_key_constraints` and any differences
           # between it and the `comparison_foreign_key_constraints`
           def self.compare_foreign_key_constraints foreign_key_constraints, comparison_foreign_key_constraints
+            log.info "Comparing Foreign Key Constraints..."
+
             result = {}
             # the base foreign_key_constraints
             foreign_key_constraints.each do |name, foreign_key_constraint|
@@ -391,8 +426,14 @@ module DynamicMigrations
                 exists: false
               }
             else
+              type = base.class.name.split("::").last
+              name = base.is_a?(Schema::Table::PrimaryKey) ? nil : base.name
+              log.info "  Comparing #{type} `#{name}`"
+
               result = {}
               method_list.each do |method_name|
+                log.info "    Comparing `#{method_name}`"
+
                 matches = (comparison && comparison.send(method_name) == base.send(method_name)) || false
                 result[method_name] = {
                   value: base.send(method_name),
@@ -403,6 +444,14 @@ module DynamicMigrations
               result
             end
           end
+
+          def self.log
+            @logger ||= Logging.logger[self]
+          end
+
+          def log
+            @logger
+          end
         end
       end
     end

data/lib/dynamic_migrations/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DynamicMigrations
-  VERSION = "3.8.2"
+  VERSION = "3.8.3"
 end

data/lib/dynamic_migrations.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
+# postgres gem
 require "pg"
+# logging gem
+require "logging"
 
 require "dynamic_migrations/version"
 require "dynamic_migrations/invalid_source_error"

data/sig/dynamic_migrations/postgres/server/database/differences/to_migrations/extensions.rbs

@@ -10,6 +10,9 @@ module DynamicMigrations
             module Extensions
 
               private
+              # this method is available on the ToMigrations class which includes this module
+              def log: -> Logging::Logger
+
               def process_extension: (Symbol extension_name, untyped configuration_extension, untyped database_extension) -> void
 
 

data/sig/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/enums.rbs

@@ -13,6 +13,8 @@ module DynamicMigrations
                 private
                 def process_enums: (Symbol schema_name, untyped configuration_enums, untyped database_enums) -> void
                 def process_enum: (Symbol schema_name, Symbol enum_name, untyped configuration_enum, untyped database_enum) -> void
+                # this method is available on the ToMigrations class which includes this module
+                def log: -> Logging::Logger
 
               end
             end

data/sig/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/functions.rbs

@@ -13,6 +13,8 @@ module DynamicMigrations
                 private
                 def process_functions: (Symbol schema_name, untyped configuration_functions, untyped database_functions) -> void
                 def process_function: (Symbol schema_name, Symbol function_name, untyped configuration_function, untyped database_function) -> void
+                # this method is available on the ToMigrations class which includes this module
+                def log: -> Logging::Logger
 
               end
             end

data/sig/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/columns.rbs

@@ -14,6 +14,8 @@ module DynamicMigrations
                   private
                   def process_columns: (Symbol schema_name, Symbol table_name, untyped configuration_columns, untyped database_columns) -> void
                   def process_column: (Symbol schema_name, Symbol table_name, Symbol column_name, untyped configuration_column, untyped database_column) -> void
+                  # this method is available on the ToMigrations class which includes this module
+                  def log: -> Logging::Logger
 
                 end
               end

data/sig/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/foreign_key_constraints.rbs

@@ -14,6 +14,8 @@ module DynamicMigrations
                   private
                   def process_foreign_key_constraints: (Symbol schema_name, Symbol table_name, untyped configuration_foreign_key_constraints, untyped database_foreign_key_constraints) -> void
                   def process_foreign_key_constraint: (Symbol schema_name, Symbol table_name, Symbol foreign_key_constraint_name, untyped configuration_foreign_key_constraint, untyped database_foreign_key_constraint) -> void
+                  # this method is available on the ToMigrations class which includes this module
+                  def log: -> Logging::Logger
 
                 end
               end

data/sig/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/indexes.rbs

@@ -14,6 +14,8 @@ module DynamicMigrations
                   private
                   def process_indexes: (Symbol schema_name, Symbol table_name, untyped configuration_indexes, untyped database_indexes) -> void
                   def process_index: (Symbol schema_name, Symbol table_name, Symbol index_name, untyped configuration_index, untyped database_index) -> void
+                  # this method is available on the ToMigrations class which includes this module
+                  def log: -> Logging::Logger
 
                 end
               end

data/sig/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/primary_key.rbs

@@ -13,6 +13,8 @@ module DynamicMigrations
 
                   private
                   def process_primary_key: (Symbol schema_name, Symbol table_name, untyped configuration_primary_key, untyped database_primary_key) -> void
+                  # this method is available on the ToMigrations class which includes this module
+                  def log: -> Logging::Logger
 
                 end
               end

data/sig/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/triggers.rbs

@@ -14,6 +14,8 @@ module DynamicMigrations
                   private
                   def process_triggers: (Symbol schema_name, Symbol table_name, untyped configuration_triggers, untyped database_triggers) -> void
                   def process_trigger: (Symbol schema_name, Symbol table_name, Symbol trigger_name, untyped configuration_trigger, untyped database_trigger) -> void
+                  # this method is available on the ToMigrations class which includes this module
+                  def log: -> Logging::Logger
 
                 end
               end

data/sig/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/unique_constraints.rbs

@@ -14,6 +14,8 @@ module DynamicMigrations
                   private
                   def process_unique_constraints: (Symbol schema_name, Symbol table_name, untyped configuration_unique_constraints, untyped database_unique_constraints) -> void
                   def process_unique_constraint: (Symbol schema_name, Symbol table_name, Symbol unique_constraint_name, untyped configuration_unique_constraint, untyped database_unique_constraint) -> void
+                  # this method is available on the ToMigrations class which includes this module
+                  def log: -> Logging::Logger
 
                 end
               end

data/sig/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/validations.rbs

@@ -14,6 +14,8 @@ module DynamicMigrations
                   private
                   def process_validations: (Symbol schema_name, Symbol table_name, untyped configuration_validations, untyped database_validations) -> void
                   def process_validation: (Symbol schema_name, Symbol table_name, Symbol validation_name, untyped configuration_validation, untyped database_validation) -> void
+                  # this method is available on the ToMigrations class which includes this module
+                  def log: -> Logging::Logger
 
                 end
               end

data/sig/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables.rbs

@@ -22,6 +22,8 @@ module DynamicMigrations
                 def process_triggers: (Symbol schema_name, Symbol table_name, untyped configuration_triggers, untyped database_triggers) -> void
                 def process_unique_constraints: (Symbol schema_name, Symbol table_name, untyped configuration_unique_constraints, untyped database_unique_constraints) -> void
                 def process_validations: (Symbol schema_name, Symbol table_name, untyped configuration_validations, untyped database_validations) -> void
+                # this method is available on the ToMigrations class which includes this module
+                def log: -> Logging::Logger
 
               end
             end

data/sig/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas.rbs

@@ -21,6 +21,9 @@ module DynamicMigrations
               # this method comes from the Tables module
               def process_tables: (Symbol schema_name, untyped configuration_tables, untyped database_tables) -> void
 
+              # this method is available on the ToMigrations class which includes this module
+              def log: -> Logging::Logger
+
             end
           end
         end

data/sig/dynamic_migrations/postgres/server/database/differences/to_migrations.rbs

@@ -8,6 +8,7 @@ module DynamicMigrations
         class Differences
           class ToMigrations
             @database: Database
+            @logger: Logging::Logger
             @differences_hash: untyped
             @generator: Generator
             @differences: Differences
@@ -30,6 +31,7 @@ module DynamicMigrations
 
             private
             def differences: -> Hash[untyped, untyped]
+            def log: -> Logging::Logger
 
             # this method comes from the Schemas module
             def process_schema: (Symbol schema_name, untyped configuration_schema, untyped database_schema) -> void

data/sig/dynamic_migrations/postgres/server/database/differences.rbs

@@ -4,18 +4,11 @@ module DynamicMigrations
       class Database
         class Differences
           @database: Database
+          @logger: Logging::Logger
+          self.@logger: Logging::Logger
 
           def initialize: (Database database) -> void
-          def to_h: -> {
-            configuration: {
-              schemas: Hash[Symbol, untyped],
-              extensions: Hash[Symbol, {exists: bool}]
-            },
-            database: {
-              schemas: Hash[Symbol, untyped],
-              extensions: Hash[Symbol, {exists: bool}]
-            }
-          }
+          def to_h: -> untyped
           def to_migrations: -> Hash[Symbol, Array[{name: Symbol, content: String}]]
 
           def self.compare_schemas: (Hash[Symbol, Schema] schemas, Hash[Symbol, Schema] comparison_schemas) -> Hash[Symbol, untyped]
@@ -34,7 +27,11 @@ module DynamicMigrations
           def self.compare_indexes: (Hash[Symbol, Schema::Table::Index] indexes, Hash[Symbol, Schema::Table::Index] comparison_indexes) -> Hash[Symbol, untyped]
           def self.compare_validations: (Hash[Symbol, Schema::Table::Validation] validations, Hash[Symbol, Schema::Table::Validation] comparison_validations) -> Hash[Symbol, untyped]
           def self.compare_foreign_key_constraints: (Hash[Symbol, Schema::Table::ForeignKeyConstraint] foreign_key_constraints, Hash[Symbol, Schema::Table::ForeignKeyConstraint] comparison_foreign_key_constraints) -> Hash[Symbol, untyped]
-          def self.compare_record: (Object | nil base, Object | nil comparison, Array[Symbol] method_list) -> Hash[Symbol, untyped]
+          def self.compare_record: (untyped | nil base, Object | nil comparison, Array[Symbol] method_list) -> Hash[Symbol, untyped]
+          def self.log: -> Logging::Logger
+
+          private
+          def log: -> Logging::Logger
 
           class ExpectedDatabaseError < StandardError
           end

data/sig/logging.rbs

@@ -0,0 +1,11 @@
+module Logging
+  class Logger
+    def []: (Object) -> Logger
+
+    def debug: (String) -> void
+    def info: (String) -> void
+    def warn: (String) -> void
+  end
+
+  def self.logger: () -> Logger
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynamic_migrations
 version: !ruby/object:Gem::Version
-  version: 3.8.2
+  version: 3.8.3
 platform: ruby
 authors:
 - Craig Ulliott
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
 - !ruby/object:Gem::Dependency
   name: yaml
   requirement: !ruby/object:Gem::Requirement
@@ -247,6 +261,7 @@ files:
 - sig/dynamic_migrations/postgres/server/database/structure_loader.rbs
 - sig/dynamic_migrations/postgres/server/database/triggers_and_functions_loader.rbs
 - sig/dynamic_migrations/postgres/server/database/validations_loader.rbs
+- sig/logging.rbs
 - sig/pg.rbs
 - sig/tsort.rbs
 homepage: