parse-stack-next 5.7.6 → 5.8.0

data/lib/parse/model/object.rb

@@ -387,10 +387,21 @@ module Parse
       # @return [String] the name of the Parse collection for this model.
       def parse_class(remoteName = nil)
         @parse_class ||= model_name.name
-        @parse_class = remoteName.to_s unless remoteName.nil?
+        unless remoteName.nil?
+          @parse_class = remoteName.to_s
+          Parse::Model.model_registry_changed!
+        end
         @parse_class
       end
 
+      # @!visibility private
+      # A new model can answer a class name {Parse::Model.find_class} already
+      # recorded as a miss, so the registry caches are reset.
+      def inherited(subclass)
+        super
+        Parse::Model.model_registry_changed!
+      end
+
       # The set of default ACLs to be applied on newly created instances of this class.
       # The result follows the class's {acl_policy_setting}: the shipped default
       # policy is `:owner_else_private`, whose fallback half is {Parse::ACL.private}
@@ -1352,6 +1363,13 @@ module Parse
       # the trust signal here.
       trusted = @_trusted_init == true
       @_trusted_init = nil
+      # Accept hash-like input that is not a Hash: Rails strong parameters
+      # (`ActionController::Parameters`) and Struct / OpenStruct values.
+      # Strong parameters raise from `to_h` when unpermitted, so
+      # strong-parameter filtering still applies. Other objects that merely
+      # respond to `to_h` (Set, Range, Array) are ignored as before rather
+      # than converted.
+      opts = opts.to_h if self.class.hash_like_init_input?(opts)
       input_hash = opts.is_a?(Hash) ? opts : nil
       input_had_acl = input_hash && %w[ACL acl].any? do |key|
         input_hash.key?(key) || input_hash.key?(key.to_sym)
@@ -1362,13 +1380,24 @@ module Parse
       if opts.is_a?(String) #then it's the objectId
         @id = opts.to_s
       elsif opts.is_a?(Hash)
-        # Pop the `:as` option (also accepts string key) before applying
-        # attributes so it is not mistaken for a model property. This holds
-        # the caller-supplied owner user for save-time ACL resolution.
-        acl_owner_override = opts.delete(:as) || opts.delete("as")
+        # Pop the `as:` option before applying attributes so it is not
+        # mistaken for a model property. It holds the caller-supplied owner
+        # user for save-time ACL resolution, so only a Symbol key written
+        # in code is honored. A String "as" key (form or JSON params, or any
+        # key of a HashWithIndifferentAccess) is removed and ignored: a
+        # request body must not be able to pick the ACL owner, e.g.
+        # `{"as" => "*"}` to make the record public.
+        if opts.key?(:as) || opts.key?("as")
+          symbol_key = !opts.is_a?(ActiveSupport::HashWithIndifferentAccess) && opts.key?(:as)
+          acl_owner_override = symbol_key ? opts[:as] : nil
+          opts = opts.dup
+          opts.delete(:as)
+          opts.delete("as")
+          self.class.validate_acl_owner_option!(acl_owner_override) unless acl_owner_override.nil?
+        end
         #if the objectId is provided we will consider the object pristine
         #and not track dirty items
-        dirty_track = opts[Parse::Model::OBJECT_ID] || opts[:objectId] || opts[:id]
+        dirty_track = opts[Parse::Model::OBJECT_ID] || opts[:objectId] || opts[:id] || opts[Parse::Model::ID]
         # Always filter the narrow PROTECTED_INITIALIZE_KEYS set unless
         # the caller is a trusted hydration path. Decoupled from
         # dirty_track so an objectId-bearing hash from a controller,
@@ -1398,11 +1427,18 @@ module Parse
       # self-write-plus-public-read ACL on signup; stamping any value from
       # the SDK side (even `{}`) overrides that and locks the new user out
       # of editing their own profile without the master key.
+      #
+      # A trusted hydration of an existing row (server JSON with an objectId)
+      # is also exempt. A row without an `ACL` key is public on the server,
+      # so stamping the local default would misreport it (usually as
+      # private). Such a row is never ACL-pristine either: the save-time
+      # resolver must not replace the ACL of a record that already exists.
+      server_row = trusted && input_had_id
       acl_was_user_supplied = !self.acl.nil?
-      unless self.class.builtin_acl_default_active?
+      unless self.class.builtin_acl_default_active? || server_row
         self.acl = self.class.default_acls.as_json if self.acl.nil?
       end
