parse-stack-next 5.7.6 → 5.8.0

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

@@ -87,7 +87,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,6 +207,15 @@ 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!)
 
@@ -318,7 +331,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 +447,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/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