schema_ferry 0.2.0 → 0.3.0

data/lib/schema_ferry/converter/schema_converter.rb

@@ -1,172 +0,0 @@
-# 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
-
-      # MySQL spatial column types have no PostgreSQL equivalent (that would
-      # require PostGIS, which schema_ferry does not manage). Most of these
-      # already raise TypeMapper's ConversionError, since ActiveRecord's
-      # mysql2 adapter reports them as an unrecognized type (nil). POINT is
-      # the sole exception: AR matches sql_type against an unanchored /int/i
-      # regex (see register_class_with_limit in
-      # ActiveRecord::ConnectionAdapters::AbstractAdapter#initialize_type_map),
-      # which matches "point" as a substring — so it's misreported as plain
-      # :integer instead. Without this check it would sail through as a
-      # meaningless integer column instead of raising. It must be caught
-      # here, by sql_type, and raised explicitly — the same failure mode as
-      # any other unsupported type, not a warning that's easy to miss in a
-      # cron log.
-      MISDETECTED_SPATIAL_SQL_TYPE = /\Apoint\b/i
-
-      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)
-        kept_tables = raw_tables.reject { |t| @ignored_tables.include?(t[:name]) }
-        fk_columns  = collect_fk_columns(kept_tables)
-        kept_tables.map { |t| convert_table(t, fk_columns.fetch(t[:name], [])) }
-      end
-
-      private
-
-      def convert_table(raw, fk_columns)
-        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, fk_columns),
-          indexes:           convert_indexes(raw[:indexes], raw[:name], rule, ignored),
-          foreign_keys:      convert_foreign_keys(raw),
-          check_constraints: build_check_constraints(raw, rule, ignored)
-        )
-      end
-
-      # Columns on either side of a surviving foreign key must land in
-      # PostgreSQL's integer type family: a numeric(20, 0) column cannot
-      # reference a bigint key.
-      def collect_fk_columns(raw_tables)
-        raw_tables.each_with_object({}) do |raw, acc|
-          surviving_foreign_keys(raw).each do |fk|
-            (acc[raw[:name]] ||= []) << fk[:column]
-            (acc[fk[:to_table]] ||= []) << fk[:primary_key]
-          end
-        end
-      end
-
-      def surviving_foreign_keys(raw)
-        ignored = @table_rules[raw[:name]]&.ignored_columns || []
-        raw[:foreign_keys]
-          .reject { |fk| @ignored_tables.include?(fk[:to_table]) }
-          .reject { |fk| ignored.include?(fk[:column]) }
-      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, fk_columns)
-        raw_columns
-          .reject { |c| ignored.include?(c[:name]) }
-          .map do |c|
-            check_misdetected_spatial_type!(c, table_name, rule)
-            @column_converter.call(c, table_name, rule, fk_columns)
-          end
-      end
-
-      # map_column already lets a rule override any column's type before it
-      # ever reaches this check (ColumnConverter#call skips TypeMapper
-      # entirely when an override is present), same as for any other type.
-      def check_misdetected_spatial_type!(raw, table_name, rule)
-        return unless raw[:sql_type].to_s.match?(MISDETECTED_SPATIAL_SQL_TYPE)
-        return if rule&.column_type_overrides&.key?(raw[:name])
-
-        raise ConversionError, "#{table_name}.#{raw[:name]}: MySQL #{raw[:sql_type]} columns have no " \
-                               "PostgreSQL equivalent without PostGIS, which schema_ferry does not " \
-                               "manage. Exclude it with ignore_column :#{raw[:name]}."
-      end
-
-      def convert_indexes(raw_indexes, table_name, rule, ignored)
-        raw_indexes
-          .reject { |idx| rule&.ignored_indexes&.include?(idx[:name]) }
-          .reject { |idx| idx[:columns].intersect?(ignored) }
-          .map do |idx|
-            check_unsupported_index_type!(idx, table_name)
-            build_index_schema(idx, table_name)
-          end
-      end
-
-      def convert_foreign_keys(raw)
-        surviving_foreign_keys(raw).map { |fk| build_fk_schema(fk) }
-      end
-
-      # A warning here would be easy to miss in an unattended cron run.
-      # Raising makes this failure show up the same way as any other error:
-      # a non-zero exit status a monitor can catch.
-      def check_unsupported_index_type!(idx, table_name)
-        return unless UNSUPPORTED_INDEX_TYPES.include?(idx[:type])
-
-        raise ConversionError, "#{table_name}: #{idx[:type].to_s.upcase} index #{idx[:name].inspect} " \
-                               "has no PostgreSQL equivalent. Exclude it with ignore_index :#{idx[:name]}."
-      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],
-          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

data/lib/schema_ferry/dsl/config.rb

@@ -1,77 +0,0 @@
-# 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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module SchemaFerry
-  module DSL
-    class TableRule
-      UNSET = Object.new.freeze
-      private_constant :UNSET
-
-      attr_reader :table_name, :column_type_overrides,
-                  :column_default_overrides, :ignored_columns, :ignored_indexes
-
-      def initialize(table_name)
-        @table_name               = table_name.to_s
-        @column_type_overrides    = {}
-        @column_default_overrides = {}
-        @ignored_columns          = []
-        @ignored_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
-    end
-  end
-end

data/lib/schema_ferry/schema_model.rb

@@ -1,56 +0,0 @@
-# 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
-    :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

@@ -1,29 +0,0 @@
-# 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

@@ -1,88 +0,0 @@
-# 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
-            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/schemafile_renderer.rb

@@ -1,143 +0,0 @@
-# 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 << "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 custom_fk_column?(foreign_key)
-        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
-
-      # ridgepole's PostgreSQL export omits column: when it follows the Rails
-      # convention, and it compares foreign keys by their literal options —
-      # emitting column: for conventional names re-creates the FK every run.
-      def custom_fk_column?(foreign_key)
-        foreign_key.column && foreign_key.column != "#{foreign_key.to_table.singularize}_id"
-      end
-    end
-  end
-end

data/lib/schema_ferry/warnings.rb

@@ -1,13 +0,0 @@
-# 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