parse-stack-next 5.7.6 → 5.8.0

data/lib/parse/retrieval/profiles.rb

@@ -0,0 +1,320 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require "timeout"
+
+module Parse
+  module Retrieval
+    # Server-configured retrieval profiles for the `semantic_search` agent
+    # tool.
+    #
+    # A profile composes the library's existing retrieval paths (vector,
+    # hybrid, reranking) with explicit budgets, so an application can offer
+    # an agent a few named strategies (for example `fast`, `balanced`,
+    # `precise`) without letting the model pick providers, endpoints, or
+    # credentials. The agent only ever names a profile; everything else is
+    # fixed on the server at registration time.
+    #
+    # @example
+    #   Parse::Retrieval.register_reranker(:voyage,
+    #     Parse::Retrieval::Reranker::Voyage.new(api_key: ENV.fetch("VOYAGE_API_KEY"), model: "rerank-3-lite"))
+    #
+    #   Parse::Retrieval::Profiles.register(:fast, k: 5, max_k: 10)
+    #   Parse::Retrieval::Profiles.register(:precise,
+    #     reranker: :voyage, rerank_candidates: 30, rerank_top_n: 8,
+    #     rerank_max_document_chars: 4_000, rerank_timeout: 5,
+    #     on_rerank_failure: :fallback, max_total_tokens: 8_000)
+    #
+    #   agent.execute(:semantic_search, class_name: "Article", query: "refund policy", profile: "precise")
+    #
+    # Registration validates the whole configuration, so a misconfigured
+    # profile (unknown option, unregistered reranker, non-positive budget)
+    # fails at boot rather than mid-request. Without a `profile:` argument
+    # `semantic_search` behaves exactly as before.
+    module Profiles
+      # A validated, frozen profile.
+      Profile = Struct.new(
+        :name, :k, :max_k, :hybrid, :reranker, :rerank_candidates, :rerank_top_n,
+        :rerank_max_document_chars, :rerank_timeout, :on_rerank_failure, :max_total_tokens,
+        keyword_init: true,
+      ) do
+        # @return [Boolean] true when the profile reranks.
+        def rerank?
+          !reranker.nil?
+        end
+      end
+
+      ALLOWED_OPTIONS = %i[
+        k max_k hybrid reranker rerank_candidates rerank_top_n
+        rerank_max_document_chars rerank_timeout on_rerank_failure max_total_tokens
+      ].freeze
+
+      # Defaults applied to an option the profile does not set.
+      DEFAULTS = {
+        k: 10,
+        max_k: 20,
+        hybrid: nil,
+        rerank_candidates: 30,
+        rerank_top_n: nil,
+        rerank_max_document_chars: 4_000,
+        rerank_timeout: 10,
+        on_rerank_failure: :fallback,
+        max_total_tokens: nil,
+      }.freeze
+
+      # Hard ceilings no profile may exceed, so a misconfigured profile still
+      # cannot fan out unbounded provider work.
+      MAX_RERANK_CANDIDATES = 100
+      # semantic_search returns at most this many documents, so a larger
+      # max_k could never take effect; it is refused rather than clamped.
+      MAX_K = 20
+      MAX_RERANK_DOCUMENT_CHARS = 32_000
+
+      FAILURE_MODES = %i[fallback raise].freeze
+      # Options that only have an effect when the profile names a reranker.
+      RERANK_OPTIONS = %i[rerank_candidates rerank_top_n rerank_max_document_chars rerank_timeout on_rerank_failure].freeze
+      HYBRID_KEYS = %i[lexical vector fusion].freeze
+      NAME_RE = /\A[a-z][a-z0-9_]{0,39}\z/.freeze
+
+      @registry = {}
+      @mutex = Mutex.new
+
+      class << self
+        # Register (or replace) a profile.
+        #
+        # @param name [Symbol, String] lowercase identifier.
+        # @param options [Hash] see {ALLOWED_OPTIONS}.
+        #   * `k`, `max_k` [Integer]: default and maximum results.
+        #   * `hybrid` [true, Hash]: run lexical + vector fusion; a Hash
+        #     carries server-side `lexical:`, `vector:`, `fusion:` settings.
+        #   * `reranker` [Symbol, String]: a name registered with
+        #     {Parse::Retrieval.register_reranker}.
+        #   * `rerank_candidates` [Integer]: documents retrieved and sent to
+        #     the reranker (capped at {MAX_RERANK_CANDIDATES}).
+        #   * `rerank_top_n` [Integer, nil]: documents kept after reranking
+        #     (defaults to the effective `k`).
+        #   * `rerank_max_document_chars` [Integer]: each document's text is
+        #     cut to this length before it is sent to the reranker.
+        #   * `rerank_timeout` [Numeric]: seconds allowed for reranking.
+        #   * `on_rerank_failure` [:fallback, :raise]: on timeout or provider
+        #     failure, keep the retrieval order (observable) or fail the call.
+        #   * `max_total_tokens` [Integer, nil]: default response budget.
+        # @return [Profile]
+        # @raise [ArgumentError] on any invalid option.
+        def register(name, **options)
+          profile = build(name, options)
+          @mutex.synchronize { @registry[profile.name] = profile }
+          profile
+        end
+
+        # @return [Profile] the registered profile.
+        # @raise [Parse::Agent::ValidationError] for an unknown name, listing
+        #   the registered ones.
+        def fetch!(name)
+          key = name.to_s
+          profile = @mutex.synchronize { @registry[key] }
+          return profile if profile
+
+          raise Parse::Agent::ValidationError,
+                "Unknown retrieval profile #{key.inspect}. Available: #{names.inspect}."
+        end
+
+        # @return [Array<String>] registered profile names, sorted.
+        def names
+          @mutex.synchronize { @registry.keys.sort }
+        end
+
+        def unregister(name)
+          @mutex.synchronize { @registry.delete(name.to_s) }
+        end
+
+        def reset!
+          @mutex.synchronize { @registry.clear }
+        end
+
+        private
+
+        def build(name, options)
+          key = name.to_s
+          unless key.match?(NAME_RE)
+            raise ArgumentError, "Retrieval profile name #{name.inspect} must match #{NAME_RE.inspect}."
+          end
+          unknown = options.keys.map(&:to_sym) - ALLOWED_OPTIONS
+          unless unknown.empty?
+            raise ArgumentError,
+                  "Retrieval profile #{key.inspect}: unknown option(s) #{unknown.inspect}. " \
+                  "Allowed: #{ALLOWED_OPTIONS.inspect}."
+          end
+          given = options.transform_keys(&:to_sym)
+          rerank_only = given.keys & RERANK_OPTIONS
+          if given[:reranker].nil? && !rerank_only.empty?
+            raise ArgumentError,
+                  "Retrieval profile #{key.inspect}: #{rerank_only.inspect} only apply with a reranker:; " \
+                  "set reranker: or remove them."
+          end
+          opts = DEFAULTS.merge(given)
+
+          k = positive_int!(key, :k, opts[:k])
+          max_k = positive_int!(key, :max_k, opts[:max_k])
+          raise ArgumentError, "Retrieval profile #{key.inspect}: k (#{k}) exceeds max_k (#{max_k})." if k > max_k
+          if max_k > MAX_K
+            raise ArgumentError,
+                  "Retrieval profile #{key.inspect}: max_k #{max_k} exceeds the semantic_search maximum (#{MAX_K})."
+          end
+
+          reranker = nil
+          unless opts[:reranker].nil?
+            reranker = opts[:reranker].to_s
+            unless Parse::Retrieval.reranker_registered?(reranker)
+              raise ArgumentError,
+                    "Retrieval profile #{key.inspect}: reranker #{reranker.inspect} is not registered. " \
+                    "Register it with Parse::Retrieval.register_reranker before the profile."
+            end
+          end
+
+          candidates = positive_int!(key, :rerank_candidates, opts[:rerank_candidates])
+          if candidates > MAX_RERANK_CANDIDATES
+            raise ArgumentError,
+                  "Retrieval profile #{key.inspect}: rerank_candidates #{candidates} exceeds #{MAX_RERANK_CANDIDATES}."
+          end
+          top_n = opts[:rerank_top_n].nil? ? nil : positive_int!(key, :rerank_top_n, opts[:rerank_top_n])
+          if top_n && top_n > candidates
+            raise ArgumentError,
+                  "Retrieval profile #{key.inspect}: rerank_top_n (#{top_n}) exceeds rerank_candidates (#{candidates})."
+          end
+          doc_chars = positive_int!(key, :rerank_max_document_chars, opts[:rerank_max_document_chars])
+          if doc_chars > MAX_RERANK_DOCUMENT_CHARS
+            raise ArgumentError,
+                  "Retrieval profile #{key.inspect}: rerank_max_document_chars #{doc_chars} exceeds " \
+                  "#{MAX_RERANK_DOCUMENT_CHARS}."
+          end
+          timeout = opts[:rerank_timeout]
+          unless timeout.is_a?(Numeric) && timeout.positive?
+            raise ArgumentError, "Retrieval profile #{key.inspect}: rerank_timeout must be a positive number."
+          end
+          failure = opts[:on_rerank_failure].to_s.to_sym
+          unless FAILURE_MODES.include?(failure)
+            raise ArgumentError,
+                  "Retrieval profile #{key.inspect}: on_rerank_failure must be one of #{FAILURE_MODES.inspect}."
+          end
+          budget = opts[:max_total_tokens].nil? ? nil : positive_int!(key, :max_total_tokens, opts[:max_total_tokens])
+
+          Profile.new(
+            name: key, k: k, max_k: max_k, hybrid: normalize_hybrid!(key, opts[:hybrid]),
+            reranker: reranker, rerank_candidates: candidates, rerank_top_n: top_n,
+            rerank_max_document_chars: doc_chars, rerank_timeout: timeout,
+            on_rerank_failure: failure, max_total_tokens: budget,
+          ).freeze
+        end
+
+        def positive_int!(key, option, value)
+          unless value.is_a?(Integer) && value.positive?
+            raise ArgumentError,
+                  "Retrieval profile #{key.inspect}: #{option} must be a positive Integer (got #{value.inspect})."
+          end
+          value
+        end
+
+        def normalize_hybrid!(key, hybrid)
+          return nil if hybrid.nil? || hybrid == false
+          return {} if hybrid == true
+          unless hybrid.is_a?(Hash)
+            raise ArgumentError, "Retrieval profile #{key.inspect}: hybrid must be true or a Hash."
+          end
+          extra = hybrid.keys.map(&:to_sym) - HYBRID_KEYS
+          unless extra.empty?
+            raise ArgumentError,
+                  "Retrieval profile #{key.inspect}: unknown hybrid option(s) #{extra.inspect}. " \
+                  "Allowed: #{HYBRID_KEYS.inspect}."
+          end
+          Marshal.load(Marshal.dump(hybrid.transform_keys(&:to_sym))).freeze
+        end
+      end
+    end
+
+    # Wraps a registered reranker with a profile's budgets. Every document
+    # is cut to `rerank_max_document_chars`, the call is charged to the
+    # caller's spend budget through `charge`, and the provider call is
+    # bounded by `rerank_timeout`. On a timeout or provider failure it
+    # either returns nil (the retriever then keeps the retrieval order) and
+    # records the reason, or re-raises, per `on_rerank_failure`.
+    #
+    # The text it receives has already passed the `semantic_search` text
+    # source check, so it never contains a field outside the agent's
+    # effective `agent_fields`.
+    class BudgetedReranker
+      attr_reader :stats
+
+      # @param inner [#rerank] the registered reranker.
+      # @param profile [Profiles::Profile]
+      # @param charge [Proc, nil] `charge.call(tokens)`; may raise to refuse.
+      def initialize(inner, profile, charge: nil)
+        @inner = inner
+        @profile = profile
+        @charge = charge
+        @stats = { used: false, documents: 0, chars: 0, tokens_estimated: 0,
+                   duration_ms: 0.0, fallback: false, fallback_reason: nil }
+      end
+
+      # Longest query sent to a reranker. The query is paired with every
+      # document in the provider call, so an unbounded query multiplies the
+      # cost of every rerank.
+      MAX_QUERY_CHARS = 2_000
+
+      def rerank(query:, documents:, top_n: nil)
+        limit = @profile.rerank_max_document_chars
+        query = query.to_s[0, MAX_QUERY_CHARS]
+        docs = Array(documents).map { |d| d.to_s[0, limit] }
+        tokens = Parse::Embeddings::SpendCap.estimate_tokens(query) * [docs.length, 1].max +
+                 docs.sum { |d| Parse::Embeddings::SpendCap.estimate_tokens(d) }
+        @stats.merge!(used: true, documents: docs.length, chars: docs.sum(&:length), tokens_estimated: tokens)
+        @charge&.call(tokens)
+
+        started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        begin
+          Timeout.timeout(@profile.rerank_timeout) do
+            @inner.rerank(query: query, documents: docs, top_n: top_n)
+          end
+        rescue Timeout::Error, StandardError => e
+          raise if @profile.on_rerank_failure == :raise
+          @stats[:fallback] = true
+          @stats[:fallback_reason] = e.is_a?(Timeout::Error) ? "timeout" : e.class.name
+          nil
+        ensure
+          @stats[:duration_ms] = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round(1)
+        end
+      end
+    end
+
+    @rerankers = {}
+    @rerankers_mutex = Mutex.new
+
+    class << self
+      # Register a reranker under a name that retrieval profiles reference.
+      # Profiles name rerankers instead of embedding them so provider
+      # objects (and their credentials) stay server-side.
+      #
+      # @param name [Symbol, String]
+      # @param reranker [#rerank]
+      def register_reranker(name, reranker)
+        unless reranker.respond_to?(:rerank)
+          raise ArgumentError, "Parse::Retrieval.register_reranker: #{reranker.class} does not respond to #rerank."
+        end
+        @rerankers_mutex.synchronize { @rerankers[name.to_s] = reranker }
+      end
+
+      # @return [#rerank, nil]
+      def reranker(name)
+        @rerankers_mutex.synchronize { @rerankers[name.to_s] }
+      end
+
+      def reranker_registered?(name)
+        !reranker(name).nil?
+      end
+
+      def reset_rerankers!
+        @rerankers_mutex.synchronize { @rerankers.clear }
+      end
+    end
+  end
+end