-      @_acl_pristine = !acl_was_user_supplied
+      @_acl_pristine = !acl_was_user_supplied && !server_row
       @_acl_owner_override = acl_owner_override
 
       # Record where our ACL knowledge came from. `acl.nil?` alone is not
@@ -1467,11 +1503,89 @@ module Parse
       Parse::Pointer.new self.parse_class, id
     end
 
-    # Determines if this object has been saved to the Parse database. If an object has
-    # pending changes, then it is considered to not yet be persisted.
-    # @return [Boolean] true if this object has not been saved.
+    # Whether this object exists on the server, in the ActiveModel sense
+    # (`form_with` uses it to choose between create and update). An object
+    # with an objectId is persisted even when it has unsaved changes or was
+    # built without timestamps (a pointer or an id-only instance). Use
+    # {#changed?} to ask whether there are unsaved changes.
+    #
+    # The one exception is an objectId assigned client-side during a create
+    # (`parse_reference precompute: true`, `acl_owner :self`): the object
+    # is not persisted until the create succeeds and returns `createdAt`.
+    #
+    # A destroyed object is not persisted, matching ActiveModel's
+    # `persisted? == !new_record? && !destroyed?` contract.
+    # @return [Boolean] true if this object exists on the server.
     def persisted?
-      changed? == false && !(@id.nil? || @created_at.nil? || @updated_at.nil? || @acl.nil?)
+      return false if @id.blank?
+      return false if destroyed?
+      return @created_at.present? if defined?(@_creating_record) && @_creating_record
+      true
+    end
+
+    # Whether this object was deleted from the server by a successful
+    # {#destroy}. A destroyed object keeps its objectId (so `dom_id`,
+    # `to_key` and Turbo Stream removals keep working) but is no longer
+    # {#persisted?}, and {#save} refuses to write it.
+    # @return [Boolean]
+    def destroyed?
+      @_destroyed == true
+    end
+
+    # An ActiveRecord-compatible cache key: `"<collection>/<objectId>"` for an
+    # object with an id, `"<collection>/new"` otherwise. The collection
+    # segment comes from `model_name.cache_key` (for example `"songs"` or
+    # `"music/albums"`), so records of different classes that share an
+    # objectId never collide in a fragment cache.
+    # @return [String]
+    def cache_key
+      prefix = self.class.model_name.cache_key
+      @id.present? ? "#{prefix}/#{@id}" : "#{prefix}/new"
+    end
+
+    # The cache version, derived from `updated_at` in the same
+    # `"%Y%m%d%H%M%S%6N"` form ActiveRecord uses. Returns nil when the
+    # object has no `updated_at` (new or pointer-state objects). Reads the
+    # stored value directly, so it never triggers an autofetch or changes
+    # dirty state.
+    # @return [String, nil]
+    def cache_version
+      value = @updated_at
+      value = Parse::Date.parse(value) if value.is_a?(String)
+      return nil unless value.respond_to?(:to_time)
+      value.to_time.utc.strftime("%Y%m%d%H%M%S%6N")
+    rescue ArgumentError
+      nil
+    end
+
+    # The cache key with the {#cache_version} appended, as in ActiveRecord.
+    # @return [String]
+    def cache_key_with_version
+      version = cache_version
+      version ? "#{cache_key}-#{version}" : cache_key
+    end
+
+    # The current values of this object's properties, keyed by local
+    # attribute name (as Strings).
+    #
+    # {#attributes} returns the property TYPE map (`{"title" => :string}`
+    # style, with Symbol keys). That shape is load-bearing: ActiveModel
+    # serialization reads its keys and then calls each reader, and
+    # {#as_json} depends on it. This method is the value form. It reads the
+    # stored values directly, so it never autofetches a pointer, never
+    # applies defaults, and never changes dirty state; an unfetched field
+    # reads as nil.
+    # @return [Hash{String => Object}]
+    def attribute_values
+      self.class.fields.each_key.with_object({}) do |key, h|
+        ivar = :"@#{key}"
+        next unless self.class.field_map.key?(key)
+        value = instance_variable_defined?(ivar) ? instance_variable_get(ivar) : nil
+        if value.is_a?(String) && self.class.fields[key] == :date
+          value = (Parse::Date.parse(value) rescue value)
+        end
+        h[key.to_s] = value
+      end
     end
 
     # Force reload from the database and replace any local fields with data from
@@ -1618,7 +1732,9 @@ module Parse
         @_fetched_keys = nil
       else
         # Always include :id and convert to symbols
