parse-stack-next 5.7.6 → 5.8.0

data/lib/parse/model/core/actions.rb

@@ -34,8 +34,10 @@ module Parse
       end
       hash_constraints = constraints(true)
 
-      klass.save_all(hash_constraints, &block) if block_given?
-      klass.save_all(hash_constraints)
+      # One call: with a block it saves what the block modifies; without one
+      # it force-saves every match. (Previously a block call also ran a
+      # second, forced pass over every matching record.)
+      klass.save_all(hash_constraints, &block)
     end
   end
 
@@ -99,6 +101,8 @@ module Parse
       # late for this: the public API documents mutating an object and adding it
       # afterwards.
       TRANSACTION_CONTEXT_KEY = :__parse_transaction_context__
+      # Parse Server error code for a transaction write conflict.
+      TRANSACTION_CONFLICT_CODE = 251
 
       # Distinguishes a property whose ivar did not exist from one explicitly
       # set to nil. Rollback removes the former instead of defining it as nil.
@@ -416,11 +420,22 @@ module Parse
         #     [user1, user2]  # Return array of objects to save
         #   end
         #
-        # @param retries [Integer] number of times to retry on transaction conflict (error 251)
+        # Transactions need MongoDB running as a replica set (or mongos) on
+        # the Parse Server side.
+        #
+        # @param retries [Integer] number of attempts on a transaction conflict
+        #   (error 251), which Parse Server reports only after rolling back.
+        # @param retry_server_errors [Boolean] also resend after a bare HTTP 500
+        #   from Parse Server. Parse Server answers both an aborted transaction
+        #   and a failed commit this way, and a commit can fail after it was
+        #   applied, so a resend can apply the transaction twice. Off by
+        #   default; enable it only for writes that are safe to repeat (it
+        #   works around Parse Server running a transaction's requests
+        #   concurrently, which MongoDB intermittently rejects).
         # @yield [Parse::BatchOperation] the batch operation to add requests to
         # @return [Array<Parse::Response>] the responses from the transaction
         # @raise [Parse::Error] if the transaction fails
-        def transaction(retries: 5, &block)
+        def transaction(retries: 5, retry_server_errors: false, &block)
           raise ArgumentError, "Block required for transaction" unless block_given?
 
           previous_context = Fiber[TRANSACTION_CONTEXT_KEY]
@@ -476,10 +491,45 @@ module Parse
             end
 
             # Submit with retry logic for transaction conflicts.
+            # Parse Server reports a write conflict inside a transaction as
+            # error code 251, after rolling it back. Retry on that structured
+            # code only (a per-request response code, or the code of the
+            # response an error carries).
             attempts = 0
-            begin
+            loop do
               attempts += 1
-              responses = batch.submit
+              begin
+                responses = batch.submit
+              rescue Parse::Error => e
+                # A conflict is recognized only from the structured Parse
+                # error code in the response, never from message text, so an
+                # unrelated "251" in an error message cannot trigger a resend.
+                conflict = e.respond_to?(:response) && e.response.respond_to?(:code) &&
+                           e.response.code.to_i == TRANSACTION_CONFLICT_CODE
+                # A bare 500 does not say whether the transaction was applied:
+                # Parse Server answers an aborted transaction and a failed
+                # commit (which may have been applied) the same way, and a
+                # 502/503/504 comes from a gateway that may have timed out
+                # after the commit. Only a 251 conflict is a confirmed
+                # rollback; a 500 is resent only when the caller opted in.
+                server_500 = e.is_a?(Parse::Error::ServiceUnavailableError) && e.http_status == 500
+                if (conflict || (server_500 && retry_server_errors)) && attempts < retries
+                  sleep(0.1 * attempts)
+                  next
+                end
+                # Name the likely causes rather than surfacing only "Internal
+                # server error". The original error is the cause.
+                if server_500
+                  raise Parse::Error,
+                        "Transaction failed: Parse Server answered 500 (#{e.message}) after " \
+                        "#{attempts} attempt(s). The transaction may or may not have been applied; " \
+                        "check before resending. Parse Server transactions need MongoDB running as " \
+                        "a replica set or mongos, and on a standalone server every transaction fails " \
+                        "this way; otherwise see the Parse Server log. For a non-atomic batch, save " \
+                        "the objects with Array#save instead."
+                end
+                raise
+              end
 
               if responses.all?(&:success?)
                 # Match responses to objects using the request tag (Ruby object_id).
