rails-ai-context 5.35.0 → 5.35.2

data/lib/rails_ai_context/introspectors/model_introspector.rb

@@ -224,9 +224,10 @@ module RailsAiContext
 
             next if mixin_path?(record.path_name.underscore, source)
 
-            declarations = DeclaredConstant.declarations(source, path_name: record.path_name)
-            declaration = DeclaredConstant.declaration_for(declarations, record.path_name)
-            class_name = declaration&.name || record.path_name
+            path_name = SourceScan.concerns_name(record.path_name, source)
+            declarations = DeclaredConstant.declarations(source, path_name: path_name)
+            declaration = DeclaredConstant.declaration_for(declarations, path_name)
+            class_name = declaration&.name || path_name
             # Two files can declare one class (an app reopening a model to add methods);
             # the one that names a superclass defines the model.
             previous = found[class_name]
@@ -245,7 +246,7 @@ module RailsAiContext
           rescue => e
             # The file is known here whatever failed, and a consumer with none
             # derives app/models/<name>.rb, which a pack model does not have.
-            found[record.path_name] = { error: e.message, file: record.file }.compact
+            found[SourceScan.concerns_name(record.path_name, source.to_s)] = { error: e.message, file: record.file }.compact
           end
         end
       end
@@ -391,10 +392,10 @@ module RailsAiContext
       # The tables every other database's dump holds; nil when one of them is not on disk to read.
       def secondary_dump_tables
         RunCache.fetch([ :secondary_dump_tables, app.root.to_s ]) do
-          SchemaDumpPath.secondaries(app.root).values.each_with_object(Set.new) do |(format, path), tables|
-            break nil unless File.exist?(path)
+          AppDatabases.for(app.root).reject(&:primary).filter_map(&:dump).each_with_object(Set.new) do |dump, tables|
+            break nil unless File.exist?(dump.path)
 
-            found = format == :ruby ? SchemaReader.new(path).tables : StructureSqlReader.parse(SafeFile.read(path).to_s)[:tables]
+            found = dump.format == :ruby ? SchemaReader.new(dump.path).tables : StructureSqlReader.parse(SafeFile.read(dump.path).to_s)[:tables]
             tables.merge(found.keys)
           end
         end
@@ -550,16 +551,12 @@ module RailsAiContext
           source.match?(/^[^\S\n]*primary_abstract_class\b/)
       end
 
-      # `concerns/` under app/models is the Zeitwerk root for mixins: it does
-      # not namespace its files, so the path is not their name. A nested
-      # concerns/ is an ordinary namespace - OpenProject fills one with mixins,
-      # but a class declared there is a model like any other.
+      # A file under any concerns/ that is not named for a class. One that is
+      # may be a model: Whitehall keeps one in app/models/concerns itself.
       def mixin_path?(relative, source)
-        segments = relative.split("/")
-        return false unless segments.include?("concerns")
-        return true if segments.first == "concerns"
+        return false unless relative.split("/").include?("concerns")
 
-        !DeclaredConstant.declares_class?(source, path_name: relative.camelize)
+        SourceScan.concern_class(source, SourceScan.concerns_name(relative.camelize, source)).nil?
       end
 
       # A class whose file is inside an installed gem (PaperTrail::Version) is
@@ -596,15 +593,17 @@ module RailsAiContext
 
         known = models.map(&:name).to_set
         @outside_model_dirs = Set.new
-        # Concerns stay in: a nested concerns directory is a namespace, so a
-        # class declared under one is a model and constantize sorts the mixins
-        # out. A top-level `app/models/concerns` is an autoload root instead,
-        # so its files declare no `Concerns::` prefix and that path name never
-        # constantizes.
+        # A nested concerns directory is a namespace, so a class under one is a model;
+        # under the top-level one only a file that declares a class is read on.
         SourceScan.model_paths(app.root, base_model: model_base_check).each do |record|
-          next if record.path_name.start_with?("Concerns::")
-          next if known.include?(record.path_name)
-          next if config.excluded_models.include?(record.path_name)
+          path_name = record.path_name
+          if path_name.start_with?("Concerns::")
+            source = model_source(record.path).to_s
+            path_name = SourceScan.concerns_name(path_name, source)
+          end
+          next if known.include?(path_name)
+          next if config.excluded_models.include?(path_name)
+          next if path_name != record.path_name && mixin_path?(record.path_name.underscore, source)
 
           # The path does not name the class: an app inflection only changes
           # case, so activitypub/activity.rb camelizes to a constant the app
@@ -612,7 +611,7 @@ module RailsAiContext
           # load. A root pushed under a namespace declares a prefix the path
           # lacks. Read only where the camelized name is not already loaded, so
           # a booted run does not parse every model file to learn nothing.
-          class_name = DeclaredConstant.named(model_source(record.path).to_s, record.path_name)
+          class_name = DeclaredConstant.named(model_source(record.path).to_s, path_name)
           next if known.include?(class_name)
           next if config.excluded_models.include?(class_name)
 
@@ -630,10 +629,9 @@ module RailsAiContext
             next unless klass < ActiveRecord::Base && !klass.abstract_class?
             models << klass
             known << class_name
-          rescue NameError, LoadError, ScriptError => e
-            # A syntax-broken file costs itself, not the whole listing, but
-            # its name is recorded: a file that exists for a class reflection
-            # lacks is not the same answer as no such model.
+          rescue StandardError, ScriptError => e
+            # A file that raises as it loads costs itself alone, and its name is recorded:
+            # a file that exists for a class reflection lacks is no missing model.
             @unloadable[class_name] = e.message.to_s.lines.first.to_s.strip
             @outside_model_dirs << class_name unless model_dir_file?(record.path)
           end
@@ -988,7 +986,7 @@ module RailsAiContext
         bases = abstract_bases(model)
         return bases unless model.superclass == ActiveRecord::Base
 
-        bases | ActiveRecord::Base.subclasses.select { |klass| klass.name && klass.abstract_class? }
+        bases | DeclaredConstant.carried(ActiveRecord::Base.subclasses).select(&:abstract_class?)
       end
 
       def every_model_modules
@@ -1138,13 +1136,7 @@ module RailsAiContext
 
         return nil unless has_type_column
 
-        children = if model.respond_to?(:descendants)
-          model.descendants.map(&:name).compact.sort
-        elsif model.respond_to?(:subclasses)
-          model.subclasses.map(&:name).compact.sort
-        else
-          []
-        end
+        children = DeclaredConstant.carried(model.descendants).map(&:name).sort
 
         parent = model.superclass
         sti_parent = if parent && parent != ActiveRecord::Base &&
@@ -2245,15 +2237,17 @@ module RailsAiContext
               source = model_source(path)
               next if source.nil? || mixin_path?(relative, source) || abstract_class?(source)
 
+              path_name = SourceScan.concerns_name(relative.camelize, source)
+
               # The static tier never loads the app's inflector, so camelizing alone
               # would invent `Activitypub::` for an app that declares `ActivityPub::`.
-              class_name = DeclaredConstant.resolve(source, relative.camelize)
+              class_name = DeclaredConstant.resolve(source, path_name)
               next if found.key?(class_name) || config.excluded_models.include?(class_name)
 
-              declaration = DeclaredConstant.declaration_for(DeclaredConstant.declarations(source, path_name: relative.camelize), class_name)
+              declaration = DeclaredConstant.declaration_for(DeclaredConstant.declarations(source, path_name: path_name), class_name)
               found[class_name] = { path: path, source: source, superclass: declaration&.superclass, nesting: declaration&.nesting }
             rescue => e
-              found[relative.camelize] ||= { error: e.message }
+              found[path_name || relative.camelize] ||= { error: e.message }
             end
           end
         end

data/lib/rails_ai_context/introspectors/multi_database_introspector.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "uri"
+
 module RailsAiContext
   module Introspectors
     # Discovers multi-database configuration: multiple databases, replicas,
