rails-ai-context 5.30.2 → 5.32.0

data/lib/rails_ai_context/introspectors/rendered_record.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Introspectors
+    # The records a bare `render @post.comments` hands to Rails, and the partial Rails renders for them.
+    # Only the conventional model file is read: app/models/<model>.rb.
+    module RenderedRecord
+      LISTENERS = { associations: Listeners::AssociationsListener, methods: Listeners::MethodsListener }.freeze
+      COLLECTIONS = %w[has_many has_and_belongs_to_many].freeze
+
+      # `associations` by name: [model, collection?], or :unknown for a polymorphic or computed class.
+      # `partial_path` is nil when the model's own to_partial_path returns no literal.
+      Model = Data.define(:associations, :partial_path)
+
+      module_function
+
+      # [the model, whether it is a collection] for a chain such as "post.comments.reverse": the
+      # receiver, then each association its model declares. A call that is no association keeps a
+      # collection's records (`.first`, `.recent`); on a single record it returns who knows what, so nil.
+      # A receiver that is no model (`current_user.posts`) is read from the next name, as `render @posts`
+      # is; nil when the app holds no model for that either.
+      def resolve(chain, root, memo = {})
+        segments = chain.split(".")
+        return [ segments.first.singularize, segments.first != segments.first.singularize ] if segments.size == 1
+
+        segments = segments.drop(1) unless read(segments.first.singularize, root, memo)
+        model = segments.first.singularize
+        return nil unless read(model, root, memo)
+
+        collection = segments.first != model
+        segments.drop(1).each do |segment|
+          target = read(model, root, memo)&.associations&.[](segment)
+          return nil if target == :unknown || (target.nil? && !collection)
+          model, collection = target if target
+        end
+        [ model, collection ]
+      end
+
+      # The model's own literal to_partial_path, else ActiveModel's default; nil when it computes one.
+      def partial_path(model, root, memo = {})
+        found = read(model, root, memo)
+        found ? found.partial_path : default_path(model)
+      end
+
+      def default_path(model)
+        "#{model.pluralize}/#{model.split('/').last}"
+      end
+
+      def read(model, root, memo)
+        memo.fetch(model) do
+          memo[model] = begin
+            relative = "app/models/#{model}.rb"
+            model_file(File.join(root.to_s, relative), model) if SafePath.locate(relative, under: root.to_s).ok?
+          end
+        end
+      rescue => e
+        RailsAiContext.debug_fail(e, nil, label: "RenderedRecord.read")
+      end
+
+      def model_file(path, model)
+        walked = SourceIntrospector.walk(path, LISTENERS)
+        associations = Array(walked[:associations]).to_h { |assoc| [ assoc[:name].to_s, target(assoc) ] }
+        own = ActionResolver.own_methods(walked[:methods], model.camelize)
+                            .find { |m| m[:scope] == :instance && m[:name].to_s == "to_partial_path" }
+        Model.new(associations, own ? literal_return(path, own[:offset]) : default_path(model))
+      end
+
+      def target(assoc)
+        options = assoc[:options] || {}
+        # A through association's class is its source's, declared on another model; a named source is not the name.
+        return :unknown if options[:polymorphic] || (options.key?(:source) && !options.key?(:class_name))
+
+        class_name = options[:class_name]
+        return :unknown if options.key?(:class_name) && (!class_name.is_a?(String) || class_name == Confidence::INFERRED)
+
+        model = class_name ? class_name.delete_prefix("::").underscore : assoc[:name].to_s.singularize
+        [ model, COLLECTIONS.include?(assoc[:type].to_s) ]
+      end
+
+      # The string a one-line `def` at `offset` returns.
+      def literal_return(path, offset)
+        body = AstWalk.def_at(AstCache.parse(path).value, offset)&.body&.body
+        body&.size == 1 && body.first.is_a?(Prism::StringNode) ? body.first.unescaped : nil
+      end
+    end
+  end
+end

data/lib/rails_ai_context/introspectors/retry_policy.rb

@@ -2,10 +2,13 @@
 
 module RailsAiContext
   module Introspectors
-    # A job's retry macro as a reader would write it: the exception list, then `attempts:` and
-    # `wait:` in that order, read off the call so a multi-line macro reads the same.
+    # A job's retry macro as a reader would write it: the exception list, then its options in
+    # the order below, read off the call so a multi-line macro reads the same.
     module RetryPolicy
