schema_ferry 0.1.0

data/lib/schema_ferry/converter/type_mapper.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module SchemaFerry
+  module Converter
+    class TypeMapper
+      # PG has no limit concept for text/binary/bigint; drop the MySQL-derived
+      # limits.
+      LIMIT_STRIPPED_TYPES = %i[text binary bigint].freeze
+
+      # PG's default timestamp precision is 6. Spelling it out makes ridgepole
+      # see a diff against the PG export (which omits it) on every run.
+      DEFAULT_PRECISION_TYPES = %i[datetime timestamptz time].freeze
+      PG_DEFAULT_PRECISION    = 6
+
+      DEFAULTS = {
+        json: :jsonb
+      }.freeze
+
+      KNOWN_TYPES = %i[
+        string text integer bigint float decimal
+        datetime date time boolean binary json jsonb
+      ].freeze
+
+      def initialize(global_overrides = {})
+        @overrides = DEFAULTS.merge(global_overrides)
+      end
+
+      # Returns [pg_type_sym, adjusted_options_hash]
+      def call(ar_type, options = {})
+        unless KNOWN_TYPES.include?(ar_type)
+          raise ConversionError, "Unknown MySQL AR type: #{ar_type.inspect}. " \
+                                 "Use map_type or map_column to specify a PostgreSQL type."
+        end
+
+        pg_type  = @overrides.fetch(ar_type, ar_type)
+        adjusted = options.dup
+        pg_type, adjusted = normalize_integer(adjusted) if pg_type == :integer
+        adjusted.delete(:limit) if LIMIT_STRIPPED_TYPES.include?(pg_type)
+        strip_default_precision(pg_type, adjusted)
+        # PG numeric(20) equals numeric(20,0) and is exported without scale.
+        adjusted[:scale] = nil if pg_type == :decimal && adjusted[:scale]&.zero?
+
+        [pg_type, adjusted]
+      end
+
+      private
+
+      # MySQL reports every integer flavor as :integer with a byte limit; PG only
+      # has smallint(2) / integer(4) / bigint(8). Emit the shape ridgepole
+      # exports for PG so repeated runs see no diff.
+      def normalize_integer(options)
+        case options[:limit]
+        when nil  then [:integer, options]
+        when 1, 2 then [:integer, options.merge(limit: 2)]
+        when 3, 4 then [:integer, options.merge(limit: nil)]
+        else           [:bigint,  options.merge(limit: nil)]
+        end
+      end
+
+      def strip_default_precision(pg_type, options)
+        return unless DEFAULT_PRECISION_TYPES.include?(pg_type)
+
+        options[:precision] = nil if options[:precision] == PG_DEFAULT_PRECISION
+      end
+    end
+  end
+end

data/lib/schema_ferry/dsl/config.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module SchemaFerry
+  module DSL
+    class Config
+      ENUM_MODES = %i[string check].freeze
+
+      attr_reader :source_url, :target_url,
+                  :global_type_overrides,
+                  :table_rules,
+                  :ignored_tables,
+                  :enum_mode
+
+      # Evaluates a definition block and returns a validated Config.
+      def self.build(&block)
+        new.tap do |config|
+          config.instance_eval(&block)
+          config.validate!
+        end
+      end
+
+      # Evaluates a definition file (the DSL body, without the
+      # SchemaFerry.define wrapper) and returns a validated Config.
+      def self.load_file(path)
+        new.tap do |config|
+          config.instance_eval(File.read(path), path.to_s, 1)
+          config.validate!
+        end
+      end
+
+      def initialize
+        @global_type_overrides = {}
+        @table_rules           = {}
+        @ignored_tables        = []
+        @enum_mode             = :string
+      end
+
+      def source(url)
+        @source_url = url
+      end
+
+      def target(url)
+        @target_url = url
+      end
+
+      def map_type(mysql_type, to:)
+        @global_type_overrides[mysql_type.to_sym] = to.to_sym
+      end
+
+      def table(table_name, &)
+        rule = TableRule.new(table_name)
+        rule.instance_eval(&)
+        @table_rules[table_name.to_s] = rule
+      end
+
+      def ignore_table(table_name)
+        @ignored_tables << table_name.to_s
+      end
+
+      # How to convert MySQL enum columns:
+      #   :string — plain varchar, values not enforced (default)
+      #   :check  — varchar plus a CHECK constraint restricting the values
+      def enum_as(mode)
+        unless ENUM_MODES.include?(mode.to_sym)
+          raise ConfigError, "enum_as accepts #{ENUM_MODES.map(&:inspect).join(" or ")}, got #{mode.inspect}"
+        end
+
+        @enum_mode = mode.to_sym
+      end
+
+      def validate!
+        raise ConfigError, 'source is not configured. Add: source "mysql2://..."' unless @source_url
+        raise ConfigError, 'target is not configured. Add: target "postgresql://..."' unless @target_url
+      end
+    end
+  end
+end

