dynamic_migrations 3.8.6 → 3.8.7

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

@@ -10,10 +10,10 @@ module DynamicMigrations
               module Tables
                 def process_tables schema_name, configuration_tables, database_tables
                   # process all the tables
-                  log.info "  Processing Tables..."
+                  log.debug "  Processing Tables"
                   table_names = (configuration_tables.keys + database_tables.keys).uniq
                   table_names.each do |table_name|
-                    log.info "  Processing Table #{table_name}..."
+                    log.debug "  Processing Table #{table_name}"
                     process_table schema_name, table_name, configuration_tables[table_name] || {}, database_tables[table_name] || {}
                   end
                 end
@@ -22,7 +22,7 @@ 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"
+                    log.debug "  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)
@@ -35,7 +35,7 @@ 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"
+                    log.debug "  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
@@ -48,15 +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"
+                    log.debug "  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"
+                      log.debug "    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"
+                      log.debug "    Table `#{table_name}` description does not match"
                       @generator.set_table_comment table
                     end
 
@@ -64,7 +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"
+                    log.debug "  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,7 +11,7 @@ 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"
+                  log.debug "Schema `#{schema_name}` exists in configuration but not in the database"
 
                   # a migration to create the schema
                   schema = @database.configured_schema schema_name
@@ -26,7 +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"
+                  log.debug "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]
@@ -40,7 +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"
+                  log.debug "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

@@ -40,19 +40,19 @@ module DynamicMigrations
 
             def migrations
               # process all the extensions
-              log.info "Processing Extensions..."
+              log.debug "Processing Extensions"
               extension_names = differences[:configuration][:extensions].keys
               extension_names.each do |extension_name|
-                log.info "Processing Extension `#{extension_name}`..."
+                log.debug "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..."
+              log.debug "Processing Schemas"
               schema_names = differences[:configuration][:schemas].keys
               schema_names.each do |schema_name|
-                log.info "Processing Schema `#{schema_name}`..."
+                log.debug "Processing Schema `#{schema_name}`"
                 process_schema schema_name, differences[:configuration][:schemas][schema_name], differences[:database][:schemas][schema_name]
               end
 

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

@@ -33,18 +33,18 @@ module DynamicMigrations
           # return a hash representing any differenced betweek the loaded and configured
           # versions of the current database
           def to_h
-            log.info "Building differences between configured and loaded database structure..."
+            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..."
+            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..."
+            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)
@@ -53,7 +53,7 @@ module DynamicMigrations
           end
 
           def self.compare_extensions extensions, comparison_extensions
-            log.info "Comparing Extensions..."
+            log.info "Comparing Extensions"
 
             result = {}
             # the extensions
@@ -76,7 +76,7 @@ module DynamicMigrations
           end
 
           def self.compare_schemas schemas, comparison_schemas
-            log.info "Comparing Schemas..."
+            log.info "Comparing Schemas"
 
             result = {}
             # the base schemas
@@ -118,7 +118,7 @@ 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..."
+            log.debug "Comparing Tables"
 
             result = {}
             # the base tables
@@ -143,7 +143,7 @@ module DynamicMigrations
           def self.compare_table table, comparison_table
             raise TableRequiredError if table.nil?
 
-            log.info "Comparing Table `#{table.name}`"
+            log.debug "Comparing Table `#{table.name}`"
 
             primary_key = table.has_primary_key? ? table.primary_key : nil
             if comparison_table
@@ -187,7 +187,7 @@ 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..."
+            log.debug "Comparing Functions"
 
             result = {}
             # the base functions
@@ -212,7 +212,7 @@ 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..."
+            log.debug "Comparing Enums"
 
             result = {}
             # the base enums
@@ -237,7 +237,7 @@ 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..."
+            log.debug "Comparing Columns"
 
             result = {}
             # the base columns
@@ -266,7 +266,7 @@ 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..."
+            log.debug "Comparing Triggers"
 
             result = {}
             # the base triggers
@@ -299,7 +299,7 @@ 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..."
+            log.debug "Comparing Unique Constraints"
 
             result = {}
             # the base unique_constraints
@@ -327,7 +327,7 @@ 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..."
+            log.debug "Comparing Indexes"
 
             result = {}
             # the base indexes
@@ -358,7 +358,7 @@ 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..."
+            log.debug "Comparing Validations"
 
             result = {}
             # the base validations
@@ -387,7 +387,7 @@ 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..."
+            log.debug "Comparing Foreign Key Constraints"
 
             result = {}
             # the base foreign_key_constraints
@@ -428,11 +428,11 @@ module DynamicMigrations
             else
               type = base.class.name.split("::").last
               name = base.is_a?(Schema::Table::PrimaryKey) ? nil : base.name