@@ -13,22 +15,37 @@ module RailsAiContext
         dbs = discover_databases
         {
           databases: dbs,
-          replicas: dbs.select { |d| d[:replica] }.map { |d| { name: d[:name], adapter: d[:adapter] } },
+          replicas: dbs.select { |d| d[:replica] }.map { |d| d.slice(:name, :adapter, :environments) },
           sharding: detect_sharding,
           model_connections: detect_model_connections,
           multi_db: dbs.size > 1
-        }.merge({ example_adapters: example_adapters }.compact)
+        }.merge(from_configuration)
+      end
+
+      # What the section says of each database by name, read from configuration alone.
+      def listing
+        { databases: discover_databases }.merge(from_configuration)
       end
 
       private
 
+      def from_configuration
+        { example_adapters: example_adapters, primary_name: primary_name }.compact
+      end
+
+      # The primary's database.yml name where it is not "primary": a generated file tells it from a database that is.
+      def primary_name
+        name = RailsAiContext::AppDatabases.for(root).primary&.name.to_s
+        name unless name.empty? || name == "primary"
+      rescue => e
+        RailsAiContext.debug_fail(e, nil, label: "primary_name")
+      end
+
+      # Every app database; one the running environment does not configure names where it is configured.
       def discover_databases
-        booted = booted_databases
-        # A boot that failed leaves the handlers empty without raising, and an
-        # app that declares two databases is not an app with none.
-        booted.any? ? booted : file_databases
+        RailsAiContext::AppDatabases.for(root).map { |db| database_entry(db) }
       rescue => e
-        RailsAiContext.debug_fail(e, file_databases, label: "discover_databases")
+        RailsAiContext.debug_fail(e, [], label: "discover_databases")
       end
 
       # Adapters in the example database files of an app that commits none, read by line since
@@ -113,30 +130,16 @@ module RailsAiContext
         end
       end
 
-      def booted_databases
-        return [] unless defined?(ActiveRecord::Base)
-
-        ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, include_hidden: true).map do |config|
-          info = { name: config.name, adapter: config.adapter }
-          info[:database] = anonymize_db_name(config.database) if config.database
-          info[:replica] = true if config.respond_to?(:replica?) && config.replica?
-          info
+      def database_entry(db)
+        info = { name: db.name, adapter: db.adapter }
+        info[:adapter_default] = true if db.adapter_default
+        database = db.config.database if db.config.respond_to?(:database)
+        info[:database] = anonymize_db_name(database) if database
+        info[:replica] = true if db.replica
+        # Configured only in another environment, or only a committed dump names it.
+        unless db.here
+          db.environments.any? ? info[:environments] = db.environments : info[:dump_only] = true
         end
-      end
-
-      def file_databases
-        databases = RailsAiContext::DatabaseYml.databases(root)
-        # Rails builds the primary from DATABASE_URL when the file has no entry for the env.
-        return ENV["DATABASE_URL"].to_s.empty? ? [] : [ database_entry("primary", {}) ] if databases.empty?
-
-        databases.map { |name, entry| database_entry(name, entry) }
-      end
-
-      def database_entry(name, entry)
-        adapter, from_default = RailsAiContext::DatabaseYml.adapter(name, entry)
-        info = { name: name.to_s, adapter: adapter }
-        info[:adapter_default] = true if from_default
-        info[:replica] = true if entry["replica"] == true
         info
       end
 

data/lib/rails_ai_context/introspectors/node_source.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "prism"
+
 module RailsAiContext
   module Introspectors
     # A node's source with its heredoc bodies: Prism's `slice` stops at the node's end, so

data/lib/rails_ai_context/introspectors/performance_introspector.rb

@@ -18,27 +18,68 @@ module RailsAiContext
       attr_writer :context
 
       def call
-        schema_data = load_schema_data
         model_data = load_model_data