-      MACROS = %i[retry_on discard_on sidekiq_options].freeze
+      # Sidekiq's backoff and its last-retry handler take only a block.
+      BLOCK_MACROS = %i[sidekiq_retry_in sidekiq_retries_exhausted].freeze
+      MACROS = (%i[retry_on discard_on sidekiq_options] + BLOCK_MACROS).freeze
+      RETRY_ON_OPTIONS = %i[attempts wait queue priority jitter].freeze
 
       module_function
 
@@ -18,13 +21,13 @@ module RailsAiContext
           when :retry_on then with_options("retry_on #{hit[:values].join(', ')}", options)
           when :discard_on then "discard_on #{hit[:values].join(', ')}"
           when :sidekiq_options then "sidekiq retry: #{source_of(options[:retry])}" if options[:retry]
+          when *BLOCK_MACROS then "#{hit[:macro]} #{hit[:block]}".strip
           end
         end
       end
 
       def with_options(entry, options)
-        entry += ", attempts: #{source_of(options[:attempts])}" if options[:attempts]
-        entry += ", wait: #{source_of(options[:wait])}" if options[:wait]
+        RETRY_ON_OPTIONS.each { |key| entry += ", #{key}: #{source_of(options[key])}" if options[key] }
         entry
       end
 

data/lib/rails_ai_context/introspectors/route_introspector.rb

@@ -38,9 +38,15 @@ module RailsAiContext
           result[:dynamic_routes] = dynamic if dynamic.positive?
           engine_routes = booted_engine_routes
           result[:engine_routes] = engine_routes if engine_routes.any?
+          add_grape_endpoints(result)
         end
       end
 
+      def add_grape_endpoints(result)
+        grape = GrapeEndpoints.call(app.root, result[:mounted_engines])
+        result[:grape_endpoints] = grape if grape.any?
+      end
+
       # Static tier: answer route questions from config/routes.rb and the
       # files it draws.
       # Output mirrors the runtime shape exactly so tools, resources, and
@@ -53,9 +59,10 @@ module RailsAiContext
         return { error: "config/routes.rb not found in #{app.root}" } if top_files.empty?
 
         records, mounts, files = walk_route_files(top_files)
+        records = records.map { |r| r.except(:engine) } if engine_root?
         in_repo = in_repo_routes(mounts)
         records += in_repo.values.flat_map(&:first)
-        mounts = (mounts + in_repo.values.flat_map(&:last)).uniq { |mount| [ mount[:engine], mount[:path] ] }
+        mounts = distinct_mounts(mounts + in_repo.values.flat_map(&:last))
         # What an app draws into an engine's table is the engine's, which the
         # booted tier's Rails.application.routes holds only as the mount.
         app_records, engine_records = records.partition { |r| r[:engine].nil? }
@@ -72,12 +79,13 @@ module RailsAiContext
           total_routes: RouteCoverage.dedupe_put_patch_routes(entries).size,
           by_controller: group_by_controller(entries),
           api_namespaces: api_namespaces(entries),
-          mounted_engines: mounts.map { |m| { engine: m[:engine], path: m[:path] } },
+          mounted_engines: mounts.map { |m| { engine: m[:engine], path: m[:path], condition: m[:condition] }.compact },
           # Every mount parsed from routes.rb is controller-less by
           # construction, so the booted tier's count has a static answer too.
           unrouted_mounts: mounts.size,
           root_route: static_root_route(entries),
           note: "Parsed statically from #{static_sources_phrase(files, top_files)}" \
+                "#{initializers_phrase}" \
                 "#{computed ? ', plus route files config/application.rb computes (not read)' : ''} (app not booted)",
           confidence: Confidence::STATIC
         }
@@ -86,9 +94,20 @@ module RailsAiContext
         result[:engine_routes] = engine_routes if engine_routes.any?
         unread = (in_repo_route_files - in_repo.keys).size
         result[:in_repo_route_files] = unread if unread.positive?
+        add_grape_endpoints(result)
         result
       end
 
+      # Run from a mountable engine's own root there is no app table: the
+      # engine's table, drawn in its config/routes.rb, is the project's routes.
+      def engine_root?
+        return @engine_root unless @engine_root.nil?
+
+        root = app.root.to_s
+        @engine_root = !File.exist?(File.join(root, "config", "application.rb")) &&
+                       !app_route_file?(File.join(root, "config", "routes.rb"))
+      end
+
       # Every routes.rb under an in-repo engine or plugin root. One the app does not mount has
       # no place in the static table, so the count says it was skipped.
       def in_repo_route_files
