parse-stack-next 5.6.0 → 5.7.1

data/lib/parse/retrieval/retriever.rb

@@ -224,8 +224,7 @@ module Parse
       chunker ||= default_chunker
       text_wire = wire_name(klass, resolved_text_field)
 
-      raw_hits =
-        if hybrid
+      raw_hits = if hybrid
           fetch_hybrid_hits(klass, query, k, field, filter, merged_vector_filter,
                             tenant_scope, hybrid, scope_opts)
         else
@@ -253,8 +252,8 @@ module Parse
                           tenant_scope, hybrid, scope_opts)
       cfg = hybrid.is_a?(Hash) ? hybrid : {}
       lexical = (cfg[:lexical] || cfg["lexical"] || {}).dup
-      vector  = (cfg[:vector]  || cfg["vector"]  || {}).dup
-      fusion  = cfg[:fusion] || cfg["fusion"]
+      vector = (cfg[:vector] || cfg["vector"] || {}).dup
+      fusion = cfg[:fusion] || cfg["fusion"]
 
       lexical[:query] ||= query
       # Tenant scope must be AUTHORITATIVE in BOTH branches. The previous
@@ -278,8 +277,7 @@ module Parse
 
     # @!visibility private
     def resolve_class!(klass)
-      resolved =
-        case klass
+      resolved = case klass
         when nil
           nil
         when Class

data/lib/parse/schema/index_migrator.rb

@@ -110,7 +110,7 @@ module Parse
         managed, ours = partition_parse_managed(existing)
         to_create, in_sync, conflicts = diff_declarations(declared, ours)
         declared_names = declared.map { |d| d[:options][:name] }.compact.to_set
-        declared_sigs  = declared.map { |d| key_sig(d[:keys]) }.to_set
+        declared_sigs = declared.map { |d| key_sig(d[:keys]) }.to_set
         orphans = ours.reject do |idx|
           declared_sigs.include?(key_sig(idx["key"] || idx[:key])) ||
             declared_names.include?(idx["name"] || idx[:name])
@@ -122,21 +122,21 @@ module Parse
         after_with_drop = after_no_drop - orphans.size
 
         {
-          collection:               collection,
-          declared:                 declared,
-          existing:                 existing,
-          parse_managed:            managed.map { |i| i["name"] || i[:name] },
-          to_create:                to_create,
-          in_sync:                  in_sync,
-          conflicts:                conflicts,
-          orphans:                  orphans.map { |i| i["name"] || i[:name] }.compact,
-          capacity_used:            used,
-          capacity_after:           after_no_drop,
-          capacity_remaining:       max - after_no_drop,
-          capacity_ok:              after_no_drop <= max,
+          collection: collection,
+          declared: declared,
+          existing: existing,
+          parse_managed: managed.map { |i| i["name"] || i[:name] },
+          to_create: to_create,
+          in_sync: in_sync,
+          conflicts: conflicts,
+          orphans: orphans.map { |i| i["name"] || i[:name] }.compact,
+          capacity_used: used,
+          capacity_after: after_no_drop,
+          capacity_remaining: max - after_no_drop,
+          capacity_ok: after_no_drop <= max,
           capacity_after_with_drop: after_with_drop,
           capacity_remaining_with_drop: max - after_with_drop,
-          capacity_ok_with_drop:    after_with_drop <= max,
+          capacity_ok_with_drop: after_with_drop <= max,
         }
       end
 
@@ -181,7 +181,7 @@ module Parse
           p[:orphans].each do |name|
             confirm = "drop:#{collection}:#{name}"
             res = Parse::MongoDB.drop_index(collection, name, confirm: confirm,
-                                            allow_system_classes: collection.start_with?("_Join:"))
+                                                              allow_system_classes: collection.start_with?("_Join:"))
             dropped << name if res == :dropped
           end
         end