+        schemas, unchecked = database_schemas
+        counter_cache = []
+        fk_indexes = []
+        schemas.each do |name, tables, foreign_keys|
+          tag = ->(finding) { name ? finding.merge(database: name) : finding }
+          counter_cache.concat(detect_missing_counter_cache(model_data, tables).map(&tag))
+          fk_indexes.concat(detect_missing_fk_indexes(tables, model_data, foreign_keys).map(&tag))
+        end
 
         {
           n_plus_one_risks: detect_n_plus_one,
-          missing_counter_cache: detect_missing_counter_cache(model_data, schema_data),
-          missing_fk_indexes: detect_missing_fk_indexes(schema_data, model_data, load_foreign_keys),
+          missing_counter_cache: counter_cache.uniq { |f| f.except(:database) },
+          missing_fk_indexes: fk_indexes,
           model_all_in_controllers: detect_model_all_in_controllers(model_data),
           eager_load_candidates: detect_eager_load_candidates(model_data),
           summary: nil # populated below
-        }.tap { |result| result[:summary] = build_summary(result) }
+        }.tap do |result|
+          result[:unchecked_databases] = unchecked if unchecked.any?
+          result[:summary] = build_summary(result)
+        end
       end
 
       private
 
-      def load_schema_data
-        SchemaReader.for(root).tables
+      # [[database name (nil for the primary), tables, foreign keys]], and { name:, reason: } for each database not read.
+      def database_schemas
+        reader = SchemaReader.for(root)
+        schemas = [ [ nil, reader.tables, reader.foreign_keys ] ]
+        unchecked = []
+        databases = AppDatabases.for(root)
+        # Rails names one file for the first database and the one named primary. It is read once, above.
+        shared = databases.primary&.dump&.path
+        databases.reject { |db| db.primary || db.replica || (shared && db.dump&.path == shared) }.each do |db|
+          read = read_dump(db)
+          read[:reason] ? unchecked << { name: db.name, reason: read[:reason] } : schemas << [ db.name, read[:tables], read[:foreign_keys] ]
+        end
+        [ schemas, unchecked ]
+      end
+
+      # { tables:, foreign_keys: } from the database's dump, or { reason: } saying why there is none to read.
+      def read_dump(db)
+        return { reason: no_dump_reason(db) } unless db.dump
+
+        path = db.dump.path
+        shown = path.delete_prefix("#{root.to_s.chomp('/')}/")
+        return { reason: "#{shown} is not on disk" } unless File.exist?(path)
+
+        content = SafeFile.read(path, max_size: RailsAiContext.configuration.max_schema_file_size)
+        return { reason: "#{shown} is over max_schema_file_size" } unless content
+        return SchemaReader.new(path).then { |schema| { tables: schema.tables, foreign_keys: schema.foreign_keys } } if db.dump.format == :ruby
+
+        tables = StructureSqlReader.parse(content)[:tables]
+        { tables: tables,
+          foreign_keys: tables.values.flat_map { |table| Array(table[:foreign_keys]).map { |fk| { from: fk[:from_table], to: fk[:to_table], column: fk[:column] } } } }
       end
 
-      def load_foreign_keys
-        SchemaReader.for(root).foreign_keys
+      def no_dump_reason(db)
+        return "its database.yml entry turns `database_tasks` off, so Rails writes it no dump" unless db.tasks
+        return "its database.yml entry turns `schema_dump` off, so Rails writes it no dump" unless db.settings["schema_dump"]
+
+        "`schema_dump` in its database.yml entry names no file this check reads"
       end
 
       # The models section when the run has one; otherwise the model tier is
@@ -77,7 +118,7 @@ module RailsAiContext
           ast = SourceIntrospector.walk_source(record.source, {
             classes: Listeners::ClassDefinitionListener,
             associations: Listeners::AssociationsListener,
-            tree: TREE_LISTENER,
+            column_macros: COLUMN_MACRO_LISTENER,
             mixins: Listeners::MixinsListener,
             counter_culture: -> { Listeners::GenericMacroListener.new(:counter_culture) }
           })
@@ -106,7 +147,7 @@ module RailsAiContext
             table_name: model_table(class_name),
             has_many: has_many,
             belongs_to: belongs_to,
