parse-stack-next 5.7.6 → 5.8.1

data/lib/parse/graphql/type_generator.rb

@@ -29,6 +29,9 @@ module Parse
         string: ::GraphQL::Types::String,
         integer: ::GraphQL::Types::Int,
         float: ::GraphQL::Types::Float,
+        # A :number property may hold fractional values, which GraphQL's
+        # 32-bit Int cannot represent, so it is exposed as Float.
+        number: ::GraphQL::Types::Float,
         boolean: ::GraphQL::Types::Boolean,
         date: ::GraphQL::Types::ISO8601DateTime,
         timezone: ::GraphQL::Types::String,

data/lib/parse/live_query/client.rb

@@ -374,7 +374,11 @@ module Parse
         if class_name.is_a?(Parse::Query)
           query = class_name
           class_name = query.table
-          where = query.compile_where
+          where = query.compile_rest_where
+          # The subscription runs under the query's own session (or its
+          # `become` client's); a different explicit token raises, and so
+          # does a query bound to another application than this client.
+          session_token = query.live_query_session_token(session_token, live_query_client: self)
         end
 
         # Refuse server-side-JS / data-mutating operators in the `where`
@@ -1007,6 +1011,27 @@ module Parse
         end
       end
 
+      # Release the latch set when this admin client first connected inside
+      # {Parse.without_master_key}. Until this is called, every later
+      # connect and reconnect withholds the master key. The next connect
+      # made outside the block then sends it again, elevating every
+      # subscription on the socket (a warning names how many).
+      # @return [void]
+      def allow_master_key_connection!
+        return unless @master_key_withheld
+        @master_key_withheld = false
+        @master_key_latch_released = true
+        nil
+      end
+
+      # @return [Boolean] whether this client withholds its master key on
+      #   every connect because it first connected inside
+      #   {Parse.without_master_key}.
+      def master_key_withheld?
+        @master_key_withheld == true
+      end
+      public :allow_master_key_connection!, :master_key_withheld?
+
       # Resubscribe all pending subscriptions
       def resubscribe_all
         subs = @monitor.synchronize { @subscriptions.values.dup }
@@ -1031,8 +1056,32 @@ module Parse
         # bypasses ACL/CLP/protectedFields. Sending it unconditionally
         # (the pre-5.1.0 behavior) silently elevated session-token
         # subscriptions the caller believed were scoped.
-        if admin_connection?
+        if admin_connection? && Parse.respond_to?(:master_key_disabled?) && Parse.master_key_disabled?
+          # Inside `Parse.without_master_key` the connect frame carries no
+          # master key, as REST requests in the block do not. The socket is
+          # then ACL-scoped for its whole lifetime, and the choice is latched:
+          # a later reconnect (including an explicit `connect` made outside
+          # the block) keeps withholding it, so subscriptions created on
+          # this socket are never silently elevated.
+          @master_key_withheld = true
+          @connected_as_admin = false
+          warn_master_key_withheld_once
+        elsif admin_connection? && @master_key_withheld
+          @connected_as_admin = false
+          warn_master_key_withheld_once
+        elsif admin_connection?
+          if @master_key_latch_released
+            @master_key_latch_released = false
+            pending = @monitor.synchronize { @subscriptions.size }
+            if pending.positive?
+              warn "[Parse::LiveQuery:SECURITY] reconnecting with the master key after " \
+                   "allow_master_key_connection!: #{pending} existing subscription(s), " \
+                   "including any created inside Parse.without_master_key, now bypass " \
+                   "ACL/CLP."
+            end
+          end
           message[:masterKey] = @master_key
+          @connected_as_admin = true
           warn_master_key_connection_once
         elsif @use_master_key
           # Opted into admin mode but no usable master key is present —
@@ -1045,6 +1094,16 @@ module Parse
         send_message(message)
       end
 
+      # One-time warning that an admin connection was opened without its
+      # master key because `Parse.without_master_key` was active.
+      def warn_master_key_withheld_once
+        return if @master_key_withheld_warning_emitted
+        @master_key_withheld_warning_emitted = true
+        warn "[Parse::LiveQuery] admin connection (use_master_key: true) opened " \
+             "inside Parse.without_master_key: the connect frame carries no master " \
+             "key, so every subscription on this connection is ACL-scoped."
+      end
+
       # One-time loud warning that this connection bypasses ACL/CLP for
       # every subscription. Master-key LiveQuery is connection-level, so
       # this is the only place the risk can be surfaced.
