parse-stack-next 5.5.6 → 5.7.0

data/lib/parse/embeddings.rb

@@ -104,6 +104,7 @@ module Parse
     class InvalidImageURL < Error
       # @return [Symbol] failure-mode tag.
       attr_reader :reason
+
       def initialize(reason, message)
         @reason = reason
         super(message)
@@ -132,6 +133,7 @@ module Parse
         end
         super(name.to_sym, provider)
       end
+
       alias_method :store, :[]=
     end
 
@@ -247,6 +249,9 @@ module Parse
           @configuration = nil
           @allowed_image_hosts = nil
           @allowed_image_types = nil
+          @allowed_video_types = nil
+          @max_media_bytes = nil
+          BindingAudit.reset!
           @trust_provider_url_fetch = nil
         end
       end
@@ -323,6 +328,54 @@ module Parse
         @allowed_image_types ||= ImageFetch::DEFAULT_ALLOWED_IMAGE_TYPES
       end
 
+      # Configure the MIME types {VideoSource.verify!} accepts after
+      # magic-byte sniffing. Defaults to
+      # {VideoSource::DEFAULT_ALLOWED_VIDEO_TYPES}, which is MP4 only —
+      # the sole container Voyage accepts. As with images, the sniffed
+      # type — never the `Content-Type` header — is what gets checked.
+      #
+      # Widening this does NOT widen what a provider accepts: the
+      # Voyage adapter still enforces its own format and size limits.
+      #
+      # @param types [Array<String>] MIME type strings.
+      # @return [Array<String>]
+      def allowed_video_types=(types)
+        unless types.is_a?(Array) && !types.empty? &&
+               types.all? { |t| t.is_a?(String) && t.include?("/") }
+          raise ArgumentError,
+                "Parse::Embeddings.allowed_video_types= expects a non-empty Array of " \
+                "MIME type Strings (got #{types.inspect})."
+        end
+        CONFIG_MUTEX.synchronize { @allowed_video_types = types.dup.freeze }
+      end
+
+      # @return [Array<String>] MIME allowlist for video bytes (frozen).
+      def allowed_video_types
+        @allowed_video_types ||= VideoSource::DEFAULT_ALLOWED_VIDEO_TYPES
+      end
+
+      # Per-file ceiling for streamed media, checked by
+      # {MediaFile}. Voyage documents 20 MB per image and 20 MB per
+      # video; the default matches. Streaming keeps an oversized file
+      # from exhausting memory, but the provider still rejects it, so
+      # failing locally turns a wasted upload into an immediate error.
+      #
+      # @param bytes [Integer] positive byte count.
+      # @return [Integer]
+      def max_media_bytes=(bytes)
+        unless bytes.is_a?(Integer) && bytes.positive?
+          raise ArgumentError,
+                "Parse::Embeddings.max_media_bytes= expects a positive Integer " \
+                "(got #{bytes.inspect})."
+        end
+        CONFIG_MUTEX.synchronize { @max_media_bytes = bytes }
+      end
+
+      # @return [Integer] per-file ceiling for {MediaFile}, in bytes.
+      def max_media_bytes
+        @max_media_bytes ||= MediaFile::DEFAULT_MAX_MEDIA_BYTES
+      end
+
       # Sentinel-gated opt-in for forwarding image URLs to embedding
       # providers. Assign the exact {TRUST_PROVIDER_URL_FETCH_SENTINEL}
       # String to unlock; any other value (including `true`, `1`,
@@ -396,8 +449,7 @@ module Parse
       # @raise [InvalidImageURL] on any other validation failure.
       def validate_image_url!(url, allow_insecure: false, mode: :forward)
         unless mode == :fetch || trust_provider_url_fetch?
-          hint =
-            if allowed_image_hosts.empty?
+          hint = if allowed_image_hosts.empty?
               " First populate Parse::Embeddings.allowed_image_hosts with the CDN " \
               "hostnames you trust (currently empty — every host would be denied " \
               "even after the sentinel is set)."
@@ -412,30 +464,30 @@ module Parse
 
         unless url.is_a?(String) && !url.empty?
           raise InvalidImageURL.new(:parse,
-            "Parse::Embeddings.validate_image_url!: url must be a non-empty String " \
-            "(got #{url.class}).")
+                                    "Parse::Embeddings.validate_image_url!: url must be a non-empty String " \
+                                    "(got #{url.class}).")
         end
 
         uri = begin
