forest_liana 9.22.0 → 9.22.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6042deb02adc0ae0d73c97cac99e2abdf0807cdf759cfd0cde116bf94fdc3dff
-  data.tar.gz: 351c37c6fd6cfc17e9c4de3c8f760b84527ca7c1d7a0e2df6976b67b8d549329
+  metadata.gz: be442492f5ecaafbff4d9d246c03634430ce0164159117f30a898cb730486090
+  data.tar.gz: 331dad7bbb30db9f6542adebf235ce1b8bf6e6f8abc96ef986b8fbb2c677aacd
 SHA512:
-  metadata.gz: 7a952e5b05d2c1491f74b77a53e16012d89419af19040e6168488e000afba0651ebea4f3d7cb21b1ef3045598be8317c30930f7a1e6a681fd5458b8ce956672f
-  data.tar.gz: 9884f0447c34ccb867abf7a2b41326229391e6a3c2689ad9884a15d09ac0ad067ba3a7ebfb30df13cab9502524ef29cd69de941779bfd3185cd385a893261960
+  metadata.gz: 8b01396fdeb47da3b36cba49666da16dd352ac8742a12cb83b84617b9c5e8529aaeaf500181c8b36cc4993aa090caaddf03e9c6b21ee3a17ddd47ab471b64e70
+  data.tar.gz: 707b4b922403fdefa05723d0fbdfadedc73bf7c73b59c1b7a9df6e8a55de61b6a43c2056ff50192063a385fc3e7a1202ac0770114c242409bf0a4499c84a46b0

data/app/services/forest_liana/base_getter.rb

@@ -473,10 +473,7 @@ module ForestLiana
         association = projected_resource.reflect_on_association(relation_path.relations.first.to_sym)
         next unless association
 
-        preload_owner_keys(association).each do |key|
-          select << "#{projected_resource.table_name}.#{key}" if column?(projected_resource, key)
-        end
-
+        select_dependency_preload_keys(select, relation_path, joined_relations)
         select_foreign_keys(select, projected_resource, association, joined?(association, joined_relations))
 
         # A relation the caller also projects is built off the JOIN, and the preloader leaves an
@@ -528,6 +525,82 @@ module ForestLiana
       Array(reflection.join_foreign_key)
     end
 
+    # The same keys, but for every hop of a declared path this select can still reach, not only
+    # the first. The first hop reads the root row, which this select builds. The hop after it
+    # reads the rows that first hop produced — and when that hop is a relation the query *joins*,
+    # those rows are the narrowed ones built off the JOIN, so its key has to be named here too.
+    # It was not, and the list answered 500 rather than the one field (PRD-1316).
+    def select_dependency_preload_keys(select, relation_path, joined_relations)
+      chains = flatten_dependency_hops(relation_path.relations)
+      return if chains.empty?
+
+      narrowed_hops(chains, joined_relations).each do |owner, reflection|
+        Array(reflection.join_foreign_key).each do |key|
+          select << "#{owner.table_name}.#{key}" if column?(owner, key)
+        end
+      end
+    end
+
+    # The leading hops whose owner row this query builds itself, narrowed, and whose key it
+    # therefore has to name.
+    #
+    # The first hop always counts: it reads the root row. One hop past a *joined* relation counts
+    # too, its owners being the narrowed rows the JOIN built rather than the whole ones a preload
+    # selects. Two relations can be the joined one, and either shape reaches here:
+    #   - the chain's own first hop, which for a :through is the relation it goes through
+    #     (`island` of `has_one :location, through: :island`): the preloader reuses the loaded
+    #     association and reads the source key off it;
+    #   - the first declared relation, when the request displays it: the preloader then leaves
+    #     that whole declaration alone, and the next declared relation reads its key off the
+    #     joined rows. For a plain relation both are the same hop; for a :through they are not,
+    #     and the second was missed.
+    #
+    # Nothing past those: joined_relations only ever names root relations, so every later hop
+    # comes from a preload of its own, which selects whole rows. Every table named up to here is
+    # in the FROM clause — eager loading a :through joins the tables it goes through as well.
+    def narrowed_hops(chains, joined_relations)
+      declared, head = chains.first
+      hops = chains.flat_map(&:last)
+
+      count = joined?(head.first.last, joined_relations) ? 2 : 1
+      count = [count, head.size + 1].max if joined?(declared, joined_relations)
+
+      hops.first(count)
+    end
+
+    # The direct reflections the preloader really walks for a declared path, grouped by the
+    # relation that declared them and each paired with the model it reads its key off.
+    #
+    # A :through hop is not preloaded as one: Preloader::ThroughAssociation loads the through
+    # relation, then the source relation on those records. So the relation a path names can hide
+    # the one the query joins — `location:coordinates` walking Tree's `has_one :location, through:
+    # :island` really starts on the joined `island`, which the declaration never mentions.
+    def flatten_dependency_hops(relations)
+      model = projected_resource
+
+      relations.map do |name|
+        association = model.reflect_on_association(name.to_sym)
+        return [] if association.nil? || SchemaUtils.polymorphic?(association)
+
+        chain = [association, flatten_through_hops(model, association)]
+        model = association.klass
+        chain
+      end
+    # Same net as preload_skip_reason's, for the same shapes: a :through naming a hop that does
+    # not exist, or a class_name pointing at no model, answers NameError off #klass. Nothing is
+    # selected for such a path — skip_preload? drops it from the preload too, so there is no key
+    # left to select for.
+    rescue NameError, ActiveRecord::ActiveRecordError
+      []
+    end
+
+    def flatten_through_hops(owner, association)
+      return [[owner, association]] unless association.through_reflection?
+
+      flatten_through_hops(owner, association.through_reflection) +
+        flatten_through_hops(association.through_reflection.klass, association.source_reflection)
+    end
+
     def get_one_association(name)
       # Handle composite primary keys - name might be an Array
       name_sym = name.is_a?(Array) ? name : name.to_sym

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "9.22.0"
+  VERSION = "9.22.1"
 end

