db_schema 0.1

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'db_schema'
+
+require 'pry'
+require 'awesome_print'
+AwesomePrint.pry!
+
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+createdb db_schema_test

data/db_schema.gemspec

@@ -0,0 +1,35 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'db_schema/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'db_schema'
+  spec.version       = DbSchema::VERSION
+  spec.authors       = ['Vsevolod Romashov']
+  spec.email         = ['7@7vn.ru']
+
+  spec.summary       = 'Declarative database schema definition.'
+  spec.description   = 'A database schema management tool that reads a "single-source-of-truth" schema definition from a ruby file and auto-migrates the database to conform to it.'
+  spec.homepage      = 'https://github.com/7even/db_schema'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r(^spec/)) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r(^exe/)) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'sequel'
+  spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
+
+  spec.add_development_dependency 'bundler', '~> 1.11'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'awesome_print', '~> 1.7'
+
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'guard-rspec'
+  spec.add_development_dependency 'terminal-notifier'
+  spec.add_development_dependency 'terminal-notifier-guard'
+
+  spec.add_development_dependency 'pg'
+end

data/lib/db_schema.rb

@@ -0,0 +1,125 @@
+require 'sequel'
+require 'yaml'
+
+require 'db_schema/configuration'
+require 'db_schema/utils'
+require 'db_schema/definitions'
+require 'db_schema/awesome_print'
+require 'db_schema/dsl'
+require 'db_schema/validator'
+require 'db_schema/reader'
+require 'db_schema/changes'
+require 'db_schema/runner'
+require 'db_schema/version'
+
+module DbSchema
+  class << self
+    def describe(&block)
+      desired_schema = DSL.new(block).schema
+      validate(desired_schema)
+
+      actual_schema = Reader.read_schema
+      changes = Changes.between(desired_schema, actual_schema)
+      return if changes.empty?
+
+      log_changes(changes) if configuration.log_changes?
+      return if configuration.dry_run?
+
+      Runner.new(changes).run!
+
+      if configuration.post_check_enabled?
+        perform_post_check(desired_schema)
+      end
+    end
+
+    def connection
+      @connection ||= Sequel.connect(
+        adapter:  configuration.adapter,
+        host:     configuration.host,
+        port:     configuration.port,
+        database: configuration.database,
+        user:     configuration.user,
+        password: configuration.password
+      ).tap do |db|
+        db.extension :pg_enum
+        db.extension :pg_array
+      end
+    end
+
+    def configure(connection_parameters)
+      @configuration = Configuration.new(connection_parameters)
+      @connection    = nil
+    end
+
+    def configure_from_yaml(yaml_path, environment, **other_options)
+      data = Utils.symbolize_keys(YAML.load_file(yaml_path))
+      filtered_data = Utils.filter_by_keys(
+        data[environment.to_sym],
+        *%i(adapter host port database username password)
+      )
+      renamed_data = Utils.rename_keys(filtered_data, username: :user)
+
+      configure(renamed_data.merge(other_options))
+    end
+
+    def configuration
+      raise 'You must call DbSchema.configure in order to connect to the database.' if @configuration.nil?
+
+      @configuration
+    end
+
+    def reset!
+      @configuration = nil
+      @connection    = nil
+    end
+
+  private
+    def validate(schema)
+      validation_result = Validator.validate(schema)
+
+      unless validation_result.valid?
+        message = "Requested schema is invalid:\n\n"
+
+        validation_result.errors.each do |error|
+          message << "* #{error}\n"
+        end
+
+        raise InvalidSchemaError, message
+      end
+    end
+
+    def log_changes(changes)
+      return if changes.empty?
+
+      puts 'DbSchema is applying these changes to the database:'
+      if changes.respond_to?(:ai)
+        puts changes.ai
+      else
+        puts changes.inspect
+      end
+    end
+
+    def perform_post_check(desired_schema)
+      unapplied_changes = Changes.between(desired_schema, Reader.read_schema)
+      return if unapplied_changes.empty?
+
+      readable_changes = if unapplied_changes.respond_to?(:ai)
+        unapplied_changes.ai
+      else
+        unapplied_changes.inspect
+      end
+
+      message = <<-ERROR
+Your database still differs from the expected schema after applying it; if you are 100% sure this is ok you can turn these checks off with DbSchema.configure(post_check: false). Here are the differences:
+
+#{readable_changes}
+      ERROR
+
+      raise SchemaMismatch, message
+    end
+  end
+
+  class InvalidSchemaError < ArgumentError; end
+  class SchemaMismatch < RuntimeError; end
+  class UnsupportedOperation < ArgumentError; end
+end