data/lib/parse/retrieval/retriever.rb

@@ -342,7 +342,11 @@ module Parse
       sym = field.to_sym
       fmap = klass.respond_to?(:field_map) ? klass.field_map : {}
       mapped = fmap[sym]
-      (mapped || sym.to_s.columnize).to_s
+      return mapped.to_s if mapped
+      # An exact declared server name (`title_exact`, `PublicText`) is kept
+      # as written, matching Parse::Agent::MetadataRegistry.wire_field_names.
+      return field.to_s if fmap.values.any? { |v| v.to_s == field.to_s }
+      sym.to_s.columnize
     end
 
     # @!visibility private
@@ -359,9 +363,14 @@ module Parse
     # document's presentation text (the same `text_field` used for
     # chunking). Index alignment between `documents` and `raw_hits` is
     # preserved so the returned `index` maps back to the right hit.
+    #
+    # A reranker that returns nil (Parse::Retrieval::BudgetedReranker after
+    # a timeout or provider failure under `on_rerank_failure: :fallback`)
+    # keeps the retrieval order, trimmed to `top_n`.
     def apply_rerank(reranker, query, raw_hits, text_wire, top_n)
       documents = raw_hits.map { |doc| fetch_field(doc, text_wire, text_wire).to_s }
       results = reranker.rerank(query: query, documents: documents, top_n: top_n)
+      return top_n ? raw_hits.first(top_n) : raw_hits if results.nil?
       results.map do |r|
         hit = raw_hits[r.index]
         next nil if hit.nil?

data/lib/parse/retrieval.rb

@@ -8,3 +8,5 @@
 # `semantic_search` agent tool (which depends on the agent layer) is
 # loaded separately from `lib/parse/agent.rb`.
 require_relative "retrieval/retriever"
+require_relative "retrieval/profiles"
+require_relative "retrieval/benchmark"

data/lib/parse/schema/search_index_migrator.rb

@@ -67,7 +67,7 @@ module Parse
       def plan
         coll = collection_name
         existing, available = fetch_existing_indexes(coll)
-        declared = @model_class.mongo_search_index_declarations.map { |d| effective_declaration(d) }
+        declared = all_declarations.map { |d| effective_declaration(d) }
 
         existing_by_name = existing.each_with_object({}) do |idx, h|
           name = (idx["name"] || idx[:name]).to_s
@@ -131,6 +131,7 @@ module Parse
       #   - `:wait_results` — Hash{name => :ready|:failed|:timeout} when
       #     `wait: true`; empty otherwise.
       def apply!(update: false, drop: false, wait: false, timeout: 600)
+        load_atlas_search!
         p = plan
         coll = p[:collection]
         wait_results = {}
@@ -189,6 +190,17 @@ module Parse
 
       private
 
+      # Hand-written `mongo_search_index` declarations plus definitions
+      # generated by `vector_search_index` (computed now, from the model's
+      # current declarations).
+      def all_declarations
+        declared = @model_class.mongo_search_index_declarations.dup
+        if @model_class.respond_to?(:generated_vector_search_index_declarations)
+          declared.concat(@model_class.generated_vector_search_index_declarations)
+        end
+        declared
+      end
+
       # Augment a `vectorSearch` declaration with the model's registered
       # `agent_tenant_scope` field as a `type: "filter"` path when the
       # declaration doesn't already carry it. Tenant-scoped retrieval
@@ -242,15 +254,21 @@ module Parse
       # Search support) — the migrator degrades gracefully and treats
       # the absence as "no indexes yet".
       def fetch_existing_indexes(coll)
-        unless defined?(Parse::AtlasSearch::IndexManager)
-          return [[], false]
-        end
         return [[], false] unless mongodb_enabled?
+        load_atlas_search!
         [Parse::AtlasSearch::IndexManager.list_indexes(coll, force_refresh: true), true]
-      rescue Parse::AtlasSearch::NotAvailable, StandardError
+      rescue StandardError # includes Parse::AtlasSearch::NotAvailable
         [[], false]
       end
 