data/spec/dummy/app/models/location.rb

@@ -1,3 +1,8 @@
 class Location < ActiveRecord::Base
   belongs_to :island
+
+  # Reached as the hop *after* Tree#location, a has_one :through the list displays: the row it
+  # reads `locations.coordinates` off is the narrowed one that relation's own JOIN built
+  # (query_footprint_spec.rb, PRD-1316).
+  has_many :trees_by_coordinates, class_name: 'Tree', primary_key: 'coordinates', foreign_key: 'name'
 end

data/spec/dummy/app/models/tree.rb

@@ -9,4 +9,8 @@ class Tree < ActiveRecord::Base
     optional: true
 
   has_one :location, through: :island
+
+  # A :through whose hop is the displayed `belongs_to :owner`: a path naming this relation alone
+  # never names the relation the query joins, which is the shape PRD-1316 crashed on.
+  has_many :owner_named_trees, through: :owner, source: :trees_by_name
 end

data/spec/dummy/app/models/user.rb

@@ -6,6 +6,17 @@ class User < ActiveRecord::Base
   # The only has_and_belongs_to_many of the dummy.
   has_and_belongs_to_many :favourite_trees, class_name: 'Tree', join_table: 'trees_users'
 
+  # Keyed on `name`, not on the primary key, like Owner#trees_by_name — but reached here as the
+  # *second* hop of a dependency path whose first hop the list also displays, so the row it reads
+  # `users.name` off is the narrowed one the JOIN built (query_footprint_spec.rb, PRD-1316).
+  has_many :trees_by_name, class_name: 'Tree', primary_key: 'name', foreign_key: 'name'
+
+  # The same second-hop shape, but with the two keys held apart: the preloader reads
+  # `users.title`, `foreign_key` answers `age`, and `age` is no column of users at all. The one
+  # relation of the dummy that tells join_foreign_key and foreign_key apart on a narrowed row —
+  # everywhere else they either agree or both land on the primary key a join emits anyway.
+  has_many :trees_by_title, class_name: 'Tree', primary_key: 'title', foreign_key: 'age'
+
   # The keyword form is the only one Rails 6.1 knows; Rails 8 only keeps the positional one.
   if Rails.gem_version >= Gem::Version.new('7.0')
     enum :title, [ :king, :villager, :outlaw ]

