dynamic_migrations 2.1.0 → 3.0.0

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

@@ -0,0 +1,122 @@
+module DynamicMigrations
+  module Postgres
+    class Generator
+      module Table
+        class NoTableCommentError < StandardError
+        end
+
+        class NoTableColumnCommentError < StandardError
+        end
+
+        def create_table table, code_comment = nil
+          if table.description.nil?
+            raise NoTableCommentError, "Refusing to generate create_table migration, no description was provided for `#{table.schema.name}`.`#{table.name}`"
+          end
+
+          add_migration table.schema.name, table.name, :create_table, table.name, code_comment, <<~RUBY
+            table_comment = <<~COMMENT
+              #{indent table.description}
+            COMMENT
+            create_table :#{table.name}, #{table_options table} do |t|
+              #{indent table_columns(table.columns)}
+            end
+          RUBY
+        end
+
+        def drop_table table, code_comment = nil
+          add_migration table.schema.name, table.name, :drop_table, table.name, code_comment, <<~RUBY
+            drop_table :#{table.name}, force: true
+          RUBY
+        end
+
+        # add a comment to a table
+        def set_table_comment table, code_comment = nil
+          description = table.description
+
+          if description.nil?
+            raise MissingDescriptionError
+          end
+
+          add_migration table.schema.name, table.name, :set_table_comment, table.name, code_comment, <<~RUBY
+            set_table_comment :#{table.name}, <<~COMMENT
+              #{indent description}
+            COMMENT
+          RUBY
+        end
+
+        # remove the comment from a table
+        def remove_table_comment table, code_comment = nil
+          add_migration table.schema.name, table.name, :remove_table_comment, table.name, code_comment, <<~RUBY
+            remove_table_comment :#{table.name}
+          RUBY
+        end
+
+        private
+
+        def table_columns columns
+          lines = []
+          timestamps = []
+          columns.each do |column|
+            # skip the :id, as it is handled by the table_options method
+            next if column.name == :id
+            # skip the :created_at and :updated_at as they are handled below
+            if column.name == :created_at || column.name == :updated_at
+              timestamps << column.name
+              next
+            end
+
+            options = {}
+            options[:null] = column.null
+
+            unless column.default.nil?
+              options[:default] = "\"#{column.default}\""
+            end
+
+            if column.description.nil?
+              raise NoTableColumnCommentError, "Refusing to generate create_table migration, no description was provided for `#{column.table.schema.name}`.`#{column.table.name}` column `#{column.name}`"
+            end
+            options[:comment] = <<~RUBY
+              <<~COMMENT
+                #{indent column.description}
+              COMMENT
+            RUBY
+
+            options_syntax = options.map { |k, v| "#{k}: #{v}" }.join(", ")
+
+            lines << "t.#{column.data_type} :#{column.name}, #{options_syntax}"
+          end
+
+          if timestamps.any?
+            lines << "t.timestamps :#{timestamps.join(", :")}"
+          end
+
+          lines.join("\n")
+        end
+
+        def table_options table
+          options = []
+          options << if table.has_column?(:id)
+            "id: :#{table.column(:id).data_type}"
+          else
+            "id: false"
+          end
+
+          if table.has_primary_key?
+            pk_column_names = table.primary_key.columns.map(&:name)
+            # if there is only one primary key column and it is not called id, then
+            # we define it here. If it is called :id then we don't need to define it
+            if pk_column_names.count == 1 && pk_column_names.first != :id
+              options << "primary_key: :#{pk_column_names.first}"
+            elsif pk_column_names.count > 1
+              options << "primary_key: [:#{pk_column_names.join(", :")}]"
+            end
+          end
+
+          options << "comment: table_comment"
+
+          options.join(", ")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+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}"
+
+          unless trigger.action_condition.nil?
+            options[:action_condition] = ":#{trigger.action_condition}"
+          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_migration trigger.table.schema.name, trigger.table.name, :add_trigger, trigger.name, code_comment, <<~RUBY
+            #{method_name} :#{trigger.table.name}, #{options_syntax}
+          RUBY
+        end
+
+        def remove_trigger trigger, code_comment = nil
+          add_migration trigger.table.schema.name, trigger.table.name, :remove_trigger, trigger.name, code_comment, <<~RUBY
+            remove_trigger :#{trigger.table.name}, :#{trigger.name}
+          RUBY
+        end
+
+        def recreate_trigger original_trigger, updated_trigger
+          # remove the original trigger
+          removal_fragment = remove_trigger original_trigger, <<~CODE_COMMENT
+            Removing original trigger because it has changed (it is recreated below)
+            Changes:
+              #{indent original_trigger.differences_descriptions(updated_trigger).join("\n")}
+          CODE_COMMENT
+
+          # recrete the trigger with the new options
+          recreation_fragment = add_trigger updated_trigger, <<~CODE_COMMENT
+            Recreating this trigger
+          CODE_COMMENT
+
+          # return the new fragments (the main reason to return them here is for the specs)
+          [removal_fragment, recreation_fragment]
+        end
+
+        # add a comment to a trigger
+        def set_trigger_comment trigger, code_comment = nil
+          description = trigger.description
+
+          if description.nil?
+            raise MissingDescriptionError
+          end
+
+          add_migration trigger.table.schema.name, trigger.table.name, :set_trigger_comment, trigger.name, code_comment, <<~RUBY
+            set_trigger_comment :#{trigger.table.name}, :#{trigger.name}, <<~COMMENT
+              #{indent description}
+            COMMENT
+          RUBY
+        end
+
+        # remove the comment from a trigger
+        def remove_trigger_comment trigger, code_comment = nil
+          add_migration trigger.table.schema.name, trigger.table.name, :remove_trigger_comment, trigger.name, code_comment, <<~RUBY
+            remove_trigger_comment :#{trigger.table.name}, :#{trigger.name}
+          RUBY
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+module DynamicMigrations
+  module Postgres
+    class Generator
+      module UniqueConstraint
+        def add_unique_constraint unique_constraint, code_comment = nil
+          # the migration accepts either a single column name or an array of column names
+          # we use the appropriate syntax just to make the migration prettier and easier
+          # to understand
+          column_names = (unique_constraint.column_names.count == 1) ? ":#{unique_constraint.column_names.first}" : "[:#{unique_constraint.column_names.join(", :")}]"
+
+          options = {
+            name: ":#{unique_constraint.name}",
+            deferrable: unique_constraint.deferrable,
+            initially_deferred: unique_constraint.initially_deferred
+          }
+
+          unless unique_constraint.description.nil?
+            options[:comment] = <<~RUBY
+              <<~COMMENT
+                #{indent unique_constraint.description}
+              COMMENT
+            RUBY
+          end
+
+          options_syntax = options.map { |k, v| "#{k}: #{v}" }.join(", ")
+
+          add_migration unique_constraint.table.schema.name, unique_constraint.table.name, :add_unique_constraint, unique_constraint.name, code_comment, <<~RUBY
+            add_unique_constraint :#{unique_constraint.table.name}, #{column_names}, #{options_syntax}
+          RUBY
+        end
+
+        def remove_unique_constraint unique_constraint, code_comment = nil
+          add_migration unique_constraint.table.schema.name, unique_constraint.table.name, :remove_unique_constraint, unique_constraint.name, code_comment, <<~RUBY
+            remove_unique_constraint :#{unique_constraint.table.name}, :#{unique_constraint.name}
+          RUBY
+        end
+
+        def recreate_unique_constraint original_unique_constraint, updated_unique_constraint
+          # remove the original unique_constraint
+          removal_fragment = remove_unique_constraint original_unique_constraint, <<~CODE_COMMENT
+            Removing original unique constraint because it has changed (it is recreated below)
+            Changes:
+              #{indent original_unique_constraint.differences_descriptions(updated_unique_constraint).join("\n")}
+          CODE_COMMENT
+
+          # recrete the unique_constraint with the new options
+          recreation_fragment = add_unique_constraint updated_unique_constraint, <<~CODE_COMMENT
+            Recreating this unique constraint
+          CODE_COMMENT
+
+          # return the new fragments (the main reason to return them here is for the specs)
+          [removal_fragment, recreation_fragment]
+        end
+
+        # add a comment to a unique_constraint
+        def set_unique_constraint_comment unique_constraint, code_comment = nil
+          description = unique_constraint.description
+
+          if description.nil?
+            raise MissingDescriptionError
+          end
+
+          add_migration unique_constraint.table.schema.name, unique_constraint.table.name, :set_unique_constraint_comment, unique_constraint.name, code_comment, <<~RUBY
+            set_unique_constraint_comment :#{unique_constraint.table.name}, :#{unique_constraint.name}, <<~COMMENT
+              #{indent description}
+            COMMENT
+          RUBY
+        end
+
+        # remove the comment from a unique_constraint
+        def remove_unique_constraint_comment unique_constraint, code_comment = nil
+          add_migration unique_constraint.table.schema.name, unique_constraint.table.name, :remove_unique_constraint_comment, unique_constraint.name, code_comment, <<~RUBY
+            remove_unique_constraint_comment :#{unique_constraint.table.name}, :#{unique_constraint.name}
+          RUBY
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+module DynamicMigrations
+  module Postgres
+    class Generator
+      module Validation
+        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 = ""
+          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(", ")
+
+          validation_sql = validation.check_clause.strip
+          # ensure that the validation ends with a semicolon
+          unless validation_sql.end_with? ";"
+            validation_sql << ";"
+          end
+
+          add_migration validation.table.schema.name, validation.table.name, :add_validation, validation.name, code_comment, (comment_sql + <<~RUBY)
+            add_validation :#{validation.table.name}, #{options_syntax} do
+              <<~SQL
+                #{indent validation_sql}
+              SQL
+            end
+          RUBY
+        end
+
+        def remove_validation validation, code_comment = nil
+          add_migration validation.table.schema.name, validation.table.name, :remove_validation, validation.name, code_comment, <<~RUBY
+            remove_validation :#{validation.table.name}, :#{validation.name}
+          RUBY
+        end
+
+        def recreate_validation original_validation, updated_validation
+          # remove the original validation
+          removal_fragment = remove_validation original_validation, <<~CODE_COMMENT
+            Removing original validation because it has changed (it is recreated below)
+            Changes:
+              #{indent original_validation.differences_descriptions(updated_validation).join("\n")}
+          CODE_COMMENT
+
+          # recrete the validation with the new options
+          recreation_fragment = add_validation updated_validation, <<~CODE_COMMENT
+            Recreating this validation
+          CODE_COMMENT
+
+          # return the new fragments (the main reason to return them here is for the specs)
+          [removal_fragment, recreation_fragment]
+        end
+
+        # add a comment to a validation
+        def set_validation_comment validation, code_comment = nil
+          description = validation.description
+
+          if description.nil?
+            raise MissingDescriptionError
+          end
+
+          add_migration validation.table.schema.name, validation.table.name, :set_validation_comment, validation.name, code_comment, <<~RUBY
+            set_validation_comment :#{validation.table.name}, :#{validation.name}, <<~COMMENT
+              #{indent description}
+            COMMENT
+          RUBY
+        end
+
+        # remove the comment from a validation
+        def remove_validation_comment validation, code_comment = nil
+          add_migration validation.table.schema.name, validation.table.name, :remove_validation_comment, validation.name, code_comment, <<~RUBY
+            remove_validation_comment :#{validation.table.name}, :#{validation.name}
+          RUBY
+        end
+      end
+    end
+  end
+end