+      # Parse::AtlasSearch is not loaded with the SDK. Load it here instead
+      # of testing `defined?(Parse::AtlasSearch...)`: the namespace can
+      # already exist (protected_paths.rb opens it early) without the
+      # IndexManager or the error classes the migrator needs.
+      def load_atlas_search!
+        require_relative "../atlas_search"
+      end
+
       def mongodb_enabled?
         defined?(Parse::MongoDB) &&
           Parse::MongoDB.respond_to?(:enabled?) &&

data/lib/parse/schema.rb

@@ -53,7 +53,9 @@ module Parse
     # Parse field type mappings to Ruby types
     TYPE_MAP = {
       "String" => :string,
-      "Number" => :integer,
+      # A Number column holds integral and fractional values; :number keeps
+      # integers as Integer and fractional values as Float.
+      "Number" => :number,
       "Boolean" => :boolean,
       "Date" => :date,
       "File" => :file,
@@ -71,6 +73,7 @@ module Parse
       string: "String",
       integer: "Number",
       float: "Number",
+      number: "Number",
       boolean: "Boolean",
       date: "Date",
       file: "File",
@@ -83,8 +86,51 @@ module Parse
       relation: "Relation",
       bytes: "Bytes",
       acl: "ACL",
+      # SDK-only property types with no native Parse column type. They are
+      # stored in the column type Parse Server actually holds them as.
+      vector: "Array",
+      timezone: "String",
+      time_zone: "String",
+      phone: "String",
+      email: "String",
     }.freeze
 
