parse-stack-next 5.6.0 → 5.7.0

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

@@ -109,6 +109,100 @@ module Parse
         end
       end
 
+      # Capture the property values a transaction rollback must restore.
+      #
+      # Property values live in `@<field>` instance variables (see
+      # {Parse::Properties::ClassMethods#property}), so those are what gets
+      # snapshotted. {Parse::Object#attributes} is deliberately NOT captured:
+      # it returns a SCHEMA map (field name to type symbol), not values, so
+      # restoring it never rolled anything back.
+      #
+      # Restoring it was also actively harmful. `@attributes` is the ivar
+      # `ActiveModel::Dirty` keys its behavior on: `mutations_from_database`
+      # builds an `AttributeMutationTracker` over `@attributes` the moment
+      # that ivar is defined (and a `ForcedMutationTracker` otherwise), while
+      # `forget_attribute_assignments` calls `map(&:forgetting_assignment)`
+      # on it. Handing either one a schema Hash raised `NoMethodError` on a
+      # type symbol and on the `[key, value]` pair `Hash#map` yields. Both
+      # sites rescue and warn, so every rollback silently downgraded the
+      # object to broken change tracking instead of failing.
+      #
+      # @param obj [Parse::Object] the object being tracked.
+      # @return [Hash] field name to a snapshot of its value. Mutable values
+      #   are duplicated so in-place mutation between snapshot and rollback
+      #   cannot corrupt the saved copy.
+      def self.snapshot_property_values(obj)
+        fields = obj.class.respond_to?(:fields) ? obj.class.fields.keys : []
+        fields.each_with_object({}) do |key, snapshot|
+          ivar = :"@#{key}"
+          next unless obj.instance_variable_defined?(ivar)
+          snapshot[ivar] = dup_for_snapshot(obj.instance_variable_get(ivar))
+        end
+      end
+
+      # Copy a property value deeply enough that later in-place mutation of
+      # the live value cannot reach the snapshot.
+      #
+      # A plain `dup` is not sufficient for collection-backed properties:
+      # `:array` and association properties hold a {Parse::CollectionProxy},
+      # and duplicating the proxy still shares the underlying `@collection`
+      # array, so `widget.tags << "b"` would mutate the snapshot too. The
+      # proxy's inner array is duplicated as well.
+      #
+      # @param value [Object] the live property value.
+      # @return [Object] a copy safe to hold across the transaction.
+      def self.dup_for_snapshot(value)
+        copy = begin
+            value.dup
+          rescue TypeError
+            # Symbols, Integers, true/false/nil and other immediates are not
+            # duplicable on older rubies; they are also immutable, so sharing
+            # the reference is safe.
+            return value
+          end
+
+        if copy.instance_variable_defined?(:@collection)
+          inner = copy.instance_variable_get(:@collection)
+          copy.instance_variable_set(:@collection, inner.dup) if inner.is_a?(Array)
+        end
+        copy
+      end
+
+      # Restore the values captured by {snapshot_property_values}.
+      #
+      # Writes ivars directly rather than going through the property setters,
+      # since the setters mark the object dirty and the caller restores the
+      # dirty state itself immediately afterwards.
+      #
+      # @param obj [Parse::Object] the object being rolled back.
+      # @param snapshot [Hash] the return value of {snapshot_property_values}.
+      # @return [void]
+      def self.restore_property_values(obj, snapshot)
+        return unless snapshot.is_a?(Hash)
+        snapshot.each do |ivar, value|
+          obj.instance_variable_set(ivar, value)
+        end
+      end
+
+      # Roll a single tracked object back to the state captured when it was
+      # added to the transaction.
+      #
+      # @param state [Hash] one entry of the transaction's `original_states`.
+      # @return [void]
+      def self.rollback_object_state(state)
+        obj = state[:object]
+        return if obj.nil?
+        restore_property_values(obj, state[:property_values])
+        obj.instance_variable_set(:@changed_attributes, state[:changed_attributes])
+        obj.instance_variable_set(:@id, state[:id])
+        # Restore change tracking state. Leaving `@mutations_from_database`
+        # nil is fine: `ActiveModel::Dirty` lazily rebuilds it, and with
+        # `@attributes` no longer defined on the object it correctly rebuilds
+        # a `ForcedMutationTracker`.
+        obj.instance_variable_set(:@mutations_from_database, state[:mutations_from_database])
+        obj.instance_variable_set(:@mutations_before_last_save, state[:mutations_before_last_save])
+      end
+
       # Class methods applied to Parse::Object subclasses.
       module ClassMethods
 
@@ -169,7 +263,7 @@ module Parse
             if obj.respond_to?(:attributes) && obj.respond_to?(:id) && !original_states.key?(obj.object_id)
               original_states[obj.object_id] = {
                 object: obj,
-                attributes: obj.attributes.dup,
+                property_values: Parse::Core::Actions.snapshot_property_values(obj),
                 changed_attributes: obj.instance_variable_get(:@changed_attributes)&.dup || {},
                 id: obj.id,
                 mutations_from_database: obj.instance_variable_get(:@mutations_from_database),
@@ -243,13 +337,7 @@ module Parse
 
               # Rollback local object states
               original_states.each_value do |state|
-                obj = state[:object]
-                obj.instance_variable_set(:@attributes, state[:attributes])
-                obj.instance_variable_set(:@changed_attributes, state[:changed_attributes])
-                obj.instance_variable_set(:@id, state[:id])
-                # Restore change tracking state
-                obj.instance_variable_set(:@mutations_from_database, state[:mutations_from_database])
-                obj.instance_variable_set(:@mutations_before_last_save, state[:mutations_before_last_save])
+                Parse::Core::Actions.rollback_object_state(state)
               end
 
               raise Parse::Error, "Transaction failed: #{error_response.error}"
@@ -263,13 +351,7 @@ module Parse
 
             # Rollback local object states on final failure
             original_states.each_value do |state|
-              obj = state[:object]
-              obj.instance_variable_set(:@attributes, state[:attributes])
-              obj.instance_variable_set(:@changed_attributes, state[:changed_attributes])
-              obj.instance_variable_set(:@id, state[:id])
-              # Restore change tracking state
-              obj.instance_variable_set(:@mutations_from_database, state[:mutations_from_database])
-              obj.instance_variable_set(:@mutations_before_last_save, state[:mutations_before_last_save])
+              Parse::Core::Actions.rollback_object_state(state)
             end
 
             raise e

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

@@ -276,5 +276,3 @@ module Parse
     end
   end
 end
-
-

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

@@ -18,9 +18,9 @@ module Parse
     # gracefully (`{available: false, reason: ...}`) instead of raising
     # when the underlying service is unreachable or unconfigured.
     module Describe
-      LOCAL_SECTIONS   = %i[model acl].freeze
+      LOCAL_SECTIONS = %i[model acl].freeze
       NETWORK_SECTIONS = %i[schema clp atlas indexes].freeze
-      ALL_SECTIONS     = (LOCAL_SECTIONS + NETWORK_SECTIONS).freeze
+      ALL_SECTIONS = (LOCAL_SECTIONS + NETWORK_SECTIONS).freeze
 
       # Core/built-in field keys we don't report under `:model[:fields]` —
       # they're inherited from Parse::Object (in both snake_case and
@@ -55,7 +55,7 @@ module Parse
       # @return [Hash, String]
       def describe(*sections, pretty: false, network: false, usage: false, master: false, client: nil)
         requested = sections.flatten.map(&:to_sym)
-        active    = if requested.empty?
+        active = if requested.empty?
             network ? ALL_SECTIONS : LOCAL_SECTIONS
           else
             requested
@@ -72,13 +72,13 @@ module Parse
 
       def describe_section(section, client:, network:, usage: false, master: false)
         case section
-        when :model  then describe_model_section
-        when :acl    then describe_acl_section
+        when :model then describe_model_section
+        when :acl then describe_acl_section
         when :schema then network_section(network) { describe_schema_section(client) }
-        when :clp    then network_section(network) { describe_clp_section(client) }
-        when :atlas   then network_section(network) { describe_atlas_section }
+        when :clp then network_section(network) { describe_clp_section(client) }
+        when :atlas then network_section(network) { describe_atlas_section }
         when :indexes then network_section(network) { describe_indexes_section(usage: usage, master: master) }
-        else               { available: false, reason: :unknown_section }
+        else { available: false, reason: :unknown_section }
         end
       end
 
@@ -92,15 +92,15 @@ module Parse
       def describe_model_section
         local_fields = fields.reject { |k, _| CORE_FIELD_KEYS.include?(k) }
         {
-          parse_class:   parse_class,
-          fields:        local_fields,
-          field_count:   local_fields.size,
-          references:    (respond_to?(:references) ? references.dup : {}),
-          relations:     (respond_to?(:relations) ? relations.dup : {}),
-          defaults:      (respond_to?(:defaults_list) ? defaults_list.dup : []),
-          enums:         (respond_to?(:enums) ? enums.dup : {}),
-          agent_fields:  (respond_to?(:agent_field_allowlist) && agent_field_allowlist.any? ?
-                          agent_field_allowlist.map(&:to_s).sort : nil),
+          parse_class: parse_class,
+          fields: local_fields,
+          field_count: local_fields.size,
+          references: (respond_to?(:references) ? references.dup : {}),
+          relations: (respond_to?(:relations) ? relations.dup : {}),
+          defaults: (respond_to?(:defaults_list) ? defaults_list.dup : []),
+          enums: (respond_to?(:enums) ? enums.dup : {}),
+          agent_fields: (respond_to?(:agent_field_allowlist) && agent_field_allowlist.any? ?
+            agent_field_allowlist.map(&:to_s).sort : nil),
           agent_methods: agent_method_names_or_nil,
         }
       end
@@ -115,9 +115,9 @@ module Parse
       def describe_acl_section
         defaults = respond_to?(:default_acls) ? default_acls : nil
         {
-          default_acl:         defaults.respond_to?(:as_json) ? defaults.as_json : nil,
+          default_acl: defaults.respond_to?(:as_json) ? defaults.as_json : nil,
           default_acl_private: (respond_to?(:default_acl_private) ? !!default_acl_private : nil),
-          acl_policy:          instance_variable_get(:@acl_policy_setting),
+          acl_policy: instance_variable_get(:@acl_policy_setting),
         }
       end
 
@@ -126,12 +126,12 @@ module Parse
         return { available: false, reason: :class_missing_on_server } if info.nil?
         diff = Parse::Schema::SchemaDiff.new(self, info)
         {
-          available:          true,
-          in_sync:            diff.in_sync?,
+          available: true,
+          in_sync: diff.in_sync?,
           server_field_count: info.field_names.size,
-          missing_on_server:  diff.missing_on_server,
-          missing_locally:    diff.missing_locally,
-          type_mismatches:    diff.type_mismatches,
+          missing_on_server: diff.missing_on_server,
+          missing_locally: diff.missing_locally,
+          type_mismatches: diff.type_mismatches,
         }
       end
 
@@ -148,10 +148,10 @@ module Parse
         indexes = Parse::AtlasSearch::IndexManager.list_indexes(parse_class)
         {
           available: true,
-          count:     indexes.size,
-          indexes:   indexes.map { |i|
-            { name:      i["name"],
-              status:    i["status"],
+          count: indexes.size,
+          indexes: indexes.map { |i|
+            { name: i["name"],
+              status: i["status"],
               queryable: i["queryable"] }
           },
         }
@@ -183,8 +183,8 @@ module Parse
         normalized = raw.map { |idx| normalize_index_entry(idx, stats: stats) }
         result = {
           available: true,
-          count:     normalized.size,
-          indexes:   normalized,
+          count: normalized.size,
+          indexes: normalized,
         }
         if usage
           # Empty stats Hash means the role lacks clusterMonitor / Atlas
@@ -203,22 +203,22 @@ module Parse
           # plans for any `_Join:*` collections from
           # `mongo_relation_index`.
           plans = Parse::Schema::IndexMigrator.new(self).plan
-          base  = parse_class
+          base = parse_class
           parent_plan = plans[base]
           if parent_plan
-            result[:declared]      = parent_plan[:declared].map { |d| describe_decl(d) }
-            result[:drift]         = describe_drift(parent_plan)
+            result[:declared] = parent_plan[:declared].map { |d| describe_decl(d) }
+            result[:drift] = describe_drift(parent_plan)
             result[:parse_managed] = parent_plan[:parse_managed]
-            result[:capacity]      = describe_capacity(parent_plan)
+            result[:capacity] = describe_capacity(parent_plan)
           end
           join_plans = plans.reject { |k, _| k == base }
           unless join_plans.empty?
             result[:relations] = join_plans.each_with_object({}) do |(coll, p), h|
               h[coll] = {
-                declared:      p[:declared].map { |d| describe_decl(d) },
-                drift:         describe_drift(p),
+                declared: p[:declared].map { |d| describe_decl(d) },
+                drift: describe_drift(p),
                 parse_managed: p[:parse_managed],
-                capacity:      describe_capacity(p),
+                capacity: describe_capacity(p),
               }
             end
           end
@@ -234,18 +234,18 @@ module Parse
       def describe_drift(plan)
         {
           to_create: plan[:to_create].map { |d| describe_decl(d) },
-          in_sync:   plan[:in_sync].map   { |d| describe_decl(d) },
-          orphans:   plan[:orphans],
+          in_sync: plan[:in_sync].map { |d| describe_decl(d) },
+          orphans: plan[:orphans],
           conflicts: plan[:conflicts],
         }
       end
 
       def describe_capacity(plan)
         {
-          used:      plan[:capacity_used],
-          after:     plan[:capacity_after],
+          used: plan[:capacity_used],
+          after: plan[:capacity_after],
           remaining: plan[:capacity_remaining],
-          ok:        plan[:capacity_ok],
+          ok: plan[:capacity_ok],
         }
       end
 
@@ -259,11 +259,11 @@ module Parse
       def normalize_index_entry(idx, stats: {})
         name = idx["name"] || idx[:name]
         entry = {
-          name:           name,
-          implicit_id:    name == "_id_",
-          key:            coerce_bson(idx["key"] || idx[:key] || {}),
-          unique:         idx["unique"] == true,
-          sparse:         idx["sparse"] == true,
+          name: name,
+          implicit_id: name == "_id_",
+          key: coerce_bson(idx["key"] || idx[:key] || {}),
+          unique: idx["unique"] == true,
+          sparse: idx["sparse"] == true,
           partial_filter: coerce_bson(idx["partialFilterExpression"] || idx[:partialFilterExpression]),
           expire_after_seconds: idx["expireAfterSeconds"] || idx[:expireAfterSeconds],
         }
@@ -292,10 +292,10 @@ module Parse
         if (m = data[:model])
           lines << "  fields:     #{m[:field_count]}"
           lines << "  references: #{m[:references].inspect}" if m[:references].any?
-          lines << "  relations:  #{m[:relations].inspect}"  if m[:relations].any?
-          lines << "  defaults:   #{m[:defaults].inspect}"   if m[:defaults].any?
+          lines << "  relations:  #{m[:relations].inspect}" if m[:relations].any?
+          lines << "  defaults:   #{m[:defaults].inspect}" if m[:defaults].any?
           lines << "  enums:      #{m[:enums].keys.inspect}" if m[:enums].any?
-          lines << "  agent_fields:  #{m[:agent_fields].inspect}"  if m[:agent_fields]
+          lines << "  agent_fields:  #{m[:agent_fields].inspect}" if m[:agent_fields]
           lines << "  agent_methods: #{m[:agent_methods].inspect}" if m[:agent_methods]
         end
 
@@ -309,8 +309,8 @@ module Parse
             label = s[:in_sync] ? "in sync" : "drifted"
             lines << "  schema: #{label} (server fields=#{s[:server_field_count]})"
             lines << "    missing_on_server: #{s[:missing_on_server].keys.inspect}" if s[:missing_on_server].any?
-            lines << "    missing_locally:   #{s[:missing_locally].keys.inspect}"   if s[:missing_locally].any?
-            lines << "    type_mismatches:   #{s[:type_mismatches].keys.inspect}"   if s[:type_mismatches].any?
+            lines << "    missing_locally:   #{s[:missing_locally].keys.inspect}" if s[:missing_locally].any?
+            lines << "    type_mismatches:   #{s[:type_mismatches].keys.inspect}" if s[:type_mismatches].any?
           else
             lines << "  schema: unavailable (#{s[:reason]})"
           end
@@ -351,10 +351,10 @@ module Parse
             end
             if (drift = ix[:drift])
               lines << "    declared:    #{ix[:declared].size}"
-              lines << "    to_create:   #{drift[:to_create].size}"   if drift[:to_create].any?
-              lines << "    in_sync:     #{drift[:in_sync].size}"     if drift[:in_sync].any?
-              lines << "    orphans:     #{drift[:orphans].inspect}"  if drift[:orphans].any?
-              lines << "    conflicts:   #{drift[:conflicts].size}"   if drift[:conflicts].any?
+              lines << "    to_create:   #{drift[:to_create].size}" if drift[:to_create].any?
+              lines << "    in_sync:     #{drift[:in_sync].size}" if drift[:in_sync].any?
+              lines << "    orphans:     #{drift[:orphans].inspect}" if drift[:orphans].any?
+              lines << "    conflicts:   #{drift[:conflicts].size}" if drift[:conflicts].any?
             end
             if (cap = ix[:capacity])
               lines << "    capacity:    #{cap[:used]}/#{Parse::Core::Indexing::MAX_INDEXES_PER_COLLECTION} (#{cap[:remaining]} remaining)"
@@ -366,7 +366,7 @@ module Parse
                 lines << "      declared:  #{info[:declared].size}"
                 d = info[:drift]
                 lines << "      to_create: #{d[:to_create].size}" if d[:to_create].any?
-                lines << "      in_sync:   #{d[:in_sync].size}"   if d[:in_sync].any?
+                lines << "      in_sync:   #{d[:in_sync].size}" if d[:in_sync].any?
                 lines << "      orphans:   #{d[:orphans].inspect}" if d[:orphans].any?
               end
             end

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

@@ -162,8 +162,7 @@ module Parse
         if directives.empty?
           raise ArgumentError, "#{self.class}#compute_embedding!: no `embed` directives declared."
         end
-        selected =
-          if field
+        selected = if field
             d = directives[field.to_sym]
             unless d
               raise ArgumentError,
@@ -211,7 +210,7 @@ module Parse
         # @return [Symbol] the target vector field name.
         # @raise [InvalidEmbedDeclaration] on declaration-time misuse.
         def embed(*source_fields, into:, input_type: :search_document, digest_field: nil,
-                  meta_field: nil)
+                                  meta_field: nil)
           if source_fields.empty?
             raise InvalidEmbedDeclaration,
                   "#{self}.embed: at least one source field is required."
@@ -325,8 +324,8 @@ module Parse
         # @return [Symbol] the target vector field name.
         # @raise [InvalidEmbedDeclaration] on declaration-time misuse.
         def embed_image(source_field, into:, input_type: :search_document,
-                        digest_field: nil, allow_insecure: false,
-                        source: :url, exif_strip: true, meta_field: nil)
+                                      digest_field: nil, allow_insecure: false,
+                                      source: :url, exif_strip: true, meta_field: nil)
           # Capture the fetch mode immediately — the legacy local
           # `source = source_field.to_sym` below shadows the kwarg.
           source_mode = source_mode_for_embed_image!(source)
@@ -489,12 +488,12 @@ module Parse
         # The provenance tuple a freshly-embedded row would carry today.
         def current_embed_identity(directive)
           model = begin
-            Parse::Embeddings.provider(directive.provider_name).model_name
-          rescue Parse::Embeddings::ProviderNotRegistered
-            raise
-          rescue NotImplementedError
-            nil
-          end
+              Parse::Embeddings.provider(directive.provider_name).model_name
+            rescue Parse::Embeddings::ProviderNotRegistered
+              raise
+            rescue NotImplementedError
+              nil
+            end
           {
             "provider" => directive.provider_name.to_s,
             "model" => model,
@@ -649,10 +648,10 @@ module Parse
       # explicit `audit_all!` path apply identical rules.
       def self.audit_binding!(klass, directive)
         provider = begin
-          Parse::Embeddings.provider(directive.provider_name)
-        rescue Parse::Embeddings::ProviderNotRegistered
-          return
-        end
+            Parse::Embeddings.provider(directive.provider_name)
+          rescue Parse::Embeddings::ProviderNotRegistered
+            return
+          end
         Parse::Embeddings::BindingAudit.verify!(klass, directive.into, provider)
       end
 
@@ -720,10 +719,10 @@ module Parse
         return if directive.meta_field.nil?
         return unless record.respond_to?(:"#{directive.meta_field}=")
         model = begin
-          provider.model_name
-        rescue NotImplementedError
-          nil
-        end
+            provider.model_name
+          rescue NotImplementedError
+            nil
+          end
         record.public_send(:"#{directive.meta_field}=", {
           "provider" => directive.provider_name.to_s,
           "model" => model,
@@ -777,8 +776,7 @@ module Parse
       # fetches it itself).
       def self.call_provider(provider, directive, input)
         if directive.image?
-          source =
-            if directive.bytes_mode?
+          source = if directive.bytes_mode?
               Parse::Embeddings::ImageFetch.fetch!(
                 input,
                 allow_insecure: directive.allow_insecure ? true : false,
@@ -788,8 +786,8 @@ module Parse
               input
             end
           provider.embed_image([source],
-            input_type: directive.input_type,
-            allow_insecure: directive.allow_insecure ? true : false)
+                               input_type: directive.input_type,
+                               allow_insecure: directive.allow_insecure ? true : false)
         else
           provider.embed_text([input], input_type: directive.input_type)
         end

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

@@ -203,6 +203,8 @@ module Parse
 
         # Apply attributes from server (only keys in result get updated)
         apply_attributes!(result, dirty_track: false)
+        record_authorization_hydration!(result, partial: is_partial_fetch) if
+          respond_to?(:record_authorization_hydration!)
 
         begin
           clear_changes!

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

@@ -93,9 +93,9 @@ module Parse
       # @raise [ArgumentError] when validation rules fail (no fields,
       #   unknown field, parallel arrays, relation field, etc.)
       def mongo_index(*fields, unique: false, sparse: false, partial: nil,
-                      expire_after: nil, name: nil)
+                               expire_after: nil, name: nil)
         register_index(fields, key_value: 1, unique: unique, sparse: sparse,
-                       partial: partial, expire_after: expire_after, name: name)
+                               partial: partial, expire_after: expire_after, name: name)
       end
 
       # Declare a UNIQUE index on the exact dedup tuple that
@@ -175,7 +175,7 @@ module Parse
       # which `2dsphere` indexes natively.
       def mongo_geo_index(field, sparse: false, name: nil)
         register_index([field], key_value: "2dsphere", unique: false,
-                       sparse: sparse, partial: nil, expire_after: nil, name: name)
+                                sparse: sparse, partial: nil, expire_after: nil, name: name)
       end
 
       # Declare an index on a Parse Relation's join collection. Relations
@@ -277,7 +277,7 @@ module Parse
       private
 
       def register_index(fields, key_value:, unique:, sparse:, partial:,
-                         expire_after:, name:)
+                                 expire_after:, name:)
         fields = fields.flatten.map(&:to_sym)
         if fields.empty?
           raise ArgumentError, "#{self}.mongo_index requires at least one field name"
@@ -304,13 +304,13 @@ module Parse
         assert_at_most_one_array_field!(fields, wire_keys)
 
         declaration = {
-          keys:          wire_keys,
-          options:       {
+          keys: wire_keys,
+          options: {
             unique: unique, sparse: sparse,
             partial_filter: partial, expire_after: expire_after, name: name,
           }.reject { |_, v| v.nil? || v == false }.freeze,
-          declared_for:  fields.dup.freeze,
-          collection:    nil, # nil sentinel means "use the model's parse_class"
+          declared_for: fields.dup.freeze,
+          collection: nil, # nil sentinel means "use the model's parse_class"
         }.freeze
 
         # Idempotent redeclaration (same class re-opened or sub-class
@@ -325,10 +325,10 @@ module Parse
       # model's `parse_class`.
       def register_relation_index(collection, column, source:)
         decl = {
-          keys:         { column => 1 }.freeze,
-          options:      {}.freeze,
+          keys: { column => 1 }.freeze,
+          options: {}.freeze,
           declared_for: [source].freeze,
-          collection:   collection,
+          collection: collection,
         }.freeze
         append_index_declaration(decl)
       end
@@ -343,10 +343,10 @@ module Parse
       # column (which `mongo_relation_index` continues to reject).
       def register_relation_dedup_index(collection, source:)
         decl = {
-          keys:         { "owningId" => 1, "relatedId" => 1 }.freeze,
-          options:      { unique: true }.freeze,
+          keys: { "owningId" => 1, "relatedId" => 1 }.freeze,
+          options: { unique: true }.freeze,
           declared_for: [source].freeze,
-          collection:   collection,
+          collection: collection,
         }.freeze
         append_index_declaration(decl)
       end

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

@@ -185,7 +185,7 @@ module Parse
         #   `after_create` callback that issues a follow-up `update!`.
         # @return [Symbol] the registered field name
         def parse_reference(field_name = :parse_reference, field: nil, precompute: false,
-                            index: true, unique_index: true)
+                                                           index: true, unique_index: true)
           field_name = field_name.to_sym
           unless field_name.to_s =~ /\A[a-z_][a-z0-9_]*\z/i
             raise ArgumentError,

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

@@ -245,7 +245,7 @@ module Parse
           dropped = opts.keys.map(&:to_sym) - forwarded
           unless dropped.empty?
             warn "[#{self}] property #{key.inspect} resolves to a pointer association; " \
-                 "ignoring unsupported option(s) #{dropped.map(&:inspect).join(', ')} " \
+                 "ignoring unsupported option(s) #{dropped.map(&:inspect).join(", ")} " \
                  "(not available on belongs_to)."
           end
           return belongs_to(key, bt_opts)
@@ -447,7 +447,7 @@ module Parse
               expected = record.class.vector_properties.dig(attribute, :dimensions)
               if expected && value.dimensions != expected
                 record.errors.add(attribute,
-                  "field :#{attribute} expected #{expected} dimensions, got #{value.dimensions}.")
+                                  "field :#{attribute} expected #{expected} dimensions, got #{value.dimensions}.")
               end
             end
           end # validates_each

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

@@ -613,7 +613,7 @@ module Parse
         # Forward session-token / use_master_key when supplied so client-mode
         # callers can scope a `.find` to a logged-in user without dropping
         # down to the raw `client.fetch_object` form.
-        client_opts[:session_token]  = session_token  unless session_token.nil?
+        client_opts[:session_token] = session_token unless session_token.nil?
         client_opts[:use_master_key] = use_master_key unless use_master_key.nil?
         # The parallel path spawns worker threads via `Parallel.map`. Worker
         # threads don't inherit fiber-local storage from the calling thread,

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

@@ -72,7 +72,7 @@ module Parse
       # These are managed automatically by Parse Server.
       SCHEMA_READONLY_CLASSES = [
         Parse::Model::CLASS_PUSH_STATUS,
-        Parse::Model::CLASS_SCHEMA
+        Parse::Model::CLASS_SCHEMA,
       ].freeze
 
       # Default CLP that grants public access to all operations.
@@ -84,7 +84,7 @@ module Parse
         "create" => { "*" => true },
         "update" => { "*" => true },
         "delete" => { "*" => true },
-        "addField" => { "*" => true }
+        "addField" => { "*" => true },
       }.freeze
 
       # Reset the CLP on the server to public defaults.

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

@@ -99,9 +99,9 @@ module Parse
         end
 
         declaration = {
-          name:       name_str,
+          name: name_str,
           definition: deep_freeze(definition),
-          type:       type_str,
+          type: type_str,
         }.freeze
 
         existing = mongo_search_index_declarations.find { |d| d[:name] == name_str }