dynamic_migrations 3.5.2 → 3.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d618a9b98ed9b0f378f6e4342c57e6df554df34c600572a6aa55db61dbb32fad
-  data.tar.gz: a90d7e5fa28aa0f4dbc2d42a7545ed6207bc800baba766dd23c9bc0e73cfd0c6
+  metadata.gz: a25d76d54d7129a77f16574c4b6a84cf82ca6105afe4279ba868b34b97fa4814
+  data.tar.gz: b60f87c21dd0e53aed9853d4eaece239cab1d2524ba9c500e3dc364eda1d40dd
 SHA512:
-  metadata.gz: 33c0b803f4a4a01aff67b258ade285c2acf0420c0c611b918cf24405f5081497050bdcb726532b01fe4d832a086d15a4b37dc5a03c445772e7b6e863edd795c6
-  data.tar.gz: 7a00457cdb78107f62c43bd74647513817c1fbb0e4dbbc92bdc458aefc02030980fd074d03f2ada4399dd442f4152098024a492839fe98ccba2ad16ad4508356
+  metadata.gz: ef75931965eb2dd877bd22a82b4ad6532df5ab4e9e5ff24cc160f9fcc81c3c1db7eca2698b30da99a29000c7c67cf4efd1f5d7eca8ff28fbcc31631a0d43225b
+  data.tar.gz: 4d4218e2872b79b68b79517696403f3aa15c1b87ac2c9b8afd47e1ebb4a1fcb1b3e3efbd0f0db61ad788e8c80472b2eef1d389e08dbf0153414dcfecab5b976c

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [3.6.0](https://github.com/craigulliott/dynamic_migrations/compare/v3.5.3...v3.6.0) (2023-09-13)
+
+
+### Features
+
+* plugin architecture for validation and trigger templates (allows for creating cleaner migrations with custom methods) ([f4e9d5e](https://github.com/craigulliott/dynamic_migrations/commit/f4e9d5eae803196e727a5b4d7314e773cd90ba00))
+
+
+### Bug Fixes
+
+* fixed badly generated trigger migration ([f4e9d5e](https://github.com/craigulliott/dynamic_migrations/commit/f4e9d5eae803196e727a5b4d7314e773cd90ba00))
+
+## [3.5.3](https://github.com/craigulliott/dynamic_migrations/compare/v3.5.2...v3.5.3) (2023-09-11)
+
+
+### Bug Fixes
+
+* accepting nil or false for existence check when calculating differences (because if the schema doesn't exist we wont have table objects to test against) ([de63879](https://github.com/craigulliott/dynamic_migrations/commit/de638791035a0a1ad4658149777aa6e2ac7dc2ed))
+
 ## [3.5.2](https://github.com/craigulliott/dynamic_migrations/compare/v3.5.1...v3.5.2) (2023-09-11)
 
 

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

@@ -62,28 +62,28 @@ module DynamicMigrations
         end
 
         # wrappers for add_trigger which provide more friendly syntax
-        def before_insert table_name, name:, function_schema_name:, function_name:, 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, action_condition: action_condition, action_reference_old_table: action_reference_old_table, action_reference_new_table: action_reference_new_table, comment: comment
+        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
+          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:, 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, action_condition: action_condition, action_reference_old_table: action_reference_old_table, action_reference_new_table: action_reference_new_table, comment: comment
+        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
+          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:, 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, action_condition: action_condition, action_reference_old_table: action_reference_old_table, action_reference_new_table: action_reference_new_table, comment: comment
+        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
+          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:, 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, action_condition: action_condition, action_reference_old_table: action_reference_old_table, action_reference_new_table: action_reference_new_table, comment: comment
+        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
+          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:, 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, action_condition: action_condition, action_reference_old_table: action_reference_old_table, action_reference_new_table: action_reference_new_table, comment: comment
+        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
+          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:, 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, action_condition: action_condition, action_reference_old_table: action_reference_old_table, action_reference_new_table: action_reference_new_table, comment: comment
+        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
+          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
 
         def remove_trigger table_name, trigger_name

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

@@ -2,62 +2,96 @@ module DynamicMigrations
   module Postgres
     class Generator
       module Trigger
-        def add_trigger trigger, code_comment = nil
-          options = {
-            name: ":#{trigger.name}"
-          }
-
-          # if the trigger is a row trigger and the action timing is before or after
-          # then we can use some syntactic sugar to make the migration look nicer
-          # we use method names like before_insert, after_update, etc. and drop the
-          # unnessessary options
-          if trigger.action_orientation == :row && [:before, :after].include?(trigger.action_timing)
-            method_name = "#{trigger.action_timing}_#{trigger.event_manipulation}"
-          else
-            method_name = "add_trigger"
-            options[:action_timing] = ":#{trigger.action_timing}"
-            options[:event_manipulation] = ":#{trigger.event_manipulation}"
-            options[:action_orientation] = ":#{trigger.action_orientation}"
-          end
-
-          # added here because we want the timing and manipulation to visually appear first
-          options[:function_schema_name] = ":#{trigger.function.schema.name}"
-          options[:function_name] = ":#{trigger.function.name}"
+        class UnexpectedTemplateError < StandardError
+        end
 
-          unless trigger.action_condition.nil?
-            options[:action_condition] = ":#{trigger.action_condition}"
-          end
+        class TemplateAlreadyExistsError < StandardError
+        end
 
-          unless trigger.parameters.nil?
-            options[:parameters] = "\"#{trigger.parameters}\""
-          end
+        def self.template template_name
+          @templates && @templates[template_name]
+        end
 
-          unless trigger.action_reference_old_table.nil?
-            options[:action_reference_old_table] = ":#{trigger.action_reference_old_table}"
-          end
+        def self.has_template? template_name
+          @templates&.key?(template_name) || false
+        end
 
-          unless trigger.action_reference_new_table.nil?
-            options[:action_reference_new_table] = ":#{trigger.action_reference_new_table}"
-          end
+        # install a template into the migration generator, this can be used from outside this
+        # library to clean up common migrations (replace common migrations with syntatic sugar)
+        def self.add_template name, template_class
+          @templates ||= {}
+          raise TemplateAlreadyExistsError, name if @templates.key?(name)
+          @templates[name] = template_class
+        end
 
-          unless trigger.description.nil?
-            options[:comment] = <<~RUBY
-              <<~COMMENT
-                #{indent trigger.description}
-              COMMENT
-            RUBY
-          end
+        def add_trigger trigger, code_comment = nil
+          # if we have a corresponding template, then use it
+          if trigger.template
+            unless (template_class = Trigger.template(trigger.template))
+              raise UnexpectedTemplateError, "Unrecognised template #{trigger.template}"
+            end
 
-          options_syntax = options.map { |k, v| "#{k}: #{v}" }.join(", ")
+            arguments = template_class.new(trigger, code_comment).fragment_arguments
+            add_fragment(**arguments)
 
-          add_fragment schema: trigger.table.schema,
-            table: trigger.table,
-            migration_method: :add_trigger,
-            object: trigger,
-            code_comment: code_comment,
-            migration: <<~RUBY
-              #{method_name} :#{trigger.table.name}, #{options_syntax}
-            RUBY
+          # no template, process this as a default trigger (takes all options)
+          else
+            options = {
+              name: ":#{trigger.name}"
+            }
+
+            # if the trigger is a row trigger and the action timing is before or after
+            # then we can use some syntactic sugar to make the migration look nicer
+            # we use method names like before_insert, after_update, etc. and drop the
+            # unnessessary options
+            if trigger.action_orientation == :row && [:before, :after].include?(trigger.action_timing)
+              method_name = "#{trigger.action_timing}_#{trigger.event_manipulation}"
+            else
+              method_name = "add_trigger"
+              options[:action_timing] = ":#{trigger.action_timing}"
+              options[:event_manipulation] = ":#{trigger.event_manipulation}"
+              options[:action_orientation] = ":#{trigger.action_orientation}"
+            end
+
+            # added here because we want the timing and manipulation to visually appear first
+            options[:function_schema_name] = ":#{trigger.function.schema.name}"
+            options[:function_name] = ":#{trigger.function.name}"
+
+            unless trigger.action_condition.nil?
+              options[:action_condition] = "\"#{trigger.action_condition}\""
+            end
+
+            unless trigger.parameters.nil?
+              options[:parameters] = "\"#{trigger.parameters}\""
+            end
+
+            unless trigger.action_reference_old_table.nil?
+              options[:action_reference_old_table] = ":#{trigger.action_reference_old_table}"
+            end
+
+            unless trigger.action_reference_new_table.nil?
+              options[:action_reference_new_table] = ":#{trigger.action_reference_new_table}"
+            end
+
+            unless trigger.description.nil?
+              options[:comment] = <<~RUBY
+                <<~COMMENT
+                  #{indent trigger.description}
+                COMMENT
+              RUBY
+            end
+
+            options_syntax = options.map { |k, v| "#{k}: #{v}" }.join(", ")
+
+            add_fragment schema: trigger.table.schema,
+              table: trigger.table,
+              migration_method: :add_trigger,
+              object: trigger,
+              code_comment: code_comment,
+              migration: <<~RUBY
+                #{method_name} :#{trigger.table.name}, #{options_syntax}
+              RUBY
+          end
         end
 
         def remove_trigger trigger, code_comment = nil

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

@@ -0,0 +1,38 @@
+module DynamicMigrations
+  module Postgres
+    class Generator
+      class TriggerTemplateBase
+        class TemplateError < StandardError
+        end
+
+        attr_reader :trigger
+
+        def initialize trigger, code_comment
+          @trigger = trigger
+          @code_comment = code_comment
+        end
+
+        private
+
+        def assert_column_count! count = 1
+          if @trigger.columns.count != count
+            raise TemplateError, "#{self.class.name} trigger template requires a trigger with only #{count} column"
+          end
+        end
+
+        def first_column
+          column = @trigger.columns.first
+          if column.nil?
+            raise TemplateError, "#{self.class.name} trigger template requires a first column"
+          end
+          column
+        end
+
+        def indent multi_line_string, levels = 1
+          spaces = "  " * levels
+          multi_line_string.gsub("\n", "\n#{spaces}")
+        end
+      end
+    end
+  end
+end

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

@@ -2,44 +2,79 @@ module DynamicMigrations
   module Postgres
     class Generator
       module Validation
+        class UnexpectedTemplateError < StandardError
+        end
+
+        class TemplateAlreadyExistsError < StandardError
+        end
+
+        def self.template template_name
+          @templates && @templates[template_name]
+        end
+
+        def self.has_template? template_name
+          @templates&.key?(template_name) || false
+        end
+
+        # install a template into the migration generator, this can be used from outside this
+        # library to clean up common migrations (replace common migrations with syntatic sugar)
+        def self.add_template name, template_class
+          @templates ||= {}
+          raise TemplateAlreadyExistsError, name if @templates.key?(name)
+          @templates[name] = template_class
+        end
+
         def add_validation validation, code_comment = nil
-          options = {
-            name: ":#{validation.name}",
-            deferrable: validation.deferrable,
-            initially_deferred: validation.initially_deferred
-          }
-
-          if validation.description.nil?
-            comment_sql = ""
+          # if we have a corresponding template, then use it
+          if validation.template
+            unless (template_class = Validation.template(validation.template))
+              raise UnexpectedTemplateError, "Unrecognised template #{validation.template}"
+            end
+
+            arguments = template_class.new(validation, code_comment).fragment_arguments
+            add_fragment(**arguments)
+
+          # no template, process this as a default validation (takes all options)
           else
-            comment_sql = <<~RUBY
-              #{validation.name}_comment = <<~COMMENT
-                #{indent validation.description || ""}
-              COMMENT
-            RUBY
-            options[:comment] = "#{validation.name}_comment"
-          end
 
-          options_syntax = options.map { |k, v| "#{k}: #{v}" }.join(", ")
+            options = {
+              name: ":#{validation.name}",
+              deferrable: validation.deferrable,
+              initially_deferred: validation.initially_deferred
+            }
 
-          validation_sql = validation.check_clause.strip
-          # ensure that the validation ends with a semicolon
-          unless validation_sql.end_with? ";"
-            validation_sql << ";"
-          end
+            if validation.description.nil?
+              comment_sql = ""
+            else
+              comment_sql = <<~RUBY
+                #{validation.name}_comment = <<~COMMENT
+                  #{indent validation.description || ""}
+                COMMENT
+              RUBY
+              options[:comment] = "#{validation.name}_comment"
+            end
 
-          add_fragment schema: validation.table.schema,
-            table: validation.table,
-            migration_method: :add_validation,
-            object: validation,
-            code_comment: code_comment,
-            migration: comment_sql + <<~RUBY
-              add_validation :#{validation.table.name}, #{options_syntax} do
-                <<~SQL
-                  #{indent validation_sql}
-                SQL
-              end
-            RUBY
+            options_syntax = options.map { |k, v| "#{k}: #{v}" }.join(", ")
+
+            validation_sql = validation.check_clause.strip
+            # ensure that the validation ends with a semicolon
+            unless validation_sql.end_with? ";"
+              validation_sql << ";"
+            end
+
+            add_fragment schema: validation.table.schema,
+              table: validation.table,
+              migration_method: :add_validation,
+              object: validation,
+              code_comment: code_comment,
+              migration: comment_sql + <<~RUBY
+                add_validation :#{validation.table.name}, #{options_syntax} do
+                  <<~SQL
+                    #{indent validation_sql}
+                  SQL
+                end
+              RUBY
+          end
         end
 
         def remove_validation validation, code_comment = nil

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

@@ -0,0 +1,74 @@
+module DynamicMigrations
+  module Postgres
+    class Generator
+      class ValidationTemplateBase
+        class TemplateError < StandardError
+        end
+
+        attr_reader :validation
+
+        def initialize validation, code_comment
+          @validation = validation
+          @code_comment = code_comment
+        end
+
+        private
+
+        def assert_not_deferred!
+          if @validation.initially_deferred || @validation.deferrable
+            raise TemplateError, "#{self.class.name} validation template requires constraints to be are not deferrable"
+          end
+        end
+
+        def assert_column_count! count = 1
+          if @validation.columns.count != count
+            raise TemplateError, "#{self.class.name} validation template requires a validation with only #{count} column"
+          end
+        end
+
+        def first_column
+          column = @validation.columns.first
+          if column.nil?
+            raise TemplateError, "#{self.class.name} validation template requires a first column"
+          end
+          column
+        end
+
+        def value_from_check_clause regex
+          matches = @validation.check_clause.strip.match(regex)
+          unless matches
+            raise TemplateError, "#{self.class.name} validation template check_clause was not an expected format"
+          end
+          if matches[:value].nil?
+            raise TemplateError, "#{self.class.name} validation template check_clause could not parse out value from regex (expected `value` named capture group in the regex)"
+          end
+          matches[:value]
+        end
+
+        def name_and_description_options_string default_name
+          options = {}
+          # we only need to provide a name if it is different than the default
+          unless @validation.name == default_name
+            options[:name] = @validation.name
+          end
+          # only provide a comment if it is not nil
+          unless @validation.description.nil?
+            options[:comment] = <<~RUBY
+              <<~COMMENT
+                #{indent @validation.description || ""}
+              COMMENT
+            RUBY
+          end
+
+          options_string = options.map { |k, v| "#{k}: #{v}" }.join(", ")
+          options_string.empty? ? nil : ", #{options_string}"
+        end
+
+        def indent multi_line_string, levels = 1
+          spaces = "  " * levels
+          multi_line_string.gsub("\n", "\n#{spaces}")
+        end
+      end
+    end
+  end
+end

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

@@ -10,13 +10,13 @@ module DynamicMigrations
               def process_extension extension_name, configuration_extension, database_extension
                 # if the extension exists in the configuration but not in the database
                 # then we have to create it
-                if configuration_extension[:exists] == true && database_extension[:exists] == false
+                if configuration_extension[:exists] == true && !database_extension[:exists]
                   # a migration to create the extension
                   @generator.create_extension extension_name
 
                 # if the extension exists in the database but not in the configuration
                 # then we need to delete it
-                elsif configuration_extension[:exists] == false && database_extension[:exists] == true
+                elsif database_extension[:exists] == true && !configuration_extension[:exists]
                   # a migration to drop the extension
                   @generator.drop_extension extension_name
                 end

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

@@ -19,7 +19,7 @@ module DynamicMigrations
                 def process_enum schema_name, enum_name, configuration_enum, database_enum
                   # If the enum exists in the configuration but not in the database
                   # then we have to create it.
-                  if configuration_enum[:exists] == true && database_enum[:exists] == false
+                  if configuration_enum[:exists] == true && !database_enum[:exists]
                     # a migration to create the enum
                     enum = @database.configured_schema(schema_name).enum(enum_name)
                     @generator.create_enum enum
@@ -30,7 +30,7 @@ module DynamicMigrations
 
                   # If the schema exists in the database but not in the configuration
                   # then we need to delete it.
-                  elsif configuration_enum[:exists] == false && database_enum[:exists] == true
+                  elsif database_enum[:exists] == true && !configuration_enum[:exists]
                     # a migration to create the enum
                     enum = @database.loaded_schema(schema_name).enum(enum_name)
                     @generator.drop_enum enum

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

@@ -19,14 +19,14 @@ module DynamicMigrations
                 def process_function schema_name, function_name, configuration_function, database_function
                   # If the function exists in the configuration but not in the database
                   # then we have to create it.
-                  if configuration_function[:exists] == true && database_function[:exists] == false
+                  if configuration_function[:exists] == true && !database_function[:exists]
                     # a migration to create the function
                     function = @database.configured_schema(schema_name).function(function_name)
                     @generator.create_function function
 
                   # If the schema exists in the database but not in the configuration
                   # then we need to delete it.
-                  elsif configuration_function[:exists] == false && database_function[:exists] == true
+                  elsif database_function[:exists] == true && !configuration_function[:exists]
                     # a migration to create the function
                     function = @database.loaded_schema(schema_name).function(function_name)
                     @generator.drop_function function

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

@@ -19,7 +19,7 @@ module DynamicMigrations
                 def process_table schema_name, table_name, configuration_table, database_table
                   # 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] == false
+                  if configuration_table[:exists] == true && !database_table[:exists]
                     # a migration to create the table
                     table = @database.configured_schema(schema_name).table(table_name)
                     @generator.create_table table
@@ -30,7 +30,7 @@ module DynamicMigrations
 
                   # If the schema exists in the database but not in the configuration
                   # then we need to delete it.
-                  elsif configuration_table[:exists] == false && database_table[:exists] == true
+                  elsif database_table[:exists] == true && !configuration_table[:exists]
                     # we process everything else before we drop the table, because the other
                     # database objects are dependent on the table
                     process_dependents schema_name, table_name, {}, database_table

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

@@ -10,7 +10,7 @@ module DynamicMigrations
               def process_schema schema_name, configuration_schema, database_schema
                 # 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] == false
+                if configuration_schema[:exists] == true && !database_schema[:exists]
                   # a migration to create the schema
                   schema = @database.configured_schema schema_name
                   @generator.create_schema schema
@@ -23,7 +23,7 @@ module DynamicMigrations
 
                 # if the schema exists in the database but not in the configuration
                 # then we need to delete it
-                elsif configuration_schema[:exists] == false && database_schema[:exists] == true
+                elsif database_schema[:exists] == true && !configuration_schema[:exists]
                   # 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]

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

@@ -35,6 +35,9 @@ module DynamicMigrations
               class UnexpectedActionOrderError < StandardError
               end
 
+              class UnexpectedTemplateError < StandardError
+              end
+
               attr_reader :table
               attr_reader :name
               attr_reader :event_manipulation
@@ -46,9 +49,10 @@ module DynamicMigrations
               attr_reader :action_reference_old_table
               attr_reader :action_reference_new_table
               attr_reader :description
+              attr_reader :template
 
               # initialize a new object to represent a validation in a postgres table
-              def initialize source, table, name, action_timing:, event_manipulation:, parameters:, action_orientation:, function:, action_order: nil, action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, description: nil
+              def initialize source, table, name, action_timing:, event_manipulation:, parameters:, action_orientation:, function:, action_order: nil, action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, description: nil, template: nil
                 super source
 
                 unless table.is_a? Table
@@ -125,6 +129,13 @@ module DynamicMigrations
                   @description = description.strip
                   @description = nil if description == ""
                 end
+
+                unless template.nil?
+                  unless Generator::Trigger.has_template? template
+                    raise UnexpectedTemplateError, template
+                  end
+                  @template = template
+                end
               end
 
               def action_order

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

@@ -38,13 +38,13 @@ module DynamicMigrations
               end
 
               # adds a new trigger to this table, and returns it
-              def add_trigger name, action_timing:, event_manipulation:, parameters:, action_orientation:, function:, action_order: nil, action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, description: nil
+              def add_trigger name, action_timing:, event_manipulation:, parameters:, action_orientation:, function:, action_order: nil, action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, description: nil, template: nil
                 if has_trigger? name
                   raise(TriggerAlreadyExistsError, "Trigger #{name} already exists")
                 end
                 included_target = self
                 if included_target.is_a? Table
-                  new_trigger = @triggers[name] = Trigger.new source, included_target, name, action_timing: action_timing, event_manipulation: event_manipulation, action_order: action_order, parameters: parameters, action_orientation: action_orientation, function: function, action_condition: action_condition, action_reference_old_table: action_reference_old_table, action_reference_new_table: action_reference_new_table, description: description
+                  new_trigger = @triggers[name] = Trigger.new source, included_target, name, action_timing: action_timing, event_manipulation: event_manipulation, action_order: action_order, parameters: parameters, action_orientation: action_orientation, function: function, action_condition: action_condition, action_reference_old_table: action_reference_old_table, action_reference_new_table: action_reference_new_table, description: description, template: template
                 else
                   raise ModuleIncludedIntoUnexpectedTargetError, included_target
                 end

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

@@ -17,15 +17,19 @@ module DynamicMigrations
               class DuplicateColumnError < StandardError
               end
 
+              class UnexpectedTemplateError < StandardError
+              end
+
               attr_reader :table
               attr_reader :name
               attr_reader :check_clause
               attr_reader :deferrable
               attr_reader :initially_deferred
               attr_reader :description
+              attr_reader :template
 
               # initialize a new object to represent a validation in a postgres table
-              def initialize source, table, columns, name, check_clause, description: nil, deferrable: false, initially_deferred: false
+              def initialize source, table, columns, name, check_clause, description: nil, deferrable: false, initially_deferred: false, template: nil
                 super source
                 raise ExpectedTableError, table unless table.is_a? Table
                 @table = table
@@ -57,6 +61,13 @@ module DynamicMigrations
 
                 raise ExpectedBooleanError, initially_deferred unless [true, false].include?(initially_deferred)
                 @initially_deferred = initially_deferred
+
+                unless template.nil?
+                  unless Generator::Validation.has_template? template
+                    raise UnexpectedTemplateError, "Unrecognised template #{template}"
+                  end
+                  @template = template
+                end
               end
 
               # return true if this has a description, otherwise false

data/lib/dynamic_migrations/version.rb

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

data/lib/dynamic_migrations.rb

@@ -77,6 +77,8 @@ require "dynamic_migrations/postgres/generator/primary_key"
 require "dynamic_migrations/postgres/generator/trigger"
 require "dynamic_migrations/postgres/generator/unique_constraint"
 require "dynamic_migrations/postgres/generator/validation"
+require "dynamic_migrations/postgres/generator/validation_template_base"
+require "dynamic_migrations/postgres/generator/trigger_template_base"
 require "dynamic_migrations/postgres/generator"
 require "dynamic_migrations/postgres/generator/fragment"
 require "dynamic_migrations/postgres/generator/migration"

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

@@ -1,5 +1,3 @@
-# TypeProf 0.21.7
-
 # Classes
 module DynamicMigrations
   module ActiveRecord
@@ -10,6 +8,13 @@ module DynamicMigrations
         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
+
         # stubbing these out, as they are available on the module which includes this module
         def execute: (String sql) -> void
         def schema_name: () -> Symbol

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

@@ -1,10 +1,14 @@
-# TypeProf 0.21.7
-
 # Classes
 module DynamicMigrations
   module Postgres
     class Generator
       module Trigger
+        self.@templates: Hash[Symbol, singleton(TriggerTemplateBase)]
+
+        def self.template: (Symbol template_name) -> singleton(TriggerTemplateBase)
+        def self.has_template?: (Symbol template_name) -> bool
+        def self.add_template: (Symbol template_name, singleton(TriggerTemplateBase) template_class) -> void
+
         def add_trigger: (Server::Database::Schema::Table::Trigger trigger, ?String? code_comment) -> Fragment
         def remove_trigger: (Server::Database::Schema::Table::Trigger trigger, ?String? code_comment) -> Fragment
         def recreate_trigger: (Server::Database::Schema::Table::Trigger original_trigger, Server::Database::Schema::Table::Trigger updated_trigger) -> Array[Fragment]
@@ -16,6 +20,11 @@ module DynamicMigrations
 
         def indent: (String migration, ?Integer levels) -> String
 
+        class UnexpectedTemplateError < StandardError
+        end
+
+        class TemplateAlreadyExistsError < StandardError
+        end
       end
     end
   end

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

@@ -0,0 +1,25 @@
+# Classes
+module DynamicMigrations
+  module Postgres
+    class Generator
+      class TriggerTemplateBase
+        @code_comment: untyped
+
+        attr_reader trigger: untyped
+
+        def initialize: (untyped trigger, 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}
+
+        private
+        def assert_column_count!: (?Integer count) -> nil
+        def first_column: -> untyped
+        def indent: (untyped multi_line_string, ?Integer levels) -> untyped
+
+        class TemplateError < StandardError
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,12 @@ module DynamicMigrations
   module Postgres
     class Generator
       module Validation
+        self.@templates: Hash[Symbol, singleton(ValidationTemplateBase)]
+
+        def self.template: (Symbol template_name) -> singleton(ValidationTemplateBase)
+        def self.has_template?: (Symbol template_name) -> bool
+        def self.add_template: (Symbol template_name, singleton(ValidationTemplateBase) template_class) -> void
+
         def add_validation: (Postgres::Server::Database::Schema::Table::Validation validation, ?String? code_comment) -> Fragment
         def remove_validation: (Postgres::Server::Database::Schema::Table::Validation validation, ?String? code_comment) -> Fragment
         def recreate_validation: (Postgres::Server::Database::Schema::Table::Validation original_validation, Postgres::Server::Database::Schema::Table::Validation updated_validation) -> Array[Fragment]
@@ -15,7 +21,13 @@ module DynamicMigrations
         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 indent: (String migration, ?Integer levels) -> String
+
+        class UnexpectedTemplateError < StandardError
+        end
+
+        class TemplateAlreadyExistsError < StandardError
         end
+      end
     end
   end
 end

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

@@ -0,0 +1,30 @@
+# TypeProf 0.21.8
+
+# Classes
+module DynamicMigrations
+  module Postgres
+    class Generator
+      class ValidationTemplateBase
+        @code_comment: untyped
+
+        attr_reader validation: untyped
+
+        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}
+
+        private
+        def assert_not_deferred!: -> nil
+        def assert_column_count!: (?Integer count) -> nil
+        def first_column: -> untyped
+        def value_from_check_clause: (untyped regex) -> untyped
+        def name_and_description_options_string: (untyped default_name) -> String?
+        def indent: (String multi_line_string, ?Integer levels) -> String
+
+        class TemplateError < StandardError
+        end
+      end
+    end
+  end
+end

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

@@ -20,8 +20,9 @@ module DynamicMigrations
               attr_reader action_reference_old_table: Symbol?
               attr_reader action_reference_new_table: Symbol?
               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?) -> void
+              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 action_order: -> Integer
               def has_description?: -> false
               def differences_descriptions: (Trigger other_trigger) -> Array[String]
@@ -52,6 +53,9 @@ module DynamicMigrations
 
               class UnexpectedActionOrderError < StandardError
               end
+
+              class UnexpectedTemplateError < StandardError
+              end
             end
           end
         end

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?) -> 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
 
               # these come from the table object (which this module is included into)
               def source: -> database_or_configuration

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

@@ -13,8 +13,9 @@ module DynamicMigrations
               attr_reader deferrable: bool
               attr_reader initially_deferred: bool
               attr_reader description: String?
+              attr_reader template: Symbol?
 
-              def initialize: (database_or_configuration source, Table table, Array[Column] columns, Symbol name, String check_clause, ?deferrable: bool, ?initially_deferred: bool, ?description: String?) -> void
+              def initialize: (database_or_configuration source, Table table, Array[Column] columns, Symbol name, String check_clause, ?deferrable: bool, ?initially_deferred: bool, ?description: String?, ?template: Symbol?) -> void
               def columns: -> Array[Column]
               def column_names: -> Array[Symbol]
               def has_description?: -> bool
@@ -34,6 +35,10 @@ module DynamicMigrations
 
               class ModuleIncludedIntoUnexpectedTargetError < StandardError
               end
+
+              class UnexpectedTemplateError < StandardError
+              end
+
             end
           end
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dynamic_migrations
 version: !ruby/object:Gem::Version
-  version: 3.5.2
+  version: 3.6.0
 platform: ruby
 authors:
 - Craig Ulliott
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-09-11 00:00:00.000000000 Z
+date: 2023-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -102,8 +102,10 @@ files:
 - lib/dynamic_migrations/postgres/generator/table.rb
 - lib/dynamic_migrations/postgres/generator/table_migration.rb
 - lib/dynamic_migrations/postgres/generator/trigger.rb
+- lib/dynamic_migrations/postgres/generator/trigger_template_base.rb
 - lib/dynamic_migrations/postgres/generator/unique_constraint.rb
 - lib/dynamic_migrations/postgres/generator/validation.rb
+- lib/dynamic_migrations/postgres/generator/validation_template_base.rb
 - lib/dynamic_migrations/postgres/server.rb
 - lib/dynamic_migrations/postgres/server/database.rb
 - lib/dynamic_migrations/postgres/server/database/configured_extensions.rb
@@ -192,8 +194,10 @@ files:
 - sig/dynamic_migrations/postgres/generator/table.rbs
 - sig/dynamic_migrations/postgres/generator/table_migration.rbs
 - sig/dynamic_migrations/postgres/generator/trigger.rbs
+- sig/dynamic_migrations/postgres/generator/trigger_template_base.rbs
 - sig/dynamic_migrations/postgres/generator/unique_constraint.rbs
 - sig/dynamic_migrations/postgres/generator/validation.rbs
+- sig/dynamic_migrations/postgres/generator/validation_template_base.rbs
 - sig/dynamic_migrations/postgres/server.rbs
 - sig/dynamic_migrations/postgres/server/database.rbs
 - sig/dynamic_migrations/postgres/server/database/configured_extensions.rbs