forest_liana 9.3.14 → 9.3.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9d26eae41b148fe02b538ee3203010cf491e7a54ddc82f70bec65200864e693
-  data.tar.gz: e27a72bd11f586a440aed43f1e1ee9ce4abc2214e2bde575ab93c9b5a6c25e04
+  metadata.gz: 53102b046de3c8137e31de9c1cdd7581d860e497ef870f0fee0c08e4faa34c3f
+  data.tar.gz: 1eaf3d98e252b8683fb6b2398058dd86b269b45df5f6644c488d2aba5c110206
 SHA512:
-  metadata.gz: ec6c3e5ae7cd26eb4299ae8cadacc08f1acd252f71c93d9a239b15b9273634b56aa8228ad272fcaef48db8d820f0b673bc55983df541201ab2702e8561a8e992
-  data.tar.gz: 2d31b0ed25ff8d6340ddd63d7656f159532ba05bd5a10d0e8f21d1d8f304469377e970334eecde63c29f2ee03cb41ef4a9acf7de8ccfe5b1e7ad25ebc19e9193
+  metadata.gz: 6ccf9b6efd785f8ffcc39f0e0514ba73c408b98ae5a842695279b38127fb17cc8e5b555391596c5e2132933cb981a9916d641ff5cb7fb58481cbe5928b1a5d1c
+  data.tar.gz: 58c7b9630f16d8cbb00fa4c058a6002c635f3f07c0c3a0183989b9acbeda16667864a3e183fb1557faf6a38c1b6062056f720364722148fbfcd8facd6e4e4a3a

data/app/services/forest_liana/base_getter.rb

@@ -5,23 +5,14 @@ module ForestLiana
     end
 
     def get_resource
-      use_act_as_paranoid = @resource.instance_methods
-        .include? :really_destroyed?
-
-      # NOTICE: Do not unscope with the paranoia gem to prevent the retrieval
-      #         of deleted records.
-      use_act_as_paranoid ? @resource : @resource.unscoped
+      @resource.instance_methods.include?(:really_destroyed?) ? @resource : @resource.unscoped
     end
 
     def includes_for_serialization
-      includes_initial = @includes
       includes_for_smart_belongs_to = @collection.fields_smart_belongs_to.map { |field| field[:field] }
+      includes_for_smart_belongs_to &= @field_names_requested if @field_names_requested
 
-      if @field_names_requested
-        includes_for_smart_belongs_to = includes_for_smart_belongs_to & @field_names_requested
-      end
-
-      includes_initial.concat(includes_for_smart_belongs_to).map(&:to_s)
+      @includes.concat(includes_for_smart_belongs_to).map(&:to_s)
     end
 
     private
@@ -31,34 +22,36 @@ module ForestLiana
     end
 
     def optimize_record_loading(resource, records)
-      instance_dependent_associations = instance_dependent_associations(resource)
+      polymorphic, preload_loads = analyze_associations(resource)
+      result = records.eager_load(@includes.uniq - preload_loads - polymorphic)
 
+      result = result.preload(preload_loads) if Rails::VERSION::MAJOR >= 7
+
+      result
+    end
+
+    def analyze_associations(resource)
       polymorphic = []
-      preload_loads = @includes.select do |name|
+      preload_loads = @includes.uniq.select do |name|
         association = resource.reflect_on_association(name)
         if SchemaUtils.polymorphic?(association)
           polymorphic << association.name
           false
         else
-          targetModelConnection = association.klass.connection
-          targetModelDatabase = targetModelConnection.current_database if targetModelConnection.respond_to? :current_database
-          resourceConnection = resource.connection
-          resourceDatabase = resourceConnection.current_database if resourceConnection.respond_to? :current_database
-
-          targetModelDatabase != resourceDatabase
+          separate_database?(resource, association)
         end
-      end + instance_dependent_associations
+      end + instance_dependent_associations(resource)
 
-      result = records.eager_load(@includes - preload_loads - polymorphic)
+      [polymorphic, preload_loads]
+    end
 
-      # Rails 7 can mix `eager_load` and `preload` in the same scope
-      # Rails 6 cannot mix `eager_load` and `preload` in the same scope
-      # Rails 6 and 7 cannot mix `eager_load` and `includes` in the same scope
-      if Rails::VERSION::MAJOR >= 7
-        result = result.preload(preload_loads)
-      end
+    def separate_database?(resource, association)
+      target_model_connection = association.klass.connection
+      target_model_database = target_model_connection.current_database if target_model_connection.respond_to? :current_database
+      resource_connection = resource.connection
+      resource_database = resource_connection.current_database if resource_connection.respond_to? :current_database
 
-      result
+      target_model_database != resource_database
     end
 
     def instance_dependent_associations(resource)

data/app/services/forest_liana/filters_parser.rb