-          URI.parse(url)
-        rescue URI::InvalidURIError => e
-          raise InvalidImageURL.new(:parse,
-            "Parse::Embeddings.validate_image_url!: invalid URL (#{e.message}).")
-        end
+            URI.parse(url)
+          rescue URI::InvalidURIError => e
+            raise InvalidImageURL.new(:parse,
+                                      "Parse::Embeddings.validate_image_url!: invalid URL (#{e.message}).")
+          end
 
         valid_schemes = allow_insecure ? %w[http https] : %w[https]
         unless valid_schemes.include?(uri.scheme)
           raise InvalidImageURL.new(:scheme,
-            "Parse::Embeddings.validate_image_url!: scheme must be #{valid_schemes.join(' or ')} " \
-            "(got #{uri.scheme.inspect}). Forwarding non-HTTPS image URLs to a provider " \
-            "leaks any embedded query-string secrets in cleartext.")
+                                    "Parse::Embeddings.validate_image_url!: scheme must be #{valid_schemes.join(" or ")} " \
+                                    "(got #{uri.scheme.inspect}). Forwarding non-HTTPS image URLs to a provider " \
+                                    "leaks any embedded query-string secrets in cleartext.")
         end
 
         if uri.userinfo
           raise InvalidImageURL.new(:userinfo,
-            "Parse::Embeddings.validate_image_url!: URL must not include userinfo " \
-            "credentials. Embedding providers will forward the full URL in their fetch " \
-            "and may log it.")
+                                    "Parse::Embeddings.validate_image_url!: URL must not include userinfo " \
+                                    "credentials. Embedding providers will forward the full URL in their fetch " \
+                                    "and may log it.")
         end
 
         # `uri.hostname` returns the IDNA-decoded form WITHOUT IPv6
@@ -446,7 +498,7 @@ module Parse
         host = uri.hostname
         if host.nil? || host.empty?
           raise InvalidImageURL.new(:parse,
-            "Parse::Embeddings.validate_image_url!: URL is missing a host.")
+                                    "Parse::Embeddings.validate_image_url!: URL is missing a host.")
         end
 
         # Reject non-canonical IPv4 forms (decimal `2130706433`,
@@ -463,9 +515,9 @@ module Parse
         # character).
         if ip_shaped_but_not_canonical?(host)
           raise InvalidImageURL.new(:host_blocked,
-            "Parse::Embeddings.validate_image_url!: host #{host.inspect} is an obfuscated " \
-            "or non-canonical IP literal. Use dotted-quad IPv4 (a.b.c.d) or canonical IPv6. " \
-            "Decimal/octal/hex IP forms are refused to prevent localhost-bypass attempts.")
+                                    "Parse::Embeddings.validate_image_url!: host #{host.inspect} is an obfuscated " \
+                                    "or non-canonical IP literal. Use dotted-quad IPv4 (a.b.c.d) or canonical IPv6. " \
+                                    "Decimal/octal/hex IP forms are refused to prevent localhost-bypass attempts.")
         end
 
         # **Image-host allowlist runs BEFORE the resolver hop.** Round-2
@@ -477,9 +529,9 @@ module Parse
         allowed = allowed_image_hosts
         if allowed.empty?
           raise InvalidImageURL.new(:host_not_allowlisted,
-            "Parse::Embeddings.validate_image_url!: Parse::Embeddings.allowed_image_hosts " \
-            "is empty — every image URL is denied. Add the CDN hostnames you trust before " \
-            "forwarding image URLs to a provider.")
+                                    "Parse::Embeddings.validate_image_url!: Parse::Embeddings.allowed_image_hosts " \
+                                    "is empty — every image URL is denied. Add the CDN hostnames you trust before " \
+                                    "forwarding image URLs to a provider.")
         end
         permitted = allowed.any? do |entry|
           if entry.start_with?(".")
@@ -491,8 +543,8 @@ module Parse
         end
         unless permitted
           raise InvalidImageURL.new(:host_not_allowlisted,
-            "Parse::Embeddings.validate_image_url!: host #{host.inspect} not in " \
-            "Parse::Embeddings.allowed_image_hosts (#{allowed.inspect}).")
+                                    "Parse::Embeddings.validate_image_url!: host #{host.inspect} not in " \
+                                    "Parse::Embeddings.allowed_image_hosts (#{allowed.inspect}).")
         end
 
         # Port allowlist runs after the host allowlist (cheap string
