schema_ferry 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e954e39c0309126d404ec1a7b95cfcaf062cbdf18525e6d179e8747c96d95aaf
-  data.tar.gz: 29c7495b19fb18d7cb9ea1a17fb64b8778dc7deeefeeee50858b0584adc57fe8
+  metadata.gz: 689fd7901be3470c89447bcf83a61fb4185880e53f5723afa3385d2c23850a29
+  data.tar.gz: e74cd92c6c2b0c446b4b57e5460311f9885044f3f1f1ad2b86b23fc926cb0671
 SHA512:
-  metadata.gz: 939a4335e6ad17b7eabbde3d4f3979e09009493cef5b474ec033cfbf853f4def56fb505d82aa9ab4366ab6ff6158196aed1f9a4ea762470cc5e3938a148f181e
-  data.tar.gz: d7e983858d24f45938fbda3a8c76d4a0de06d496c949a91320903b0c49b1ff440450570440e7726860e6c2158bbddec080d3a92c78918f62182f84321ad21b42
+  metadata.gz: c918782073cfb88339251517b2985a022b7035eb813c21045afe9ba66b252adaf32350820ac756c035e795411963af678747a5aeb00ec82404ab1bc10b006ee7
+  data.tar.gz: 8a8d656502ee2ad147212f3920b19136ec31ca88f7b99d2391ade83046f9a0db476bbc163fdc496034e2d3048ff58219674aee03f8315a07b15b5ab4b576f9ac

data/CHANGELOG.md