@@ -1,6 +1,6 @@
 module ForestLiana
   class FiltersParser
-    AGGREGATOR_OPERATOR = %w(and or)
+    AGGREGATOR_OPERATOR = %w(and or).freeze
 
     def initialize(filters, resource, timezone, params = nil)
       @filters = filters
@@ -13,18 +13,14 @@ module ForestLiana
     def apply_filters
       return @resource unless @filters
 
-      where = parse_aggregation(@filters)
-      return @resource unless where
+      where_clause = parse_aggregation(@filters)
+      return @resource unless where_clause
 
       @joins.each do |join|
-        current_resource = @resource.reflect_on_association(join.name).klass
-        current_resource.include(ArelHelpers::Aliases)
-        current_resource.aliased_as(join.name) do |aliased_resource|
-          @resource = @resource.joins(ArelHelpers.join_association(@resource, join.name, Arel::Nodes::OuterJoin, aliases: [aliased_resource]))
-        end
+        @resource = @resource.eager_load(join.name)
       end
 
-      @resource.where(where)
+      @resource.where(where_clause)
     end
 
     def parse_aggregation(node)
@@ -170,8 +166,8 @@ module ForestLiana
         current_resource = @resource.reflect_on_association(field.split(':').first.to_sym)&.klass
         raise ForestLiana::Errors::HTTP422Error.new("Field '#{field}' not found") unless current_resource
 
-        association = get_association_name_for_condition(field)
-        quoted_table_name = ActiveRecord::Base.connection.quote_column_name(association)
+        get_association_name_for_condition(field)
+        quoted_table_name = current_resource.table_name
         field_name = field.split(':')[1]
       else
         quoted_table_name = @resource.quoted_table_name

data/app/services/forest_liana/resources_getter.rb

@@ -1,68 +1,32 @@
 module ForestLiana
   class ResourcesGetter < BaseGetter
-    attr_reader :search_query_builder
-    attr_reader :includes
-    attr_reader :records_count
+    attr_reader :search_query_builder, :includes, :records_count
 
     def initialize(resource, params, forest_user)
       @resource = resource
       @params = params
+      @user = forest_user
       @count_needs_includes = false
       @collection_name = ForestLiana.name_for(@resource)
       @collection = get_collection(@collection_name)
       @fields_to_serialize = get_fields_to_serialize
       @field_names_requested = field_names_requested
-      get_segment
+      @segment = get_segment
       compute_includes
-      @user = forest_user
-      @search_query_builder = SearchQueryBuilder.new(@params, @includes, @collection, forest_user)
+      @search_query_builder = SearchQueryBuilder.new(@params, @includes, @collection, @user)
 
       prepare_query
     end
 
     def self.get_ids_from_request(params, user)
       attributes = params.dig('data', 'attributes')
-      has_body_attributes = attributes != nil
-      is_select_all_records_query = has_body_attributes && attributes[:all_records] == true
-
-      # NOTICE: If it is not a "select all records" query and it receives a list of ID, return list of ID.
-      return attributes[:ids] if (!is_select_all_records_query && attributes[:ids])
-
-      # NOTICE: If it is a "select all records" we have to perform query to build ID list.
-      ids = Array.new
-
-      # NOTICE: Merging all_records_subset_query into attributes preserves filters in HasManyGetter and ResourcesGetter.
-      attributes = attributes.merge(attributes[:all_records_subset_query].dup.to_unsafe_h)
-
-      # NOTICE: Initialize actual resources getter (could either a HasManyGetter or a ResourcesGetter).
-      is_related_data = attributes[:parent_collection_id] &&
-        attributes[:parent_collection_name] &&
-        attributes[:parent_association_name]
-      if is_related_data
-        parent_collection_name = attributes[:parent_collection_name]
-        parent_model = ForestLiana::SchemaUtils.find_model_from_collection_name(parent_collection_name)
-        model = parent_model.reflect_on_association(attributes[:parent_association_name].try(:to_sym))
-        resources_getter = ForestLiana::HasManyGetter.new(parent_model, model, attributes.merge({
-          collection: parent_collection_name,
-          id: attributes[:parent_collection_id],
-          association_name: attributes[:parent_association_name],
-        }), user)
-      else
-        collection_name = attributes[:collection_name]
-        model = ForestLiana::SchemaUtils.find_model_from_collection_name(collection_name)
-        resources_getter = ForestLiana::ResourcesGetter.new(model, attributes, user)
-      end
+      return attributes[:ids] if attributes&.fetch(:all_records, false) == false && attributes[:ids]
 
-      # NOTICE: build IDs list.
-      resources_getter.query_for_batch.find_in_batches() do |records|
-        ids += records.map { |record| record.id }
-      end
-
-      # NOTICE: remove excluded IDs.
-      ids_excluded = (attributes[:all_records_ids_excluded]).map { |id_excluded| id_excluded.to_s }
-      return ids.select { |id| !ids_excluded.include? id.to_s } if (ids_excluded && ids_excluded.any?)
+      attributes = merge_subset_query(attributes)
+      resources_getter = initialize_resources_getter(attributes, user)
+      ids = fetch_ids(resources_getter)
 
-      return ids
+      filter_excluded_ids(ids, attributes[:all_records_ids_excluded])
     end
 
     def perform
@@ -70,9 +34,7 @@ module ForestLiana
     end
 
     def count
-      # NOTICE: For performance reasons, do not optimize loading the data if there is  no search or
-      #         filters on associations.
-      @records_count = @count_needs_includes ? optimize_record_loading(@resource, @records).count : @records.count
+      @records_count = @count_needs_includes ? optimized_count : @records.count
     end
 
     def query_for_batch
@@ -91,12 +53,12 @@ module ForestLiana
 
       if @collection && @collection.search_fields
         includes_for_smart_search = @collection.search_fields
-          .select { |field| field.include? '.' }
-          .map { |field| field.split('.').first.to_sym }
+                                               .select { |field| field.include? '.' }
+                                               .map { |field| field.split('.').first.to_sym }
 
         includes_has_many = SchemaUtils.many_associations(@resource)
-          .select { |association| SchemaUtils.model_included?(association.klass) }
-          .map(&:name)
+                                       .select { |association| SchemaUtils.model_included?(association.klass) }
+                                       .map(&:name)
 
         includes_for_smart_search = includes_for_smart_search & includes_has_many
       end
@@ -115,107 +77,126 @@ module ForestLiana
     private
 
     def get_fields_to_serialize
-      if @params[:fields] && @params[:fields][@collection_name]
-        @params[:fields][@collection_name].split(',').map { |name| name.to_sym }
-      else
-        []
-      end
+      @params.dig(:fields, @collection_name)&.split(',')&.map(&:to_sym) || []
     end
 
     def get_segment
-      if @params[:segment]
-        @segment = @collection.segments.find do |segment|
-          segment.name == @params[:segment]
-        end
-      end
-      @segment ||= nil
+      @collection.segments.find { |segment| segment.name == @params[:segment] } if @params[:segment]
     end
 
     def field_names_requested
       return nil unless @params[:fields] && @params[:fields][@collection_name]
 
-      associations_for_query = []
+      associations_for_query = extract_associations_from_filter
+      associations_for_query << @params[:sort].split('.').first.to_sym if @params[:sort]&.include?('.')
+      @fields_to_serialize | associations_for_query
+    end
 
-      # NOTICE: Populate the necessary associations for filters
-      if @params[:filter]
-        @params[:filter].each do |field, values|
-          if field.include? ':'
-            associations_for_query << field.split(':').first.to_sym
-            @count_needs_includes = true
-          end
+    def extract_associations_from_filter
+      associations = []
+      @params[:filter]&.each do |field, _|
+        if field.include?(':')
+          associations << field.split(':').first.to_sym
+          @count_needs_includes = true
         end
       end
-
       @count_needs_includes = true if @params[:search]
 
-      if @params[:sort] && @params[:sort].include?('.')
-        associations_for_query << @params[:sort].split('.').first.to_sym
+      associations
+    end
+
+    def prepare_query
+      @records = get_resource
+
+      if @segment
+        @records = apply_segment(@records)
       end
 
-      @fields_to_serialize | associations_for_query
+      apply_live_query_segment if @params[:segmentQuery]
+      @records = search_query
     end
 
-    def search_query
-      @search_query_builder.perform(@records)
+    def optimized_count
+      optimize_record_loading(@resource, @records).count
     end
 
-    def prepare_query
-      @records = get_resource
+    def apply_segment(records)
+      return records.send(@segment.scope) if @segment.scope
+      return records.where(@segment.where.call) if @segment.where
+
+      records
+    end
 
-      if @segment && @segment.scope
-        @records = @records.send(@segment.scope)
-      elsif @segment && @segment.where
-        @records = @records.where(@segment.where.call())
+    def apply_live_query_segment
+      LiveQueryChecker.new(@params[:segmentQuery], 'Live Query Segment').validate
+
+      begin
+        segment_query = @params[:segmentQuery].gsub(/\;\s*$/, '')
+        @records = @records.where(
+          "#{@resource.table_name}.#{@resource.primary_key} IN (SELECT id FROM (#{segment_query}) as ids)"
+        )
+      rescue => error
+        handle_live_query_error(error)
       end
+    end
 
-      # NOTICE: Live Query mode
-      if @params[:segmentQuery]
-        LiveQueryChecker.new(@params[:segmentQuery], 'Live Query Segment').validate()
-
-        begin
-          segmentQuery = @params[:segmentQuery].gsub(/\;\s*$/, '')
-          @records = @records.where(
-            "#{@resource.table_name}.#{@resource.primary_key} IN (SELECT id FROM (#{segmentQuery}) as ids)"
-          )
-        rescue => error
-          error_message = "Live Query Segment: #{error.message}"
-          FOREST_REPORTER.report error
-          FOREST_LOGGER.error(error_message)
-          raise ForestLiana::Errors::LiveQueryError.new(error_message)
-        end
+    def handle_live_query_error(error)
+      error_message = "Live Query Segment: #{error.message}"
+      FOREST_REPORTER.report error
+      FOREST_LOGGER.error(error_message)
+      raise ForestLiana::Errors::LiveQueryError.new(error_message)
+    end
+
+    def self.merge_subset_query(attributes)
+      attributes.merge(attributes[:all_records_subset_query].dup.to_unsafe_h)
+    end
+
+    def self.initialize_resources_getter(attributes, user)
+      if related_data?(attributes)
+        HasManyGetter.new(*related_data_params(attributes, user))
+      else
+        ResourcesGetter.new(SchemaUtils.find_model_from_collection_name(attributes[:collection_name]), attributes, user)
       end
+    end
 
-      @records = search_query
+    def self.related_data?(attributes)
+      attributes[:parent_collection_id] && attributes[:parent_collection_name] && attributes[:parent_association_name]
     end
 
-    def association?(field)
-      @resource.reflect_on_association(field.to_sym).present?
+    def self.related_data_params(attributes, user)
+      parent_model = SchemaUtils.find_model_from_collection_name(attributes[:parent_collection_name])
+      model = parent_model.reflect_on_association(attributes[:parent_association_name].to_sym)
+      [parent_model, model, attributes.merge(collection: attributes[:parent_collection_name]), user]
+    end
+
+    def self.fetch_ids(resources_getter)
+      ids = []
+      resources_getter.query_for_batch.find_in_batches { |records| ids += records.map(&:id) }
+
+      ids
+    end
+
+    def self.filter_excluded_ids(ids, ids_excluded)
+      ids_excluded ? ids.reject { |id| ids_excluded.map(&:to_s).include?(id.to_s) } : ids
+    end
+
+    def search_query
+      @search_query_builder.perform(@records)
     end
 
     def offset
       return 0 unless pagination?
 
-      number = @params[:page][:number]
-      if number && number.to_i > 0
-        (number.to_i - 1) * limit
-      else
-        0
-      end
+      number = @params.dig(:page, :number)
+      number.to_i.positive? ? (number.to_i - 1) * limit : 0
     end
 
     def limit
-      return 10 unless pagination?
-
-      if @params[:page][:size]
-        @params[:page][:size].to_i
-      else
-        10
-      end
+      @params.dig(:page, :size)&.to_i || 10
     end
 
     def pagination?
-      @params[:page] && @params[:page][:number]
+      @params[:page]&.dig(:number)
     end
-
   end
 end

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "9.3.14"
+  VERSION = "9.3.15"
 end

data/spec/services/forest_liana/filters_parser_spec.rb

@@ -421,7 +421,7 @@ module ForestLiana
       context 'on belongs to field' do
         context 'existing field' do
           let(:field_name) { 'trees:age' }
-          it { expect(result).to eq "\"trees\".\"age\""}
+          it { expect(result).to eq "trees.\"age\""}
         end
         context 'not existing field' do
           let(:field_name) { 'hero:age' }

data/spec/services/forest_liana/resources_getter_spec.rb

@@ -248,6 +248,31 @@ module ForestLiana
       end
     end
 
+    context 'when fields is given' do
+      let(:resource) { Island }
+      let(:filters) { {
+        field: 'location:id',
+        operator: 'equal',
+        value: 1,
+      }.to_json }
+
+      it 'should get only the expected records' do
+        getter.perform
+        records = getter.records
+        count = getter.count
+
+        expect(records.count).to eq 1
+        expect(count).to eq 1
+        expect(records.map(&:id)).to eq [1]
+      end
+
+      it 'should include associated table only once' do
+        sql_query = getter.perform.to_sql
+        location_includes_count = sql_query.scan('LEFT OUTER JOIN "locations"').count
+        expect(location_includes_count).to eq(1)
+      end
+    end
+
     describe 'when getting instance dependent associations' do
       let(:resource) { Island }
       let(:fields) { { 'Island' => 'id,eponymous_tree', 'eponymous_tree' => 'id,name'} }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: forest_liana
 version: !ruby/object:Gem::Version
-  version: 9.3.14
+  version: 9.3.15
 platform: ruby
 authors:
 - Sandro Munda
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-08-30 00:00:00.000000000 Z
+date: 2024-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails