forest_liana 9.11.3 → 9.15.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dcd40a6f023ba4a2a7eddd15891ac11743dea8fee0df3378c42e604afbfe8c7e
-  data.tar.gz: 61ceac08bd477c79ea3d6284114b6a9a08f2514758378f4f7a96c3845efd4f8f
+  metadata.gz: 1c700fa60cbdb6da1e131e2e041d7bec408052bf6ce50304e51f2e6f6525e8d8
+  data.tar.gz: fdc53e76cf29afabdd6b18ec6a3279bd0e9bec3b467e8f8b16cb6cbb7dda87aa
 SHA512:
-  metadata.gz: e09c8a0a86cee9b238e35057b0e29e5b842fcf0a2a1380a57fb10bf00c9c2cf6cb5cf16bb9908d72fc4219966efa910742de673e5d0f9cd6696bbd83724d4f67
-  data.tar.gz: 24ecaa8c8a9442ec3c677bb71f47dbf8a120cba326732f202264869d1a3188265a30caa14054ffbd13c218deb6b13294ef997f60d83f0f347faccbc60d32bc98
+  metadata.gz: fe65c60f75a320f96e826dc7b93e25106d0958c62f1157212496ba57eef33e9be08776ab104200b2eb9d7e772fc1f2cae58f811f2033d57e2969e877cf3dbc64
+  data.tar.gz: bf3c7eb151213fb126ef896d040369c2a3c65500e8e2ecbd292c06cbb016939fc607e295db9fc719b09e428c52ad7f4462bee211f7f532794be0d4895ef2d50d

data/app/controllers/forest_liana/router.rb

@@ -37,6 +37,8 @@ class ForestLiana::Router
           end
         end
 
+        params["action"] = action
+        params["controller"] = "#{env["SCRIPT_NAME"]}/#{collection_name}".delete_prefix("/")
         controller.action(action.to_sym).call(env)
       rescue NoMethodError => exception
         FOREST_REPORTER.report exception

data/app/serializers/forest_liana/serializer_factory.rb

@@ -118,10 +118,6 @@ module ForestLiana
 
           if ret[:href].blank?
             begin
-              if @options[:include].try(:include?, attribute_name.to_s)
-                object.send(attribute_name)
-              end
-
               SchemaUtils.many_associations(object.class).each do |a|
                 if a.name == attribute_name
                   ret[:href] = "/forest/#{ForestLiana.name_for(object.class)}/#{object.id}/relationships/#{attribute_name}"
@@ -135,6 +131,33 @@ module ForestLiana
           ret
         end
 
+        def has_one_relationships
+          return {} if self.class.to_one_associations.nil?
+          data = {}
+          self.class.to_one_associations.each do |attribute_name, attr_data|
+            relation = object.class.reflect_on_all_associations.find { |a| a.name == attribute_name }
+
+            next if !should_include_attr?(attribute_name, attr_data)
+
+            unless relation.nil? || (relation.respond_to?(:polymorphic?) && relation.polymorphic?)
+              relation_class_name = ForestLiana.name_for(relation.klass).demodulize
+
+              if object.respond_to?(relation.foreign_key.to_sym) &&
+                @options[:fields][relation_class_name]&.size == 1 &&
+                @options[:fields][relation_class_name]&.include?(relation.klass.primary_key.to_sym)
+
+                attr_data[:attr_or_block] = proc {
+                  foreign_key_value = object.send(relation.foreign_key.to_sym)
+                  foreign_key_value.nil? ? nil : relation.klass.new(relation.klass.primary_key => foreign_key_value)
+                }
+              end
+            end
+
+            data[attribute_name] = attr_data
+          end
+          data
+        end
+
         private
 
         def intercom_integration?

data/app/services/forest_liana/aggregation_helper.rb

@@ -0,0 +1,42 @@
+module ForestLiana
+  module AggregationHelper
+    def resolve_field_path(field_param, default_field = 'id')
+      if field_param.blank?
+        default_field ||= @resource.primary_key || 'id'
+        return "#{@resource.table_name}.#{default_field}"
+      end
+
+      if field_param.include?(':')
+        association, field = field_param.split ':'
+        associated_resource = @resource.reflect_on_association(association.to_sym)
+        "#{associated_resource.table_name}.#{field}"
+      else
+        "#{@resource.table_name}.#{field_param}"
+      end
+    end
+
+    def aggregation_sql(type, field)
+      field_path = resolve_field_path(field)
+
+      case type
+      when 'sum'
+        "SUM(#{field_path})"
+      when 'count'
+        "COUNT(DISTINCT #{field_path})"
+      else
+        raise "Unsupported aggregator : #{type}"
+      end
+    end
+
+    def aggregation_alias(type, field)
+      case type
+      when 'sum'
+        "sum_#{field.downcase}"
+      when 'count'
+        'count_id'
+      else
+        raise "Unsupported aggregator : #{type}"
+      end
+    end
+  end
+end

data/app/services/forest_liana/base_getter.rb

@@ -19,13 +19,14 @@ module ForestLiana
 
     def compute_includes
       @includes = ForestLiana::QueryHelper.get_one_association_names_symbol(@resource)
+      @optional_includes = []
     end
 
-    def optimize_record_loading(resource, records)
+    def optimize_record_loading(resource, records, force_preload = true)
       polymorphic, preload_loads = analyze_associations(resource)
-      result = records.eager_load(@includes.uniq - preload_loads - polymorphic)
+      result = records.eager_load(@includes.uniq - preload_loads - polymorphic - @optional_includes)
 
-      result = result.preload(preload_loads) if Rails::VERSION::MAJOR >= 7
+      result = result.preload(preload_loads) if Rails::VERSION::MAJOR >= 7 && force_preload
 
       result
     end
@@ -46,6 +47,8 @@ module ForestLiana
     end
 
     def separate_database?(resource, association)
+      return false if SchemaUtils.polymorphic?(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

data/app/services/forest_liana/has_many_getter.rb

@@ -37,6 +37,8 @@ module ForestLiana
     private
 
     def compute_includes
+      @optional_includes = []
+
       @includes = @association.klass
         .reflect_on_all_associations
         .select do |association|
@@ -60,9 +62,8 @@ module ForestLiana
     end
 
     def field_names_requested
-      return nil unless @params[:fields] && @params[:fields][@collection_name]
-      @params[:fields][@collection_name].split(',')
-        .map { |name| name.to_sym }
+      fields = @params.dig(:fields, @collection_name)
+      Array(fields&.split(',')).map(&:to_sym)
     end
 
     def model_association

data/app/services/forest_liana/leaderboard_stat_getter.rb

@@ -1,6 +1,9 @@
 module ForestLiana
   class LeaderboardStatGetter < StatGetter
+    include AggregationHelper
+
     def initialize(parent_model, params, forest_user)
+      @resource = parent_model
       @scoped_parent_model = get_scoped_model(parent_model, forest_user, params[:timezone])
       child_model = @scoped_parent_model.reflect_on_association(params[:relationshipFieldName]).klass
       @scoped_child_model = get_scoped_model(child_model, forest_user, params[:timezone])
@@ -14,13 +17,15 @@ module ForestLiana
     def perform
       includes = ForestLiana::QueryHelper.get_one_association_names_symbol(@scoped_child_model)
 
+      alias_name = aggregation_alias(@aggregate, @aggregate_field)
+
       result = @scoped_child_model
         .joins(includes)
         .where({ @scoped_parent_model.name.downcase.to_sym => @scoped_parent_model })
         .group(@group_by)
-        .order(order)
+        .order(Arel.sql("#{alias_name} DESC"))
         .limit(@limit)
-        .send(@aggregate, @aggregate_field)
+        .pluck(@group_by, Arel.sql("#{aggregation_sql(@aggregate, @aggregate_field)} AS #{alias_name}"))
         .map { |key, value| { key: key, value: value } }
 
       @record = Model::Stat.new(value: result)
@@ -33,18 +38,5 @@ module ForestLiana
 
       FiltersParser.new(scope_filters, model, timezone, @params).apply_filters
     end
-
-    def order
-      order = 'DESC'
-
-      # NOTICE: The generated alias for a count is "count_all", for a sum the
-      #         alias looks like "sum_#{aggregate_field}"
-      if @aggregate == 'sum'
-        field = @aggregate_field.downcase
-      else
-        field = 'all'
-      end
-      "#{@aggregate}_#{field} #{order}"
-    end
   end
 end

data/app/services/forest_liana/pie_stat_getter.rb

@@ -1,5 +1,6 @@
 module ForestLiana
   class PieStatGetter < StatGetter
+    include AggregationHelper
     attr_accessor :record
 
     def perform
@@ -13,11 +14,16 @@ module ForestLiana
           resource = FiltersParser.new(filters, resource, @params[:timezone], @params).apply_filters
         end
 
-        result = resource
-          .group(groupByFieldName)
-          .order(order)
-          .send(@params[:aggregator].downcase, @params[:aggregateFieldName])
-          .map do |key, value|
+        aggregation_type = @params[:aggregator].downcase
+        aggregation_field = @params[:aggregateFieldName]
+        alias_name = aggregation_alias(aggregation_type, aggregation_field)
+
+        resource = resource
+                     .group(groupByFieldName)
+                     .order(Arel.sql("#{alias_name} DESC"))
+                     .pluck(groupByFieldName, Arel.sql("#{aggregation_sql(aggregation_type, aggregation_field)} AS #{alias_name}"))
+
+        result = resource.map do |key, value|
             # NOTICE: Display the enum name instead of an integer if it is an
             #         "Enum" field type on old Rails version (before Rails
             #         5.1.3).
@@ -38,28 +44,7 @@ module ForestLiana
     end
 
     def groupByFieldName
-      if @params[:groupByFieldName].include? ':'
-        association, field = @params[:groupByFieldName].split ':'
-        resource = @resource.reflect_on_association(association.to_sym)
-        "#{resource.table_name}.#{field}"
-      else
-        "#{@resource.table_name}.#{@params[:groupByFieldName]}"
-      end
-    end
-
-    def order
-      order = 'DESC'
-
-      # NOTICE: The generated alias for a count is "count_all", for a sum the
-      #         alias looks like "sum_#{aggregateFieldName}"
-      if @params[:aggregator].downcase == 'sum'
-        field = @params[:aggregateFieldName].downcase
-      else
-        # `count_id` is required only for rails v5
-        field = Rails::VERSION::MAJOR == 5 || @includes.size > 0 ? 'id' : 'all'
-      end
-      "#{@params[:aggregator].downcase}_#{field} #{order}"
+      resolve_field_path(@params[:groupByFieldName])
     end
-
   end
 end

data/app/services/forest_liana/resources_getter.rb

@@ -30,7 +30,20 @@ module ForestLiana
     end
 
     def perform
-      @records = optimize_record_loading(@resource, @records)
+      polymorphic_association, preload_loads = analyze_associations(@resource)
+      includes = @includes.uniq - polymorphic_association - preload_loads - @optional_includes
+      has_smart_fields = Array(@params.dig(:fields, @collection_name)&.split(',')).any? do |field|
+        ForestLiana::SchemaHelper.is_smart_field?(@resource, field)
+      end
+
+      if includes.empty? || has_smart_fields
+        @records = optimize_record_loading(@resource, @records, false)
+      else
+        select = compute_select_fields
+        @records = optimize_record_loading(@resource, @records, false).references(includes).select(*select)
+      end
+
+      @records
     end
 
     def count
@@ -42,31 +55,122 @@ module ForestLiana
     end
 
     def records
-      @records.offset(offset).limit(limit).to_a
+      records = @records.offset(offset).limit(limit).to_a
+      polymorphic_association, preload_loads = analyze_associations(@resource)
+
+      if polymorphic_association.any? && Rails::VERSION::MAJOR >= 7
+        preloader = ActiveRecord::Associations::Preloader.new(records: records, associations: polymorphic_association)
+        preloader.loaders
+        preloader.branches.each do |branch|
+          branch.loaders.each do |loader|
+            records_by_owner = loader.records_by_owner
+            records_by_owner.each do |record, association|
+              record_index =  records.find_index { |r| r.id == record.id }
+              records[record_index].define_singleton_method(branch.association) do
+                association.first
+              end
+            end
+          end
+        end
+      end
+
+      preload_cross_database_associations(records, preload_loads)
+
+      records
+    end
+
+    def preload_cross_database_associations(records, preload_loads)
+      preload_loads.each do |association_name|
+        association = @resource.reflect_on_association(association_name)
+        next unless separate_database?(@resource, association)
+
+        columns = columns_for_cross_database_association(association_name)
+        if association.macro == :belongs_to
+          foreign_key = association.foreign_key
+          primary_key = association.klass.primary_key
+
+          ids = records.map { |r| r.public_send(foreign_key) }.compact.uniq
+          next if ids.empty?
+
+          associated = association.klass.where(primary_key => ids)
+                                  .select(columns)
+                                  .index_by { |record| record.public_send(primary_key) }
+
+          records.each do |record|
+            record.define_singleton_method(association_name) do
+              associated[record.send(foreign_key.to_sym)] || nil
+            end
+          end
+        end
+
+        if association.macro == :has_one
+          foreign_key = association.foreign_key
+          primary_key = association.active_record_primary_key
+
+          ids = records.map { |r| r.public_send(primary_key) }.compact.uniq
+          next if ids.empty?
+
+          associated = association.klass.where(foreign_key => ids)
+                                  .select(columns)
+                                  .index_by { |record| record.public_send(foreign_key.to_sym) }
+
+          records.each do |record|
+            record.define_singleton_method(association_name) do
+              associated[record.send(primary_key.to_sym)] || nil
+            end
+          end
+        end
+      end
+    end
+
+    def columns_for_cross_database_association(association_name)
+      association = @resource.reflect_on_association(association_name)
+
+      # Always include all columns of the associated model to avoid missing attribute errors
+      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
+
+      columns.uniq
     end
 
     def compute_includes
       associations_has_one = ForestLiana::QueryHelper.get_one_associations(@resource)
 
-      includes = associations_has_one.map(&:name)
-      includes_for_smart_search = []
+      @optional_includes = []
+      if @field_names_requested && @params['searchExtended'].to_i != 1
+        includes = associations_has_one.map do |association|
+          association_name = association.name.to_s
 
-      if @collection && @collection.search_fields
-        includes_for_smart_search = @collection.search_fields
-                                               .select { |field| field.include? '.' }
-                                               .map { |field| field.split('.').first.to_sym }
+          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
 
-        includes_has_many = SchemaUtils.many_associations(@resource)
-                                       .select { |association| SchemaUtils.model_included?(association.klass) }
-                                       .map(&:name)
+          association.name
+        end
 
-        includes_for_smart_search = includes_for_smart_search & includes_has_many
-      end
+        includes_for_smart_search = []
+        if @collection && @collection.search_fields
+          includes_for_smart_search = @collection.search_fields
+                                                 .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)
+
+          includes_for_smart_search = includes_for_smart_search & includes_has_many
+        end
 
-      if @field_names_requested
         @includes = (includes & @field_names_requested).concat(includes_for_smart_search)
       else
-        @includes = includes
+        @includes = associations_has_one
+        # Avoid eager loading has_one associations pointing to a different database as ORM can't join cross databases
+                      .reject { |association| separate_database?(@resource, association) }
+                      .map(&:name)
       end
     end
 
@@ -85,7 +189,7 @@ module ForestLiana
     end
 
     def field_names_requested
-      return nil unless @params[:fields] && @params[:fields][@collection_name]
+      return [] unless @params.dig(:fields, @collection_name)
 
       associations_for_query = extract_associations_from_filter
       associations_for_query << @params[:sort].split('.').first.to_sym if @params[:sort]&.include?('.')
@@ -94,15 +198,29 @@ module ForestLiana
 
     def extract_associations_from_filter
       associations = []
-      @params[:filter]&.each do |field, _|
-        if field.include?(':')
+
+      filters = @params[:filters]
+      filters = JSON.parse(filters) if filters.is_a?(String)
+
+      conditions = []
+
+      if filters.is_a?(Hash) && filters.key?('conditions')
+        conditions = filters['conditions']
+      elsif filters.is_a?(Hash) && filters.key?('field')
+        conditions = [filters]
+      end
+
+      conditions.each do |condition|
+        field = condition['field']
+        if field&.include?(':')
           associations << field.split(':').first.to_sym
           @count_needs_includes = true
         end
       end
+
       @count_needs_includes = true if @params[:search]
 
-      associations
+      associations.uniq
     end
 
     def prepare_query
@@ -210,5 +328,46 @@ module ForestLiana
     def pagination?
       @params[:page]&.dig(:number)
     end
+
+    def compute_select_fields
+      select = ['_forest_admin_eager_load']
+      @field_names_requested.each do |path|
+        association = get_one_association(path)
+        if association
+          while association.options[:through]
+            association = get_one_association(association.options[:through])
+          end
+
+          if SchemaUtils.polymorphic?(association)
+            select << "#{@resource.table_name}.#{association.foreign_type}"
+          end
+          select << "#{@resource.table_name}.#{association.foreign_key}"
+        end
+
+        fields = @params[:fields]&.[](path)&.split(',')
+        if fields
+          association = get_one_association(path)
+          table_name = association.table_name
+
+          fields.each do |association_path|
+            if ForestLiana::SchemaHelper.is_smart_field?(association.klass, association_path)
+              association.klass.attribute_names.each { |attribute| select << "#{table_name}.#{attribute}" }
+            else
+              select << "#{table_name}.#{association_path}"
+            end
+          end
+        else
+          select << "#{@resource.table_name}.#{path}"
+        end
+      end
+
+      select.uniq
+    end
+
+    def get_one_association(name)
+      ForestLiana::QueryHelper.get_one_associations(@resource)
+                              .select { |association| association.name == name.to_sym }
+                              .first
+    end
   end
 end

data/app/services/forest_liana/schema_adapter.rb

@@ -278,7 +278,13 @@ module ForestLiana
               field[:field] = association.name
               field[:inverse_of] = inverse_of(association)
               field[:relationship] = get_relationship_type(association)
-          # NOTICE: Create the fields of hasOne, HasMany, … relationships.
+
+              ForestLiana::SchemaUtils.disable_filter_and_sort_if_cross_db!(
+                field,
+                association.name.to_s,
+                ForestLiana.name_for(@model)
+              )
+              # NOTICE: Create the fields of hasOne, HasMany, … relationships.
           else
             collection.fields << get_schema_for_association(association)
           end
@@ -346,7 +352,7 @@ module ForestLiana
     end
 
     def get_schema_for_association(association)
-      {
+      opts ={
         field: association.name.to_s,
         type: get_type_for_association(association),
         relationship: get_relationship_type(association),
@@ -363,6 +369,14 @@ module ForestLiana
         widget: nil,
         validations: []
       }
+
+      ForestLiana::SchemaUtils.disable_filter_and_sort_if_cross_db!(
+        opts,
+        association.name.to_s,
+        ForestLiana.name_for(@model)
+      )
+
+      opts
     end
 
     def get_relationship_type(association)

data/app/services/forest_liana/schema_utils.rb

@@ -126,5 +126,27 @@ module ForestLiana
     def self.is_active_type? model
       Object.const_defined?('ActiveType::Object') && model < ActiveType::Object
     end
+
+    def self.disable_filter_and_sort_if_cross_db!(opts, name, collection_name)
+      return unless opts[:reference]
+
+      assoc_name = opts[:reference].split('.').first&.underscore&.to_sym || name
+      model = find_model_from_collection_name(collection_name)
+      return unless model
+
+      association = model.reflect_on_association(assoc_name)
+      return unless association
+      return if polymorphic?(association)
+
+      model_db = model.connection_db_config.database
+      assoc_db = association.klass.connection_db_config.database
+
+      if model_db != assoc_db
+        opts[:is_filterable] = false
+        opts[:is_sortable] = false
+      end
+    rescue => e
+      FOREST_LOGGER.warn("Could not evaluate cross-db association for #{name}: #{e.message}")
+    end
   end
 end

data/app/services/forest_liana/search_query_builder.rb

@@ -150,7 +150,7 @@ module ForestLiana
           conditions.join(' OR '),
           search_value_for_string: "%#{@search.downcase}%",
           search_value_for_uuid: @search.to_s
-        )
+        ) unless conditions.empty?
       end
 
       @records

data/lib/forest_liana/active_record_override.rb

@@ -0,0 +1,65 @@
+module ForestLiana
+  module ActiveRecordOverride
+    module Associations
+      require 'active_record/associations/join_dependency'
+      module JoinDependency
+        def apply_column_aliases(relation)
+          if !(@join_root_alias = relation.select_values.empty?) &&
+            relation.select_values.first.to_s == '_forest_admin_eager_load'
+
+            relation.select_values.shift
+            used_cols = {}
+            # Find and expand out all column names being used in select(...)
+            new_select_values = relation.select_values.map(&:to_s).each_with_object([]) do |col, select|
+              unless col.include?(' ') # Pass it through if it's some expression (No chance for a simple column reference)
+                col = if (col_parts = col.split('.')).length == 1
+                  [col]
+                else
+                  [col_parts[0..-2].join('.'), col_parts.last]
+                end
+                used_cols[col] = nil
+              end
+              select << col
+            end
+
+            if new_select_values.present?
+              relation.select_values = new_select_values
+            else
+              relation.select_values.clear
+            end
+
+            @aliases ||= ActiveRecord::Associations::JoinDependency::Aliases.new(join_root.each_with_index.map do |join_part, i|
+              join_alias = join_part.table&.table_alias || join_part.table_name
+              keys = [join_part.base_klass.primary_key] # Always include the primary key
+
+              # # %%% Optional to include all foreign keys:
+              # keys.concat(join_part.base_klass.reflect_on_all_associations.select { |a| a.belongs_to? }.map(&:foreign_key))
+              # Add foreign keys out to referenced tables that we belongs_to
+              join_part.children.each { |child| keys << child.reflection.foreign_key if child.reflection.belongs_to? }
+
+              # Add the foreign key that got us here -- "the train we rode in on" -- if we arrived from
+              # a has_many or has_one:
+              if join_part.is_a?(ActiveRecord::Associations::JoinDependency::JoinAssociation) &&
+                !join_part.reflection.belongs_to?
+                keys << join_part.reflection.foreign_key
+              end
+              keys = keys.compact # In case we're using composite_primary_keys
+              j = 0
+              columns = join_part.column_names.each_with_object([]) do |column_name, s|
+                # Include columns chosen in select(...) as well as the PK and any relevant FKs
+                if used_cols.keys.find { |c| (c.length == 1 || c.first == join_alias) && c.last == column_name } ||
+                  keys.find { |c| c == column_name }
+                  s << ActiveRecord::Associations::JoinDependency::Aliases::Column.new(column_name, "t#{i}_r#{j}")
+                end
+                j += 1
+              end
+              ActiveRecord::Associations::JoinDependency::Aliases::Table.new(join_part, columns)
+            end)
+            relation.select_values.clear
+          end
+          relation._select!(-> { aliases.columns })
+        end
+      end
+    end
+  end
+end

data/lib/forest_liana/engine.rb

@@ -7,6 +7,7 @@ require 'jwt'
 require 'bcrypt'
 require_relative 'bootstrapper'
 require_relative 'collection'
+require_relative 'active_record_override'
 
 module Rack
   class Cors
@@ -90,6 +91,12 @@ module ForestLiana
       end
     end
 
+    initializer 'forest_liana.override_active_record_dependency' do
+      ActiveSupport.on_load(:active_record) do
+        ActiveRecord::Associations::JoinDependency.prepend(ForestLiana::ActiveRecordOverride::Associations::JoinDependency)
+      end
+    end
+
     config.after_initialize do |app|
       if error
         FOREST_REPORTER.report error