refine-rails 2.13.5 → 2.13.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2336d0d23d8af77f9f090bfd8962c25a8c97c9d9f39ffce7be9fe2034d7affc
-  data.tar.gz: 191d8e607720235a354e4da42e640e0fd3ca5b29aca814c1a1a0531d75f01833
+  metadata.gz: ed9b99ff1ffc9ead0b84cead020b7abd3340b3b1ea85506ff51436469c8d38c8
+  data.tar.gz: e94ad2aec17f47227f2c590632266fda4d567fe757ed4eb7a139bd8e45d70c1a
 SHA512:
-  metadata.gz: f0fd3bc2e744d3de0fcd7092bd87d5969d472c886eacc7d007ff711bae937449588b48cb7ed5e56f590756f6d0f214fee2b690bdc9ead7676453b7e64e8862e5
-  data.tar.gz: 692abd2df6a29e0687f4aa4ad985ebf88371b5a72b7b45432d42e4837cc423272a98c15dc2a139bdebe7ac0a0d24a53b293b8f7f25e43081da1fc13013c555fd
+  metadata.gz: 387b1428a0ac1d05da2291578c14b08b208499243c3f6c546afc437f62a932c343d675e1e0189337a752ed52cd3beef9e3f847f638ac238f08465e367629bad5
+  data.tar.gz: 436423c40e435a5c35290e5cc1572fc88f6ff4a57ba2e42b2370140811a52bcbf20ca8e1f4a046509292a3f9454de19b992baad4faf2792555535abc1c6c8d64

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

@@ -16,7 +16,7 @@ module Refine::Conditions
     include SupportsFlatQueries
 
     attr_reader :ensurances, :before_validations, :clause, :filter
-    attr_accessor :display, :id, :is_refinement, :attribute
+    attr_accessor :display, :id, :is_refinement, :attribute, :is_flat_query
 
     I18N_PREFIX = "refine.refine_blueprints.condition."
 

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

@@ -15,8 +15,10 @@ module Refine::Conditions
     # @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] 
+    # This is mostly a copy of the `apply` method from the Condition module, but avoids recursion and the pending_subquery system
     def apply_flat(input, table, initial_query, inverse_clause=false)
       table ||= filter.table
+      @is_flat_query = true
       # Ensurance validations are checking the developer configured correctly
       run_ensurance_validations
       # Allow developer to modify user input
@@ -27,6 +29,7 @@ module Refine::Conditions
       # TODO Determine right place to set the clause
       validate_user_input(input)
       if input.dig(:filter_refinement).present?
+        # TODO - Handle refinements. Currently not working for flat queries because its dependent on the pending_subquery system
 
         filter_condition = call_proc_if_callable(@filter_refinement_proc)
         # Set the filter on the filter_condition to be the current_condition's filter
@@ -39,7 +42,7 @@ module Refine::Conditions
       end
 
       if is_relationship_attribute?
-        return handle_flat_relational_condition(input: input, query: initial_query, inverse_clause: inverse_clause)
+        return handle_flat_relational_condition(input: input, table: table, query: initial_query, inverse_clause: inverse_clause)
       end
       # Not a relationship attribute, apply condition normally
       nodes = apply_condition(input, table, inverse_clause)
@@ -51,7 +54,7 @@ module Refine::Conditions
       nodes
     end
 
-    def handle_flat_relational_condition(input:, query:, inverse_clause:)
+    def handle_flat_relational_condition(input:, table:, query:, inverse_clause:)
       # Split on first .
       decompose_attribute = @attribute.split(".", 2)
       # Attribute now is the back half of the initial attribute
@@ -71,20 +74,27 @@ module Refine::Conditions
       end
 
       through_reflection = instance
+      forced_id = false
 
       # 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])
+        unless condition_uses_different_database?(through_reflection.klass, query.model)
+          forced_id = true
+          @attribute = get_foreign_key_from_relation(instance: instance, reflection: through_reflection)
+        end
+      end
+
+      unless condition_uses_different_database?(through_reflection.klass, query.model)
         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
+      # TODO - this is not the right long-term place for this.
+      apply_flat_relational_condition(instance: instance, relation: relation, through_reflection: through_reflection, input: input, table: table, query: query, inverse_clause: inverse_clause, forced_id: forced_id)
+    end
 
+    def apply_flat_relational_condition(instance:, relation:, through_reflection:, input:, table:, query:, inverse_clause:, forced_id: false)
       unless instance
         raise "Relationship does not exist for #{relation}."
       end