+    # Resolve the local type of a model field for schema comparison and
+    # migration. `fields` has no entry for a `has_many through: :relation`
+    # association, so a field that only appears in `relations` is reported
+    # as `:relation`.
+    # @param model_class [Class] a Parse::Object subclass
+    # @param name [Symbol] the canonical field name (a `field_map` key)
+    # @return [Symbol, nil]
+    def self.local_field_type(model_class, name)
+      type = model_class.fields[name]
+      return type.to_sym unless type.nil?
+      return :relation if model_class.respond_to?(:relations) && model_class.relations.key?(name.to_sym)
+      nil
+    end
+
+    # Build the server column definition for a model field, including the
+    # `targetClass` a Pointer or Relation column requires.
+    # @param model_class [Class] a Parse::Object subclass
+    # @param name [Symbol] the canonical field name (a `field_map` key)
+    # @param wire [String, Symbol] the server column name
+    # @return [Hash] the column definition, e.g. `{ "type" => "Pointer", "targetClass" => "Author" }`
+    def self.field_definition_for(model_class, name, wire)
+      type = local_field_type(model_class, name) || :string
+      parse_type = REVERSE_TYPE_MAP[type] || "String"
+      definition = { "type" => parse_type }
+      case parse_type
+      when "Pointer"
+        target = model_class.references[wire.to_s] || model_class.references[wire.to_sym] ||
+                 model_class.references[name]
+        definition["targetClass"] = target.to_s if target
+      when "Relation"
+        target = model_class.relations[name.to_sym] || model_class.relations[wire.to_sym]
+        definition["targetClass"] = target.to_s if target
+      end
+      definition
+    end
+
     class << self
       # Fetch all schemas from the Parse Server.
       # @param client [Parse::Client] optional client to use
@@ -247,7 +293,7 @@ module Parse
         @model_class.field_map.each do |name, wire|
           next if core_field?(name)
           next if server.include?(wire.to_s)
-          missing[name] = @model_class.fields[name]
+          missing[name] = Parse::Schema.local_field_type(@model_class, name)
         end
         missing
       end
@@ -263,7 +309,7 @@ module Parse
         server.each do |name, info|
           # Skip core fields
           next if %w[objectId createdAt updatedAt ACL].include?(name)
-          missing[name] = info[:type] unless local.include?(name) || local.include?(name.underscore.to_sym)
+          missing[name] = info[:type] unless local.include?(name) || local.include?(name.underscore)
         end
         missing
       end
@@ -285,7 +331,7 @@ module Parse
         mismatches = {}
         @model_class.field_map.each do |name, wire|
           next if core_field?(name)
-          local_type = @model_class.fields[name]
+          local_type = Parse::Schema.local_field_type(@model_class, name)
           next if local_type.nil?
           server_type = @server_schema.field_type(wire.to_s)
           next unless server_type
@@ -359,8 +405,15 @@ module Parse
         @model_class.fields.reject { |k, _| core_field?(k) }
       end
 
+      # Every local name a server column may match: field keys plus the
+      # canonical and wire names in `field_map` (which also covers
+      # `has_many through: :relation` columns, absent from `fields`).
       def local_field_names
-        local_fields.keys.map(&:to_s)
+        names = local_fields.keys.map(&:to_s)
+        @model_class.field_map.each do |name, wire|
+          names << name.to_s << wire.to_s
+        end
+        names.uniq
       end
 
       def server_field_names
@@ -371,10 +424,16 @@ module Parse
         %i[id object_id created_at updated_at acl objectId createdAt updatedAt ACL].include?(name.to_sym)
       end
 
+      # Types that compare equal to the server column they are stored in:
+      # a `:vector` is an Array column, and `:timezone`, `:phone`, and
+      # `:email` are String columns.
       def normalize_type(type)
         case type.to_sym
         when :integer, :float, :number then :number
         when :geo_point then :geopoint
+        when :geo_polygon then :polygon
+        when :vector then :array
+        when :timezone, :time_zone, :phone, :email then :string
         else type.to_sym
         end
       end
@@ -414,11 +473,11 @@ module Parse
         end
 
         @diff.missing_on_server.each do |name, type|
-          ops << {
-            action: :add_field,
-            field: @model_class.field_map[name].to_s,
-            type: REVERSE_TYPE_MAP[type] || "String",
-          }
+          wire = @model_class.field_map[name]
+          definition = Parse::Schema.field_definition_for(@model_class, name, wire)
+          op = { action: :add_field, field: wire.to_s, type: definition["type"] }
+          op[:target_class] = definition["targetClass"] if definition["targetClass"]
+          ops << op
         end
 
         ops
@@ -435,7 +494,8 @@ module Parse
           when :create_class
             lines << "  CREATE CLASS #{op[:class_name]}"
           when :add_field
-            lines << "  ADD FIELD #{op[:field]} (#{op[:type]})"
+            target = op[:target_class] ? " -> #{op[:target_class]}" : ""
+            lines << "  ADD FIELD #{op[:field]} (#{op[:type]}#{target})"
           end
         end
         lines.join("\n")
@@ -469,7 +529,8 @@ module Parse
         # Add missing fields
         @diff.missing_on_server.each do |name, type|
           field_name = @model_class.field_map[name].to_s
-          field_schema = { "fields" => { field_name => field_definition(type) } }
+          definition = Parse::Schema.field_definition_for(@model_class, name, field_name)
+          field_schema = { "fields" => { field_name => definition } }
 
           response = @client.update_schema(@model_class.parse_class, field_schema)
           if response.success?
@@ -494,7 +555,7 @@ module Parse
         # multi-word or custom-`field:` property.
         @model_class.field_map.each do |name, wire|
           next if %i[id object_id created_at updated_at acl objectId createdAt updatedAt ACL].include?(name)
-          fields[wire.to_s] = field_definition(@model_class.fields[name])
+          fields[wire.to_s] = Parse::Schema.field_definition_for(@model_class, name, wire)
         end
 
         # Add pointer targets. `references` is keyed by the wire column name
@@ -533,11 +594,6 @@ module Parse
         end
         Parse::Schema.default_class_level_permissions
       end
-
-      def field_definition(type)
-        parse_type = REVERSE_TYPE_MAP[type.to_sym] || "String"
-        { "type" => parse_type }
-      end
     end
   end
 end

data/lib/parse/stack/tasks.rb

@@ -21,8 +21,10 @@ module Parse
 
       # Installs the rake tasks.
       def install_tasks
-        if defined?(::Rails)
-          unless Rake::Task.task_defined?("db:seed") || Rails.root.blank?
+        # `Rails` alone is not enough: gems such as rails-html-sanitizer
+        # define a bare `Rails` module with no `root` or `application`.
+        if defined?(::Rails) && ::Rails.respond_to?(:root)
+          unless Rake::Task.task_defined?("db:seed") || ::Rails.root.blank?
             namespace :db do
               desc "Seeds your database with by loading db/seeds.rb"
               task :seed => "parse:env" do
@@ -36,8 +38,8 @@ module Parse
           task :env do
             if Rake::Task.task_defined?("environment")
               Rake::Task["environment"].invoke
-              if defined?(::Rails)
-                Rails.application.eager_load! if Rails.application.present?
+              if defined?(::Rails) && ::Rails.respond_to?(:application)
+                ::Rails.application.eager_load! if ::Rails.application.present?
               end
             end
           end

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.7.6"
+    VERSION = "5.8.0"
   end
 end