exwiw 0.9.7 → 0.9.9

data/lib/exwiw/japanese_names.rb

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+module Exwiw
+  # Paired (kanji, katakana) Japanese name data for the `ja` locale of the
+  # person-family `replace_with_fake_data` types (see {RowTransformer}).
+  #
+  # faker's `ja` locale ships kanji names only, with no reading, so it cannot
+  # produce kana (フリガナ) at all, and its last_name / first_name pools are
+  # unrelated to each other. exwiw bundles this paired dataset instead so that:
+  #
+  # - a fake person carries a kana reading that actually matches its kanji, and
+  # - last_name / first_name / full name (and their kana) for a single seed all
+  #   come from the same person (a coherent identity).
+  #
+  # The kanji sets extend faker's `ja` name list (its top 100 surnames / 100
+  # given names) with common additions; exwiw supplies the readings. 142 x 142
+  # = 20,164 combinations exceeds the person pool size
+  # (RowTransformer::PERSON_POOL_SIZE = 20,000), so the ja pool is filled with
+  # that many DISTINCT people rather than repeating a small subset.
+  #
+  # Readings are katakana (matching the katakana convention of typical `*_kana`
+  # columns). They are plausible common readings, not the only possible reading
+  # of each kanji — fake data only needs to look real, not be canonical.
+  module JapaneseNames
+    SURNAMES = [
+      %w[佐藤 サトウ],
+      %w[鈴木 スズキ],
+      %w[高橋 タカハシ],
+      %w[田中 タナカ],
+      %w[伊藤 イトウ],
+      %w[山本 ヤマモト],
+      %w[渡辺 ワタナベ],
+      %w[中村 ナカムラ],
+      %w[小林 コバヤシ],
+      %w[加藤 カトウ],
+      %w[吉田 ヨシダ],
+      %w[山田 ヤマダ],
+      %w[佐々木 ササキ],
+      %w[山口 ヤマグチ],
+      %w[松本 マツモト],
+      %w[井上 イノウエ],
+      %w[木村 キムラ],
+      %w[林 ハヤシ],
+      %w[斎藤 サイトウ],
+      %w[清水 シミズ],
+      %w[山崎 ヤマザキ],
+      %w[阿部 アベ],
+      %w[森 モリ],
+      %w[池田 イケダ],
+      %w[橋本 ハシモト],
+      %w[山下 ヤマシタ],
+      %w[石川 イシカワ],
+      %w[中島 ナカジマ],
+      %w[前田 マエダ],
+      %w[藤田 フジタ],
+      %w[後藤 ゴトウ],
+      %w[小川 オガワ],
+      %w[岡田 オカダ],
+      %w[村上 ムラカミ],
+      %w[長谷川 ハセガワ],
+      %w[近藤 コンドウ],
+      %w[石井 イシイ],
+      %w[斉藤 サイトウ],
+      %w[坂本 サカモト],
+      %w[遠藤 エンドウ],
+      %w[藤井 フジイ],
+      %w[青木 アオキ],
+      %w[福田 フクダ],
+      %w[三浦 ミウラ],
+      %w[西村 ニシムラ],
+      %w[藤原 フジワラ],
+      %w[太田 オオタ],
+      %w[松田 マツダ],
+      %w[原田 ハラダ],
+      %w[岡本 オカモト],
+      %w[中野 ナカノ],
+      %w[中川 ナカガワ],
+      %w[小野 オノ],
+      %w[田村 タムラ],
+      %w[竹内 タケウチ],
+      %w[金子 カネコ],
+      %w[中山 ナカヤマ],
+      %w[和田 ワダ],
+      %w[石田 イシダ],
+      %w[工藤 クドウ],
+      %w[上田 ウエダ],
+      %w[原 ハラ],
+      %w[森田 モリタ],
+      %w[酒井 サカイ],
+      %w[横山 ヨコヤマ],
+      %w[柴田 シバタ],
+      %w[宮崎 ミヤザキ],
+      %w[宮本 ミヤモト],
+      %w[内田 ウチダ],
+      %w[高木 タカギ],
+      %w[谷口 タニグチ],
+      %w[安藤 アンドウ],
+      %w[丸山 マルヤマ],
+      %w[今井 イマイ],
+      %w[大野 オオノ],
+      %w[高田 タカダ],
+      %w[菅原 スガワラ],
+      %w[河野 コウノ],
+      %w[武田 タケダ],
+      %w[藤本 フジモト],
+      %w[上野 ウエノ],
+      %w[杉山 スギヤマ],
+      %w[千葉 チバ],
+      %w[村田 ムラタ],
+      %w[増田 マスダ],
+      %w[小島 コジマ],
+      %w[小山 コヤマ],
+      %w[大塚 オオツカ],
+      %w[平野 ヒラノ],
+      %w[久保 クボ],
+      %w[渡部 ワタナベ],
+      %w[松井 マツイ],
+      %w[菊地 キクチ],
+      %w[岩崎 イワサキ],
+      %w[松尾 マツオ],
+      %w[佐野 サノ],
+      %w[木下 キノシタ],
+      %w[野口 ノグチ],
+      %w[野村 ノムラ],
+      %w[新井 アライ],
+%w[北村 キタムラ],
+%w[平田 ヒラタ],
+%w[森本 モリモト],
+%w[荒木 アラキ],
+%w[大西 オオニシ],
+%w[菅野 カンノ],
+%w[小池 コイケ],
+%w[桜井 サクライ],
+%w[高野 タカノ],
+%w[川口 カワグチ],
+%w[大久保 オオクボ],
+%w[中田 ナカタ],
+%w[川崎 カワサキ],
+%w[飯田 イイダ],
+%w[星野 ホシノ],
+%w[岩田 イワタ],
+%w[大森 オオモリ],
+%w[松岡 マツオカ],
+%w[沢田 サワダ],
+%w[内藤 ナイトウ],
+%w[松浦 マツウラ],
+%w[西田 ニシダ],
+%w[白石 シライシ],
+%w[浜田 ハマダ],
+%w[早川 ハヤカワ],
+%w[永井 ナガイ],
+%w[松村 マツムラ],
+%w[三宅 ミヤケ],
+%w[福島 フクシマ],
+%w[大橋 オオハシ],
+%w[中西 ナカニシ],
+%w[吉川 ヨシカワ],
+%w[服部 ハットリ],
+%w[尾崎 オザキ],
+%w[水野 ミズノ],
+%w[香川 カガワ],
+%w[荒井 アライ],
+%w[田口 タグチ],
+%w[江口 エグチ],
+%w[秋山 アキヤマ],
+%w[黒田 クロダ],
+%w[今村 イマムラ],
+    ].freeze
+
+    GIVEN_NAMES = [
+      %w[翔太 ショウタ],
+      %w[蓮 レン],
+      %w[翔 ショウ],
+      %w[陸 リク],
+      %w[颯太 ソウタ],
+      %w[悠斗 ユウト],
+      %w[大翔 ヒロト],
+      %w[翼 ツバサ],
+      %w[樹 イツキ],
+      %w[奏太 ソウタ],
+      %w[大和 ヤマト],
+      %w[大輝 ダイキ],
+      %w[悠 ユウ],
+      %w[隼人 ハヤト],
+      %w[健太 ケンタ],
+      %w[大輔 ダイスケ],
+      %w[駿 シュン],
+      %w[陽斗 ハルト],
+      %w[優 ユウ],
+      %w[陽 ヨウ],
+      %w[悠人 ユウト],
+      %w[誠 マコト],
+      %w[拓海 タクミ],
+      %w[仁 ジン],
+      %w[悠太 ユウタ],
+      %w[悠真 ユウマ],
+      %w[大地 ダイチ],
+      %w[健 ケン],
+      %w[遼 リョウ],
+      %w[大樹 ダイキ],
+      %w[諒 リョウ],
+      %w[響 ヒビキ],
+      %w[太一 タイチ],
+      %w[一郎 イチロウ],
+      %w[優斗 ユウト],
+      %w[亮 リョウ],
+      %w[海斗 カイト],
+      %w[颯 ソウ],
+      %w[亮太 リョウタ],
+      %w[匠 タクミ],
+      %w[陽太 ヨウタ],
+      %w[航 ワタル],
+      %w[瑛太 エイタ],
+      %w[直樹 ナオキ],
+      %w[空 ソラ],
+      %w[光 ヒカル],
+      %w[太郎 タロウ],
+      %w[輝 ヒカル],
+      %w[一輝 カズキ],
+      %w[蒼 アオイ],
+      %w[葵 アオイ],
+      %w[優那 ユウナ],
+      %w[優奈 ユウナ],
+      %w[凛 リン],
+      %w[陽菜 ヒナ],
+      %w[愛 アイ],
+      %w[結衣 ユイ],
+      %w[美咲 ミサキ],
+      %w[楓 カエデ],
+      %w[さくら サクラ],
+      %w[遥 ハルカ],
+      %w[美優 ミユ],
+      %w[莉子 リコ],
+      %w[七海 ナナミ],
+      %w[美月 ミヅキ],
+      %w[結菜 ユナ],
+      %w[真央 マオ],
+      %w[花音 カノン],
+      %w[陽子 ヨウコ],
+      %w[舞 マイ],
+      %w[美羽 ミウ],
+      %w[優衣 ユイ],
+      %w[未来 ミク],
+      %w[彩 アヤ],
+      %w[彩乃 アヤノ],
+      %w[彩花 アヤカ],
+      %w[智子 トモコ],
+      %w[奈々 ナナ],
+      %w[千尋 チヒロ],
+      %w[愛美 マナミ],
+      %w[優菜 ユウナ],
+      %w[杏 アン],
+      %w[裕子 ユウコ],
+      %w[芽衣 メイ],
+      %w[綾乃 アヤノ],
+      %w[琴音 コトネ],
+      %w[桜 サクラ],
+      %w[恵 メグミ],
+      %w[杏奈 アンナ],
+      %w[美桜 ミオ],
+      %w[優花 ユウカ],
+      %w[玲奈 レナ],
+      %w[結 ユイ],
+      %w[茜 アカネ],
+      %w[美穂 ミホ],
+      %w[明日香 アスカ],
+      %w[愛子 アイコ],
+      %w[美緒 ミオ],
+      %w[千夏 チナツ],
+      %w[真希 マキ],
+%w[陽向 ヒナタ],
+%w[大介 ダイスケ],
+%w[涼介 リョウスケ],
+%w[悠介 ユウスケ],
+%w[拓也 タクヤ],
+%w[和也 カズヤ],
+%w[直人 ナオト],
+%w[雄太 ユウタ],
+%w[翔平 ショウヘイ],
+%w[健太郎 ケンタロウ],
+%w[慎太郎 シンタロウ],
+%w[竜也 タツヤ],
+%w[圭 ケイ],
+%w[樹里 ジュリ],
+%w[花子 ハナコ],
+%w[由美 ユミ],
+%w[由美子 ユミコ],
+%w[美穂子 ミホコ],
+%w[直子 ナオコ],
+%w[京子 キョウコ],
+%w[順子 ジュンコ],
+%w[洋子 ヨウコ],
+%w[幸子 サチコ],
+%w[美和 ミワ],
+%w[理沙 リサ],
+%w[麻衣 マイ],
+%w[早紀 サキ],
+%w[春香 ハルカ],
+%w[沙織 サオリ],
+%w[香織 カオリ],
+%w[友美 トモミ],
+%w[恵子 ケイコ],
+%w[真由美 マユミ],
+%w[里奈 リナ],
+%w[彩香 アヤカ],
+%w[亜美 アミ],
+%w[春菜 ハルナ],
+%w[千秋 チアキ],
+%w[桃子 モモコ],
+%w[美里 ミサト],
+%w[結子 ユウコ],
+%w[陽介 ヨウスケ],
+    ].freeze
+  end
+end