@@ -511,13 +561,13 @@ module Parse
               end
 
               error_response = responses.find { |response| !response.success? }
-              raise Parse::Error, "Transaction failed: #{error_response.error}"
-            rescue Parse::Error => e
-              if e.message.include?("251") && attempts < retries
+              error_code = error_response&.code.to_i
+              if error_code == TRANSACTION_CONFLICT_CODE && attempts < retries
                 sleep(0.1 * attempts)
-                retry
+                next
               end
-              raise
+              detail = error_response&.error || "unknown error"
+              raise Parse::Error, "Transaction failed (code #{error_code}): #{detail}"
             end
           rescue StandardError
             original_states.each_value do |state|
@@ -989,59 +1039,60 @@ module Parse
           iterator_block = nil
           if block_given?
             iterator_block = block
-            force ||= false
           else
             # if no block given, assume you want to just save all objects
             # regardless of modification.
             force = true
           end
-          # Only generate the comparison block once.
-          # updated_comparison_block = Proc.new { |x| x.updated_at }
 
+          # Work on a copy so the caller's constraints hash is not mutated.
+          base_constraints = constraints.dup
           anchor_date = Parse::Date.now
-          constraints.merge! :updated_at.on_or_before => anchor_date
-          constraints.merge! cache: false
+          base_constraints[:updated_at.on_or_before] = anchor_date
+          base_constraints[:cache] = false
           # oldest first, so we create a reduction-cycle
-          constraints.merge! order: :updated_at.asc, limit: batch_size
-          update_query = query(constraints)
-          #puts "Setting Anchor Date: #{anchor_date}"
-          cursor = nil
+          base_constraints[:order] = :updated_at.asc
+          base_constraints[:limit] = batch_size
+
+          # Keyset cursor over (updated_at, objectId). Saved objects move past
+          # the anchor date and drop out of the query. Objects the block left
+          # unchanged keep their updated_at, so each page resumes at the last
+          # seen updated_at and excludes the ids already visited at exactly
+          # that timestamp. Every page therefore makes progress, and records
+          # the block does not modify are visited once instead of ending the
+          # run early.
+          cursor_time = nil
+          seen_at_cursor = []
           has_errors = false
           loop do
-            results = update_query.results
+            page_constraints = base_constraints.dup
+            if cursor_time
+              page_constraints[:updated_at.gte] = cursor_time
+              page_constraints[:objectId.nin] = seen_at_cursor if seen_at_cursor.any?
+            end
+            results = query(page_constraints).results
 
             break if results.empty?
 
-            # verify we didn't get duplicates fetches
-            if cursor.is_a?(Parse::Object) && results.any? { |x| x.id == cursor.id }
-              warn "[#{self}.save_all] Unbounded update detected with id #{cursor.id}."
-              has_errors = true
-              break cursor
-            end
-
             results.each(&iterator_block) if iterator_block.present?
             # we don't need to refresh the objects in the array with the results
             # since we will be throwing them away. Force determines whether
             # to save these objects regardless of whether they are dirty.
             batch = results.save(merge: false, force: force)
-
-            # faster version assuming sorting order wasn't messed up
-            cursor = results.last
-            # slower version, but more accurate
-            # cursor_item = results.max_by(&updated_comparison_block).updated_at
-            # puts "[Parse::SaveAll] Updated #{results.count} records updated <= #{cursor.updated_at}"
+            # Record failures before any break, so a failing last page is
+            # reported.
+            has_errors ||= batch.error?
 
             break if results.count < batch_size # we didn't hit a cap on results.
-            if cursor.is_a?(Parse::Object)
-              update_query.where :updated_at.gte => cursor.updated_at
 
-              if cursor.updated_at.present? && cursor.updated_at > anchor_date
-                warn "[#{self}.save_all] Reached anchor date  #{anchor_date} < #{cursor.updated_at}"
-                break cursor
-              end
+            last_time = results.last.updated_at
+            break if last_time.nil?
+            if cursor_time && last_time == cursor_time
+              seen_at_cursor.concat(results.map(&:id))
+            else
+              cursor_time = last_time
+              seen_at_cursor = results.select { |r| r.updated_at == last_time }.map(&:id)
             end
-
-            has_errors ||= batch.error?
           end
           not has_errors
         end
@@ -1073,9 +1124,22 @@ module Parse
         if response.error?
           puts "[#{parse_class}:#{field} Operation] #{response.error}"
         end
+        # Keep the server's reply so a caller can adopt the field's new value
+        # (Parse Server returns the whole array for Add/AddUnique/Remove).
+        @_last_operation_result = response.success? && response.result.is_a?(Hash) ? response.result : nil
         response.success?
       end
 
+      # @!visibility private
+      # The value Parse Server returned for `field` from the last
+      # {#operate_field!}, or nil when the reply did not include it.
+      def _last_operation_value(field)
+        result = @_last_operation_result
+        return nil unless result.is_a?(Hash)
+        wire = (self.field_map[field.to_sym] || field).to_s
+        result[wire]
+      end
+
       # Perform an atomic add operation to the array field.
       # @param field [String] the name of the field in the Parse collection.
       # @param objects [Array] the set of items to add to this field.
@@ -1150,20 +1214,27 @@ module Parse
         operate_field! field, relation_action
       end
 
-      # Atomically increment or decrement a specific field.
+      # Atomically increment or decrement a specific field. This is the one
+      # place the local value is updated after the server applies the
+      # increment; the `<field>_increment!` helpers delegate here.
       # @param field [String] the name of the field in the Parse collection.
-      # @param amount [Integer] the amoun to increment. Use negative values to decrement.
+      # @param amount [Numeric] the amount to increment. Use negative values to decrement.
+      #  Integer amounts are sent as integers; any other Numeric is sent as a Float
+      #  so fractional increments on Number columns are not truncated.
       # @see #operate_field!
       def op_increment!(field, amount = 1)
         unless amount.is_a?(Numeric)
           raise ArgumentError, "Amount should be numeric"
         end
-        result = operate_field! field, { __op: :Increment, amount: amount.to_i }.freeze
+        amount = amount.is_a?(Integer) ? amount : amount.to_f
+        result = operate_field! field, { __op: :Increment, amount: amount }.freeze
         if result
-          # Also update the local state to reflect the increment
+          # Also update the local state to reflect the increment.
+          # operate_field! does not touch local state.
           field_sym = field.to_sym
           current_value = self[field_sym] || 0
-          new_value = current_value + amount.to_i
+          current_value = 0 unless current_value.is_a?(Numeric)
+          new_value = current_value + amount
           set_attribute_method = "#{field}_set_attribute!"
           if respond_to?(set_attribute_method)
             send(set_attribute_method, new_value, true) # Set new value with dirty tracking
@@ -1190,19 +1261,47 @@ module Parse
 
       # Creates an array of all possible operations that need to be performed
       # on this object. This includes all property and relational operation changes.
+      #
+      # This is the path batch saves ({Array#save}) and
+      # {Parse::Object.transaction} use, so it applies the same save-time
+      # rules as {#save} that do not depend on callbacks:
+      # - a new object resolves its {Parse::Object.acl_policy} owner ACL
+      #   first, so batch-created records get the same ACL as single saves;
+      # - a new object sends its relation additions in the create body,
+      #   since there is no objectId yet for a separate relation PUT;
+      # - a reference to an unsaved object raises {Parse::RecordNotSaved}
+      #   instead of writing a pointer with a null objectId.
       # @param force [Boolean] whether this object should be saved even if does not have
       #  pending changes.
       # @return [Array<Parse::Request>] the list of API requests.
+      # @raise [Parse::RecordNotSaved] if a pointer, array or relation field
+      #  references an object that has not been saved.
       def change_requests(force = false)
         requests = []
         # get the URI path for this object.
         uri = self.uri_path