data/lib/db_schema/awesome_print.rb

@@ -0,0 +1,246 @@
+begin
+  require 'awesome_print'
+rescue LoadError
+end
+
+if defined?(AwesomePrint)
+  module AwesomePrint
+    module DbSchema
+      def self.included(base)
+        base.send :alias_method, :cast_without_dbschema, :cast
+        base.send :alias_method, :cast, :cast_with_dbschema
+      end
+
+      def cast_with_dbschema(object, type)
+        case object
+        when ::DbSchema::Definitions::Table
+          :dbschema_table
+        when ::DbSchema::Definitions::Field::Custom
+          :dbschema_custom_field
+        when ::DbSchema::Definitions::Field::Base
+          :dbschema_field
+        when ::DbSchema::Definitions::Index
+          :dbschema_index
+        when ::DbSchema::Definitions::Index::Field
+          :dbschema_index_field
+        when ::DbSchema::Definitions::CheckConstraint
+          :dbschema_check_constraint
+        when ::DbSchema::Definitions::ForeignKey
+          :dbschema_foreign_key
+        when ::DbSchema::Definitions::Enum
+          :dbschema_enum
+        when ::DbSchema::Changes::CreateTable
+          :dbschema_create_table
+        when ::DbSchema::Changes::DropTable
+          :dbschema_drop_table
+        when ::DbSchema::Changes::AlterTable
+          :dbschema_alter_table
+        when ::DbSchema::Changes::CreateColumn
+          :dbschema_create_column
+        when ::DbSchema::Changes::DropColumn
+          :dbschema_column_operation
+        when ::DbSchema::Changes::RenameColumn
+          :dbschema_rename_column
+        when ::DbSchema::Changes::AlterColumnType
+          :dbschema_alter_column_type
+        when ::DbSchema::Changes::CreatePrimaryKey,
+             ::DbSchema::Changes::DropPrimaryKey,
+             ::DbSchema::Changes::AllowNull,
+             ::DbSchema::Changes::DisallowNull
+          :dbschema_column_operation
+        when ::DbSchema::Changes::AlterColumnDefault
+          :dbschema_alter_column_default
+        when ::DbSchema::Changes::CreateIndex
+          :dbschema_index
+        when ::DbSchema::Changes::DropIndex
+          :dbschema_column_operation
+        when ::DbSchema::Changes::CreateCheckConstraint
+          :dbschema_check_constraint
+        when ::DbSchema::Changes::DropCheckConstraint
+          :dbschema_column_operation
+        when ::DbSchema::Changes::CreateForeignKey
+          :dbschema_create_foreign_key
+        when ::DbSchema::Changes::DropForeignKey
+          :dbschema_drop_foreign_key
+        when ::DbSchema::Changes::CreateEnum
+          :dbschema_enum
+        when ::DbSchema::Changes::DropEnum
+          :dbschema_column_operation
+        when ::DbSchema::Changes::AddValueToEnum
+          :dbschema_add_value_to_enum
+        else
+          cast_without_dbschema(object, type)
+        end
+      end
+
+    private
+      def awesome_dbschema_table(object)
+        data = ["fields: #{object.fields.ai}"]
+        data << "indices: #{object.indices.ai}" if object.indices.any?
+        data << "checks: #{object.checks.ai}" if object.checks.any?
+        data << "foreign_keys: #{object.foreign_keys.ai}" if object.foreign_keys.any?
+
+        data_string = indent_lines(data.join(', '))
+        "#<DbSchema::Definitions::Table #{object.name.ai} #{data_string}>"
+      end
+
+      def awesome_dbschema_field(object)
+        options = object.options.map do |k, v|
+          key = colorize("#{k}:", :symbol)
+          "#{key} #{v.ai}"
+        end.unshift(nil).join(', ')
+
+        primary_key = if object.primary_key?
+          ', ' + colorize('primary key', :nilclass)
+        else
+          ''
+        end
+
+        "#<#{object.class} #{object.name.ai}#{options}#{primary_key}>"
+      end
+
+      def awesome_dbschema_custom_field(object)
+        options = object.options.map do |k, v|
+          key = colorize("#{k}:", :symbol)
+          "#{key} #{v.ai}"
+        end.unshift(nil).join(', ')
+
+        primary_key = if object.primary_key?
+          ', ' + colorize('primary key', :nilclass)
+        else
+          ''
+        end
+
+        "#<#{object.class} (#{object.type.ai}) #{object.name.ai}#{options}#{primary_key}>"
+      end
+
+      def awesome_dbschema_index(object)
+        fields = format_dbschema_fields(object.fields)
+        using = ' using ' + colorize(object.type.to_s, :symbol) unless object.btree?
+
+        data = [nil]
+        data << colorize('unique', :nilclass) if object.unique?
+        data << colorize('condition: ', :symbol) + object.condition.ai unless object.condition.nil?
+
+        "#<#{object.class} #{object.name.ai} on #{fields}#{using}#{data.join(', ')}>"
+      end
+
+      def awesome_dbschema_index_field(object)
+        data = [object.name.ai]
+
+        if object.desc?
+          data << colorize('desc', :nilclass)
+          data << colorize('nulls last', :symbol) if object.nulls == :last
+        else
+          data << colorize('nulls first', :symbol) if object.nulls == :first
+        end
+
+        data.join(' ')
+      end
+
+      def awesome_dbschema_check_constraint(object)
+        "#<#{object.class} #{object.name.ai} #{object.condition.ai}>"
+      end
+
+      def awesome_dbschema_foreign_key(object)
+        fields = format_dbschema_fields(object.fields)
+        references = "#{colorize('references', :class)} #{object.table.ai}"
+        references << ' ' + format_dbschema_fields(object.keys) unless object.references_primary_key?
+
+        data = [nil]
+        data << colorize("on_update:", :symbol) + " #{object.on_update.ai}" unless object.on_update == :no_action
+        data << colorize("on_delete:", :symbol) + " #{object.on_delete.ai}" unless object.on_delete == :no_action
+        data << colorize('deferrable', :nilclass) if object.deferrable?
+
+        "#<#{object.class} #{object.name.ai} on #{fields} #{references}#{data.join(', ')}>"
+      end
+
+      def awesome_dbschema_enum(object)
+        values = object.values.map do |value|
+          colorize(value.to_s, :string)
+        end.join(', ')
+
+        "#<#{object.class} #{object.name.ai} (#{values})>"
+      end
+
+      def awesome_dbschema_create_table(object)
+        data = ["fields: #{object.fields.ai}"]
+        data << "indices: #{object.indices.ai}" if object.indices.any?
+        data << "checks: #{object.checks.ai}" if object.checks.any?
+
+        data_string = indent_lines(data.join(', '))
+        "#<DbSchema::Changes::CreateTable #{object.name.ai} #{data_string}>"
+      end
+
+      def awesome_dbschema_drop_table(object)
+        "#<DbSchema::Changes::DropTable #{object.name.ai}>"
+      end
+
+      def awesome_dbschema_alter_table(object)
+        data = ["fields: #{object.fields.ai}"]
+        data << "indices: #{object.indices.ai}" if object.indices.any?
+        data << "checks: #{object.checks.ai}" if object.checks.any?
+
+        data_string = indent_lines(data.join(', '))
+        "#<DbSchema::Changes::AlterTable #{object.name.ai} #{data_string}>"
+      end
+
+      def awesome_dbschema_create_column(object)
+        "#<DbSchema::Changes::CreateColumn #{object.field.ai}>"
+      end
+
+      def awesome_dbschema_drop_column(object)
+        "#<DbSchema::Changes::DropColumn #{object.name.ai}>"
+      end
+
+      def awesome_dbschema_rename_column(object)
+        "#<DbSchema::Changes::RenameColumn #{object.old_name.ai} => #{object.new_name.ai}>"
+      end
+
+      def awesome_dbschema_alter_column_type(object)
+        attributes = object.new_attributes.map do |k, v|
+          key = colorize("#{k}:", :symbol)
+          "#{key} #{v.ai}"
+        end.unshift(nil).join(', ')
+
+        "#<DbSchema::Changes::AlterColumnType #{object.name.ai}, #{object.new_type.ai}#{attributes}>"
+      end
+
+      def awesome_dbschema_alter_column_default(object)
+        "#<DbSchema::Changes::AlterColumnDefault #{object.name.ai}, #{object.new_default.ai}>"
+      end
+
+      def awesome_dbschema_create_foreign_key(object)
+        "#<DbSchema::Changes::CreateForeignKey #{object.foreign_key.ai} on #{object.table_name.ai}>"
+      end
+
+      def awesome_dbschema_drop_foreign_key(object)
+        "#<DbSchema::Changes::DropForeignKey #{object.fkey_name.ai} on #{object.table_name.ai}>"
+      end
+
+      def awesome_dbschema_column_operation(object)
+        "#<#{object.class} #{object.name.ai}>"
+      end
+
+      def awesome_dbschema_add_value_to_enum(object)
+        before = " before #{object.before.ai}" unless object.add_to_the_end?
+
+        "#<DbSchema::Changes::AddValueToEnum #{object.new_value.ai} to #{object.enum_name.ai}#{before}>"
+      end
+
+      def format_dbschema_fields(fields)
+        if fields.one?
+          fields.first.ai
+        else
+          '[' + fields.map(&:ai).join(', ') + ']'
+        end
+      end
+
+      def indent_lines(text, indent_level = 4)
+        text.gsub(/(?<!\A)^/, ' ' * indent_level)
+      end
+    end
+  end
+
+  AwesomePrint::Formatter.send(:include, AwesomePrint::DbSchema)
+end