-            tree_parent_keys: tree_parent_keys(ast, class_name),
+            macro_columns: macro_columns(ast, class_name),
             counter_cultures: ast[:counter_culture].map { |c| counter_culture_record(c) }
           }
         rescue => e
@@ -114,24 +155,39 @@ module RailsAiContext
         end
       end
 
-      # Gem macros that declare a parent key, with the option that renames it.
-      # ponytail: a fixed list; a gem outside it declares keys the static walk cannot see.
+      # Tree gem macros, which declare a parent key, with the option that renames it.
       TREE_MACROS = { acts_as_tree: :foreign_key, acts_as_nested_set: :parent_column,
                       has_closure_tree: :parent_column_name }.freeze
-      TREE_LISTENER = -> { Listeners::GenericMacroListener.new(*TREE_MACROS.keys) }
-      TREE_CONCERN_LISTENERS = { tree: TREE_LISTENER, mixins: Listeners::MixinsListener }.freeze
-
-      # The parent key a tree macro declares, in the model or its concerns.
+      # paper_trail adds `has_many :versions, as: :item` when the app boots.
+      VERSIONS_MACRO = :has_paper_trail
+      # Gem macros that declare a column.
+      # ponytail: a fixed list; a gem outside it declares columns the static walk cannot see.
+      COLUMN_MACROS = [ *TREE_MACROS.keys, VERSIONS_MACRO ].freeze
+      COLUMN_MACRO_LISTENER = -> { Listeners::GenericMacroListener.new(*COLUMN_MACROS) }
+      COLUMN_MACRO_CONCERN_LISTENERS = { column_macros: COLUMN_MACRO_LISTENER, mixins: Listeners::MixinsListener }.freeze
+
+      # The [table, column] a gem macro declares, in the model or its concerns.
       # The models section cannot carry it statically: the macro is a gem's.
-      def tree_parent_keys(ast, class_name)
-        collected = ConcernMacros.collect(root, ast[:mixins], keys: %i[tree], prefer: "model",
+      def macro_columns(ast, class_name)
+        collected = ConcernMacros.collect(root, ast[:mixins], keys: %i[column_macros], prefer: "model",
                                           within: class_name, cache: (@concern_cache ||= {}),
-                                          listeners: TREE_CONCERN_LISTENERS).collected
-        (ast[:tree] + Array(collected[:tree])).map do |macro|
-          ((macro[:options] || {})[TREE_MACROS[macro[:macro]]] || "parent_id").to_s
+                                          listeners: COLUMN_MACRO_CONCERN_LISTENERS).collected
+        (ast[:column_macros] + Array(collected[:column_macros])).map do |macro|
+          options = macro[:options] || {}
+          next [ versions_table(options, class_name), "item_id" ] if macro[:macro] == VERSIONS_MACRO
+
+          [ model_table(class_name), (options[TREE_MACROS[macro[:macro]]] || "parent_id").to_s ]
         end
       end
 
+      # PaperTrail::Version reads `versions`; `versions: { class_name: }`, or the older `class_name:`, names another class.
+      def versions_table(options, owner)
+        written = options[:versions].is_a?(Hash) ? options[:versions][:class_name] : options[:class_name]
+        return "versions" unless written.is_a?(String)
+
+        table_of(TableName.resolve_class(written, owner) { |candidate| candidate if resolved_models.key?(candidate) } || written, resolved_models)
+      end
+
       # The scan reads the run models section, so an association a concern or a
       # base declares is one it can follow.
       def detect_n_plus_one
@@ -271,9 +327,9 @@ module RailsAiContext
         end
       end
 
-      def tree_parent_columns(model_data)
+      def macro_declared_columns(model_data)
         Array(model_data).each_with_object(Set.new) do |model, found|
-          Array(model[:tree_parent_keys]).each { |key| found << [ model[:table_name].to_s, key ] }
+          Array(model[:macro_columns]).each { |column| found << column }
         end
       end
 
@@ -285,7 +341,7 @@ module RailsAiContext
       def detect_missing_fk_indexes(schema_data, model_data = [], foreign_keys = [])
         missing = []
         declared = foreign_key_columns(foreign_keys) | association_columns(resolved_models) |