@@ -1063,6 +1122,17 @@ module Parse
       # silently disagree with the connection's actual authorization.
       # Both are "you think you're scoped (or elevated) but you're not."
       def warn_subscription_scope_mismatch(use_master_key, session_token)
+        if @connected_as_admin && Parse.respond_to?(:master_key_disabled?) && Parse.master_key_disabled? &&
+           !@block_on_admin_warning_emitted
+          # Parse Server fixes master-key authorization per connection at
+          # connect time, so a socket that connected with the master key
+          # stays elevated even for a subscription made inside the block.
+          @block_on_admin_warning_emitted = true
+          warn "[Parse::LiveQuery:SECURITY] subscribe inside Parse.without_master_key " \
+               "on a connection that already connected with the master key: Parse " \
+               "Server authorizes per connection, so this subscription still " \
+               "bypasses ACL/CLP. Use a non-admin client for streams inside the block."
+        end
         if use_master_key && !admin_connection?
           return if @per_sub_master_key_warning_emitted
           @per_sub_master_key_warning_emitted = true

data/lib/parse/lock_backend.rb

@@ -164,9 +164,10 @@ module Parse
       # a holder whose lease expired and was re-acquired by someone else
       # can never delete the new holder's key. Falls back to a
       # best-effort GET-then-DEL for raw-Moneta stores, where the
-      # worst-case cross-holder-delete race is bounded by the short TTL
-      # (callers clamp `ttl:` to ≤ 30s) — documented residual risk for
-      # the non-Redis path.
+      # worst-case cross-holder-delete race is bounded by the lease TTL.
+      # `Parse::Lock` clamps `ttl:` to 30s and the `first_or_create!`
+      # create-lock to 300s. This is a documented residual risk for the
+      # non-Redis path.
       #
       # @param store [Object] Moneta-shaped store.
       # @param key [String] cache key.

data/lib/parse/model/acl.rb

@@ -147,6 +147,25 @@ module Parse
       @delegate = owner
     end
 
+    # Deep-copies the permissions table so a `dup`/`clone` of an ACL never
+    # shares mutable state with the original. ActiveModel dirty tracking
+    # stores a clone of the ACL as the "before" value on the first change;
+    # with a shallow copy, later in-place edits (`apply`, `delete`,
+    # `Permission#no_read!`) also rewrote that saved value. `rollback!`
+    # then restored the edited ACL and the change history reported the old
+    # and new values as identical.
+    # @!visibility private
+    def initialize_copy(other)
+      super
+      src = other.instance_variable_get(:@permissions)
+      @permissions = nil
+      return if src.nil?
+      @permissions = {}
+      src.each do |key, perm|
+        @permissions[key] = perm.is_a?(Permission) ? adopt_permission(perm.dup) : perm
+      end
+    end
+
     # Create a new ACL with default Public read/write permissions and any
     # overrides from the input hash format.
     # @param read [Boolean] the read permissions for PUBLIC (default: true)
@@ -268,6 +287,21 @@ module Parse
       as_json == other_acl.as_json
     end
 
+    # Strict equality used by Hash keys and `Array#uniq`. Unlike {#==}, a
+    # plain Hash is never `eql?` to an ACL, since the two cannot share a
+    # {#hash} value. Two ACLs granting the same privileges are `eql?` and
+    # hash alike. The hash follows the current permissions, so an ACL
+    # mutated after use as a Hash key must be rehashed like any Hash key.
+    # @return [Boolean]
+    def eql?(other_acl)
+      other_acl.is_a?(Parse::ACL) && as_json == other_acl.as_json
+    end
+
+    # @return [Integer] a hash value consistent with {#eql?}.
+    def hash
+      [Parse::ACL, as_json].hash
+    end
+
     # Set the public read and write permissions.
     # @param read [Boolean] the read permission state.
     # @param write [Boolean] the write permission state.
@@ -285,17 +319,23 @@ module Parse
       @delegate.acl_will_change! if @delegate.respond_to?(:acl_will_change!)
     end
 
-    # Removes a permission for an objectId or user.
+    # Removes every permission for a user, role or the public entry.
     # @overload delete(object)
-    #  @param object [Parse::User] the user to revoke permissions.
+    #  @param object [Parse::User, Parse::Pointer] the user to revoke permissions.
+    # @overload delete(role)
+    #  @param role [Parse::Role] the role to revoke permissions.
     # @overload delete(id)
