dynamic_migrations 2.1.0 → 3.0.0

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

@@ -0,0 +1,92 @@
+module DynamicMigrations
+  module Postgres
+    class Generator
+      module Column
+        class NoColumnCommentError < StandardError
+        end
+
+        def add_column column, code_comment = nil
+          if column.description.nil?
+            raise NoColumnCommentError, "Refusing to generate add_column migration, no description was provided for `#{column.table.schema.name}`.`#{column.table.name}` column `#{column.name}`"
+          end
+
+          options = {}
+          options[:null] = column.null
+
+          unless column.default.nil?
+            options[:default] = "\"#{column.default}\""
+          end
+
+          if column.array?
+            options[:array] = true
+          end
+
+          options_syntax = options.map { |k, v| "#{k}: #{v}" }.join(", ")
+
+          data_type = column.data_type
+          if column.array?
+            data_type = "\"#{data_type}\""
+          end
+
+          add_migration column.table.schema.name, column.table.name, :add_column, column.name, code_comment, <<~RUBY
+            add_column :#{column.table.name}, :#{column.name}, :#{data_type}, #{options_syntax}, comment: <<~COMMENT
+              #{indent column.description}
+            COMMENT
+          RUBY
+        end
+
+        def change_column column, code_comment = nil
+          options = {}
+          options[:null] = column.null
+
+          unless column.default.nil?
+            options[:default] = "\"#{column.default}\""
+          end
+
+          if column.array?
+            options[:array] = true
+          end
+
+          options_syntax = options.map { |k, v| "#{k}: #{v}" }.join(", ")
+
+          data_type = column.data_type
+          if column.array?
+            data_type = ":\"#{data_type}\""
+          end
+
+          add_migration column.table.schema.name, column.table.name, :change_column, column.name, code_comment, <<~RUBY
+            change_column :#{column.table.name}, :#{column.name}, :#{data_type}, #{options_syntax}
+          RUBY
+        end
+
+        def remove_column column, code_comment = nil
+          add_migration column.table.schema.name, column.table.name, :remove_column, column.name, code_comment, <<~RUBY
+            remove_column :#{column.table.name}, :#{column.name}
+          RUBY
+        end
+
+        # add a comment to a column
+        def set_column_comment column, code_comment = nil
+          description = column.description
+
+          if description.nil?
+            raise MissingDescriptionError
+          end
+
+          add_migration column.table.schema.name, column.table.name, :set_column_comment, column.name, code_comment, <<~RUBY
+            set_column_comment :#{column.table.name}, :#{column.name}, <<~COMMENT
+              #{indent description}
+            COMMENT
+          RUBY
+        end
+
+        # remove the comment from a column
+        def remove_column_comment column, code_comment = nil
+          add_migration column.table.schema.name, column.table.name, :remove_column_comment, column.name, code_comment, <<~RUBY
+            remove_column_comment :#{column.table.name}, :#{column.name}
+          RUBY
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+module DynamicMigrations
+  module Postgres
+    class Generator
+      module ForeignKeyConstraint
+        def add_foreign_key_constraint foreign_key_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
+          p_c_names = foreign_key_constraint.column_names
+          column_names = (p_c_names.count == 1) ? ":#{p_c_names.first}" : "[:#{p_c_names.join(", :")}]"
+
+          f_c_names = foreign_key_constraint.foreign_column_names
+          foreign_column_names = (f_c_names.count == 1) ? ":#{f_c_names.first}" : "[:#{f_c_names.join(", :")}]"
+
+          options = {
+            name: ":#{foreign_key_constraint.name}",
+            initially_deferred: foreign_key_constraint.initially_deferred,
+            deferrable: foreign_key_constraint.deferrable,
+            on_delete: ":#{foreign_key_constraint.on_delete}",
+            on_update: ":#{foreign_key_constraint.on_update}"
+          }
+          unless foreign_key_constraint.description.nil?
+            options[:comment] = <<~RUBY
+              <<~COMMENT
+                #{indent foreign_key_constraint.description}
+              COMMENT
+            RUBY
+          end
+
+          options_syntax = options.map { |k, v| "#{k}: #{v}" }.join(", ")
+
+          add_migration foreign_key_constraint.table.schema.name, foreign_key_constraint.table.name, :add_foreign_key, foreign_key_constraint.name, code_comment, <<~RUBY
+            add_foreign_key :#{foreign_key_constraint.table.name}, #{column_names}, :#{foreign_key_constraint.foreign_table.name}, #{foreign_column_names}, #{options_syntax}
+          RUBY
+        end
+
+        def remove_foreign_key_constraint foreign_key_constraint, code_comment = nil
+          add_migration foreign_key_constraint.table.schema.name, foreign_key_constraint.table.name, :remove_foreign_key, foreign_key_constraint.name, code_comment, <<~RUBY
+            remove_foreign_key :#{foreign_key_constraint.table.name}, :#{foreign_key_constraint.name}
+          RUBY
+        end
+
+        def recreate_foreign_key_constraint original_foreign_key_constraint, updated_foreign_key_constraint
+          # remove the original foreign_key_constraint
+          removal_fragment = remove_foreign_key_constraint original_foreign_key_constraint, <<~CODE_COMMENT
+            Removing original foreign key constraint because it has changed (it is recreated below)
+            Changes:
+              #{indent original_foreign_key_constraint.differences_descriptions(updated_foreign_key_constraint).join("\n")}
+          CODE_COMMENT
+
+          # recrete the foreign_key_constraint with the new options
+          recreation_fragment = add_foreign_key_constraint updated_foreign_key_constraint, <<~CODE_COMMENT
+            Recreating this foreign key 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 foreign_key_constraint
+        def set_foreign_key_constraint_comment foreign_key_constraint, code_comment = nil
+          description = foreign_key_constraint.description
+
+          if description.nil?
+            raise MissingDescriptionError
+          end
+
+          add_migration foreign_key_constraint.table.schema.name, foreign_key_constraint.table.name, :set_foreign_key_constraint_comment, foreign_key_constraint.name, code_comment, <<~RUBY
+            set_foreign_key_comment :#{foreign_key_constraint.table.name}, :#{foreign_key_constraint.name}, <<~COMMENT
+              #{indent description}
+            COMMENT
+          RUBY
+        end
+
+        # remove the comment from a foreign_key_constraint
+        def remove_foreign_key_constraint_comment foreign_key_constraint, code_comment = nil
+          add_migration foreign_key_constraint.table.schema.name, foreign_key_constraint.table.name, :remove_foreign_key_constraint_comment, foreign_key_constraint.name, code_comment, <<~RUBY
+            remove_foreign_key_comment :#{foreign_key_constraint.table.name}, :#{foreign_key_constraint.name}
+          RUBY
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module DynamicMigrations
+  module Postgres
+    class Generator
+      class Fragment
+        attr_reader :object_name
+        attr_reader :code_comment
+
+        def initialize object_name, code_comment, content
+          @object_name = object_name
+          @code_comment = code_comment
+          @content = content
+        end
+
+        def to_s
+          strings = []
+          comment = @code_comment
+          unless comment.nil?
+            strings << "# " + comment.split("\n").join("\n# ")
+          end
+          strings << @content
+          strings.join("\n").strip
+        end
+
+        def has_code_comment?
+          !@code_comment.nil?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+module DynamicMigrations
+  module Postgres
+    class Generator
+      module Function
+        def create_function function, code_comment = nil
+          options = {}
+
+          if function.description.nil?
+            comment_sql = ""
+          else
+            comment_sql = <<~RUBY
+              #{function.name}_comment = <<~COMMENT
+                #{indent function.description || ""}
+              COMMENT
+            RUBY
+            options[:comment] = "#{function.name}_comment"
+          end
+
+          options_syntax = options.map { |k, v| "#{k}: #{v}" }.join(", ")
+          optional_options_syntax = (options_syntax == "") ? "" : ", #{options_syntax}"
+
+          fn_sql = function.definition.strip
+          # ensure that the function ends with a semicolon
+          unless fn_sql.end_with? ";"
+            fn_sql << ";"
+          end
+
+          add_migration function.schema.name, function.triggers.first&.table&.name, :create_function, function.name, code_comment, (comment_sql + <<~RUBY)
+            create_function :#{function.name}#{optional_options_syntax} do
+              <<~SQL
+                #{indent fn_sql}
+              SQL
+            end
+          RUBY
+        end
+
+        def update_function function, code_comment = nil
+          fn_sql = function.definition.strip
+          # ensure that the function ends with a semicolon
+          unless fn_sql.end_with? ";"
+            fn_sql << ";"
+          end
+
+          add_migration function.schema.name, function.triggers.first&.table&.name, :update_function, function.name, code_comment, <<~RUBY
+            update_function :#{function.name} do
+              <<~SQL
+                #{indent fn_sql}
+              SQL
+            end
+          RUBY
+        end
+
+        def drop_function function, code_comment = nil
+          add_migration function.schema.name, function.triggers.first&.table&.name, :drop_function, function.name, code_comment, <<~RUBY
+            drop_function :#{function.name}
+          RUBY
+        end
+
+        # add a comment to a function
+        def set_function_comment function, code_comment = nil
+          add_migration function.schema.name, function.triggers.first&.table&.name, :set_function_comment, function.name, code_comment, <<~RUBY
+            set_function_comment :#{function.name}, <<~COMMENT
+              #{indent function.description || ""}
+            COMMENT
+          RUBY
+        end
+
+        # remove the comment from a function
+        def remove_function_comment function, code_comment = nil
+          add_migration function.schema.name, function.triggers.first&.table&.name, :remove_function_comment, function.name, code_comment, <<~RUBY
+            remove_function_comment :#{function.name}
+          RUBY
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+module DynamicMigrations
+  module Postgres
+    class Generator
+      module Index
+        def add_index index, 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 = (index.column_names.count == 1) ? ":#{index.column_names.first}" : "[:#{index.column_names.join(", :")}]"
+
+          options = {
+            name: ":#{index.name}",
+            unique: index.unique,
+            using: ":#{index.type}",
+            # todo: support custom sorting, it requires refactoring the index class because the ordering is actually on a column by column basis, not the index itself
+            sort: ":#{index.order}"
+          }
+
+          # :first is the default when :desc is specified, :last is the default when :asc is specified
+          if (index.order == :desc && index.nulls_position == :last) || (index.order == :asc && index.nulls_position == :first)
+            # todo: support nulls_position, it requires writing our own migrator because rails does not provide this option
+            raise "custom nulls_position is not currently supported"
+          end
+
+          unless index.where.nil?
+            options[:where] = "\"#{index.where}\""
+          end
+
+          unless index.description.nil?
+            options[:comment] = <<~RUBY
+              <<~COMMENT
+                #{indent index.description}
+              COMMENT
+            RUBY
+          end
+
+          where_sql = ""
+          unless index.where.nil?
+            options[:where] = "#{index.name}_where_sql"
+            where_sql = <<~RUBY
+              #{index.name}_where_sql = <<~SQL
+                #{indent index.where}
+              SQL
+            RUBY
+          end
+
+          options_syntax = options.map { |k, v| "#{k}: #{v}" }.join(", ")
+
+          add_migration index.table.schema.name, index.table.name, :add_index, index.name, code_comment, (where_sql + <<~RUBY)
+            add_index :#{index.table.name}, #{column_names}, #{options_syntax}
+          RUBY
+        end
+
+        def remove_index index, code_comment = nil
+          add_migration index.table.schema.name, index.table.name, :remove_index, index.name, code_comment, <<~RUBY
+            remove_index :#{index.table.name}, :#{index.name}
+          RUBY
+        end
+
+        def recreate_index original_index, updated_index
+          # remove the original index
+          removal_fragment = remove_index original_index, <<~CODE_COMMENT
+            Removing original index because it has changed (it is recreated below)
+            Changes:
+              #{indent original_index.differences_descriptions(updated_index).join("\n")}
+          CODE_COMMENT
+
+          # recrete the index with the new options
+          recreation_fragment = add_index updated_index, <<~CODE_COMMENT
+            Recreating this index
+          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 index
+        def set_index_comment index, code_comment = nil
+          description = index.description
+
+          if description.nil?
+            raise MissingDescriptionError
+          end
+
+          add_migration index.table.schema.name, index.table.name, :set_index_comment, index.name, code_comment, <<~RUBY
+            set_index_comment :#{index.table.name}, :#{index.name}, <<~COMMENT
+              #{indent description}
+            COMMENT
+          RUBY
+        end
+
+        # remove the comment from a index
+        def remove_index_comment index, code_comment = nil
+          add_migration index.table.schema.name, index.table.name, :remove_index_comment, index.name, code_comment, <<~RUBY
+            remove_index_comment :#{index.table.name}, :#{index.name}
+          RUBY
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module DynamicMigrations
+  module Postgres
+    class Generator
+      module PrimaryKey
+        def add_primary_key primary_key, 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 = (primary_key.column_names.count == 1) ? ":#{primary_key.column_names.first}" : "[:#{primary_key.column_names.join(", :")}]"
+
+          options = {
+            name: ":#{primary_key.name}"
+          }
+
+          unless primary_key.description.nil?
+            options[:comment] = <<~RUBY
+              <<~COMMENT
+                #{indent primary_key.description}
+              COMMENT
+            RUBY
+          end
+
+          options_syntax = options.map { |k, v| "#{k}: #{v}" }.join(", ")
+
+          add_migration primary_key.table.schema.name, primary_key.table.name, :add_primary_key, primary_key.name, code_comment, <<~RUBY
+            add_primary_key :#{primary_key.table.name}, #{column_names}, #{options_syntax}
+          RUBY
+        end
+
+        def remove_primary_key primary_key, code_comment = nil
+          add_migration primary_key.table.schema.name, primary_key.table.name, :remove_primary_key, primary_key.name, code_comment, <<~RUBY
+            remove_primary_key :#{primary_key.table.name}, :#{primary_key.name}
+          RUBY
+        end
+
+        def recreate_primary_key original_primary_key, updated_primary_key
+          # remove the original primary_key
+          removal_fragment = remove_primary_key original_primary_key, <<~CODE_COMMENT
+            Removing original primary key because it has changed (it is recreated below)
+            Changes:
+              #{indent original_primary_key.differences_descriptions(updated_primary_key).join("\n")}
+          CODE_COMMENT
+
+          # recrete the primary_key with the new options
+          recreation_fragment = add_primary_key updated_primary_key, <<~CODE_COMMENT
+            Recreating this primary key
+          CODE_COMMENT
+
+          # return the new fragments (the main reason to return them here is for the specs)
+          [removal_fragment, recreation_fragment]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module DynamicMigrations
+  module Postgres
+    class Generator
+      module Schema
+        def create_schema schema, code_comment = nil
+          add_migration schema.name, nil, :create_schema, schema.name, code_comment, <<~RUBY
+            create_schema :#{schema.name}
+          RUBY
+        end
+
+        def drop_schema schema, code_comment = nil
+          add_migration schema.name, nil, :drop_schema, schema.name, code_comment, <<~RUBY
+            drop_schema :#{schema.name}
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/postgres/generator/schema_migrations/section.rb