-                   tree_parent_columns(model_data)
+                   macro_declared_columns(model_data)
 
         schema_data.each do |table_name, table|
           columns = table[:columns]

data/lib/rails_ai_context/introspectors/pg_partitions.rb

@@ -7,9 +7,6 @@ module RailsAiContext
     module PgPartitions
       module_function
 
-      # activerecord-postgis-adapter reports "PostGIS" for what is a PostgreSQL connection.
-      POSTGRES_ADAPTER = /postg/i
-
       # Scoped the way connection.tables is.
       NAMES_SQL = <<~SQL.squish.freeze
         SELECT c.relname FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
@@ -19,7 +16,7 @@ module RailsAiContext
       def names(conn)
         # relispartition arrived with partitions in 10; querying it before then
         # fails, and a failed query aborts any open transaction.
-        return [] unless conn.adapter_name.match?(POSTGRES_ADAPTER) && conn.database_version >= 10_00_00
+        return [] unless RailsAiContext::DatabaseFamily.of(conn).postgresql? && conn.database_version >= 10_00_00
 
         conn.select_values(NAMES_SQL)
       rescue => e

data/lib/rails_ai_context/introspectors/schema_conventions.rb

@@ -196,17 +196,15 @@ module RailsAiContext
       # primary, sqlite queue) and each dump must be typed by its own. dump_path
       # names a secondary database's dump, nil the primary's; database: names the database outright.
       def implicit_pk_type(root, dump_path = nil, database: SchemaDumpPath.database_name(root, dump_path))
-        adapter = database_adapter_for(root, database)
-        adapter&.start_with?("sqlite") ? "integer" : "bigint"
+        RailsAiContext::DatabaseFamily.of(database_adapter_for(root, database)).implicit_pk_type
       end
 
-      # The running environment's adapter for one database, as database.yml and a merged URL name it.
-      # A database it does not configure (Rails 8's queue outside production) takes the adapter of the
-      # environment that does, else the running primary's.
+      # One app database's adapter, the primary's for no name. A database only another environment configures (Rails 8's queue
+      # outside production) takes that environment's; one only a dump names, the primary's.
       def database_adapter_for(root, db_name)
-        yml = RailsAiContext::DatabaseYml
-        entry = yml.entry(root, db_name) || yml.elsewhere(root, db_name)&.last
-        yml.adapter(db_name, entry).first || (yml.adapter("primary", yml.primary(root)).first unless entry)
+        databases = RailsAiContext::AppDatabases.for(root)
+        found = databases.of_dump_name(db_name)
+        found&.config ? found.adapter : databases.primary&.adapter
       end
 
       # A primary key as connection.primary_key gives it: the column's name, or

data/lib/rails_ai_context/introspectors/schema_dump_path.rb

@@ -20,24 +20,22 @@ module RailsAiContext
         end
       end
 