@@ -251,9 +270,13 @@ module RailsAiContext
         []
       end
 
-      # Both arms of an if/else can mount one app at one path; a mount is
-      # named once per app and path.
+      # Booted, the routes section walks these for mount conditions and the
+      # engines section for its mount list, so one run walks them once.
       def walk_route_files(top_files)
+        RunCache.fetch([ :route_walk, app.root.to_s, top_files ]) { walk_route_files!(top_files) }
+      end
+
+      def walk_route_files!(top_files)
         already_read = []
         @route_names = Set.new
         records, mounts, files = top_files.each_with_object([ [], [], [] ]) do |path, (all_records, all_mounts, all_files)|
@@ -264,7 +287,86 @@ module RailsAiContext
           all_mounts.concat(sub_mounts)
           all_files.concat(sub_files)
         end
-        [ records, mounts.uniq { |mount| [ mount[:engine], mount[:path] ] }, files.uniq ]
+        added, added_mounts = walk_route_initializers(already_read)
+        # An after_initialize hook adds its blocks after every initializer has added its own.
+        prepended, appended = added.sort_by.with_index { |r, i| [ r[:late] ? 1 : 0, i ] }.partition { |r| r[:prepend] }
+        records = (prepended + records + appended).map { |r| r.except(:prepend, :late) }
+        [ records, distinct_mounts(mounts + added_mounts), files.uniq ]
+      end
+
+      # Both arms of an if/else can mount one app at one path; a mount is named once per app and
+      # path, under no condition when a copy has none or the copies fill every arm of one chain.
+      def distinct_mounts(mounts)
+        mounts.group_by { |mount| [ mount[:engine], mount[:path] ] }.map do |_, same|
+          mount = same.first.except(:condition, :arm)
+          conditions = same.map { |copy| copy[:condition] }.uniq
+          next mount if conditions.include?(nil) || every_arm?(same.map { |copy| copy[:arm] })
+
+          mount = mount.merge(merged: true) if conditions.size > 1
+          mount.merge(condition: conditions.join(" or "))
+        end
+      end
+
+      def every_arm?(arms)
+        return false if arms.include?(nil)
+
+        chain = arms.first.first(2)
+        arms.all? { |arm| arm.first(2) == chain } && arms.map { |arm| arm[2] }.uniq.size == arms.first.last
+      end
+
+      # Initializers that add to the app's table with `routes.prepend` or
+      # `routes.append`, which Rails evaluates before and after the draw.
+      def route_initializers
+        @route_initializers ||= begin
+          root = app.root.to_s
+          PathResolver.initializer_paths(root).select do |path|
+            # Regex prefilter over every initializer; walk_draw_target's AST walk decides.
+            SafeFile.read(path).to_s.match?(/\.routes\.(?:append|prepend)\b/) && app_route_file?(path)
+          end
+        end
+      end
+
+      def walk_route_initializers(already_read)
+        route_initializers.each_with_object([ [], [] ]) do |path, (records, mounts)|
+          sub_records, sub_mounts = walk_draw_target(path, already_read, 0, {})
+          records.concat(sub_records)
+          mounts.concat(sub_mounts)
+        end
+      end
+
+      # The controller#action rows of a route set; the engines section counts an engine's table with them.
+      def table_routes(route_set)
+        route_set.routes.filter_map do |route|
+          # Journey::Route exposes the flag as a plain attribute reader
+          # (`internal`), not a predicate - a respond_to?(:internal?) guard
+          # never matches and would let Rails' info/mailers routes through.
+          next if route.respond_to?(:internal) && route.internal
+          next if route.defaults[:controller].blank?
+
+          route_path = route.path.spec.to_s.gsub("(.:format)", "")
+          action = route.defaults[:action]
+
+          entry = {
+            verb: route.verb.presence || "ANY",
+            path: route_path,
+            controller: route.defaults[:controller],
+            action: action,
+            name: route.name,
+            constraints: extract_constraints(route)
+          }
+
+          params = route_path.scan(/:(\w+)/).flatten
+          entry[:params] = params if params.any?
+
+          entry[:restful] = %w[index show new create edit update destroy].include?(action)
+
+          entry.compact
+        end
+      end
+
+      # The redirects and lambdas a route set holds, which no controller#action row lists.
+      def dynamic_route_count(route_set)
+        controllerless_routes(route_set).count { |r| dynamic_target?(r) }
       end
 
       private
@@ -284,11 +386,11 @@ module RailsAiContext
         scope = draw[:scope] || []
         already_read << [ path, scope ]
         ast = SourceIntrospector.walk(path, {
-          routes: -> { Listeners::RoutesDslListener.new(scope: scope, route_set: method(:route_set_prefixes), names: @route_names) },
+          routes: -> { Listeners::RoutesDslListener.new(scope: scope, route_set: method(:route_set_prefixes), names: @route_names, multi_path: multi_path_routes?) },
           mounts: -> { Listeners::MountListener.new(prefix: draw[:prefix], name_prefix: draw[:name_prefix]) }
         })
         records = ast[:routes] || []
-        mounts = ast[:mounts] || []
+        mounts = (ast[:mounts] || []).map { |m| m[:arm] ? m.merge(arm: [ path, *m[:arm] ]) : m }
         files = [ path ]
 
         records.select { |r| r[:type] == :dynamic && r[:macro] == :draw }.each do |record|
@@ -374,6 +476,16 @@ module RailsAiContext
         RailsAiContext.debug_fail(e, [ [], [], [] ], label: "draw target #{target}")
       end
 
+      # Rails 8.1 raises on `get "/a", "/b"`; with no version locked the routes are not guessed.
+      def multi_path_routes?
+        return @multi_path_routes if defined?(@multi_path_routes)
+
+        locked = GemLock.for(app.root.to_s).version("actionpack")
+        @multi_path_routes = !locked.nil? && Gem::Version.new(locked) < Gem::Version.new("8.1.0.a")
+      rescue ArgumentError
+        @multi_path_routes = false
+      end
+
       # `draw(:"admin/users")` is legal and resolves under config/routes/, but
       # the name reaches here from source text, so the resolved path has to be
       # confirmed inside that directory before it is read.
@@ -407,6 +519,13 @@ module RailsAiContext
         "#{lead} and #{CountPhrase.call(drawn, "file")} #{tops.size == 1 ? 'it draws' : 'they draw'}"
       end
 
+      def initializers_phrase
+        return "" if route_initializers.empty?
+
+        root = "#{app.root}#{File::SEPARATOR}"
+        ", plus routes appended or prepended in #{route_initializers.map { |f| f.delete_prefix(root) }.join(', ')}"
+      end
+
       def extract_routes
         # Force Rails to reload routes if routes.rb has changed
         app.routes_reloader&.execute_if_updated rescue nil
@@ -441,38 +560,10 @@ module RailsAiContext
         RailsAiContext.debug_fail(e, [], label: "booted_engine_routes")
       end
 
-      def table_routes(route_set)
-        route_set.routes.filter_map do |route|
-          # Journey::Route exposes the flag as a plain attribute reader
-          # (`internal`), not a predicate - a respond_to?(:internal?) guard
-          # never matches and would let Rails' info/mailers routes through.
-          next if route.respond_to?(:internal) && route.internal
-          next if route.defaults[:controller].blank?
-
-          route_path = route.path.spec.to_s.gsub("(.:format)", "")
-          action = route.defaults[:action]
-
-          entry = {
-            verb: route.verb.presence || "ANY",
-            path: route_path,
-            controller: route.defaults[:controller],
-            action: action,
-            name: route.name,
-            constraints: extract_constraints(route)
-          }
-
-          params = route_path.scan(/:(\w+)/).flatten
-          entry[:params] = params if params.any?
-
-          entry[:restful] = %w[index show new create edit update destroy].include?(action)
-
-          entry.compact
-        end
-      end
-
+      # What `bin/rails routes` prints beside the route, written alike on every Ruby.
       def extract_constraints(route)
-        constraints = route.constraints.to_s
-        constraints.empty? ? nil : constraints
+        shown = route.requirements.except(:controller, :action)
+        "{#{shown.map { |key, value| "#{key}: #{value.inspect}" }.join(', ')}}" if shown.any?
       rescue => e
         RailsAiContext.debug_fail(e, nil, label: "extract_constraints")
       end