data/lib/schema_ferry/dsl/table_rule.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module SchemaFerry
+  module DSL
+    class TableRule
+      UNSET = Object.new.freeze
+      private_constant :UNSET
+
+      EXTRA_INDEX_OPTIONS = %i[name unique using where opclass order].freeze
+
+      attr_reader :table_name, :column_type_overrides,
+                  :column_default_overrides, :ignored_columns, :ignored_indexes,
+                  :extra_indexes
+
+      def initialize(table_name)
+        @table_name               = table_name.to_s
+        @column_type_overrides    = {}
+        @column_default_overrides = {}
+        @ignored_columns          = []
+        @ignored_indexes          = []
+        @extra_indexes            = []
+      end
+
+      def map_column(column_name, type:, default: UNSET)
+        @column_type_overrides[column_name.to_s] = type.to_sym
+        @column_default_overrides[column_name.to_s] = default unless default.equal?(UNSET)
+      end
+
+      def ignore_column(column_name)
+        @ignored_columns << column_name.to_s
+      end
+
+      def ignore_index(index_name)
+        @ignored_indexes << index_name.to_s
+      end
+
+      # Declares a PostgreSQL-side index that does not exist in MySQL (e.g. a
+      # pg_trgm GIN index replacing a skipped FULLTEXT index). Declared indexes
+      # are part of the generated schema, so sync keeps them.
+      def add_index(*columns, **options)
+        unknown = options.keys - EXTRA_INDEX_OPTIONS
+        unless unknown.empty?
+          raise ConfigError, "add_index: unknown option(s) #{unknown.map(&:inspect).join(", ")} " \
+                             "(allowed: #{EXTRA_INDEX_OPTIONS.map(&:inspect).join(", ")})"
+        end
+
+        @extra_indexes << { columns: columns.map(&:to_s), options: options }
+      end
+    end
+  end
+end

data/lib/schema_ferry/errors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SchemaFerry
+  class Error               < StandardError; end
+  class ConfigError         < Error; end
+  class ConnectionError     < Error; end
+  class ReadError           < Error; end
+  class ConversionError     < Error; end
+  class RidgepoleNotFoundError < Error; end
+  class RidgepoleError < Error; end
+end

data/lib/schema_ferry/pipeline.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SchemaFerry
+  class Pipeline
+    def initialize(config)
+      @config = config
+    end
+
+    def dry_run
+      Target::RidgepoleRunner.new(@config.target_url).run(schemafile, dry_run: true)
+    end
+
+    def apply!
+      Target::RidgepoleRunner.new(@config.target_url).run(schemafile, dry_run: false)
+    end
+
+    def schemafile
+      mysql_tables = Source::MysqlReader.new(@config.source_url).read_all
+      pg_tables    = Converter::SchemaConverter.new(@config).convert(mysql_tables)
+      Target::SchemafileRenderer.new.render(pg_tables)
+    end
+  end
+end

