schema_ferry 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: aacec6bc39b272cc96454401749eea5b880bb7c3a3d08e4666927f00f92d0379
+  data.tar.gz: eb407968fdbb8b848a1c4f942fb824cef3a80a063a1effb81bf02389342a69ce
+SHA512:
+  metadata.gz: 2e4663eb185b31ab7724e574c01c9b23fb49b8844a3e20bcebcba2ebc467d1abe8b8e7e7272fa73b0cf122f4a74cc6433811b4598a328b8847edad41b73963ae
+  data.tar.gz: db642c4079f769cc430a79bbe7174a4dd1b13b89000bfcdc0ae9b4ce3e47c29e57db2c756820c543ab06531b3ce6a430f90861d8ed70a46c91bc7bc2f1d82b82

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 kyuuri1791
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,202 @@
+# schema_ferry
+
+You're migrating a production MySQL database to PostgreSQL. Moving the data takes days or weeks — and meanwhile, developers keep shipping schema changes to MySQL. schema_ferry is a Ruby gem that keeps the PostgreSQL schema continuously in sync until cutover, driven by a declarative DSL.
+
+- **Incremental by design** — if the source schema changes mid-migration, just run it again; no manual diffing needed
+- **Sensible defaults, fully customizable** — built-in type mappings handle most cases; override anything with a few DSL rules
+- **Safe to iterate** — `dry_run` shows the exact changes that would be applied, before touching anything
+
+schema_ferry is designed to run repeatedly (e.g. via cron). Data migration is out of scope — pair it with [pgloader](https://pgloader.io/) (one-shot bulk copy) or CDC replication (AWS DMS, [Debezium](https://debezium.io/), …), which load rows into the tables schema_ferry has created.
+
+## Requirements
+
+- Ruby >= 3.1
+- ActiveRecord >= 7.1
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "schema_ferry"
+```
+
+```bash
+bundle install
+```
+
+## Usage
+
+### Basic
+
+```ruby
+require "schema_ferry"
+
+pipeline = SchemaFerry.define do
+  source "mysql2://user:password@host:3306/source_db"
+  target "postgresql://user:password@host:5432/target_db"
+end
+
+pipeline.dry_run  # returns the changes that would be applied, without applying them
+pipeline.apply!   # applies the schema to PostgreSQL
+```
+
+There is also `pipeline.schemafile`, which returns the generated schema as a string without connecting to the target.
+
+`apply!` makes the target match the generated schema — including **dropping** columns and indexes that are not part of it. Before running against a target that holds data, read [Destructive changes](#destructive-changes) below.
+
+### CLI
+
+For cron jobs — or whenever you'd rather not write a runner script — there is a small CLI. Put the same DSL (without the `SchemaFerry.define` wrapper) in a `Ferryfile`:
+
+```ruby
+source "mysql2://user:password@host:3306/source_db"
+target "postgresql://user:password@host:5432/target_db"
+```
+
+Then:
+
+```bash
+schema_ferry dry-run                     # show what would change (reads ./Ferryfile)
+schema_ferry apply                       # apply to PostgreSQL
+schema_ferry apply -c path/to/Ferryfile  # explicit definition file path
+```
+
+Each command prints the changes it applied (or would apply) followed by a one-line summary (`118 tables synced, 3 changes applied`). The exit status is 0 on success and 1 on any error, so cron mail and monitoring can rely on it.
+
+### Custom conversion rules
+
+```ruby
+pipeline = SchemaFerry.define do
+  source "mysql2://user:password@host:3306/source_db"
+  target "postgresql://user:password@host:5432/target_db"
+
+  map_type :datetime, to: :timestamptz # override a default mapping (datetime → timestamp) globally
+  map_type :json, to: :json            # e.g. opt out of the default json → jsonb conversion
+
+  table :users do
+    map_column :is_admin, type: :boolean # override a specific column's type
+    ignore_column :legacy_field          # exclude a column
+    ignore_index :idx_old_legacy         # exclude an index
+  end
+
+  ignore_table :old_sessions  # exclude an entire table
+end
+```
+
+The same rules work in a CLI definition file.
+
+### Destructive changes
+
+`apply!` delegates to [ridgepole](https://github.com/ridgepole/ridgepole), which makes the target match the generated schema. For tables it manages, **columns and indexes that are missing from the generated schema are dropped from the target** (e.g. a column excluded via `ignore_column`, or an index created by hand on the target — declare those with `add_index` instead). Tables absent from the generated schema are themselves left untouched.
+
+Review `dry_run` output before your first `apply!` and whenever you change the conversion rules — those are the moments that introduce drops. Unattended runs in between only mirror changes made to the MySQL schema; if even those need review, schedule `dry-run` instead and apply by hand.
+
+## DSL reference
+
+### Top-level
+
+| Method | Description |
+|---|---|
+| `source "mysql2://..."` | Source MySQL connection string |
+| `target "postgresql://..."` | Target PostgreSQL connection string |
+| `map_type :from, to: :to` | Override a type globally (e.g. `map_type :datetime, to: :timestamptz`) |
+| `enum_as :check` | Convert enum columns to varchar **plus a CHECK constraint** (default `:string` = plain varchar) |
+| `ignore_table :name` | Exclude a table from conversion |
+| `table :name do ... end` | Define per-table rules |
+
+### Inside a `table` block
+
+| Method | Description |
+|---|---|
+| `map_column :col, type: :type` | Override a column's type |
+| `map_column :col, type: :type, default: value` | …and give it an explicit default |
+| `ignore_column :col` | Exclude a column |
+| `ignore_index :index_name` | Exclude an index |
+| `add_index :col, ...options` | Declare a PostgreSQL-only index (options: `name`, `unique`, `using`, `opclass`, `where`, `order`) |
+
+Ignoring a column also drops indexes and foreign keys that reference it. Renaming tables or columns is out of scope — clean up names after the cutover with a regular migration.
+
+**tinyint(1) caveat:** ActiveRecord reads `tinyint(1)` as boolean, including its default (`DEFAULT 2` is read as `true`). If a `tinyint(1)` column actually holds 0/1/2-style values, override both the type and the default: `map_column :flags, type: :integer, default: 2`. Without an explicit default, schema_ferry drops the unreliable boolean default and warns.
+
+## Default type mapping
+
+| MySQL | PostgreSQL | Notes |
+|---|---|---|
+| `VARCHAR(n)` / `CHAR(n)` | `varchar(n)` | length preserved |
+| `TEXT` / `MEDIUMTEXT` / `LONGTEXT` | `text` | size classes dropped — PostgreSQL `text` is unbounded |
+| `TINYINT(1)` | `boolean` | see the caveat above if a column holds more than 0/1 |
+| `TINYINT`…`BIGINT` (signed) | `smallint` / `integer` / `bigint` | widths normalized to PostgreSQL's three integer sizes |
+| `TINYINT`…`INT` `UNSIGNED` | one size larger | e.g. `INT UNSIGNED` → `bigint` |
+| `BIGINT UNSIGNED` | `numeric(20)` | PostgreSQL has no unsigned 8-byte integer; emitted with a warning |
+| `FLOAT` / `DOUBLE` | `double precision` | |
+| `DECIMAL(p,s)` | `numeric(p,s)` | |
+| `DATETIME` / `TIMESTAMP` | `timestamp` | use `map_type :datetime, to: :timestamptz` for `timestamptz` |
+| `DATE` / `TIME` | `date` / `time` | |
+| `BINARY` / `BLOB` family | `bytea` | |
+| `JSON` | `jsonb` | opt out with `map_type :json, to: :json` |
+| `ENUM(...)` | `varchar` | add `enum_as :check` to enforce the values with a CHECK constraint |
+
+`map_type` / `map_column` take Rails-style abstract type symbols (`:string`, `:integer`, `:jsonb`, …), not raw SQL type names.
+
+### Automatic adjustments (with warnings)
+
+Some MySQL constructs have no PostgreSQL equivalent. schema_ferry handles them and prints a `[schema_ferry]` warning to stderr:
+
+- **FULLTEXT / SPATIAL indexes** are skipped. Declare a replacement with `add_index` (e.g. `add_index :body, using: :gin, opclass: :gin_trgm_ops` — requires `CREATE EXTENSION pg_trgm` on the target, done once by hand) and silence the warning with `ignore_index`. Don't create replacement indexes by hand: anything not in the generated schema is dropped on the next run.
+- **Index prefix lengths** (`KEY (col(10))`) are dropped silently — PostgreSQL indexes the full column.
+- **Identifiers over 63 bytes** (MySQL allows 64): index and foreign key names are shortened deterministically (`first 54 bytes + _ + 8-char digest`), so repeated runs stay stable. Overlong table names are only warned about — rename those yourself.
+- **Zero-date defaults** (`'0000-00-00 00:00:00'`) are invalid in PostgreSQL and are dropped.
+
+## How it works
+
+Each run executes a three-stage pipeline:
+
+```
+MySQL schema
+     │
+     │  1. Read (ActiveRecord)
+     ▼
+table definitions
+     │
+     │  2. Convert (default mappings + your DSL rules)
+     ▼
+Schemafile
+     │
+     │  3. Apply (ridgepole, diff only)
+     ▼
+PostgreSQL schema
+```
+
+1. **Read** — connects to MySQL and reads table definitions (columns, indexes, foreign keys) via ActiveRecord, using a connection pool isolated from any host Rails app
+2. **Convert** — applies the default type mappings and your custom rules to build a PostgreSQL-ready schema
+3. **Apply** — renders the schema as a [ridgepole](https://github.com/ridgepole/ridgepole) Schemafile and runs `ridgepole --apply` (or `--dry-run`) against the target database. ridgepole compares the declared schema with the target's current state and applies only the difference — that diffing is what makes runs incremental and idempotent, so schema_ferry never has to track what it applied before
+
+## Development
+
+```bash
+bundle install
+bundle exec rubocop
+```
+
+### Unit tests
+
+Cover the DSL, conversion rules, and schema rendering. No database needed:
+
+```bash
+bundle exec rspec spec/lib/
+```
+
+### Integration tests
+
+Run the full pipeline against real MySQL and PostgreSQL containers:
+
+```bash
+docker compose up -d --wait
+INTEGRATION=true bundle exec rspec spec/integration/
+docker compose down
+```
+
+## License
+
+[MIT License](https://opensource.org/licenses/MIT)

data/exe/schema_ferry

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "schema_ferry"
+require "schema_ferry/cli"
+
+exit SchemaFerry::CLI.new.run(ARGV)

data/lib/schema_ferry/cli.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module SchemaFerry
+  # Minimal command-line interface: `schema_ferry <apply|dry-run> [-c FILE]`.
+  # #run returns a process exit code instead of calling Kernel#exit so the
+  # class stays testable.
+  class CLI
+    DEFAULT_CONFIG_PATH = "Ferryfile"
+    COMMANDS = %w[apply dry-run].freeze
+
+    def initialize(stdout: $stdout, stderr: $stderr)
+      @stdout = stdout
+      @stderr = stderr
+    end
+
+    def run(argv)
+      args = parser.parse(argv)
+      return print_and_succeed(parser.to_s) if @mode == :help
+      return print_and_succeed(VERSION) if @mode == :version
+
+      command = args.first
+      return usage_error("missing command") if command.nil?
+      return usage_error("unknown command: #{command}") unless COMMANDS.include?(command)
+
+      run_command(command)
+    rescue Error, OptionParser::ParseError => e
+      @stderr.puts "schema_ferry: #{e.message}"
+      1
+    end
+
+    private
+
+    def run_command(command)
+      config     = load_config
+      schemafile = Pipeline.new(config).schemafile
+      dry_run    = command == "dry-run"
+      output     = Target::RidgepoleRunner.new(config.target_url).run(schemafile, dry_run: dry_run)
+
+      @stdout.puts output
+      @stdout.puts summary(schemafile, output, dry_run: dry_run)
+      0
+    end
+
+    def summary(schemafile, output, dry_run:)
+      tables  = schemafile.scan(/^create_table /).count
+      changes = count_changes(output)
+      detail  =
+        if changes.zero?
+          "no changes"
+        else
+          "#{changes} #{pluralize(changes, "change")} #{dry_run ? "pending" : "applied"}"
+        end
+      "#{tables} #{pluralize(tables, "table")} #{dry_run ? "checked" : "synced"}, #{detail}"
+    end
+
+    # `--apply` echoes each executed operation as a "-- op(...)" line;
+    # `--dry-run` prints the pending operations as top-level DSL calls.
+    def count_changes(output)
+      return 0 if output.include?("No change")
+
+      applied = output.scan(/^-- /).count
+      applied.positive? ? applied : output.scan(/^\w+\(/).count
+    end
+
+    def pluralize(count, word)
+      count == 1 ? word : "#{word}s"
+    end
+
+    def load_config
+      path = @config_path || DEFAULT_CONFIG_PATH
+      raise ConfigError, "definition file not found: #{path}" unless File.exist?(path)
+
+      DSL::Config.load_file(path)
+    end
+
+    def parser
+      @parser ||= OptionParser.new do |o|
+        o.banner = "Usage: schema_ferry <apply|dry-run> [options]"
+        o.on("-c", "--config FILE", "Definition file (default: #{DEFAULT_CONFIG_PATH})") { |v| @config_path = v }
+        o.on("-h", "--help", "Show this help") { @mode = :help }
+        o.on("--version", "Show version") { @mode = :version }
+      end
+    end
+
+    def print_and_succeed(text)
+      @stdout.puts text
+      0
+    end
+
+    def usage_error(message)
+      @stderr.puts "schema_ferry: #{message}"
+      @stderr.puts parser
+      1
+    end
+  end
+end

data/lib/schema_ferry/converter/column_converter.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module SchemaFerry
+  module Converter
+    class ColumnConverter
+      include Warnings
+
+      # PG has no unsigned integers: bump to the next size that holds the full
+      # unsigned range. Keys/values are AR byte limits.
+      UNSIGNED_LIMIT_BUMP = { 1 => 2, 2 => 4, 3 => 4, 4 => 8 }.freeze
+
+      def initialize(type_mapper)
+        @type_mapper = type_mapper
+      end
+
+      def call(raw, table_name, rule)
+        raw      = bump_unsigned_integer(raw)
+        raw      = drop_zero_date_default(raw, table_name)
+        override = rule&.column_type_overrides&.[](raw[:name])
+        col_opts = raw.slice(:limit, :precision, :scale, :null, :default, :default_function, :comment)
+
+        if override
+          col_opts[:default] = override_default(raw, rule, override)
+          ColumnSchema.new(name: raw[:name], type: override, **col_opts)
+        else
+          pg_type, pg_opts = @type_mapper.call(raw[:type], col_opts)
+          ColumnSchema.new(name: raw[:name], type: pg_type, **pg_opts)
+        end
+      end
+
+      private
+
+      def bump_unsigned_integer(raw)
+        return raw unless raw[:type] == :integer && raw[:sql_type].to_s.include?("unsigned")
+
+        if raw[:limit] == 8
+          emit_warning "column #{raw[:name].inspect}: BIGINT UNSIGNED has no PostgreSQL " \
+                       "integer equivalent; mapped to decimal(20, 0)."
+          raw.merge(type: :decimal, limit: nil, precision: 20, scale: 0)
+        else
+          raw.merge(limit: UNSIGNED_LIMIT_BUMP.fetch(raw[:limit], raw[:limit]))
+        end
+      end
+
+      # MySQL zero dates ('0000-00-00' …) are invalid on PostgreSQL. AR already
+      # nils out zero DATE defaults, but zero DATETIME defaults come through as
+      # strings.
+      def drop_zero_date_default(raw, table_name)
+        return raw unless raw[:default].is_a?(String) && raw[:default].start_with?("0000-00-00")
+
+        emit_warning "#{table_name}.#{raw[:name]}: default #{raw[:default].inspect} is " \
+                     "invalid on PostgreSQL; the default was dropped."
+        raw.merge(default: nil)
+      end
+
+      # AR reads tinyint(1) defaults as booleans (DEFAULT 2 becomes true), so a
+      # default is unreliable once the type is overridden away from :boolean.
+      def override_default(raw, rule, override)
+        defaults = rule.column_default_overrides
+        return defaults[raw[:name]] if defaults.key?(raw[:name])
+
+        default = raw[:default]
+        if [true, false].include?(default) && override != :boolean
+          emit_warning "#{rule.table_name}.#{raw[:name]}: dropping default #{default.inspect} — " \
+                       "MySQL reported a tinyint(1) default as boolean, which is unreliable under " \
+                       "a type override. Restore it explicitly: " \
+                       "map_column :#{raw[:name]}, type: :#{override}, default: <value>"
+          return nil
+        end
+        default
+      end
+    end
+  end
+end

data/lib/schema_ferry/converter/enum_check_builder.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module SchemaFerry
+  module Converter
+    # Builds CHECK constraints enforcing MySQL enum values on varchar columns
+    # (enum_as :check).
+    class EnumCheckBuilder
+      def call(raw_table, rule, ignored)
+        raw_table[:columns].filter_map do |col|
+          next if ignored.include?(col[:name])
+          # A type override takes the column away from varchar; the caller owns
+          # any constraint then.
+          next if rule&.column_type_overrides&.key?(col[:name])
+
+          values = enum_values(col[:sql_type])
+          next if values.nil?
+
+          build_constraint(raw_table[:name], col[:name], values)
+        end
+      end
+
+      private
+
+      def build_constraint(table_name, col_name, values)
+        CheckConstraintSchema.new(
+          expression: expression(col_name, values),
+          name:       IdentifierShortener.shorten("chk_#{table_name}_#{col_name}",
+                                                  kind: "check constraint", table: table_name)
+        )
+      end
+
+      # "enum('a','b')" → ["a", "b"] (values keep MySQL's quote escaping).
+      def enum_values(sql_type)
+        return nil unless sql_type.to_s.start_with?("enum(")
+
+        sql_type.scan(/'((?:[^']|'')*)'/).flatten
+      end
+
+      # PG stores CHECK expressions normalized; this is the fixed point of that
+      # normalization for a varchar column (verified on PG 16). Anything else —
+      # e.g. "kind IN ('a', 'b')" — makes ridgepole re-create it on every run.
+      def expression(column, values)
+        list = values.map { |v| "'#{v}'::character varying::text" }.join(", ")
+        "#{column}::text = ANY (ARRAY[#{list}])"
+      end
+    end
+  end
+end

data/lib/schema_ferry/converter/identifier_shortener.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module SchemaFerry
+  module Converter
+    # PostgreSQL truncates identifiers to 63 bytes (MySQL allows 64). A silently
+    # truncated index name makes ridgepole see a diff on every run, so names that
+    # would overflow are shortened deterministically instead.
+    module IdentifierShortener
+      extend Warnings
+
+      MAX_BYTES   = 63
+      HASH_LENGTH = 8
+
+      module_function
+
+      def shorten(name, kind:, table:)
+        return name if name.nil? || name.bytesize <= MAX_BYTES
+
+        prefix = name.byteslice(0, MAX_BYTES - HASH_LENGTH - 1)
+        short  = "#{prefix}_#{Digest::MD5.hexdigest(name)[0, HASH_LENGTH]}"
+        emit_warning "#{table}: #{kind} name #{name.inspect} exceeds PostgreSQL's " \
+                     "#{MAX_BYTES}-byte identifier limit; renamed to #{short.inspect}."
+        short
+      end
+
+      def warn_long_table_name(name)
+        return if name.bytesize <= MAX_BYTES
+
+        emit_warning "table name #{name.inspect} exceeds PostgreSQL's #{MAX_BYTES}-byte " \
+                     "identifier limit and will be truncated by PostgreSQL. Rename the " \
+                     "table before applying to avoid ridgepole re-creating it on every run."
+      end
+    end
+  end
+end

data/lib/schema_ferry/converter/schema_converter.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module SchemaFerry
+  module Converter
+    class SchemaConverter
+      include Warnings
+
+      # PostgreSQL has no FULLTEXT/SPATIAL equivalent that ridgepole can express.
+      UNSUPPORTED_INDEX_TYPES = %i[fulltext spatial].freeze
+
+      def initialize(config)
+        @column_converter = ColumnConverter.new(TypeMapper.new(config.global_type_overrides))
+        @table_rules      = config.table_rules
+        @ignored_tables   = config.ignored_tables
+        @enum_check       = (EnumCheckBuilder.new if config.enum_mode == :check)
+      end
+
+      def convert(raw_tables)
+        raw_tables
+          .reject { |t| @ignored_tables.include?(t[:name]) }
+          .map    { |t| convert_table(t) }
+      end
+
+      private
+
+      def convert_table(raw)
+        rule    = @table_rules[raw[:name]]
+        ignored = rule&.ignored_columns || []
+        IdentifierShortener.warn_long_table_name(raw[:name])
+
+        TableSchema.new(
+          name:              raw[:name],
+          primary_key:       raw[:primary_key],
+          pk_type:           convert_pk_type(raw),
+          pk_limit:          raw[:pk_limit],
+          comment:           raw[:comment],
+          columns:           convert_columns(raw[:columns], raw[:name], rule, ignored),
+          indexes:           convert_indexes(raw[:indexes], raw[:name], rule, ignored),
+          foreign_keys:      convert_foreign_keys(raw[:foreign_keys], ignored),
+          check_constraints: build_check_constraints(raw, rule, ignored)
+        )
+      end
+
+      # MySQL BIGINT comes through AR as :integer with limit 8, so the sql_type
+      # is the only reliable source for the id: option.
+      def convert_pk_type(raw)
+        return raw[:pk_type] unless raw[:pk_type] == :integer
+
+        sql_type = raw[:pk_sql_type].to_s
+        if sql_type.include?("unsigned")
+          if sql_type.start_with?("bigint")
+            emit_warning "table #{raw[:name]}: BIGINT UNSIGNED primary key has no PostgreSQL " \
+                         "equivalent; using signed bigint (values above 2^63-1 will not fit)."
+          end
+          :bigint
+        elsif sql_type.start_with?("bigint")
+          :bigint
+        else
+          :integer
+        end
+      end
+
+      def convert_columns(raw_columns, table_name, rule, ignored)
+        raw_columns
+          .reject { |c| ignored.include?(c[:name]) }
+          .map    { |c| @column_converter.call(c, table_name, rule) }
+      end
+
+      def convert_indexes(raw_indexes, table_name, rule, ignored)
+        converted = raw_indexes
+                    .reject { |idx| rule&.ignored_indexes&.include?(idx[:name]) }
+                    .reject { |idx| skip_unsupported_index?(idx, table_name) }
+                    .reject { |idx| idx[:columns].intersect?(ignored) }
+                    .map    { |idx| build_index_schema(idx, table_name) }
+        converted + extra_indexes(rule, table_name)
+      end
+
+      def extra_indexes(rule, table_name)
+        (rule&.extra_indexes || []).map do |extra|
+          opts = extra[:options]
+          name = opts[:name] || "index_#{table_name}_on_#{extra[:columns].join("_")}"
+          IndexSchema.new(
+            name:    IdentifierShortener.shorten(name.to_s, kind: "index", table: table_name),
+            columns: extra[:columns],
+            unique:  opts[:unique],
+            using:   opts[:using],
+            opclass: opts[:opclass],
+            where:   opts[:where],
+            orders:  opts[:order],
+            lengths: nil
+          )
+        end
+      end
+
+      def convert_foreign_keys(raw_fkeys, ignored)
+        raw_fkeys
+          .reject { |fk| @ignored_tables.include?(fk[:to_table]) }
+          .reject { |fk| ignored.include?(fk[:column]) }
+          .map    { |fk| build_fk_schema(fk) }
+      end
+
+      def skip_unsupported_index?(idx, table_name)
+        return false unless UNSUPPORTED_INDEX_TYPES.include?(idx[:type])
+
+        emit_warning "#{table_name}: skipping #{idx[:type].to_s.upcase} index #{idx[:name].inspect} " \
+                     "(no PostgreSQL equivalent). Declare a replacement with add_index " \
+                     "(e.g. add_index :col, using: :gin, opclass: :gin_trgm_ops) and " \
+                     "silence this warning with ignore_index :#{idx[:name]}."
+        true
+      end
+
+      def build_index_schema(raw, table_name)
+        IndexSchema.new(
+          name:    IdentifierShortener.shorten(raw[:name], kind: "index", table: table_name),
+          columns: raw[:columns],
+          unique:  raw[:unique],
+          using:   raw[:using],
+          opclass: nil, # MySQL has no operator classes
+          where:   raw[:where],
+          lengths: raw[:lengths],
+          orders:  raw[:orders]
+        )
+      end
+
+      def build_fk_schema(raw)
+        ForeignKeySchema.new(
+          from_table:  raw[:from_table],
+          to_table:    raw[:to_table],
+          column:      raw[:column],
+          primary_key: raw[:primary_key],
+          on_update:   raw[:on_update],
+          on_delete:   raw[:on_delete],
+          name:        IdentifierShortener.shorten(raw[:name], kind: "foreign key", table: raw[:from_table])
+        )
+      end
+
+      def build_check_constraints(raw, rule, ignored)
+        return [] unless @enum_check
+
+        @enum_check.call(raw, rule, ignored)
+      end
+    end
+  end
+end