data/lib/db_schema/changes.rb

@@ -0,0 +1,396 @@
+require 'db_schema/definitions'
+require 'dry/equalizer'
+
+module DbSchema
+  module Changes
+    class << self
+      def between(desired_schema, actual_schema)
+        desired_tables = extract_tables(desired_schema)
+        actual_tables  = extract_tables(actual_schema)
+
+        table_names = [desired_tables, actual_tables].flatten.map(&:name).uniq
+
+        table_changes = table_names.each.with_object([]) do |table_name, changes|
+          desired = desired_tables.find { |table| table.name == table_name }
+          actual  = actual_tables.find  { |table| table.name == table_name }
+
+          if desired && !actual
+            changes << CreateTable.new(
+              table_name,
+              fields:  desired.fields,
+              indices: desired.indices,
+              checks:  desired.checks
+            )
+
+            fkey_operations = desired.foreign_keys.map do |fkey|
+              CreateForeignKey.new(table_name, fkey)
+            end
+            changes.concat(fkey_operations)
+          elsif actual && !desired
+            changes << DropTable.new(table_name)
+
+            actual.foreign_keys.each do |fkey|
+              changes << DropForeignKey.new(table_name, fkey.name)
+            end
+          elsif actual != desired
+            field_operations = field_changes(desired.fields, actual.fields)
+            index_operations = index_changes(desired.indices, actual.indices)
+            check_operations = check_changes(desired.checks, actual.checks)
+            fkey_operations  = foreign_key_changes(table_name, desired.foreign_keys, actual.foreign_keys)
+
+            if field_operations.any? || index_operations.any? || check_operations.any?
+              changes << AlterTable.new(
+                table_name,
+                fields:  field_operations,
+                indices: index_operations,
+                checks:  check_operations
+              )
+            end
+
+            changes.concat(fkey_operations)
+          end
+        end
+
+        desired_enums = extract_enums(desired_schema)
+        actual_enums  = extract_enums(actual_schema)
+
+        enum_names = [desired_enums, actual_enums].flatten.map(&:name).uniq
+
+        enum_changes = enum_names.each_with_object([]) do |enum_name, changes|
+          desired = desired_enums.find { |enum| enum.name == enum_name }
+          actual  = actual_enums.find  { |enum| enum.name == enum_name }
+
+          if desired && !actual
+            changes << CreateEnum.new(enum_name, desired.values)
+          elsif actual && !desired
+            changes << DropEnum.new(enum_name)
+          elsif actual != desired
+            new_values     = desired.values - actual.values
+            dropped_values = actual.values - desired.values
+
+            if dropped_values.any?
+              raise UnsupportedOperation, "Enum #{enum_name.inspect} doesn't describe values #{dropped_values.inspect} that are present in the database; dropping values from enums is not supported."
+            end
+
+            if desired.values - new_values != actual.values
+              raise UnsupportedOperation, "Enum #{enum_name.inspect} describes values #{(desired.values - new_values).inspect} that are present in the database in a different order (#{actual.values.inspect}); reordering values in enums is not supported."
+            end
+
+            new_values.reverse.each do |value|
+              value_index = desired.values.index(value)
+
+              if value_index == desired.values.count - 1
+                changes << AddValueToEnum.new(enum_name, value)
+              else
+                next_value = desired.values[value_index + 1]
+                changes << AddValueToEnum.new(enum_name, value, before: next_value)
+              end
+            end
+          end
+        end
+
+        table_changes + enum_changes
+      end
+
+    private
+      def field_changes(desired_fields, actual_fields)
+        field_names = [desired_fields, actual_fields].flatten.map(&:name).uniq
+
+        field_names.each.with_object([]) do |field_name, table_changes|
+          desired = desired_fields.find { |field| field.name == field_name }
+          actual  = actual_fields.find  { |field| field.name == field_name }
+
+          if desired && !actual
+            table_changes << CreateColumn.new(desired)
+          elsif actual && !desired
+            table_changes << DropColumn.new(field_name)
+          elsif actual != desired
+            if (actual.type != desired.type) || (actual.attributes != desired.attributes)
+              table_changes << AlterColumnType.new(
+                field_name,
+                new_type: desired.type,
+                **desired.attributes
+              )
+            end
+
+            if desired.primary_key? && !actual.primary_key?
+              table_changes << CreatePrimaryKey.new(field_name)
+            end
+
+            if actual.primary_key? && !desired.primary_key?
+              table_changes << DropPrimaryKey.new(field_name)
+            end
+
+            if desired.null? && !actual.null?
+              table_changes << AllowNull.new(field_name)
+            end
+
+            if actual.null? && !desired.null?
+              table_changes << DisallowNull.new(field_name)
+            end
+
+            if actual.default != desired.default
+              table_changes << AlterColumnDefault.new(field_name, new_default: desired.default)
+            end
+          end
+        end
+      end
+
+      def index_changes(desired_indices, actual_indices)
+        index_names = [desired_indices, actual_indices].flatten.map(&:name).uniq
+
+        index_names.each.with_object([]) do |index_name, table_changes|
+          desired = desired_indices.find { |index| index.name == index_name }
+          actual  = actual_indices.find  { |index| index.name == index_name }
+
+          if desired && !actual
+            table_changes << CreateIndex.new(
+              name:      index_name,
+              fields:    desired.fields,
+              unique:    desired.unique?,
+              type:      desired.type,
+              condition: desired.condition
+            )
+          elsif actual && !desired
+            table_changes << DropIndex.new(index_name)
+          elsif actual != desired
+            table_changes << DropIndex.new(index_name)
+            table_changes << CreateIndex.new(
+              name:      index_name,
+              fields:    desired.fields,
+              unique:    desired.unique?,
+              type:      desired.type,
+              condition: desired.condition
+            )
+          end
+        end
+      end
+
+      def check_changes(desired_checks, actual_checks)
+        check_names = [desired_checks, actual_checks].flatten.map(&:name).uniq
+
+        check_names.each.with_object([]) do |check_name, table_changes|
+          desired = desired_checks.find { |check| check.name == check_name }
+          actual  = actual_checks.find  { |check| check.name == check_name }
+
+          if desired && !actual
+            table_changes << CreateCheckConstraint.new(
+              name:      check_name,
+              condition: desired.condition
+            )
+          elsif actual && !desired
+            table_changes << DropCheckConstraint.new(check_name)
+          elsif actual != desired
+            table_changes << DropCheckConstraint.new(check_name)
+            table_changes << CreateCheckConstraint.new(
+              name:      check_name,
+              condition: desired.condition
+            )
+          end
+        end
+      end
+
+      def foreign_key_changes(table_name, desired_foreign_keys, actual_foreign_keys)
+        key_names = [desired_foreign_keys, actual_foreign_keys].flatten.map(&:name).uniq
+
+        key_names.each.with_object([]) do |key_name, table_changes|
+          desired = desired_foreign_keys.find { |key| key.name == key_name }
+          actual  = actual_foreign_keys.find  { |key| key.name == key_name }
+
+          foreign_key = Definitions::ForeignKey.new(
+            name:       key_name,
+            fields:     desired.fields,
+            table:      desired.table,
+            keys:       desired.keys,
+            on_delete:  desired.on_delete,
+            on_update:  desired.on_update,
+            deferrable: desired.deferrable?
+          ) if desired
+
+          if desired && !actual
+            table_changes << CreateForeignKey.new(table_name, foreign_key)
+          elsif actual && !desired
+            table_changes << DropForeignKey.new(table_name, key_name)
+          elsif actual != desired
+            table_changes << DropForeignKey.new(table_name, key_name)
+            table_changes << CreateForeignKey.new(table_name, foreign_key)
+          end
+        end
+      end
+
+      def extract_tables(schema)
+        Utils.filter_by_class(schema, Definitions::Table)
+      end
+
+      def extract_enums(schema)
+        Utils.filter_by_class(schema, Definitions::Enum)
+      end
+    end
+
+    class CreateTable
+      include Dry::Equalizer(:name, :fields, :indices, :checks)
+      attr_reader :name, :fields, :indices, :checks
+
+      def initialize(name, fields: [], indices: [], checks: [])
+        @name    = name
+        @fields  = fields
+        @indices = indices
+        @checks  = checks
+      end
+    end
+
+    class DropTable
+      include Dry::Equalizer(:name)
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+    end
+
+    class AlterTable
+      include Dry::Equalizer(:name, :fields, :indices, :checks)
+      attr_reader :name, :fields, :indices, :checks
+
+      def initialize(name, fields: [], indices: [], checks: [])
+        @name    = name
+        @fields  = fields
+        @indices = indices
+        @checks  = checks
+      end
+    end
+
+    # Abstract base class for single-column toggle operations.
+    class ColumnOperation
+      include Dry::Equalizer(:name)
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+    end
+
+    class CreateColumn
+      include Dry::Equalizer(:field)
+      attr_reader :field
+
+      def initialize(field)
+        @field = field
+      end
+
+      def name
+        field.name
+      end
+
+      def type
+        field.type
+      end
+
+      def primary_key?
+        field.primary_key?
+      end
+
+      def options
+        field.options
+      end
+    end
+
+    class DropColumn < ColumnOperation
+    end
+
+    class RenameColumn
+      attr_reader :old_name, :new_name
+
+      def initialize(old_name:, new_name:)
+        @old_name = old_name
+        @new_name = new_name
+      end
+    end
+
+    class AlterColumnType
+      include Dry::Equalizer(:name, :new_type, :new_attributes)
+      attr_reader :name, :new_type, :new_attributes
+
+      def initialize(name, new_type:, **new_attributes)
+        @name           = name
+        @new_type       = new_type
+        @new_attributes = new_attributes
+      end
+    end
+
+    class CreatePrimaryKey < ColumnOperation
+    end
+
+    class DropPrimaryKey < ColumnOperation
+    end
+
+    class AllowNull < ColumnOperation
+    end
+
+    class DisallowNull < ColumnOperation
+    end
+
+    class AlterColumnDefault
+      include Dry::Equalizer(:name, :new_default)
+      attr_reader :name, :new_default
+
+      def initialize(name, new_default:)
+        @name        = name
+        @new_default = new_default
+      end
+    end
+
+    class CreateIndex < Definitions::Index
+    end
+
+    class DropIndex < ColumnOperation
+    end
+
+    class CreateCheckConstraint < Definitions::CheckConstraint
+    end
+
+    class DropCheckConstraint < ColumnOperation
+    end
+
+    class CreateForeignKey
+      include Dry::Equalizer(:table_name, :foreign_key)
+      attr_reader :table_name, :foreign_key
+
+      def initialize(table_name, foreign_key)
+        @table_name  = table_name
+        @foreign_key = foreign_key
+      end
+    end
+
+    class DropForeignKey
+      include Dry::Equalizer(:table_name, :fkey_name)
+      attr_reader :table_name, :fkey_name
+
+      def initialize(table_name, fkey_name)
+        @table_name = table_name
+        @fkey_name  = fkey_name
+      end
+    end
+
+    class CreateEnum < Definitions::Enum
+    end
+
+    class DropEnum < ColumnOperation
+    end
+
+    class AddValueToEnum
+      include Dry::Equalizer(:enum_name, :new_value, :before)
+      attr_reader :enum_name, :new_value, :before
+
+      def initialize(enum_name, new_value, before: nil)
+        @enum_name = enum_name
+        @new_value = new_value
+        @before    = before
+      end
+
+      def add_to_the_end?
+        before.nil?
+      end
+    end
+  end
+end