data/lib/schema_ferry/schema_model.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module SchemaFerry
+  TableSchema = Struct.new(
+    :name,              # String
+    :primary_key,       # String | Array<String> | nil
+    :pk_type,           # Symbol: :bigint, :integer, :string, etc. (single-column PK only)
+    :pk_limit,          # Integer | nil (limit of a string PK column)
+    :comment,           # String | nil
+    :columns,           # Array<ColumnSchema>
+    :indexes,           # Array<IndexSchema>
+    :foreign_keys,      # Array<ForeignKeySchema>
+    :check_constraints, # Array<CheckConstraintSchema>
+    keyword_init: true
+  )
+
+  ColumnSchema = Struct.new(
+    :name,       # String
+    :type,       # Symbol (:string, :integer, :jsonb, …)
+    :limit,      # Integer | nil
+    :precision,  # Integer | nil
+    :scale,      # Integer | nil
+    :null,             # Boolean
+    :default,          # Object | nil
+    :default_function, # String | nil (e.g. "CURRENT_TIMESTAMP")
+    :comment,          # String | nil
+    keyword_init: true
+  )
+
+  IndexSchema = Struct.new(
+    :name,    # String
+    :columns, # Array<String>
+    :unique,  # Boolean
+    :using,   # Symbol | nil
+    :opclass, # Symbol | Hash | nil (PostgreSQL operator class, e.g. :gin_trgm_ops)
+    :where,   # String | nil
+    :lengths, # Integer | Hash | nil
+    :orders,  # Symbol | Hash | nil
+    keyword_init: true
+  )
+
+  CheckConstraintSchema = Struct.new(
+    :expression, # String (e.g. "kind IN ('a', 'b')")
+    :name,       # String
+    keyword_init: true
+  )
+
+  ForeignKeySchema = Struct.new(
+    :from_table,  # String
+    :to_table,    # String
+    :column,      # String
+    :primary_key, # String
+    :on_update,   # Symbol | nil
+    :on_delete,   # Symbol | nil
+    :name,        # String | nil
+    keyword_init: true
+  )
+end

data/lib/schema_ferry/source/connection_registry.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SchemaFerry
+  module Source
+    module ConnectionRegistry
+      # Uses a fresh ConnectionHandler per call so the pool is fully isolated
+      # from ActiveRecord::Base and any host Rails app connections.
+      # AR 7.2+ banned anonymous AR subclasses, so we bypass that path entirely.
+      def self.with_connection(url)
+        handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+        begin
+          pool = handler.establish_connection(url, owner_name: "schema_ferry")
+          conn = pool.checkout
+          conn.verify!
+        rescue ActiveRecord::ActiveRecordError => e
+          raise ConnectionError, e.message
+        end
+
+        begin
+          yield conn
+        ensure
+          pool.checkin(conn)
+        end
+      ensure
+        handler&.clear_all_connections!
+      end
+    end
+  end
+end

data/lib/schema_ferry/source/mysql_reader.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module SchemaFerry
+  module Source
+    class MysqlReader
+      def initialize(url)
+        @url = url
+      end
+
+      def read_all
+        ConnectionRegistry.with_connection(@url) do |conn|
+          conn.tables.sort.map { |table_name| read_table(conn, table_name) }
+        end
+      rescue ConnectionError
+        raise
+      rescue StandardError => e
+        raise ReadError, e.message
+      end
+
+      private
+
+      def read_table(conn, name)
+        columns = conn.columns(name)
+        pk      = conn.primary_key(name)
+        pk_col  = pk.is_a?(String) ? columns.find { |c| c.name == pk } : nil
+        {
+          name:         name,
+          primary_key:  pk,
+          pk_type:      pk_col&.type,
+          pk_limit:     pk_col&.type == :string ? pk_col.limit : nil,
+          pk_sql_type:  pk_col&.sql_type,
+          comment:      conn.table_comment(name).presence,
+          columns:      serialize_columns(columns, pk),
+          indexes:      serialize_indexes(conn.indexes(name)),
+          foreign_keys: serialize_foreign_keys(conn.foreign_keys(name), name)
+        }
+      end
+
+      # A single-column PK is rendered via create_table's id: option, so it is
+      # excluded here. Composite PK columns must stay: primary_key: [...] does
+      # not create them.
+      def serialize_columns(columns, primary_key)
+        columns.reject { |c| c.name == primary_key }.map do |c|
+          {
+            name:             c.name,
+            type:             c.type,
+            sql_type:         c.sql_type,
+            limit:            c.limit,
+            precision:        c.precision,
+            scale:            c.scale,
+            null:             c.null,
+            default:          c.default,
+            default_function: c.default_function,
+            comment:          c.comment
+          }
+        end
+      end
+
+      def serialize_indexes(indexes)
+        indexes.map do |idx|
+          {
+            name:    idx.name,
+            columns: Array(idx.columns),
+            unique:  idx.unique,
+            using:   idx.using,
+            type:    idx.type, # :fulltext | :spatial | nil
+            where:   idx.where,
+            lengths: idx.lengths.presence,
+            orders:  idx.orders.presence
+          }
+        end
+      end
+
+      def serialize_foreign_keys(fkeys, from_table)
+        fkeys.map do |fk|
+          {
+            from_table:  from_table,
+            to_table:    fk.to_table,
+            column:      fk.column,
+            primary_key: fk.primary_key,
+            on_update:   fk.on_update,
+            on_delete:   fk.on_delete,
+            name:        fk.name
+          }
+        end
+      end
+    end
+  end
+end