@@ -483,6 +574,8 @@ module RailsAiContext
             entry = { verb: r[:verb], path: r[:path], action: r[:action], name: r[:name] }
             entry[:params] = r[:params] if r[:params]
             entry[:restful] = r[:restful] unless r[:restful].nil?
+            entry[:condition] = r[:condition] if r[:condition]
+            entry[:constraints] = r[:constraints] if r[:constraints]
             entry.compact
           end
         end
@@ -495,13 +588,13 @@ module RailsAiContext
       end
 
       def count_controllerless_constructs
-        controllerless_routes.count { |r| dynamic_target?(r) }
+        dynamic_route_count(app.routes)
       rescue => e
         RailsAiContext.debug_fail(e, 0, label: "count_controllerless_constructs")
       end
 
-      def controllerless_routes
-        app.routes.routes.reject do |r|
+      def controllerless_routes(route_set = app.routes)
+        route_set.routes.reject do |r|
           (r.respond_to?(:internal) && r.internal) || r.defaults[:controller].present?
         end
       end
@@ -524,6 +617,8 @@ module RailsAiContext
       # count includes it either way and a header that disagrees with the list
       # below it is the thing this pairing exists to prevent.
       def detect_mounted_engines
+        # The live table holds only what this environment drew; the source holds the condition it drew it under.
+        source = static_mounts
         mounted_routes.map do |r|
           mounted = r.app.respond_to?(:app) ? r.app.app : r.app
           name = mounted.is_a?(Class) ? mounted.name : mounted.class.name
@@ -531,12 +626,28 @@ module RailsAiContext
           # print and is still one of the endpoints the count counts, so it is
           # named for what it is rather than dropped into a disagreement
           # between the two numbers.
-          { engine: name || "(anonymous Rack app)", path: mount_path(r) }
+          path = mount_path(r)
+          { engine: name || "(anonymous Rack app)", path: path, condition: source_mount(source, name, path)&.dig(:condition) }.compact
         rescue => e
           RailsAiContext.debug_fail(e, { engine: "(unreadable Rack app)", path: nil }, label: "detect_mounted_engines")
         end
       end
 
+      # Source names an instance or a factory mount by what it wrote
+      # (`MetricsApp.new`) and a computed path not at all, so after the exact
+      # app and path, the one mount at that path, then the one of that app
+      # with no literal path. Two candidates (an if/else at one path, or one
+      # entry merged from several mounts) are a guess, so none is taken.
+      def source_mount(source, name, path)
+        source.find { |m| m[:engine] == name && m[:path] == path } ||
+          sole(source.select { |m| m[:path] == path }) ||
+          sole(source.select { |m| m[:engine] == name && m[:path].nil? })
+      end
+
+      def sole(candidates)
+        candidates.first if candidates.one? && !candidates.first[:merged]
+      end
+
       # Routable, controller-less, and not a redirect or a lambda: what is
       # left is a Rack app attached at a path. Walked once: the count and the
       # list are the same set, and reading it twice is reading the whole route

data/lib/rails_ai_context/introspectors/schema_conventions.rb

@@ -22,19 +22,58 @@ module RailsAiContext
         composite_pk = !pk_opt.nil? && !pk_opt.is_a?(String) && !pk_opt.is_a?(Symbol)
         return [] if options[:id] == false || composite_pk
 
-        id_type = options[:id].is_a?(String) || options[:id].is_a?(Symbol) ? options[:id].to_s : pk_type
+        # set_primary_key (7.0 to 8.1): an id: hash gives the type, its other keys the column's options.
+        id = options[:id]
+        id_options = id.is_a?(Hash) ? id.except(:type).reject { |_, value| value == RailsAiContext::Confidence::INFERRED } : {}
+        id = id[:type] if id.is_a?(Hash)
+        id_type = (id.is_a?(String) || id.is_a?(Symbol)) && id.to_s != "primary_key" ? id.to_s : pk_type
         [ { name: pk_opt ? pk_opt.to_s : "id", type: id_type, default: nil,
-            options: { null: false }, primary_key: true } ]
+            options: { null: false }.merge(id_options), primary_key: true } ]
       end
 
