dynamic_migrations 3.6.9 → 3.6.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eda59bc82b8accf553a95dabc66fdb1d59ea68750cb4318b2ee970d62d5b679f
-  data.tar.gz: faaf288de33ee1a6d419be2148a4cc7ec5f76bcd05260d5419b82af7fd256f51
+  metadata.gz: f31ee44c0dced52756c6f563ea8b321b0cbce5d6cd53f7ef7fb796efb5f7e58a
+  data.tar.gz: f3151d84b1574d421d9c122310ce3394f98d4920aa571dc168de2858c91cdc7a
 SHA512:
-  metadata.gz: 85bb27898ab75f4815f7d08b6c7cdd27174f7bbb850fb55d21dad082627077e175d26b87fa64aa3651d98a914e1719a81d0d72955b7b763ecb5fe2ee5e93c9a1
-  data.tar.gz: a2bb9765ad753949c7f8db6640ca41046f7d1e946d0ed05211cce922d1f0c8b63dc4111183d1ab556c8f4b01278f3f83b2a39fd45c49dd50f718e32e8e617bbb
+  metadata.gz: c090b0758ed52dd8b21a5327e83f6d41f23afc5ad3c53bf265166a85245738c37c5188b15dfed27bb890b36db62896590c7dea3fc8d80e130120d43bd548e560
+  data.tar.gz: 74eb4c9ad0d25987f588ccdc0239e460bbc7169a82cec5fc7c837077e822570ac11d61ae7a136a27f49a5c7093c2e91100d22dd3247729bbbb63fd9c316e19f2

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [3.6.11](https://github.com/craigulliott/dynamic_migrations/compare/v3.6.10...v3.6.11) (2023-09-13)
+
+
+### Bug Fixes
+
+* injecting dependent_function into templated triggers ([9e770a3](https://github.com/craigulliott/dynamic_migrations/commit/9e770a352b176c7b10471e9185ac01feca538c0c))
+* writing enums to the migration files as arrays of strings for more compatibility with special characters ([1910e0f](https://github.com/craigulliott/dynamic_migrations/commit/1910e0f709e5bd560696c2e2b3bd729c7a61e319))
+
+## [3.6.10](https://github.com/craigulliott/dynamic_migrations/compare/v3.6.9...v3.6.10) (2023-09-13)
+
+
+### Bug Fixes
+
+* only concerned about function and enum dependencies if they are in other schemas or have multiple objects which reference them ([ee42670](https://github.com/craigulliott/dynamic_migrations/commit/ee426704d56329cd4ae450d93308097a4419ee63))
+* some extensions have hyphens in their names, coercing them to underscores so that this does not break the migration class name ([0b2396b](https://github.com/craigulliott/dynamic_migrations/commit/0b2396b171f6d1eeb8dc4567658937576357ba2a))
+
 ## [3.6.9](https://github.com/craigulliott/dynamic_migrations/compare/v3.6.8...v3.6.9) (2023-09-13)
 
 

data/lib/dynamic_migrations/postgres/generator/column.rb

@@ -45,11 +45,19 @@ module DynamicMigrations
             "\"#{data_type}\""
           end
 
+          # we only provide a dependent enum if the enum has more than one column
+          # or is in a different schema, otherwise it is added to the same migration as this
+          # column and we don't need to worry about dependencies
+          dependent_enum = nil
+          # column.enum will be nil if the column is not an enum
+          if column.enum && (column.enum.columns.count > 1 || column.table.schema != column.enum.schema)
+            dependent_enum = column.enum
+          end
+
           add_fragment schema: column.table.schema,
             table: column.table,
             migration_method: :add_column,
-            # this will be nil if the column is not an enum
-            dependent_enum: column.enum,
+            dependent_enum: dependent_enum,
             object: column,
             code_comment: code_comment,
             migration: <<~RUBY

data/lib/dynamic_migrations/postgres/generator/enum.rb

@@ -6,13 +6,22 @@ module DynamicMigrations
         end
 
         def create_enum enum, code_comment = nil
+          # we only provide a table if the enum has a single column and they
+          # are in the same schema, otherwise we can't reliable handle dependencies
+          # so the enum will be created in the schema's migration
+          enum_table = nil
+          if enum.columns.count == 1 && enum.schema == enum.columns.first&.table&.schema
+            enum_table = enum.columns.first&.table
+          end
+
           add_fragment schema: enum.schema,
+            table: enum_table,
             migration_method: :create_enum,
             object: enum,
             code_comment: code_comment,
             migration: <<~RUBY
               create_enum :#{enum.name}, [
-                :#{enum.values.join(",\n  :")}
+                "#{enum.values.join("\",\n  \"")}"
               ]
             RUBY
         end
@@ -31,7 +40,7 @@ module DynamicMigrations
             code_comment: code_comment,
             migration: <<~RUBY
               add_enum_values :#{updated_enum.name}, [
-                :#{added_values.join(",\n  :")}
+                "#{added_values.join("\",\n  \"")}"
               ]
             RUBY
         end

data/lib/dynamic_migrations/postgres/generator/extension.rb

@@ -5,7 +5,9 @@ module DynamicMigrations
         def enable_extension extension_name, code_comment = nil
           # no table or schema name for this fragment (it is executed at the database level)
           add_fragment migration_method: :enable_extension,
-            object: extension_name,
+            # some extensions have hyphens in them, so coerce the name to underscores
+            # because the object name is used in the migration class name
+            object: extension_name.to_s.tr("-", "_").to_sym,
             code_comment: code_comment,
             migration: <<~RUBY
               enable_extension "#{extension_name}"
@@ -15,7 +17,9 @@ module DynamicMigrations
         def disable_extension extension_name, code_comment = nil
           # no table or schema name for this fragment (it is executed at the database level)
           add_fragment migration_method: :disable_extension,
-            object: extension_name,
+            # some extensions have hyphens in them, so coerce the name to underscores
+            # because the object name is used in the migration class name
+            object: extension_name.to_s.tr("-", "_").to_sym,
             code_comment: code_comment,
             migration: <<~RUBY
               disable_extension "#{extension_name}"

data/lib/dynamic_migrations/postgres/generator/fragment.rb

@@ -2,6 +2,9 @@ module DynamicMigrations
   module Postgres
     class Generator
       class Fragment
+        class InvalidNameError < StandardError
+        end
+
         attr_reader :schema_name
         attr_reader :table_name
         attr_reader :migration_method
@@ -12,10 +15,24 @@ module DynamicMigrations
         attr_reader :dependency_enum_name
 
         def initialize schema_name, table_name, migration_method, object_name, code_comment, content
+          valid_name_regex = /\A[a-z][a-z0-9]+(_[a-z0-9]+)*\z/
+
+          unless schema_name.nil? || (schema_name.to_s.match valid_name_regex)
+            raise InvalidNameError, "Invalid schema name `#{schema_name}`, must only be lowercase letters, numbers and underscores"
+          end
           @schema_name = schema_name
+
+          unless table_name.nil? || (table_name.to_s.match valid_name_regex)
+            raise InvalidNameError, "Invalid table name `#{table_name}`, must only be lowercase letters, numbers and underscores"
+          end
           @table_name = table_name
-          @migration_method = migration_method
+
+          unless object_name.to_s.match valid_name_regex
+            raise InvalidNameError, "Invalid object name `#{object_name}`, must only be lowercase letters, numbers and underscores"
+          end
           @object_name = object_name
+
+          @migration_method = migration_method
           @code_comment = code_comment
           @content = content
         end

data/lib/dynamic_migrations/postgres/generator/function.rb

@@ -21,8 +21,16 @@ module DynamicMigrations
 
           fn_sql = function.definition.strip
 
+          # we only provide a table if the function has a single trigger and they
+          # are in the same schema, otherwise we can't reliable handle dependencies
+          # so the function will be created in the schema's migration
+          function_table = nil
+          if function.triggers.count == 1 && function.schema == function.triggers.first&.table&.schema
+            function_table = function.triggers.first&.table
+          end
+
           add_fragment schema: function.schema,
-            table: function.triggers.first&.table,
+            table: function_table,
             migration_method: :create_function,
             object: function,
             code_comment: code_comment,

data/lib/dynamic_migrations/postgres/generator/migration.rb

@@ -181,10 +181,10 @@ module DynamicMigrations
             :enums
 
           elsif all_fragments_for_method? [:enable_extension]
-            (@fragments.count > 1) ? :enable_extensions : :"create_#{fragments.first&.object_name}_extension"
+            (@fragments.count > 1) ? :enable_extensions : :"enable_#{fragments.first&.object_name}_extension"
 
           elsif all_fragments_for_method? [:disable_extension]
-            (@fragments.count > 1) ? :disable_extensions : :"drop_#{fragments.first&.object_name}_extension"
+            (@fragments.count > 1) ? :disable_extensions : :"disable_#{fragments.first&.object_name}_extension"
 
           elsif @fragments.first&.table_name
             :"changes_for_#{@fragments.first&.table_name}"

data/lib/dynamic_migrations/postgres/generator/trigger.rb

@@ -32,7 +32,15 @@ module DynamicMigrations
             end
 
             arguments = template_class.new(trigger, code_comment).fragment_arguments
-            add_fragment(**arguments)
+
+            # we only provide a dependent function if the function has more than one trigger
+            # or is in a different schema, otherwise it is added to the same migration as this
+            # trigger and we don't need to worry about dependencies
+            if trigger.function && (trigger.function.triggers.count > 1 || trigger.table.schema != trigger.function.schema)
+              add_fragment(dependent_function: trigger.function, **arguments)
+            else
+              add_fragment(**arguments)
+            end
 
           # no template, process this as a default trigger (takes all options)
           else
@@ -83,13 +91,21 @@ module DynamicMigrations
 
             options_syntax = options.map { |k, v| "#{k}: #{v}" }.join(", ")
 
+            # we only provide a dependent function if the function has more than one trigger
+            # or is in a different schema, otherwise it is added to the same migration as this
+            # trigger and we don't need to worry about dependencies
+            dependent_function = nil
+            # trigger.function will be nil if the trigger is not an function
+            if trigger.function && (trigger.function.triggers.count > 1 || trigger.table.schema != trigger.function.schema)
+              dependent_function = trigger.function
+            end
+
             add_fragment schema: trigger.table.schema,
               table: trigger.table,
               migration_method: :add_trigger,
               object: trigger,
               code_comment: code_comment,
-              dependent_function: trigger.function,
-              # also need dependent_enum
+              dependent_function: dependent_function,
               migration: <<~RUBY
                 #{method_name} :#{trigger.table.name}, #{options_syntax}
               RUBY

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

@@ -50,7 +50,7 @@ module DynamicMigrations
                 process_schema schema_name, differences[:configuration][:schemas][schema_name], differences[:database][:schemas][schema_name]
               end
 
-              # return the migrations organized by schema
+              # return the migrations (they are sorted via a dependency algorithm)
               @generator.migrations
             end
 

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

@@ -17,11 +17,14 @@ module DynamicMigrations
             attr_reader :name
             attr_reader :values
             attr_reader :description
+            attr_reader :columns
 
             # initialize a new object to represent a postgres enum
             def initialize source, schema, name, values, description: nil
               super source
 
+              @columns = []
+
               @values = []
 
               raise ExpectedSchemaError, schema unless schema.is_a? Schema
@@ -47,6 +50,15 @@ module DynamicMigrations
               !@description.nil?
             end
 
+            # for tracking all the columns which are associated with this enum
+            def add_column column
+              # this should never happen, but adding it just in case
+              unless column.source == source
+                raise "Internal error - column source `#{column.source}` does not match enum source `#{source}`"
+              end
+              @columns << column
+            end
+
             def differences_descriptions other_enum
               method_differences_descriptions other_enum, [
                 :values

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

@@ -48,7 +48,7 @@ module DynamicMigrations
               !@description.nil?
             end
 
-            # returns all the triggers which are associated with this function
+            # for tracking all the triggers which are associated with this function
             def add_trigger trigger
               # this should never happen, but adding it just in case
               unless trigger.source == source

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

@@ -54,6 +54,9 @@ module DynamicMigrations
                     raise UnexpectedEnumError, "enum `#{enum.full_name}` does not match this column's data type `#{@data_type}`"
                   end
                   @enum = enum
+                  # associate this column with the enum (so they are aware of each other)
+                  enum.add_column self
+
                 end
               end
 

data/lib/dynamic_migrations/version.rb

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

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

@@ -37,6 +37,9 @@ module DynamicMigrations
         def set_dependent_enum: (Symbol schema_name, Symbol enum_name) -> void
 
         def dependency_type: -> (nil | :function | :table | :enum)
+
+        class InvalidNameError < StandardError
+        end
       end
     end
   end

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

@@ -12,7 +12,7 @@ module DynamicMigrations
         def initialize: (untyped validation, untyped code_comment) -> void
 
         # abstract method (should actually be added to child classes)
-        def fragment_arguments: -> {schema: Postgres::Server::Database::Schema, table: Postgres::Server::Database::Schema::Table, migration_method: :add_validation, object: Postgres::Server::Database::Schema::Table::Validation, code_comment: String?, migration: String}
+        def fragment_arguments: -> {schema: Postgres::Server::Database::Schema, table: Postgres::Server::Database::Schema::Table, migration_method: Symbol, object: untyped, code_comment: String?, migration: String, dependent_function: Postgres::Server::Database::Schema::Function?}
 
         private
         def assert_not_deferred!: -> nil

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

@@ -11,9 +11,11 @@ module DynamicMigrations
             attr_reader name: Symbol
             attr_reader values: Array[Symbol]
             attr_reader description: String?
+            attr_reader columns: Array[Table::Column]
             def initialize: (database_or_configuration source, Schema schema, Symbol name, Array[Symbol] values, ?description: String?) -> void
             def full_name: -> Symbol
             def has_description?: -> bool
+            def add_column: (Schema::Table::Column column) -> void
             def differences_descriptions: (Enum other_enum) -> Array[String]
 
             class ExpectedSchemaError < StandardError

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynamic_migrations
 version: !ruby/object:Gem::Version
-  version: 3.6.9
+  version: 3.6.11
 platform: ruby
 authors:
 - Craig Ulliott