data/lib/schema_ferry/target/ridgepole_runner.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "open3"
+require "tempfile"
+
+module SchemaFerry
+  module Target
+    # Runs ridgepole as a subprocess rather than via Ridgepole::Client:
+    # the client calls ActiveRecord::Base.establish_connection and patches AR
+    # in-process, which would hijack a host Rails app's database connection.
+    # The tempfile exists because the CLI only reads the schema from -f FILE.
+    class RidgepoleRunner
+      def initialize(target_url)
+        @target_url = target_url
+      end
+
+      def run(schema_content, dry_run: false)
+        bin = find_ridgepole!
+
+        Tempfile.create(["schema_ferry_", ".rb"]) do |f|
+          f.write(schema_content)
+          f.flush
+
+          cmd = [bin, "--apply", "-c", @target_url, "-f", f.path]
+          cmd << "--dry-run" if dry_run
+
+          stdout, stderr, status = Open3.capture3(*cmd)
+          raise RidgepoleError, [stdout, stderr].reject { |s| s.strip.empty? }.join("\n") unless status.success?
+
+          stdout
+        end
+      end
+
+      private
+
+      def find_ridgepole!
+        Gem.bin_path("ridgepole", "ridgepole")
+      rescue Gem::GemNotFoundException
+        raise RidgepoleNotFoundError,
+              "ridgepole binary not found. Add gem 'ridgepole' to your Gemfile."
+      end
+    end
+  end
+end