-      # Each secondary database's dump by its database.yml name, as schema_dump_path names it:
-      # its schema_dump, else <name>_schema.rb or <name>_structure.sql in its format.
-      def secondaries(root)
-        root = root.to_s
-        RailsAiContext::RunCache.fetch([ :secondary_schema_dumps, root ]) do
-          RailsAiContext::DatabaseYml.task_secondaries(root).each_with_object({}) do |(name, entry), found|
-            format = schema_format(root, entry)
-            dump = entry.key?("schema_dump") ? configured(root, entry, format) : [ format, File.join(root, "db", "#{name}_#{FILE_NAMES[format]}") ]
-            found[name] = dump if dump
-          end
-        end
+      # A secondary database's dump: the file schema_dump_path names (its schema_dump, else <name>_schema.rb or
+      # <name>_structure.sql in its format) when on disk, else a file under its name in either format. nil for none.
+      def secondary(root, name, config)
+        format = schema_format(root, config)
+        own = configured(root, config, format) if config.key?("schema_dump")
+        # Rails gives an entry named primary the unprefixed file wherever it stands.
+        named = [ format, *(FILE_NAMES.keys - [ format ]) ].map { |f| [ f, File.join(root, "db", "#{"#{name}_" unless name == "primary"}#{FILE_NAMES[f]}") ] }
+        [ own, *named ].compact.find { |_, path| File.exist?(path) } || (config.key?("schema_dump") ? own : named.first)
       end
 
-      # The database a dump belongs to: the secondary whose dump it is, else the one its file name says.
+      # The database a dump belongs to: the app database whose dump it is, else the one its file name says.
+      # No dump is the primary's.
       def database_name(root, dump_path)
-        return "primary" if dump_path.nil?
+        return RailsAiContext::AppDatabases.for(root).primary&.name || "primary" if dump_path.nil?
 
-        named = secondaries(root).find { |_, (_, path)| path == dump_path.to_s }&.first
+        named = RailsAiContext::AppDatabases.for(root).find_by_dump(dump_path)&.name
         named || File.basename(dump_path.to_s).sub(/\.(rb|sql)\z/, "").sub(/_?(schema|structure)\z/, "").then { |name| name.empty? ? "primary" : name }
       end
 

data/lib/rails_ai_context/introspectors/schema_introspector.rb

@@ -143,17 +143,20 @@ module RailsAiContext
         RailsAiContext.debug_fail(e, "unknown", label: "adapter_name")
       end
 
+      def family
+        RailsAiContext::DatabaseFamily.of(adapter_name)
+      end
+
       def sqlite?
-        adapter_name.to_s.match?(/sqlite/i)
+        family.sqlite?
       end
 
       def postgres?
-        adapter_name.to_s.match?(/postg/i)
+        family.postgresql?
       end
 
-      # Every MySQL adapter inherits mariadb? from AbstractMysqlAdapter.
       def mysql?
-        connection.respond_to?(:mariadb?)
+        RailsAiContext::DatabaseFamily.of(connection).mysql?
       end
 
       def connection
@@ -593,31 +596,41 @@ module RailsAiContext
         @secondary_database_dumps ||= read_secondary_database_dumps
       end
 
-      # [name, format, path] for each secondary database's dump on disk, the configured first.
+      def app_databases
+        RailsAiContext::AppDatabases.for(app.root)
+      end
+
+      # [name, format, path] for each other database's dump on disk, in the app databases' order.
       def secondary_dump_files
         primary = dump_candidates.map(&:last)
-        configured = SchemaDumpPath.secondaries(app.root).map { |name, (format, path)| [ name, format, path ] }
-        taken = primary + configured.map(&:last)
-        globbed = SchemaDumpPath::FILE_NAMES.flat_map do |format, file|
-          kind, ext = file.split(".")
-          Dir.glob(File.join(app.root.to_s, "db", "*_#{kind}.#{ext}")).sort
-            .reject { |path| taken.include?(path) }
-            .map { |path| [ File.basename(path, ".#{ext}").delete_suffix("_#{kind}"), format, path ] }
+        app_databases.filter_map do |db|
+          path = db.dump&.path
+          [ db.name, db.dump.format, path ] if path && !db.primary && !primary.include?(path) && File.exist?(path)
         end
-        (configured + globbed).reject { |_, _, path| primary.include?(path) || !File.exist?(path) }
       end
 
+      NO_TABLES = "declares no tables"
+
+      # A dump too large to read, or holding no tables, keeps an entry that says so.
       def read_secondary_database_dumps
+        unread = {}
         dumps = secondary_dump_files.each_with_object({}) do |(name, format, path), found|
-          next if found.key?(name)
-
           parsed = parse_dump(format, path)
-          next if parsed[:tables].blank?
+          if parsed[:tables].blank?
+            unread[name] = [ path, parsed[:error]&.delete_prefix("#{relative_dump_path(path)} ") || NO_TABLES ]
+            next
+          end
 
           parsed[:note] = "Parsed from #{relative_dump_path(path)} (from committed dump, not a live connection)"
           found[name] = parsed.merge(database_files(path, migrate_dir_for_dump(path)))
         end
-        replay_secondary_migrations(dumps)
+        replay_secondary_migrations(dumps, unread)
+        unread.each do |name, (path, state)|
+          dumps[name] ||= { tables: {}, total_tables: 0, note: "#{relative_dump_path(path)} #{state}, so its tables are not listed" }
+                          .merge(database_files(path, migrate_dir_for_dump(path)), state == NO_TABLES ? {} : { unread: true })
+        end
+        names = app_databases.names
+        dumps.sort_by { |name, _| names.index(name) || names.size }.to_h
       end
 
       # Where a secondary database's schema lives, app-relative, so a rule
@@ -627,22 +640,29 @@ module RailsAiContext
         { dump: (relative_dump_path(dump) if dump), migrations_paths: (dirs if dirs.any?) }.compact
       end
 
-      # A database whose dump is not written yet answers from its own migrations_paths.
-      def replay_secondary_migrations(dumps)
-        RailsAiContext::DatabaseYml.task_secondaries(app.root).each do |name, entry|
-          next if dumps.key?(name)
+      # A database whose dump gives no tables answers from its own migrations_paths.
+      def replay_secondary_migrations(dumps, unread)
+        app_databases.secondaries.each do |db|
+          name = db.name
+          dirs = db.migrate_dirs
+          next if dumps.key?(name) || dirs.empty? || dirs == [ migrations_dir ]
 
-          dirs = MigrationReplay.configured_dirs(app.root.to_s, entry) or next
           pk_type = SchemaConventions.implicit_pk_type(app.root.to_s, database: name)
           tables = MigrationReplay.tables(dirs, pk_type: pk_type, root: app.root.to_s,
                                                 adapter: SchemaConventions.database_adapter_for(app.root.to_s, name))
           next if tables.empty?
 
           tables.each_value { |table| SchemaConventions.mark_primary_key(table) }
-          _, dump = SchemaDumpPath.secondaries(app.root)[name]
+          dump = db.dump&.path
+          path, state = unread[name]
+          said = if path then "#{relative_dump_path(path)} #{state}"
+          elsif dump && File.exist?(dump) && secondary_dump(dump).nil?
+            "#{relative_dump_path(dump)} is read as the #{app_databases.primary.name} database's dump"
+          else "no #{dump ? relative_dump_path(dump) : "#{name}_schema.rb"}"
+          end
           dumps[name] = {
             adapter: "static_parse", tables: tables, total_tables: SchemaConventions.table_count(tables),
-            note: "Reconstructed from the migrations in #{dirs.map { |dir| relative_dump_path(dir) }.join(', ')} (#{connection_state}, no #{dump ? relative_dump_path(dump) : "#{name}_schema.rb"})"
+            note: "Reconstructed from the migrations in #{dirs.map { |dir| relative_dump_path(dir) }.join(', ')} (#{connection_state}, #{said})"
           }.merge(database_files(dump, dirs))
         end
         dumps
@@ -721,8 +741,8 @@ module RailsAiContext
       end
 
       def dump_lookup(database)
-        adapter = SchemaConventions.database_adapter_for(app.root.to_s, database || "primary")
-        return if adapter && !adapter.start_with?("postg")
+        adapter = SchemaConventions.database_adapter_for(app.root.to_s, database)
+        return if adapter && !RailsAiContext::DatabaseFamily.of(adapter).postgresql?
 
         _, format, path = database ? secondary_dump_files.find { |name, _, _| name == database } : [ nil, *present_dump ]
         return unless path && File.exist?(path)
@@ -878,7 +898,7 @@ module RailsAiContext
       def parse_migrations
         pk_type = SchemaConventions.implicit_pk_type(app.root.to_s)
         replayed = MigrationReplay.replayed(migrations_dirs, pk_type: pk_type, root: app.root.to_s,
-                                            adapter: SchemaConventions.database_adapter_for(app.root.to_s, "primary"))
+                                            adapter: SchemaConventions.database_adapter_for(app.root.to_s, nil))
         tables = replayed.tables
         tables.each_value { |table| SchemaConventions.mark_primary_key(table) }