@@ -502,8 +554,8 @@ module Parse
         require_relative "model/file"
         unless Parse::File.allowed_remote_ports.include?(port)
           raise InvalidImageURL.new(:port,
-            "Parse::Embeddings.validate_image_url!: port #{port} not in " \
-            "Parse::File.allowed_remote_ports.")
+                                    "Parse::Embeddings.validate_image_url!: port #{port} not in " \
+                                    "Parse::File.allowed_remote_ports.")
         end
 
         # CIDR + DNS resolution last — most expensive (syscall). An
@@ -516,7 +568,7 @@ module Parse
         rescue ArgumentError => e
           tag = e.message.include?("private/internal address") ? :host_blocked : :parse
           raise InvalidImageURL.new(tag,
-            "Parse::Embeddings.validate_image_url!: #{e.message}")
+                                    "Parse::Embeddings.validate_image_url!: #{e.message}")
         end
 
         # Return the canonicalized URL so callers store/forward
@@ -590,5 +642,9 @@ require_relative "embeddings/qwen"
 require_relative "embeddings/local_http"
 require_relative "embeddings/spend_cap"
 require_relative "embeddings/image_fetch"
+require_relative "embeddings/video_source"
+require_relative "embeddings/streaming_body"
+require_relative "embeddings/media_file"
+require_relative "embeddings/binding_audit"
 require_relative "embeddings/cache"
 require_relative "embeddings/batch_embedder"

data/lib/parse/graphql/type_generator.rb

@@ -87,7 +87,7 @@ module Parse
         end
         collisions = by_gql_name.select { |_, names| names.size > 1 }
         return if collisions.empty?
-        details = collisions.map { |gql, parse| "#{gql} ← #{parse.join(', ')}" }.join('; ')
+        details = collisions.map { |gql, parse| "#{gql} ← #{parse.join(", ")}" }.join("; ")
         raise "Parse::GraphQL::TypeGenerator: graphql_name collisions: #{details}. " \
               "Parse class names that differ only by underscores collapse to the same " \
               "GraphQL type name. Rename or generate the conflicting classes separately."

data/lib/parse/graphql.rb

@@ -26,11 +26,11 @@ module Parse
       def available?
         return @gem_available if defined?(@gem_available)
         @gem_available = begin
-          require "graphql"
-          true
-        rescue LoadError
-          false
-        end
+            require "graphql"
+            true
+          rescue LoadError
+            false
+          end
       end
 
       # Force-reset the cached availability flag. Test-only.

data/lib/parse/live_query/client.rb

@@ -364,7 +364,7 @@ module Parse
       #   returned subscription and register callbacks later.
       # @return [Subscription]
       def subscribe(class_name, where: {}, fields: nil, keys: nil, watch: nil, session_token: nil,
-                    use_master_key: false, &block)
+                                use_master_key: false, &block)
         # Handle Parse::Object subclass
         if class_name.is_a?(Class) && class_name < Parse::Object
           class_name = class_name.parse_class

data/lib/parse/live_query.rb

@@ -83,7 +83,7 @@ module Parse
         prefix_parts = []
         prefix_parts << "request_id=#{request_id}" if request_id
         prefix_parts << "class=#{class_name}" if class_name
-        prefixed = prefix_parts.empty? ? text : "#{prefix_parts.join(' ')} #{text}"
+        prefixed = prefix_parts.empty? ? text : "#{prefix_parts.join(" ")} #{text}"
         super(prefixed)
       end
     end

data/lib/parse/lock.rb

@@ -93,10 +93,10 @@ module Parse
   module Lock
     KEY_PREFIX = "parse-stack:lock:v1:"
 
-    DEFAULT_TTL  = 3
+    DEFAULT_TTL = 3
     DEFAULT_WAIT = 2.0
-    MAX_TTL      = 30
-    MAX_WAIT     = 30
+    MAX_TTL = 30
+    MAX_WAIT = 30
 
     # Minimum byte-length for an explicit `secret:` kwarg. 16 bytes
     # ≈ 128 bits of separation between tenants — short enough not to