@@ -0,0 +1,37 @@
+module DynamicMigrations
+  module Postgres
+    class Generator
+      class SchemaMigrations
+        class Section
+          attr_reader :schema_name
+          attr_reader :table_name
+          attr_reader :content_type
+          attr_reader :fragment
+
+          def initialize schema_name, table_name, content_type, fragment
+            @schema_name = schema_name
+            @table_name = table_name
+            @content_type = content_type
+            @fragment = fragment
+          end
+
+          def object_name
+            @fragment.object_name
+          end
+
+          def to_s
+            @fragment.to_s
+          end
+
+          def is_comment?
+            content_type? :comment
+          end
+
+          def content_type? content_type
+            @content_type == content_type
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+module DynamicMigrations
+  module Postgres
+    class Generator
+      class SchemaMigrations
+        class SectionNotFoundError < StandardError
+        end
+
+        attr_reader :current_migration_sections
+
+        def initialize
+          @migrations = []
+          @current_migration_sections = []
+        end
+
+        def add_fragment schema_name, table_name, content_type, fragment
+          @current_migration_sections << Section.new(schema_name, table_name, content_type, fragment)
+        end
+
+        def finalize
+          if @current_migration_sections.any?
+
+            contents = []
+            @current_migration_sections.each do |section|
+              contents << section.to_s
+              # add an empty line between sections (unless this is a comment section)
+              unless section.is_comment?
+                contents << ""
+              end
+            end
+
+            @migrations << {
+              name: generate_current_migration_name,
+              content: contents.join("\n").strip
+            }
+
+            @current_migration_sections = []
+          end
+        end
+
+        def to_a
+          @migrations
+        end
+
+        private
+
+        def current_migration_has_content_type? content_type
+          @current_migration_sections.map(&:content_type).include? content_type
+        end
+
+        def current_migration_section_of_content_type content_type
+          section = @current_migration_sections.find(&:content_type)
+          if section.nil?
+            raise SectionNotFoundError, "No section of type #{content_type} found"
+          end
+          section
+        end
+
+        # return true if the current migration only has the provided content types and comments
+        def current_migration_only_content_types? content_types
+          (@current_migration_sections.map(&:content_type) - content_types - [:comment]).empty?
+        end
+
+        def generate_current_migration_name
+          if current_migration_has_content_type? :create_schema
+            "create_#{current_migration_section_of_content_type(:create_schema).schema_name}_schema".to_sym
+
+          elsif current_migration_has_content_type? :drop_schema
+            "drop_#{current_migration_section_of_content_type(:drop_schema).schema_name}_schema".to_sym
+
+          elsif current_migration_has_content_type? :create_table
+            "create_#{current_migration_section_of_content_type(:create_table).table_name}".to_sym
+
+          elsif current_migration_has_content_type? :drop_table
+            "drop_#{current_migration_section_of_content_type(:drop_table).table_name}".to_sym
+
+          elsif current_migration_only_content_types? [:create_function]
+            "create_function_#{@current_migration_sections.find { |s| s.content_type == :create_function }&.object_name}".to_sym
+
+          elsif current_migration_only_content_types? [:create_function, :update_function, :drop_function, :set_function_comment, :remove_function_comment]
+            :schema_functions
+
+          elsif @current_migration_sections.first&.table_name
+            "changes_for_#{@current_migration_sections.first&.table_name}".to_sym
+
+          else
+            :changes
+          end
+        end
+      end
+    end
+  end
+end