parse-stack-next 4.5.0 → 5.0.1

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

@@ -0,0 +1,285 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require_relative "../../vector_search"
+require_relative "../../embeddings"
+
+module Parse
+  module Core
+    # Class-level `find_similar` wrapper around {Parse::VectorSearch.search}
+    # for any Parse::Object subclass that has declared at least one
+    # `:vector` property.
+    #
+    # The wrapper handles three things the low-level entry point doesn't:
+    #
+    # 1. **Field resolution.** Defaults to the subclass's single
+    #    `:vector` property; raises if the class has none, requires
+    #    explicit `field:` if it has more than one.
+    # 2. **Declared-dimension validation.** Compares the query vector's
+    #    length against the `dimensions:` declared on the property,
+    #    so callers get "expected 1536, got 768" instead of an Atlas-
+    #    side error after a round-trip.
+    # 3. **Index auto-discovery.** Looks up the Atlas vectorSearch
+    #    index covering the field via
+    #    {Parse::AtlasSearch::IndexCatalog.find_vector_index} when no
+    #    explicit `index:` kwarg is given.
+    #
+    # ACL/CLP enforcement is inherited from {Parse::VectorSearch.search}
+    # (which routes through {Parse::MongoDB} — REST `/aggregate` is
+    # master-key-only and bypasses ACL/CLP, see CLAUDE.md). The full
+    # scope-kwarg surface (`session_token:`, `master:`, `acl_user:`,
+    # `acl_role:`) is forwarded as-is.
+    #
+    # @example default field, default index
+    #   WikiArticle.find_similar(vector: query_embedding, k: 5)
+    #
+    # @example explicit field + post-filter, scoped to a session
+    #   Document.find_similar(
+    #     vector: embed.call("ruby parse"),
+    #     field: :body_embedding,
+    #     k: 10,
+    #     filter: { tag: "ruby" },
+    #     session_token: user.session_token,
+    #   )
+    module VectorSearchable
+      # Raised when the calling class has no `:vector` property to
+      # search against. Distinct from {Parse::VectorSearch::InvalidQueryVector}
+      # because the misuse is at the class level, not the query level.
+      class NoVectorProperty < ArgumentError; end
+
+      # Raised when a class declares more than one `:vector` property
+      # and the caller didn't pass `field:` to disambiguate.
+      class AmbiguousVectorField < ArgumentError; end
+
+      # Raised when no Atlas vectorSearch index covers the requested
+      # field and the caller didn't pass an explicit `index:` kwarg.
+      class IndexNotResolved < ArgumentError; end
+
+      # Raised by the `find_similar(text:)` overload when the resolved
+      # `:vector` property has no `provider:` (and therefore no way to
+      # turn `text:` into a query vector). Distinct from
+      # {Parse::Embeddings::ProviderNotRegistered} (registry miss) — this
+      # is a class-declaration miss: the field was declared without
+      # binding it to a provider at the property level.
+      class EmbedderNotConfigured < ArgumentError; end
+
+      # Find documents whose declared `:vector` property is closest to
+      # `vector:` under the Atlas vectorSearch index's similarity
+      # function.
+      #
+      # @param vector [Array<Float>, Parse::Vector, nil] the query
+      #   embedding. Mutually exclusive with `text:` — exactly one of the
+      #   two must be given.
+      # @param text [String, nil] natural-language query. When given, the
+      #   resolved field's declared `provider:` is looked up via
+      #   {Parse::Embeddings.provider}, used to embed `[text]` with
+      #   `input_type: :search_query`, and the resulting vector is used
+      #   in place of `vector:`. Requires the property to have been
+      #   declared with `provider:` metadata.
+      # @param k [Integer] number of hits to return. Default 10.
+      # @param field [Symbol, String, nil] the `:vector` property to
+      #   search. Auto-resolves when the class has exactly one
+      #   `:vector` property.
+      # @param filter [Hash, nil] post-`$vectorSearch` `$match` filter.
+      # @param vector_filter [Hash, nil] Atlas-native pre-search filter
+      #   (fields must be declared `type: "filter"` in the index).
+      # @param index [String, nil] explicit vectorSearch index name.
+      #   Skips auto-discovery when given.
+      # @param num_candidates [Integer, nil] HNSW search width.
+      # @param max_time_ms [Integer, nil] server-side timeout.
+      # @param raw [Boolean] when true return the raw Mongo documents
+      #   (each enriched with `_vscore`); when false (default) build
+      #   instances of the calling class and attach `vector_score`.
+      # @param scope_opts [Hash] ACL/CLP scope kwargs forwarded to
+      #   {Parse::VectorSearch.search}: `session_token:`, `master:`,
+      #   `acl_user:`, `acl_role:`.
+      # @return [Array<Parse::Object>, Array<Hash>] hits in
+      #   descending-similarity order. Each instance responds to
+      #   `vector_score` (the Atlas `vectorSearchScore`).
+      # @raise [NoVectorProperty] when the class has no `:vector`
+      #   property.
+      # @raise [AmbiguousVectorField] when the class has more than one
+      #   `:vector` property and `field:` was omitted.
+      # @raise [Parse::VectorSearch::InvalidQueryVector] when the query
+      #   vector's shape doesn't match the declared dimensions.
+      # @raise [IndexNotResolved] when no covering vectorSearch index
+      #   exists and no explicit `index:` was given.
+      # @raise [ArgumentError] when neither `vector:` nor `text:` is
+      #   given, or both are given.
+      # @raise [EmbedderNotConfigured] when `text:` is given but the
+      #   resolved field's property has no `provider:` declared.
+      # @raise [Parse::Embeddings::ProviderNotRegistered] when the
+      #   declared `provider:` was never registered via
+      #   {Parse::Embeddings.register}.
+      # @raise [Parse::Embeddings::InvalidResponseError] when the
+      #   registered provider returns a payload that is not a single
+      #   vector (defense-in-depth above {Parse::Embeddings::Provider#validate_response!}).
+      #
+      # @note When `text:` is given, the text is sent over the wire to
+      #   the embedding provider (e.g. OpenAI). Operators that enable
+      #   global Faraday request logging on the embedding connection
+      #   will capture the full query text in the JSON request body.
+      #   Treat `text:` as user-visible content for log-handling
+      #   purposes.
+      # @note The provider is responsible for bounding its own request
+      #   timeout. {Parse::Embeddings::OpenAI} self-bounds at 30 s read
+      #   / 5 s connect with capped retries. Custom providers MUST
+      #   self-bound — `find_similar` does not impose a wall-clock
+      #   deadline on the embed step.
+      def find_similar(vector: nil, text: nil, k: 10, field: nil, filter: nil,
+                       vector_filter: nil, index: nil,
+                       num_candidates: nil, max_time_ms: nil, raw: false,
+                       **scope_opts)
+        if vector.nil? && text.nil?
+          raise ArgumentError,
+                "#{self}.find_similar: must pass either `vector:` or `text:`."
+        end
+        if !vector.nil? && !text.nil?
+          raise ArgumentError,
+                "#{self}.find_similar: pass either `vector:` or `text:`, not both."
+        end
+
+        resolved_field = resolve_vector_field!(field)
+        declared_dims = vector_properties.dig(resolved_field, :dimensions)
+
+        query_vector =
+          if text.nil?
+            coerce_query_vector(vector)
+          else
+            embed_query_text!(text, resolved_field)
+          end
+        Parse::VectorSearch.validate_query_vector!(query_vector, dimensions: declared_dims)
+
+        index_name = resolve_vector_index!(resolved_field, index)
+
+        raw_hits = Parse::VectorSearch.search(
+          parse_class,
+          field: resolved_field,
+          query_vector: query_vector,
+          k: k,
+          num_candidates: num_candidates,
+          filter: filter,
+          vector_filter: vector_filter,
+          index: index_name,
+          max_time_ms: max_time_ms,
+          **scope_opts,
+        )
+
+        return raw_hits if raw
+        build_vector_hits(raw_hits)
+      end
+
+      private
+
+      def resolve_vector_field!(field)
+        declared = vector_properties.keys
+        if field
+          sym = field.to_sym
+          unless declared.include?(sym)
+            raise NoVectorProperty,
+                  "#{self}.find_similar: field :#{sym} is not a :vector property " \
+                  "(declared :vector fields: #{declared.inspect})."
+          end
+          return sym
+        end
+        if declared.length == 1
+          return declared.first
+        end
+        if declared.empty?
+          raise NoVectorProperty,
+                "#{self}.find_similar: no :vector property declared on this class."
+        end
+        raise AmbiguousVectorField,
+              "#{self}.find_similar: class declares multiple :vector properties " \
+              "(#{declared.inspect}); pass `field:` to disambiguate."
+      end
+
+      # Maximum bytes accepted for the `text:` overload. 256 KiB is well
+      # above any reasonable embedding-model token budget (8K tokens ≈
+      # 32 KB UTF-8) and keeps a runaway caller from shipping multi-MB
+      # bodies to the provider — and from filling operator error-trackers
+      # with the captured request body when the provider eventually 400s.
+      MAX_QUERY_TEXT_BYTES = 256 * 1024
+
+      # Embed a natural-language query against the provider declared on
+      # the resolved `:vector` property. Validates the text input here
+      # (rather than letting the provider raise its own message) so the
+      # error trace points at `find_similar`, not at HTTP-layer code.
+      def embed_query_text!(text, resolved_field)
+        unless text.is_a?(String)
+          raise ArgumentError,
+                "#{self}.find_similar: `text:` must be a String (got #{text.class})."
+        end
+        if text.empty?
+          raise ArgumentError,
+                "#{self}.find_similar: `text:` is empty."
+        end
+        if text.bytesize > MAX_QUERY_TEXT_BYTES
+          raise ArgumentError,
+                "#{self}.find_similar: `text:` exceeds #{MAX_QUERY_TEXT_BYTES} bytes " \
+                "(#{text.bytesize}); embedding providers will reject it. Chunk the " \
+                "input client-side before calling find_similar(text:)."
+        end
+        provider_name = vector_properties.dig(resolved_field, :provider)
+        if provider_name.nil?
+          raise EmbedderNotConfigured,
+                "#{self}.find_similar: property :#{resolved_field} has no `provider:` " \
+                "declared; cannot embed `text:`. Declare `provider: :openai` (or other) " \
+                "on the property, or pass an explicit `vector:`."
+        end
+        provider = Parse::Embeddings.provider(provider_name)
+        vectors = provider.embed_text([text], input_type: :search_query)
+        unless vectors.is_a?(Array) && vectors.length == 1 && vectors.first.is_a?(Array)
+          raise Parse::Embeddings::InvalidResponseError,
+                "#{self}.find_similar: provider #{provider_name.inspect} did not return " \
+                "a single vector for `text:` (got #{vectors.inspect[0, 80]})."
+        end
+        vectors.first
+      end
+
+      def coerce_query_vector(vector)
+        case vector
+        when Parse::Vector then vector.to_a
+        when Array         then vector
+        else
+          raise Parse::VectorSearch::InvalidQueryVector,
+                "vector: must be an Array<Float> or Parse::Vector (got #{vector.class})."
+        end
+      end
+
+      def resolve_vector_index!(field, explicit_index)
+        return explicit_index if explicit_index && !explicit_index.to_s.empty?
+        begin
+          require_relative "../../atlas_search"
+        rescue LoadError
+          raise IndexNotResolved,
+                "#{self}.find_similar: no index: given and Parse::AtlasSearch " \
+                "could not be loaded; pass an explicit index: kwarg."
+        end
+        idx = Parse::AtlasSearch::IndexCatalog.find_vector_index(parse_class, field: field)
+        if idx.nil?
+          raise IndexNotResolved,
+                "#{self}.find_similar: no vectorSearch index found covering " \
+                "#{parse_class}.#{field}; pass index: explicitly or create one " \
+                "via Parse::AtlasSearch::IndexCatalog.create_index."
+        end
+        (idx["name"] || idx[:name]).to_s
+      end
+
+      def build_vector_hits(raw_hits)
+        return [] if raw_hits.nil? || raw_hits.empty?
+        converted = Parse::MongoDB.convert_documents_to_parse(raw_hits, parse_class)
+        converted.each_with_index.map do |doc, idx|
+          obj = Parse::Object.build(doc, parse_class)
+          next nil unless obj
+          score = raw_hits[idx]["_vscore"] || raw_hits[idx][:_vscore]
+          # `vector_score` reader is defined once on Parse::Object — see
+          # lib/parse/model/object.rb — so we only need to set the ivar
+          # here. No per-row singleton methods.
+          obj.instance_variable_set(:@_vector_score, score) if score
+          obj
+        end.compact
+      end
+    end
+  end
+end

data/lib/parse/model/file.rb

@@ -221,8 +221,7 @@ module Parse
 
         size_cap = max_remote_size
         timeout = remote_timeout
-        URI.open(uri,
-                 read_timeout: timeout,
+        uri.open(read_timeout: timeout,
                  open_timeout: timeout,
                  redirect: false,
                  content_length_proc: ->(len) {
@@ -479,10 +478,23 @@ module Parse
     end
 
     # Save the file by uploading it to Parse and creating a file pointer.
+    # @param session_token [String, nil] thread an authenticated user's
+    #   session token through the upload. Required when the SDK is running
+    #   in client mode against a Parse Server with
+    #   `fileUpload.enableForAuthenticatedUser` on (the typical safe
+    #   configuration). When nil, the upload uses whatever auth the
+    #   default client carries — which for client-mode builds is anonymous.
+    # @param use_master_key [Boolean, nil] explicitly opt in or out of
+    #   master-key auth for this upload. Defaults to the client's
+    #   configured behavior. Pass `false` in client-mode code to assert
+    #   that no master key is smuggled into the upload.
     # @return [Boolean] true if successfully uploaded and saved.
-    def save
+    def save(session_token: nil, use_master_key: nil)
       unless saved? || @contents.nil? || @name.nil?
-        response = client.create_file(@name, @contents, @mime_type)
+        opts = {}
+        opts[:session_token]   = session_token unless session_token.nil?
+        opts[:use_master_key]  = use_master_key unless use_master_key.nil?
+        response = client.create_file(@name, @contents, @mime_type, **opts)
         unless response.error?
           result = response.result
           @name = result[FIELD_NAME] || File.basename(result[FIELD_URL])

data/lib/parse/model/model.rb

@@ -102,12 +102,17 @@ module Parse
     # names used in Parse, we will need to have a dynamic lookup system where
     # when a parse class name received, we go through all of our subclasses to determine
     # which Parse::Object subclass is responsible for handling this Parse table class.
-    # we use @@model_cache to cache the results of the algorithm since we do this frequently
-    # when encoding and decoding objects.
-    # @!visibility private
-    @@model_cache = {}
+    # The cache is held as a class-instance variable on the singleton (rather than a
+    # `@@class_var`) and guarded by a Mutex so concurrent encode/decode paths cannot
+    # tear the underlying Hash. Class-instance state also keeps the cache out of any
+    # subclass's reach, matching the per-class-state convention used elsewhere in
+    # the SDK (see Parse::ACLScope `@no_acl_warned`).
+    @model_cache = {}
+    @model_cache_mutex = Mutex.new
 
     class << self
+      # @!visibility private
+      attr_reader :model_cache, :model_cache_mutex
       # @!attribute self.raise_on_save_failure
       # By default, we return `true` or `false` for save and destroy operations.
       # If you prefer to have `Parse::Object` raise an exception instead, you
@@ -179,13 +184,24 @@ module Parse
       # legitimate findables. Rescue per-descendant so the iteration
       # continues past the unnamed-and-default-parse_class case while
       # still considering anonymous-but-overridden ones.
-      @@model_cache[str] ||= Parse::Object.descendants.find do |f|
-        begin
-          cls = f.parse_class
-        rescue StandardError
-          next false
+      # Reference Parse::Model directly: this class method is inherited by
+      # subclasses (e.g. Parse::Object.find_class), so a bare `@model_cache`
+      # would resolve on the subclass singleton — which has no cache. The
+      # cache lives on Parse::Model itself.
+      Parse::Model.model_cache_mutex.synchronize do
+        cached = Parse::Model.model_cache[str]
+        return cached if cached
+
+        result = Parse::Object.descendants.find do |f|
+          begin
+            cls = f.parse_class
+          rescue StandardError
+            next false
+          end
+          cls == str || cls == "_#{str}"
         end
-        cls == str || cls == "_#{str}"
+        Parse::Model.model_cache[str] = result if result
+        result
       end
     end
   end

data/lib/parse/model/object.rb

@@ -23,6 +23,7 @@ require_relative "date"
 require_relative "time_zone"
 require_relative "phone"
 require_relative "email"
+require_relative "vector"
 require_relative "acl"
 require_relative "clp"
 require_relative "push"
@@ -35,6 +36,8 @@ require_relative "core/describe"
 require_relative "core/indexing"
 require_relative "core/search_indexing"
 require_relative "core/properties"
+require_relative "core/vector_searchable"
+require_relative "core/embed_managed"
 require_relative "core/errors"
 require_relative "core/builder"
 require_relative "core/enhanced_change_tracking"
@@ -117,7 +120,7 @@ module Parse
   #
   # All columns in a Parse object are considered a type of property (ex. string, numbers, arrays, etc)
   # except in two cases - Pointers and Relations. For a detailed discussion of properties, see
-  # The {https://github.com/modernistik/parse-stack#defining-properties Defining Properties} section.
+  # The {https://github.com/neurosynq/parse-stack-next#defining-properties Defining Properties} section.
   #
   # Associations:
   #
@@ -151,11 +154,33 @@ module Parse
     extend Core::Describe
     extend Core::Indexing
     extend Core::SearchIndexing
+    extend Core::VectorSearchable
+    include Core::EmbedManaged
     include Core::Fetching
     include Core::Actions
     # @!visibility private
     BASE_OBJECT_CLASS = "Parse::Object".freeze
 
+    # Search/vector-search result accessors. Populated by
+    # `Parse::AtlasSearch.process_search_results` and
+    # `Parse::Core::VectorSearchable.build_vector_hits` via
+    # `instance_variable_set`. Defined here once instead of per-result
+    # via `define_singleton_method` so high-k result sets don't inflate
+    # a singleton class per row, and so a user-defined override on a
+    # subclass can't silently desync from the ivar.
+    #
+    # Each returns nil unless the object was returned from the
+    # corresponding search path.
+    #
+    # @return [Float, nil] vectorSearch relevance score.
+    def vector_score; @_vector_score; end
+
+    # @return [Float, nil] Atlas Search relevance score.
+    def search_score; @_search_score; end
+
+    # @return [Hash, nil] Atlas Search highlights blob.
+    def search_highlights; @_search_highlights; end
+
     # @return [Model::TYPE_OBJECT]
     def __type; Parse::Model::TYPE_OBJECT; end
 
@@ -365,6 +390,7 @@ module Parse
       def default_acls
         @default_acls ||= case acl_policy_setting
                           when :public, :owner_else_public then Parse::ACL.everyone
+                          when :public_read, :owner_but_public_read then Parse::ACL.everyone(true, false)
                           when :private, :owner_else_private then Parse::ACL.private
                           else Parse::ACL.everyone
                           end
@@ -431,7 +457,7 @@ module Parse
       end
 
       # Valid ACL policies that can be passed to {acl_policy}.
-      VALID_ACL_POLICIES = [:public, :private, :owner_else_public, :owner_else_private].freeze
+      VALID_ACL_POLICIES = [:public, :public_read, :private, :owner_else_public, :owner_else_private, :owner_but_public_read].freeze
 
       # Declarative ACL policy applied to newly-created instances of this class.
       # The policy is resolved at save time so that explicit ACL changes by the
@@ -443,9 +469,16 @@ module Parse
       # 2. Owner pointer resolved from the declared `owner:` field → owner R/W only
       # 3. The else-half of the policy: `:public` → public R/W, `:private` → master-key only
       #
-      # @param policy [Symbol] one of `:public`, `:private`, `:owner_else_public`, `:owner_else_private`.
+      # @param policy [Symbol] one of `:public`, `:public_read`, `:private`,
+      #   `:owner_else_public`, `:owner_else_private`, `:owner_but_public_read`.
+      #   `:public_read` stamps `{"*": {"read": true}}` — anyone can read, no
+      #   one can write through ACL (only the master key can mutate). Useful
+      #   for catalog/lookup tables. `:owner_but_public_read` stamps the
+      #   resolved owner with R/W AND grants public read in the same ACL —
+      #   useful for publicly-viewable content with a single authoring user;
+      #   falls back to `:public_read` semantics when no owner resolves.
       # @param owner [Symbol,nil] the name of the property/belongs_to whose pointer designates the owner user.
-      #   Only meaningful for `:owner_else_*` policies.
+      #   Only meaningful for `:owner_*` policies.
       # @example
       #   class Post < Parse::Object
       #     acl_policy :owner_else_private, owner: :author
@@ -488,10 +521,14 @@ module Parse
             "declare a belongs_to pointer to the owning user."
         end
         if owner && !policy.to_s.start_with?("owner_")
-          warn "[#{self}] `owner:` is ignored when acl_policy is #{policy.inspect}; only :owner_else_public and :owner_else_private use it."
+          warn "[#{self}] `owner:` is ignored when acl_policy is #{policy.inspect}; only :owner_else_public, :owner_else_private, and :owner_but_public_read use it."
         end
         if owner.nil? && policy.to_s.start_with?("owner_")
-          fallback = (policy == :owner_else_public) ? "public R/W" : "master-key-only"
+          fallback = case policy
+                     when :owner_else_public then "public R/W"
+                     when :owner_but_public_read then "public read only"
+                     else "master-key-only"
+                     end
           warn "[#{self}] acl_policy #{policy.inspect} declared without `owner:` field; ACL resolution will always use the fallback (#{fallback}). Pass `as:` at construction to override."
         end
         @acl_policy_setting = policy
@@ -1180,6 +1217,20 @@ module Parse
         end
       end
 
+      # `:vector` fields are excluded from serialization by default —
+      # embeddings are large (often 1024–4096 floats), they leak ML
+      # signal to clients, and they round-trip through the dedicated
+      # embed/find_similar pipelines rather than the standard REST
+      # save/find. Pass `include_vectors: true` to opt back in (e.g.,
+      # for tests or internal mongo-direct bulk writes).
+      unless opts[:include_vectors] == true
+        vector_fields = self.class.respond_to?(:fields) ? self.class.fields(:vector).keys.map(&:to_s) : []
+        if vector_fields.any?
+          except = Array(opts[:except]).map(&:to_s) | vector_fields
+          opts = opts.merge(except: except)
+        end
+      end
+
       # When :only is specified without :strict, automatically include identification fields
       # so the serialized object can be properly identified
       if opts[:only] && !opts[:strict]
@@ -1807,6 +1858,8 @@ module Parse
       target_acl = case policy
                    when :public
                      Parse::ACL.everyone(true, true)
+                   when :public_read
+                     Parse::ACL.everyone(true, false)
                    when :private
                      Parse::ACL.private
                    when :owner_else_public
@@ -1825,6 +1878,10 @@ module Parse
                      else
                        Parse::ACL.private
                      end
+                   when :owner_but_public_read
+                     acl = Parse::ACL.everyone(true, false)
+                     acl.apply(owner_id, true, true) if owner_id
+                     acl
                    end
 
       # Only re-stamp if the resolved ACL differs from the init-time stamp;

data/lib/parse/model/pointer.rb

@@ -109,6 +109,20 @@ module Parse
     # @return [Model::TYPE_POINTER]
     def __type; Parse::Model::TYPE_POINTER; end
 
+    # Search/vector-search result accessors. Defined here (instead of
+    # only on Parse::Object) so that hydration paths which fall back to
+    # a Pointer — e.g. Atlas Search results whose `className` has no
+    # corresponding Ruby subclass loaded — still surface the score and
+    # highlights attached by `Parse::AtlasSearch.process_search_results`
+    # / `Parse::Core::VectorSearchable.build_vector_hits`. Each returns
+    # nil unless the instance came from the corresponding search path.
+    # @return [Float, nil]
+    def vector_score; @_vector_score; end
+    # @return [Float, nil]
+    def search_score; @_search_score; end
+    # @return [Hash, nil]
+    def search_highlights; @_search_highlights; end
+
     alias_method :className, :parse_class
     # A Parse object as a className field and objectId. In ruby, we will use the
     # id attribute method, but for usability, we will also alias it to objectId
@@ -289,9 +303,9 @@ module Parse
     # @param includes [Array<String>, nil] optional list of pointer fields to expand.
     # @return [Parse::Object] the fetched Parse::Object, nil otherwise.
     # @example Fetch pointer with caching
-    #   capture = capture_pointer.fetch_cache!
+    #   post = post_pointer.fetch_cache!
     # @example Partial fetch with caching
-    #   capture = capture_pointer.fetch_cache!(keys: [:title, :status])
+    #   post = post_pointer.fetch_cache!(keys: [:title, :status])
     # @see #fetch
     def fetch_cache!(keys: nil, includes: nil)
       fetch(keys: keys, includes: includes, cache: true)

data/lib/parse/model/shortnames.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "object"
 
 # Simple include to use short verion of core class names

data/lib/parse/model/validations/uniqueness_validator.rb

@@ -26,11 +26,11 @@ module Parse
     #     validates :username, uniqueness: { case_sensitive: false }
     #   end
     #
-    # @example Scoped uniqueness (unique within an organization)
+    # @example Scoped uniqueness (unique within a tenant)
     #   class Employee < Parse::Object
     #     property :employee_id, :string
-    #     belongs_to :organization
-    #     validates :employee_id, uniqueness: { scope: :organization }
+    #     belongs_to :tenant
+    #     validates :employee_id, uniqueness: { scope: :tenant }
     #   end
     #
     # @example With custom message