@@ -196,13 +196,13 @@ module Parse
       # @raise [Parse::Lock::UnavailableError] when `on_degraded: :raise`
       #   and the store is process-local.
       def acquire(key, ttl: DEFAULT_TTL, wait: DEFAULT_WAIT,
-                  on_degraded: :warn, secret: :auto, &block)
+                       on_degraded: :warn, secret: :auto, &block)
         raise ArgumentError, "block required" unless block_given?
         validated_key = validate_key!(key)
         validate_on_degraded!(on_degraded)
         validate_secret!(secret)
-        normalized_ttl  = clamp(Integer(ttl),  1,   MAX_TTL)
-        normalized_wait = clamp(Float(wait),   0.0, MAX_WAIT)
+        normalized_ttl = clamp(Integer(ttl), 1, MAX_TTL)
+        normalized_wait = clamp(Float(wait), 0.0, MAX_WAIT)
 
         # Route through Parse::LockBackend — the shared module that
         # also serves Parse::CreateLock. The KEY_PREFIX
@@ -216,15 +216,12 @@ module Parse
         # up the operator-configured secret if one exists; the
         # explicit-String branch overrides it; the explicit-nil
         # branch opts out without a warn.
-        resolved_secret =
-          case secret
-          when :auto   then Parse::LockBackend.lock_secret_for(store: store, source: "Parse::Lock")
-          when String  then secret
-          when nil     then nil
+        resolved_secret = case secret
+          when :auto then Parse::LockBackend.lock_secret_for(store: store, source: "Parse::Lock")
+          when String then secret
+          when nil then nil
           end
-        digest = resolved_secret \
-          ? OpenSSL::HMAC.hexdigest("SHA256", resolved_secret, validated_key) \
-          : Digest::SHA256.hexdigest(validated_key)
+        digest = resolved_secret ? OpenSSL::HMAC.hexdigest("SHA256", resolved_secret, validated_key) : Digest::SHA256.hexdigest(validated_key)
         store_key = "#{KEY_PREFIX}#{digest}"
 
         if Parse::LockBackend.degraded_store?(store)
@@ -238,13 +235,13 @@ module Parse
           # cross-process owner here — the Mutex IS the exclusion — so a
           # fresh UUID is purely for signature parity / local fencing.
           return Parse::LockBackend.synchronize_process_mutex(store_key) do
-            yield SecureRandom.uuid
-          end
+                   yield SecureRandom.uuid
+                 end
         end
 
-        owner       = SecureRandom.uuid
+        owner = SecureRandom.uuid
         acquired_at = nil
-        start       = Parse::LockBackend.monotonic_now
+        start = Parse::LockBackend.monotonic_now
 
         loop do
           if Parse::LockBackend.try_acquire(store, store_key, owner, normalized_ttl)

data/lib/parse/lock_backend.rb

@@ -102,7 +102,7 @@ module Parse
       #   error (Parse::CreateLockUnavailableError vs
       #   Parse::Lock::UnavailableError) without coupling here.
       def handle_degraded(mode, key, source: "Parse::LockBackend",
-                          unavailable_error: nil)
+                                     unavailable_error: nil)
         case mode
         when :raise
           err = unavailable_error || Parse::Error

data/lib/parse/lookup_rewriter.rb

@@ -236,9 +236,9 @@ module Parse
       mongo_local = "_p_#{pointer_field}"
       if foreign_has_parse_reference?(target_class)
         replace_keys(spec,
-                    "from" => from_collection,
-                    "localField" => mongo_local,
-                    "foreignField" => PARSE_REFERENCE_REMOTE)
+                     "from" => from_collection,
+                     "localField" => mongo_local,
+                     "foreignField" => PARSE_REFERENCE_REMOTE)
       else
         as_value = read_string(spec, "as")
         let_var = "rwLookupId_#{pointer_field}"
@@ -262,9 +262,9 @@ module Parse
       mongo_foreign = "_p_#{pointer_field}"
       if foreign_has_parse_reference?(local_class)
         replace_keys(spec,
-                    "from" => from_collection,
-                    "localField" => PARSE_REFERENCE_REMOTE,
-                    "foreignField" => mongo_foreign)
+                     "from" => from_collection,
+                     "localField" => PARSE_REFERENCE_REMOTE,
+                     "foreignField" => mongo_foreign)
       else
         as_value = read_string(spec, "as")
         let_var = "rwReverseId_#{pointer_field}"