-      # Rails omits column:/primary_key: only where the convention holds, so
-      # the fallback is what was declared rather than a guess.
-      def foreign_key_entry(from, to, column, primary_key)
+      # The dump leaves out column:, primary_key:, validate: true and deferrable: false where they are Rails'
+      # defaults; Rails 7.0 reads DEFERRABLE INITIALLY IMMEDIATE back as true, which 7.1 names :immediate.
+      def foreign_key_entry(from, to, column, primary_key, on_delete: nil, on_update: nil, deferrable: nil, validate: nil)
+        known = ->(value) { value unless value == RailsAiContext::Confidence::INFERRED }
         {
           from_table: from, to_table: to,
-          column: primary_key_value(column) || "#{to.to_s.singularize}_id",
-          primary_key: primary_key_value(primary_key) || "id"
-        }
+          column: primary_key_value(column) || "#{to.to_s.split('.').last.to_s.singularize}_id",
+          primary_key: primary_key_value(primary_key) || "id",
+          on_delete: known.(on_delete)&.to_s, on_update: known.(on_update)&.to_s,
+          deferrable: (deferrable == true ? "immediate" : known.(deferrable)&.to_s if deferrable), validate: (false if validate == false)
+        }.compact
+      end
+
+      FOREIGN_KEY_OPTIONS = %i[on_delete on_update deferrable validate].freeze
+
+      # An index's options past name, columns, unique and where, as schema.rb
+      # writes them; btree is every adapter's default, so the dump leaves it out.
+      def index_detail(columns, using: nil, type: nil, include: nil, order: nil, opclass: nil, length: nil, nulls_not_distinct: nil)
+        {
+          using: (using.to_s unless using.nil? || using.to_s == "btree"),
+          type: (type.to_s unless type.nil? || type.to_s.empty?),
+          include: (Array(include).map(&:to_s) unless Array(include).empty?),
+          order: per_key(order, columns),
+          opclass: per_key(opclass, columns),
+          length: per_key(length, columns),
+          nulls_not_distinct: (true if nulls_not_distinct == true)
+        }.compact
+      end
+
+      # An index option given per key, or once for every key (`order: :desc`).
+      def per_key(value, columns)
+        value = Array(columns).to_h { |column| [ column, value ] } unless value.is_a?(Hash)
+        value = value.reject { |_, v| v.nil? || v.to_s.empty? }
+        value.to_h { |key, v| [ key.to_s, v.is_a?(Integer) ? v : v.to_s ] } unless value.empty?
+      end
+
+      # deferrable: false is the default the dump leaves out.
+      def unique_constraint_entry(name, columns, deferrable)
+        {
+          name: name&.to_s,
+          columns: Array(columns).map(&:to_s),
+          deferrable: (deferrable.to_s if deferrable)
+        }.compact
       end
 
       # Rails' limit before it shortens an index name (max_index_name_size).
@@ -134,44 +173,26 @@ module RailsAiContext
       # since Rails 5.1, except SQLite where it stays integer. The dump does
       # not record it, but config/database.yml names the adapter - looked up
       # per database, because a multi-db app can mix adapters (postgres
-      # primary, sqlite queue) and each dump must be typed by its own.
-      def implicit_pk_type(root, dump_path)
-        db_name = File.basename(dump_path.to_s).sub(/\.(rb|sql)\z/, "").sub(/_?(schema|structure)\z/, "")
-        db_name = "primary" if db_name.empty?
-
-        adapter = database_adapter_for(root, db_name)
+      # 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"
       end
 
-      # Best-effort adapter lookup from config/database.yml without booting:
-      # a keyed entry for this database name wins; a file with exactly one
-      # distinct adapter is unambiguous; anything else falls back to the
-      # first adapter (the primary comes first in generated configs).
+      # 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.
       def database_adapter_for(root, db_name)