data/lib/schema_ferry/target/schemafile_renderer.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module SchemaFerry
+  module Target
+    class SchemafileRenderer
+      TIMESTAMP_COLS = %w[created_at updated_at].freeze
+
+      def render(tables)
+        table_blocks = tables.map { |t| render_table(t) }
+        fkey_lines   = tables.flat_map { |t| t.foreign_keys.map { |fk| render_foreign_key(fk) } }
+
+        parts = table_blocks
+        parts += fkey_lines unless fkey_lines.empty?
+        parts.join("\n\n")
+      end
+
+      private
+
+      def render_table(table)
+        lines = []
+        lines << "create_table #{table.name.inspect}#{pk_options(table)} do |t|"
+        lines.concat(render_columns(table.columns))
+        table.indexes.each { |idx| lines << render_index(idx) }
+        Array(table.check_constraints).each { |chk| lines << render_check_constraint(chk) }
+        lines << "end"
+        lines.join("\n")
+      end
+
+      def pk_options(table)
+        opts = []
+        case table.primary_key
+        when nil
+          opts << "id: false"
+        when String
+          opts << "primary_key: #{table.primary_key.inspect}" if table.primary_key != "id"
+          if table.pk_type && table.pk_type != :bigint
+            opts << "id: #{table.pk_type.inspect}"
+            opts << "limit: #{table.pk_limit.inspect}" if table.pk_limit
+          end
+        when Array
+          opts << "primary_key: #{table.primary_key.inspect}"
+        end
+        opts.unshift("force: :cascade")
+        opts << "comment: #{table.comment.inspect}" if table.comment
+        ", #{opts.join(", ")}"
+      end
+
+      def render_columns(columns)
+        ts_created  = columns.find { |c| c.name == "created_at" }
+        ts_updated  = columns.find { |c| c.name == "updated_at" }
+        use_timestamps = collapsible_timestamps?(ts_created, ts_updated)
+
+        lines      = []
+        emitted_ts = false
+
+        columns.each do |col|
+          if TIMESTAMP_COLS.include?(col.name) && use_timestamps
+            unless emitted_ts
+              lines << render_timestamps(ts_created)
+              emitted_ts = true
+            end
+            next
+          end
+          lines << render_column(col)
+        end
+
+        lines
+      end
+
+      def collapsible_timestamps?(created_at, updated_at)
+        return false unless created_at && updated_at
+        return false unless created_at.type == :datetime && updated_at.type == :datetime
+
+        created_at.null == updated_at.null &&
+          created_at.precision == updated_at.precision &&
+          created_at.default.nil? && updated_at.default.nil? &&
+          created_at.default_function.nil? && updated_at.default_function.nil?
+      end
+
+      def render_timestamps(col)
+        opts = []
+        opts << "null: false" if col.null == false
+        opts << "precision: #{col.precision}" if col.precision
+        opts.empty? ? "  t.timestamps" : "  t.timestamps #{opts.join(", ")}"
+      end
+
+      def render_column(col)
+        parts = [col.name.inspect]
+        opts  = column_options(col)
+        parts << opts unless opts.empty?
+        "  t.#{col.type} #{parts.join(", ")}"
+      end
+
+      def column_options(col)
+        pairs = []
+        pairs << "limit: #{col.limit.inspect}"         if col.limit
+        pairs << "precision: #{col.precision.inspect}" if col.precision
+        pairs << "scale: #{col.scale.inspect}"         if col.scale
+        pairs << render_default(col)                   if render_default(col)
+        pairs << "null: false"                         if col.null == false
+        pairs << "comment: #{col.comment.inspect}"     if col.comment
+        pairs.join(", ")
+      end
+
+      def render_default(col)
+        return "default: #{col.default.inspect}" unless col.default.nil?
+
+        "default: -> { #{col.default_function.inspect} }" if col.default_function
+      end
+
+      def render_index(idx)
+        cols  = idx.columns.inspect
+        parts = ["name: #{idx.name.inspect}"]
+        parts << "unique: true" if idx.unique
+        parts << "using: #{idx.using.inspect}" if idx.using
+        parts << "opclass: #{idx.opclass.inspect}" if idx.opclass
+        parts << "where: #{idx.where.inspect}" if idx.where
+        parts << "order: #{idx.orders.inspect}" if idx.orders
+        "  t.index #{cols}, #{parts.join(", ")}"
+      end
+
+      def render_check_constraint(chk)
+        "  t.check_constraint #{chk.expression.inspect}, name: #{chk.name.inspect}"
+      end
+
+      def render_foreign_key(foreign_key)
+        parts = [foreign_key.from_table.inspect, foreign_key.to_table.inspect]
+        parts << "column: #{foreign_key.column.inspect}" if foreign_key.column
+        non_default_pk = foreign_key.primary_key && foreign_key.primary_key != "id"
+        parts << "primary_key: #{foreign_key.primary_key.inspect}" if non_default_pk
+        parts << "name: #{foreign_key.name.inspect}"               if foreign_key.name
+        parts << "on_update: #{foreign_key.on_update.inspect}"     if foreign_key.on_update
+        parts << "on_delete: #{foreign_key.on_delete.inspect}"     if foreign_key.on_delete
+        "add_foreign_key #{parts.join(", ")}"
+      end
+    end
+  end
+end

data/lib/schema_ferry/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SchemaFerry
+  VERSION = "0.1.0"
+end

data/lib/schema_ferry/warnings.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SchemaFerry
+  # Mix in (include for classes, extend for module_function modules) to emit
+  # "[schema_ferry]"-prefixed warnings to stderr.
+  module Warnings
+    private
+
+    def emit_warning(message)
+      Kernel.warn("[schema_ferry] #{message}")
+    end
+  end
+end

data/lib/schema_ferry.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+require_relative "schema_ferry/version"
+require_relative "schema_ferry/errors"
+require_relative "schema_ferry/warnings"
+require_relative "schema_ferry/schema_model"
+require_relative "schema_ferry/dsl/table_rule"
+require_relative "schema_ferry/dsl/config"
+require_relative "schema_ferry/source/connection_registry"
+require_relative "schema_ferry/source/mysql_reader"
+require_relative "schema_ferry/converter/type_mapper"
+require_relative "schema_ferry/converter/identifier_shortener"
+require_relative "schema_ferry/converter/column_converter"
+require_relative "schema_ferry/converter/enum_check_builder"
+require_relative "schema_ferry/converter/schema_converter"
+require_relative "schema_ferry/target/schemafile_renderer"
+require_relative "schema_ferry/target/ridgepole_runner"
+require_relative "schema_ferry/pipeline"
+
+module SchemaFerry
+  def self.define(&)
+    Pipeline.new(DSL::Config.build(&))
+  end
+end