parse-stack-next 5.5.6 → 5.7.0

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,
@@ -642,6 +641,20 @@ module Parse
       # `Parse::Embeddings.validate_image_url!`, and call
       # `Provider#embed_image`. Digest tracking elides the provider
       # call when the source has not changed since last save.
+      # @!visibility private
+      # Run the shared binding validator when the declared provider is
+      # actually registered. Delegates to
+      # {Parse::Embeddings::BindingAudit} so the lazy path and the
+      # 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::BindingAudit.verify!(klass, directive.into, provider)
+      end
+
       def self.recompute_embedding!(record, directive)
         input = build_source_input(record, directive)
         stored_digest = record.public_send(directive.digest_field)
@@ -658,6 +671,18 @@ module Parse
           return
         end
 
+        # Audit the binding BEFORE the digest early-return, not after.
+        # A drifted `model:` is a configuration fault, not a property of
+        # this particular record: if the check sat behind the digest
+        # gate, an unchanged record would skip it and the mismatch would
+        # stay invisible until some unrelated record happened to be
+        # edited. Saving any record with this directive should surface
+        # it. Skipped silently when the provider is not registered — the
+        # resolution below still raises for records that actually embed,
+        # so an unchanged save keeps its existing no-provider-needed
+        # behavior.
+        audit_binding!(record.class, directive)
+
         digest = digest_for(input)
         return if stored_digest == digest && target_present
 
@@ -694,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,
@@ -751,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,
@@ -762,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

@@ -159,6 +159,11 @@ module Parse
 
       # @return [Hash] per-property metadata for `:vector`-typed fields.
       # Maps property names (symbols) to a frozen options hash:
+      # Similarity functions Atlas vectorSearch accepts. Validated at
+      # declaration time so a typo surfaces when the class loads rather
+      # than as an Atlas index error much later.
+      VECTOR_SIMILARITIES = %w[euclidean cosine dotProduct].freeze
+
       # `{ dimensions: Integer, provider: Symbol, model: String, similarity: Symbol }`.
       # `dimensions:` is required; the rest are optional and only carry
       # meaning for the embedding provider plumbing layered above this
@@ -240,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)
@@ -396,11 +401,42 @@ module Parse
                   "Property #{self}##{key} :vector dimensions #{dims} exceeds max " \
                   "#{Parse::Vector::MAX_DIMENSIONS}."
           end
+
+          # `searchable:` separates "can be stored" from "can be
+          # indexed". Parse::Vector tolerates up to 16384 dims, but
+          # Atlas caps a vectorSearch index at 8192 — so without this,
+          # a wider property is declarable, storable, and permanently
+          # unsearchable, with the failure surfacing only at query
+          # time. Default true: a :vector property exists to be
+          # searched, and opting out should be the deliberate act.
+          searchable = opts.key?(:searchable) ? opts[:searchable] : true
+          unless [true, false].include?(searchable)
+            raise ArgumentError,
+                  "Property #{self}##{key} :vector `searchable:` must be true or false " \
+                  "(got #{searchable.inspect})."
+          end
+          if searchable && defined?(Parse::VectorSearch) &&
+             dims > Parse::VectorSearch::MAX_DIMENSIONS
+            raise ArgumentError,
+                  "Property #{self}##{key} :vector dimensions #{dims} exceeds the Atlas " \
+                  "vectorSearch index cap (#{Parse::VectorSearch::MAX_DIMENSIONS}); such a " \
+                  "vector can be stored but never searched. Reduce dimensions, or declare " \
+                  "`searchable: false` to acknowledge it is storage-only."
+          end
+
+          similarity = opts[:similarity]
+          if similarity && !VECTOR_SIMILARITIES.include?(similarity.to_s)
+            raise ArgumentError,
+                  "Property #{self}##{key} :vector `similarity:` must be one of " \
+                  "#{VECTOR_SIMILARITIES.inspect} (got #{similarity.inspect})."
+          end
+
           vector_properties[key] = {
             dimensions: dims,
             provider: opts[:provider],
             model: opts[:model],
-            similarity: opts[:similarity],
+            similarity: similarity,
+            searchable: searchable,
           }.freeze
 
           validates_each key do |record, attribute, value|
@@ -411,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 }