sunstone 8.0.0 → 8.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd0eae0dbdee21a95ca29317302b67b50647f7d6654af15553425f55d1d11aed
-  data.tar.gz: b0cdc960489411360b1ee4f2cb4cdcce93b7df2464dabdafa2bc26955be002b3
+  metadata.gz: 9e9d652c2cfc067ca7a6921350122369134b44a200a262d93da2f9df98c90d5c
+  data.tar.gz: b13d474440401eb82768422ece2047e9b0e1f1cf470264e4a2d786dcdf5c13eb
 SHA512:
-  metadata.gz: ce768f425153db1d5a2242f845bc3de221a4d0d0d8a30a1428c128d2bb1e4353ef986020283fdd1d17e7652937c38d03eb1f42478acbc694da32135f335cab22
-  data.tar.gz: ece020a27e0554bad07f0e831919e8969cebdd6970adc344fb4f018b3a45032588dcd7c4eb512d9fcb8ff4acfc09ef27d9fe6124fa2b9db0d5eeff659885d800
+  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

@@ -4,27 +4,6 @@
 module ActiveRecord
   module Calculations
 
-    # 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
-      else
-        with_connection do |conn|
-          # Rails compiles this to a string, but we don't have string we
-          # have a hash
-          if model.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
-            sv = arel_columns(select_values)
-            sv.one? ? sv.first : sv
-          else
-            sv = arel_columns(select_values).map { |column| conn.visitor.compile(column) } 
-            sv.one? ? sv.first : sv.join(", ")
-          end
-        end
-      end
-    end
-
     def pluck(*column_names)
       if @none
         if @async
@@ -46,7 +25,7 @@ module ActiveRecord
       if has_include?(column_names.first)
         relation = apply_join_dependency
         relation.pluck(*column_names)
-      elsif model.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+      elsif model.sunstone?
         load
         return records.pluck(*column_names.map{|n| n.to_s.sub(/^#{model.table_name}\./, "")})
       else
@@ -69,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 && !model.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

@@ -118,6 +118,11 @@ 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
 
         # 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)

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/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 = '8.0.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: 8.0.0
+  version: 8.0.1
 platform: ruby
 authors:
 - Jon Bracy
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-24 00:00:00.000000000 Z
+date: 2025-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -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

data/ext/active_record/finder_methods.rb

@@ -1,246 +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) && 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).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