dynamic_migrations 3.6.7 → 3.6.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 595c87d8edaa9e8a2d3d8f3676e4383b1c5c3fd59223051d5541855e5117fa61
-  data.tar.gz: df3dfbff71ec825947dd7d8a89fd8a163291fbdf5ef58ffa95b15b057ff028d9
+  metadata.gz: eda59bc82b8accf553a95dabc66fdb1d59ea68750cb4318b2ee970d62d5b679f
+  data.tar.gz: faaf288de33ee1a6d419be2148a4cc7ec5f76bcd05260d5419b82af7fd256f51
 SHA512:
-  metadata.gz: 346ea3c2425e136487200f521b9669d1cd4ec3646f64113340b2bf487416b48226c68d4b32e5008dca9405f75dd7c50020edbe9caa33e4fcd2c676f61f09fbbf
-  data.tar.gz: bfc5f568840046e813f0c04b47a54b50be0c4053ae2f8dd94cd5f59c86c42505aeb902d4a8eb85004b5aa0f37c922d25cac793d87a20f467d32bc2730f51f3fc
+  metadata.gz: 85bb27898ab75f4815f7d08b6c7cdd27174f7bbb850fb55d21dad082627077e175d26b87fa64aa3651d98a914e1719a81d0d72955b7b763ecb5fe2ee5e93c9a1
+  data.tar.gz: a2bb9765ad753949c7f8db6640ca41046f7d1e946d0ed05211cce922d1f0c8b63dc4111183d1ab556c8f4b01278f3f83b2a39fd45c49dd50f718e32e8e617bbb

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [3.6.9](https://github.com/craigulliott/dynamic_migrations/compare/v3.6.8...v3.6.9) (2023-09-13)
+
+
+### Bug Fixes
+
+* enum name as a data type should include the schema name ([7658d14](https://github.com/craigulliott/dynamic_migrations/commit/7658d1482b7e50bcce11268d8121ee59ae194fa3))
+
+## [3.6.8](https://github.com/craigulliott/dynamic_migrations/compare/v3.6.7...v3.6.8) (2023-09-13)
+
+
+### Bug Fixes
+
+* dependency resolution is now aware of functions, enums and works across schemas. ([460de82](https://github.com/craigulliott/dynamic_migrations/commit/460de828be1826930bc1b185cf2a4c4e354d7dad))
+* enum columns now accept an enum object ([460de82](https://github.com/craigulliott/dynamic_migrations/commit/460de828be1826930bc1b185cf2a4c4e354d7dad))
+* trigger parameters is now an array of strings ([460de82](https://github.com/craigulliott/dynamic_migrations/commit/460de828be1826930bc1b185cf2a4c4e354d7dad))
+
 ## [3.6.7](https://github.com/craigulliott/dynamic_migrations/compare/v3.6.6...v3.6.7) (2023-09-13)
 
 

data/lib/dynamic_migrations/active_record/migrators/trigger.rb

@@ -16,7 +16,7 @@ module DynamicMigrations
         end
 
         # create a postgres trigger
-        def add_trigger table_name, name:, action_timing:, event_manipulation:, action_orientation:, function_schema_name:, function_name:, parameters: nil, action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, comment: nil
+        def add_trigger table_name, name:, action_timing:, event_manipulation:, action_orientation:, function_schema_name:, function_name:, parameters: [], action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, comment: nil
           unless [:insert, :delete, :update].include? event_manipulation
             raise UnexpectedEventManipulationError, event_manipulation
           end
@@ -47,13 +47,15 @@ module DynamicMigrations
           end
           temp_tables_sql = temp_tables.any? ? "REFERENCING #{temp_tables.join(" ")}" : ""
 
+          parameters_str = parameters.map { |p| quote(p) }.join(", ")
+
           # schema_name was not provided to this method, it comes from the migration class
           execute <<~SQL
             CREATE TRIGGER #{name}
               #{timing_sql} ON #{schema_name}.#{table_name} #{temp_tables_sql}
                 FOR EACH #{action_orientation}
                   #{condition_sql}
-                  EXECUTE FUNCTION #{function_schema_name}.#{function_name}(#{parameters});
+                  EXECUTE FUNCTION #{function_schema_name}.#{function_name}(#{parameters_str});
           SQL
 
           if comment.is_a? String
@@ -62,27 +64,27 @@ module DynamicMigrations
         end
 
         # wrappers for add_trigger which provide more friendly syntax
-        def before_insert table_name, name:, function_schema_name:, function_name:, parameters: nil, action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, comment: nil
+        def before_insert table_name, name:, function_schema_name:, function_name:, parameters: [], action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, comment: nil
           add_trigger table_name, name: name, action_timing: :before, event_manipulation: :insert, action_orientation: :row, function_schema_name: function_schema_name, function_name: function_name, parameters: parameters, action_condition: action_condition, action_reference_old_table: action_reference_old_table, action_reference_new_table: action_reference_new_table, comment: comment
         end
 
-        def before_update table_name, name:, function_schema_name:, function_name:, parameters: nil, action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, comment: nil
+        def before_update table_name, name:, function_schema_name:, function_name:, parameters: [], action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, comment: nil
           add_trigger table_name, name: name, action_timing: :before, event_manipulation: :update, action_orientation: :row, function_schema_name: function_schema_name, function_name: function_name, parameters: parameters, action_condition: action_condition, action_reference_old_table: action_reference_old_table, action_reference_new_table: action_reference_new_table, comment: comment
         end
 
-        def before_delete table_name, name:, function_schema_name:, function_name:, parameters: nil, action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, comment: nil
+        def before_delete table_name, name:, function_schema_name:, function_name:, parameters: [], action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, comment: nil
           add_trigger table_name, name: name, action_timing: :before, event_manipulation: :delete, action_orientation: :row, function_schema_name: function_schema_name, function_name: function_name, parameters: parameters, action_condition: action_condition, action_reference_old_table: action_reference_old_table, action_reference_new_table: action_reference_new_table, comment: comment
         end
 
-        def after_insert table_name, name:, function_schema_name:, function_name:, parameters: nil, action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, comment: nil
+        def after_insert table_name, name:, function_schema_name:, function_name:, parameters: [], action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, comment: nil
           add_trigger table_name, name: name, action_timing: :after, event_manipulation: :insert, action_orientation: :row, function_schema_name: function_schema_name, function_name: function_name, parameters: parameters, action_condition: action_condition, action_reference_old_table: action_reference_old_table, action_reference_new_table: action_reference_new_table, comment: comment
         end
 
-        def after_update table_name, name:, function_schema_name:, function_name:, parameters: nil, action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, comment: nil
+        def after_update table_name, name:, function_schema_name:, function_name:, parameters: [], action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, comment: nil
           add_trigger table_name, name: name, action_timing: :after, event_manipulation: :update, action_orientation: :row, function_schema_name: function_schema_name, function_name: function_name, parameters: parameters, action_condition: action_condition, action_reference_old_table: action_reference_old_table, action_reference_new_table: action_reference_new_table, comment: comment
         end
 
-        def after_delete table_name, name:, function_schema_name:, function_name:, parameters: nil, action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, comment: nil
+        def after_delete table_name, name:, function_schema_name:, function_name:, parameters: [], action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, comment: nil
           add_trigger table_name, name: name, action_timing: :after, event_manipulation: :delete, action_orientation: :row, function_schema_name: function_schema_name, function_name: function_name, parameters: parameters, action_condition: action_condition, action_reference_old_table: action_reference_old_table, action_reference_new_table: action_reference_new_table, comment: comment
         end
 

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

@@ -48,6 +48,8 @@ module DynamicMigrations
           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,
             object: column,
             code_comment: code_comment,
             migration: <<~RUBY
@@ -77,6 +79,8 @@ module DynamicMigrations
           add_fragment schema: column.table.schema,
             table: column.table,
             migration_method: :change_column,
+            # this will be nil if the column is not an enum
+            dependent_enum: column.enum,
             object: column,
             code_comment: code_comment,
             migration: <<~RUBY

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

@@ -8,6 +8,8 @@ module DynamicMigrations
         attr_reader :object_name
         attr_reader :dependency_schema_name
         attr_reader :dependency_table_name
+        attr_reader :dependency_function_name
+        attr_reader :dependency_enum_name
 
         def initialize schema_name, table_name, migration_method, object_name, code_comment, content
           @schema_name = schema_name
@@ -38,7 +40,7 @@ module DynamicMigrations
 
         # If a table dependency has been set, then returns a hash with the schema_name
         # and table_name, otherwise returns nil.
-        def dependency
+        def table_dependency
           if dependency_schema_name && dependency_table_name
             {
               schema_name: dependency_schema_name,
@@ -47,18 +49,77 @@ module DynamicMigrations
           end
         end
 
+        # If a function dependency has been set, then returns a hash with the schema_name
+        # and function_name, otherwise returns nil.
+        def function_dependency
+          if dependency_schema_name && dependency_function_name
+            {
+              schema_name: dependency_schema_name,
+              function_name: dependency_function_name
+            }
+          end
+        end
+
+        # If an enum dependency has been set, then returns a hash with the schema_name
+        # and enum_name, otherwise returns nil.
+        def enum_dependency
+          if dependency_schema_name && dependency_enum_name
+            {
+              schema_name: dependency_schema_name,
+              enum_name: dependency_enum_name
+            }
+          end
+        end
+
         # returns true if the fragment has a table dependency, and the dependency matches
         # the provided schema_name and table_name, otherwise returns false.
-        def is_dependent_on? schema_name, table_name
+        def is_dependent_on_table? schema_name, table_name
           dependency_schema_name && schema_name == dependency_schema_name && table_name == dependency_table_name || false
         end
 
-        # Set the table table dependency for this fragment. Takes a schema name and
+        # Set a table dependency for this fragment. Takes a schema name and
         # table name
         def set_dependent_table schema_name, table_name
+          if @dependency_schema_name
+            raise "Cannot set a table dependency for a fragment that already has a #{dependency_type} dependency"
+          end
           @dependency_schema_name = schema_name
           @dependency_table_name = table_name
         end
+
+        # Set a function dependency for this fragment. Takes a schema name and
+        # function name
+        def set_dependent_function schema_name, function_name
+          if @dependency_schema_name
+            raise "Cannot set a table dependency for a fragment that already has a #{dependency_type} dependency"
+          end
+          @dependency_schema_name = schema_name
+          @dependency_function_name = function_name
+        end
+
+        # Set an enum dependency for this fragment. Takes a schema name and
+        # enum name
+        def set_dependent_enum schema_name, enum_name
+          if @dependency_schema_name
+            raise "Cannot set a table dependency for a fragment that already has a #{dependency_type} dependency"
+          end
+          @dependency_schema_name = schema_name
+          @dependency_enum_name = enum_name
+        end
+
+        private
+
+        # returns a symbol representing the type of dependency this fragment has,
+        # or nil if there is no dependency
+        def dependency_type
+          if dependency_function_name
+            :function
+          elsif dependency_enum_name
+            :enum
+          elsif dependency_table_name
+            :table
+          end
+        end
       end
     end
   end

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

@@ -96,18 +96,34 @@ module DynamicMigrations
         # Return an array of table dependencies for this migration, this array comes from
         # combining any table dependencies from each fragment.
         # Will raise an error if no fragments have been provided.
-        def dependencies
+        def table_dependencies
           raise NoFragmentsError if fragments.empty?
-          @fragments.map(&:dependency).compact
+          @fragments.map(&:table_dependency).compact
+        end
+
+        # Return an array of function dependencies for this migration, this array comes from
+        # combining any function dependencies from each fragment.
+        # Will raise an error if no fragments have been provided.
+        def function_dependencies
+          raise NoFragmentsError if fragments.empty?
+          @fragments.map(&:function_dependency).compact
+        end
+
+        # Return an array of enum dependencies for this migration, this array comes from
+        # combining any enum dependencies from each fragment.
+        # Will raise an error if no fragments have been provided.
+        def enum_dependencies
+          raise NoFragmentsError if fragments.empty?
+          @fragments.map(&:enum_dependency).compact
         end
 
         # removes and returns any fragments which have a dependency on the table with the
         # provided schema_name and table_name, this is used for extracting fragments which
         # cause circular dependencies so they can be placed into their own migrations
         def extract_fragments_with_dependency schema_name, table_name
-          results = @fragments.filter { |f| f.is_dependent_on? schema_name, table_name }
+          results = @fragments.filter { |f| f.is_dependent_on_table? schema_name, table_name }
           # remove any of these from the internal array of fragments
-          @fragments.filter! { |f| !f.is_dependent_on?(schema_name, table_name) }
+          @fragments.filter! { |f| !f.is_dependent_on_table?(schema_name, table_name) }
           # return the results
           results
         end

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

@@ -13,19 +13,35 @@ module DynamicMigrations
             raise NoTableCommentError, "Refusing to generate create_table migration, no description was provided for `#{table.schema.name}`.`#{table.name}`"
           end
 
-          add_fragment schema: table.schema,
+          # We only add the columns that are not enums from within the add_table block, this
+          # is because columns that are enums require those enums to be created first and we
+          # want to create those as seperate fragments which have the correct dependency metadata
+          columns_without_enums = table.columns.reject(&:enum)
+          columns_with_enums = table.columns.select(&:enum)
+
+          fragments = []
+          fragments << add_fragment(schema: table.schema,
             table: table,
             migration_method: :create_table,
             object: table,
             code_comment: code_comment,
             migration: <<~RUBY
               table_comment = <<~COMMENT
-                #{indent table.description}
+                #{indent table.description || ""}
               COMMENT
               create_table :#{table.name}, #{table_options table} do |t|
-                #{indent table_columns(table.columns)}
+                #{indent table_columns(columns_without_enums)}
               end
             RUBY
+          )
+
+          # seperately add the columns that are enums (so dependency managment works correctly)
+          fragments += columns_with_enums.map do |column|
+            add_column column
+          end
+
+          # return all the fragments (we do this with all generators so e can more easily test the methods)
+          fragments
         end
 
         def drop_table table, code_comment = nil

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

@@ -61,8 +61,8 @@ module DynamicMigrations
               options[:action_condition] = "\"#{trigger.action_condition}\""
             end
 
-            unless trigger.parameters.nil?
-              options[:parameters] = "\"#{trigger.parameters}\""
+            unless trigger.parameters.empty?
+              options[:parameters] = "[\"#{trigger.parameters.join('", "')}\"]"
             end
 
             unless trigger.action_reference_old_table.nil?
@@ -88,6 +88,8 @@ module DynamicMigrations
               migration_method: :add_trigger,
               object: trigger,
               code_comment: code_comment,
+              dependent_function: trigger.function,
+              # also need dependent_enum
               migration: <<~RUBY
                 #{method_name} :#{trigger.table.name}, #{options_syntax}
               RUBY

data/lib/dynamic_migrations/postgres/generator.rb

@@ -41,9 +41,10 @@ module DynamicMigrations
         # a hash to hold the generated migrations orgnized by their schema and table
         # this makes it easier and faster to work with them within this method
         database_migrations = {}
-        # the database_specific_migration is for migrations which dont belong
-        # within a specific schema
-        database_specific_migration = DatabaseMigration.new
+        # the database_specific_migrations are for migrations which dont belong
+        # within a specific schema, they are important enough that we have a
+        # dedicated migration for each one
+        database_specific_migrations = []
 
         # Process each fragment, and organize them into migrations. We create a shared
         # Migration for each table, and a single shared migration for any schema migrations
@@ -75,7 +76,9 @@ module DynamicMigrations
           # migrations with no schema or table, are added to a database
           # migration (these are really just creating/dropping schemas and extensions)
           elsif schema_name.nil? && table_name.nil?
-            database_specific_migration.add_fragment fragment
+            database_specific_migration = DatabaseMigration.new
+            database_specific_migration.add_fragment(fragment)
+            database_specific_migrations << database_specific_migration
 
           else
             raise UnprocessableFragmentError
@@ -94,7 +97,7 @@ module DynamicMigrations
           # never have dependencies
           schema_migrations[:table_migrations].values.each do |table_migration|
             # recursively test each table migration for circular dependencies
-            table_migration.dependencies.each do |dependency|
+            table_migration.table_dependencies.each do |dependency|
               if circular_dependency? table_migration.schema_name, table_migration.table_name, dependency, all_table_migrations
                 # remove the fragment which is causing the circular dependency
                 removed_fragments = table_migration.extract_fragments_with_dependency dependency[:schema_name], dependency[:table_name]
@@ -132,10 +135,10 @@ module DynamicMigrations
             # if there is a schema migration, then it should always come first
             # so make the table migration depend on it
             deps << schema_migrations[:schema_migration] if schema_migrations[:schema_migration]
-            # if the table migration has any dependencies, then add them
-            table_migration.dependencies.each do |dependency|
+            # if the table migration has any dependencies on other tables, then add them
+            table_migration.table_dependencies.each do |dependency|
               # find the migration which matches the dependency
-              dependent_migration = schema_migrations[:table_migrations][dependency[:table_name]]
+              dependent_migration = database_migrations[dependency[:schema_name]] && database_migrations[dependency[:schema_name]][:table_migrations][dependency[:table_name]]
               # if the table migration is not found, then it's safe to assume the table was created
               # by an earlier set of migrations
               unless dependent_migration.nil?
@@ -143,6 +146,14 @@ module DynamicMigrations
                 deps << dependent_migration
               end
             end
+            # if the table migration has any dependencies on functions or enums, then add them
+            (table_migration.function_dependencies + table_migration.enum_dependencies).each do |dependency|
+              # functions are always added to a schema specific migration, if it does not exist then
+              # we can assume the function was added in a previous set of migrations
+              if (dependencies_schema_migration = database_migrations[dependency[:schema_name]] && database_migrations[dependency[:schema_name]][:schema_migration])
+                deps << dependencies_schema_migration
+              end
+            end
           end
           # add each additional migration, and its dependencies
           schema_migrations[:additional_migrations].each do |additional_migration|
@@ -157,16 +168,24 @@ module DynamicMigrations
             unless table_migration.nil?
               deps << table_migration
             end
-            # if the additional_migration has any dependencies, then add them too
-            additional_migration.dependencies.each do |dependency|
+            # if the additional_migration has any dependencies on other tables, then add them too
+            additional_migration.table_dependencies.each do |dependency|
               # find the table migration which matches the dependency
-              dependent_migration = schema_migrations[:table_migrations][dependency[:table_name]]
+              dependent_migration = database_migrations[dependency[:schema_name]] && database_migrations[dependency[:schema_name]][:table_migrations][dependency[:table_name]]
               # if the table migration is not found, then it's safe to assume the table was created
               # by an earlier set of migrations
               unless dependent_migration.nil?
                 deps << dependent_migration
               end
             end
+            # if the table migration has any dependencies on functions or enums, then add them
+            (table_migration.function_dependencies + table_migration.enum_dependencies).each do |dependency|
+              # functions are always added to a schema specific migration, if it does not exist then
+              # we can assume the function was added in a previous set of migrations
+              if (dependencies_schema_migration = database_migrations[dependency[:schema_name]] && database_migrations[dependency[:schema_name]][:schema_migration])
+                deps << dependencies_schema_migration
+              end
+            end
           end
         end
 
@@ -174,9 +193,9 @@ module DynamicMigrations
         # the order is determined by their dependencies
         final_migrations = dependency_sorter.tsort
 
-        # if any database only migrations exist, then add them to the from of the array here
-        if database_specific_migration.fragments.any?
-          final_migrations.unshift database_specific_migration
+        # if any database only migrations exist, then add them to the front of the array here
+        if database_specific_migrations.any?
+          final_migrations = database_specific_migrations + final_migrations
         end
 
         # return the final migrations in the expected format
@@ -200,7 +219,7 @@ module DynamicMigrations
           dependent_migrations = all_table_migrations.filter { |m| m.schema_name == dependency[:schema_name] && m.table_name == dependency[:table_name] }
           # recursively call this method for all the dependencies for these migrations
           dependent_migrations.each do |dependent_migration|
-            dependent_migration.dependencies.each do |next_dependency|
+            dependent_migration.table_dependencies.each do |next_dependency|
               # if we find a dependency which matches the original schema and table name then we have a circular dependency
               if circular_dependency?(schema_name, table_name, next_dependency, all_table_migrations)
                 return true
@@ -221,15 +240,26 @@ module DynamicMigrations
         @dep[node].each(&block)
       end
 
-      def add_fragment migration_method:, object:, migration:, schema: nil, table: nil, code_comment: nil, dependent_table: nil
+      # This method is called from within the various modules which are included to this class.
+      # It locally stores all the fragments which will later be organized into different migrations.
+      def add_fragment migration_method:, object:, migration:, schema: nil, table: nil, code_comment: nil, dependent_table: nil, dependent_function: nil, dependent_enum: nil
         # Remove any empty lines and whitespace from the beginning or the end of the migration and then
         # strip any empty lines witin the migration (remove the whitespace from them, not delete them).
         final_migration = strip_empty_lines(migration).strip
         fragment = Fragment.new(schema&.name, table&.name, migration_method, object.name, code_comment, final_migration)
+
         if dependent_table
           fragment.set_dependent_table dependent_table.schema.name, dependent_table.name
         end
 
+        if dependent_function
+          fragment.set_dependent_function dependent_function.schema.name, dependent_function.name
+        end
+
+        if dependent_enum
+          fragment.set_dependent_enum dependent_enum.schema.name, dependent_enum.name
+        end
+
         # add this fragment to the list
         @fragments << fragment
 

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

@@ -15,8 +15,24 @@ module DynamicMigrations
           # tables and columns
           def recursively_load_database_structure
             validations = fetch_validations
-            fetch_structure.each do |schema_name, schema_definition|
-              schema = add_loaded_schema schema_name
+
+            structure = fetch_structure
+
+            # add any schemas
+            structure.each do |schema_name, schema_definition|
+              add_loaded_schema schema_name
+            end
+
+            # add any enums (required for adding columns below)
+            fetch_enums.each do |schema_name, schema_definition|
+              schema_definition.each do |enum_name, enum_definition|
+                loaded_schema(schema_name).add_enum enum_name, enum_definition[:values], description: enum_definition[:description]
+              end
+            end
+
+            structure.each do |schema_name, schema_definition|
+              # the schema was already added above
+              schema = loaded_schema schema_name
               schema_validations = validations[schema_name]
 
               schema_definition[:tables].each do |table_name, table_definition|
@@ -25,11 +41,19 @@ module DynamicMigrations
 
                 # add each table column
                 table_definition[:columns].each do |column_name, column_definition|
+                  if column_definition[:is_enum]
+                    enum_schema, enum_name = column_definition[:data_type].to_s.split(".")
+                    enum = table.schema.database.loaded_schema(enum_schema.to_sym).enum(enum_name.to_sym)
+                  else
+                    enum = nil
+                  end
+
                   table.add_column column_name, column_definition[:data_type],
                     null: column_definition[:null],
                     default: column_definition[:default],
                     description: column_definition[:description],
-                    interval_type: column_definition[:interval_type]
+                    interval_type: column_definition[:interval_type],
+                    enum: enum
                 end
 
                 # add any validations
@@ -44,13 +68,6 @@ module DynamicMigrations
               add_loaded_extension extension_name
             end
 
-            # add any enums
-            fetch_enums.each do |schema_name, schema_definition|
-              schema_definition.each do |enum_name, enum_definition|
-                loaded_schema(schema_name).add_enum enum_name, enum_definition[:values], description: enum_definition[:description]
-              end
-            end
-
             # now that the structure has been loaded, we can add keys (foreign
             # keys need to be added last, because they can depend on tables from
             # different schemas)

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

@@ -52,6 +52,10 @@ module DynamicMigrations
                 :values
               ]
             end
+
+            def full_name
+              :"#{schema.name}.#{name}"
+            end
           end
         end
       end

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

@@ -11,6 +11,9 @@ module DynamicMigrations
               class ExpectedTableError < StandardError
               end
 
+              class UnexpectedEnumError < StandardError
+              end
+
               attr_reader :table
               attr_reader :name
               attr_reader :data_type
@@ -18,9 +21,10 @@ module DynamicMigrations
               attr_reader :null
               attr_reader :default
               attr_reader :interval_type
+              attr_reader :enum
 
               # initialize a new object to represent a column in a postgres table
-              def initialize source, table, name, data_type, null: true, default: nil, description: nil, interval_type: nil
+              def initialize source, table, name, data_type, null: true, default: nil, description: nil, interval_type: nil, enum: nil
                 super source
                 raise ExpectedTableError, table unless table.is_a? Table
                 @table = table
@@ -28,7 +32,6 @@ module DynamicMigrations
                 raise ExpectedSymbolError, name unless name.is_a? Symbol
                 @name = name
 
-                @data_type = data_type
                 raise ExpectedSymbolError, data_type unless data_type.is_a? Symbol
                 @data_type = data_type
 
@@ -42,6 +45,16 @@ module DynamicMigrations
                 end
 
                 @interval_type = interval_type
+
+                if enum
+                  unless enum.is_a? Enum
+                    raise UnexpectedEnumError, "#{enum} is not a valid enum"
+                  end
+                  unless @data_type == enum.full_name || @data_type == "#{enum.full_name}[]"
+                    raise UnexpectedEnumError, "enum `#{enum.full_name}` does not match this column's data type `#{@data_type}`"
+                  end
+                  @enum = enum
+                end
               end
 
               # return true if this column has a description, otherwise false

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

@@ -92,11 +92,10 @@ module DynamicMigrations
                 end
                 @action_condition = action_condition&.strip
 
-                is_comma_sperated_list_of_strings = (parameters.is_a?(String) && parameters[/\A'[\w\d_ -]+'(, ?'[\w\d_ -]+')*\z/])
-                unless parameters.nil? || is_comma_sperated_list_of_strings
-                  raise UnexpectedParametersError, "unexpected parameters `#{parameters}`, currently only a comma seeparated list of strings is supported"
+                unless parameters.is_a?(Array) && parameters.all? { |p| p.is_a? String }
+                  raise UnexpectedParametersError, "unexpected parameters `#{parameters}`, currently only an array of strings is supported"
                 end
-                @parameters = parameters&.strip
+                @parameters = parameters
 
                 unless [:row, :statement].include? action_orientation
                   raise UnexpectedActionOrientationError, action_orientation
@@ -167,11 +166,12 @@ module DynamicMigrations
                 @action_condition = new_action_condition&.strip
               end
 
-              def parameters= new_parameters
-                unless new_parameters.nil? || new_parameters.is_a?(String)
-                  raise ExpectedStringError, new_parameters
+              def add_parameter new_parameter
+                unless new_parameter.is_a? String
+                  raise UnexpectedParametersError, "unexpected parameter `#{new_parameter}`, can only add strings to the list of parameters"
                 end
-                @parameters = new_parameters&.strip
+
+                @parameters << new_parameter
               end
 
               # return true if this has a description, otherwise false

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

@@ -33,6 +33,13 @@ module DynamicMigrations
                       AND attnum = columns.ordinal_position
                   )
                   END AS data_type,
+                  -- is this an emum
+                  EXISTS (
+                    SELECT 1
+                    FROM pg_type typ
+                      INNER JOIN pg_enum enu ON typ.oid = enu.enumtypid
+                    WHERE typ.typname = columns.udt_name
+                  ) AS is_enum,
                   -- If data_type identifies an interval type, this column contains
                   -- the specification which fields the intervals include for this
                   -- column, e.g., YEAR TO MONTH, DAY TO SECOND, etc. If no field
@@ -93,6 +100,7 @@ module DynamicMigrations
 
                   column[:data_type] = row["data_type"].to_sym
                   column[:null] = row["is_nullable"] == "YES"
+                  column[:is_enum] = row["is_enum"] == "TRUE"
                   column[:default] = row["column_default"]
                   column[:description] = row["column_description"]
                   column[:interval_type] = row["interval_type"].nil? ? nil : row["interval_type"].to_sym
@@ -102,26 +110,6 @@ module DynamicMigrations
             schemas
           end
 
-          # recursively process the database and build all the schemas,
-          # tables and columns
-          def recursively_load_database_structure
-            fetch_structure.each do |schema_name, schema_definition|
-              schema = add_loaded_schema schema_name
-
-              schema_definition[:tables].each do |table_name, table_definition|
-                table = schema.add_table table_name, table_definition[:description]
-
-                table_definition[:columns].each do |column_name, column_definition|
-                  table.add_column column_name, column_definition[:data_type],
-                    null: column_definition[:null],
-                    default: column_definition[:default],
-                    description: column_definition[:description],
-                    interval_type: column_definition[:interval_type]
-                end
-              end
-            end
-          end
-
           # returns a list of the schema names in this database
           def fetch_schema_names
             rows = connection.exec(<<~SQL)

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

@@ -38,7 +38,7 @@ module DynamicMigrations
                 SUBSTRING(
                   pg_get_triggerdef(t.oid)
                   FROM
-                  '\\(([\d\w_''-]+)\\)$'
+                  '\\(([^(]+)\\)$'
                 ) AS parameters,
                 p_n.nspname AS function_schema,
                 p.proname AS function_name,
@@ -96,6 +96,10 @@ module DynamicMigrations
                 raise EventTriggerProcedureSchemaMismatchError, "Expected trigger, procedure and event_object to be in the same schema for trigger '#{trigger_name}'"
               end
 
+              # turn the parameters into an array of strings
+              # the format looks a little like this: "'hi', 'there', 'hmmm'"
+              parameters = row["parameters"]&.delete("'")&.split(",")&.map(&:strip) || []
+
               table[trigger_name] = {
                 trigger_schema: row["trigger_schema"].to_sym,
                 event_manipulation: row["event_manipulation"].to_sym,
@@ -104,7 +108,7 @@ module DynamicMigrations
                 function_schema: row["function_schema"].to_sym,
                 function_name: row["function_name"].to_sym,
                 function_definition: row["function_definition"],
-                parameters: row["parameters"],
+                parameters: parameters,
                 action_orientation: row["action_orientation"].to_sym,
                 action_timing: row["action_timing"].to_sym,
                 # `action_reference_old_table` and `action_reference_new_table` can be null

data/lib/dynamic_migrations/version.rb

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

data/sig/dynamic_migrations/active_record/migrators/trigger.rbs

@@ -3,17 +3,17 @@ module DynamicMigrations
   module ActiveRecord
     module Migrators
       module Trigger
-        def add_trigger: (Symbol table_name, name: Symbol, action_timing: Symbol, event_manipulation: Symbol, action_orientation: Symbol, function_schema_name: Symbol, function_name: Symbol, ?parameters: String?, ?action_condition: String?, ?action_reference_old_table: Symbol?, ?action_reference_new_table: Symbol?, ?comment: String?) -> void
+        def add_trigger: (Symbol table_name, name: Symbol, action_timing: Symbol, event_manipulation: Symbol, action_orientation: Symbol, function_schema_name: Symbol, function_name: Symbol, ?parameters: Array[String], ?action_condition: String?, ?action_reference_old_table: Symbol?, ?action_reference_new_table: Symbol?, ?comment: String?) -> void
         def remove_trigger: (Symbol table_name, Symbol trigger_name) -> void
         def set_trigger_comment: (Symbol table_name, Symbol trigger_name, String comment) -> void
         def remove_trigger_comment: (Symbol table_name, Symbol trigger_name) -> void
 
-        def before_insert: (Symbol table_name, name: Symbol, function_schema_name: Symbol, function_name: Symbol, ?parameters: String?, ?action_condition: String?, ?action_reference_old_table: Symbol?, ?action_reference_new_table: Symbol?, ?comment: String?) -> void
-        def before_update: (Symbol table_name, name: Symbol, function_schema_name: Symbol, function_name: Symbol, ?parameters: String?, ?action_condition: String?, ?action_reference_old_table: Symbol?, ?action_reference_new_table: Symbol?, ?comment: String?) -> void
-        def before_delete: (Symbol table_name, name: Symbol, function_schema_name: Symbol, function_name: Symbol, ?parameters: String?, ?action_condition: String?, ?action_reference_old_table: Symbol?, ?action_reference_new_table: Symbol?, ?comment: String?) -> void
-        def after_insert: (Symbol table_name, name: Symbol, function_schema_name: Symbol, function_name: Symbol, ?parameters: String?, ?action_condition: String?, ?action_reference_old_table: Symbol?, ?action_reference_new_table: Symbol?, ?comment: String?) -> void
-        def after_update: (Symbol table_name, name: Symbol, function_schema_name: Symbol, function_name: Symbol, ?parameters: String?, ?action_condition: String?, ?action_reference_old_table: Symbol?, ?action_reference_new_table: Symbol?, ?comment: String?) -> void
-        def after_delete: (Symbol table_name, name: Symbol, function_schema_name: Symbol, function_name: Symbol, ?parameters: String?, ?action_condition: String?, ?action_reference_old_table: Symbol?, ?action_reference_new_table: Symbol?, ?comment: String?) -> void
+        def before_insert: (Symbol table_name, name: Symbol, function_schema_name: Symbol, function_name: Symbol, ?parameters: Array[String], ?action_condition: String?, ?action_reference_old_table: Symbol?, ?action_reference_new_table: Symbol?, ?comment: String?) -> void
+        def before_update: (Symbol table_name, name: Symbol, function_schema_name: Symbol, function_name: Symbol, ?parameters: Array[String], ?action_condition: String?, ?action_reference_old_table: Symbol?, ?action_reference_new_table: Symbol?, ?comment: String?) -> void
+        def before_delete: (Symbol table_name, name: Symbol, function_schema_name: Symbol, function_name: Symbol, ?parameters: Array[String], ?action_condition: String?, ?action_reference_old_table: Symbol?, ?action_reference_new_table: Symbol?, ?comment: String?) -> void
+        def after_insert: (Symbol table_name, name: Symbol, function_schema_name: Symbol, function_name: Symbol, ?parameters: Array[String], ?action_condition: String?, ?action_reference_old_table: Symbol?, ?action_reference_new_table: Symbol?, ?comment: String?) -> void
+        def after_update: (Symbol table_name, name: Symbol, function_schema_name: Symbol, function_name: Symbol, ?parameters: Array[String], ?action_condition: String?, ?action_reference_old_table: Symbol?, ?action_reference_new_table: Symbol?, ?comment: String?) -> void
+        def after_delete: (Symbol table_name, name: Symbol, function_schema_name: Symbol, function_name: Symbol, ?parameters: Array[String], ?action_condition: String?, ?action_reference_old_table: Symbol?, ?action_reference_new_table: Symbol?, ?comment: String?) -> void
 
         # stubbing these out, as they are available on the module which includes this module
         def execute: (String sql) -> void

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

@@ -12,7 +12,7 @@ module DynamicMigrations
         def remove_column_comment: (Postgres::Server::Database::Schema::Table::Column column, ?String? code_comment) -> Fragment
 
         # 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?) -> untyped
+        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/enum.rbs

@@ -11,7 +11,7 @@ module DynamicMigrations
         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
         # these come from the generator object (which this module is included into)
-        def add_fragment: (schema: Server::Database::Schema, migration_method: Symbol, object: Server::Database::Schema::Enum enum, migration: String, ?table: nil | Server::Database::Schema::Table, ?code_comment: String?, ?dependent_table: nil | Server::Database::Schema::Table) -> Fragment
+        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
 
         class UnremovableEnumValuesError < StandardError

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

@@ -9,7 +9,7 @@ module DynamicMigrations
         def disable_extension: (Symbol extension_name, ?String? code_comment) -> Fragment
 
         # 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?) -> untyped
+        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
       end
     end
   end

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

@@ -12,7 +12,7 @@ module DynamicMigrations
         def remove_foreign_key_constraint_comment: (Postgres::Server::Database::Schema::Table::ForeignKeyConstraint foreign_key_constraint, ?String? code_comment) -> Fragment
 
         # 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?) -> untyped
+        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
         end

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

@@ -19,13 +19,24 @@ module DynamicMigrations
         # dependecy on a table is optional
         attr_reader dependency_schema_name: Symbol?
         attr_reader dependency_table_name: Symbol?
+        attr_reader dependency_function_name: Symbol?
+        attr_reader dependency_enum_name: Symbol?
 
         def initialize: (Symbol? schema_name, Symbol? table_name, Symbol migration_method, Symbol object_name, String? code_comment, String content) -> void
         def to_s: -> String
         def has_code_comment?: -> bool
-        def dependency: -> ({schema_name: Symbol, table_name: Symbol} | nil)
-        def is_dependent_on?: (Symbol schema_name, Symbol table_name) -> bool
+
+        def table_dependency: -> ({schema_name: Symbol, table_name: Symbol} | nil)
+        def function_dependency: -> ({schema_name: Symbol, function_name: Symbol} | nil)
+        def enum_dependency: -> ({schema_name: Symbol, enum_name: Symbol} | nil)
+
+        def is_dependent_on_table?: (Symbol schema_name, Symbol table_name) -> bool
+
         def set_dependent_table: (Symbol schema_name, Symbol table_name) -> void
+        def set_dependent_function: (Symbol schema_name, Symbol function_name) -> void
+        def set_dependent_enum: (Symbol schema_name, Symbol enum_name) -> void
+
+        def dependency_type: -> (nil | :function | :table | :enum)
       end
     end
   end

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

@@ -12,7 +12,7 @@ module DynamicMigrations
         def remove_function_comment: (Postgres::Server::Database::Schema::Function function, ?String? code_comment) -> Fragment
 
         # 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?) -> untyped
+        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
       end

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

@@ -12,7 +12,7 @@ module DynamicMigrations
         def remove_index_comment: (Postgres::Server::Database::Schema::Table::Index index, ?String? code_comment) -> Fragment
 
         # 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?) -> untyped
+        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
         end

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

@@ -18,8 +18,12 @@ module DynamicMigrations
         attr_reader fragments: Array[Fragment]
         def initialize: (?Symbol? schema_name, ?Symbol? table_name) -> void
         def add_fragment: (Fragment fragment) -> void
-        def dependencies: -> Array[{schema_name: Symbol, table_name: Symbol}]
-        def extract_fragments_with_dependency: (Symbol schema_name, Symbol table_name) -> Array[Fragment]
+        def table_dependencies: -> Array[{schema_name: Symbol, table_name: Symbol}]
+        def enum_dependencies: -> Array[{schema_name: Symbol, enum_name: Symbol}]
+        def function_dependencies: -> Array[{schema_name: Symbol, function_name: Symbol}]
+
+        def extract_fragments_with_table_dependency: (Symbol schema_name, Symbol table_name) -> Array[Fragment]
+
         def content: -> String
         def name: -> (:changes | :schema_functions | Symbol)
 

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

@@ -10,7 +10,7 @@ module DynamicMigrations
         def recreate_primary_key: (Postgres::Server::Database::Schema::Table::PrimaryKey original_primary_key, Postgres::Server::Database::Schema::Table::PrimaryKey updated_primary_key) -> Array[Fragment]
 
         # 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?) -> untyped
+        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/schema.rbs

@@ -9,7 +9,7 @@ module DynamicMigrations
         def drop_schema: (Postgres::Server::Database::Schema schema, ?String? code_comment) -> Fragment
 
         # 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?) -> untyped
+        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
 
       end
     end

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

@@ -5,13 +5,14 @@ module DynamicMigrations
   module Postgres
     class Generator
       module Table
-        def create_table: (Postgres::Server::Database::Schema::Table table, ?String? code_comment) -> Fragment
+        def create_table: (Postgres::Server::Database::Schema::Table table, ?String? code_comment) -> Array[Fragment]
         def drop_table: (Postgres::Server::Database::Schema::Table table, ?String? code_comment) -> Fragment
         def set_table_comment: (Postgres::Server::Database::Schema::Table table, ?String? code_comment) -> Fragment
         def remove_table_comment: (Postgres::Server::Database::Schema::Table table, ?String? code_comment) -> Fragment
 
         # 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?) -> untyped
+        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 add_column: (Postgres::Server::Database::Schema::Table::Column column, ?String? code_comment) -> Fragment
 
         def indent: (String migration, ?Integer levels) -> String
 

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

@@ -16,7 +16,7 @@ module DynamicMigrations
         def remove_trigger_comment: (Postgres::Server::Database::Schema::Table::Trigger trigger, ?String? code_comment) -> Fragment
 
         # 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?) -> untyped
+        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/unique_constraint.rbs

@@ -12,7 +12,7 @@ module DynamicMigrations
         def remove_unique_constraint_comment: (Postgres::Server::Database::Schema::Table::UniqueConstraint unique_constraint, ?String? code_comment) -> Fragment
 
         # 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?) -> untyped
+        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
         end

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

@@ -18,7 +18,7 @@ module DynamicMigrations
         def remove_validation_comment: (Postgres::Server::Database::Schema::Table::Validation validation, ?String? code_comment) -> Fragment
 
         # 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?) -> untyped
+        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.rbs

@@ -29,7 +29,7 @@ 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 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: nil | Server::Database::Schema::Table) -> Fragment
+      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 strip_empty_lines: (String migration) -> String
       def tsort_each_node: -> Enumerator[untyped, untyped]

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

@@ -12,6 +12,7 @@ module DynamicMigrations
             attr_reader values: Array[Symbol]
             attr_reader description: String?
             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 differences_descriptions: (Enum other_enum) -> Array[String]
 

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

@@ -13,12 +13,17 @@ module DynamicMigrations
               attr_reader data_type: Symbol
               attr_reader array: bool
               attr_reader interval_type: Symbol?
-              def initialize: (database_or_configuration source, Table table, Symbol name, Symbol data_type, ?null: bool, ?default: untyped, ?description: String?, ?interval_type: Symbol?) -> void
+              attr_reader enum: Enum?
+
+              def initialize: (database_or_configuration source, Table table, Symbol name, Symbol data_type, ?null: bool, ?default: untyped, ?description: String?, ?interval_type: Symbol?, ?enum: Enum?) -> void
               def has_description?: -> bool
               def array?: -> bool
 
               class ExpectedTableError < StandardError
               end
+
+              class UnexpectedEnumError < StandardError
+              end
             end
           end
         end

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

@@ -14,7 +14,7 @@ module DynamicMigrations
               attr_reader event_manipulation: Symbol
               attr_reader action_timing: Symbol
               attr_reader action_condition: String?
-              attr_reader parameters: String?
+              attr_reader parameters: Array[String]
               attr_reader action_orientation: Symbol
               attr_reader function: Function
               attr_reader action_reference_old_table: Symbol?
@@ -22,7 +22,7 @@ module DynamicMigrations
               attr_reader description: String?
               attr_reader template: Symbol?
 
-              def initialize: (database_or_configuration source, Table table, Symbol name, action_timing: Symbol, event_manipulation: Symbol, parameters: String?, action_orientation: Symbol, function: Function, ?action_order: Integer?, ?action_condition: String?, ?action_reference_old_table: Symbol?, ?action_reference_new_table: Symbol?, ?description: String?, ?template: Symbol?) -> void
+              def initialize: (database_or_configuration source, Table table, Symbol name, action_timing: Symbol, event_manipulation: Symbol, parameters: Array[String], action_orientation: Symbol, function: Function, ?action_order: Integer?, ?action_condition: String?, ?action_reference_old_table: Symbol?, ?action_reference_new_table: Symbol?, ?description: String?, ?template: Symbol?) -> void
               def action_order: -> Integer
               def has_description?: -> false
               def differences_descriptions: (Trigger other_trigger) -> Array[String]

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

@@ -14,7 +14,7 @@ module DynamicMigrations
               def has_trigger?: (untyped name) -> bool
               def triggers: -> Array[Trigger]
               def triggers_hash: -> Hash[Symbol, Trigger]
-              def add_trigger: (Symbol name, action_timing: Symbol, event_manipulation: Symbol, parameters: String, action_orientation: Symbol, function: Function, ?action_order: Integer?, ?action_condition: String?, ?action_reference_old_table: Symbol?, ?action_reference_new_table: Symbol?, ?description: String?, ?template: Symbol?) -> Trigger
+              def add_trigger: (Symbol name, action_timing: Symbol, event_manipulation: Symbol, parameters: Array[String], action_orientation: Symbol, function: Function, ?action_order: Integer?, ?action_condition: String?, ?action_reference_old_table: Symbol?, ?action_reference_new_table: Symbol?, ?description: String?, ?template: Symbol?) -> Trigger
 
               # these come from the table object (which this module is included into)
               def source: -> database_or_configuration

metadata

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