+        creating = new?
+
+        _resolve_default_acl if creating && respond_to?(:_resolve_default_acl, true)
+        _assert_no_unsaved_references!
+
+        if creating
+          body = attribute_updates
+          relation_additions = relation_changes? ? relation_change_operations.first : {}
+          if attribute_changes? || relation_additions.present? || force
+            body.merge!(relation_additions)
+            # Forward a client-assigned objectId, as {#create} does.
+            body[Parse::Model::OBJECT_ID] = @id if @id.present?
+            r = Request.new(:post, uri, body: body)
+            r.tag = object_id
+            requests << r
+          end
+          return requests
+        end
 
         # generate the request to update the object (PUT)
         if attribute_changes? || force
-          # if it's new, then we should call :post for creating the object.
-          method = new? ? :post : :put
-          r = Request.new(method, uri, body: attribute_updates)
+          r = Request.new(:put, uri, body: attribute_updates)
           r.tag = object_id
           requests << r
         end
@@ -1220,6 +1319,52 @@ module Parse
         requests
       end
 
+      # @!visibility private
+      # Names of changed fields that reference a Parse object without an
+      # objectId: a pointer field, an array of objects, or relation
+      # additions. Saving such a field would store a pointer whose objectId
+      # is null.
+      # @return [Array<String>]
+      def unsaved_reference_fields
+        unsaved = ->(v) { v.is_a?(Parse::Pointer) && v.id.blank? }
+        changed.each_with_object([]) do |key, list|
+          sym = key.to_sym
+          next unless fields[sym].present? || relations[sym].present?
+          value = instance_variable_get(:"@#{key}")
+          bad = if relations[sym].present?
+              value.respond_to?(:additions) && value.additions.any?(&unsaved)
+            elsif value.is_a?(Parse::CollectionProxy) || value.is_a?(Array)
+              value.to_a.any?(&unsaved)
+            else
+              unsaved.call(value)
+            end
+          list << key.to_s if bad
+        end
+      end
+
+      # @!visibility private
+      # @raise [Parse::RecordNotSaved] when {#unsaved_reference_fields} is not empty.
+      def _assert_no_unsaved_references!
+        fields_list = unsaved_reference_fields
+        return if fields_list.empty?
+        raise Parse::RecordNotSaved.new(self),
+              "#{parse_class} references unsaved object(s) in #{fields_list.join(", ")}. " \
+              "Save the referenced object(s) first."
+      end
+
+      # @!visibility private
+      # Refuses a write that would store a dangling pointer. Adds an error to
+      # {#errors} and returns false (save turns that into false, or raises
+      # with autoraise).
+      def _check_unsaved_references
+        fields_list = unsaved_reference_fields
+        return true if fields_list.empty?
+        fields_list.each do |f|
+          errors.add(f.to_sym, "references an unsaved object; save it first")
+        end
+        false
+      end
+
       # This methods sends an update request for this object with the any change
       # information based on its local attributes. The bang implies that it will send
       # the request even though it is possible no changes were performed. This is useful
@@ -1242,6 +1387,7 @@ module Parse
             self.updated_at_will_change! if respond_to?(:updated_at_will_change!)
           end
         end
+        return false unless _check_unsaved_references
         response = client.update_object(parse_class, id, attribute_updates, session_token: _session_token)
         @_last_response = response
         if response.success?
@@ -1279,6 +1425,9 @@ module Parse
       # @return [Boolean] true/false whether it was successful.
       def create
         run_callbacks :create do
+          # Checked after the before_save / before_create callbacks so a
+          # callback that saves the referenced object first still works.
+          next false unless _check_unsaved_references
           body = attribute_updates
           # Forward a client-assigned objectId when a `before_create` callback
           # set it (e.g. `parse_reference precompute: true`). attribute_updates
@@ -1293,9 +1442,14 @@ module Parse
           unless res.error?
             result = res.result
             @id = result[Parse::Model::OBJECT_ID] || @id
-            @created_at = result["createdAt"] || @created_at
+            # Store Parse::Date values, not the raw ISO strings. The :date
+            # property reader converts a String on read and marks the field
+            # dirty while doing so, which made a freshly created record
+            # report unsaved changes (and send an empty PUT on the next
+            # save) as soon as `updated_at` was read.
+            @created_at = _server_date(result["createdAt"]) || @created_at
             #if the object is created, updatedAt == createdAt
-            @updated_at = result["updatedAt"] || result["createdAt"] || @updated_at
+            @updated_at = _server_date(result["updatedAt"] || result["createdAt"]) || @updated_at
             # Because beforeSave hooks can change the fields we are saving, any items that were
             # changed, are returned to us and we should apply those locally to be in sync.
             set_attributes!(result)
@@ -1305,6 +1459,18 @@ module Parse
         end
       end
 
+      # @!visibility private
+      # Parse a server timestamp (ISO string or Parse date hash) into a
+      # Parse::Date. Returns nil for nil or unparseable input.
+      def _server_date(value)
+        return nil if value.nil?
+        return value if value.is_a?(Parse::Date)
+        value = value["iso"] || value[:iso] if value.is_a?(Hash)
+        Parse::Date.parse(value.to_s)
+      rescue ArgumentError
+        nil
+      end
+
       # @!visibility private
       def _session_token
         if @_session_token.respond_to?(:session_token)
@@ -1351,9 +1517,30 @@ module Parse
           raise Parse::Error::ProtocolError, error_msg
         end
 
+        # A destroyed record is never recreated by a later save (ActiveRecord
+        # returns false here too). Build a new object to write it again.
+        if destroyed?
+          if self.class.raise_on_save_failure || autoraise.present?
+            raise Parse::RecordNotSaved.new(self), "Cannot save a destroyed #{parse_class} (id '#{@id}')."
+          end
+          return false
+        end
+
         @_session_token = _validate_session_token! session, :save
         return true unless changed? || force
 
+        # A create may assign the objectId client-side from a callback
+        # (parse_reference precompute, acl_owner :self). Until the create
+        # returns createdAt, persisted? must stay false for such an object.
+        @_creating_record = true if @id.blank?
+        _save_with_callbacks(autoraise: autoraise, force: force, validate: validate)
+      ensure
+        remove_instance_variable(:@_creating_record) if defined?(@_creating_record)
+      end
+
+      # @!visibility private
+      # Body of {#save} after the deleted-object, session and no-change checks.
+      def _save_with_callbacks(autoraise:, force:, validate:)
         # Run validations (validation callbacks are now triggered by valid? method)
         # Pass context so `on: :create` and `on: :update` options work with callbacks
         if validate
@@ -1376,7 +1563,9 @@ module Parse
           callback_executed = true
           #first process the create/update action if any
           #then perform any relation changes that need to be performed
-          success = new? ? create : perform_update(force: force)
+          was_new = new?
+          success = was_new ? create : perform_update(force: force)
+          saved_fields = changed.map(&:to_sym)
 
           # if the save was successful and we have relational changes
           # let's update send those next.
@@ -1388,13 +1577,13 @@ module Parse
               success = update_relations
               if success
                 changes_applied!
-                clear_partial_fetch_state!
+                _after_save_partial_fetch_state!(was_new, saved_fields)
               elsif self.class.raise_on_save_failure || autoraise.present?
                 raise Parse::RecordNotSaved.new(self), "Failed updating relations. #{self.parse_class} partially saved."
               end
             else
               changes_applied!
-              clear_partial_fetch_state!
+              _after_save_partial_fetch_state!(was_new, saved_fields)
             end
           elsif self.class.raise_on_save_failure || autoraise.present?
             raise Parse::RecordNotSaved.new(self), "Failed to create or save attributes. #{self.parse_class} was not saved."
@@ -1427,6 +1616,11 @@ module Parse
 
       # Delete this record from the Parse collection. Only valid if this object has an `id`.
       # This will run all the `destroy` callbacks.
+      #
+      # After a successful destroy the object keeps its `id`, {Parse::Object#destroyed?}
+      # returns true and {Parse::Object#persisted?} returns false. Saving a destroyed
+      # object is refused: {#save} returns false and {#save!} raises
+      # {Parse::RecordNotSaved}, as in ActiveRecord.
       # @param session [String] a session token if you want to apply ACLs for a user in this operation.
       # @raise ArgumentError if a non-nil value is passed to `session` that doesn't provide a session token string.
       # @return [Boolean] whether the operation was successful.
@@ -1438,7 +1632,11 @@ module Parse
           res = client.delete_object parse_class, id, session_token: _session_token
           success = res.success?
           if success
-            @id = nil
+            # Keep the objectId so `dom_id`, `to_key` and Turbo Stream
+            # removals still identify the record, and mark it destroyed so
+            # `persisted?` is false and a later `save` refuses rather than
+            # recreating it.
+            @_destroyed = true
             changes_applied!
           elsif self.class.raise_on_save_failure
             raise Parse::RecordNotSaved.new(self), "Failed to create or save attributes. #{self.parse_class} was not saved."
@@ -1553,20 +1751,24 @@ module Parse
       # Clears changes information on all collections (array and relations) and all
       # local attributes.
       def changes_applied!
-        # find all fields that are of type :array
-        fields(:array) do |key, v|
-          proxy = send(key)
-          # clear changes
-          proxy.changes_applied! if proxy.respond_to?(:changes_applied!)
-        end
-
-        # for all relational fields,
-        relations.each do |key, v|
-          proxy = send(key)
-          # clear changes if they support the method.
+        # Settle the array and relation proxies that exist. Read the ivar
+        # rather than the getter: the getter can autofetch a pointer or
+        # build an empty proxy, and neither has changes to settle. A
+        # relation proxy also drops its saved additions and removals here,
+        # so a later save does not send them again.
+        (fields(:array).keys + relations.keys).uniq.each do |key|
+          ivar = :"@#{key}"
+          next unless instance_variable_defined?(ivar)
+          proxy = instance_variable_get(ivar)
           proxy.changes_applied! if proxy.respond_to?(:changes_applied!)
         end
         changes_applied
+        # The saved ACL is the new baseline. Without this, the snapshot from
+        # before the first edit survived the save, so `acl_was` kept
+        # reporting the pre-save ACL: revoking a grant after saving it
+        # compared equal to that stale snapshot, `acl_changed?` was false,
+        # and the revocation was silently dropped while save returned true.
+        @_acl_snapshot_before_change = nil
       end
     end
   end

data/lib/parse/model/core/builder.rb

@@ -89,6 +89,9 @@ module Parse
         if klass.nil?
           klass = ::Class.new(Parse::Object)
           Parse::Generated.const_set(parse_class_name, klass)
+          # The default parse_class comes from the Ruby name, which here is
+          # namespaced ("Parse::Generated::Post"). Bind the server class name.
+          klass.parse_class(className.to_s)
         end
         unless klass.is_a?(Class) && klass <= Parse::Object
           raise ArgumentError, "Resolved class #{klass.inspect} for #{className.inspect} is not a Parse::Object subclass"
@@ -106,22 +109,111 @@ module Parse
         class_fields = klass.field_map.values + [:className]
         fields.each do |field, type|
           field = field.to_sym
-          key = field.to_s.underscore.to_sym
           next if base_fields.include?(field) || class_fields.include?(field)
+          next unless type.respond_to?(:[]) && type[:type].present?
 
-          data_type = type[:type].downcase.to_sym
-          if data_type == :pointer
-            klass.belongs_to key, as: safe_target_class(type[:targetClass]), field: field
-          elsif data_type == :relation
-            klass.has_many key, through: :relation, as: safe_target_class(type[:targetClass]), field: field
-          else
-            klass.property key, data_type, field: field
+          data_type = type[:type].to_s.downcase.to_sym
+          # A model's field registry shares one namespace between Ruby
+          # names and server columns, so a column whose name another column
+          # already claimed as its Ruby name (`foo_bar` after `fooBar`)
+          # cannot be mapped. Skip it instead of aborting the whole build.
+          if klass.fields.key?(field) || klass.field_map.key?(field)
+            builder_warn "skipping column #{className}.#{field}: its name is already " \
+                         "used by another column of the same class"
+            next
+          end
+          key = safe_accessor_name(klass, field, data_type)
+          next if key.nil?
+
+          begin
+            if data_type == :pointer
+              klass.belongs_to key, as: safe_target_class(type[:targetClass]), field: field
+            elsif data_type == :relation
+              klass.has_many key, through: :relation, as: safe_target_class(type[:targetClass]), field: field
+            else
+              # A renamed accessor must not get an alias under the column
+              # name, which is the method it was renamed to avoid.
+              opts = { field: field }
+              opts[:alias] = false if key.to_s != field.to_s.underscore
+              klass.property key, data_type, **opts
+            end
+          rescue StandardError, SystemStackError => e
+            builder_warn "skipping column #{className}.#{field}: #{e.class}: #{e.message}"
+            next
+          end
+          # Hydration from server JSON dispatches on `<column>_set_attribute!`.
+          # The association and property DSLs only alias that hook when the
+          # column name itself is free as a method, so add it for a renamed
+          # accessor (`class` -> `class_field`).
+          setter = :"#{field}_set_attribute!"
+          target = :"#{key}_set_attribute!"
+          if setter != target && !klass.method_defined?(setter) && klass.method_defined?(target)
+            klass.send(:alias_method, setter, target)
           end
           class_fields.push(field)
         end
         klass
       end
 
+      # Suffix appended to a column's Ruby accessor name when the natural
+      # (underscored) name is unusable.
+      RENAMED_ACCESSOR_SUFFIX = "_field"
+
+      # @!visibility private
+      # Chooses the Ruby accessor name for server column `field`. The natural
+      # name is `field.underscore`. It is replaced with `<name>_field` (then
+      # `<name>_field2`, ...) when it would shadow a method every
+      # Parse::Object relies on (`class`, `hash`, `save`, `send`,
+      # `object_id`, `changes`, ...), when a boolean column's class-level
+      # scope would shadow a class method (`freeze`, `name`), or when another
+      # column already claimed it (`fooBar` and `foo_bar` both underscore to
+      # `foo_bar`). The server column name is unchanged (it is kept with
+      # `field:`). Returns nil, after a warning, when no safe name exists.
+      # @return [Symbol, nil]
+      def self.safe_accessor_name(klass, field, data_type)
+        natural = field.to_s.underscore
+        unless natural.match?(/\A[a-z_][a-zA-Z0-9_]*\z/)
+          builder_warn "skipping column #{klass.parse_class}.#{field}: not a valid Ruby method name"
+          return nil
+        end
+        candidates = [natural, "#{natural}#{RENAMED_ACCESSOR_SUFFIX}"]
+        candidates.concat((2..9).map { |n| "#{natural}#{RENAMED_ACCESSOR_SUFFIX}#{n}" })
+        name = candidates.find { |c| !accessor_conflict?(klass, c.to_sym, data_type) }
+        if name.nil?
+          builder_warn "skipping column #{klass.parse_class}.#{field}: no free Ruby accessor name"
+          return nil
+        end
+        if name != natural
+          builder_warn "column #{klass.parse_class}.#{field} is exposed as ##{name} " \
+                       "because ##{natural} would clash with an existing method or column"
+        end
+        name.to_sym
+      end
+
+      # @!visibility private
+      # Whether defining accessor `key` on `klass` would replace an existing
+      # method or reuse a name another column already maps to.
+      def self.accessor_conflict?(klass, key, data_type)
+        return true if klass.fields.key?(key) || klass.field_map.key?(key)
+        return true if klass.respond_to?(:relations) && klass.relations.key?(key)
+        instance_names = [key, :"#{key}=", :"#{key}_changed?", :"#{key}_was"]
+        instance_names << :"#{key}?" if data_type == :boolean
+        return true if instance_names.any? { |m| method_taken?(klass, m) }
+        # Boolean columns also get a class-level scope named after the key.
+        return true if data_type == :boolean && klass.respond_to?(key, true)
+        false
+      end
+
+      # @!visibility private
+      def self.method_taken?(klass, name)
+        klass.method_defined?(name) || klass.private_method_defined?(name)
+      end
+
+      # @!visibility private
+      def self.builder_warn(message)
+        warn "[Parse::Model::Builder] #{message}"
+      end
+
       # @!visibility private
       # Validates a server-returned `targetClass` string before forwarding
       # it to `belongs_to`/`has_many`. Returns `nil` for missing or