-              log.info "  Comparing #{type} `#{name}`"
+              log.debug "  Comparing #{type} `#{name}`"
 
               result = {}
               method_list.each do |method_name|
-                log.info "    Comparing `#{method_name}`"
+                log.debug "    Comparing `#{method_name}`"
 
                 matches = (comparison && comparison.send(method_name) == base.send(method_name)) || false
                 result[method_name] = {

data/lib/dynamic_migrations/postgres/server/database/schema/enum.rb

@@ -19,6 +19,9 @@ module DynamicMigrations
             class ValueMustBeStringError < StandardError
             end
 
+            class EnumValueTooLongError < StandardError
+            end
+
             attr_reader :schema
             attr_reader :name
             attr_reader :values
@@ -61,6 +64,10 @@ module DynamicMigrations
                 raise ValueAlreadyExistsError, "Value `#{value}` already exists in enum `#{name}`"
               end
 
+              if value.length > 63
+                raise EnumValueTooLongError, "Value `#{value}` must be less than 64 characters"
+              end
+
               @values << value
             end
 

data/lib/dynamic_migrations/postgres/server/database/schema/table.rb

@@ -16,6 +16,9 @@ module DynamicMigrations
             class PrimaryKeyAlreadyExistsError < StandardError
             end
 
+            class MissingExtensionError < StandardError
+            end
+
             include Columns
             include Validations
             include Indexes
@@ -116,7 +119,64 @@ module DynamicMigrations
               end
 
               # in case any of the columnbs are citext columns
-              connection.exec("CREATE EXTENSION IF NOT EXISTS citext;")
+              # in case any of the columns use the citext data type
+              required_extensions = []
+              if columns.any? { |column| column.data_type.start_with? "citext" }
+                required_extensions << "citext"
+              end
+              if columns.any? { |column| column.data_type.start_with? "postgis" }
+                required_extensions << "postgis"
+              end
+
+              required_extensions.each do |extension_name|
+                extension_result = connection.exec(<<~SQL)
+                  SELECT
+                    (
+                      SELECT 1
+                      FROM pg_available_extensions
+                      WHERE name = '#{extension_name}'
+                    ) as is_available,
+                    (
+                      SELECT 1
+                      FROM pg_extension
+                      WHERE extname = '#{extension_name}'
+                    ) as is_installed
+                SQL
+
+                row = extension_result.first
+                raise MissingExtensionError, "unexpected error" if row.nil?
+
+                unless row["is_installed"]
+                  detail = if row["is_available"]
+                    <<~DETAIL
+                      The `#{extension_name}` extension is available for installation,
+                      but has not been installed for this database.
+                    DETAIL
+                  else
+                    <<~DETAIL
+                      The `#{extension_name}` extension is not installed, and does not
+                      appear to be available for installation.
+                    DETAIL
+                  end
+                  raise MissingExtensionError, <<~ERROR.tr!("\n", " ")
+                    This table uses the `#{extension_name}` data type. #{detail}
+                    Add the extension, then generate and run the migrations which will
+                    enable the extension for your database before defining validations
+                    or triggers which rely on it.
+
+                    Note, the `#{extension_name}` extension is required even for defining
+                    some validations and triggers. This library needs to connect to postgres
+                    and gererate normalized versions of validation check clauses and trigger
+                    action conditions before it can even compare them to validations or triggers
+                    which may or may not already exist in the database.
+                  ERROR
+                end
+              end
+
+              # if any of the columns require postgis
+              if required_extensions.include? "postgis"
+                connection.exec("SET search_path TO public,postgis;")
+              end
 
               # note, this is not actually a TEMP TABLE, it is created within a transaction
               # and rolled back.

data/lib/dynamic_migrations/version.rb

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

data/sig/dynamic_migrations/postgres/generator/enum.rbs

@@ -10,6 +10,8 @@ module DynamicMigrations
         def drop_enum: (Server::Database::Schema::Enum enum, ?String? code_comment) -> Fragment
         def set_enum_comment: (Server::Database::Schema::Enum enum, ?String? code_comment) -> Fragment
         def remove_enum_comment: (Server::Database::Schema::Enum enum, ?String? code_comment) -> Fragment
+        def optional_enum_table: (Postgres::Server::Database::Schema::Enum enum) -> Server::Database::Schema::Table?
+
         # these come from the generator object (which this module is included into)
         def add_fragment: (migration_method: Symbol, object: untyped, migration: String, ?schema: Server::Database::Schema?, ?table: Server::Database::Schema::Table?, ?code_comment: String?, ?dependent_table: Server::Database::Schema::Table?, ?dependent_function: Server::Database::Schema::Function?, ?dependent_enum: Server::Database::Schema::Enum?) -> Fragment
         def indent: (String migration, ?Integer levels) -> String

data/sig/dynamic_migrations/postgres/generator/function.rbs

@@ -10,6 +10,7 @@ module DynamicMigrations
         def drop_function: (Postgres::Server::Database::Schema::Function function, ?String? code_comment) -> Fragment
         def set_function_comment: (Postgres::Server::Database::Schema::Function function, ?String? code_comment) -> Fragment
         def remove_function_comment: (Postgres::Server::Database::Schema::Function function, ?String? code_comment) -> Fragment
+        def optional_function_table: (Postgres::Server::Database::Schema::Function function) -> Server::Database::Schema::Table?
 
         # these come from the generator object (which this module is included into)
         def add_fragment: (migration_method: Symbol, object: untyped, migration: String, ?schema: Server::Database::Schema?, ?table: Server::Database::Schema::Table?, ?code_comment: String?, ?dependent_table: Server::Database::Schema::Table?, ?dependent_function: Server::Database::Schema::Function?, ?dependent_enum: Server::Database::Schema::Enum?) -> Fragment

data/sig/dynamic_migrations/postgres/generator/migration.rbs

@@ -22,6 +22,7 @@ module DynamicMigrations
         def enum_dependencies: -> Array[{schema_name: Symbol, enum_name: Symbol}]
         def function_dependencies: -> Array[{schema_name: Symbol, function_name: Symbol}]
 
+        def fragments_with_table_dependency_count: (Symbol schema_name, Symbol table_name) -> Integer
         def extract_fragments_with_table_dependency: (Symbol schema_name, Symbol table_name) -> Array[Fragment]
 
         def content: -> String

data/sig/dynamic_migrations/postgres/generator/schema_migration.rbs

@@ -5,6 +5,8 @@ module DynamicMigrations
   module Postgres
     class Generator
       class SchemaMigration < Migration
+        def schema_name: -> Symbol
+
         def initialize: (Symbol schema_name) -> void
 
       end

data/sig/dynamic_migrations/postgres/generator/table_migration.rbs

@@ -5,6 +5,9 @@ module DynamicMigrations
   module Postgres
     class Generator
       class TableMigration < Migration
+        def schema_name: -> Symbol
+        def table_name: -> Symbol
+
         def initialize: (Symbol schema_name, Symbol table_name) -> void
       end
     end

data/sig/dynamic_migrations/postgres/generator.rbs

@@ -7,6 +7,7 @@ module DynamicMigrations
       include TSort
 
       @fragments: Array[Fragment]
+      @logger: Logging::Logger
 
       include Schema
       include Table
@@ -27,13 +28,14 @@ module DynamicMigrations
       }]
 
       private