@@ -92,19 +102,40 @@ module Refine::Conditions
       relation_table_being_queried = through_reflection.klass.arel_table
       relation_class = through_reflection.klass
 
-      nodes = apply_condition(input, relation_table_being_queried, inverse_clause)
+      instance = get_reflection_object(query, relation) if forced_id
+
+      key_1 = key_1(instance)
+      key_2 = key_2(instance)
+      if condition_uses_different_database?(relation_class, query.model)
+        nodes = handle_flat_cross_database_condition(input: input, table: table, relation_class: relation_class, relation_table_being_queried: relation_table_being_queried, inverse_clause: inverse_clause, key_1: key_1, key_2: key_2)  
+      else
+        if forced_id
+          nodes = apply(input, relation_table_being_queried, query, inverse_clause, key_2)
+        else
+          nodes = apply(input, relation_table_being_queried, query, inverse_clause)
+        end
+      end
+
       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
 
-      # 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
+    # When we need to go to another DB for the relation. We need to do a separate query to get the IDS of
+    # the records matching the condition that will then be passed into the primary query.
+    def handle_flat_cross_database_condition(input:, table:, relation_class:, relation_table_being_queried:, inverse_clause:, key_1:, key_2:)
+      relational_query = relation_class.select(key_2).arel
+      node = apply(input, relation_table_being_queried, relation_class, inverse_clause)
+      relational_query = relational_query.where(node)
+      array_of_ids = relation_class.connection.exec_query(relational_query.to_sql).rows.flatten
+      if array_of_ids.length == 1
+        nodes = table[:"#{key_1}"].eq(array_of_ids.first)
+      else
+        nodes = table[:"#{key_1}"].in(array_of_ids)
+      end
     end
 
     def get_through_reflection(instance:, relation:)
@@ -129,6 +160,7 @@ module Refine::Conditions
       # 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.needs_distinct = true
         filter.pending_joins[relation] = join_type
       end
     end
@@ -141,5 +173,10 @@ module Refine::Conditions
         add_pending_join(reflection.name, :inner)
       end
     end
+
+    def condition_uses_different_database?(current_model, parent_model)
+      # Are the queries on different databases?
+      parent_model.connection_db_config.configuration_hash != current_model.connection_db_config.configuration_hash
+    end
   end
 end

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

@@ -21,13 +21,7 @@ module Refine::Conditions
 
       # 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
+      instance = get_reflection_object(query, relation)
 
       unless instance
         raise "Relationship does not exist for #{relation}."
@@ -69,6 +63,16 @@ module Refine::Conditions
       end
     end
 
+    def get_reflection_object(query, relation)
+      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
+    end
+
     def create_pending_wherein_subquery(input:, relation:, instance:, query:)
       # This method builds out the linking keys between the provided query model and the relation
       # and saves it to pending relationship subqueries

data/app/models/refine/inspector.rb

@@ -37,5 +37,12 @@ module Refine
       @blueprint.select{|c| c[:type] == "criterion" && negative_clauses.include?(c[:input][:clause])}.any?
     end
 
+    def has_duplicate_conditions?
+      return false if @blueprint.nil? || @blueprint.empty?
+      conditions = @blueprint.select{|c| c[:type] == "criterion"}
+      condition_ids = conditions.map{|c| c[:condition_id]}
+      condition_ids.length != condition_ids.uniq.length
+    end
+
   end
 end

data/app/models/refine/tracks_pending_relationship_subqueries.rb

@@ -116,6 +116,7 @@ module Refine
       subset.each do |relation, subquery|
         # relation = table
         # subquery.keys = [:instance, :query, :key, :secondary] possibly (:children)
+
         if subquery.dig(:children).present?
           # Send in the values at children as the subset hash and remove from existing subquery
           child_nodes = subquery.delete(:children)

data/app/views/refine/advanced_inline/criteria/new.turbo_stream.erb

@@ -1,6 +1,5 @@
 <% form_id = dom_id(@criterion, :form) %>
 
-<% puts "In New Turbo Stream" %>
 <%= turbo_stream.update dom_id(@criterion) do %>
   <%= render "refine/advanced_inline/filters/popup",
     frame_id: dom_id(@criterion), is_open: true do

data/lib/refine/rails/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: refine-rails
 version: !ruby/object:Gem::Version
-  version: 2.13.5
+  version: 2.13.7
 platform: ruby
 authors:
 - Colleen Schnettler
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-17 00:00:00.000000000 Z
+date: 2025-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails