parse-stack-next 5.7.6 → 5.8.1

data/lib/parse/model/associations/has_many.rb

@@ -378,10 +378,22 @@ module Parse
           }
 
           define_method(key) do |*args, &block|
-            return [] if @id.nil?
             query = Parse::Query.new(klassName, limit: :max)
 
-            query.where(foreign_field => self) unless opts[:scope_only] == true
+            unless opts[:scope_only] == true
+              if @id.blank?
+                # An unsaved owner has no related records. Return a query
+                # that matches nothing, so chaining still works, without
+                # sending a constraint on a pointer with a null objectId.
+                query.where(:objectId.in => [])
+                query.define_singleton_method(:results) do |*_a, **_o, &blk|
+                  blk ? [].each(&blk) : []
+                end
+                query.define_singleton_method(:count) { |*_a, **_o| 0 }
+              else
+                query.where(foreign_field => self)
+              end
+            end
 
             if scope.is_a?(Proc)
               # magic, override the singleton method_missing with accessing object level methods
@@ -483,6 +495,7 @@ module Parse
           }
 
           self.field_map.merge!(key => parse_field)
+          Parse::Model.model_registry_changed!
           # dirty tracking
           define_attribute_methods key
 
@@ -510,7 +523,7 @@ module Parse
             unless val.is_a?(Parse::PointerCollectionProxy)
               results = []
               #results = val.parse_objects if val.respond_to?(:parse_objects)
-              val = proxyKlass.new results, delegate: self, key: key
+              val = proxyKlass.new results, delegate: self, key: key, parse_class: klassName
               instance_variable_set(ivar, val)
             end
             val
@@ -542,6 +555,17 @@ module Parse
               warn "[#{self.class}] has_many :#{key} expected className=#{klassName.inspect}, ignoring incoming className=#{val[Parse::Model::KEY_CLASS_NAME].inspect}"
             end
             if val.is_a?(Hash) && val["__type"] == "Relation"
+              current = instance_variable_get(ivar)
+              # A server descriptor carries no membership. When the current
+              # proxy holds staged additions or removals (a fetch of a record
+              # with unsaved relation changes), keep it so they are not lost.
+              if track != true && current.is_a?(Parse::RelationCollectionProxy) &&
+                 current.staged_changes?
+                # The loaded list predates this fetch. Unload it so the next
+                # read queries the server and re-applies the staged changes.
+                current.reset! if current.loaded?
+                return current
+              end
               relation_objects = val["objects"] || []
               val = Parse::RelationCollectionProxy.new relation_objects, delegate: self, key: key, parse_class: klassName
             elsif val.is_a?(Hash) && val["__op"] == "AddRelation" && val["objects"].present?
@@ -554,10 +578,21 @@ module Parse
               _collection.loaded = true
               _collection.remove val["objects"].parse_objects(klassName)
               val = _collection
-            elsif val.is_a?(Array)
-              # Otherwise create a new collection based on what the user
-              # defined; always coerce array elements to the declared class.
-              val = proxyKlass.new val.parse_objects(klassName), delegate: self, key: key, parse_class: klassName
+            elsif val.is_a?(Array) || (track == true && val.is_a?(Parse::CollectionProxy) && !val.is_a?(proxyKlass))
+              _collection = proxyKlass.new [], delegate: self, key: key, parse_class: klassName
+              items = if track == true
+                  # Assignment from application code: validate every item.
+                  # An item of another class, nil, or a value that is not an
+                  # object, pointer or objectId raises ArgumentError rather
+                  # than being stored under the declared class.
+                  _collection.send(:typecast_items, val.to_a)
+                else
+                  # Server data: coerce elements to the declared class.
+                  val.parse_objects(klassName)
+                end
+              _collection.set_collection!(items)
+              _collection.loaded = true
+              val = _collection
             end
 
             # send dirty tracking if set
@@ -579,11 +614,16 @@ module Parse
           #   for more information.
           if data_type == :relation
             # return a query given the foreign table class name.
+            # The $relatedTo key is the remote column, which differs from the
+            # local name when `field:` is given.
             define_method("#{key}_relation_query") do
-              Parse::Query.new(klassName, key.to_sym.related_to => self.pointer, limit: :max)
+              Parse::Query.new(klassName, parse_field.related_to => self.pointer, limit: :max)
             end
-            # fetch the contents of the relation
+            # fetch the contents of the relation. An owner without an
+            # objectId has nothing on the server; a query for it would send
+            # a null objectId, which Parse Server rejects.
             define_method("#{key}_fetch!") do
+              next [] if @id.blank?
               q = self.send :"#{key}_relation_query"
               q.results || []
             end

data/lib/parse/model/associations/has_one.rb

@@ -142,7 +142,9 @@ module Parse
           end
 
           define_method(key) do |*args, &block|
-            return nil if @id.nil?
+            # An unsaved owner has no related record, unless the scope alone
+            # selects it (`scope_only: true` does not use the owner id).
+            return nil if @id.blank? && opts[:scope_only] != true
             query = Parse::Query.new(klassName, limit: 1)
             query.where(foreign_field => self) unless opts[:scope_only] == true
 

data/lib/parse/model/associations/pointer_collection_proxy.rb

@@ -32,15 +32,50 @@ module Parse
     # @overload add(parse_objects)
     #  Add an array of Parse::Objects or Parse::Pointers to this collection.
     #  @param parse_objects [Array<Parse::Object,Parse::Pointer>] the array to append.
+    # An objectId String is accepted and becomes a pointer of the declared
+    # class.
+    # @raise [ArgumentError] if an item is nil, of another Parse class, or
+    #  cannot be turned into a pointer.
     # @return [Array<Parse::Object>] the collection
     def add(*items)
-      notify_will_change! if items.count > 0
-      items.flatten.parse_objects.each do |item|
-        collection.push(item) if item.is_a?(Parse::Pointer)
-      end
+      items = typecast_items(items)
+      return @collection if items.empty?
+      notify_will_change!
+      items.each { |item| collection.push(item) }
       @collection
     end
 
+    alias_method :push, :add
+
+    # Add items that are not already part of the collection.
+    # @param items [Array<Parse::Object,Parse::Pointer,String>] items to uniquely add
+    # @raise [ArgumentError] (see #add)
+    # @return [Array<Parse::Object>] the collection
+    def add_unique(*items)
+      items = typecast_items(items)
+      return @collection if items.empty?
+      notify_will_change!
+      @collection = collection | items
+      @collection
+    end
+
+    alias_method :push_unique, :add_unique
+
+    # @see #add
+    def <<(*list)
+      add(*list)
+      self
+    end
+
+    # Replace the contents of the collection. The items are validated as in
+    # {#add}.
+    # @param items [Array<Parse::Object,Parse::Pointer,String>] the new contents.
+    # @raise [ArgumentError] (see #add)
+    # @return [self]
+    def replace(items)
+      super(typecast_items(Array(items.is_a?(Parse::CollectionProxy) ? items.to_a : items)))
+    end
+
     # Removes Parse::Objects from the collection.
     # @overload remove(parse_object)
     #  Remove a Parse::Object or Parse::Pointer to this collection.
@@ -48,40 +83,37 @@ module Parse
     # @overload remove(parse_objects)
     #  Remove an array of Parse::Objects or Parse::Pointers from this collection.
     #  @param parse_objects [Array<Parse::Object,Parse::Pointer>] the array of objects to remove.
+    # An objectId String removes the object of the declared class with that id.
     # @return [Array<Parse::Object>] the collection
     def remove(*items)
-      notify_will_change! if items.count > 0
-      items.flatten.parse_objects.each do |item|
-        collection.delete item
-      end
+      items = typecast_items(items, strict: false)
+      return @collection if items.empty?
+      notify_will_change!
+      items.each { |item| collection.delete item }
       @collection
     end
 
+    alias_method :delete, :remove
+
     # Atomically add a set of Parse::Objects to this collection.
-    # This is done by making the API request directly with Parse server; the
-    # local object is not updated with changes.
     # @see CollectionProxy#add!
     # @see #add_unique!
     def add!(*items)
-      super(items.flatten.parse_pointers)
+      super(*typecast_items(items))
     end
 
     # Atomically add a set of Parse::Objects to this collection for those not already
     # in the collection.
-    # This is done by making the API request directly with Parse server; the
-    # local object is not updated with changes.
     # @see CollectionProxy#add_unique!
     # @see #add!
     def add_unique!(*items)
-      super(items.flatten.parse_pointers)
+      super(*typecast_items(items))
     end
 
     # Atomically remove a set of Parse::Objects to this collection.
-    # This is done by making the API request directly with Parse server; the
-    # local object is not updated with changes.
     # @see CollectionProxy#remove!
     def remove!(*items)