data/spec/dummy/lib/forest_liana/collections/tree.rb

@@ -37,6 +37,33 @@ class Forest::Tree
     object.location&.coordinates
   end
 
+  # A multi-hop path whose first hop the list also displays as a column. The hop-2 preload reads
+  # `users.name` off the rows the JOIN built with a narrowed select — the fixture for "is the key
+  # a later hop reads selected on the table it is joined from" (query_footprint_spec.rb).
+  field :owner_named_trees_count, type: 'Number', dependencies: ['owner:trees_by_name:name'] do
+    object.owner.trees_by_name.size
+  end
+
+  # The same failure through a :through, where the joined hop is the one the path never names —
+  # PRD-1316's own declaration shape.
+  field :owner_named_tree_names, type: 'String', dependencies: ['owner_named_trees:name'] do
+    object.owner_named_trees.map(&:name).join(',')
+  end
+
+  # The hop-2 key held apart from the hop's foreign key: `users.title` is what the preloader
+  # reads, `age` what foreign_key answers and no column of users. Reading the wrong one of the
+  # two selects nothing at all, and the list 500s again.
+  field :owner_titled_trees_count, type: 'Number', dependencies: ['owner:trees_by_title:name'] do
+    object.owner.trees_by_title.size
+  end
+
+  # A path that carries on *past* a displayed has_one :through: the preloader leaves the whole
+  # declaration alone and the next hop reads `locations.coordinates` off the rows that relation's
+  # JOIN built. The joined relation is then the one the path names, not the hop it goes through.
+  field :location_trees_count, type: 'Number', dependencies: ['location:trees_by_coordinates:name'] do
+    object.location&.trees_by_coordinates&.size
+  end
+
   # A smart belongs_to: is_virtual with a reference, and no ActiveRecord reflection behind it —
   # the fixture for everything that walks a getter's includes (has_many_getter_spec.rb,
   # associations_spec.rb). Nothing else in the dummy declared one.

data/spec/requests/projection_header_spec.rb

@@ -207,7 +207,7 @@ describe 'Requesting resources with the Forest-Projection header', :type => :req
       expect(response.status).to eq 200
       expect(body['data']['attributes']).to eq('id' => @user.id, 'name' => 'Michel')
       expect(body['data']['relationships'].keys)
-        .to match_array %w[trees_owned trees_cut addresses favourite_trees smart_trees]
+        .to match_array %w[trees_owned trees_cut trees_by_name trees_by_title addresses favourite_trees smart_trees]
       expect(body['data']['relationships']['trees_owned']['links']['related']['href'])
         .to eq "/forest/User/#{@user.id}/relationships/trees_owned"
       expect(body['data']['relationships']['favourite_trees']['links']['related']['href'])
@@ -578,6 +578,32 @@ describe 'Requesting resources with the Forest-Projection header', :type => :req
     end
   end
 
+  # PRD-1316. The hop after a joined one reads its key off the narrowed rows the JOIN built, so
+  # that key belongs to this select — `owner:trees_by_name:name` preloads Tree's owners' trees by
+  # `users.name`, which nothing else here would have selected.
+  describe 'on a dependency path whose first hop the request also projects' do
+    let(:getter) do
+      ForestLiana::ResourceGetter.new(
+        Tree,
+        ActionController::Parameters.new(
+          id: 1, fields: { 'Tree' => 'id,name,owner,owner_named_trees_count' }
+        ),
+        nil
+      )
+    end
+
+    it 'selects the key the next hop reads, on the joined table' do
+      expect(getter.send(:compute_select_fields, [:owner])).to include('users.name')
+    end
+
+    it 'leaves it out when that hop is not joined, its table not being in the FROM clause' do
+      select = getter.send(:compute_select_fields, [])
+
+      expect(select).to include('trees.owner_id')
+      expect(select).not_to include('users.name')
+    end
+  end
+
   # NOTICE: Only a bare column name can be table-qualified. An ordering expression would reach
   #         the SQL as table.LOWER(name) and raise.
   describe 'on a collection ordered by an expression' do

data/spec/requests/query_footprint_spec.rb