@@ -5,7 +5,26 @@ 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]
+## [0.3.0] - 2026-07-11
+
+### Added
+
+- `apply!(allow_drops: false)` — refuses to apply anything (raising `SchemaFerry::DropNotAllowedError` instead) whenever the diff contains a column, index, foreign key, or constraint drop. The default remains `allow_drops: true`, matching the gem's "MySQL is the source of truth" philosophy, but this gives an escape hatch for handoff periods where a target-only addition might otherwise get swept up in a legitimate MySQL-driven drop. The CLI exposes the same behavior via `schema_ferry apply --disable-drops`.
+
+### Changed
+
+- `map_column :col, type: :type` is now `column :col, map_type_to: :type`. `map_column` implied a mapping between two columns, which isn't what it does — it overrides one column's own type in place. `column` pairs with the existing `table` block, and `map_type_to:` mirrors `map_type`'s `to:` keyword for the same kind of type override.
+- `apply!` now wraps the whole migration in a single transaction (via ridgepole's `--pre-query`/`--post-query`), so a failure partway through no longer leaves a half-applied schema on the target.
+- A table name over 63 bytes now raises `SchemaFerry::ConversionError` instead of just warning. `apply!` was never actually going to succeed for it anyway — ActiveRecord's own PostgreSQL schema statements reject an over-length `create_table` outright — so the warning was misleading about how far the pipeline would actually get. `ignore_table` it, or rename it in MySQL.
+
+### Removed
+
+- `Pipeline#schemafile` — it exposed the generated ridgepole Schemafile as a string without connecting to the target. That text is an internal hand-off format between schema_ferry and ridgepole, and keeping it public meant committing to a stable, human-friendly rendering of it forever. Pipeline's API is now just `dry_run` and `apply!`; to preview what a run would do, use `dry_run` — it shows the actual diff against the target rather than the full declared schema.
+
+### Fixed
+
+- A MySQL `MULTIPOINT` column silently passed through as a plain PostgreSQL integer instead of raising. ActiveRecord misdetects `MULTIPOINT` as `:integer`, the same bug that already affected `POINT` — the check only matched `POINT` by name, so `MULTIPOINT` slipped past it. All eight MySQL spatial types (`GEOMETRY`, `POINT`, `LINESTRING`, `POLYGON`, `MULTIPOINT`, `MULTILINESTRING`, `MULTIPOLYGON`, `GEOMETRYCOLLECTION`) are now matched directly by `sql_type`, so they all raise the same explicit "no PostgreSQL equivalent without PostGIS" error instead of some going through a generic "unknown type" message.
+- `Pipeline#apply!(allow_drops: false)` read the MySQL schema twice — once for the drop pre-check and once for the actual apply — so a schema change landing on MySQL between the two reads could apply a drop the pre-check never saw. The schema is now read and converted once, and the same Schemafile is used for both the pre-check and the apply, matching what the CLI already did.
 
 ## [0.2.0] - 2026-07-06
 

data/README.md

@@ -6,7 +6,7 @@ You're migrating a production MySQL database to PostgreSQL. Moving the data take
 - **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://github.com/dimitri/pgloader) (one-shot bulk copy) or CDC replication (AWS DMS, [Debezium](https://github.com/debezium/debezium), …), which load rows into the tables schema_ferry keeps in sync.
+schema_ferry is designed to run repeatedly — as a step in whatever CI/CD pipeline you already have (Jenkins, Step Functions, GitHub Actions, …). Data migration is out of scope — pair it with [pgloader](https://github.com/dimitri/pgloader) (one-shot bulk copy) or CDC replication (AWS DMS, [Debezium](https://github.com/debezium/debezium), …), which load rows into the tables schema_ferry keeps in sync.
 
 ## Requirements
 
@@ -41,13 +41,11 @@ pipeline.dry_run  # returns the changes that would be applied, without applying
 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 from the target that are not part of it. Before running against a target that holds data, read [Coverage](#coverage) below.
+`apply!` makes the target match the generated schema — including **dropping** columns, indexes, foreign keys, and constraints from the target that are not part of it. Before running against a target that holds data, read [Handoff](#handoff) 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`:
+As a step in an existing pipeline, 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"
@@ -60,9 +58,10 @@ Then:
 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
+schema_ferry apply --disable-drops       # refuse instead of applying if the diff contains a drop
 ```
 
-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.
+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 your monitoring can rely on it.
 
 ### Custom conversion rules
 
@@ -75,7 +74,7 @@ pipeline = SchemaFerry.define do
   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
+    column :is_admin, map_type_to: :boolean # override a specific column's type
     ignore_column :legacy_field          # exclude a column
     ignore_index :idx_old_legacy         # exclude an index
   end
@@ -84,25 +83,7 @@ pipeline = SchemaFerry.define do
 end
 ```
 
-The same rules work in a CLI definition file.
-
-### Coverage
-
-schema_ferry syncs what can be done automatically — exactly where possible, or as an approximation with a warning where it isn't — and leaves the rest to add by hand, later. Where there's no reasonable equivalent at all, it raises instead of guessing. Add the column or index by hand once you're fully cut over to PostgreSQL — not before, since `apply!` delegates to [ridgepole](https://github.com/ridgepole/ridgepole), which drops anything missing from the generated schema on a managed table, including something added by hand as a stand-in — but never drops a table that's absent from it entirely.
-
-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.
-
-Normalized automatically, with a warning to stderr:
-
-- **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.
-- **BIGINT UNSIGNED columns on a foreign key** (either side) become signed `bigint` instead of `numeric(20)` — a numeric column cannot reference a bigint primary key. Values above 2⁶³−1 will not fit, the same trade-off as for `BIGINT UNSIGNED` primary keys.
-
-Raises instead:
-
-- **FULLTEXT indexes** — PostgreSQL has no equivalent construct (a `pg_trgm` GIN index is a common approximation, but it's not the same search semantics, so schema_ferry doesn't create one for you). Because of the drop behavior above, you can't pre-create a replacement during the sync period — add one once you're fully cut over to PostgreSQL. `ignore_index` them.
-- **Spatial columns** (`POINT`, `GEOMETRY`, `POLYGON`, `LINESTRING`, …) — PostgreSQL has no built-in equivalent without PostGIS, which schema_ferry does not manage. `ignore_column` them.
+The same rules work in a `Ferryfile`.
 
 ## DSL reference
 
@@ -121,14 +102,14 @@ Raises instead:
 
 | 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 |
+| `column :col, map_type_to: :type` | Override a column's type |
+| `column :col, map_type_to: :type, default: value` | …and give it an explicit default |
 | `ignore_column :col` | Exclude a column |
 | `ignore_index :index_name` | Exclude an index |
 
-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.
+Ignoring a column also drops indexes and foreign keys that reference it.
 
-**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.
+**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: `column :flags, map_type_to: :integer, default: 2`. Without an explicit default, schema_ferry drops the unreliable boolean default and warns.
 
 ## Default type mapping
 
@@ -139,7 +120,7 @@ Ignoring a column also drops indexes and foreign keys that reference it. Renamin
 | `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. Columns on a foreign key become signed `bigint` instead — see above |
+| `BIGINT UNSIGNED` | `numeric(20)` | PostgreSQL has no unsigned 8-byte integer; emitted with a warning. Columns on a foreign key become signed `bigint` instead — see [Handoff](#handoff) below |
 | `FLOAT` / `DOUBLE` | `double precision` | |
 | `DECIMAL(p,s)` | `numeric(p,s)` | |
 | `DATETIME` / `TIMESTAMP` | `timestamp` | use `map_type :datetime, to: :timestamptz` for `timestamptz` |
@@ -148,7 +129,28 @@ Ignoring a column also drops indexes and foreign keys that reference it. Renamin
 | `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.
+`map_type` / `column`'s `map_type_to:` take Rails-style abstract type symbols (`:string`, `:integer`, `:jsonb`, …), not raw SQL type names.
+
+## Handoff
+
+MySQL is the source of truth: `apply!` makes PostgreSQL match the generated schema exactly, so anything else on the target — including a column or index added by hand as an early stand-in — gets dropped. That's intentional. Add the real thing by hand once you're fully cut over to PostgreSQL, not before. The one exception is a table absent from the generated schema entirely — that's left alone.
+
+Though that's the philosophy, if you don't want it, you can switch it off with `apply!(allow_drops: false)`: `apply!` then only goes through when the diff is drop-free; otherwise it raises `SchemaFerry::DropNotAllowedError` instead of applying anything to the target.
+
+Within that generated schema, schema_ferry syncs what can be done automatically — exactly where possible, or as an approximation with a warning where it isn't — and leaves the rest to add by hand, later. Where there's no reasonable equivalent at all, it raises instead of guessing.
+
+Normalized automatically, with a warning to stderr:
+
+- **Index prefix lengths** (`KEY (col(10))`) are dropped silently — PostgreSQL indexes the full column.
+- **Index and foreign key names over 63 bytes** (MySQL allows 64) are shortened deterministically (`first 54 bytes + _ + 8-char digest`), so repeated runs stay stable.
+- **Zero-date defaults** (`'0000-00-00 00:00:00'`) are invalid in PostgreSQL and are dropped.
+- **BIGINT UNSIGNED columns on a foreign key** (either side) become signed `bigint` instead of `numeric(20)` — a numeric column cannot reference a bigint primary key. Values above 2⁶³−1 will not fit, the same trade-off as for `BIGINT UNSIGNED` primary keys.
+
+Raises instead:
+
+- **FULLTEXT indexes** — PostgreSQL has no equivalent construct (a `pg_trgm` GIN index is a common approximation, but it's not the same search semantics, so schema_ferry doesn't create one for you). Because of the drop behavior above, you can't pre-create a replacement during the sync period — add one once you're fully cut over to PostgreSQL. `ignore_index` them.
+- **Spatial columns** (`POINT`, `GEOMETRY`, `POLYGON`, `LINESTRING`, …) — PostgreSQL has no built-in equivalent without PostGIS, which schema_ferry does not manage. `ignore_column` them.
+- **Table names over 63 bytes** (MySQL allows 64) — unlike index and foreign key names, schema_ferry won't rename a table for you (too invasive to do silently). `ignore_table` it, or rename it in MySQL.
 
 ## How it works
 

data/lib/schema_ferry/cli.rb

@@ -3,16 +3,16 @@
 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
+    include Support::DropDetectable
+
     DEFAULT_CONFIG_PATH = "Ferryfile"
     COMMANDS = %w[apply dry-run].freeze
 
     def initialize(stdout: $stdout, stderr: $stderr)
-      @stdout = stdout
-      @stderr = stderr
+      @stdout      = stdout
+      @stderr      = stderr
+      @allow_drops = true
     end
 
     def run(argv)
@@ -33,10 +33,18 @@ module SchemaFerry
     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)
+      config       = load_config
+      mysql_tables = IO::MysqlReader.new(config.source_url).read_all
+      schemafile   = Core::Translator.new(config).translate(mysql_tables)
+      dry_run      = command == "dry-run"
+      writer       = IO::PostgresWriter.new(config.target_url)
+
+      if command == "apply" && !@allow_drops
+        drops = detect_drops(writer.run(schemafile, dry_run: true))
+        raise DropNotAllowedError, "refused: the diff contains drop(s):\n#{drops.join("\n")}" unless drops.empty?
+      end
+
+      output = writer.run(schemafile, dry_run: dry_run)
 
       @stdout.puts output
       @stdout.puts summary(schemafile, output, dry_run: dry_run)
@@ -72,13 +80,14 @@ module SchemaFerry
       path = @config_path || DEFAULT_CONFIG_PATH
       raise ConfigError, "definition file not found: #{path}" unless File.exist?(path)
 
-      DSL::Config.load_file(path)
+      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("--disable-drops", "apply: refuse if the diff contains any drop") { @allow_drops = false }
         o.on("-h", "--help", "Show this help") { @mode = :help }
         o.on("--version", "Show version") { @mode = :version }
       end

data/lib/schema_ferry/config.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module SchemaFerry
+  class Config
+    attr_reader :source_url, :target_url,
+                :global_type_overrides,
+                :table_rules,
+                :ignored_tables,
+                :enum_mode
+
+    class << self
+      # Ruby entry point
+      def build(&block)
+        evaluate { |config| config.instance_eval(&block) }
+      end
+
+      # CLI entry point
+      def load_file(path)
+        evaluate { |config| config.instance_eval(File.read(path), path.to_s, 1) }
+      end
+
+      private
+
+      def evaluate
+        new.tap do |config|
+          yield config
+          config.validate!
+        end
+      end
+    end
+
+    def initialize
+      @global_type_overrides = {}
+      @table_rules           = Hash.new(TableRule::EMPTY)
+      @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)
+      modes = %i[string check]
+      unless modes.include?(mode.to_sym)
+        raise ConfigError, "enum_as accepts #{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
+
+    # Vocabulary available inside a `table :name do ... end` block.
+    class TableRule
+      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
+
+      EMPTY = new("").freeze # Null object for tables without a `table ... do` block.
+      DEFAULT_OMITTED = Object.new.freeze
+      private_constant :DEFAULT_OMITTED
+
+      def column(column_name, map_type_to:, default: DEFAULT_OMITTED)
+        @column_type_overrides[column_name.to_s] = map_type_to.to_sym
+        @column_default_overrides[column_name.to_s] = default unless default.equal?(DEFAULT_OMITTED)
+      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/{converter → core}/column_converter.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module SchemaFerry
-  module Converter
+  module Core
     class ColumnConverter
-      include Warnings
+      include Support::Warnings
 
       # PG has no unsigned integers: bump to the next size that holds the full
       # unsigned range. Keys/values are AR byte limits.
@@ -16,7 +16,7 @@ module SchemaFerry
       def call(raw, table_name, rule, fk_columns = [])
         raw      = bump_unsigned_integer(raw, table_name, fk_columns.include?(raw[:name]))
         raw      = drop_zero_date_default(raw, table_name)
-        override = rule&.column_type_overrides&.[](raw[:name])
+        override = rule.column_type_overrides[raw[:name]]
         col_opts = raw.slice(:limit, :precision, :scale, :null, :default, :default_function, :comment)
 
         if override
@@ -71,7 +71,7 @@ module SchemaFerry
           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>"
+                       "column :#{raw[:name]}, map_type_to: :#{override}, default: <value>"
           return nil
         end
         default

data/lib/schema_ferry/{converter → core}/enum_check_builder.rb

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
 
 module SchemaFerry
-  module Converter
+  module Core
     # Builds CHECK constraints enforcing MySQL enum values on varchar columns
     # (enum_as :check).
     class EnumCheckBuilder
-      def call(raw_table, rule, ignored)
+      include IdentifierShortenable
+
+      def call(raw_table, rule)
         raw_table[:columns].filter_map do |col|
-          next if ignored.include?(col[:name])
+          next if rule.ignored_columns.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])
+          next if rule.column_type_overrides.key?(col[:name])
 
           values = enum_values(col[:sql_type])
           next if values.nil?
