forest_liana 9.16.0 → 9.16.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5b410cf0b004c0b725119f7f0d4328165b344579181d022930a3965c53569b6
-  data.tar.gz: 0c69947edf290b25d2fa53503f9f754a3d0d73e571ef6af525969c201bb0e469
+  metadata.gz: f5def4c0d7226797a8b932f16749a655b526c6278689417b712866c1eb223a78
+  data.tar.gz: c08d1acf4f8f36a67590b334cd175c76e87deabc47507dd7a57619a7f94302ec
 SHA512:
-  metadata.gz: 8391f47c0f3731827d4170eaae994e230b8567a6166b344581876576d10eabf1df964ae51b1480823ba2d50b3ef08bd53a99851d29dc4db26b92fe60d3df126e
-  data.tar.gz: 5a934a2555b71fed7b80d49546435c1141223b9d6ba00a7443bf8503e76c1aa38211c906cd95da091242a024e30da9c1007ce5491a4d70a1731cbf4df1b19b07
+  metadata.gz: 63b2d98871047ed88390ba98905430e201c7bf43b94d86d13fa1dd7a3c77ccbc8f0711e6d0f878f93ac48c09d6d3a35db630979690764038e4b85ad6e51b976a
+  data.tar.gz: 134d72f9a8b49d5f3fdf3889eb72fb08f4308ff2645fc97933c7122cffcaf35891b5bff8e3e3fa5de9725381cf9a7142bf5188146db6035048efccab6e7c33dc

data/app/controllers/forest_liana/application_controller.rb

@@ -173,7 +173,7 @@ module ForestLiana
             fields[relation_name] = relation_fields
           elsif model.reflect_on_association(relation_name.to_sym)
             model_association = model.reflect_on_association(relation_name.to_sym)
-            if model_association
+            if model_association && !model_association.polymorphic?
               model_name = ForestLiana.name_for(model_association.klass)
               # NOTICE: Join fields in case of model with self-references.
               if fields[model_name]
@@ -184,6 +184,8 @@ module ForestLiana
               else
                 fields[model_name] = relation_fields
               end
+            elsif model_association && model_association.polymorphic?
+              fields[relation_name] = relation_fields
             end
           else
             smart_relations.each do |smart_relation|
@@ -227,7 +229,9 @@ module ForestLiana
             included = json['included']
 
             values = field_names_requested.map do |field_name|
-              if record_attributes[field_name]
+              if field_name == 'id'
+                json['data']['id']
+              elsif record_attributes[field_name]
                 record_attributes[field_name]
               elsif record_relationships[field_name] &&
                 record_relationships[field_name]['data']

data/app/serializers/forest_liana/serializer_factory.rb