data/lib/exwiw/mongodb_collection_config.rb

@@ -39,7 +39,30 @@ module Exwiw
     # `path`.
     attribute :embedded_in, optional(EmbeddedIn), skip_serializing_if_nil: true
 
+    # `reverse_scope` opts a collection into multi-referencer reverse scoping,
+    # mirroring the SQL TableConfig key (see Exwiw::ReverseScope): a
+    # global-identity collection referenced by many scoped collections is
+    # constrained to the union of the ids those referencers actually point at,
+    # instead of being dumped in full. Unlike the SQL adapters (which emit a
+    # UNION subquery), the mongodb adapter captures each `via` arm's column
+    # values at runtime while the referencer collection streams, so the
+    # reverse-scoped collection must be processed AFTER its referencers — see
+    # DetermineTableProcessingOrder (runtime_reverse_scope) and
+    # MongodbAdapter#reverse_scope_filter. User-configured and never emitted by
+    # MongoidSchemaGenerator; preserved across regeneration (see #merge).
+    attribute :reverse_scope, Serdes::OptionalType.new(ReverseScope), skip_serializing_if_nil: true
+
     def self.from(obj)
+      # Reject unknown keys before deserializing: Serdes silently drops them,
+      # which would turn a typo'd key — or a key only the SQL adapters support,
+      # like a field-level `raw_sql` — into a silent no-op (see
+      # Exwiw::StrictKeys). `comment` is a declared attribute here and on the
+      # nested belongs_to/field entries, so free-form notes stay accepted.
+      if obj.is_a?(Hash)
+        collection_name = obj["name"] || obj[:name]
+        StrictKeys.validate!(self, obj, owner: "collection '#{collection_name}'")
+      end
+
       instance = super
       instance.__send__(:validate_embedded!)
       instance.__send__(:validate_belongs_tos!)