@@ -24,8 +26,8 @@ module SchemaFerry
       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)
+          name:       shorten_identifier("chk_#{table_name}_#{col_name}",
+                                         kind: "check constraint", table: table_name)
         )
       end
 

data/lib/schema_ferry/{converter/identifier_shortener.rb → core/identifier_shortenable.rb}

@@ -3,19 +3,17 @@
 require "digest"
 
 module SchemaFerry
-  module Converter
+  module Core
     # 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
+    module IdentifierShortenable
+      include Support::Warnings
 
       MAX_BYTES   = 63
       HASH_LENGTH = 8
 
-      module_function
-
-      def shorten(name, kind:, table:)
+      def shorten_identifier(name, kind:, table:)
         return name if name.nil? || name.bytesize <= MAX_BYTES
 
         prefix = name.byteslice(0, MAX_BYTES - HASH_LENGTH - 1)
@@ -24,14 +22,6 @@ module SchemaFerry
                      "#{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/core/schema_model.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Plain data structs for the converted (PostgreSQL-side) schema: TableConverter
+# builds these, SchemafileRenderer reads them.
+module SchemaFerry
+  module Core
+    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
+end

data/lib/schema_ferry/core/schemafile_renderer.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module SchemaFerry
+  module Core
+    class SchemafileRenderer
+      Call = Struct.new(:name, :args, :opts, :children)
+      Raw = Struct.new(:source)
+
+      def render(tables)
+        calls = tables.map { |table| table_call(table) }
+        calls += tables.flat_map { |table| table.foreign_keys.map { |fk| foreign_key_call(fk) } }
+        calls.map { |call| serialize(call) }.join("\n\n")
+      end
+
+      private
+
+      def table_call(table)
+        children = table.columns.map { |col| column_call(col) }
+        children += table.indexes.map { |idx| index_call(idx) }
+        children += Array(table.check_constraints).map { |chk| check_constraint_call(chk) }
+        Call.new("create_table", [table.name], table_options(table), children)
+      end
+
+      def table_options(table)
+        opts = { force: :cascade }
+        case table.primary_key
+        when nil
+          opts[:id] = false
+        when String
+          opts[:primary_key] = table.primary_key if table.primary_key != "id"
+          if table.pk_type && table.pk_type != :bigint
+            opts[:id]    = table.pk_type
+            opts[:limit] = table.pk_limit
+          end
+        when Array
+          opts[:primary_key] = table.primary_key
+        end
+        opts[:comment] = table.comment
+        opts
+      end
+
+      def column_call(col)
+        Call.new("t.#{col.type}", [col.name], {
+                   limit:     col.limit,
+                   precision: col.precision,
+                   scale:     col.scale,
+                   default:   default_option(col),
+                   null:      (false if col.null == false),
+                   comment:   col.comment
+                 })
+      end
+
+      def default_option(col)
+        return col.default unless col.default.nil?
+
+        Raw.new("-> { #{col.default_function.inspect} }") if col.default_function
+      end
+
+      def index_call(idx)
+        Call.new("t.index", [idx.columns], {
+                   name:   idx.name,
+                   unique: (true if idx.unique),
+                   using:  idx.using,
+                   order:  idx.orders
+                 })
+      end
+
+      def check_constraint_call(chk)
+        Call.new("t.check_constraint", [chk.expression], { name: chk.name })
+      end
+
+      def foreign_key_call(foreign_key)
+        Call.new("add_foreign_key", [foreign_key.from_table, foreign_key.to_table], {
+                   column:      (foreign_key.column if custom_fk_column?(foreign_key)),
+                   primary_key: (foreign_key.primary_key if foreign_key.primary_key && foreign_key.primary_key != "id"),
+                   name:        foreign_key.name,
+                   on_update:   foreign_key.on_update,
+                   on_delete:   foreign_key.on_delete
+                 })
+      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
+
+      def serialize(call, indent = "")
+        head = "#{indent}#{[call.name, arguments(call)].reject(&:empty?).join(" ")}"
+        return head unless call.children
+
+        ["#{head} do |t|",
+         *call.children.map { |child| serialize(child, "#{indent}  ") },
+         "#{indent}end"].join("\n")
+      end
+
+      def arguments(call)
+        positional = call.args.map { |arg| literal(arg) }
+        keyword    = call.opts.filter_map { |key, value| "#{key}: #{literal(value)}" unless value.nil? }
+        (positional + keyword).join(", ")
+      end
+
+      def literal(value)
+        value.is_a?(Raw) ? value.source : value.inspect
+      end
+    end
+  end
+end