@@ -399,6 +399,209 @@ describe 'SQL footprint of a front call', type: :request do
     end
   end
 
+  # PRD-1316. A relation the list also displays is built off the JOIN, with a select narrowed to
+  # the requested columns — and the preloader leaves an already-loaded association alone, so the
+  # next hop of the path reads its key off those narrowed rows. `users.name` was never selected:
+  # the whole list answered 500 `missing attribute: name`, not just the field.
+  #
+  # The multi-hop fixture above never caught it because its own second hop (Island has_one
+  # :location) keys on `isle.id`, and apply_column_aliases always emits a joined table's primary
+  # key. Only a non-primary key reveals the gap.
+  describe 'a list whose declared path goes through a relation the request also displays' do
+    let(:seed) do
+      seeded = 0
+      lambda do |n|
+        n.times do
+          seeded += 1
+          Tree.create!(name: "owner#{seeded}", owner: User.create!(name: "owner#{seeded}"))
+        end
+      end
+    end
+    let(:params) do
+      { fields: { 'Tree' => 'id,name,owner,owner_named_trees_count' }, page: page,
+        searchExtended: '0', sort: '-id', timezone: 'Europe/Paris' }
+    end
+
+    it 'selects the key the next hop reads off the joined row' do
+      result = footprint(seed: seed) do |rows|
+        get '/forest/Tree', params: params, headers: headers
+        expect(response).to have_http_status(200)
+        expect(listed_rows).to eq(rows)
+      end
+
+      expect(result.per_row_delta).to eq(0), -> { result.delta_report }
+      # The key rides along in the JOIN's own select: still one joined query, never a second
+      # SELECT on users and never a fallback to "users".*.
+      expect(join_count(result.grown, 'users')).to eq(1)
+      expect(selects_from(result.grown, 'users')).to be_empty
+      root = selects_from(result.grown, 'trees').first
+      expect(root).to include(column_ref('users', 'name'))
+      expect(root).not_to include(column_ref('users', 'title'))
+    end
+
+    it 'selects it just as well when the request asks the relation for no column of its own' do
+      seed.call(3)
+
+      get '/forest/Tree', params: params.merge(fields: params[:fields].merge('owner' => 'id')),
+          headers: headers
+
+      expect(response).to have_http_status(200)
+      counts = JSON.parse(response.body)['data'].map { |row| row['attributes']['owner_named_trees_count'] }
+      expect(counts).to all(eq(1))
+    end
+
+    it 'reaches the far end of the path' do
+      seed.call(3)
+
+      get '/forest/Tree', params: params, headers: headers
+
+      expect(response).to have_http_status(200)
+      counts = JSON.parse(response.body)['data'].map { |row| row['attributes']['owner_named_trees_count'] }
+      expect(counts).to all(eq(1))
+    end
+  end
+
+  # The same shape declared the way the ticket declared it: the path names the :through relation
+  # alone, and the relation the query joins (`owner`) is the hop it goes through — a hop the
+  # declaration never mentions.
+  describe 'a list whose declared :through hides the joined hop' do
+    let(:seed) do
+      seeded = 0
+      lambda do |n|
+        n.times do
+          seeded += 1
+          Tree.create!(name: "owner#{seeded}", owner: User.create!(name: "owner#{seeded}"))
+        end
+      end
+    end
+    let(:params) do
+      { fields: { 'Tree' => 'id,name,owner,owner_named_tree_names', 'owner' => 'id' }, page: page,
+        searchExtended: '0', sort: '-id', timezone: 'Europe/Paris' }
+    end
+
+    it 'selects the key the source hop reads off the joined through row' do
+      result = footprint(seed: seed) do |rows|
+        get '/forest/Tree', params: params, headers: headers
+        expect(response).to have_http_status(200)
+        expect(listed_rows).to eq(rows)
+      end
+
+      expect(result.per_row_delta).to eq(0), -> { result.delta_report }
+      expect(join_count(result.grown, 'users')).to eq(1)
+      # As above: the key rides along in the JOIN's own select, and the narrowing survives —
+      # giving up and selecting the whole joined row would serve the same page just as green.
+      expect(selects_from(result.grown, 'users')).to be_empty
+      root = selects_from(result.grown, 'trees').first
+      expect(root).to include(column_ref('users', 'name'))
+      expect(root).not_to include(column_ref('users', 'title'))
+    end
+
+    it 'reaches the far end of the through' do
+      seed.call(3)
+
+      get '/forest/Tree', params: params, headers: headers
+
+      expect(response).to have_http_status(200)
+      names = JSON.parse(response.body)['data'].map { |row| row['attributes']['owner_named_tree_names'] }
+      expect(names).to all(match(/\Aowner\d+\z/))
+    end
+  end
+
+  # PRD-1316, the half a fixture keyed on `name` cannot see: `join_foreign_key` is what the
+  # preloader reads off the owner row, and `foreign_key` is not the same column. Both answer
+  # `name` for User#trees_by_name, and every other hop of the suite where they differ keys on
+  # `id`, which apply_column_aliases emits for a joined table anyway — so reading the wrong one
+  # of the two costs nothing anywhere else, and the fix would be free to rot.
+  #
+  # User#trees_by_title holds them apart: `title` is read, `age` is the foreign key, and `age`
+  # is no column of users at all, so the wrong one selects nothing and the list 500s again.
+  describe 'a list whose joined hop is keyed on a column its foreign key is not' do
+    let(:seed) do
+      seeded = 0
+      lambda do |n|
+        n.times do
+          seeded += 1
+          Tree.create!(name: 'tree', owner: User.create!(name: "owner#{seeded}"))
+        end
+      end
+    end
+    let(:params) do
+      { fields: { 'Tree' => 'id,name,owner,owner_titled_trees_count', 'owner' => 'id' }, page: page,
+        searchExtended: '0', sort: '-id', timezone: 'Europe/Paris' }
+    end
+
+    it 'selects the key the preloader reads, not the association foreign key' do
+      result = footprint(seed: seed) do |rows|
+        get '/forest/Tree', params: params, headers: headers
+        expect(response).to have_http_status(200)
+        expect(listed_rows).to eq(rows)
+      end
+
+      expect(result.per_row_delta).to eq(0), -> { result.delta_report }
+      expect(join_count(result.grown, 'users')).to eq(1)
+      expect(selects_from(result.grown, 'users')).to be_empty
+      root = selects_from(result.grown, 'trees').first
+      expect(root).to include(column_ref('users', 'title'))
+      expect(root).not_to include(column_ref('users', 'name'))
+    end
+  end
+
+  # The path does not stop at the displayed relation but carries on past it. The preloader leaves
+  # that whole declaration alone — it is already loaded off the JOIN — so the hop *after* it reads
+  # its key off those narrowed rows. Where the relation is a :through, the hop the chain starts
+  # with (`island`) is not the one the request displays (`location`), and looking only at the
+  # first named nothing as joined at all: 500 on `locations.coordinates`.
+  describe 'a list whose declared path carries on past a joined :through' do
+    let(:seed) do
+      seeded = 0
+      lambda do |n|
+        n.times do
+          seeded += 1
+          island = Island.create!(name: "isle#{seeded}")
+          Location.create!(island: island, coordinates: "tree#{seeded}")
+          Tree.create!(name: "tree#{seeded}", island: island, owner: User.create!(name: 'owner'))
+        end
+      end
+    end
+    let(:params) do
+      { fields: { 'Tree' => 'id,name,location,location_trees_count', 'location' => 'id' },
+        page: page, searchExtended: '0', sort: '-id', timezone: 'Europe/Paris' }
+    end
+
+    it 'selects the key the hop after the whole declaration reads' do
+      result = footprint(seed: seed) do |rows|
+        get '/forest/Tree', params: params, headers: headers
+        expect(response).to have_http_status(200)
+        expect(listed_rows).to eq(rows)
+      end
+
+      # Rails 6.1's Preloader reuses the association the JOIN already loaded and the page costs
+      # nothing extra. From Rails 7 it re-walks the :through instead — only `location` is loaded
+      # on these rows, never the `island` it goes through — and builds Locations of its own that
+      # `object.location`, still the JOIN's row, never reads: the preload is wasted and the field
+      # falls back to one read per row. Orthogonal to the key selected here, which is what makes
+      # that read answer the right thing rather than nothing; pinned so it stays visible.
+      expect(result.per_row_delta(table: 'trees')).to eq(Rails::VERSION::MAJOR >= 7 ? 1 : 0),
+                                                      -> { result.delta_report(table: 'trees') }
+      # The key rides along in the JOIN's own select, which stays narrowed: still one joined
+      # query, and never a fallback to "locations".*.
+      expect(join_count(result.grown, 'locations')).to eq(1)
+      root = selects_from(result.grown, 'trees').first
+      expect(root).to include(column_ref('locations', 'coordinates'))
+      expect(root).not_to include(column_ref('locations', 'updated_at'))
+    end
+
+    it 'reaches the far end of the path' do
+      seed.call(3)
+
+      get '/forest/Tree', params: params, headers: headers
+
+      expect(response).to have_http_status(200)
+      counts = JSON.parse(response.body)['data'].map { |row| row['attributes']['location_trees_count'] }
+      expect(counts).to all(eq(1))
+    end
+  end
+
   describe 'a list projecting a smart field that walks an undeclared relation' do
     let(:seed) do
       lambda do |n|

data/spec/services/forest_liana/base_getter_spec.rb

@@ -172,6 +172,44 @@ module ForestLiana
       end
     end
 
+    # The same two shapes, on the other half of the mechanism: skip_preload? keeps them out of the
+    # preload, and this keeps them out of the select. Neither guard can be reached through a
+    # collection of the dummy — SmartFieldDependencies.validate! strips such a declaration at boot
+    # — so they are exercised the way a collection built outside that pass would reach them.
+    describe '#select_dependency_preload_keys' do
+      def keys_for(resource, relations, column: 'name', joined: nil)
+        getter.instance_variable_set(:@resource, resource)
+        select = []
+        getter.send(:select_dependency_preload_keys, select,
+                    SmartFieldDependencies::RelationPath.new(relations, column), joined)
+        select
+      end
+
+      it 'selects the key of every hop it can still reach' do
+        expect(keys_for(Tree, %w[owner trees_by_name], joined: [:owner]))
+          .to eq(['trees.owner_id', 'users.name'])
+      end
+
+      it 'selects nothing for a path naming a relation that does not exist' do
+        expect(keys_for(Tree, %w[nowhere])).to eq([])
+      end
+
+      it 'selects nothing for a path crossing a polymorphic relation' do
+        expect(keys_for(Address, %w[addressable])).to eq([])
+      end
+
+      # A class_name: pointing at no model, or a :through naming a hop that is not there: both
+      # answer NameError off #klass, which nothing here would otherwise catch.
+      it 'selects nothing for a path whose target model does not resolve' do
+        reflection = Tree.reflect_on_association(:island)
+        allow(reflection).to receive(:klass).and_raise(NameError, 'uninitialized constant Nowhere')
+        allow(Tree).to receive(:reflect_on_association).and_call_original
+        allow(Tree).to receive(:reflect_on_association).with(:island).and_return(reflection)
+
+        expect(keys_for(Tree, %w[island location], column: 'coordinates')).to eq([])
+      end
+    end
+
     # Every skip above silently reinstates the N+1 the declaration was written to remove, and
     # what breaks a declaration that used to work is usually a change made elsewhere, long after
     # anyone verified it. The log line is the only thing that says so.

data/spec/services/forest_liana/schema_adapter_spec.rb

@@ -93,12 +93,17 @@ module ForestLiana
               "location",
               "name",
               "owner",
+              "owner_named_trees",
               "updated_at",
               "name_with_age",
               "owner_name",
               "owner_name_declared",
               "island_coordinates",
               "through_coordinates",
+              "owner_named_trees_count",
+              "owner_named_tree_names",
+              "owner_titled_trees_count",
+              "location_trees_count",
               "smart_owner"
             ]
           )

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: forest_liana
 version: !ruby/object:Gem::Version
-  version: 9.22.0
+  version: 9.22.1
 platform: ruby
 authors:
 - Sandro Munda
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-23 00:00:00.000000000 Z
+date: 2026-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails