exwiw 0.4.6 → 0.4.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dac24d68af7c0c39949a11c810cccc14e6818ac0edb9198a3a6b846d2d81bcee
-  data.tar.gz: c4b111dc3dccc8940627b7dcabf2ea5633300eb5e670b52ec8683e78a2922040
+  metadata.gz: 6bf23b63e169e4f28dceda8611fe1dc599ed3fba7565a063ac11d7e66e84816e
+  data.tar.gz: 4768cb5990bc6bb534e38bf458d814ad7be4ff57cc4ecb02565aae245078a7d1
 SHA512:
-  metadata.gz: 15cdaa9351b32c3159f27a79204506f557825441d2c8253da5981d0e903504240963fcf279a34c28b02f084004f9d728499ee8fb3ea609a94b3583b72f8b8ce8
-  data.tar.gz: 7b7de3276484ce8bb97164f26aed9dc23f25f51736065c0f3f15337be49f82db322bbe16534fc77c0ad85fefd55fa1e825b25933b8c2f0e85e50694da6333f2f
+  metadata.gz: bd2b11ab17de73e205639bc917cdd4bff23a793caa282c23f1a987b3391a6bc1550e65078924f82c6e63bdc03c22a9e37b0b1977c2602f5fbe0940b68dd92c13
+  data.tar.gz: 78681a8c80263454d9bcaef29282de2bf1853b478dd2025382b2a0e4dfe089ea14af8dd970cd0127c8ddf2b71f9a3306024959303052102592203487d387e5a7

data/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## [Unreleased]
 
+## [0.4.7] - 2026-06-10
+
+### Fixed
+
+- PostgreSQL: `CREATE TYPE ... AS ENUM` statements in schema dumps no longer duplicate labels when the same enum type is used by multiple columns across the target tables. The `query_enum_types` query now filters by column in a subquery so the `pg_type` / `pg_enum` join produces each label exactly once.
+
+### Added
+
+- MongoDB: a `belongs_to` may now declare `references`, the parent field its foreign key actually points at, so foreign-key propagation can follow a relation that references a non-`_id` parent field (e.g. a `uuid`). Previously the adapter always stashed the parent's `primary_key` (`_id`, an ObjectId) and constrained children with `foreign_key $in [ObjectId(...)]`; a child whose FK stores the parent's `uuid` String never matched, so its slice (and everything below it) came back empty — making business-entity-scoped dumps unusable for models referenced by `primary_key: :uuid`. With `"references": "uuid"` on the child's `belongs_to`, the adapter captures the parent's `uuid` values during extraction and matches the child against those instead. `references` defaults to the parent's `primary_key` (so existing configs are unchanged). `schema:generate_mongoid` now auto-emits it by reading Mongoid's `belongs_to ..., primary_key:` (a non-`_id` primary key becomes `"references": "<field>"`; a default `_id` emits nothing), so no hand-editing is needed for `primary_key:`-declared associations — and a hand-added value still survives regeneration. The SQL adapters ignore it (they join on the parent primary key).
+- MongoDB: `--uri=URI` connects with a full connection string (`mongodb://...` or `mongodb+srv://...`), letting you reach managed/replica-set deployments (e.g. Atlas) where TLS, `replicaSet`, `authSource`, and credentials must be specified — they live in the URI's query string. Previously the adapter was hard-coded to a single `host:port` with no TLS / `authSource` / `replicaSet` / SRV support, so such instances were unreachable. When given, the URI is the source of truth: `--host`/`--port`/`--user`/`DATABASE_PASSWORD` are ignored and `--host`/`--port`/`--database` are no longer required; `--database`, if still passed, overrides the database in the URI path. The flag is mongodb-only, and the URI is never written to logs (it may carry credentials).
+
 ## [0.4.6] - 2026-06-08
 
 ### Fixed

data/README.md

@@ -494,6 +494,7 @@ The MongoDB adapter is experimental. To use it:
 
 - Add `gem "mongo"` to your Gemfile in addition to `exwiw` (it is not declared as a runtime dependency of the gem).
 - Set `--adapter=mongodb`. `--user` / `DATABASE_PASSWORD` are optional and only needed when your MongoDB requires authentication.