-        @_fetched_keys = keys.map { |k| Parse::Query.format_field(k).to_sym }
+        @_fetched_keys = Parse::Query.with_field_aliases(parse_class) do
+          keys.map { |k| Parse::Query.format_field(k).to_sym }
+        end
         @_fetched_keys << :id unless @_fetched_keys.include?(:id)
         @_fetched_keys << :objectId unless @_fetched_keys.include?(:objectId)
         @_fetched_keys.uniq!
@@ -1641,7 +1757,15 @@ module Parse
       key = key.to_sym
       # Base keys are always considered fetched
       return true if Parse::Properties::BASE_KEYS.include?(key)
-      return true if key == :acl || key == :ACL
+      # The ACL counts as fetched only when the selective response carried
+      # it. Treating it as always present made `acl` read nil on a partial
+      # fetch, so `(obj.acl || Parse::ACL.new).apply(...)` replaced the
+      # record's real ACL with a single grant on save. Reading it now
+      # autofetches like any other field the partial fetch left out.
+      if key == :acl || key == :ACL
+        return @_fetched_keys.include?(:ACL) || @_fetched_keys.include?(:acl) ||
+               instance_variable_get(:@_authorization_acl_state) != :unknown
+      end
 
       # Check both local key and remote field name
       # Convert remote_key to symbol for consistent comparison
@@ -1704,8 +1828,25 @@ module Parse
       @_nested_fetched_keys[field_name]
     end
 
+    # @!visibility private
+    # Partial-fetch tracking after a successful save. A create leaves a fully
+    # known object. An update returns only `updatedAt`, so fields the partial
+    # fetch never loaded (the ACL among them) are still unknown: keep the
+    # tracking, and count the fields just written as known. Clearing it made
+    # an unloaded `acl` read nil, and a grant added to that nil replaced the
+    # record's existing grants on the next save.
+    # @param was_new [Boolean] whether the save created the object.
+    # @param saved_fields [Array<Symbol>] the fields the save wrote.
+    # @return [void]
+    def _after_save_partial_fetch_state!(was_new, saved_fields)
+      if was_new || !has_selective_keys?
+        clear_partial_fetch_state!
+        return
+      end
+      @_fetched_keys = (@_fetched_keys + Array(saved_fields).map(&:to_sym)).uniq
+    end
+
     # Clears all partial fetch tracking state.
-    # Called after successful save since server returns updated object.
     # @return [void]
     def clear_partial_fetch_state!
       @_fetched_keys = nil
@@ -1777,9 +1918,73 @@ module Parse
     # @note This does not reload the object from the persistent store, for this use "reload!" instead.
     # @see #reload!
     def rollback!
+      snapshot = defined?(@_acl_snapshot_before_change) ? @_acl_snapshot_before_change : nil
       restore_attributes
+      # ACL edits are usually made in place (`acl.apply`, `acl.delete`), so
+      # the value ActiveModel restores may be the edited object itself.
+      # Restore from the pre-change snapshot instead, and drop the snapshot
+      # so a later edit captures a fresh baseline.
+      @acl = Parse::ACL.typecast(snapshot.as_json, self) if snapshot && !@acl.nil?
+      @_acl_snapshot_before_change = nil
+    end
+
+    # Keys that mass assignment never applies to an object: the objectId
+    # under its local and remote names. An existing object's id must not be
+    # retargeted by a params hash (`{"id" => "victim"}` would redirect the
+    # next save to another record). A new object gets an id only through
+    # the constructor, {Parse::Object.build}, or an explicit `id=` call.
+    PROTECTED_IDENTITY_KEYS = %w[id objectId].freeze
+
+    # Mass-assign attributes with dirty tracking (the Rails form path).
+    # Filters {Parse::Properties::PROTECTED_MASS_ASSIGNMENT_KEYS} (session
+    # token, roles, ACL row permissions, auth data, timestamps, className)
+    # and {PROTECTED_IDENTITY_KEYS}. Accepts a Hash or hash-like input such as
+    # permitted `ActionController::Parameters` (unpermitted parameters raise
+    # from `to_h`).
+    # @param hash [Hash]
+    def attributes=(hash)
+      hash = hash.to_h if self.class.hash_like_init_input?(hash)
+      return unless hash.is_a?(Hash)
+      super(_without_identity_keys(hash))
+    end
+
+    # @!visibility private
+    # Strips {PROTECTED_IDENTITY_KEYS} on every mass-assignment
+    # (`dirty_track: true`) call, and on hydration once the object already
+    # has an id. Hydration of an object without an id (the constructor,
+    # {Parse::Object.build}) may still set it.
+    def apply_attributes!(hash, dirty_track: false, filter_protected: nil, protected_set: nil)
+      if hash.is_a?(Hash) && (dirty_track || @id.present?)
+        hash = _without_identity_keys(hash)
+      end
+      super(hash, dirty_track: dirty_track, filter_protected: filter_protected, protected_set: protected_set)
+    end
+
+    private
+
+    # ActiveModel's `assign_attributes` funnels through this method after
+    # its strong-parameters check. Apply the same protected-key filter as
+    # {#attributes=} so `assign_attributes("session_token" => …, "id" => …,
+    # "created_at" => …)` cannot set those fields.
+    def _assign_attributes(attributes)
+      if attributes.key?("ACL") || attributes.key?("acl") || attributes.key?(:ACL) || attributes.key?(:acl)
+        Parse::Properties.warn_acl_mass_assignment_once!
+      end
+      blocked = Parse::Properties::PROTECTED_MASS_ASSIGNMENT_KEYS
+      filtered = attributes.reject do |key, _|
+        name = key.to_s
+        blocked.include?(name) || PROTECTED_IDENTITY_KEYS.include?(name)
+      end
+      super(filtered)
+    end
+
+    def _without_identity_keys(hash)
+      return hash unless hash.any? { |key, _| PROTECTED_IDENTITY_KEYS.include?(key.to_s) }
+      hash.reject { |key, _| PROTECTED_IDENTITY_KEYS.include?(key.to_s) }
     end
 