-      super(items.flatten.parse_pointers)
+      super(*typecast_items(items, strict: false))
     end
 
     # Force fetch the set of pointer objects in this collection.
@@ -130,5 +162,101 @@ module Parse
       opts = defaults.merge(opts)
       super(opts)
     end
+
+    private
+
+    # Convert the given items to Parse objects of the collection's class.
+    # Parse objects and pointers are kept, pointer hashes are built, and an
+    # objectId String becomes a pointer of the declared class.
+    # @param items [Array] the items to convert (nested arrays are flattened).
+    # @param strict [Boolean] when true, an item that cannot be converted, or
+    #  belongs to another Parse class, raises. When false it is skipped.
+    # @raise [ArgumentError] in strict mode, for an invalid item.
+    # @return [Array<Parse::Pointer>]
+    def typecast_items(items, strict: true)
+      items.flatten.each_with_object([]) do |item, list|
+        obj = typecast_item(item)
+        if obj.nil?
+          next unless strict
+          raise ArgumentError, "Invalid item #{item.inspect} for #{collection_label}: " \
+                               "expected a Parse::Object, Parse::Pointer or objectId String."
+        end
+        unless item_class_allowed?(obj.parse_class)
+          next unless strict
+          raise ArgumentError, "Invalid item for #{collection_label}: expected a " \
+                               "#{@parse_class} object, got #{obj.parse_class}."
+        end
+        list << obj
+      end
+    end
+
+    # The server returns the field's array as pointer hashes. Each entry
+    # becomes an object of the declared class, reusing the local object with
+    # the same id so fetched data is kept. The array is adopted only when
+    # the declared class is a registered model and every entry is a pointer
+    # to that class; anything else (another class, a bare string, a value
+    # that is not a pointer) makes the operation apply locally instead,
+    # rather than relabeling the entry as the declared class.
+    # @return [Array<Parse::Pointer>, nil]
+    def adopt_server_items(value)
+      return nil if @parse_class.blank? || Parse::Model.find_class(@parse_class).nil?
+      local_by_id = {}
+      collection.to_a.each do |item|
+        id = item.respond_to?(:id) ? item.id : nil
+        local_by_id[id] ||= item if id.present?
+      end
+      value.map do |entry|
+        class_name, object_id = server_pointer_parts(entry)
+        return nil unless object_id.is_a?(String) && object_id.present?
+        return nil unless Parse::Model.same_parse_class?(class_name, @parse_class)
+        local_by_id[object_id] || typecast_item(entry) || (return nil)
+      end
+    end
+
+    # @return [Array(String, String), nil] the className and objectId of a
+    #   pointer entry from a server reply, or nil when it is not a pointer.
+    def server_pointer_parts(entry)
+      case entry
+      when Parse::Pointer
+        [entry.parse_class, entry.id]
+      when Hash
+        type = entry["__type"] || entry[:__type]
+        return nil unless %w[Pointer Object].include?(type.to_s)
+        [entry["className"] || entry[:className], entry["objectId"] || entry[:objectId]]
+      end
+    end
+
+    # @return [Parse::Pointer, nil] the item as a Parse object, or nil.
+    def typecast_item(item)
+      case item
+      when Parse::Pointer
+        item
+      when Hash
+        type = item["__type"] || item[:__type]
+        return nil if type.present? && !%w[Pointer Object].include?(type.to_s)
+        # A pointer hash is wire data: with a declared class its className
+        # is ignored (with a warning), as for server data.
+        [item].parse_objects(@parse_class.presence).first
+      when String
+        return nil if item.blank? || @parse_class.blank?
+        Parse::Object.build({ Parse::Model::TYPE_FIELD => Parse::Model::TYPE_POINTER,
+                              Parse::Model::KEY_CLASS_NAME => @parse_class,
+                              Parse::Model::OBJECT_ID => item }, @parse_class)
+      end
+    end
+
+    # @return [Boolean] whether an item of `klass` may be part of this
+    #   collection. The class is checked when the declared class is a
+    #   registered model; a declaration naming no model (for example a
+    #   has_many whose `as:` was left to default) keeps accepting any class.
+    def item_class_allowed?(klass)
+      return true if @parse_class.blank? || Parse::Model.find_class(@parse_class).nil?
+      klass.present? && Parse::Model.same_parse_class?(klass, @parse_class)
+    end
+
+    def collection_label
+      owner = @delegate.respond_to?(:parse_class) ? @delegate.parse_class : @delegate.class
+      @key ? "#{owner}##{@key}" : self.class.name
+    end
   end
 end

data/lib/parse/model/associations/relation_collection_proxy.rb

@@ -24,18 +24,19 @@ module Parse
   # get matching items within the relation collection.
   #
   # When creating a Relation proxy, all the delegate methods defined in the superclasses
-  # need to be implemented, in addition to a few others with the key parameter:
-  # _relation_query and _commit_relation_updates . :'key'_relation_query should return a
+  # need to be implemented, in addition to :'key'_relation_query, which should return a
   # Parse::Query object that is properly tied to the foreign table class related to this object column.
   # Example, if an Artist has many Song objects, then the query to be returned by this method
   # should be a Parse::Query for the class 'Song'.
   # Because relation changes are separate from object changes, you can call save on a
-  # relation collection to save the current add and remove operations. Because the delegate needs
-  # to be informed of the changes being committed, it will be notified
-  # through :'key'_commit_relation_updates message. The delegate is also in charge of
-  # clearing out the change information for the collection if saved successfully.
+  # relation collection to send only its staged add and remove operations, through the
+  # owner's atomic relation operations.
   # @see PointerCollectionProxy
   class RelationCollectionProxy < PointerCollectionProxy
+    # @!visibility private
+    # Default for {#save}'s `session:`: keep the owner's session as it is.
+    SESSION_UNSET = Object.new.freeze
+
     define_attribute_methods :additions, :removals
     # @!attribute [r] removals
     #  The objects that have been newly removed to this collection
@@ -51,9 +52,29 @@ module Parse
       @removals = []
     end
 
+    # The items of the relation. The first access queries the server for the
+    # related objects, then applies the additions and removals that have not
+    # been saved yet. An owner without an objectId has nothing on the server,
+    # so no query is sent for it.
+    # @return [Array<Parse::Object>]
+    def collection
+      unless @loaded
+        fetched = owner_saved? ? forward(:"#{@key}_fetch!") : nil
+        list = fetched.to_a.reject { |item| @removals.include?(item) }
+        @additions.each { |item| list.push(item) unless list.include?(item) }
+        @collection = list
+        @loaded = true
+      end
+      @collection
+    end
+
     # You can get items within the collection relation filtered by a specific set
     # of query constraints.
     def all(constraints = {}, &block)
+      # An unsaved owner has no relation on the server yet.
+      unless owner_saved?
+        return block_given? ? collection.each(&block) : collection
+      end
       q = query({ limit: :max }.merge(constraints))
       if block_given?
         # if we have a query, then use the Proc with it (more efficient)
@@ -86,32 +107,44 @@ module Parse
       query(limit: count)
     end
 
-    # Add Parse::Objects to the relation.
+    # Add Parse::Objects to the relation. The change is staged and sent with
+    # the next save of the owner. Staging does not query the relation.
+    # Adding an item that is already staged has no further effect.
     # @overload add(parse_object)
     #  Add a Parse::Object or Parse::Pointer to this relation.
     #  @param parse_object [Parse::Object,Parse::Pointer] the object to add
     # @overload add(parse_objects)
     #  Add an array of Parse::Objects or Parse::Pointers to this relation.
     #  @param parse_objects [Array<Parse::Object,Parse::Pointer>] the array to append.
+    # @raise [ArgumentError] if an item is nil, of another Parse class, or
+    #  cannot be turned into a pointer.
     # @return [Array<Parse::Object>] the collection
     def add(*items)
-      items = items.flatten.parse_objects
+      items = typecast_items(items)
       return @collection if items.empty?
 
       notify_will_change!
       additions_will_change!
       removals_will_change!
-      # take all the items
       items.each do |item|
-        @additions.push item
-        @collection.push item
-        #cleanup
-        @removals.delete item
+        @additions.push(item) unless @additions.include?(item)
+        @removals.delete(item)
+        @collection.push(item) if @loaded && !@collection.include?(item)
       end
       @collection
     end
 
-    # Removes Parse::Objects from the relation.
+    alias_method :push, :add
+
+    # Same as {#add}: a relation never holds an object twice.
+    def add_unique(*items)
+      add(*items)
+    end
+
+    alias_method :push_unique, :add_unique
+
+    # Removes Parse::Objects from the relation. The change is staged and sent
+    # with the next save of the owner. Staging does not query the relation.
     # @overload remove(parse_object)
     #  Remove a Parse::Object or Parse::Pointer to this relation.
     #  @param parse_object [Parse::Object,Parse::Pointer] the object to remove
@@ -120,52 +153,165 @@ module Parse
     #  @param parse_objects [Array<Parse::Object,Parse::Pointer>] the array of objects to remove.
     # @return [Array<Parse::Object>] the collection
     def remove(*items)
-      items = items.flatten.parse_objects
+      items = typecast_items(items, strict: false)
       return @collection if items.empty?
       notify_will_change!
       additions_will_change!
       removals_will_change!
+      # An unsaved owner has nothing on the server to remove.
+      saved = owner_saved?
       items.each do |item|
-        @removals.push item
-        @collection.delete item
-        # remove it from any add operations
-        @additions.delete item
+        @removals.push(item) if saved && !@removals.include?(item)
+        @additions.delete(item)
+        @collection.delete(item)
       end
       @collection
     end
 
+    alias_method :delete, :remove
+
+    # Stage the removal of every object in the relation. This loads the
+    # relation to know what to remove.
+    # @return [Array<Parse::Object>] the (now empty) collection.
+    def clear
+      remove(*collection.to_a)
+      @collection
+    end
+
+    # Stage the changes that make the relation hold exactly `items`.
+    # @return [self]
+    def replace(items)
+      items = typecast_items(Array(items.is_a?(Parse::CollectionProxy) ? items.to_a : items))
+      current = collection.to_a
+      stale = current.reject { |item| items.include?(item) }
+      remove(*stale) if stale.any?
+      fresh = items.reject { |item| current.include?(item) }
+      add(*fresh) if fresh.any?
+      self
+    end
+
     # Atomically add a set of Parse::Objects to this relation.
-    # This is done by making the API request directly with Parse server; the
-    # local object is not updated with changes.
+    # This is done by making the API request directly with Parse server. On
+    # success the loaded collection includes the items, and a staged
+    # removal of the same items is dropped so a later save does not undo it.
+    # On an owner that has not been saved yet the items are staged as in
+    # {#add} and sent with the next save.
+    # @return [Boolean] whether the operation succeeded.
     def add!(*items)
       return false unless @delegate.respond_to?(:op_add_relation!)
-      items = items.flatten.parse_pointers
-      @delegate.send :op_add_relation!, @key, items
+      items = typecast_items(items)
+      return true if items.empty?
+      return add(*items) && true unless owner_persisted?
+      return false unless @delegate.send(:op_add_relation!, @key, items.parse_pointers)
+      items.each do |item|
+        @removals.delete(item)
+        @collection.push(item) if @loaded && !@collection.include?(item)
+      end
+      true
     end
 
-    # Atomically add a set of Parse::Objects to this relation.
-    # This is done by making the API request directly with Parse server; the
-    # local object is not updated with changes.
+    # @see #add!
     def add_unique!(*items)
-      return false unless @delegate.respond_to?(:op_add_relation!)
-      items = items.flatten.parse_pointers
-      @delegate.send :op_add_relation!, @key, items
+      add!(*items)
     end
 
-    # Atomically remove a set of Parse::Objects to this relation.
-    # This is done by making the API request directly with Parse server; the
-    # local object is not updated with changes.
+    # Atomically remove a set of Parse::Objects from this relation.
+    # This is done by making the API request directly with Parse server. On
+    # success the items leave the loaded collection, and a staged addition
+    # of the same items is dropped.
+    # @return [Boolean] whether the operation succeeded.
     def remove!(*items)
       return false unless @delegate.respond_to?(:op_remove_relation!)
-      items = items.flatten.parse_pointers
-      @delegate.send :op_remove_relation!, @key, items
+      items = typecast_items(items, strict: false)
+      return true if items.empty?
+      return remove(*items) && true unless owner_persisted?
+      return false unless @delegate.send(:op_remove_relation!, @key, items.parse_pointers)
+      items.each do |item|
+        @additions.delete(item)
+        @collection.delete(item)
+      end
+      true
+    end
+
+    # Marks the staged additions and removals as saved. Called after the
+    # owner is saved successfully, so the operations are not sent again by a
+    # later save.
+    def changes_applied!
+      @additions = []
+      @removals = []
+      super
+    end
+
+    # Drops the staged additions and removals. The items are reloaded from
+    # the server on the next access.
+    def rollback!
+      super
+      @additions = []
+      @removals = []
+      reset!
+      @collection
     end
 
-    # Save the changes to the relation
-    def save
-      unless @removals.empty? && @additions.empty?
-        forward :"#{@key}_commit_relation_updates"
+    # @return [Boolean] true when additions or removals are staged and not
+    #   yet sent.
+    def staged_changes?
+      @additions.any? || @removals.any?
+    end
+
+    # Drops the staged additions and removals and clears the dirty tracking,
+    # without sending anything. When operations were staged, the items are
+    # reloaded from the server on the next access, since the loaded list
+    # included them.
+    def clear_changes!
+      staged = staged_changes?
+      @additions = []
+      @removals = []
+      super
+      reset! if staged
+      @collection
+    end
+
+    # Sends the staged additions and removals of this relation without saving
+    # the rest of the owner. The owner must already be saved: an unsaved owner
+    # sends its relation additions when it is created.
+    #
+    # Removals and additions go out as two requests, removals first (each
+    # through the owner's atomic relation operation, so {Parse::Role} cache
+    # invalidation still runs). The two are not atomic: if the removals
+    # succeed and the additions fail, the removals stay applied, they are no
+    # longer staged, and the additions stay staged for a retry. An owner
+    # save sends relation changes the same way.
+    #
+    # The requests use the owner's session token from its last
+    # `save(session:)`, or the client's default credentials. Pass `session:`
+    # to send them as a specific user (a session token String or a
+    # {Parse::User}), or `session: nil` to send them with no session token.
+    # @param session [String, Parse::User, nil] the session to send the
+    #  operations with, when given.
+    # @return [Boolean] whether the staged operations were applied. False
+    #  when the owner is not saved yet or a request failed; operations that
+    #  did not succeed stay staged.
+    def save(session: SESSION_UNSET)
+      return true if @additions.empty? && @removals.empty?
+      return false unless owner_persisted?
+      return false unless @delegate.respond_to?(:op_add_relation!) && @delegate.respond_to?(:op_remove_relation!)
+      applied = with_owner_session(session) do
+        if @removals.any?
+          next false unless @delegate.send(:op_remove_relation!, @key, @removals.parse_pointers)
+          @removals = []
+        end
+        if @additions.any?
+          next false unless @delegate.send(:op_add_relation!, @key, @additions.parse_pointers)
+          @additions = []
+        end
+        true
+      end
+      return false unless applied
+      clear_changes_information
+      if @delegate.respond_to?(:clear_attribute_changes, true)
+        @delegate.send(:clear_attribute_changes, [@key.to_s])
       end
+      true
     end
 
     # @see #add
@@ -173,5 +319,50 @@ module Parse
       list.each { |d| add(d) }
       @collection
     end
+
+    private
+
+    attr_writer :additions, :removals
+
+    # @return [Boolean] whether the owner has an objectId to query by.
+    def owner_saved?
+      !(@delegate.respond_to?(:id) && @delegate.id.blank?)
+    end
+
+    # @return [Boolean] whether the owner exists on the server, so a write to
+    #  its relation can be sent. Follows {Parse::Object#persisted?}: an
+    #  id-only handle to a stored record counts, but an objectId assigned
+    #  client-side during a create (`parse_reference precompute:`) does not
+    #  until the create returns, and neither does a destroyed owner.
+    def owner_persisted?
+      return false unless owner_saved?
+      !@delegate.respond_to?(:persisted?) || @delegate.persisted?
+    end
+
+    # Run the block with the owner's session token set to `session`, then
+    # restore the owner's previous token. {SESSION_UNSET} runs it unchanged.
+    def with_owner_session(session)
+      return yield if session.equal?(SESSION_UNSET)
+      token = @delegate.send(:_validate_session_token!, session, :save)
+      had = @delegate.instance_variable_defined?(:@_session_token)
+      previous = @delegate.instance_variable_get(:@_session_token)
+      @delegate.instance_variable_set(:@_session_token, token)
+      begin
+        yield
+      ensure
+        if had
+          @delegate.instance_variable_set(:@_session_token, previous)
+        else
+          @delegate.remove_instance_variable(:@_session_token)
+        end
+      end
+    end
+
+    # ActiveModel reads the current value when a change starts. Read the
+    # items directly: going through {#collection} would query the whole
+    # relation just to stage an add or remove.
+    def _read_attribute(attr)
+      attr.to_s == "collection" ? @collection : super
+    end
   end
 end