@@ -122,6 +122,15 @@ module ForestLiana
       serializer = Class.new {
         include ForestAdmin::JSONAPI::Serializer
 
+        def id
+          pk = object.class.primary_key
+          if pk.is_a?(Array)
+            pk.map { |key| object.send(key) }.to_json
+          else
+            object.id.to_s
+          end
+        end
+
         def self_link
           "/forest#{super.underscore}"
         end

data/app/services/forest_liana/has_many_getter.rb

@@ -25,7 +25,29 @@ module ForestLiana
     end
 
     def count
-      @records_count = @records.count
+      association_class = model_association
+
+      if association_class.primary_key.is_a?(Array)
+        adapter_name = association_class.connection.adapter_name.downcase
+
+        if adapter_name.include?('sqlite')
+          # For SQLite: concatenate columns for DISTINCT count
+          pk_concat = association_class.primary_key.map do |pk|
+            "#{association_class.table_name}.#{pk}"
+          end.join(" || '|' || ")
+
+          @records_count = @records.distinct.count(Arel.sql(pk_concat))
+        else
+          # For PostgreSQL/MySQL: use DISTINCT with multiple columns
+          pk_columns = association_class.primary_key.map do |pk|
+            "#{association_class.table_name}.#{pk}"
+          end.join(', ')
+
+          @records_count = @records.distinct.count(Arel.sql(pk_columns))
+        end
+      else
+        @records_count = @records.count
+      end
     end
 
     def query_for_batch
@@ -72,7 +94,8 @@ module ForestLiana
     end
 
     def prepare_query
-      association = get_resource().find(@params[:id]).send(@params[:association_name])
+      parent_record = ForestLiana::Utils::CompositePrimaryKeyHelper.find_record(get_resource(), @resource, @params[:id])
+      association = parent_record.send(@params[:association_name])
       @records = optimize_record_loading(association, @search_query_builder.perform(association))
     end
 

data/app/services/forest_liana/resource_getter.rb

@@ -14,7 +14,7 @@ module ForestLiana
     def perform
       records = optimize_record_loading(@resource, get_resource())
       scoped_records = ForestLiana::ScopeManager.apply_scopes_on_records(records, @user, @collection_name, @params[:timezone])
-      @record = scoped_records.find(@params[:id])
+      @record = ForestLiana::Utils::CompositePrimaryKeyHelper.find_record(scoped_records, @resource, @params[:id])
     end
   end
 end

data/app/services/forest_liana/resources_getter.rb

@@ -16,6 +16,7 @@ module ForestLiana
       @search_query_builder = SearchQueryBuilder.new(@params, @includes, @collection, @user)
 
       prepare_query
+      @base_records_for_batch = @records
     end
 
     def self.get_ids_from_request(params, user)
@@ -51,7 +52,7 @@ module ForestLiana
     end
 
     def query_for_batch
-      @records
+      @base_records_for_batch
     end
 
     def records
@@ -84,7 +85,10 @@ module ForestLiana
       columns = association.klass.column_names.map(&:to_sym)
 
       # Ensure the foreign key is present for manual binding (especially for has_one)
-      columns << association.foreign_key.to_sym if association.macro == :has_one
+      if association.macro == :has_one
+        foreign_keys = Array(association.foreign_key).map(&:to_sym)
+        columns.concat(foreign_keys)
+      end
 
       columns.uniq
     end
@@ -94,17 +98,7 @@ module ForestLiana
 
       @optional_includes = []
       if @field_names_requested && @params['searchExtended'].to_i != 1
-        includes = associations_has_one.map do |association|
-          association_name = association.name.to_s
-
-          fields = @params[:fields]&.[](association_name)&.split(',')
-          if fields&.size == 1 && fields.include?(association.klass.primary_key)
-            @field_names_requested << association.foreign_key
-            @optional_includes << association.name
-          end
-
-          association.name
-        end
+        includes = associations_has_one.map(&:name)
 
         includes_for_smart_search = []
         if @collection && @collection.search_fields
@@ -119,7 +113,13 @@ module ForestLiana
           includes_for_smart_search = includes_for_smart_search & includes_has_many
         end
 
-        @includes = (includes & @field_names_requested).concat(includes_for_smart_search)
+        filter_associations = extract_associations_from_filter
+        filter_has_many = filter_associations.select do |assoc_name|
+          assoc = @resource.reflect_on_association(assoc_name)
+          assoc && [:has_many, :has_and_belongs_to_many].include?(assoc.macro)
+        end
+
+        @includes = (includes & @field_names_requested).concat(includes_for_smart_search).concat(filter_has_many).uniq
       else
         @includes = associations_has_one
         # Avoid eager loading has_one associations pointing to a different database as ORM can't join cross databases
@@ -167,8 +167,13 @@ module ForestLiana
       conditions.each do |condition|
         field = condition['field']
         if field&.include?(':')
+          # Handle association filters with : separator (e.g., "user:name")
           associations << field.split(':').first.to_sym
           @count_needs_includes = true
+        elsif field&.include?('.')
+          # Handle nested association filters with . separator (e.g., "top_level_partner.display_name")
+          associations << field.split('.').first.to_sym
+          @count_needs_includes = true
         end
       end
 
@@ -285,17 +290,91 @@ module ForestLiana
 
     def compute_select_fields
       select = ['_forest_admin_eager_load']
+
+      pk = @resource.primary_key
+      if pk.is_a?(Array)
+        pk.each { |key| select << "#{@resource.table_name}.#{key}" }
+      else
+        select << "#{@resource.table_name}.#{pk}"
+      end
+
+      # Include columns used in default ordering for batch cursor compatibility
+      if @resource.respond_to?(:default_scoped) && @resource.default_scoped.order_values.any?
+        @resource.default_scoped.order_values.each do |order_value|
+          if order_value.is_a?(Arel::Nodes::Ordering)
+            # Extract column name from Arel node
+            column_name = order_value.expr.name if order_value.expr.respond_to?(:name)
+            select << "#{@resource.table_name}.#{column_name}" if column_name
+          elsif order_value.is_a?(String) || order_value.is_a?(Symbol)
+            # Handle simple column names
+            column_name = order_value.to_s.split(' ').first.split('.').last
+            select << "#{@resource.table_name}.#{column_name}"
+          end
+        end
+      end
+
+      # Handle ActiveStorage associations from both @includes and @field_names_requested
+      active_storage_associations_processed = Set.new
+
+      (@includes + @field_names_requested).each do |path|
+        association = path.is_a?(Symbol) ? @resource.reflect_on_association(path) : get_one_association(path)
+        next unless association
+        next if active_storage_associations_processed.include?(association.name)
+        next unless is_active_storage_association?(association)
+
+        # Include all columns from ActiveStorage tables to avoid initialization errors
+        table_name = association.table_name
+        association.klass.column_names.each do |column_name|
+          select << "#{table_name}.#{column_name}"
+        end
+
+        # Include the foreign key from the main resource (e.g., blob_id, record_id)
+        if association.macro == :belongs_to || association.macro == :has_one
+          foreign_keys = Array(association.foreign_key)
+          foreign_keys.each do |fk|
+            select << "#{@resource.table_name}.#{fk}"
+          end
+        end
+
+        active_storage_associations_processed.add(association.name)
+      end
+
       @field_names_requested.each do |path|
         association = get_one_association(path)
         if association
+          through_chain = []
           while association.options[:through]
+            through_chain << association.options[:through]
             association = get_one_association(association.options[:through])
           end
 
-          if SchemaUtils.polymorphic?(association)
-            select << "#{@resource.table_name}.#{association.foreign_type}"
+          # Skip ActiveStorage associations - already processed above
+          next if is_active_storage_association?(association)
+
+          # For :through associations, only add foreign keys from the direct (first) association in the chain
+          # Don't try to select columns from the main table for the final :through target
+          if through_chain.any?
+            # Use the first association in the through chain
+            first_through = get_one_association(through_chain.first)
+            if first_through && (first_through.macro == :belongs_to || first_through.macro == :has_one)
+              foreign_keys = Array(first_through.foreign_key)
+              foreign_keys.each do |fk|
+                select << "#{@resource.table_name}.#{fk}"
+              end
+            end
+          else
+            # Direct association (not :through)
+            if SchemaUtils.polymorphic?(association)
+              select << "#{@resource.table_name}.#{association.foreign_type}"
+            end
+
+            if association.macro == :belongs_to || association.macro == :has_one
+              foreign_keys = Array(association.foreign_key)
+              foreign_keys.each do |fk|
+                select << "#{@resource.table_name}.#{fk}"
+              end
+            end
           end
-          select << "#{@resource.table_name}.#{association.foreign_key}"
         end
 
         fields = @params[:fields]&.[](path)&.split(',')
@@ -303,7 +382,11 @@ module ForestLiana
           association = get_one_association(path)
           table_name = association.table_name
 
+          next if association && is_active_storage_association?(association)
+
           fields.each do |association_path|
+            next if association_path == 'id'
+
             if ForestLiana::SchemaHelper.is_smart_field?(association.klass, association_path)
               association.klass.attribute_names.each { |attribute| select << "#{table_name}.#{attribute}" }
             else
@@ -319,9 +402,21 @@ module ForestLiana
     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
       ForestLiana::QueryHelper.get_one_associations(@resource)
-                              .select { |association| association.name == name.to_sym }
+                              .select { |association| association.name == name_sym }
                               .first
     end
+
+    def is_active_storage_association?(association)
+      return false unless association
+      return false if SchemaUtils.polymorphic?(association)
+
+      klass_name = association.klass.name
+      klass_name == 'ActiveStorage::Attachment' ||
+      klass_name == 'ActiveStorage::Blob' ||
+      klass_name.start_with?('ActiveStorage::')
+    end
   end
 end

data/app/services/forest_liana/utils/composite_primary_key_helper.rb

@@ -0,0 +1,27 @@
+module ForestLiana
+  module Utils
+    module CompositePrimaryKeyHelper
+      def self.find_record(scoped_records, resource, id)
+        primary_key = resource.primary_key
+
+        if primary_key.is_a?(Array)
+          id_values = parse_composite_id(id)
+          conditions = primary_key.zip(id_values).to_h
+          scoped_records.find_by(conditions)
+        else
+          scoped_records.find(id)
+        end
+      end
+
+      def self.parse_composite_id(id)
+        return id if id.is_a?(Array)
+
+        if id.to_s.start_with?('[') && id.to_s.end_with?(']')
+          JSON.parse(id.to_s)
+        else
+          raise ForestLiana::Errors::HTTP422Error.new("Composite primary key ID must be in format [value1,value2], received: #{id}")
+        end
+      end
+    end
+  end
+end

data/app/services/forest_liana/utils/context_variables_injector.rb

@@ -5,7 +5,14 @@ module ForestLiana
       def self.inject_context_in_value(value, context_variables)
         inject_context_in_value_custom(value) do |context_variable_key|
           value = context_variables.get_value(context_variable_key)
-          raise "Unknown context variable: #{context_variable_key}, please check the query for any typos" if value.nil?
+          if value.nil?
+            available_keys = context_variables.respond_to?(:keys) ? context_variables.keys.join(', ') : 'unknown'
+            available_context = context_variables.inspect
+            error_message = "Unknown context variable: '#{context_variable_key}'. " \
+                          "Please check the query for any typos. " \
+                          "Available context variables: #{available_keys}. "
+            raise error_message
+          end
           value.to_s
         end
       end

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "9.16.0"
+  VERSION = "9.16.1"
 end

data/spec/requests/resources_spec.rb

@@ -309,6 +309,82 @@ describe 'Requesting User resources', :type => :request  do
   end
 end
 
+describe 'Requesting Island resources', :type => :request  do
+  let(:scope_filters) { {'scopes' => {}, 'team' => {'id' => '1', 'name' => 'Operations'}} }
+  before do
+    island = Island.create(name: 'Paradise Island')
+    Location.create(coordinates: '10,20', island: island)
+
+    Rails.cache.write('forest.users', {'1' => { 'id' => 1, 'roleId' => 1, 'rendering_id' => '1' }})
+    Rails.cache.write('forest.has_permission', true)
+    Rails.cache.write(
+      'forest.collections',
+      {
+        'Island' => {
+          'browse'  => [1],
+          'read'    => [1],
+          'edit'    => [1],
+          'add'     => [1],
+          'delete'  => [1],
+          'export'  => [1],
+          'actions' => {}
+        }
+      }
+    )
+
+    allow(ForestLiana::IpWhitelist).to receive(:retrieve) { true }
+    allow(ForestLiana::IpWhitelist).to receive(:is_ip_whitelist_retrieved) { true }
+    allow(ForestLiana::IpWhitelist).to receive(:is_ip_valid) { true }
+    allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return(scope_filters)
+  end
+
+  after do
+    Island.destroy_all
+    Location.destroy_all
+  end
+
+  token = JWT.encode({
+    id: 1,
+    email: 'michael.kelso@that70.show',
+    first_name: 'Michael',
+    last_name: 'Kelso',
+    team: 'Operations',
+    rendering_id: 16,
+    exp: Time.now.to_i + 2.weeks.to_i,
+    permission_level: 'admin'
+  }, ForestLiana.auth_secret, 'HS256')
+
+  headers = {
+    'Accept' => 'application/json',
+    'Content-Type' => 'application/json',
+    'Authorization' => "Bearer #{token}"
+  }
+
+  describe 'csv' do
+    it 'should return CSV with has_one association without SQL error' do
+      params = {
+        fields: { 'Island' => 'id,name,location', 'location' => 'coordinates'},
+        page: { 'number' => '1', 'size' => '10' },
+        searchExtended: '0',
+        sort: '-id',
+        timezone: 'Europe/Paris',
+        header: 'id,name,location',
+      }
+      get '/forest/Island.csv', params: params, headers: headers
+
+      expect(response.status).to eq(200)
+      expect(response.headers['Content-Type']).to include('text/csv')
+      expect(response.headers['Content-Disposition']).to include('attachment')
+
+      csv_content = response.body
+      csv_lines = csv_content.split("\n")
+
+      expect(csv_lines.first).to eq(params[:header])
+      expect(csv_lines[1]).to eq('1,Paradise Island,"10,20"')
+    end
+  end
+end
+
 describe 'Requesting Address resources', :type => :request  do
   let(:scope_filters) { {'scopes' => {}, 'team' => {'id' => '1', 'name' => 'Operations'}} }
   before do
@@ -391,4 +467,50 @@ describe 'Requesting Address resources', :type => :request  do
       )
     end
   end
+
+  describe 'csv' do
+    it 'should return CSV with polymorphic association' do
+      params = {
+        fields: { 'Address' => 'id,line1,city,addressable', 'addressable' => 'name'},
+        page: { 'number' => '1', 'size' => '10' },
+        searchExtended: '0',
+        sort: '-id',
+        timezone: 'Europe/Paris',
+        header: 'id,line1,city,addressable',
+      }
+      get '/forest/Address.csv', params: params, headers: headers
+
+      expect(response.status).to eq(200)
+      expect(response.headers['Content-Type']).to include('text/csv')
+      expect(response.headers['Content-Disposition']).to include('attachment')
+
+      csv_content = response.body
+      csv_lines = csv_content.split("\n")
+
+      expect(csv_lines.first).to eq(params[:header])
+      expect(csv_lines[1]).to eq('1,10 Downing Street,London,Michel')
+    end
+
+    it 'should return CSV with only requested fields and ignore optional polymorphic relation' do
+      params = {
+        fields: { 'Address' => 'id,line1,city', 'addressable' => 'name'},
+        page: { 'number' => '1', 'size' => '10' },
+        searchExtended: '0',
+        sort: '-id',
+        timezone: 'Europe/Paris',
+        header: 'id,line1,city',
+      }
+      get '/forest/Address.csv', params: params, headers: headers
+
+      expect(response.status).to eq(200)
+      expect(response.headers['Content-Type']).to include('text/csv')
+      expect(response.headers['Content-Disposition']).to include('attachment')
+
+      csv_content = response.body
+      csv_lines = csv_content.split("\n")
+
+      expect(csv_lines.first).to eq(params[:header])
+      expect(csv_lines[1]).to eq('1,10 Downing Street,London')
+    end
+  end
 end

data/spec/services/forest_liana/resources_getter_composite_keys_spec.rb

@@ -0,0 +1,116 @@
+require 'rails_helper'
+
+module ForestLiana
+  describe ResourcesGetter do
+    describe 'composite primary keys support' do
+      let(:resource) { User }
+      let(:params) do
+        {
+          page: { size: 10, number: 1 },
+          sort: 'id',
+          fields: { 'User' => 'id,name' }
+        }
+      end
+      let(:user) { { 'id' => '1', 'rendering_id' => 13 } }
+
+      before do
+        allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return({
+          'scopes' => {},
+          'team' => {'id' => '1', 'name' => 'Operations'}
+        })
+      end
+
+      describe '#get_one_association' do
+        it 'does not crash when name is a symbol' do
+          getter = described_class.new(resource, params, user)
+          expect {
+            getter.send(:get_one_association, :owner)
+          }.not_to raise_error
+        end
+
+        it 'does not crash when name is a string' do
+          getter = described_class.new(resource, params, user)
+          expect {
+            getter.send(:get_one_association, 'owner')
+          }.not_to raise_error
+        end
+
+        it 'does not crash when name is an array (composite key edge case)' do
+          getter = described_class.new(resource, params, user)
+          # Should not raise "undefined method `to_sym' for Array"
+          expect {
+            getter.send(:get_one_association, [:user_id, :slot_id])
+          }.not_to raise_error
+        end
+
+        it 'returns nil gracefully when name is an array' do
+          getter = described_class.new(resource, params, user)
+          result = getter.send(:get_one_association, [:user_id, :slot_id])
+          expect(result).to be_nil
+        end
+      end
+
+      describe 'handling composite foreign keys in associations' do
+        let(:mock_association) do
+          double('Association',
+            name: :test_association,
+            foreign_key: [:user_id, :slot_id],  # Composite foreign key
+            klass: double('Klass', column_names: ['id', 'name']),
+            macro: :has_one,
+            options: {}
+          )
+        end
+
+        let(:simple_association) do
+          double('Association',
+            name: :simple_association,
+            foreign_key: 'user_id',  # Simple foreign key
+            klass: double('Klass', column_names: ['id', 'name']),
+            macro: :has_one,
+            options: {}
+          )
+        end
+
+        describe '#columns_for_cross_database_association' do
+          it 'handles composite foreign keys without crashing' do
+            getter = described_class.new(resource, params, user)
+
+            allow(resource).to receive(:reflect_on_association)
+              .with(:test_association)
+              .and_return(mock_association)
+
+            expect {
+              getter.send(:columns_for_cross_database_association, :test_association)
+            }.not_to raise_error
+          end
+
+          it 'includes all composite foreign key columns' do
+            getter = described_class.new(resource, params, user)
+
+            allow(resource).to receive(:reflect_on_association)
+              .with(:test_association)
+              .and_return(mock_association)
+
+            columns = getter.send(:columns_for_cross_database_association, :test_association)
+
+            expect(columns).to include(:user_id)
+            expect(columns).to include(:slot_id)
+          end
+
+          it 'handles simple foreign keys without breaking existing behavior' do
+            getter = described_class.new(resource, params, user)
+
+            allow(resource).to receive(:reflect_on_association)
+              .with(:simple_association)
+              .and_return(simple_association)
+
+            expect {
+              columns = getter.send(:columns_for_cross_database_association, :simple_association)
+              expect(columns).to include(:user_id)
+            }.not_to raise_error
+          end
+        end
+      end
+    end
+  end
+end

data/spec/services/forest_liana/utils/context_variables_injector_spec.rb

@@ -105,7 +105,7 @@ module ForestLiana
         it 'raises an error when the variable is not found' do
           expect {
             described_class.inject_context_in_value("{{siths.selectedRecord.evilString}}", context_variables)
-          }.to raise_error('Unknown context variable: siths.selectedRecord.evilString, please check the query for any typos')
+          }.to raise_error(/Unknown context variable: 'siths\.selectedRecord\.evilString'/)
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: forest_liana
 version: !ruby/object:Gem::Version
-  version: 9.16.0
+  version: 9.16.1
 platform: ruby
 authors:
 - Sandro Munda
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-12-02 00:00:00.000000000 Z
+date: 2025-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -306,6 +306,7 @@ files:
 - app/services/forest_liana/stripe_subscriptions_getter.rb
 - app/services/forest_liana/token.rb
 - app/services/forest_liana/utils/beta_schema_utils.rb
+- app/services/forest_liana/utils/composite_primary_key_helper.rb
 - app/services/forest_liana/utils/context_variables.rb
 - app/services/forest_liana/utils/context_variables_injector.rb
 - app/services/forest_liana/value_stat_getter.rb
@@ -430,6 +431,7 @@ files:
 - spec/services/forest_liana/line_stat_getter_spec.rb
 - spec/services/forest_liana/pie_stat_getter_spec.rb
 - spec/services/forest_liana/resource_updater_spec.rb
+- spec/services/forest_liana/resources_getter_composite_keys_spec.rb
 - spec/services/forest_liana/resources_getter_spec.rb
 - spec/services/forest_liana/schema_adapter_spec.rb
 - spec/services/forest_liana/scope_manager_spec.rb
@@ -737,6 +739,7 @@ test_files:
 - spec/services/forest_liana/line_stat_getter_spec.rb
 - spec/services/forest_liana/pie_stat_getter_spec.rb
 - spec/services/forest_liana/resource_updater_spec.rb
+- spec/services/forest_liana/resources_getter_composite_keys_spec.rb
 - spec/services/forest_liana/resources_getter_spec.rb
 - spec/services/forest_liana/schema_adapter_spec.rb
 - spec/services/forest_liana/scope_manager_spec.rb