+    public
+
     # Overrides ActiveModel::Validations#validate! instance method.
     # It runs all validations for this object. If validation fails,
     # it raises ActiveModel::ValidationError otherwise it returns the object.
@@ -1877,7 +2082,9 @@ module Parse
         o.instance_variable_set(:@_nested_fetched_keys, nested_fetched_keys) if nested_fetched_keys.present?
         if fetched_keys.present?
           # Process fetched_keys like the setter does - convert to symbols and include :id
-          processed_keys = fetched_keys.map { |k| Parse::Query.format_field(k).to_sym }
+          processed_keys = Parse::Query.with_field_aliases(klass.parse_class) do
+            fetched_keys.map { |k| Parse::Query.format_field(k).to_sym }
+          end
           processed_keys << :id unless processed_keys.include?(:id)
           processed_keys << :objectId unless processed_keys.include?(:objectId)
           processed_keys.uniq!
@@ -2025,10 +2232,51 @@ module Parse
         return owner.id if owner.id.present?
         return nil
       end
-      return owner if owner.is_a?(String) && owner.present?
+      return owner if self.class.acl_owner_id_string?(owner)
       nil
     end
 
+    class << self
+      # @!visibility private
+      # Whether `opts` is hash-like input that {#initialize} converts with
+      # `to_h`: Rails strong parameters (`permitted?` / `to_unsafe_h`) or a
+      # Struct / OpenStruct. Hash, String, Array and nil are handled by
+      # {#initialize} directly; other objects are not converted.
+      def hash_like_init_input?(opts)
+        return false if opts.nil? || opts.is_a?(Hash) || opts.is_a?(String) || opts.is_a?(Array)
+        return false unless opts.respond_to?(:to_h)
+        return true if opts.respond_to?(:permitted?) || opts.respond_to?(:to_unsafe_h)
+        return true if opts.is_a?(Struct)
+        defined?(::OpenStruct) && opts.is_a?(::OpenStruct) ? true : false
+      end
+
+      # @!visibility private
+      # Whether `value` is usable as a raw user objectId for an ACL owner.
+      # Refuses the public key "*" and role keys ("role:Name"), which would
+      # grant the record to everyone or to a role instead of to one user.
+      def acl_owner_id_string?(value)
+        value.is_a?(String) && value.present? && value != "*" && !value.start_with?("role:")
+      end
+
+      # @!visibility private
+      # Validates the `as:` owner option given to {#initialize}. Accepts a
+      # Parse::User, a Parse::Pointer to `_User` with an objectId, or a raw
+      # user objectId String.
+      # @raise [ArgumentError] for any other value.
+      def validate_acl_owner_option!(owner)
+        if owner.is_a?(Parse::Pointer)
+          return if owner.parse_class == Parse::Model::CLASS_USER && owner.id.present?
+          raise ArgumentError,
+                "as: must be a Parse::User or a pointer to _User with an objectId " \
+                "(got a #{owner.parse_class} #{owner.class})."
+        end
+        return if acl_owner_id_string?(owner)
+        raise ArgumentError,
+              "as: must be a Parse::User, a pointer to _User, or a user objectId String; " \
+              "the public key \"*\" and role keys are not accepted."
+      end
+    end
+
     set_callback :save, :before, :_resolve_default_acl
 
     # Override acl_will_change! to capture a snapshot of the ACL before modification.