@@ -190,21 +190,21 @@ module Parse
           result = Parse::MongoDB.create_index(
             collection,
             decl[:keys],
-            name:                decl[:options][:name],
-            unique:              decl[:options][:unique] == true,
-            sparse:              decl[:options][:sparse] == true,
-            partial_filter:      decl[:options][:partial_filter],
-            expire_after:        decl[:options][:expire_after],
+            name: decl[:options][:name],
+            unique: decl[:options][:unique] == true,
+            sparse: decl[:options][:sparse] == true,
+            partial_filter: decl[:options][:partial_filter],
+            expire_after: decl[:options][:expire_after],
             allow_system_classes: collection.start_with?("_Join:"),
           )
           (result == :exists ? skipped : created) << decl
         end
 
         {
-          created:        created,
+          created: created,
           skipped_exists: skipped,
-          dropped:        dropped,
-          conflicts:      p[:conflicts],
+          dropped: dropped,
+          conflicts: p[:conflicts],
           capacity_blocked: false,
         }
       end
@@ -235,12 +235,12 @@ module Parse
 
       def diff_declarations(declared, existing_ours)
         to_create = []
-        in_sync   = []
+        in_sync = []
         conflicts = []
 
         declared.each do |decl|
           decl_sig = key_sig(decl[:keys])
-          named    = decl[:options][:name]
+          named = decl[:options][:name]
 
           # Prefer a name match when the declaration named one — that's
           # the operator's authoritative target. Otherwise match by key
@@ -280,7 +280,7 @@ module Parse
       def serialize_existing(idx)
         {
           name: idx["name"] || idx[:name],
-          key:  idx["key"]  || idx[:key],
+          key: idx["key"] || idx[:key],
           unique: idx["unique"] == true,
           sparse: idx["sparse"] == true,
           partial_filter: idx["partialFilterExpression"],

data/lib/parse/schema/search_index_migrator.rb

@@ -75,8 +75,8 @@ module Parse
         end
 
         to_create = []
-        in_sync   = []
-        drifted   = []
+        in_sync = []
+        drifted = []
 
         declared.each do |decl|
           target = existing_by_name[decl[:name]]
@@ -93,14 +93,14 @@ module Parse
         orphans = existing_by_name.keys.reject { |name| declared_names.include?(name) }
 
         {
-          collection:      coll,
-          declared:        declared,
-          existing:        existing,
+          collection: coll,
+          declared: declared,
+          existing: existing,
           atlas_available: available,
-          to_create:       to_create,
-          in_sync:         in_sync,
-          drifted:         drifted,
-          orphans:         orphans,
+          to_create: to_create,
+          in_sync: in_sync,
+          drifted: drifted,
+          orphans: orphans,
         }
       end
 
@@ -176,14 +176,14 @@ module Parse
         end
 
         {
-          created:         created,
-          skipped_exists:  skipped_exists,
-          in_sync:         p[:in_sync],
-          updated:         updated,
+          created: created,
+          skipped_exists: skipped_exists,
+          in_sync: p[:in_sync],
+          updated: updated,
           drifted_skipped: drifted_skipped,
-          dropped:         dropped,
+          dropped: dropped,
           orphans_skipped: orphans_skipped,
-          wait_results:    wait_results,
+          wait_results: wait_results,
         }
       end
 
@@ -321,10 +321,10 @@ module Parse
       # history, statusDetail) so operator-facing output stays readable.
       def serialize_existing(idx)
         {
-          name:               (idx["name"] || idx[:name]).to_s,
-          status:             (idx["status"] || idx[:status]).to_s,
-          queryable:          idx["queryable"] == true,
-          latest_definition:  idx["latestDefinition"] || idx[:latestDefinition],
+          name: (idx["name"] || idx[:name]).to_s,
+          status: (idx["status"] || idx[:status]).to_s,
+          queryable: idx["queryable"] == true,
+          latest_definition: idx["latestDefinition"] || idx[:latestDefinition],
         }
       end
 

data/lib/parse/stack/tasks.rb

@@ -110,7 +110,7 @@ module Parse
 
               batch_size = (ENV["BATCH_SIZE"] || "100").to_i
               batch_size = 100 if batch_size <= 0
-              dry_run    = ENV["DRY_RUN"].to_s.downcase == "true"
+              dry_run = ENV["DRY_RUN"].to_s.downcase == "true"
 
               if dry_run
                 puts "[parse:references:populate] DRY_RUN=true — no writes will be issued"
@@ -120,7 +120,7 @@ module Parse
                 fields = Array(klass._parse_reference_fields)
                 fields.each do |field_name|
                   populated_total = 0
-                  scanned_total   = 0
+                  scanned_total = 0
                   loops_without_progress = 0
                   loop do
                     # Query for records where the reference column is null/
@@ -207,7 +207,7 @@ module Parse
                   puts "    to_create:"
                   p[:to_create].each do |d|
                     flags = d[:options].dup
-                    name  = flags.delete(:name) || "(auto)"
+                    name = flags.delete(:name) || "(auto)"
                     puts "      + #{d[:keys].inspect}  name=#{name}  opts=#{flags.inspect}"
                   end
                 end
@@ -423,13 +423,13 @@ module Parse
                 end
 
                 update = ENV["UPDATE"].to_s.downcase == "true"
-                drop   = ENV["DROP"].to_s.downcase   == "true"
-                wait   = ENV["WAIT"].to_s.downcase   == "true"
+                drop = ENV["DROP"].to_s.downcase == "true"
+                wait = ENV["WAIT"].to_s.downcase == "true"
                 timeout = (ENV["WAIT_TIMEOUT"] || "600").to_i
                 modes = []
                 modes << "additive"
                 modes << "update-drifted" if update
-                modes << "drop-orphans"   if drop
+                modes << "drop-orphans" if drop
                 modes << "wait-for-ready (#{timeout}s)" if wait
                 puts "[parse:mongo:search_indexes:apply] mode: #{modes.join(" + ")}"
                 if drop

data/lib/parse/stack/version.rb

@@ -6,6 +6,6 @@ module Parse
   # The Parse Server SDK for Ruby
   module Stack
     # The current version.
-    VERSION = "5.6.0"
+    VERSION = "5.7.1"
   end
 end

data/lib/parse/stack.rb

@@ -5,6 +5,7 @@ require_relative "stack/version"
 require_relative "client"
 require_relative "query"
 require_relative "model/object"
+require_relative "access"
 require_relative "webhooks"
 require_relative "agent"
 require_relative "two_factor_auth"
@@ -303,7 +304,7 @@ module Parse
             "Parse.login: credentials rejected for #{username.inspect} (server returned no session)."
     end
     Fiber[SESSION_TOKEN_STATE_KEY] = user.session_token
-    Fiber[CURRENT_USER_STATE_KEY]  = user
+    Fiber[CURRENT_USER_STATE_KEY] = user
     user
   end
 
@@ -323,7 +324,7 @@ module Parse
   def self.logout(revoke: true)
     token = Fiber[SESSION_TOKEN_STATE_KEY]
     Fiber[SESSION_TOKEN_STATE_KEY] = nil
-    Fiber[CURRENT_USER_STATE_KEY]  = nil
+    Fiber[CURRENT_USER_STATE_KEY] = nil
     if revoke && token.is_a?(String) && !token.empty?
       begin
         Parse::Client.client.logout(token)
@@ -346,7 +347,7 @@ module Parse
     resolved = token.respond_to?(:session_token) ? token.session_token : token
     resolved = resolved.to_s if resolved
     Fiber[SESSION_TOKEN_STATE_KEY] = (resolved && !resolved.empty?) ? resolved : nil
-    Fiber[CURRENT_USER_STATE_KEY]  = nil
+    Fiber[CURRENT_USER_STATE_KEY] = nil
     Fiber[SESSION_TOKEN_STATE_KEY]
   end
 
@@ -721,17 +722,16 @@ module Parse
         next if duration_ms < threshold
         logger = respond_to?(:logger) ? Parse.logger : nil
         next unless logger
-        detail =
-          if name == "parse.mongodb.aggregate"
-            "stages=#{payload[:stage_count]} types=#{Array(payload[:stage_types]).join(',')}"
+        detail = if name == "parse.mongodb.aggregate"
+            "stages=#{payload[:stage_count]} types=#{Array(payload[:stage_types]).join(",")}"
           else
-            "filter=#{!!payload[:has_filter]} projection=#{Array(payload[:projection_keys]).join(',')}"
+            "filter=#{!!payload[:has_filter]} projection=#{Array(payload[:projection_keys]).join(",")}"
           end
         logger.warn(
           "[Parse::MongoDB] SLOW #{name} #{duration_ms}ms " \
-          "collection=#{payload[:collection]} scope=#{payload[:scope] || 'n/a'} " \
-          "#{detail} result_count=#{payload[:result_count] || 'n/a'} " \
-          "max_time_ms=#{payload[:max_time_ms] || 'n/a'}",
+          "collection=#{payload[:collection]} scope=#{payload[:scope] || "n/a"} " \
+          "#{detail} result_count=#{payload[:result_count] || "n/a"} " \
+          "max_time_ms=#{payload[:max_time_ms] || "n/a"}",
         )
       end
       ActiveSupport::Notifications.subscribe("parse.mongodb.aggregate", &handler)

data/lib/parse/vector_search/hybrid.rb

@@ -136,11 +136,11 @@ module Parse
           acc.values
              .sort_by { |e| [-e[:score], row_id(e[:doc]).to_s, e[:seq]] }
              .map do |e|
-               row = e[:doc].dup
-               row["_hybrid_score"] = e[:score]
-               row["_hybrid_ranks"] = e[:ranks]
-               row
-             end
+            row = e[:doc].dup
+            row["_hybrid_score"] = e[:score]
+            row["_hybrid_ranks"] = e[:ranks]
+            row
+          end
         end
 
         # Detect whether the cluster backing `collection` supports the
@@ -156,14 +156,21 @@ module Parse
         # cached per collection for {PROBE_CACHE_TTL}.
         #
         # @param collection [String] Parse class / Mongo collection name.
+        # @param authorizing_client [Parse::Client, nil] client whose
+        #   application binding must be checked before probing.
         # @return [Boolean]
-        def rank_fusion_supported?(collection)
+        def rank_fusion_supported?(collection, authorizing_client: nil)
+          # Check on every call, including cache hits. Otherwise a verdict
+          # cached by application A could bypass the unidentified/mismatched
+          # caller guard when application B asks about the same collection.
+          Parse::MongoDB.verify_client!(authorizing_client)
+
           key = collection.to_s
           now = monotonic
           cached = probe_cache_get(key, now)
           return cached unless cached.nil?
 
-          supported = run_probe(key)
+          supported = run_probe(key, authorizing_client: authorizing_client)
           probe_cache_put(key, supported, now)
           supported
         end
@@ -235,7 +242,7 @@ module Parse
                   "hybrid search: fusion[:method] must be :rrf, :rrf_client, or :rrf_native (got #{method.inspect})."
           end
           k_constant = fusion[:k_constant] || DEFAULT_K_CONSTANT
-          weights    = fusion[:weights]
+          weights = fusion[:weights]
           # Two distinct numbers, deliberately not one. `fusion_depth` is
           # how many rows each branch RETAINS for RRF (bounded by
           # VectorSearch::MAX_K, since it becomes a branch `k`);
@@ -256,30 +263,39 @@ module Parse
           # two-aggregate client path unless a caller explicitly opts into
           # native AND the cluster supports it. Native still falls back to
           # the client path on any execution error.
-          if method == :rrf_native && rank_fusion_supported?(collection_name)
-            # The native pipeline enforces ACL AFTER fusion, so its
-            # per-branch limit is the pre-ACL depth: the candidate
-            # window, not the fusion depth.
-            fused = run_native(collection_name, lex, vec, candidate_window,
-                               k_constant: k_constant, weights: weights, scope_opts: scope_opts)
-            if fused
-              trimmed = fused.first(k_int)
-              # Native retains the full candidate window per branch,
-              # NOT the client path's fusion depth: its ACL `$match`
-              # runs after `$rankFusion`, so the branch limit and the
-              # pre-ACL window are necessarily the same number. Report
-              # what actually executed rather than the client figure.
-              emit_hybrid_stats(collection_name: collection_name, k: k_int,
-                                method: :rrf_native, branch_depth: candidate_window,
-                                candidate_window: candidate_window,
-                                post_filter_count: fused.length,
-                                returned_count: trimmed.length)
-              return trimmed
+          if method == :rrf_native
+            native_resolution = Parse::ACLScope.resolve!(
+              scope_opts.dup, method_name: :"VectorSearch::Hybrid.search",
+            )
+            if rank_fusion_supported?(
+              collection_name,
+              authorizing_client: Parse::ACLScope.client_of(native_resolution),
+            )
+              # The native pipeline enforces ACL AFTER fusion, so its
+              # per-branch limit is the pre-ACL depth: the candidate
+              # window, not the fusion depth.
+              fused = run_native(collection_name, lex, vec, candidate_window,
+                                 k_constant: k_constant, weights: weights, scope_opts: scope_opts,
+                                 resolution: native_resolution)
+              if fused
+                trimmed = fused.first(k_int)
+                # Native retains the full candidate window per branch,
+                # NOT the client path's fusion depth: its ACL `$match`
+                # runs after `$rankFusion`, so the branch limit and the
+                # pre-ACL window are necessarily the same number. Report
+                # what actually executed rather than the client figure.
+                emit_hybrid_stats(collection_name: collection_name, k: k_int,
+                                  method: :rrf_native, branch_depth: candidate_window,
+                                  candidate_window: candidate_window,
+                                  post_filter_count: fused.length,
+                                  returned_count: trimmed.length)
+                return trimmed
+              end
             end
           end
 
           lexical_rows = run_lexical(collection_name, lex, fusion_depth, scope_opts)
-          vector_rows  = run_vector(collection_name, vec, fusion_depth, candidate_window, scope_opts)
+          vector_rows = run_vector(collection_name, vec, fusion_depth, candidate_window, scope_opts)
           fused = rrf({ lexical: lexical_rows, vector: vector_rows },
                       k_constant: k_constant, weights: weights)
           trimmed = fused.first(k_int)
@@ -310,8 +326,7 @@ module Parse
         #
         # @return [Array(Integer, Integer)] `[fusion_depth, candidate_window]`
         def resolve_windows(k_int, candidate_limit)
-          window =
-            if candidate_limit
+          window = if candidate_limit
               limit = Integer(candidate_limit)
               if limit < k_int
                 raise ArgumentError,
@@ -441,8 +456,8 @@ module Parse
           pipeline
         end
 
-        def run_native(collection_name, lex, vec, oversample, k_constant:, weights:, scope_opts:)
-          resolution = Parse::ACLScope.resolve!(scope_opts.dup, method_name: :"VectorSearch::Hybrid.search")
+        def run_native(collection_name, lex, vec, oversample, k_constant:, weights:, scope_opts:, resolution: nil)
+          resolution ||= Parse::ACLScope.resolve!(scope_opts.dup, method_name: :"VectorSearch::Hybrid.search")
           assert_clp_find!(collection_name, resolution)
           pointer_fields = resolve_pointer_fields!(collection_name, resolution)
           protected_fields = Parse::CLPScope.protected_fields_for(
@@ -455,7 +470,8 @@ module Parse
 
           pipeline = native_pipeline_for(lex, vec, oversample, resolution,
                                          k_constant: k_constant, weights: weights, limit: oversample)
-          rows = run_pipeline!(collection_name, pipeline)
+          rows = run_pipeline!(collection_name, pipeline,
+                               authorizing_client: Parse::ACLScope.client_of(resolution))
 
           unless resolution.master?
             # Defense-in-depth top-level row gate. The in-pipeline ACL
@@ -515,11 +531,11 @@ module Parse
           num_candidates = (vec[:num_candidates] || oversample * Parse::VectorSearch::DEFAULT_NUM_CANDIDATES_MULTIPLIER).to_i
           num_candidates = [[num_candidates, oversample].max, 10_000].min
           stage = {
-            "index"         => vec[:index].to_s,
-            "path"          => vec[:field].to_s,
-            "queryVector"   => vec[:query_vector],
+            "index" => vec[:index].to_s,
+            "path" => vec[:field].to_s,
+            "queryVector" => vec[:query_vector],
             "numCandidates" => num_candidates,
-            "limit"         => oversample,
+            "limit" => oversample,
           }
           stage["filter"] = vec[:vector_filter] if vec[:vector_filter] && !vec[:vector_filter].empty?
           inner = [{ "$vectorSearch" => stage }]
@@ -543,10 +559,18 @@ module Parse
 
         # -- the $rankFusion support probe -------------------------------
 
-        def run_probe(collection_name)
-          coll = Parse::MongoDB.collection(collection_name)
+        # Capability probe only: runs `$rankFusion` with an empty input and a
+        # `$limit 0`, so it reads no rows. It still carries the authorizing
+        # client because the process-global MongoDB connection must enforce
+        # its application binding even for a zero-row probe.
+        def run_probe(collection_name, authorizing_client: nil)
+          coll = Parse::MongoDB.collection(collection_name, authorizing_client: authorizing_client)
           coll.aggregate([{ "$rankFusion" => { "input" => {} } }, { "$limit" => 0 }]).to_a
           true
+        rescue Parse::MongoDB::ClientMismatch
+          # A binding violation is not evidence that the stage exists. It is a
+          # security boundary and must reach the caller without being cached.
+          raise
         rescue StandardError => e
           # "Unknown aggregation stage $rankFusion" (or an unrecognized-
           # operator variant) means the cluster predates native support.
@@ -642,8 +666,9 @@ module Parse
           end
         end
 
-        def run_pipeline!(collection_name, pipeline)
-          Parse::MongoDB.collection(collection_name).aggregate(pipeline).to_a
+        def run_pipeline!(collection_name, pipeline, authorizing_client: nil)
+          Parse::MongoDB.collection(collection_name, authorizing_client: authorizing_client)
+                        .aggregate(pipeline).to_a
         end
 
         def assert_clp_find!(collection_name, resolution)

data/lib/parse/vector_search.rb

@@ -168,6 +168,7 @@ module Parse
       def index_drift_policy
         @index_drift_policy ||= :warn
       end
+
       # Low-level `$vectorSearch` entry point.
       #
       # @param collection_name [String] Parse class name / Mongo
@@ -203,8 +204,8 @@ module Parse
       #   `_vscore` rather than `_score` so hybrid pipelines with
       #   Atlas Search don't collide on the same key).
       def search(collection_name, field:, query_vector:, k: 10,
-                 num_candidates: nil, candidate_limit: nil, filter: nil,
-                 vector_filter: nil, index: nil, max_time_ms: nil, **scope_opts)
+                                  num_candidates: nil, candidate_limit: nil, filter: nil,
+                                  vector_filter: nil, index: nil, max_time_ms: nil, **scope_opts)
         candidate_limit_override = candidate_limit
         require_available!
         index_name = (index || @default_index)
@@ -239,8 +240,7 @@ module Parse
         # receives fewer than `k`. Master mode with no caller filter
         # has no attrition, so it keeps the old one-for-one cost.
         attrition_possible = !resolution.master? || !(filter.nil? || filter.empty?)
-        candidate_limit =
-          if candidate_limit_override
+        candidate_limit = if candidate_limit_override
             Integer(candidate_limit_override)
           elsif attrition_possible
             [k_int * DEFAULT_CANDIDATE_MULTIPLIER, MAX_CANDIDATE_LIMIT].min
@@ -308,13 +308,13 @@ module Parse
         )
 
         vs_stage = {
-          "index"         => index_name.to_s,
-          "path"          => path,
-          "queryVector"   => validated_vector,
+          "index" => index_name.to_s,
+          "path" => path,
+          "queryVector" => validated_vector,
           "numCandidates" => num_candidates_int,
           # Deliberately the raised candidate window, not `k` — the
           # result set is trimmed to `k` after enforcement runs.
-          "limit"         => candidate_limit,
+          "limit" => candidate_limit,
         }
         vs_stage["filter"] = vector_filter if vector_filter && !vector_filter.empty?
         pipeline = [{ "$vectorSearch" => vs_stage }]
@@ -338,7 +338,8 @@ module Parse
 
         pipeline << { "$match" => filter } if filter
 
-        raw_results = run_pipeline!(collection_name, pipeline, max_time_ms: max_time_ms)
+        raw_results = run_pipeline!(collection_name, pipeline, max_time_ms: max_time_ms,
+                                                               authorizing_client: Parse::ACLScope.client_of(resolution))
         # Already past the server-side ACL `$match` and any caller
         # `filter` — NOT the number $vectorSearch emitted.
         post_filter_count = raw_results.length
@@ -484,10 +485,12 @@ module Parse
       # `Parse::MongoDB.aggregate` because that helper prepends an
       # ACL `$match` at stage 0, which Atlas rejects for any pipeline
       # whose stage 0 is `$vectorSearch`.
-      def run_pipeline!(collection_name, pipeline, max_time_ms: nil)
+      def run_pipeline!(collection_name, pipeline, max_time_ms: nil, authorizing_client: nil)
         agg_opts = {}
         agg_opts[:max_time_ms] = max_time_ms if max_time_ms
-        coll = Parse::MongoDB.collection(collection_name)
+        # Vector search bypasses Parse::MongoDB.aggregate, so the binding
+        # guard only sees this read if the authorizing client arrives here.
+        coll = Parse::MongoDB.collection(collection_name, authorizing_client: authorizing_client)
         coll.aggregate(pipeline, agg_opts).to_a
       rescue => e
         Parse::MongoDB.send(:raise_if_timeout!, e, collection_name, max_time_ms)

data/lib/parse/webhooks/payload.rb

@@ -718,6 +718,7 @@ module Parse
         @deferred_callbacks << block
         true
       end
+
       alias_method :defer, :after_response
 
       # @!visibility private

data/lib/parse/webhooks/registration.rb

@@ -33,10 +33,10 @@ module Parse
       def assert_webhook_url_safe!(url)
         raise ArgumentError, "Webhook URL is required" if url.nil? || url.to_s.empty?
         uri = begin
-          URI.parse(url.to_s)
-        rescue URI::InvalidURIError => e
-          raise ArgumentError, "Invalid webhook URL: #{e.message}"
-        end
+            URI.parse(url.to_s)
+          rescue URI::InvalidURIError => e
+            raise ArgumentError, "Invalid webhook URL: #{e.message}"
+          end
         unless %w[http https].include?(uri.scheme)
           raise ArgumentError, "Webhook URL must be http(s) (got #{uri.scheme.inspect})"
         end