schema_ferry 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aacec6bc39b272cc96454401749eea5b880bb7c3a3d08e4666927f00f92d0379
-  data.tar.gz: eb407968fdbb8b848a1c4f942fb824cef3a80a063a1effb81bf02389342a69ce
+  metadata.gz: a34cb64f18cd33a93ebbc3636bd1e76e170279d98ec5d9c59b8ef14e8f141fd9
+  data.tar.gz: f3ae1fbea45f7b7f5c4d5c79e5704fcc680955a77a9123a73975618c32752b8f
 SHA512:
-  metadata.gz: 2e4663eb185b31ab7724e574c01c9b23fb49b8844a3e20bcebcba2ebc467d1abe8b8e7e7272fa73b0cf122f4a74cc6433811b4598a328b8847edad41b73963ae
-  data.tar.gz: db642c4079f769cc430a79bbe7174a4dd1b13b89000bfcdc0ae9b4ce3e47c29e57db2c756820c543ab06531b3ce6a430f90861d8ed70a46c91bc7bc2f1d82b82
+  metadata.gz: 9fa8d644af36d128f1922258299fc96ba682a068f1195fced8e8446e64067c63e5d5ee81b3541f07e162d0e2588495946e111ca5076da608ab9054491f9a8cdd
+  data.tar.gz: 18dd78144c3e9ccbba232da685b0248eb22be16a73ac55090edfe6638a7d93d8ef794bcf1babad248a95f324b9bf8a3e4bac4e3db19a2b4d735d09dd45a9cffe

data/CHANGELOG.md

@@ -6,3 +6,27 @@ 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.1.2] - 2026-07-06
+
+### Fixed
+
+- `map_type :datetime, to: :timestamptz` no longer produces a schema that never converges: ActiveRecord's PostgreSQL adapter silently ignores a `precision:` option on `:timestamptz` columns (unlike `:datetime`/`:timestamp`/`:time`, where it's honored), so declaring one caused `apply!` to re-run `change_column` on every single run. `precision` is no longer emitted for `:timestamptz` columns.
+- `BIGINT UNSIGNED` columns with a default value (e.g. `DEFAULT 0`) no longer cause `apply!` to re-run `change_column` on every run after the initial `apply!`. The default is now converted to match the string form ActiveRecord's schema dumper uses for decimal defaults, so it matches ridgepole's exported state instead of diffing against it forever.
+
+## [0.1.1] - 2026-07-06
+
+### Fixed
+
+- `apply!` no longer fails with `PG::DatatypeMismatch` when a `BIGINT UNSIGNED` column takes part in a foreign key — the standard Rails-on-MySQL primary key layout. Such columns are now mapped to signed `bigint` (matching the referenced primary key) instead of `numeric(20)`, with a warning.
+- Foreign keys whose column follows the Rails naming convention (`<table>_id`) are no longer dropped and re-created on every run: the generated `add_foreign_key` now omits `column:` for conventional names, matching ridgepole's export format.
+
+## [0.1.0] - 2026-07-06
+
+### Added
+
+- Initial release
+- `SchemaFerry.define` DSL — `source` / `target`, `map_type`, `enum_as :check`, `ignore_table`, and per-table rules (`map_column`, `ignore_column`, `ignore_index`, `add_index`)
+- `Pipeline#dry_run` / `#apply!` — reads the MySQL schema via ActiveRecord, converts it with the default type mappings plus your rules, and applies the diff to PostgreSQL via ridgepole
+- `schema_ferry` CLI (`apply` / `dry-run`) driven by a `Ferryfile`, with a one-line summary and cron-friendly exit status
+- Automatic adjustments with warnings: unsigned integer widening, FULLTEXT/SPATIAL index skipping, 63-byte identifier shortening, zero-date default removal

data/README.md

@@ -128,7 +128,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 |
+| `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 below |
 | `FLOAT` / `DOUBLE` | `double precision` | |
 | `DECIMAL(p,s)` | `numeric(p,s)` | |
 | `DATETIME` / `TIMESTAMP` | `timestamp` | use `map_type :datetime, to: :timestamptz` for `timestamptz` |
@@ -147,6 +147,7 @@ Some MySQL constructs have no PostgreSQL equivalent. schema_ferry handles them a
 - **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.
 
 ## How it works
 

data/lib/schema_ferry/converter/column_converter.rb

@@ -13,8 +13,8 @@ module SchemaFerry
         @type_mapper = type_mapper
       end
 
-      def call(raw, table_name, rule)
-        raw      = bump_unsigned_integer(raw)
+      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])
         col_opts = raw.slice(:limit, :precision, :scale, :null, :default, :default_function, :comment)
@@ -30,15 +30,26 @@ module SchemaFerry
 
       private
 
-      def bump_unsigned_integer(raw)
+      def bump_unsigned_integer(raw, table_name, fk_column)
         return raw unless raw[:type] == :integer && raw[:sql_type].to_s.include?("unsigned")
 
-        if raw[:limit] == 8
+        if raw[:limit] != 8
+          raw.merge(limit: UNSIGNED_LIMIT_BUMP.fetch(raw[:limit], raw[:limit]))
+        elsif fk_column
+          # decimal(20, 0) cannot be a foreign key to a bigint primary key, so
+          # FK columns follow the primary-key conversion (signed bigint) instead.
+          emit_warning "#{table_name}.#{raw[:name]}: BIGINT UNSIGNED takes part in a foreign key; " \
+                       "mapped to signed bigint to match the referenced key " \
+                       "(values above 2^63-1 will not fit)."
+          raw
+        else
           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]))
+          # AR's schema dumper renders decimal defaults as a string (e.g.
+          # `default: "0"`), not a numeric literal — match that representation
+          # or ridgepole re-applies the default on every run.
+          new_default = raw[:default]&.to_s
+          raw.merge(type: :decimal, limit: nil, precision: 20, scale: 0, default: new_default)
         end
       end
 

data/lib/schema_ferry/converter/schema_converter.rb

@@ -16,14 +16,14 @@ module SchemaFerry
       end
 
       def convert(raw_tables)
-        raw_tables
-          .reject { |t| @ignored_tables.include?(t[:name]) }
-          .map    { |t| convert_table(t) }
+        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)
+      def convert_table(raw, fk_columns)
         rule    = @table_rules[raw[:name]]
         ignored = rule&.ignored_columns || []
         IdentifierShortener.warn_long_table_name(raw[:name])
@@ -34,13 +34,32 @@ module SchemaFerry
           pk_type:           convert_pk_type(raw),
           pk_limit:          raw[:pk_limit],
           comment:           raw[:comment],
-          columns:           convert_columns(raw[:columns], raw[:name], rule, ignored),
+          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[:foreign_keys], 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)
@@ -60,10 +79,10 @@ module SchemaFerry
         end
       end
 
-      def convert_columns(raw_columns, table_name, rule, ignored)
+      def convert_columns(raw_columns, table_name, rule, ignored, fk_columns)
         raw_columns
           .reject { |c| ignored.include?(c[:name]) }
-          .map    { |c| @column_converter.call(c, table_name, rule) }
+          .map    { |c| @column_converter.call(c, table_name, rule, fk_columns) }
       end
 
       def convert_indexes(raw_indexes, table_name, rule, ignored)
@@ -92,11 +111,8 @@ module SchemaFerry
         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) }
+      def convert_foreign_keys(raw)
+        surviving_foreign_keys(raw).map { |fk| build_fk_schema(fk) }
       end
 
       def skip_unsupported_index?(idx, table_name)

data/lib/schema_ferry/converter/type_mapper.rb

@@ -9,9 +9,15 @@ module SchemaFerry
 
       # 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
+      DEFAULT_PRECISION_TYPES = %i[datetime time].freeze
       PG_DEFAULT_PRECISION    = 6
 
+      # ActiveRecord's PostgreSQL adapter never honors a precision option on
+      # :timestamptz (only :datetime/:timestamp/:time do — see
+      # ActiveRecord::ConnectionAdapters::SchemaStatements#type_to_sql).
+      # Declaring one is always a lie, so it must never be emitted.
+      NO_PRECISION_TYPES = %i[timestamptz].freeze
+
       DEFAULTS = {
         json: :jsonb
       }.freeze
@@ -58,6 +64,7 @@ module SchemaFerry
       end
 
       def strip_default_precision(pg_type, options)
+        options[:precision] = nil if NO_PRECISION_TYPES.include?(pg_type)
         return unless DEFAULT_PRECISION_TYPES.include?(pg_type)
 
         options[:precision] = nil if options[:precision] == PG_DEFAULT_PRECISION

data/lib/schema_ferry/target/schemafile_renderer.rb

@@ -125,7 +125,7 @@ module SchemaFerry
 
       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
+        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
@@ -133,6 +133,13 @@ module SchemaFerry
         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/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: schema_ferry
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - kyuuri1791