-    #  @param id [String] the objectId to revoke permissions.
+    #  @param id [String, Symbol] a user objectId, a role key (`"role:Admin"`),
+    #   a role name whose `role:` entry exists, or `:public` / `"*"`.
+    # @return [Parse::ACL::Permission, nil] the removed permission, or nil
+    #  when there was no matching entry.
     def delete(id)
-      id = id.id if id.is_a?(Parse::Pointer)
-      if id.present? && permissions.has_key?(id)
-        will_change!
-        permissions.delete(id)
-      end
+      key = normalize_permission_key(id)
+      return nil unless key.present? && permissions.has_key?(key)
+      will_change!
+      perm = permissions.delete(key)
+      perm.acl = nil if perm.is_a?(Permission) && perm.acl.equal?(self)
+      perm
     end
 
     # Apply a new permission with a given objectId, tag or :public.
@@ -331,7 +371,7 @@ module Parse
       if permission.is_a?(ACL::Permission)
         if permissions[id.to_s] != permission
           will_change! # dirty track
-          permissions[id.to_s] = permission
+          permissions[id.to_s] = adopt_permission(permission)
         end
       end
 
@@ -351,6 +391,10 @@ module Parse
     #  @param write [Boolean] the write permission.
     def apply_role(name, read = nil, write = nil)
       name = name.name if name.is_a?(Parse::Role)
+      name = name.to_s
+      # Accept an already-prefixed key so "role:Admin" does not become
+      # "role:role:Admin".
+      name = name.delete_prefix("role:") if name.start_with?("role:")
       apply("role:#{name}", read, write)
     end
 
@@ -822,6 +866,17 @@ module Parse
 
     private
 
+    # Points a Permission at this ACL so its own mutators can mark the ACL
+    # (and the owning object) dirty. A Permission already owned by a
+    # different ACL is copied first, so one ACL's edit never reaches another.
+    # @return [Permission]
+    def adopt_permission(perm)
+      owner = perm.acl
+      perm = perm.dup if owner && !owner.equal?(self)
+      perm.acl = self
+      perm
+    end
+
     # Normalizes a user or role input to the appropriate permission key format.
     # @param user_or_role [String, Parse::User, Parse::Role] the input to normalize
     # @return [String, nil] the normalized key or nil if invalid
@@ -885,6 +940,27 @@ module Parse
       # @return [Boolean] whether this permission is allowed.
       attr_reader :write
 
+      # @!visibility private
+      # The ACL this permission belongs to. Its mutators notify this ACL so
+      # the change is dirty tracked on the owning object.
+      attr_accessor :acl
+
+      # Converts a permission flag to a strict boolean. Only `true`, the
+      # strings "true" and "1" (any case, surrounding whitespace ignored) and
+      # non-zero numbers grant. Everything else, including the string
+      # "false", denies.
+      # @!visibility private
+      # @return [Boolean]
+      def self.grant?(value)
+        case value
+        when true then true
+        when false, nil then false
+        when String then %w[true 1].include?(value.strip.downcase)
+        when Numeric then !value.zero?
+        else value.present?
+        end
+      end
+
       # Create a new permission with the given read and write privileges.
       # @overload new(read = nil, write = nil)
       #  @param read [Boolean] whether reading is allowed.
@@ -899,20 +975,34 @@ module Parse
       def initialize(r_perm = nil, w_perm = nil)
         if r_perm.is_a?(Hash)
           r_perm = r_perm.symbolize_keys
-          @read = r_perm[:read].present?
-          @write = r_perm[:write].present?
+          @read = self.class.grant?(r_perm[:read])
+          @write = self.class.grant?(r_perm[:write])
         else
-          @read = r_perm.present?
-          @write = w_perm.present?
+          @read = self.class.grant?(r_perm)
+          @write = self.class.grant?(w_perm)
         end
       end
 
+      # A copy is detached from the original's ACL; the copying ACL adopts it.
+      # @!visibility private
+      def initialize_copy(other)
+        super
+        @acl = nil
+      end
+
       # @return [Boolean] whether two permission instances have the same permissions.
       def ==(per)
         return false unless per.is_a?(self.class)
         @read == per.read && @write == per.write
       end
 
+      alias_method :eql?, :==
+
+      # @return [Integer] a hash value consistent with {#eql?}.
+      def hash
+        [self.class, @read, @write].hash
+      end
+
       # @return [Hash] A Parse-compatible ACL-hash. Omission or false on a
       #  priviledge means don't include it
       def as_json(*args)
@@ -940,19 +1030,27 @@ module Parse
         @read.present? || @write.present?
       end
 
-      # Sets the *read* value of the permission. Defaults to true.
-      # @note Setting the value in this manner is not dirty tracked.
+      # Sets the *read* value of the permission. Defaults to true. When the
+      # permission belongs to an ACL, a real change marks that ACL (and its
+      # owning object) dirty so the change is sent on the next save.
       # @version 1.7.2
-      # @return [void]
+      # @return [Boolean] the new read value.
       def read!(value = true)
+        value = self.class.grant?(value)
+        return value if value == @read
+        @acl&.will_change!
         @read = value
       end
 
-      # Sets the *write* value of the permission. Defaults to true.
-      # @note Setting the value in this manner is not dirty tracked.
+      # Sets the *write* value of the permission. Defaults to true. When the
+      # permission belongs to an ACL, a real change marks that ACL (and its
+      # owning object) dirty so the change is sent on the next save.
       # @version 1.7.2
-      # @return [void]
+      # @return [Boolean] the new write value.
       def write!(value = true)
+        value = self.class.grant?(value)
+        return value if value == @write
+        @acl&.will_change!
         @write = value
       end
 
@@ -960,14 +1058,14 @@ module Parse
       # @version 1.7.2
       # @return [void]
       def no_read!
-        @read = false
+        read!(false)
       end
 
       # Sets the *write* value of the permission to false.
       # @version 1.7.2
       # @return [void]
       def no_write!
-        @write = false
+        write!(false)
       end
     end
   end

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

@@ -183,6 +183,7 @@ module Parse
           self.fields.merge!(key => :pointer, parse_field => :pointer)
           # Mapping between local attribute name and the remote column name
           self.field_map.merge!(key => parse_field)
+          Parse::Model.model_registry_changed!
 
           # Agent metadata: a belongs_to pointer can carry a semantic description
           # (and per-value enum descriptions) just like a `property` can. This
@@ -229,8 +230,10 @@ module Parse
             # hash, lets try to build a Pointer of that type.
 
             if val.is_a?(Hash) && (val["__type"] == "Pointer" || val["__type"] == "Object")
-              # Get nested fetched keys for this field if available
-              nested_keys = nested_keys_for(association_key)
+              # Get nested fetched keys for this field if available. Query
+              # keys are recorded under the remote column name, which differs
+              # from the local name for multi-word fields.
+              nested_keys = nested_keys_for(association_key) || nested_keys_for(parse_field)
               # Always trust the declared klassName — never the className the
               # server (or attacker-controlled mass assignment) supplied. This
               # prevents type confusion where a pointer to a different class
@@ -272,21 +275,40 @@ module Parse
           end
 
           # We only support pointers, either by object or by transforming a hash.
+          # Assignment from application code (track == true) also accepts an
+          # objectId String, which becomes a pointer of the declared class,
+          # and refuses an object or pointer of another class. A pointer
+          # hash is wire data: its className is ignored in favor of the
+          # declared class, as before.
           define_method(set_attribute_method) do |val, track = true|
             if val == Parse::Properties::DELETE_OP
               val = nil
             elsif val.is_a?(Hash) && (val["__type"] == "Pointer" || val["__type"] == "Object")
               # Get nested fetched keys for this field if available
-              nested_keys = nested_keys_for(key)
+              nested_keys = nested_keys_for(key) || nested_keys_for(parse_field)
               # Always trust declared klassName over incoming hash className.
               incoming_class = val[Parse::Model::KEY_CLASS_NAME]
               if incoming_class && !Parse::Model.same_parse_class?(incoming_class, klassName)
                 warn "[#{self.class}] belongs_to :#{key} expected className=#{klassName.inspect}, ignoring incoming className=#{incoming_class.inspect}"
               end
               val = Parse::Object.build val, klassName, fetched_keys: nested_keys
+            elsif track == true && val.is_a?(String)
+              # A blank String (an empty form select) clears the pointer.
+              val = val.blank? ? nil : Parse::Object.build({ Parse::Model::TYPE_FIELD => Parse::Model::TYPE_POINTER,
+                                                             Parse::Model::KEY_CLASS_NAME => klassName,
+                                                             Parse::Model::OBJECT_ID => val }, klassName)
             end
 
             if track == true
+              unless val.nil? || val.is_a?(Parse::Pointer)
+                raise ArgumentError, "#{self.class}##{key} expects a #{klassName} object, pointer or objectId, got #{val.class}."
+              end
+              # The class is checked when the declared class is a registered
+              # model, matching has_many arrays.
+              if val.is_a?(Parse::Pointer) && Parse::Model.find_class(klassName) &&
+                 !Parse::Model.same_parse_class?(val.parse_class, klassName)
+                raise ArgumentError, "#{self.class}##{key} expects a #{klassName} object, got #{val.parse_class}."
+              end
               prepare_for_dirty_tracking!(key)
               send will_change_method unless val == instance_variable_get(ivar)
             else

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

@@ -67,6 +67,25 @@ module Parse
       @parse_class = parse_class
     end
 
+    # Copies (`dup` and `clone`) get their own backing array and their own
+    # dirty-tracking state. ActiveModel records a property's previous value
+    # by cloning it; with a shared array the "previous" proxy changed along
+    # with the live one, so change history showed the new value twice and
+    # `rollback!` restored nothing.
+    # @!visibility private
+    def initialize_copy(other)
+      super
+      @collection = other.instance_variable_get(:@collection).dup
+      # Pending relation operations (RelationCollectionProxy) are copied too.
+      %i[@additions @removals].each do |ivar|
+        next unless instance_variable_defined?(ivar)
+        value = instance_variable_get(ivar)
+        instance_variable_set(ivar, value.dup) if value.is_a?(Array)
+      end
+      @mutations_from_database = nil
+      @mutations_before_last_save = nil
+    end
+
     # true if the collection has been loaded
     def loaded?
       @loaded
@@ -81,10 +100,12 @@ module Parse
       params.nil? ? @delegate.send(method) : @delegate.send(method, params)
     end
 
-    # Reset the state of the collection.
+    # Reset the state of the collection. The items are dropped and the
+    # collection is marked as not loaded. This is not a change to the
+    # field, so it is not dirty tracked; use {#clear} to empty the field.
     def reset!
       @loaded = false
-      clear
+      @collection.clear
     end
 
     # @return [Boolean] true if two collection proxies have similar items.
@@ -102,9 +123,25 @@ module Parse
       collection #force reload
     end
 
-    # clear all items in the collection
+    # Remove all items from the collection. The field is marked as changed,
+    # so the next save stores the empty array.
+    # @return [Array] the (now empty) collection.
     def clear
+      notify_will_change!
       @collection.clear
+      @loaded = true
+      @collection
+    end
+
+    # Replace the contents of the collection with a new set of items, as
+    # Array#replace does. The field is marked as changed.
+    # @param items [Array] the new contents.
+    # @return [self]
+    def replace(items)
+      notify_will_change!
+      @collection = Array(items.is_a?(Parse::CollectionProxy) ? items.to_a : items).dup
+      @loaded = true
+      self
     end
 
     # @return [Array]
@@ -233,36 +270,60 @@ module Parse
 
     alias_method :delete, :remove
 
-    # Atomically adds all items from the array.
-    # This request is sent directly to the Parse backend.
-    # @param items [Array] items to uniquely add
+    # Atomically adds all items to the array field. The request is sent
+    # directly to the Parse backend. On success the local collection takes
+    # the array the server returned (or appends the items when the reply
+    # does not include the field) without marking the field as changed, so
+    # a later save does not overwrite the server array. On
+    # an owner that has not been saved yet there is nothing to update on
+    # the server, so the items are added locally as a normal change and
+    # sent with the next save.
+    # @param items [Array] items to add
     # @note Parse objects are automatically converted to pointer format
+    # @return [Boolean] whether the operation succeeded.
     # @see #add_unique!
     def add!(*items)
+      items = items.flatten
       return false unless @delegate.respond_to?(:op_add!)
-      @delegate.send :op_add!, @key, items_to_pointers(items.flatten)
-      reset!
+      return true if items.empty?
+      return add(*items) && true if unsaved_delegate?
+      apply_atomic_op(:op_add!, items) do |list, objs|
+        list + objs
+      end
     end
 
-    # Atomically adds all items from the array that are not already part of the collection.
-    # This request is sent directly to the Parse backend.
+    # Atomically adds the items that are not already part of the array
+    # field. The request is sent directly to the Parse backend. The local
+    # collection is updated as in {#add!}.
     # @param items [Array] items to uniquely add
     # @note Parse objects are automatically converted to pointer format
+    # @return [Boolean] whether the operation succeeded.
     # @see #add!
     def add_unique!(*items)
+      items = items.flatten
       return false unless @delegate.respond_to?(:op_add_unique!)
-      @delegate.send :op_add_unique!, @key, items_to_pointers(items.flatten)
-      reset!
+      return true if items.empty?
+      return add_unique(*items) && true if unsaved_delegate?
+      apply_atomic_op(:op_add_unique!, items) do |list, objs|
+        objs.each { |o| list << o unless list.include?(o) }
+        list
+      end
     end
 
-    # Atomically deletes all items from the array. This request is sent
-    # directly to the Parse backend.
+    # Atomically removes the items from the array field. The request is
+    # sent directly to the Parse backend. The local collection is updated
+    # as in {#add!}.
     # @param items [Array] items to remove
     # @note Parse objects are automatically converted to pointer format
+    # @return [Boolean] whether the operation succeeded.
     def remove!(*items)
+      items = items.flatten
       return false unless @delegate.respond_to?(:op_remove!)
-      @delegate.send :op_remove!, @key, items_to_pointers(items.flatten)
-      reset!
+      return true if items.empty?
+      return remove(*items) && true if unsaved_delegate?
+      apply_atomic_op(:op_remove!, items) do |list, objs|
+        list.reject { |x| objs.include?(x) }
+      end
     end
 
     # Atomically deletes all items in the array, and marks the field as `undefined` directly
@@ -276,8 +337,15 @@ module Parse
     end
 
     # Locally restores previous attributes (not from the persistent store)
+    # and clears the dirty tracking of the collection. The values are
+    # restored directly: going through the public writers would report a
+    # new change to the owner while undoing one.
     def rollback!
-      restore_attributes
+      changed.each do |attr|
+        instance_variable_set(:"@#{attr}", attribute_was(attr))
+      end
+      clear_changes_information
+      @collection
     end
 
     # clears all dirty tracked information.
@@ -416,6 +484,67 @@ module Parse
 
     private
 
+    # @return [Boolean] true when the owner has no objectId yet, so an
+    #   atomic server operation has nothing to apply to.
+    def unsaved_delegate?
+      @delegate.respond_to?(:id) && @delegate.id.blank?
+    end
+
+    # @return [Boolean] whether the owner reports this field as changed.
+    def delegate_field_dirty?
+      return false unless @delegate.respond_to?(:changed)
+      @delegate.changed.include?(@key.to_s)
+    rescue StandardError
+      false
+    end
+
+    # Run an atomic operation on the owner and, when it succeeds, apply the
+    # same change to the local collection without marking the field dirty.
+    # The block receives a copy of the current items and the operation's
+    # items and returns the new contents.
+    # @return [Boolean] whether the operation succeeded.
+    def apply_atomic_op(op, items)
+      return true if items.empty?
+      success = @delegate.send(op, @key, items_to_pointers(items))
+      return false unless success
+      # Read the owner's dirty state before touching the items, so a change
+      # that was already pending is still sent by the next save.
+      was_dirty = delegate_field_dirty?
+      # A clean array adopts the array the server returned, so a local copy
+      # that was already out of date is corrected. With unsaved local edits
+      # pending, adopting it would discard them, so the operation is applied
+      # locally instead (as it is for a reply without the field) and the
+      # pending edits are still sent on save.
+      server = was_dirty ? nil : server_array_after_op
+      @collection = server || yield(collection.to_a.dup, items)
+      @loaded = true
+      unless was_dirty
+        # Plain array properties detect in-place edits by comparing against
+        # a snapshot; take a new one so this update is not seen as an edit.
+        if @delegate.respond_to?(:_rebaseline_mutable_value!, true)
+          @delegate.send(:_rebaseline_mutable_value!, @key)
+        end
+      end
+      true
+    end
+
+    # The field's new array from the delegate's last atomic operation, when
+    # the server returned it.
+    # @return [Array, nil]
+    def server_array_after_op
+      return nil unless @delegate.respond_to?(:_last_operation_value, true)
+      value = @delegate.send(:_last_operation_value, @key)
+      value.is_a?(Array) ? adopt_server_items(value) : nil
+    end
+
+    # The local items for an array the server returned, or nil to apply the
+    # operation locally instead.
+    # @param value [Array] the field's array from the server's reply.
+    # @return [Array, nil]
+    def adopt_server_items(value)
+      Parse::Properties.deep_copy_value(value)
+    end
+
     # Convert items to pointer format for atomic operations.
     # Parse objects/pointers are converted to pointer hashes, other items pass through.
     # @param items [Array] items to convert