parse-stack-next 5.7.6 → 5.8.1

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

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

@@ -34,11 +34,18 @@ module Parse
   # material against snapshot/MONITOR exposure should set
   # `PARSE_STACK_LOCK_SECRET` or `Parse.synchronize_create_secret`.
   module CreateLock
+    # Floor for the lock lease, in seconds. When no `ttl:` is given the
+    # lease is sized from the client's request budget instead (see
+    # {.default_ttl}); this is the minimum it can be.
     DEFAULT_TTL = 3
     DEFAULT_WAIT = 2.0
     DEFAULT_POLL_BASE = 0.05
     DEFAULT_POLL_JITTER = 0.015
-    MAX_TTL = 30
+    # Ceiling for the lock lease, in seconds. The lease only matters when a
+    # holder dies without releasing; a normal exit always releases.
+    MAX_TTL = 300
+    # Requests the locked block is sized for: the find, then the create.
+    LOCKED_REQUESTS = 2
     MAX_WAIT = 30
     MAX_PAYLOAD_BYTES = 8_192
     MAX_DEPTH = 4
@@ -60,7 +67,7 @@ module Parse
       def synchronize(parse_class:, query_attrs:, options: {}, session_token: nil, master_key: nil, &block)
         raise ArgumentError, "block required" unless block_given?
 
-        ttl = clamp(Integer(options[:ttl] || DEFAULT_TTL), 1, MAX_TTL)
+        ttl = options[:ttl] ? clamp(Integer(options[:ttl]), 1, MAX_TTL) : default_ttl
         wait = clamp(Float(options[:wait] || DEFAULT_WAIT), 0.0, MAX_WAIT)
         on_degraded = options[:on_degraded] || :warn
 
@@ -115,6 +122,24 @@ module Parse
         end
       end
 
+      # The lease used when no `ttl:` is given. The lock is not renewed
+      # while held, so the lease must outlast the block it guards: a find
+      # and a create, each of which may run through every retry at the full
+      # request timeout. A lease shorter than that expires mid-block, lets a
+      # second caller in, and produces the duplicate the lock exists to
+      # prevent. The result is clamped to DEFAULT_TTL..MAX_TTL. Pass `ttl:`
+      # to override it.
+      # @param client [Parse::Client, nil] the client whose timeouts and
+      #   retry limit size the lease; the default client when nil.
+      # @return [Integer] seconds.
+      def default_ttl(client = nil)
+        client ||= Parse::Client.client
+        budget = client.respond_to?(:request_time_budget) ? client.request_time_budget : 0
+        clamp((budget * LOCKED_REQUESTS).ceil, DEFAULT_TTL, MAX_TTL)
+      rescue StandardError
+        DEFAULT_TTL
+      end
+
       # Canonical lock key for the given inputs. Public for tests.
       # @return [String]
       def canonical_key(parse_class:, query_attrs:, session_token: nil, master_key: nil)

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

@@ -145,6 +145,8 @@ module Parse
         unless defined?(Parse::MongoDB) && Parse::MongoDB.respond_to?(:enabled?) && Parse::MongoDB.enabled?
           return { available: false, reason: :mongodb_not_enabled }
         end
+        # Parse::AtlasSearch is loaded on first use, not with the SDK.
+        require_relative "../../atlas_search"
         indexes = Parse::AtlasSearch::IndexManager.list_indexes(parse_class)
         {
           available: true,

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

@@ -55,6 +55,9 @@ module Parse
       # @param preserve_changes [Boolean] if true, re-apply local dirty values to fetched fields.
       #   By default (false), fetched fields accept server values and local changes are discarded.
       #   Unfetched fields always preserve their dirty state regardless of this setting.
+      #   A relation's staged additions and removals are kept in both modes (they are
+      #   operations, not field values) and the relation stays marked changed, so the
+      #   next save sends them. Use {Parse::Object#reload!} or `clear_changes!` to drop them.
       # @param opts [Hash] a set of options to pass to the client request.
       # @option opts [Boolean, Symbol] :cache (:write_only) caching mode:
       #   - :write_only (default) - skip cache read, but update cache with fresh data
@@ -87,7 +90,11 @@ module Parse
         includes_array = includes.present? ? Array(includes) : nil
 
         # Build formatted keys once (reused for query and tracking)
-        formatted_keys = keys_array&.map { |k| Parse::Query.format_field(k) }
+        formatted_keys = if keys_array
+            Parse::Query.with_field_aliases(parse_class) do
+              keys_array.map { |k| Parse::Query.format_field(k) }
+            end
+          end
 
         # Validate keys against model fields if validation is enabled
         # Skip validation if warnings are disabled (nothing to report)
@@ -203,15 +210,26 @@ module Parse
 
         # Apply attributes from server (only keys in result get updated)
         apply_attributes!(result, dirty_track: false)
+        # The server row is now the source of truth for the ACL. A full
+        # fetch whose response has no ACL key is a public (ACL-less) row, so
+        # drop any locally stamped default rather than misreport it. Either
+        # way the record exists, so the save-time default-ACL resolver must
+        # not replace its ACL.
+        if !is_partial_fetch && !result.key?("ACL") && !result.key?(:ACL)
+          @acl = nil
+        end
+        @_acl_pristine = false
         record_authorization_hydration!(result, partial: is_partial_fetch) if
           respond_to?(:record_authorization_hydration!)
 
         begin
-          clear_changes!
+          # Not clear_changes!: that also drops a relation's staged
+          # additions and removals, which a fetch must keep.
+          clear_dirty_tracking!
         rescue => e
           # Log the error for debugging purposes
           warn "[Parse::Fetch] Warning: clear_changes! failed: #{e.class}: #{e.message}"
-          # If clear_changes! fails, manually reset change tracking
+          # If clearing fails, manually reset change tracking
           @changed_attributes = {} if instance_variable_defined?(:@changed_attributes)
           @mutations_from_database = nil if instance_variable_defined?(:@mutations_from_database)
           @mutations_before_last_save = nil if instance_variable_defined?(:@mutations_before_last_save)
@@ -253,9 +271,31 @@ module Parse
           end
         end
 
+        # A relation whose proxy still holds staged additions or removals
+        # must stay dirty, or the next save sends nothing. The loop above
+        # cannot guarantee it: when the response carries the relation's
+        # descriptor, re-applying the same proxy is not a change.
+        remark_staged_relations_dirty!
+
         self
       end
 
+      # @!visibility private
+      # Marks dirty every relation whose proxy holds staged additions or
+      # removals. Used after a fetch has cleared the record's dirty tracking.
+      def remark_staged_relations_dirty!
+        return unless respond_to?(:relations)
+        relations.each_key do |key|
+          ivar = :"@#{key}"
+          next unless instance_variable_defined?(ivar)
+          proxy = instance_variable_get(ivar)
+          next unless proxy.respond_to?(:staged_changes?) && proxy.staged_changes?
+          next if changed.include?(key.to_s)
+          will_change_method = "#{key}_will_change!"
+          send(will_change_method) if respond_to?(will_change_method)
+        end
+      end
+
       # Fetches the object with explicit caching enabled.
       # This is a convenience method that calls fetch! with cache: true.
       # Use this when you want to leverage cached responses for better performance.
@@ -318,7 +358,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?
@@ -432,9 +474,12 @@ module Parse
         # Autofetch if object is a pointer OR was selectively fetched
         # Skip if autofetch is disabled for this instance
         needs_fetch = pointer? || has_selective_keys?
+        # A pointer never autofetches for its ACL. A partially fetched object
+        # does when the ACL was left out, so code that edits it starts from
+        # the record's real ACL instead of nil.
         return unless needs_fetch &&
                       !autofetch_disabled? &&
-                      key != :acl &&
+                      !(key == :acl && pointer?) &&
                       !Parse::Properties::BASE_KEYS.include?(key) &&
                       respond_to?(:fetch)
 

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

@@ -197,20 +197,28 @@ module Parse
 
         if respond_to?(:relations) && relations[field_sym]
           proxy = public_send(field_sym)
-          # Reset the pending add/remove ledger that backs
-          # relation_change_operations. The proxy itself has no public reset
-          # API for these (its rollback!/restore_attributes path expects
-          # setters that don't exist for additions/removals), so we clear
-          # them directly and then drop the proxy's dirty markers.
-          proxy.instance_variable_set(:@additions, []) if proxy.instance_variable_defined?(:@additions)
-          proxy.instance_variable_set(:@removals, []) if proxy.instance_variable_defined?(:@removals)
+          # Drop the pending add/remove ledger that backs
+          # relation_change_operations, and the proxy's dirty markers. The
+          # relation proxy's clear_changes! also reloads its list on next
+          # access, since the loaded list included the discarded items. A
+          # handler that reads the relation after the revert therefore
+          # triggers one query for the stored members (on a saved owner).
           proxy.clear_changes! if proxy.respond_to?(:clear_changes!)
           clear_attribute_changes([field_str])
           return
         end
 
         if is_new
-          public_send("#{field_str}=", nil)
+          if field_sym == :acl && !self.class.builtin_acl_default_active?
+            # The class's ACL policy still decides a new record's ACL: put
+            # back the init-time default stamp and let the save-time
+            # resolver run, instead of a nil ACL that a reply would send
+            # as `{}` (master-key only).
+            public_send(:acl=, self.class.default_acls.as_json)
+            @_acl_pristine = true
+          else
+            public_send("#{field_str}=", nil)
+          end
         else
           restore_attributes([field_str])
         end

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

@@ -4,12 +4,16 @@
 module Parse
   # Global `const_missing` hook that lazily resolves the plural form of a
   # {Parse::Object} subclass constant to that class. Referencing `Posts`
-  # when a class `Post` exists installs `Posts` as an alias for `Post` on
-  # the referencing module and returns it, so query entry points like
+  # when a class `Post` exists installs `Posts` as an alias for `Post` and
+  # returns it, so query entry points like
   # `Posts.where(...).count` work without any per-model boilerplate.
   #
-  # The hook is prepended onto `Module` so it applies to constant lookups
-  # in any namespace (top-level and nested). It is tightly guarded: every
+  # The hook is prepended onto `Module` so a plural reference resolves from
+  # any namespace, but the alias constant is only ever installed in the
+  # namespace that defines the singular class (`::Posts` for a top-level
+  # `Post`, `Blog::Posts` for `Blog::Post`). A lookup from an unrelated
+  # module never adds a constant to that module, and a frozen namespace is
+  # skipped rather than raising `FrozenError`. It is tightly guarded: every
   # path that is not a plural-of-a-Parse-class falls through to `super`,
   # preserving normal `NameError` and autoloader (Zeitwerk/classic)
   # behavior. The whole feature is gated on {Parse.pluralized_aliases?} so