@@ -89,6 +112,8 @@ module Exwiw
         # is kept.
         merged.comment = passed.comment || comment
         merged.embedded_in = passed.embedded_in
+        # User-owned, never regenerated: carry over from the existing config.
+        merged.reverse_scope = reverse_scope
 
         # Structural facts of each belongs_to come from the freshly generated
         # config (including a generator-derived `references`), but the user-owned
@@ -124,6 +149,12 @@ module Exwiw
 
     private def validate_embedded!
       return unless embedded?
+
+      if reverse_scope
+        raise ArgumentError,
+              "MongodbCollectionConfig '#{name}' is embedded_in '#{embedded_in.collection_name}'; " \
+              "reverse_scope must not be defined (an embedded config is never dumped on its own)."
+      end
       return if belongs_tos.empty?
 
       raise ArgumentError,

data/lib/exwiw/row_transformer.rb

@@ -2,6 +2,8 @@
 
 require "digest"
 
+require_relative "japanese_names"
+
 module Exwiw
   # Applies the Ruby-process-side masking modes — `map` and
   # `replace_with_fake_data` — to the rows streamed out of a SQL adapter's
@@ -31,16 +33,46 @@ module Exwiw
     # given faker gem version + locale.
     POOL_RANDOM_SEED = 715_517
 