+- `--uri=URI` connects with a full MongoDB connection string (`mongodb://...` or `mongodb+srv://...`) instead of `--host`/`--port`. Use it for managed/replica-set deployments (e.g. Atlas) where TLS, `replicaSet`, `authSource`, and credentials must be expressed — put them in the URI's query string (e.g. `mongodb+srv://user:pass@cluster.example.com/?authSource=admin&tls=true`). The URI takes precedence: when given, `--host`/`--port`/`--user`/`DATABASE_PASSWORD` are ignored, and `--host`/`--port`/`--database` are no longer required on the CLI. `--database`, if still passed, overrides the database in the URI path; otherwise the database from the URI is used. This flag is **mongodb-only** (the SQL adapters shell out to their own client binaries and have no equivalent). The URI may carry credentials, so it is never written to logs.
 - The MongoDB adapter consumes a separate config type, `MongodbCollectionConfig`, with MongoDB-native naming. Use `fields` (instead of the SQL adapters' `columns`), and set `"primary_key": "_id"`. Foreign keys (`shop_id`, `user_id`, ...) stay as ordinary fields.
 - `--ids` values are coerced to the type actually stored in `_id` before filtering: integer-looking ids become `Integer`, 24-char hex ids become `BSON::ObjectId` (Mongoid's default `_id` type — a plain String would never match an ObjectId), and any other string is left as-is.
 - `--target-collection=COLLECTION` is a mongodb-only alias of `--target-table` (use whichever reads better for MongoDB). Specifying both, or using `--target-collection` with a non-mongodb adapter, is an error.

data/lib/exwiw/adapter/mongodb_adapter.rb

@@ -45,13 +45,20 @@ module Exwiw
         # the same config.
         @embedded_children_by_parent = index_embedded_children(config_by_name)
 
+        # Which of this collection's fields downstream children will `$in`-match
+        # against (always including primary_key). Stashed for the matching
+        # #execute call to capture, by the same build_query-before-execute
+        # invariant the embedded index relies on.
+        @propagation_keys = propagation_keys_for(config, config_by_name)
+
         filter =
           if config.name == dump_target.table_name
             # `--ids-field` may override which field --ids is matched against;
             # otherwise fall back to the primary key. Note this only changes the
             # WHERE filter on the target collection — downstream foreign-key
-            # propagation still keys off `primary_key` (see #execute, which
-            # stashes doc[primary_key] into @state).
+            # propagation keys off each child belongs_to's `references` field
+            # (default: the parent primary_key); see #execute, which stashes
+            # those fields into @state.
             #
             # Type coercion is only applied to the primary key (`_id`), whose
             # stored type we know (Mongoid's default ObjectId). For a custom
@@ -64,16 +71,15 @@ module Exwiw
               { config.primary_key => { "$in" => coerce_ids(dump_target.ids) } }
             end
           else
-            constrained = config.belongs_tos.select do |relation|
-              @state.key?(relation.table_name) && !@state[relation.table_name].empty?
-            end
-
-            if constrained.empty?
-              {}
-            else
-              constrained.each_with_object({}) do |relation, acc|
-                acc[relation.foreign_key] = { "$in" => @state[relation.table_name] }
-              end
+            config.belongs_tos.each_with_object({}) do |relation, acc|
+              # Constrain by the parent field this FK actually references
+              # (`relation.references`, default the parent primary_key). The
+              # values were captured from that field's documents in #execute, so
+              # their BSON type already matches the stored FK — no coercion.
+              values = parent_state_for(relation, config_by_name)
+              next if values.nil? || values.empty?
+
+              acc[relation.foreign_key] = { "$in" => values }
             end
           end
 
@@ -81,7 +87,7 @@ module Exwiw
           collection: config.name,
           primary_key: config.primary_key,
           filter: filter,
-          projection: build_projection(config),
+          projection: build_projection(config, @propagation_keys),
         )
       end
 
@@ -94,7 +100,14 @@ module Exwiw
           .comment(query_comment_text("collection=#{query.collection}"))
           .to_a
 
-        @state[query.collection] = docs.map { |doc| doc[query.primary_key] }
+        # Stash, per referenced field, the values children will `$in`-match
+        # against. @propagation_keys is set by the build_query call for this same
+        # collection; fall back to the primary key if execute is driven without a
+        # preceding build_query (e.g. in isolation from a test).
+        keys = @propagation_keys || [query.primary_key]
+        @state[query.collection] = keys.each_with_object({}) do |key, acc|
+          acc[key] = docs.map { |doc| doc[key] }
+        end
 
         docs
       end
@@ -227,7 +240,7 @@ module Exwiw
         end
       end
 
-      private def build_projection(config)
+      private def build_projection(config, propagation_keys = [config.primary_key])
         projection = {}
         # Always include primary key so masking templates referencing it work,
         # even if it is not declared in fields.
@@ -240,9 +253,40 @@ module Exwiw
         embedded_children_of(config).each do |child|
           projection[child.embedded_in.path] = 1
         end
+        # Ensure every field a child references is fetched, even one not declared
+        # in `fields` — otherwise doc[ref] would be nil and the child's $in empty.
+        propagation_keys.each { |key| projection[key] = 1 }
         projection
       end
 
+      # The distinct set of this collection's fields that downstream children
+      # constrain on (each child belongs_to's `references`, defaulting to this
+      # collection's primary_key), with primary_key always included so the
+      # historical primary-key-keyed propagation keeps working.
+      private def propagation_keys_for(config, config_by_name)
+        referenced = config_by_name.each_value.flat_map do |child|
+          next [] if child.embedded?
+
+          child.belongs_tos
+            .select { |relation| relation.table_name == config.name }
+            .map { |relation| relation.references || config.primary_key }
+        end
+        ([config.primary_key] + referenced).uniq
+      end
+
+      # The captured parent-collection values a child belongs_to should be
+      # constrained by: the values of the parent field the FK references
+      # (`relation.references`, default the parent primary_key). nil when the
+      # parent has not been executed yet.
+      private def parent_state_for(relation, config_by_name)
+        parent_fields = @state[relation.table_name]
+        return nil if parent_fields.nil?
+
+        reference_field =
+          relation.references || config_by_name.fetch(relation.table_name).primary_key
+        parent_fields[reference_field]
+      end
+
       private def apply_replace_with!(doc, config)
         config.fields.each do |field|
           next unless field.replace_with
@@ -292,16 +336,34 @@ module Exwiw
         @db ||=
           begin
             require 'mongo'
-            address = "#{@connection_config.host}:#{@connection_config.port}"
-            options = { database: @connection_config.database_name }
-            if @connection_config.user && !@connection_config.user.to_s.empty?
-              options[:user] = @connection_config.user
-              options[:password] = @connection_config.password
-            end
             Mongo::Logger.logger.level = ::Logger::WARN
-            Mongo::Client.new([address], **options)
+            if uri_connection?
+              # A full connection URI (e.g. `mongodb+srv://...`) is the source of
+              # truth: TLS, replicaSet, authSource and credentials are read from
+              # it, so host/port/user/password are ignored. `--database`, if
+              # given, overrides the database in the URI path; otherwise the
+              # URI's own database is used. The URI is never logged (it may carry
+              # credentials).
+              client_options = {}
+              if @connection_config.database_name && !@connection_config.database_name.to_s.empty?
+                client_options[:database] = @connection_config.database_name
+              end
+              Mongo::Client.new(@connection_config.uri, **client_options)
+            else
+              address = "#{@connection_config.host}:#{@connection_config.port}"
+              options = { database: @connection_config.database_name }
+              if @connection_config.user && !@connection_config.user.to_s.empty?
+                options[:user] = @connection_config.user
+                options[:password] = @connection_config.password
+              end
+              Mongo::Client.new([address], **options)
+            end
           end
       end
+
+      private def uri_connection?
+        !@connection_config.uri.nil? && !@connection_config.uri.to_s.empty?
+      end
     end
   end
 end

data/lib/exwiw/adapter/postgresql_adapter.rb

@@ -373,20 +373,22 @@ module Exwiw
 
         placeholders = table_names.each_with_index.map { |_, i| "$#{i + 1}" }.join(', ')
         sql = <<~SQL
-          SELECT DISTINCT
+          SELECT
             n.nspname  AS type_schema,
             t.typname  AS type_name,
             array_agg(e.enumlabel ORDER BY e.enumsortorder) AS enum_labels
-          FROM pg_attribute a
-          JOIN pg_class c      ON c.oid = a.attrelid
-          JOIN pg_namespace cn ON cn.oid = c.relnamespace
-          JOIN pg_type t       ON t.oid = a.atttypid
-          JOIN pg_namespace n  ON n.oid = t.typnamespace
-          JOIN pg_enum e       ON e.enumtypid = t.oid
-          WHERE c.relname IN (#{placeholders})
-            AND a.attnum > 0
-            AND NOT a.attisdropped
-            AND t.typtype = 'e'
+          FROM pg_type t
+          JOIN pg_namespace n ON n.oid = t.typnamespace
+          JOIN pg_enum e      ON e.enumtypid = t.oid
+          WHERE t.typtype = 'e'
+            AND t.oid IN (
+              SELECT a.atttypid
+              FROM pg_attribute a
+              JOIN pg_class c ON c.oid = a.attrelid
+              WHERE c.relname IN (#{placeholders})
+                AND a.attnum > 0
+                AND NOT a.attisdropped
+            )
           GROUP BY n.nspname, t.typname
           ORDER BY n.nspname, t.typname
         SQL

data/lib/exwiw/belongs_to.rb

@@ -12,6 +12,20 @@ module Exwiw
     # non-polymorphic belongs_to.
     attribute :foreign_type, optional(String), skip_serializing_if_nil: true
     attribute :type_value, optional(String), skip_serializing_if_nil: true
+    # The field on the parent (`table_name`) that `foreign_key` actually points
+    # at. nil means the parent's `primary_key` (the usual `_id`), so existing
+    # configs behave exactly as before. Set it when the FK references a non-`_id`
+    # parent field — e.g. Mongoid's `belongs_to :foo, primary_key: :uuid`, where
+    # the child stores `foo.uuid` rather than `foo._id`.
+    #
+    # Only the MongodbAdapter consumes this (to stash and `$in`-match the right
+    # parent field during foreign-key propagation); the SQL adapters ignore it,
+    # since they join on the parent primary key. MongoidSchemaGenerator emits it
+    # automatically from Mongoid's `belongs_to ..., primary_key:` (only when that
+    # is non-`_id`); a value may also be hand-added, and either way it survives
+    # regeneration (see TableConfig#merge / MongodbCollectionConfig#merge), so a
+    # hand edit is not clobbered by re-introspection.
+    attribute :references, optional(String), skip_serializing_if_nil: true
     # User-owned fields. The schema generators never emit them, but a user can
     # add them by hand and they survive regeneration (see TableConfig#merge /
     # MongodbCollectionConfig#merge). `ignore:true` drops the relation from
@@ -28,8 +42,10 @@ module Exwiw
     end
 
     # Structural identity used to match a freshly generated belongs_to against a
-    # user-maintained one during merge. `comment`/`ignore` are user-owned and so
-    # are intentionally excluded.
+    # user-maintained one during merge. `comment`/`ignore`/`references` are
+    # intentionally excluded so a generated relation matches a hand-edited one
+    # regardless of whether either carries a `references`, letting the merge
+    # reconcile them (a hand-edited `references` wins over the generated one).
     def identity
       [table_name, foreign_key, foreign_type, type_value]
     end

data/lib/exwiw/cli.rb

@@ -32,6 +32,7 @@ module Exwiw
       @database_port = nil
       @database_user = nil
       @database_password = ENV["DATABASE_PASSWORD"]
+      @connection_uri = nil
       @output_dir = nil
       @config_dir = nil
       @database_adapter = nil
@@ -64,6 +65,7 @@ module Exwiw
         user: @database_user,
         password: @database_password,
         database_name: @database_name,
+        uri: @connection_uri,
       )
 
       dump_target = DumpTarget.new(
@@ -115,17 +117,21 @@ module Exwiw
 
       resolve_target_collection_alias!
       resolve_ids_column_alias!
+      resolve_uri_option!
 
       if @subcommand == "explain"
         validate_explain_only!
       end
 
       if @database_adapter != "sqlite"
-        required_options = {
-          "Target database host" => @database_host,
-          "Target database port" => @database_port,
-          "Target database name" => @database_name,
-        }
+        # When a connection URI is supplied (mongodb only), host/port/database
+        # are read from the URI, so none of them are required on the CLI.
+        required_options = {}
+        unless @connection_uri
+          required_options["Target database host"] = @database_host
+          required_options["Target database port"] = @database_port
+          required_options["Target database name"] = @database_name
+        end
         required_options["Database user"] = @database_user unless @database_adapter == "mongodb"
         required_options.each do |k, v|
           if v.nil?
@@ -253,6 +259,19 @@ module Exwiw
       end
     end
 
+    # `--uri` supplies a full connection string (e.g. `mongodb+srv://...`) and is
+    # mongodb-only — the SQL adapters shell out to their own client binaries with
+    # discrete host/port/user flags and have no equivalent. Runs after the
+    # adapter name has been normalized so the family check is reliable.
+    private def resolve_uri_option!
+      return if @connection_uri.nil?
+
+      if @database_adapter != "mongodb"
+        $stderr.puts "--uri is only supported by the mongodb adapter (use --host/--port)"
+        exit 1
+      end
+    end
+
     private def validate_explain_only!
       if @database_adapter == "mongodb"
         $stderr.puts "mongodb adapter is not yet supported by 'explain' subcommand"
@@ -354,6 +373,7 @@ module Exwiw
           @config_dir = File.expand_path(v)
         end
         opts.on("-a", "--adapter=ADAPTER", "Database adapter: mysql, sqlite, postgresql, mongodb (aliases: mysql2, sqlite3)") { |v| @database_adapter = v }
+        opts.on("--uri=URI", "Full MongoDB connection URI (mongodb:// or mongodb+srv://). mongodb adapter only; takes precedence over --host/--port/--user. TLS, replicaSet, authSource and credentials are read from the URI.") { |v| @connection_uri = v }
         opts.on("--database=DATABASE", "Target database name") { |v| @database_name = v }
         opts.on("--target-table=[TABLE]", "Target table for extraction. If omitted, dump all tables.") { |v| @target_table_name = v }
         opts.on("--target-collection=[COLLECTION]", "Alias of --target-table for the mongodb adapter.") { |v| @target_collection_name = v }

data/lib/exwiw/mongodb_collection_config.rb

@@ -75,14 +75,16 @@ module Exwiw
         merged.embedded_in = passed.embedded_in
 
         # Structural facts of each belongs_to come from the freshly generated
-        # config, but the user-owned `comment`/`ignore` carry over when the same
-        # relation still exists.
+        # config (including a generator-derived `references`), but the user-owned
+        # `comment`/`ignore` — and a hand-edited `references`, which overrides the
+        # generated one — carry over when the same relation still exists.
         receiver_belongs_to_by_identity = belongs_tos.each_with_object({}) { |bt, h| h[bt.identity] = bt }
         merged.belongs_tos = passed.belongs_tos.map do |pbt|
           receiver_bt = receiver_belongs_to_by_identity[pbt.identity]
           if receiver_bt
             pbt.comment = receiver_bt.comment if receiver_bt.comment
             pbt.ignore = receiver_bt.ignore unless receiver_bt.ignore.nil?
+            pbt.references = receiver_bt.references if receiver_bt.references
           end
           pbt
         end

data/lib/exwiw/mongoid_schema_generator.rb

@@ -220,14 +220,24 @@ module Exwiw
         .uniq
     end
 
-    # Resolves a referenced belongs_to to a `{ table_name, foreign_key }` pair.
+    # Resolves a referenced belongs_to to a `{ table_name, foreign_key }` pair
+    # (plus `references` when the FK points at a non-`_id` parent field).
     # `assoc.klass` raises NameError when the association's target class no longer
     # exists (a stale/legacy `belongs_to`, e.g. pointing at a model removed years
     # ago). Under `skip_unsupported` such a relation is skipped with a warning —
     # its foreign-key column is still tracked as an ordinary field by
     # `aggregate_fields`, mirroring how polymorphic / HABTM relations are dropped.
     private def belongs_to_for(assoc)
-      { table_name: assoc.klass.collection_name.to_s, foreign_key: assoc.foreign_key }
+      result = { table_name: assoc.klass.collection_name.to_s, foreign_key: assoc.foreign_key }
+      # Mongoid's `belongs_to ..., primary_key: :uuid` makes the child's foreign
+      # key reference that parent field rather than the parent's `_id`. Surface
+      # it as `references` so MongodbAdapter constrains children by the right
+      # field (issue B1). Omit it for the default `_id` (the parent primary_key
+      # the generator emits) so existing configs/snapshots are unchanged. SQL
+      # adapters ignore `references`; only MongodbAdapter consumes it.
+      reference_field = assoc.primary_key.to_s
+      result[:references] = reference_field unless reference_field == "_id"
+      result
     rescue NameError, ::Mongoid::Errors::MongoidError => e
       raise e unless @skip_unsupported
 

data/lib/exwiw/table_config.rb

@@ -139,8 +139,10 @@ module Exwiw
         merged_table.ignore = ignore
 
         # Structural facts of each belongs_to come from the freshly generated
-        # config, but the user-owned `comment`/`ignore` carry over when the same
-        # relation still exists.
+        # config, but the user-owned `comment`/`ignore`/`references` carry over
+        # when the same relation still exists. (`references` is only consumed by
+        # the MongodbAdapter, but it lives on the shared BelongsTo, so preserve
+        # it here too rather than silently dropping a hand-added value.)
         receiver_belongs_to_by_identity = belongs_tos.each_with_object({}) { |bt, hash| hash[bt.identity] = bt }
         merged_table.belongs_tos =
           passed_table.belongs_tos.map do |passed_belongs_to|
@@ -148,6 +150,7 @@ module Exwiw
             if receiver_belongs_to
               passed_belongs_to.comment = receiver_belongs_to.comment if receiver_belongs_to.comment
               passed_belongs_to.ignore = receiver_belongs_to.ignore unless receiver_belongs_to.ignore.nil?
+              passed_belongs_to.references = receiver_belongs_to.references if receiver_belongs_to.references
             end
             passed_belongs_to
           end

data/lib/exwiw/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Exwiw
-  VERSION = "0.4.6"
+  VERSION = "0.4.7"
 end

data/lib/exwiw.rb

@@ -40,5 +40,9 @@ module Exwiw
   # the target table. When nil the table's primary key is used (the historical
   # behavior). Currently only honored by the mongodb adapter.
   DumpTarget = Struct.new(:table_name, :ids, :ids_field, keyword_init: true)
-  ConnectionConfig = Struct.new(:adapter, :host, :port, :user, :password, :database_name, keyword_init: true)
+  # `uri` is an optional full connection string (currently only honored by the
+  # mongodb adapter, e.g. `mongodb+srv://...`). When present it is the source of
+  # truth for the connection — host/port/user/password are ignored — so TLS,
+  # replica_set, auth_source, etc. can be expressed via the URI's query string.
+  ConnectionConfig = Struct.new(:adapter, :host, :port, :user, :password, :database_name, :uri, keyword_init: true)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: exwiw
 version: !ruby/object:Gem::Version
-  version: 0.4.6
+  version: 0.4.7
 platform: ruby
 authors:
 - Shia