-        content = database_yml_content(root)
-        return nil if content.empty?
-
-        adapters = content.scan(/^\s*adapter:\s*(\w+)/).flatten
-        return adapters.first if adapters.uniq.size <= 1
-
-        # Mixed adapters: find the block keyed by this database's name and
-        # take the first adapter that follows at deeper indentation. The
-        # block ends at the first non-blank line at the key's indent or
-        # shallower; blank/whitespace-only lines don't end it (and must not
-        # let it bleed into a sibling block).
-        if (m = content.match(/^([ \t]*)#{Regexp.escape(db_name)}:[ \t]*\n((?:(?:[ \t]*|\1[ \t]+\S[^\n]*)\n)*)/))
-          block_adapter = m[2][/^[ \t]*adapter:[ \t]*(\w+)/, 1]
-          return block_adapter if block_adapter
-        end
-        adapters.first
+        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)
       end
 
-      # Normalized so the line-anchored block regex above works on files with
-      # Windows endings or no final newline.
-      def database_yml_content(root)
-        db_yml = File.join(root.to_s, "config", "database.yml")
-        content = RailsAiContext::SafeFile.read(db_yml).to_s.gsub("\r\n", "\n")
-        content.empty? || content.end_with?("\n") ? content : "#{content}\n"
+      # A dump of more than one schema qualifies every name (relation_name, 8.1);
+      # the app sees a public table by its bare name under the default search_path.
+      def local_name(name)
+        name.delete_prefix("public.")
       end
 
       # A primary key as connection.primary_key gives it: the column's name, or
@@ -181,6 +202,72 @@ module RailsAiContext
         names.size > 1 ? names : names.first
       end
 
+      # The key on the table and a flag on each of its columns, from whichever
+      # side the source gave; a table with no key keeps neither.
+      def mark_primary_key(table)
+        table[:primary_key] ||= primary_key_value(Array(table[:columns]).select { |c| c[:primary_key] }.map { |c| c[:name] })
+        keys = Array(table[:primary_key]).map(&:to_s)
+        Array(table[:columns]).each { |column| column[:primary_key] = true if keys.include?(column[:name].to_s) }
+        table.delete(:primary_key) if table[:primary_key].nil?
+        table
+      end
+
+      # Every table's check constraints in one list, each naming its table.
+      def check_constraints_of(tables)
+        tables.flat_map { |name, table| Array(table[:check_constraints]).map { |constraint| { table: name, **constraint } } }
+      end
+
+      def generated_columns_of(tables)
+        tables.flat_map do |name, table|
+          Array(table[:columns]).filter_map do |column|
+            { table: name, column: column[:name], expression: column[:generated], stored: column[:stored] }.compact if column.key?(:generated)
+          end
+        end
+      end
+
+      # Views, virtual tables and skipped tables beside the tables. A view replaces a table
+      # of its name: mysqldump writes a placeholder table before the view.
+      def add_relations(tables, views: {}, virtual_tables: {}, not_dumped: {})
+        views.each { |name, view| tables[name] = view_entry(view[:sql], materialized: view[:materialized], indexes: view[:indexes]) }
+        virtual_tables.each { |name, table| tables[name] = virtual_table_entry(table[:module], table[:arguments]) }
+        not_dumped.each { |name, reason| tables[name] ||= { columns: [], indexes: [], foreign_keys: [], not_dumped: reason } }
+        tables
+      end
+
+      def view?(table)
+        table.is_a?(Hash) && %w[view materialized_view].include?(table[:kind])
+      end
+
+      # Views sit beside the tables in one Hash, and a table count leaves them out.
+      def table_count(tables)
+        tables.count { |_, table| !view?(table) }
+      end
+
+      # How a header counts the listed entries: "116 tables and 2 views".
+      def relations_phrase(tables)
+        tables ||= {}
+        count = table_count(tables)
+        phrase = CountPhrase.call(count, "table")
+        views = tables.size - count
+        views.positive? ? "#{phrase} and #{CountPhrase.call(views, "view")}" : phrase
+      end
+
+      # A dump holds a view's SQL, not its columns; only a connection lists those.
+      def view_entry(sql, materialized:, columns: [], indexes: [])
+        { kind: materialized ? "materialized_view" : "view", columns: columns, indexes: Array(indexes), foreign_keys: [], sql: sql }.compact
+      end
+
+      # A virtual table's columns are its module arguments that set no option (fts5's tokenize=...).
+      def virtual_table_entry(mod, arguments)
+        columns = Array(arguments).filter_map { |arg| arg.strip[/\A["`]?(\w+)["`]?(?:\s+UNINDEXED)?\z/i, 1] }
+        { kind: "virtual_table", module: mod, columns: columns.map { |name| { name: name } }, indexes: [], foreign_keys: [] }.compact
+      end
+
+      # MySQL's dumper writes a tiny, medium or long text or blob type as size:.
+      def mysql_text_size(sql_type)
+        sql_type.to_s[/\A(tiny|medium|long)(?:text|blob)/i, 1]&.downcase
+      end
+
       # How a primary key reads to a person: `id`, or `tag_id, account_id`.
       def primary_key_label(key)
         Array(key || "id").join(", ")