-    # Supported `replace_with_fake_data` types. `pool` builds one candidate
-    # value (called POOL_SIZE times under a seeded Faker random). Types with
-    # `compose` are uniqueness-sensitive: the pooled base alone would collide
-    # under a unique index at scale, so the final value composes the base with
-    # a 64-bit hex token derived from the same seed digest (collision
-    # probability at 5M distinct seeds ≈ 7e-7).
+    # The person pool (PERSON_TYPES) is sized independently of POOL_SIZE — at
+    # twice the size — so the coherent-identity name space is larger without
+    # disturbing the independent types' seed->value mappings. The ja pool is
+    # filled with distinct people (see .build_japanese_person_pool), so
+    # JapaneseNames must supply at least this many (surname, given) combinations.
+    PERSON_POOL_SIZE = POOL_SIZE * 2
+
+    # A coherent fake identity. All person-family types (PERSON_TYPES) draw
+    # from one shared pool of these per locale, and a seed picks the same pool
+    # index for every such column — so last_name / first_name / full name (and
+    # their kana) for one seed all belong to the same person. kana fields are
+    # only populated for the `ja` locale (faker has no readings; exwiw bundles
+    # a paired dataset — see JapaneseNames); they are nil otherwise.
+    Person = Struct.new(:last_name, :first_name, :last_name_kana, :first_name_kana)
+
+    # Person-family types: they share the per-locale person pool (built by
+    # .person_pool), and each extractor derives its value from the picked
+    # Person. Full-name ordering is locale-aware ("姓 名" for ja, "First Last"
+    # elsewhere). This is what keeps a single seed's name columns consistent.
+    PERSON_TYPES = {
+      "human_name"      => ->(p, locale) { join_full_name(p.last_name, p.first_name, locale) },
+      "last_name"       => ->(p, _locale) { p.last_name },
+      "first_name"      => ->(p, _locale) { p.first_name },
+      "human_name_kana" => ->(p, locale) { join_full_name(p.last_name_kana, p.first_name_kana, locale) },
+      "last_name_kana"  => ->(p, _locale) { p.last_name_kana },
+      "first_name_kana" => ->(p, _locale) { p.first_name_kana },
+    }.freeze
+
+    # Person-family types whose value is a kana reading, only available for the
+    # `ja` locale (the person pool carries nil kana for other locales, so these
+    # are rejected at build time with a clear error).
+    KANA_TYPES = %w[human_name_kana last_name_kana first_name_kana].freeze
+
+    # Independent (non-person) types. `pool` builds one candidate value (called
+    # POOL_SIZE times under a seeded Faker random). Types with `compose` are
+    # uniqueness-sensitive: the pooled base alone would collide under a unique
+    # index at scale, so the final value composes the base with a 64-bit hex
+    # token derived from the same seed digest (collision probability at 5M
+    # distinct seeds ≈ 7e-7).
     FAKE_TYPES = {
-      "human_name"   => { pool: -> { Faker::Name.name } },
-      "first_name"   => { pool: -> { Faker::Name.first_name } },
-      "last_name"    => { pool: -> { Faker::Name.last_name } },
       "phone_number" => { pool: -> { Faker::PhoneNumber.phone_number } },
       "address"      => { pool: -> { Faker::Address.full_address } },
       "company_name" => { pool: -> { Faker::Company.name } },
@@ -50,6 +82,13 @@ module Exwiw
                           compose: ->(base, token) { "#{base}_#{token}" } },
     }.freeze
 
+    # "姓 名" for Japanese, "First Last" otherwise. A nil part (e.g. missing
+    # kana) collapses so the result never has a dangling separator.
+    def self.join_full_name(last, first, locale)
+      parts = locale.to_s == "ja" ? [last, first] : [first, last]
+      parts.compact.join(" ")
+    end
+
     # The `r` a map proc receives: read-only access to the current row's
     # values by column name (`r['id']`). One instance is reused across all
     # rows (zero per-row allocation) — do not retain it outside the proc.
@@ -118,6 +157,15 @@ module Exwiw
             "Add `gem \"faker\"` to your Gemfile (it is not a runtime dependency of exwiw)."
     end
 
+    # Whether a (type, locale) draws any value from faker. The `ja` person pool
+    # is built entirely from exwiw's bundled dataset, so a config that only
+    # uses `ja` person types needs no faker at all.
+    def self.type_needs_faker?(type, locale)
+      return true if FAKE_TYPES.key?(type)
+
+      PERSON_TYPES.key?(type) && locale.to_s != "ja"
+    end
+
     # Pools are memoized per (type, locale): every column sharing a type+locale
     # sees the same pool, which is what makes equal seed values map to equal
     # fake values across tables and runs.
@@ -138,6 +186,51 @@ module Exwiw
       Faker::Config.random = previous_random
     end
 
+    # One pool of coherent Person records per locale, shared by every
+    # person-family type. Memoized so equal seeds map to equal people across
+    # tables and runs. `ja` is built from exwiw's bundled (kanji, kana) dataset
+    # so kana matches kanji; other locales use faker (no kana).
+    def self.person_pool(locale)
+      @person_pools ||= {}
+      @person_pools[locale] ||= build_person_pool(locale)
+    end
+
+    def self.build_person_pool(locale)
+      random = Random.new(POOL_RANDOM_SEED)
+      return build_japanese_person_pool(random) if locale.to_s == "ja"
+
+      previous_locale = Faker::Config.locale
+      previous_random = Faker::Config.random
+      Faker::Config.locale = locale if locale
+      Faker::Config.random = random
+      Array.new(PERSON_POOL_SIZE) { Person.new(Faker::Name.last_name, Faker::Name.first_name, nil, nil).freeze }.freeze
+    ensure
+      unless locale.to_s == "ja"
+        Faker::Config.locale = previous_locale
+        Faker::Config.random = previous_random
+      end
+    end
+
+    # Fill the ja pool with DISTINCT people: enumerate every (surname, given)
+    # combination, shuffle deterministically, and take PERSON_POOL_SIZE. Unlike
+    # sampling with replacement (which wastes ~37% of slots to duplicates), this
+    # gives PERSON_POOL_SIZE distinct identities — so JapaneseNames must supply
+    # at least that many combinations.
+    def self.build_japanese_person_pool(random)
+      surnames = JapaneseNames::SURNAMES
+      given_names = JapaneseNames::GIVEN_NAMES
+      combinations = surnames.size * given_names.size
+      if combinations < PERSON_POOL_SIZE
+        raise "JapaneseNames has #{combinations} (surname, given) combinations, " \
+              "need at least PERSON_POOL_SIZE=#{PERSON_POOL_SIZE}"
+      end
+
+      people = surnames.flat_map do |last|
+        given_names.map { |first| Person.new(last[0], first[0], last[1], first[1]).freeze }
+      end
+      people.shuffle(random: random).first(PERSON_POOL_SIZE).freeze
+    end
+
     def initialize(table)
       @table_name = table.name
       @name_to_index = {}
@@ -145,7 +238,11 @@ module Exwiw
       @name_to_index.freeze
       @row_accessor = Row.new(@table_name, @name_to_index)
 
-      self.class.require_faker! if table.columns.any?(&:replace_with_fake_data)
+      needs_faker = table.columns.any? do |column|
+        fd = column.replace_with_fake_data
+        fd && self.class.type_needs_faker?(fd.type, fd.locale)
+      end
+      self.class.require_faker! if needs_faker
 
       @transforms = table.columns.each_with_index.filter_map do |column, index|
         if column.map
@@ -210,11 +307,26 @@ module Exwiw
 
     private def compile_fake(column, column_index)
       fake_data = column.replace_with_fake_data
-      spec = FAKE_TYPES.fetch(fake_data.type)
+      type = fake_data.type
+      unless PERSON_TYPES.key?(type) || FAKE_TYPES.key?(type)
+        raise ArgumentError,
+              "replace_with_fake_data for column '#{@table_name}.#{column.name}': " \
+              "unknown type '#{type}'. Supported: #{(PERSON_TYPES.keys + FAKE_TYPES.keys).join(', ')}"
+      end
 
-      # Re-resolve the seed here, against the effective (post-ignore) columns:
-      # load-time validation sees the full column list, so a seed column that
-      # was ignore:true is only caught at dump time.
+      seed_index = resolve_seed_index(fake_data, column)
+
+      if PERSON_TYPES.key?(type)
+        compile_person_fake(fake_data, column, column_index, seed_index)
+      else
+        compile_independent_fake(fake_data, column_index, seed_index)
+      end
+    end
+
+    # Re-resolve the seed here, against the effective (post-ignore) columns:
+    # load-time validation sees the full column list, so a seed column that was
+    # ignore:true is only caught at dump time.
+    private def resolve_seed_index(fake_data, column)
       seed_column = fake_data.seed.delete_prefix("#{@table_name}.")
       seed_index = @name_to_index[seed_column]
       unless seed_index
@@ -223,14 +335,44 @@ module Exwiw
               "seed '#{fake_data.seed}' does not resolve to an extracted column " \
               "(is it ignore:true?)"
       end
+      seed_index
+    end
+
+    # Person-family type: pick a coherent Person from the per-locale pool. The
+    # digest[0,8] index is shared with every other person column, so one seed's
+    # name columns all belong to the same person.
+    private def compile_person_fake(fake_data, column, column_index, seed_index)
+      type = fake_data.type
+      locale = fake_data.locale
+      pool = self.class.person_pool(locale)
+      extractor = PERSON_TYPES.fetch(type)
+
+      if KANA_TYPES.include?(type) && pool.first.last_name_kana.nil?
+        raise ArgumentError,
+              "replace_with_fake_data for column '#{@table_name}.#{column.name}': " \
+              "type '#{type}' needs kana readings, which are only available with locale: ja " \
+              "(got locale: #{locale.inspect})"
+      end
+
+      # NULL-preserving like replace_with: a NULL target stays NULL.
+      lambda do |row|
+        next nil if row[column_index].nil?
+
+        digest = Digest::SHA256.digest(row[seed_index].to_s)
+        person = pool[digest[0, 8].unpack1("Q>") % PERSON_POOL_SIZE]
+        extractor.call(person, locale)
+      end
+    end
 
+    # Independent type: pick a value from its own (type, locale) pool.
+    private def compile_independent_fake(fake_data, column_index, seed_index)
       pool = self.class.fake_pool(fake_data.type, fake_data.locale)
-      compose = spec[:compose]
+      compose = FAKE_TYPES.fetch(fake_data.type)[:compose]
 
-      # NULL-preserving like replace_with: a NULL target stays NULL. A nil
-      # seed value hashes "" (deterministic). Seed values are normalized with
-      # to_s so sqlite's native Integer 123 and pg/mysql's string "123" pick
-      # the same fake value.
+      # NULL-preserving like replace_with: a NULL target stays NULL. A nil seed
+      # value hashes "" (deterministic). Seed values are normalized with to_s so
+      # sqlite's native Integer 123 and pg/mysql's string "123" pick the same
+      # fake value.
       lambda do |row|
         next nil if row[column_index].nil?
 

data/lib/exwiw/runner.rb

@@ -47,7 +47,16 @@ module Exwiw
       QueryAstBuilder.validate_scope!(dumpable_configs, table_by_name, @dump_target, @logger)
 
       @logger.info("Determining table processing order...")
-      ordered_table_names = DetermineTableProcessingOrder.run(dumpable_configs, logger: @logger)
+      # runtime_reverse_scope: the mongodb adapter builds a reverse-scoped
+      # collection's filter from ids captured while its `via` referencers were
+      # dumped, so those referencers must be processed first. The SQL adapters
+      # scope via subqueries and keep the historical belongs_to-only order
+      # (which also keeps their INSERT output loadable in foreign-key order).
+      ordered_table_names = DetermineTableProcessingOrder.run(
+        dumpable_configs,
+        logger: @logger,
+        runtime_reverse_scope: adapter.is_a?(Adapter::MongodbAdapter),
+      )
 
       clean_output_dir!
 
@@ -58,7 +67,7 @@ module Exwiw
       # replacement for the whole schema+inserts pass, after which the common
       # after-insert hook still runs. Everything before this point (validation,
       # scope check, ordering, output-dir clean) applies to both paths.
-      if use_mongodb_parallel?(adapter)
+      if use_mongodb_parallel?(adapter, configs)
         dump_mongodb_parallel(configs, table_by_name)
         run_after_insert_hook(adapter, ordered_table_names.size)
         return
@@ -209,7 +218,7 @@ module Exwiw
     # target (the schedule is built around the scoped DAG), and a runtime that can
     # fork. Anything else falls back to the serial path (warning when the user
     # explicitly asked for parallelism but it cannot apply).
-    private def use_mongodb_parallel?(adapter)
+    private def use_mongodb_parallel?(adapter, configs)
       return false unless adapter.is_a?(Adapter::MongodbAdapter)
       return false unless @parallel_workers && @parallel_workers > 1
 
@@ -218,6 +227,15 @@ module Exwiw
         return false
       end
 
+      # A reverse-scoped collection consumes @state captured from its `via`
+      # referencers, an ordering constraint the parallel schedule (built around
+      # the belongs_to DAG only) does not express yet — a worker could dump the
+      # collection before its arms and silently drop rows. Run serially instead.
+      if configs.any? { |c| c.respond_to?(:reverse_scope) && c.reverse_scope&.via&.any? }
+        @logger.warn("--parallel-workers ignored: reverse_scope collections require the serial processing order; running serially.")
+        return false
+      end
+
       unless MongodbParallelDumper.available?
         @logger.warn("--parallel-workers ignored: fork is unavailable on this runtime; running serially.")
         return false
@@ -275,7 +293,12 @@ module Exwiw
         # considered during extraction. Done here (after loading from file)
         # rather than in `.from` so the schema generators keep the full config
         # and can preserve the ignored entries on regeneration.
-        klass.from(json).reject_ignored_members!
+        begin
+          klass.from(json).reject_ignored_members!
+        rescue UnknownConfigKeyError => e
+          # `.from` knows the table, not the file; point at the offending file.
+          raise UnknownConfigKeyError, "#{file}: #{e.message}", e.backtrace
+        end
       end
     end