-      def circular_dependency?: (Symbol schema_name, Symbol table_name, {schema_name: Symbol, table_name: Symbol} dependency, Array[TableMigration] all_table_migrations) -> bool
+      def resolve_circular_dependencies: (TableMigration table_migration, Array[TableMigration] all_table_migrations, Hash[Symbol, untyped] database_migrations, Array[TableMigration] completed_table_migrations, ?Array[String] stack) -> void
       def supported_migration_method?: (Symbol migration_method) -> bool
       def add_fragment: (migration_method: Symbol, object: untyped, migration: String, ?schema: Server::Database::Schema?, ?table: Server::Database::Schema::Table?, ?code_comment: String?, ?dependent_table: Server::Database::Schema::Table?, ?dependent_function: Server::Database::Schema::Function?, ?dependent_enum: Server::Database::Schema::Enum?) -> Fragment
       def indent: (String migration, ?Integer levels) -> String
       def tsort_each_node: -> Enumerator[untyped, untyped]
       def tsort_each_child: (untyped node) -> untyped
       def trim_lines: (String migration) -> String
+      def log: -> Logging::Logger
 
       class ExpectedSymbolError < StandardError
       end

data/sig/dynamic_migrations/postgres/server/database/schema/enum.rbs

@@ -30,6 +30,9 @@ module DynamicMigrations
 
             class ValueMustBeStringError < StandardError
             end
+
+            class EnumValueTooLongError < StandardError
+            end
           end
         end
       end

data/sig/dynamic_migrations/postgres/server/database/schema/table.rbs

@@ -31,6 +31,9 @@ module DynamicMigrations
 
             class PrimaryKeyAlreadyExistsError < StandardError
             end
+
+            class MissingExtensionError < StandardError
+            end
           end
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dynamic_migrations
 version: !ruby/object:Gem::Version
-  version: 3.8.6
+  version: 3.8.7
 platform: ruby
 authors:
 - Craig Ulliott
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-08 00:00:00.000000000 Z
+date: 2023-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg