refine-rails 2.13.3 → 2.13.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d884d53b3f3d7c0dc223d7a3a772544df81c58fd389e54d97b027b743acb3f4
-  data.tar.gz: 63a180f14c982ed73ca57cf0ada9e3894a0b0328351d97b7a76b507e0d6276c2
+  metadata.gz: b2336d0d23d8af77f9f090bfd8962c25a8c97c9d9f39ffce7be9fe2034d7affc
+  data.tar.gz: 191d8e607720235a354e4da42e640e0fd3ca5b29aca814c1a1a0531d75f01833
 SHA512:
-  metadata.gz: b07dc837ed05cfae41e2332822bab37cbab7a289d60da1b7fc71e8b1cc4d08ec47e5cf072dd80bdfb4b59f82d9fbce037e4c2ad0ce89838b719c88d6925efc38
-  data.tar.gz: 28ceb0a1e948230d97571b3f1bac60b83d4d4b27ad9233cf86e7033e40337ec3dea6b704de4e85c272337c45587f3d31c5915e2234c6372f57e28625419954ca
+  metadata.gz: f0fd3bc2e744d3de0fcd7092bd87d5969d472c886eacc7d007ff711bae937449588b48cb7ed5e56f590756f6d0f214fee2b690bdc9ead7676453b7e64e8862e5
+  data.tar.gz: 692abd2df6a29e0687f4aa4ad985ebf88371b5a72b7b45432d42e4837cc423272a98c15dc2a139bdebe7ac0a0d24a53b293b8f7f25e43081da1fc13013c555fd

data/app/models/refine/conditions/condition.rb

@@ -13,6 +13,7 @@ module Refine::Conditions
     include HasThroughIdRelationship
     include WithForcedIndex
     include HasIcon
+    include SupportsFlatQueries
 
     attr_reader :ensurances, :before_validations, :clause, :filter
     attr_accessor :display, :id, :is_refinement, :attribute

data/app/models/refine/conditions/supports_flat_queries.rb

@@ -0,0 +1,145 @@
+module Refine::Conditions
+  module SupportsFlatQueries
+
+    LEFT_JOIN_CLAUSES = [
+      Refine::Conditions::Clauses::NOT_IN,
+      Refine::Conditions::Clauses::NOT_SET,
+      Refine::Conditions::Clauses::DOESNT_EQUAL,
+      Refine::Conditions::Clauses::DOESNT_CONTAIN
+    ]
+    
+    # Applies the criterion which can be a relationship condition
+    #
+    # @param [Hash] input The user's input
+    # @param [Arel::Table] table The arel_table the query is built on 
+    # @param [ActiveRecord::Relation] initial_query The base query the query is built on 
+    # @param [Bool] inverse_clause Whether to invert the clause
+    # @return [Arel::Node] 
+    def apply_flat(input, table, initial_query, inverse_clause=false)
+      table ||= filter.table
+      # Ensurance validations are checking the developer configured correctly
+      run_ensurance_validations
+      # Allow developer to modify user input
+      # TODO run_before_validate(input) -> what is this for?
+
+      run_before_validate_validations(input)
+
+      # TODO Determine right place to set the clause
+      validate_user_input(input)
+      if input.dig(:filter_refinement).present?
+
+        filter_condition = call_proc_if_callable(@filter_refinement_proc)
+        # Set the filter on the filter_condition to be the current_condition's filter
+        filter_condition.set_filter(filter)
+        filter_condition.is_refinement = true
+
+        # Applying the filter condition will modify pending relationship subqueries in place
+        filter_condition.apply(input.dig(:filter_refinement), table, initial_query)
+        input.delete(:filter_refinement)
+      end
+
+      if is_relationship_attribute?
+        return handle_flat_relational_condition(input: input, query: initial_query, inverse_clause: inverse_clause)
+      end
+      # Not a relationship attribute, apply condition normally
+      nodes = apply_condition(input, table, inverse_clause)
+      if !is_refinement && has_any_refinements?
+        refined_node = apply_refinements(input)
+        # Count refinement will return nil because it directly modified pending relationship subquery
+        nodes = nodes.and(refined_node) if refined_node
+      end
+      nodes
+    end
+
+    def handle_flat_relational_condition(input:, query:, inverse_clause:)
+      # Split on first .
+      decompose_attribute = @attribute.split(".", 2)
+      # Attribute now is the back half of the initial attribute
+      @attribute = decompose_attribute[1]
+      # Relation to be handled
+      relation = decompose_attribute[0]
+
+     
+      # Get the Reflection object which defines the relationship between query and relation
+      # First iteration pull relationship using base query which responds to model.
+      instance = if query.respond_to? :model
+        query.model.reflect_on_association(relation.to_sym)
+      else
+        # When query is sent in as subquery (recursive) the query object is the model class pulled from the
+        # previous instance value
+        query.reflect_on_association(relation.to_sym)
+      end
+
+      through_reflection = instance
+
+      # TODO - make sure we're accounting for refinements
+      if @attribute == "id"
+        # We're referencing a primary key ID, so we dont need the final join table and
+        # can just reference the foreign key of the previous step in the relation chain
+        through_reflection = get_through_reflection(instance: instance, relation: decompose_attribute[0])
+        add_pending_joins_if_needed(instance: instance, reflection: through_reflection, input: input)
+        # TODO - this is not the right long-term place for this.
+        filter.needs_distinct = true
+        @attribute = get_foreign_key_from_relation(instance: instance, reflection: through_reflection)
+      else
+        puts "TODO - not referencing an ID in attribute"
+      end
+
+      unless instance
+        raise "Relationship does not exist for #{relation}."
+      end
+
+      relation_table_being_queried = through_reflection.klass.arel_table
+      relation_class = through_reflection.klass
+
+      nodes = apply_condition(input, relation_table_being_queried, inverse_clause)
+      if !is_refinement && has_any_refinements?
+        refined_node = apply_refinements(input)
+        # Count refinement will return nil because it directly modified pending relationship subquery
+        nodes = nodes.and(refined_node) if refined_node
+      end
+      nodes
+
+      # if can_use_where_in_relationship_subquery?(instance)
+      #   create_pending_wherein_subquery(input: input, relation: relation, instance: instance, query: query)
+      # else
+      #   create_pending_has_many_through_subquery(input: input, relation: relation, instance: instance, query: query)
+      # end
+    end
+
+    def get_through_reflection(instance:, relation:)
+      if instance.is_a? ActiveRecord::Reflection::ThroughReflection
+        through_reflection = instance.through_reflection
+        instance.active_record_primary_key.to_sym
+        if(through_reflection.is_a?(ActiveRecord::Reflection::BelongsToReflection))
+          through_reflection = instance.source_reflection.through_reflection
+        end
+        through_reflection
+      else
+        puts "Not a through Reflection: #{instance.inspect}"
+      end
+    end
+
+    def get_foreign_key_from_relation(instance:, reflection:)
+      child_foreign_key = instance.source_reflection.foreign_key
+      child_foreign_key
+    end
+
+    def add_pending_join(relation, join_type=:inner)
+      # If we already are tracking the relation with a left joins, don't overwrite it
+      # puts "adding a pending join for relation: #{relation} with join type: #{join_type}"
+      unless join_type == :inner && filter.pending_joins[relation] == :left
+        filter.pending_joins[relation] = join_type
+      end
+    end
+
+    def add_pending_joins_if_needed(instance:, reflection:, input:)
+      # Determine if we need to do left-joins due to the clause needing to include null values
+      if(input && LEFT_JOIN_CLAUSES.include?(input[:clause]))
+        add_pending_join(reflection.name, :left)
+      else
+        add_pending_join(reflection.name, :inner)
+      end
+    end
+  end
+end

data/app/models/refine/filter.rb

@@ -5,6 +5,8 @@ module Refine
     include TracksPendingRelationshipSubqueries
     include Stabilize
     include Internationalized
+    include Inspector
+    include FlatQueryTools
     # This validation structure sents `initial_query` as the method to validate against
     define_model_callbacks :initialize, only: [:after]
     after_initialize :valid?
@@ -211,7 +213,7 @@ module Refine
 
     def apply_condition(criterion)
       begin
-        get_condition_for_criterion(criterion)&.apply(criterion[:input], table, initial_query)
+        get_condition_for_criterion(criterion)&.apply(criterion[:input], table, initial_query, false, nil)
       rescue Refine::Conditions::Errors::ConditionClauseError => e
         e.errors.each do |error|
           errors.add(:base, error.full_message, criterion_uid: criterion[:uid])

data/app/models/refine/flat_query_tools.rb

@@ -0,0 +1,107 @@
+# This module is meant to provide an alternative to #get_query which will attempt to make the query flat with inner and left joins
+# instead of nested queries. This is useful for performance reasons when the query is complex and the database is large.
+# NOTE: This is more specialized query construction and it is up to the implementer to use the inspector tools to ensure this is only being used for supported queries
+module Refine
+  module FlatQueryTools
+    attr_accessor :pending_joins, :applied_conditions, :needs_distinct
+
+    def pending_joins
+      @pending_joins ||= {}
+    end
+
+    def applied_conditions
+      @applied_conditions ||= {}
+    end
+
+    def needs_distinct?
+      @needs_distinct ||= false
+    end
+
+    def get_flat_query
+      raise "Initial query must exist" if initial_query.nil?
+      raise "Cannot make flat query for a filter using OR conditions" if uses_or?
+      if blueprint.present?
+        construct_flat_query
+      else
+        @relation
+      end
+    end
+
+    def get_flat_query!
+      result = get_flat_query
+      raise Refine::InvalidFilterError.new(filter: self) unless errors.none?
+      result
+    end
+
+    # This iterates through each blueprint item and applies the conditions.
+    # It is meant to be idempotent hence it checks for already applied conditions
+    def construct_flat_query
+      groups = []
+      blueprint.each do |criteria_or_conjunction|
+        if criteria_or_conjunction[:type] == "conjunction"
+          if criteria_or_conjunction[:word] == "or"
+            puts "This is an OR"
+            # Reset applied conditions since we're in a new group
+            @applied_conditions = {}
+          end
+        else
+          unless condition_already_applied?(criteria_or_conjunction)
+            node = apply_flat_condition(criteria_or_conjunction)
+            @relation = @relation.where(Arel.sql(node.to_sql))
+            track_condition_applied(criteria_or_conjunction)
+          end
+        end
+      end
+      if pending_joins.present?
+        apply_pending_joins
+      end
+      if needs_distinct?
+        @relation = @relation.distinct
+      end
+      @relation
+    end
+
+    # Same as Filter.apply_condition but uses `supports_flat_queries` helpers instead of default path
+    def apply_flat_condition(criterion)
+      begin
+        get_condition_for_criterion(criterion)&.apply_flat(criterion[:input], table, initial_query, false)
+      rescue Refine::Conditions::Errors::ConditionClauseError => e
+        e.errors.each do |error|
+          errors.add(:base, error.full_message, criterion_uid: criterion[:uid])
+        end
+      end
+    end
+
+    # Called at the end of the filter's construct_flat_query. Applies joins from pending_joins hash constructed by individual conditions
+    def apply_pending_joins
+      if pending_joins.present?
+        join_count = 0
+        pending_joins.each do |relation, join_type|
+          if join_type == :left
+            @relation = @relation.left_joins(relation.to_sym).distinct
+          else
+            @relation = @relation.joins(relation.to_sym)
+          end
+          join_count += 1
+        end
+
+        if join_count > 1
+          @relation = @relation.distinct
+        end
+      end
+    end
+
+    def track_condition_applied(criterion)
+      if applied_conditions[criterion[:condition_id]].nil?
+        applied_conditions[criterion[:condition_id]] = [criterion[:input]]
+      else
+        applied_conditions[criterion[:condition_id]] << criterion[:input]
+      end
+    end
+
+    def condition_already_applied?(criterion)
+      applied_conditions[criterion[:condition_id]] && 
+        applied_conditions[criterion[:condition_id]].include?(criterion[:input])
+    end
+  end
+end

data/app/models/refine/inspector.rb

@@ -0,0 +1,41 @@
+module Refine
+  module Inspector
+    def uses_or?
+      return false if @blueprint.nil? || @blueprint.empty?
+      @blueprint.select{|c| c[:type] == "conjunction" && c[:word] == "or"}.any?
+    end
+
+    def uses_and?
+      return false if @blueprint.nil? || @blueprint.empty?
+      @blueprint.select{|c| c[:type] == "conjunction" && c[:word] == "and"}.any?
+    end
+
+    def uses_condition(condition_id, using_clauses: [])
+      return false if @blueprint.nil? || @blueprint.empty?
+      condition = @blueprint.select{|c| c[:type] == "criterion" && c[:condition_id] == condition_id}.any?
+      using_clauses = [using_clauses] unless using_clauses&.is_a?(Array)
+      if(using_clauses.any?)
+        condition = condition && @blueprint.select{|c| c[:type] == "criterion" && using_clauses.include?(c[:input][:clause]) }.any?
+      end
+      return condition
+    end
+
+    def uses_condition_at_least(condition_id, occurrences: 1)
+      return false if @blueprint.nil? || @blueprint.empty?
+      conditions = @blueprint.select{|c| c[:type] == "criterion" && c[:condition_id] == condition_id}
+      return conditions.length >= occurrences
+    end
+
+    def uses_negative_clause?
+      return false if @blueprint.nil? || @blueprint.empty?
+      negative_clauses = [
+        Refine::Conditions::Clauses::NOT_IN,
+        Refine::Conditions::Clauses::NOT_SET,
+        Refine::Conditions::Clauses::DOESNT_EQUAL,
+        Refine::Conditions::Clauses::DOESNT_CONTAIN
+      ]
+      @blueprint.select{|c| c[:type] == "criterion" && negative_clauses.include?(c[:input][:clause])}.any?
+    end
+
+  end
+end

data/lib/refine/rails/version.rb

@@ -1,5 +1,5 @@
 module Refine
   module Rails
-    VERSION = "2.13.3"
+    VERSION = "2.13.5"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: refine-rails
 version: !ruby/object:Gem::Version
-  version: 2.13.3
+  version: 2.13.5
 platform: ruby
 authors:
 - Colleen Schnettler
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-21 00:00:00.000000000 Z
+date: 2025-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -100,6 +100,7 @@ files:
 - app/models/refine/conditions/has_through_id_relationship.rb
 - app/models/refine/conditions/numeric_condition.rb
 - app/models/refine/conditions/option_condition.rb
+- app/models/refine/conditions/supports_flat_queries.rb
 - app/models/refine/conditions/text_condition.rb
 - app/models/refine/conditions/uses_attributes.rb
 - app/models/refine/conditions/with_forced_index.rb
@@ -109,11 +110,13 @@ files:
 - app/models/refine/filters/builder.rb
 - app/models/refine/filters/criterion.rb
 - app/models/refine/filters/query.rb
+- app/models/refine/flat_query_tools.rb
 - app/models/refine/inline/criteria/date_refinement.rb
 - app/models/refine/inline/criteria/input.rb
 - app/models/refine/inline/criteria/numeric_refinement.rb
 - app/models/refine/inline/criteria/option.rb
 - app/models/refine/inline/criterion.rb
+- app/models/refine/inspector.rb
 - app/models/refine/invalid_filter_error.rb
 - app/models/refine/stabilize.rb
 - app/models/refine/stabilizers/database_stabilizer.rb