data/lib/parse/model/phone.rb

@@ -71,7 +71,25 @@ module Parse
     # Regex to strip non-digit characters (except +)
     STRIP_NON_DIGITS = /[^\d+]/
 
+    # A 10-digit North American Numbering Plan number: area code and
+    # exchange code each start with 2-9.
+    NANP_NATIONAL = /\A[2-9]\d{2}[2-9]\d{6}\z/
+
     class << self
+      # Country calling code (digits only, no `+`) assumed for numbers
+      # entered without a leading `+`. Defaults to `"1"` (North America),
+      # under which 10-digit numbers get `+1`. Set to another code (for
+      # example `"44"`) to apply that country to national numbers, or to
+      # `nil` to make no assumption, in which case a national number
+      # without `+` is left unprefixed and fails validation.
+      # @return [String, nil]
+      attr_writer :default_country_code
+
+      # @return [String, nil] see {default_country_code=}.
+      def default_country_code
+        defined?(@default_country_code) ? @default_country_code : "1"
+      end
+
       # Check if phonelib is available for enhanced validation
       # @return [Boolean] true if phonelib gem is loaded
       def phonelib_available?
@@ -131,7 +149,25 @@ module Parse
     end
 
     # Normalize a phone number string to E.164 format.
-    # Removes all non-digit characters except leading +.
+    # Removes all non-digit characters except a leading +.
+    #
+    # Input that already starts with `+` is kept as dialed. Input without
+    # a `+` is resolved as follows, identically with and without phonelib
+    # (phonelib parses the normalized result):
+    #
+    # 1. A leading `00` (international access prefix) becomes `+`.
+    # 2. With {Parse::Phone.default_country_code} set to `"1"` (the
+    #    default), a 10-digit North American number (`4155551234`,
+    #    `(415) 555-1234`) becomes `+14155551234`, and an 11-digit number
+    #    starting with `1` gets a `+`.
+    # 3. Any other number of 11 or more digits that does not start with
+    #    `0` is assumed to already include its country code.
+    # 4. A shorter national number (or one with a leading trunk `0`) gets
+    #    the default country code, minus the trunk `0`, when that code is
+    #    not `"1"`. With no default country code it is left without a `+`
+    #    so it fails validation instead of being read as some other
+    #    country's code (previously `4155551234` became the Swiss
+    #    `+41 55 551 234`).
     #
     # @param value [String] the phone number string
     # @return [String, nil] the normalized number or nil if invalid
@@ -140,12 +176,25 @@ module Parse
 
       # Remove all non-digit characters except +
       cleaned = value.to_s.gsub(STRIP_NON_DIGITS, "")
+      return cleaned if cleaned.start_with?("+")
 
-      # If it doesn't start with +, add it
-      cleaned = "+#{cleaned}" unless cleaned.start_with?("+")
+      digits = cleaned.delete("+")
+      return "+#{digits}" if digits.empty?
+      return "+#{digits[2..]}" if digits.start_with?("00")
 
-      # Return the cleaned value (may still be invalid, but we store it)
-      cleaned
+      default_cc = Parse::Phone.default_country_code.to_s.delete("+").presence
+      if default_cc == "1"
+        return "+1#{digits}" if NANP_NATIONAL.match?(digits)
+        return "+#{digits}" if digits.length == 11 && digits.start_with?("1") && NANP_NATIONAL.match?(digits[1..])
+      end
+
+      return "+#{digits}" if digits.length >= 11 && !digits.start_with?("0")
+
+      if default_cc && default_cc != "1"
+        "+#{default_cc}#{digits.sub(/\A0/, "")}"
+      else
+        digits
+      end
     end
 
     # @return [String, nil] the E.164 formatted phone number

data/lib/parse/model/pointer.rb

@@ -216,7 +216,9 @@ module Parse
       # Build query parameters for partial fetch
       query = {}
       if keys.present?
-        keys_array = Array(keys).map { |k| Parse::Query.format_field(k) }
+        keys_array = Parse::Query.with_field_aliases(parse_class) do
+          Array(keys).map { |k| Parse::Query.format_field(k) }
+        end
         query[:keys] = keys_array.join(",")
       end
       if includes.present?
@@ -246,7 +248,9 @@ module Parse
       # For partial fetch, build with fetched_keys tracking
       if keys.present?
         # Parse keys to get top-level field names and nested keys
-        top_level_keys = Array(keys).map { |k| Parse::Query.format_field(k).split(".").first.to_sym }
+        top_level_keys = Parse::Query.with_field_aliases(parse_class) do
+          Array(keys).map { |k| Parse::Query.format_field(k).split(".").first.to_sym }
+        end
         top_level_keys << :id unless top_level_keys.include?(:id)
         top_level_keys << :objectId unless top_level_keys.include?(:objectId)
         top_level_keys.uniq!
@@ -278,7 +282,9 @@ module Parse
     def fetch_json(keys: nil, includes: nil)
       query = {}
       if keys.present?
-        keys_array = Array(keys).map { |k| Parse::Query.format_field(k) }
+        keys_array = Parse::Query.with_field_aliases(parse_class) do
+          Array(keys).map { |k| Parse::Query.format_field(k) }
+        end
         query[:keys] = keys_array.join(",")
       end
       if includes.present?
@@ -314,10 +320,15 @@ module Parse
     end
 
     # Two Parse::Pointers (or Parse::Objects) are equal if both of them have
-    # the same Parse class and the same id.
+    # the same Parse class and the same id. An instance without an id (an
+    # unsaved object) is equal only to itself, as in ActiveRecord: two
+    # distinct new records are different records even though neither has
+    # an id yet.
     # @return [Boolean]
     def ==(o)
+      return true if equal?(o)
       return false unless o.is_a?(Pointer)
+      return false if id.blank? || o.id.blank?
       #only equal if the Parse class and object ID are the same.
       self.parse_class == o.parse_class && id == o.id
     end
@@ -333,8 +344,14 @@ module Parse
     # - Hash key lookups to find objects by identity
     # - Set operations
     #
+    # An instance without an id hashes by Ruby identity, consistent with
+    # {#==}. Its hash therefore changes once it is saved and receives an id,
+    # so re-index any Hash or Set that holds it as a key after saving (the
+    # same caveat as ActiveRecord).
+    #
     # @return [Integer] hash code based on class name and object id
     def hash
+      return super if id.blank?
       [parse_class, id].hash
     end
 
@@ -370,6 +387,12 @@ module Parse
     # @return [Object] the result of calling the method on the fetched object
     # @raise [Parse::AutofetchTriggeredError] if autofetch_raise_on_missing_keys is enabled
     def method_missing(method_name, *args, &block)
+      # A Parse::Object defines real accessors for its fields, so reaching
+      # here means a name with no accessor (for example the remote alias
+      # `objectId=` sent by ActiveModel's `assign_attributes`). Autofetching
+      # would issue a network request and run the call on a separate fetched
+      # copy, not on this object, so raise NoMethodError instead.
+      return super if is_a?(Parse::Object)
       # Try to find the model class for this pointer
       klass = Parse::Model.find_class(parse_class)
 
@@ -381,6 +404,16 @@ module Parse
       # We have a registered class with this field - handle autofetch
       field_name = method_name.to_s.chomp("=").to_sym
 
+      # A setter would change a fetched copy held inside this pointer, which
+      # nothing ever saves, so the write would be lost without notice.
+      if method_name.to_s.end_with?("=")
+        raise NoMethodError.new(
+          "undefined method '#{method_name}' for a #{self.class} to #{parse_class}. A pointer " \
+          "cannot be modified: fetch the object first (pointer.fetch) and set :#{field_name} on it.",
+          method_name,
+        )
+      end
+
       # If autofetch_raise_on_missing_keys is enabled, raise an error
       if Parse.autofetch_raise_on_missing_keys
         raise Parse::AutofetchTriggeredError.new(klass, id, field_name, is_pointer: true)
@@ -405,9 +438,10 @@ module Parse
     # @param include_private [Boolean] whether to include private methods
     # @return [Boolean] true if the method can be handled
     def respond_to_missing?(method_name, include_private = false)
+      return super if is_a?(Parse::Object)
       klass = Parse::Model.find_class(parse_class)
-      if klass && klass.respond_to?(:fields)
-        field_name = method_name.to_s.chomp("=").to_sym
+      if klass && klass.respond_to?(:fields) && !method_name.to_s.end_with?("=")
+        field_name = method_name.to_sym
         return true if klass.fields[field_name]
       end
       super