sunstone 7.2.0 → 8.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d280487f58777eebd36b07eb69f9492b77370ea3def7b05321bb2d4fd8e55626
-  data.tar.gz: a34f616483aca20b1207f12538e08fafb19b16ac01db6c19977b902cd1cd1537
+  metadata.gz: 9e9d652c2cfc067ca7a6921350122369134b44a200a262d93da2f9df98c90d5c
+  data.tar.gz: b13d474440401eb82768422ece2047e9b0e1f1cf470264e4a2d786dcdf5c13eb
 SHA512:
-  metadata.gz: 0211de6c05fded268d04e00af2e0f16e9f4ee0650307288ea890c343e1b20f0a2fcf924631e2c0c3e72b602af7e964c8663a6df51f22cce9bd85798b26d12604
-  data.tar.gz: 62e9b986925a43ca27c172499bca956ea20e6b8ca237d94dbcb1b07f52772ad1ffc9d5a0fe68d9ef6560e9a3df5ccc7bc27a8a78b56aad4fcccc44604f2a9060
+  metadata.gz: 5da172f2cfae9b86d5eaa2bdf37bce3b99d385171c505c4047116354c45a7231860ac7dc21dd4e0375ed72c5cdfa2e8bd93a1b289d23289ef002f02e6d547581
+  data.tar.gz: 2a7b1fb0a8061847a605499ec8d7f31aa3364802a7bce7fc40bb269959769db4d4e7fe1cee40df47c3071301e16c8d20d40b898756a3f3037224b84f81a7a590

data/ext/active_record/associations/collection_association.rb

@@ -1,73 +1,53 @@
 # The last ref that this code was synced with Rails
 # ref: 9269f634d471ad6ca46752421eabd3e1c26220b5
-module ActiveRecord
-  module Associations
-    class CollectionAssociation
-
-      def replace(other_array)
-        other_array.each { |val| raise_on_type_mismatch!(val) }
-        original_target = skip_strict_loading { load_target }.dup
-
-        if owner.new_record?
-          replace_records(other_array, original_target)
-        elsif owner.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && owner.instance_variable_defined?(:@sunstone_updating) && owner.instance_variable_get(:@sunstone_updating)
-          replace_common_records_in_memory(other_array, original_target)
-
-          # Remove from target
-          records_for_removal = (original_target - other_array)
-          if !records_for_removal.empty?
-            self.instance_variable_set(:@sunstone_changed, true)
-            records_for_removal.each { |record| callback(:before_remove, record) }
-            records_for_removal.each { |record| target.delete(record) }
-            records_for_removal.each { |record| callback(:after_remove, record) }
-          end
-
-          # Add to target
-          records_for_addition = (other_array - original_target)
-          if !records_for_addition.empty?
-            self.instance_variable_set(:@sunstone_changed, true)
-            (other_array - original_target).each do |record|
-              add_to_target(record)
-            end
-          end
-
-          other_array
-        else
-          replace_common_records_in_memory(other_array, original_target)
-          if other_array != original_target
-            transaction { replace_records(other_array, original_target) }
-          else
-            other_array
-          end
-        end
+class ActiveRecord::Associations::CollectionAssociation
+
+  def replace(other_array)
+    other_array.each { |val| raise_on_type_mismatch!(val) }
+    original_target = skip_strict_loading { load_target }.dup
+
+    if owner.new_record?
+      replace_records(other_array, original_target)
+    elsif owner.sunstone? && owner.instance_variable_defined?(:@sunstone_updating) && owner.instance_variable_get(:@sunstone_updating)
+      replace_common_records_in_memory(other_array, original_target)
+
+      # Remove from target
+      records_for_removal = (original_target - other_array)
+      if !records_for_removal.empty?
+        self.instance_variable_set(:@sunstone_changed, true)
+        records_for_removal.each { |record| callback(:before_remove, record) }
+        records_for_removal.each { |record| target.delete(record) }
+        records_for_removal.each { |record| callback(:after_remove, record) }
       end
 
-      def insert_record(record, validate = true, raise = false, &block)
-        if record.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && owner.instance_variable_defined?(:@sunstone_updating) && owner.instance_variable_get(:@sunstone_updating)
-          true
-        elsif raise
-          record.save!(validate: validate, &block)
-        else
-          record.save(validate: validate, &block)
+      # Add to target
+      records_for_addition = (other_array - original_target)
+      if !records_for_addition.empty?
+        self.instance_variable_set(:@sunstone_changed, true)
+        (other_array - original_target).each do |record|
+          add_to_target(record)
         end
       end
 
-    end
-
-    class HasManyThroughAssociation
-
-      private
-      def save_through_record(record)
-        return if record.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
-        association = build_through_record(record)
-        if association.changed?
-          association.save!
-        end
-      ensure
-        @through_records.delete(record.object_id)
+      other_array
+    else
+      replace_common_records_in_memory(other_array, original_target)
+      if other_array != original_target
+        transaction { replace_records(other_array, original_target) }
+      else
+        other_array
       end
-
     end
+  end
 
+  def insert_record(record, validate = true, raise = false, &block)
+    if record.sunstone? && owner.instance_variable_defined?(:@sunstone_updating) && owner.instance_variable_get(:@sunstone_updating)
+      true
+    elsif raise
+      record.save!(validate: validate, &block)
+    else
+      record.save(validate: validate, &block)
+    end
   end
-end
+
+end

data/ext/active_record/associations/has_many_through_association.rb

@@ -0,0 +1,16 @@
+class ActiveRecord::Associations::CollectionAssociation::HasManyThroughAssociation
+
+  private
+
+  def save_through_record(record)
+    return if record.sunstone?
+    
+    association = build_through_record(record)
+    if association.changed?
+      association.save!
+    end
+  ensure
+    @through_records.delete(record.object_id)
+  end
+
+end

data/ext/active_record/associations.rb

@@ -26,7 +26,7 @@ module ActiveRecord
         include Module.new {
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def destroy_associations
-              if !self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+              if !self.sunstone?
                 association(:#{middle_reflection.name}).delete_all(:delete_all)
                 association(:#{name}).reset
               end

data/ext/active_record/attribute_methods.rb

@@ -11,7 +11,7 @@ module ActiveRecord
     def attributes_with_values(attribute_names)
       attrs = attribute_names.index_with { |name| @attributes[name] }
 
-      if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+      if self.sunstone?
         self.class.reflect_on_all_associations.each do |reflection|
           if reflection.belongs_to?
             if association(reflection.name).loaded? && association(reflection.name).target == Thread.current[:sunstone_updating_model]

data/ext/active_record/base.rb

@@ -0,0 +1,11 @@
+class ActiveRecord::Base
+  
+  def self.sunstone?
+    connection_pool.db_config.adapter_class == ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter
+  end
+  
+  def sunstone?
+    self.class.sunstone?
+  end
+  
+end

data/ext/active_record/callbacks.rb

@@ -6,7 +6,7 @@ module ActiveRecord
     private
 
       def create_or_update(**) #:nodoc:
-        if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+        if self.sunstone?
           @_already_called ||= {}
           self.class.reflect_on_all_associations.each do |r|
             @_already_called[:"autosave_associated_records_for_#{r.name}"] = true

data/ext/active_record/locking/optimistic.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Locking
+    module Optimistic
+      
+      private
+
+        def _update_row(attribute_values, attempted_action = "update")
+          return super unless locking_enabled?
+
+          begin
+            locking_column = self.class.locking_column
+            lock_attribute_was = @attributes[locking_column]
+
+            update_constraints = _query_constraints_hash
+
+            self[locking_column] += 1
+
+            attribute_values = if attribute_values.is_a?(Hash)
+              attribute_values.merge(attributes_with_values([locking_column]))
+            else
+              attribute_values = attribute_values.dup if attribute_values.frozen?
+              attribute_values << locking_column
+              attributes_with_values(attribute_values)
+            end
+
+            # Suntone returns the row(s) not a int of afftecd_rows
+            result = self.class._update_record(
+              attribute_values,
+              update_constraints
+            )
+            affected_rows = sunstone? ? result.rows.size : result
+
+            if affected_rows != 1
+              raise ActiveRecord::StaleObjectError.new(self, attempted_action)
+            end
+
+            affected_rows
+
+          # If something went wrong, revert the locking_column value.
+          rescue Exception
+            @attributes[locking_column] = lock_attribute_was
+            raise
+          end
+        end
+
+    end
+  end
+end

data/ext/active_record/persistence.rb

@@ -59,7 +59,7 @@ module ActiveRecord
 
       result = new_record? ? _create_record(&block) : _update_record(&block)
 
-      if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && result != 0
+      if self.sunstone? && result != 0 && !result[0].nil?
         row_hash = result[0]
 
         seen = Hash.new { |h, parent_klass|
@@ -70,7 +70,7 @@ module ActiveRecord
 
         model_cache = Hash.new { |h,klass| h[klass] = {} }
         parents = model_cache[self.class.base_class]
-        
+
         row_hash.each do |key, value|
           if self.class.column_names.include?(key.to_s)
             _write_attribute(key, value)
@@ -105,7 +105,7 @@ module ActiveRecord
       attribute_names = attributes_for_create(attribute_names)
       attribute_values = attributes_with_values(attribute_names)
       returning_values = nil
-      
+
       self.class.with_connection do |connection|
         returning_columns = self.class._returning_columns_for_insert(connection)
 
@@ -115,25 +115,41 @@ module ActiveRecord
           returning_columns
         )
 
-        if !self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+        if !self.sunstone?
           returning_columns.zip(returning_values).each do |column, value|
-            _write_attribute(column, value) if !_read_attribute(column)
+            _write_attribute(column, type_for_attribute(column).deserialize(value)) if !_read_attribute(column)
           end if returning_values
         end
       end
 
       @new_record = false
       @previously_new_record = true
-      
+
       yield(self) if block_given?
-      
-      if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+
+      if self.sunstone?
         returning_values
       else
         id
       end
     end
 
+    def _touch_row(attribute_names, time)
+      time ||= current_time_from_proper_timezone
+
+      attribute_names.each do |attr_name|
+        _write_attribute(attr_name, time)
+      end
+
+      _update_row(attributes_with_values(attribute_names), "touch")
+    end
+
+    # Sunstone passes the values, not just the names. This is because if a
+    # sub resource has changed it'll send the whole shabang
+    def _update_row(attribute_values, attempted_action = "update")
+      self.class._update_record(attribute_values, _query_constraints_hash)
+    end
+
     def _update_record(attribute_names = self.attribute_names)
       attribute_names = attributes_for_update(attribute_names)
       attribute_values = attributes_with_values(attribute_names)
@@ -142,8 +158,10 @@ module ActiveRecord
         affected_rows = 0
         @_trigger_update_callback = true
       else
-        affected_rows = self.class._update_record(attribute_values, _query_constraints_hash)
-        @_trigger_update_callback = affected_rows == 1
+        affected_rows = _update_row(attribute_values)
+
+        # Suntone returns the row(s) not a int of afftecd_rows
+        @_trigger_update_callback = (sunstone? ? affected_rows.rows.size : affected_rows) == 1
       end
 
       @previously_new_record = false
@@ -179,7 +197,7 @@ module ActiveRecord
 
       end
     end
-    
+
     #!!!! TODO: I am duplicated from finder_methods.....
     def construct_association(parent, reflection, attributes, seen, model_cache)
       return if attributes.nil?
@@ -231,6 +249,6 @@ module ActiveRecord
       other.set_inverse_instance(model)
       model
     end
-    
+
   end
 end

data/ext/active_record/relation/calculations.rb

@@ -25,20 +25,20 @@ module ActiveRecord
       if has_include?(column_names.first)
         relation = apply_join_dependency
         relation.pluck(*column_names)
-      elsif klass.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+      elsif model.sunstone?
         load
-        return records.pluck(*column_names.map{|n| n.to_s.sub(/^#{klass.table_name}\./, "")})
+        return records.pluck(*column_names.map{|n| n.to_s.sub(/^#{model.table_name}\./, "")})
       else
-        klass.disallow_raw_sql!(flattened_args(column_names))
-        columns = arel_columns(column_names)
+        model.disallow_raw_sql!(flattened_args(column_names))
         relation = spawn
+        columns = relation.arel_columns(column_names)
         relation.select_values = columns
         result = skip_query_cache_if_necessary do
           if where_clause.contradiction?
             ActiveRecord::Result.empty(async: @async)
           else
-            klass.with_connection do |c|
-              c.select_all(relation.arel, "#{klass.name} Pluck", async: @async)
+            model.with_connection do |c|
+              c.select_all(relation.arel, "#{model.name} Pluck", async: @async)
             end
           end
         end
@@ -48,5 +48,22 @@ module ActiveRecord
       end
     end
 
+    private
+
+      # Prior to Rails 8 we didn't need this method becuase it would
+      # return the first value if there was just one - so we'll just
+      # do the same as prevously because it doesn't have to be joined
+      def select_for_count
+        if select_values.empty?
+          :all
+        elsif model.sunstone?
+          select_values.one? ? select_values.first : select_values
+        else
+          with_connection do |conn|
+            arel_columns(select_values).map { |column| conn.visitor.compile(column) }.join(", ")
+          end
+        end
+      end
+    
   end
 end

data/ext/active_record/relation/finder_methods.rb

@@ -0,0 +1,162 @@
+# The last ref that this code was synced with Rails
+# ref: 9269f634d471ad6ca46752421eabd3e1c26220b5
+module ActiveRecord::FinderMethods
+  class SunstoneJoinDependency
+    def initialize(klass)
+      @klass = klass
+    end
+    
+    def reflections
+      []
+    end
+    
+    def apply_column_aliases(relation)
+      relation
+    end
+    
+    def instantiate(result_set, strict_loading_value, &block)
+      seen = Hash.new { |i, object_id|
+        i[object_id] = Hash.new { |j, child_class|
+          j[child_class] = {}
+        }
+      }
+
+      model_cache = Hash.new { |h, klass| h[klass] = {} }
+      parents = model_cache[@klass]
+
+      message_bus = ActiveSupport::Notifications.instrumenter
+
+      payload = {
+        record_count: result_set.length,
+        class_name: @klass.name
+      }
+
+      message_bus.instrument("instantiation.active_record", payload) do
+        result_set.each { |row_hash|
+          parent_key = @klass.primary_key ? row_hash[@klass.primary_key] : row_hash
+          parent = parents[parent_key] ||= @klass.instantiate(row_hash.select{|k,v| @klass.column_names.include?(k.to_s) }, &block)
+          construct(parent, row_hash.select{|k,v| !@klass.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
+        }
+      end
+
+      parents.values
+    end
+
+    def construct(parent, relations, seen, model_cache, strict_loading_value)
+      relations.each do |key, attributes|
+        reflection = parent.class.reflect_on_association(key)
+        next unless reflection
+
+        if reflection.collection?
+          other = parent.association(reflection.name)
+          other.loaded!
+        else
+          if parent.association_cached?(reflection.name)
+            model = parent.association(reflection.name).target
+            construct(model, attributes.select{|k,v| !model.class.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
+          end
+        end
+
+        if !reflection.collection?
+          construct_association(parent, reflection, attributes, seen, model_cache, strict_loading_value)
+        else
+          attributes.each do |row|
+            construct_association(parent, reflection, row, seen, model_cache, strict_loading_value)
+          end
+        end
+
+      end
+    end
+
+    def construct_association(parent, reflection, attributes, seen, model_cache, strict_loading_value)
+      return if attributes.nil?
+
+      klass = if reflection.polymorphic?
+        parent.send(reflection.foreign_type).constantize.base_class
+      else
+        reflection.klass
+      end
+      id = attributes[klass.primary_key]
+      model = seen[parent.object_id][klass][id]
+
+      if model
+        construct(model, attributes.select{|k,v| !klass.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
+
+        other = parent.association(reflection.name)
+
+        if reflection.collection?
+          other.target.push(model)
+        else
+          other.target = model
+        end
+
+        other.set_inverse_instance(model)
+      else
+        model = construct_model(parent, reflection, id, attributes.select{|k,v| klass.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
+        seen[parent.object_id][model.class.base_class][id] = model
+        construct(model, attributes.select{|k,v| !klass.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
+      end
+    end
+
+
+    def construct_model(record, reflection, id, attributes, seen, model_cache, strict_loading_value)
+      klass = if reflection.polymorphic?
+        record.send(reflection.foreign_type).constantize
+      else
+        reflection.klass
+      end
+
+      model = model_cache[klass][id] ||= klass.instantiate(attributes)
+      other = record.association(reflection.name)
+
+      if reflection.collection?
+        other.target.push(model)
+      else
+        other.target = model
+      end
+
+      other.set_inverse_instance(model)
+      model
+    end
+
+  end
+
+  private
+
+    def apply_join_dependency(eager_loading: group_values.empty?)
+      if model.sunstone?
+        join_dependency = SunstoneJoinDependency.new(base_class)
+        relation = except(:includes, :eager_load, :preload)
+        relation.arel.eager_load = Arel::Nodes::EagerLoad.new(eager_load_values)
+      else
+        join_dependency = construct_join_dependency(
+          eager_load_values | includes_values, Arel::Nodes::OuterJoin
+        )
+        relation = except(:includes, :eager_load, :preload).joins!(join_dependency)
+
+        if eager_loading && has_limit_or_offset? && !(
+            using_limitable_reflections?(join_dependency.reflections) &&
+            using_limitable_reflections?(
+              construct_join_dependency(
+                select_association_list(joins_values).concat(
+                  select_association_list(left_outer_joins_values)
+                ), nil
+              ).reflections
+            )
+          )
+          relation = skip_query_cache_if_necessary do
+            model.with_connection do |c|
+              c.distinct_relation_for_primary_key(relation)
+            end
+          end
+        end
+      end
+
+      if block_given?
+        yield relation, join_dependency
+      else
+        relation
+      end
+    end
+  
+end

data/ext/active_record/relation/predicate_builder.rb

@@ -0,0 +1,78 @@
+class ActiveRecord::PredicateBuilder # :nodoc:
+
+  def expand_from_hash(attributes, &block)
+    return ["1=0"] if attributes.empty?
+
+    attributes.flat_map do |key, value|
+      if key.is_a?(Array) && key.size == 1
+        key = key.first
+        value = value.flatten
+      end
+      
+      if key.is_a?(Array)
+        queries = Array(value).map do |ids_set|
+          raise ArgumentError, "Expected corresponding value for #{key} to be an Array" unless ids_set.is_a?(Array)
+          expand_from_hash(key.zip(ids_set).to_h)
+        end
+        grouping_queries(queries)
+      elsif value.is_a?(Hash) && !table.has_column?(key)
+        ka = table.associated_table(key, &block)
+          .predicate_builder.expand_from_hash(value.stringify_keys)
+
+        if self.table.instance_variable_get(:@klass).sunstone?
+          ka.each { |k|
+            if k.left.is_a?(Arel::Attributes::Attribute) || k.left.is_a?(Arel::Attributes::Relation)
+              k.left = Arel::Attributes::Relation.new(k.left, key)
+            end
+          }
+        end
+        ka
+      elsif table.associated_with?(key)
+        # Find the foreign key when using queries such as:
+        # Post.where(author: author)
+        #
+        # For polymorphic relationships, find the foreign key and type:
+        # PriceEstimate.where(estimate_of: treasure)
+        associated_table = table.associated_table(key)
+        if associated_table.polymorphic_association?
+          value = [value] unless value.is_a?(Array)
+          klass = PolymorphicArrayValue
+        elsif associated_table.through_association?
+          next associated_table.predicate_builder.expand_from_hash(
+            associated_table.primary_key => value
+          )
+        end
+
+        klass ||= AssociationQueryValue
+        queries = klass.new(associated_table, value).queries.map! do |query|
+          # If the query produced is identical to attributes don't go any deeper.
+          # Prevents stack level too deep errors when association and foreign_key are identical.
+          query == attributes ? self[key, value] : expand_from_hash(query)
+        end
+
+        grouping_queries(queries)
+      elsif table.aggregated_with?(key)
+        mapping = table.reflect_on_aggregation(key).mapping
+        values = value.nil? ? [nil] : Array.wrap(value)
+        if mapping.length == 1 || values.empty?
+          column_name, aggr_attr = mapping.first
+          values = values.map do |object|
+            object.respond_to?(aggr_attr) ? object.public_send(aggr_attr) : object
+          end
+          self[column_name, values]
+        else
+          queries = values.map do |object|
+            mapping.map do |field_attr, aggregate_attr|
+              self[field_attr, object.try!(aggregate_attr)]
+            end
+          end
+
+          grouping_queries(queries)
+        end
+      else
+        self[key, value]
+      end
+    end
+  end
+
+end

data/ext/active_record/relation/query_methods.rb

@@ -4,7 +4,7 @@ module ActiveRecord
 
     def assert_modifiable!
       raise UnmodifiableRelation if @loaded
-      raise UnmodifiableRelation if @arel && !klass.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+      raise UnmodifiableRelation if @arel && !model.sunstone?
     end
 
   end

data/ext/active_record/transactions.rb

@@ -38,7 +38,7 @@ module ActiveRecord
         status = nil
         # connection = self.class.connection
 
-        if connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && instance_variable_defined?(:@sunstone_updating) && @sunstone_updating
+        if sunstone? && instance_variable_defined?(:@sunstone_updating) && @sunstone_updating
           status = yield
         else
           ensure_finalize = !connection.transaction_open?

data/lib/active_record/connection_adapters/sunstone/database_statements.rb

@@ -30,6 +30,7 @@ module ActiveRecord
         end
         
         def to_sar_and_binds(arel_or_sar_string, binds = [], preparable = nil, allow_retry = false)
+          # Arel::TreeManager -> Arel::Node
           if arel_or_sar_string.respond_to?(:ast)
             arel_or_sar_string = arel_or_sar_string.ast
           end
@@ -40,10 +41,13 @@ module ActiveRecord
                 "The values must be stored on the AST directly"
             end
             
-            sar = visitor.accept(arel_or_sar_string, collector)
+            col = collector()
+            col.retryable = true
+            sar = visitor.compile(arel_or_sar_string, col)
             [sar.freeze, sar.binds, false, allow_retry]
           else
-            [arel_or_sar_string.dup.freeze, binds, false, allow_retry]
+            arel_or_sar_string = arel_or_sar_string.dup.freeze unless arel_or_sar_string.frozen?
+            [arel_or_sar_string, binds, false, allow_retry]
           end
         end
         
@@ -114,9 +118,14 @@ module ActiveRecord
           sar, binds = sar_for_insert(arel, pk, binds, returning)
           internal_exec_query(sar, name, binds)
         end
+        
+        def exec_delete(arel, name = nil, binds = [])
+          x = internal_execute(arel, name, binds)
+          x.nil? ? 1 : x
+        end
 
-        def internal_exec_query(arel, name = 'SAR', binds = [], prepare: false, async: false, allow_retry: false)
-          sars = []
+        # Lowest level way to execute a query. Doesn't check for illegal writes, doesn't annotate queries, yields a native result object.
+        def raw_execute(arel, name = nil, binds = [], prepare: false, async: false, allow_retry: false, materialize_transactions: true, batch: false)
           multiple_requests = arel.is_a?(Arel::Collectors::Sunstone)
           type_casted_binds = binds#type_casted_binds(binds)
           
@@ -137,50 +146,73 @@ module ActiveRecord
               multiple_requests = true
             end
           end
-
-          send_request = lambda { |req_arel|
+          
+          send_request = lambda { |conn, req_arel, batch|
             sar = to_sar(req_arel, type_casted_binds)
-            sars.push(sar)
             log_mess = sar.path.split('?', 2)
-            log("#{sar.method} #{log_mess[0]} #{(log_mess[1] && !log_mess[1].empty?) ? MessagePack.unpack(CGI.unescape(log_mess[1])) : '' }", name) do
-              with_raw_connection do |conn|
-                response = conn.send_request(sar)
-                if response.is_a?(Net::HTTPNoContent)
-                  nil
+            log("#{sar.method} #{log_mess[0]} #{(log_mess[1] && !log_mess[1].empty?) ? MessagePack.unpack(CGI.unescape(log_mess[1])) : '' }", name) do |notification_payload|
+              result = perform_query(conn, sar, prepare:, notification_payload:, batch: batch)
+              result.instance_variable_set(:@sunstone_calculation, true) if result && sar.instance_variable_get(:@sunstone_calculation)
+              result
+            end
+          }
+          
+          result = with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
+            if multiple_requests
+              binds.delete_at(limit_bind_index) if limit_bind_index
+
+              limit, offset, results = allowed_limit, 0, nil
+              last_affected_rows = 0
+              while requested_limit ? offset < requested_limit : true
+                split_arel = arel.dup
+                split_arel.limit = limit
+                split_arel.offset = offset
+                request_results = send_request.call(conn, split_arel, true)
+                last_affected_rows += @last_affected_rows
+                if results
+                  results.push(*request_results)
                 else
-                  JSON.parse(response.body)
+                  results = request_results
                 end
+                break if request_results.size < limit
+                offset = offset + limit
               end
+              @last_affected_rows = last_affected_rows
+              results
+            else
+              send_request.call(conn, arel, true)
             end
-          }
-
-          result = if multiple_requests
-            binds.delete_at(limit_bind_index) if limit_bind_index
-
-            limit, offset, results = allowed_limit, 0, []
-            while requested_limit ? offset < requested_limit : true
-              split_arel = arel.dup
-              split_arel.limit = limit
-              split_arel.offset = offset
-              request_results = send_request.call(split_arel)
-              results = results + request_results
-              break if request_results.size < limit
-              offset = offset + limit
-            end
-            results
-          else
-            send_request.call(arel)
           end
-          
-          if sars[0].instance_variable_defined?(:@sunstone_calculation) && sars[0].instance_variable_get(:@sunstone_calculation)
+
+          result
+        end
+
+        def perform_query(raw_connection, sar, prepare:, notification_payload:, batch: false)
+          response = raw_connection.send_request(sar)
+          result = response.is_a?(Net::HTTPNoContent) ? nil : JSON.parse(response.body)
+
+          verified!
+          # handle_warnings(result)
+          @last_affected_rows = response['Affected-Rows'] || result&.count || 0
+          notification_payload[:row_count] = @last_affected_rows
+          result
+        end
+        
+        # Receive a native adapter result object and returns an ActiveRecord::Result object.
+        def cast_result(raw_result)
+          if raw_result.instance_variable_defined?(:@sunstone_calculation) && raw_result.instance_variable_get(:@sunstone_calculation)
             # this is a count, min, max.... yea i know..
-            ActiveRecord::Result.new(['all'], [result], {:all => @type_map.lookup('integer', {})})
-          elsif result.is_a?(Array)
-            ActiveRecord::Result.new(result[0] ? result[0].keys : [], result.map{|r| r.values})
+            ActiveRecord::Result.new(['all'], [raw_result], {:all => @type_map.lookup('integer', {})})
+          elsif raw_result.is_a?(Array)
+            ActiveRecord::Result.new(raw_result[0] ? raw_result[0].keys : [], raw_result.map{|r| r.values})
           else
-            ActiveRecord::Result.new(result.keys, [result.values])
+            ActiveRecord::Result.new(raw_result.keys, [raw_result.values])
           end
         end
+
+        def affected_rows(raw_result)
+          @last_affected_rows
+        end
         
         def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [], returning: nil)
           sar, binds = to_sar_and_binds(arel, binds)
@@ -190,13 +222,18 @@ module ActiveRecord
 
           id_value || last_inserted_id(value)
         end
-        
+        alias create insert
+
+        # Executes the update statement and returns the number of rows affected.
         def update(arel, name = nil, binds = [])
-          exec_update(arel, name, binds)
+          sar, binds = to_sar_and_binds(arel, binds)
+          internal_exec_query(sar, name, binds)
         end
         
+        # Executes the delete statement and returns the number of rows affected.
         def delete(arel, name = nil, binds = [])
-          exec_delete(arel, name, binds)
+          sql, binds = to_sar_and_binds(arel, binds)
+          exec_delete(sql, name, binds)
         end
 
         def last_inserted_id(result)

data/lib/active_record/connection_adapters/sunstone/schema_statements.rb

@@ -39,6 +39,8 @@ module ActiveRecord
         #  - format_type includes the column size constraint, e.g. varchar(50)
         #  - ::regclass is a function that gives the id for a table name
         def column_definitions(table_name) # :nodoc:
+          puts table_name.inspect
+          puts definition(table_name).inspect
           # TODO: settle on schema, I think we've switched to attributes, so
           # columns can be removed soon?
           definition(table_name)['attributes'] || definition(table_name)['columns']

data/lib/active_record/connection_adapters/sunstone_adapter.rb

@@ -92,18 +92,30 @@ module ActiveRecord
       end
 
       def active?
-        @raw_connection&.active?
+        @lock.synchronize do
+          @raw_connection&.active?
+        end
       end
       
-      def reconnect
-        super
-        @raw_connection&.reconnect!
+      # Connects to a StandardAPI server and sets up the adapter depending
+      # on the connected server's characteristics.
+      def connect
+        @raw_connection = self.class.new_client(@connection_parameters)
       end
 
+      def reconnect
+        @lock.synchronize do
+          @raw_connection&.reconnect!
+          connect unless @raw_connection
+        end
+      end
+      
       def disconnect!
-        super
-        @raw_connection&.disconnect!
-        @raw_connection = nil
+        @lock.synchronize do
+          super
+          @raw_connection&.disconnect!
+          @raw_connection = nil
+        end
       end
 
       def discard! # :nodoc:
@@ -111,12 +123,6 @@ module ActiveRecord
         @raw_connection = nil
       end
 
-      # Executes the delete statement and returns the number of rows affected.
-      def delete(arel, name = nil, binds = [])
-        r = exec_delete(arel, name, binds)
-        r.rows.first.to_i
-      end
-
       def native_database_types #:nodoc:
         NATIVE_DATABASE_TYPES
       end
@@ -189,17 +195,6 @@ module ActiveRecord
       end
       alias create insert
 
-      # Connects to a StandardAPI server and sets up the adapter depending
-      # on the connected server's characteristics.
-      def connect
-        @raw_connection = self.class.new_client(@connection_parameters)
-      end
-
-      def reconnect
-        @raw_connection&.reconnect!
-        connect unless @raw_connection
-      end
-
       # Configures the encoding, verbosity, schema search path, and time zone of the connection.
       # This is called by #connect and should not be called manually.
       def configure_connection

data/lib/arel/collectors/sunstone.rb

@@ -136,16 +136,24 @@ module Arel
         
         case operation
         when :count
-          path += "/#{operation}"
+          path << "/#{operation}"
         when :calculate
-          path += "/calculate"
+          path << "/calculate"
           params[:select] = columns
         when :update, :delete
-          path += "/#{params[:where]['id']}"
-          params.delete(:where)
+          if params[:where].is_a?(Array)
+            path << "/#{params[:where][0]['id']}"
+            params[:where][0].delete('id')
+            params[:where].shift if params[:where][0].empty?
+          else
+            path << "/#{params[:where]['id']}"
+            params[:where].delete('id')
+            params.delete(:where) if params[:where].empty?
+          end
+          params[:where] = params[:where].first if params[:where]&.one?
         end
 
-        if params.size > 0 && request_type == Net::HTTP::Get
+        if params.size > 0
           newpath = path + "?#{CGI.escape(MessagePack.pack(params))}"
           if newpath.length > MAX_URI_LENGTH
             request_type_override = Net::HTTP::Post

data/lib/arel/visitors/sunstone.rb

@@ -160,7 +160,6 @@ module Arel
         collector.table = o.relation.name
         collector.operation     = :update
 
-        # collector.id = o.wheres.first.children.first.right
         if !o.wheres.empty?
           collector.where = o.wheres.map { |x| visit(x, collector) }.inject([]) { |c, w|
             w.is_a?(Array) ? c += w : c << w
@@ -171,8 +170,6 @@ module Arel
           raise 'Upsupported'
         end
 
-        collector.where = collector.where.first
-
         if o.values
           collector.updates = {}
 

data/lib/sunstone/connection.rb

@@ -128,6 +128,17 @@ module Sunstone
     #    end
     #  end
     def send_request(request, body=nil, &block)
+      path_and_query = request.path.split('?', 2)
+      message = "SENDING: #{request.method} #{path_and_query[0]}"
+      if path_and_query[1]
+        if request['Query-Encoding'] == 'application/msgpack'
+          message << " " << MessagePack.unpack(CGI.unescape(path_and_query[1])).inspect
+        else
+          message << " " << CGI.unescape(path_and_query[1])
+        end
+      end
+      puts message
+      
       if request.method != 'GET' && Thread.current[:sunstone_transaction_count]
         if Thread.current[:sunstone_transaction_count] == 1 && !Thread.current[:sunstone_request_sent]
           Thread.current[:sunstone_request_sent] = request

data/lib/sunstone/version.rb

@@ -1,3 +1,3 @@
 module Sunstone
-  VERSION = '7.2.0'
+  VERSION = '8.0.1'
 end

data/lib/sunstone.rb

@@ -7,6 +7,7 @@ require 'msgpack'
 require 'cookie_store' # optional
 
 require "active_record"
+require "active_record/locking/optimistic"
 
 # Adapter
 require File.expand_path(File.join(__FILE__, '../sunstone/version'))
@@ -20,16 +21,21 @@ require File.expand_path(File.join(__FILE__, '../arel/visitors/sunstone'))
 require File.expand_path(File.join(__FILE__, '../arel/collectors/sunstone'))
 
 # ActiveRecord Extensions
+require File.expand_path(File.join(__FILE__, '../../ext/active_record/base'))
 require File.expand_path(File.join(__FILE__, '../../ext/active_record/statement_cache'))
 require File.expand_path(File.join(__FILE__, '../../ext/active_record/associations'))
 require File.expand_path(File.join(__FILE__, '../../ext/active_record/relation'))
 require File.expand_path(File.join(__FILE__, '../../ext/active_record/relation/calculations'))
 require File.expand_path(File.join(__FILE__, '../../ext/active_record/relation/query_methods'))
+require File.expand_path(File.join(__FILE__, '../../ext/active_record/relation/predicate_builder'))
+require File.expand_path(File.join(__FILE__, '../../ext/active_record/relation/finder_methods'))
 require File.expand_path(File.join(__FILE__, '../../ext/active_record/persistence'))
 require File.expand_path(File.join(__FILE__, '../../ext/active_record/callbacks'))
 require File.expand_path(File.join(__FILE__, '../../ext/active_record/attribute_methods'))
 require File.expand_path(File.join(__FILE__, '../../ext/active_record/transactions'))
 require File.expand_path(File.join(__FILE__, '../../ext/active_record/associations/collection_association'))
+require File.expand_path(File.join(__FILE__, '../../ext/active_record/associations/has_many_through_association'))
+require File.expand_path(File.join(__FILE__, '../../ext/active_record/locking/optimistic'))
 
 require File.expand_path(File.join(__FILE__, '../../ext/active_support/core_ext/object/to_query'))
 
@@ -37,7 +43,7 @@ require File.expand_path(File.join(__FILE__, '../../ext/arel/select_manager'))
 require File.expand_path(File.join(__FILE__, '../../ext/arel/nodes/eager_load'))
 require File.expand_path(File.join(__FILE__, '../../ext/arel/attributes/empty_relation'))
 require File.expand_path(File.join(__FILE__, '../../ext/arel/nodes/select_statement'))
-require File.expand_path(File.join(__FILE__, '../../ext/active_record/finder_methods'))
+
 
 
 ActiveRecord::ConnectionAdapters.register("sunstone", "ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter", "active_record/connection_adapters/sunstone_adapter")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sunstone
 version: !ruby/object:Gem::Version
-  version: 7.2.0
+  version: 8.0.1
 platform: ruby
 authors:
 - Jon Bracy
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-13 00:00:00.000000000 Z
+date: 2025-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -226,14 +226,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.2.0
+        version: 8.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.2.0
+        version: 8.0.1
 - !ruby/object:Gem::Dependency
   name: arel-extensions
   requirement: !ruby/object:Gem::Requirement
@@ -272,12 +272,16 @@ files:
 - LICENSE
 - ext/active_record/associations.rb
 - ext/active_record/associations/collection_association.rb
+- ext/active_record/associations/has_many_through_association.rb
 - ext/active_record/attribute_methods.rb
+- ext/active_record/base.rb
 - ext/active_record/callbacks.rb
-- ext/active_record/finder_methods.rb
+- ext/active_record/locking/optimistic.rb
 - ext/active_record/persistence.rb
 - ext/active_record/relation.rb
 - ext/active_record/relation/calculations.rb
+- ext/active_record/relation/finder_methods.rb
+- ext/active_record/relation/predicate_builder.rb
 - ext/active_record/relation/query_methods.rb
 - ext/active_record/statement_cache.rb
 - ext/active_record/transactions.rb
@@ -324,7 +328,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.21
 signing_key:
 specification_version: 4
 summary: A library for interacting with REST APIs

data/ext/active_record/finder_methods.rb

@@ -1,241 +0,0 @@
-# The last ref that this code was synced with Rails
-# ref: 9269f634d471ad6ca46752421eabd3e1c26220b5
-
-module ActiveRecord
-  class PredicateBuilder # :nodoc:
-
-    def expand_from_hash(attributes, &block)
-      return ["1=0"] if attributes.empty?
-
-      attributes.flat_map do |key, value|
-        if key.is_a?(Array)
-          queries = Array(value).map do |ids_set|
-            raise ArgumentError, "Expected corresponding value for #{key} to be an Array" unless ids_set.is_a?(Array)
-            expand_from_hash(key.zip(ids_set).to_h)
-          end
-          grouping_queries(queries)
-        elsif value.is_a?(Hash) && !table.has_column?(key)
-          ka = table.associated_table(key, &block)
-            .predicate_builder.expand_from_hash(value.stringify_keys)
-
-          if self.table.instance_variable_get(:@klass).connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
-            ka.each { |k|
-              if k.left.is_a?(Arel::Attributes::Attribute) || k.left.is_a?(Arel::Attributes::Relation)
-                k.left = Arel::Attributes::Relation.new(k.left, key)
-              end
-            }
-          end
-          ka
-        elsif table.associated_with?(key)
-          # Find the foreign key when using queries such as:
-          # Post.where(author: author)
-          #
-          # For polymorphic relationships, find the foreign key and type:
-          # PriceEstimate.where(estimate_of: treasure)
-          associated_table = table.associated_table(key)
-          if associated_table.polymorphic_association?
-            value = [value] unless value.is_a?(Array)
-            klass = PolymorphicArrayValue
-          elsif associated_table.through_association?
-            next associated_table.predicate_builder.expand_from_hash(
-              associated_table.primary_key => value
-            )
-          end
-
-          klass ||= AssociationQueryValue
-          queries = klass.new(associated_table, value).queries.map! do |query|
-            # If the query produced is identical to attributes don't go any deeper.
-            # Prevents stack level too deep errors when association and foreign_key are identical.
-            query == attributes ? self[key, value] : expand_from_hash(query)
-          end
-
-          grouping_queries(queries)
-        elsif table.aggregated_with?(key)
-          mapping = table.reflect_on_aggregation(key).mapping
-          values = value.nil? ? [nil] : Array.wrap(value)
-          if mapping.length == 1 || values.empty?
-            column_name, aggr_attr = mapping.first
-            values = values.map do |object|
-              object.respond_to?(aggr_attr) ? object.public_send(aggr_attr) : object
-            end
-            self[column_name, values]
-          else
-            queries = values.map do |object|
-              mapping.map do |field_attr, aggregate_attr|
-                self[field_attr, object.try!(aggregate_attr)]
-              end
-            end
-
-            grouping_queries(queries)
-          end
-        else
-          self[key, value]
-        end
-      end
-    end
-
-  end
-end
-
-module ActiveRecord
-  module FinderMethods
-
-    class SunstoneJoinDependency
-      def initialize(klass)
-        @klass = klass
-      end
-      
-      def reflections
-        []
-      end
-      
-      def apply_column_aliases(relation)
-        relation
-      end
-      
-      def instantiate(result_set, strict_loading_value, &block)
-        seen = Hash.new { |i, object_id|
-          i[object_id] = Hash.new { |j, child_class|
-            j[child_class] = {}
-          }
-        }
-
-        model_cache = Hash.new { |h, klass| h[klass] = {} }
-        parents = model_cache[@klass]
-
-        message_bus = ActiveSupport::Notifications.instrumenter
-
-        payload = {
-          record_count: result_set.length,
-          class_name: @klass.name
-        }
-
-        message_bus.instrument("instantiation.active_record", payload) do
-          result_set.each { |row_hash|
-            parent_key = @klass.primary_key ? row_hash[@klass.primary_key] : row_hash
-            parent = parents[parent_key] ||= @klass.instantiate(row_hash.select{|k,v| @klass.column_names.include?(k.to_s) }, &block)
-            construct(parent, row_hash.select{|k,v| !@klass.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
-          }
-        end
-
-        parents.values
-      end
-
-      def construct(parent, relations, seen, model_cache, strict_loading_value)
-        relations.each do |key, attributes|
-          reflection = parent.class.reflect_on_association(key)
-          next unless reflection
-
-          if reflection.collection?
-            other = parent.association(reflection.name)
-            other.loaded!
-          else
-            if parent.association_cached?(reflection.name)
-              model = parent.association(reflection.name).target
-              construct(model, attributes.select{|k,v| !model.class.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
-            end
-          end
-
-          if !reflection.collection?
-            construct_association(parent, reflection, attributes, seen, model_cache, strict_loading_value)
-          else
-            attributes.each do |row|
-              construct_association(parent, reflection, row, seen, model_cache, strict_loading_value)
-            end
-          end
-
-        end
-      end
-
-      def construct_association(parent, reflection, attributes, seen, model_cache, strict_loading_value)
-        return if attributes.nil?
-
-        klass = if reflection.polymorphic?
-          parent.send(reflection.foreign_type).constantize.base_class
-        else
-          reflection.klass
-        end
-        id = attributes[klass.primary_key]
-        model = seen[parent.object_id][klass][id]
-
-        if model
-          construct(model, attributes.select{|k,v| !klass.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
-
-          other = parent.association(reflection.name)
-
-          if reflection.collection?
-            other.target.push(model)
-          else
-            other.target = model
-          end
-
-          other.set_inverse_instance(model)
-        else
-          model = construct_model(parent, reflection, id, attributes.select{|k,v| klass.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
-          seen[parent.object_id][model.class.base_class][id] = model
-          construct(model, attributes.select{|k,v| !klass.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
-        end
-      end
-
-
-      def construct_model(record, reflection, id, attributes, seen, model_cache, strict_loading_value)
-        klass = if reflection.polymorphic?
-          record.send(reflection.foreign_type).constantize
-        else
-          reflection.klass
-        end
-
-        model = model_cache[klass][id] ||= klass.instantiate(attributes)
-        other = record.association(reflection.name)
-
-        if reflection.collection?
-          other.target.push(model)
-        else
-          other.target = model
-        end
-
-        other.set_inverse_instance(model)
-        model
-      end
-  
-    end
-
-    def apply_join_dependency(eager_loading: group_values.empty?)
-      if connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
-        join_dependency = SunstoneJoinDependency.new(base_class)
-        relation = except(:includes, :eager_load, :preload)
-        relation.arel.eager_load = Arel::Nodes::EagerLoad.new(eager_load_values)
-      else
-        join_dependency = construct_join_dependency(
-          eager_load_values | includes_values, Arel::Nodes::OuterJoin
-        )
-        relation = except(:includes, :eager_load, :preload).joins!(join_dependency)
-      end
-
-      if eager_loading && has_limit_or_offset? && !(
-          using_limitable_reflections?(join_dependency.reflections) &&
-          using_limitable_reflections?(
-            construct_join_dependency(
-              select_association_list(joins_values).concat(
-                select_association_list(left_outer_joins_values)
-              ), nil
-            ).reflections
-          )
-        )
-        if !connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
-          relation = skip_query_cache_if_necessary do
-            klass.connection.distinct_relation_for_primary_key(relation)
-          end
-        end
-      end
-
-      if block_given?
-        yield relation, join_dependency
-      else
-        relation
-      end
-    end
-    
-  end
-
-end