tina4ruby 3.13.30 → 3.13.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c71dd3827f3ae5125eb53a9fb77ebb9df940f02616163b93d3934b28561c902
-  data.tar.gz: 4269e49ecb160a17cd58f17ee10dce63d483fd3f411aab05642014dd64ef5e81
+  metadata.gz: 02b84dbb5f8e4d009306495921ab7849a28fd769d81d13019b311523d970a0e5
+  data.tar.gz: e1b298c7bd03444def8787941f87a7e6fd0adcb6be23efe810990c6005d27910
 SHA512:
-  metadata.gz: c3c4db5b3fa3359a8c27ad62d89dce04c60953be4d9e9dc6f60343f34f5168e1bc86a8df0cb6c37d40a9559cec5e950737438a18573d473960151beccd0ddacf
-  data.tar.gz: af8d3b0c1847de387fac1bf7af34eca83bbbf287e57268f4e86d83610dd919d358f9e071e814653503bb599dbf545aa3f1547edbe13d529166904c0773b72151
+  metadata.gz: 8bf774f6208956221c87bb2f546a04aab950a3cae5962dae94bbd430ee55463481886ba315a21f2680b017828d99df0c6e7a54fff331cff0e559b176da45c5a9
+  data.tar.gz: 5242a9295d6e70763ca68a377f2aa3dfd2ac8b37402b8660f439ea6bc6e0c5ddb1f278d277c2ff4ab8bf62b6d80f0ad316c8c07c099f07ecdee9040bea0ddfe5

data/lib/tina4/database.rb

@@ -366,11 +366,20 @@ module Tina4
     # v3.13.12: default `limit` is **nil** (no truncation) — the method
     # name says fetch_all, so it returns all matching rows. Pre-v3.13.12
     # silently truncated to 100. Pass an explicit `limit:` to cap.
-    def fetch_all(sql, params = [], limit: nil, offset: nil)
-      fetch(sql, params, limit: limit, offset: offset).records
+    #
+    # Pass `no_cache: true` to bypass the query cache for this call (see #fetch).
+    def fetch_all(sql, params = [], limit: nil, offset: nil, no_cache: false)
+      fetch(sql, params, limit: limit, offset: offset, no_cache: no_cache).records
     end
 
-    def fetch(sql, params = [], limit: 100, offset: nil)
+    # Fetch rows with pagination, returning a DatabaseResult.
+    #
+    # Pass `no_cache: true` to bypass the query cache entirely for this single
+    # call — no lookup, no store — and run the query directly against the
+    # driver. Works for both the request-scoped auto-cache and the persistent
+    # DB cache. The default `false` preserves the cached behaviour. Parity with
+    # Python db.fetch(no_cache=) / PHP / Node.
+    def fetch(sql, params = [], limit: 100, offset: nil, no_cache: false)
       offset ||= 0
       drv = current_driver
 
@@ -388,7 +397,7 @@ module Tina4
         effective_sql = drv.apply_limit(effective_sql, limit, offset)
       end
 
-      if @cache_enabled
+      if @cache_enabled && !no_cache
         key = cache_key(effective_sql, params)
         cached = cache_get(key)
         if cached
@@ -406,9 +415,15 @@ module Tina4
       Tina4::DatabaseResult.new(rows, sql: effective_sql, db: self)
     end
 
-    def fetch_one(sql, params = [])
+    # Fetch a single row (or nil).
+    #
+    # Pass `no_cache: true` to bypass the query cache entirely for this call —
+    # no lookup, no store — running the query directly. The `no_cache` flag is
+    # propagated to the inner #fetch so the request-scoped/persistent cache is
+    # never populated either. Default `false` preserves cached behaviour.
+    def fetch_one(sql, params = [], no_cache: false)
       sql = Tina4::Database.strip_trailing_semicolons(sql)
-      if @cache_enabled
+      if @cache_enabled && !no_cache
         key = cache_key(sql + ":ONE", params)
         cached = cache_get(key)
         if cached
@@ -422,7 +437,7 @@ module Tina4
         return value
       end
 
-      result = fetch(sql, params, limit: 1)
+      result = fetch(sql, params, limit: 1, no_cache: no_cache)
       result.first
     end
 

data/lib/tina4/graphql.rb

@@ -1026,7 +1026,9 @@ module Tina4
 
       graphql = self
       Tina4.post path, auth: false do |request, response|
-        body = request.body
+        # handle_request expects the raw JSON text (it JSON.parses internally),
+        # so read body_raw — request.body now returns the PARSED payload.
+        body = request.body_raw
         result = graphql.handle_request(body, context: { request: request })
         response.json(result)
       end

data/lib/tina4/request.rb

@@ -35,6 +35,26 @@ module Tina4
     end
   end
 
+  # Per-file upload hash: indifferent access plus a lazily-materialised
+  # `content` field. The raw bytes are read from the tempfile only on first
+  # access to `content` (then rewound, so :tempfile streaming still works),
+  # so :tempfile-only handlers never buffer large uploads in memory.
+  class FileUpload < IndifferentHash
+    def [](key)
+      if key.to_s == "content" && !key?("content") && (tf = super("tempfile"))
+        self["content"] = begin
+          tf.rewind if tf.respond_to?(:rewind)
+          data = tf.read
+          tf.rewind if tf.respond_to?(:rewind)
+          data
+        rescue StandardError
+          nil
+        end
+      end
+      super(key)
+    end
+  end
+
   # Hash subclass for HTTP headers — string keys are case-insensitive.
   #
   # HTTP header field-names are case-insensitive per RFC 7230 §3.2. With
@@ -161,16 +181,25 @@ module Tina4
       @session ||= Tina4::Session.new(@env)
     end
 
-    # Raw body string
+    # Parsed body (JSON -> Hash, form-urlencoded -> Hash, multipart ->
+    # fields Hash, else the current fallback). This matches Python's
+    # `request.body`, PHP's, and Node's: `body` is the PARSED payload, not
+    # the raw bytes. For the raw string use `body_raw`.
     def body
-      @body_raw ||= read_body
+      @body_parsed ||= parse_body
     end
 
-    # Parsed body (JSON or form data)
-    def body_parsed
-      @body_parsed ||= parse_body
+    # Raw body string — the bytes exactly as the client sent them.
+    # (This is what `body` used to return before the cross-framework
+    # parity flip; SOAP/GraphQL and any consumer that needs the raw text
+    # reads this.)
+    def body_raw
+      @body_raw ||= read_body
     end
 
+    # Backwards-compatible alias of `body` — both return the parsed payload.
+    alias body_parsed body
+
     # Parsed query string as hash
     def query
       @query_hash ||= parse_query_to_hash(@query_string)
@@ -204,7 +233,7 @@ module Tina4
 
     def json_body
       @json_body ||= begin
-        JSON.parse(body)
+        JSON.parse(body_raw)
       rescue JSON::ParserError, TypeError
         {}
       end
@@ -273,7 +302,7 @@ module Tina4
       if @content_type.include?("application/json")
         json_body
       elsif @content_type.include?("application/x-www-form-urlencoded")
-        parse_query_to_hash(body)
+        parse_query_to_hash(body_raw)
       elsif @content_type.include?("multipart/form-data")
         # Extract form fields from Rack's parsed multipart data.
         # Files are handled separately by extract_files.
@@ -324,12 +353,19 @@ module Tina4
         if form_hash
           form_hash.each do |key, value|
             if value.is_a?(Hash) && value[:tempfile]
-              result[key] = {
-                filename: value[:filename],
-                type: value[:type],
-                tempfile: value[:tempfile],
-                size: value[:tempfile].size
-              }
+              tempfile = value[:tempfile]
+
+              # Indifferent-access per-file hash so file["content"],
+              # file[:content], file["filename"], file[:filename] all work.
+              # `content` (raw bytes, never base64) is materialised lazily on
+              # first access (see FileUpload) — :tempfile-only handlers never
+              # buffer large uploads in memory.
+              file = FileUpload.new
+              file[:filename] = value[:filename]
+              file[:type]     = value[:type]
+              file[:tempfile] = tempfile
+              file[:size]     = tempfile.size
+              result[key] = file
             end
           end
         end

data/lib/tina4/response.rb

@@ -285,9 +285,19 @@ module Tina4
       self
     end
 
-    # Stream response from a block for Server-Sent Events (SSE).
+    # Stream a response for Server-Sent Events (SSE) / chunked transfer.
     #
-    # Usage:
+    # Two equivalent call styles (cross-framework parity — Python/PHP/Node
+    # pass a generator positionally; Ruby additionally supports a block):
+    #
+    #   # 1. Positional generator (Enumerator, or anything responding to
+    #   #    #each or #call that yields string chunks):
+    #   gen = Enumerator.new do |y|
+    #     10.times { |i| y << "data: message #{i}\n\n" }
+    #   end
+    #   response.stream(gen)
+    #
+    #   # 2. Block form (unchanged):
     #   Tina4::Router.get "/events" do |request, response|
     #     response.stream do |out|
     #       10.times do |i|
@@ -297,16 +307,18 @@ module Tina4
     #     end
     #   end
     #
+    # @param generator [#each, #call, nil] Optional source of string chunks.
     # @param content_type [String] Content type (default: text/event-stream)
     # @yield [Enumerator::Yielder] Block receives a yielder to push chunks
     # @return [self]
-    def stream(content_type: "text/event-stream", &block)
+    def stream(generator = nil, content_type: "text/event-stream", &block)
       @status_code = @status_code || 200
       @headers["content-type"] = content_type
       @headers["cache-control"] = "no-cache"
       @headers["connection"] = "keep-alive"
       @headers["x-accel-buffering"] = "no"
       @_streaming = true
+      @_stream_generator = generator
       @_stream_block = block
       self
     end
@@ -330,9 +342,24 @@ module Tina4
       final_headers["set-cookie"] = @cookies.join("\n") if @cookies && !@cookies.empty?
 
       if @_streaming
-        # Streaming mode — return an Enumerator as the body
+        # Streaming mode — return an Enumerator as the Rack body. A positional
+        # generator wins over a block when both are somehow present.
+        gen = @_stream_generator
+        blk = @_stream_block
         body = Enumerator.new do |yielder|
-          @_stream_block.call(yielder)
+          if gen
+            if gen.respond_to?(:each)
+              # Enumerator / array / any Enumerable of string chunks
+              gen.each { |chunk| yielder << chunk }
+            elsif gen.respond_to?(:call)
+              # Callable that receives the yielder, like the block form
+              gen.call(yielder)
+            else
+              yielder << gen.to_s
+            end
+          elsif blk
+            blk.call(yielder)
+          end
         end
         return [@status_code, final_headers, body]
       end

data/lib/tina4/response_cache.rb

@@ -86,6 +86,7 @@ module Tina4
       if hit
         if response.respond_to?(:call)
           new_response = response.call(hit.body, hit.status_code, hit.content_type)
+          set_cache_headers(new_response, "HIT", remaining_ttl(hit.expires_at))
           return [request, new_response]
         end
       end
@@ -106,16 +107,17 @@ module Tina4
     def after_cache(request, response)
       return [request, response] unless enabled?
 
-      method = if request.respond_to?(:[])
-                 request[:_cache_method]
-               else
-                 request.instance_variable_get(:@_cache_method)
-               end
-      url = if request.respond_to?(:[])
-              request[:_cache_url]
-            else
-              request.instance_variable_get(:@_cache_url)
-            end
+      # Read the tags using the SAME mechanism before_cache wrote them with.
+      # before_cache keys the write on respond_to?(:[]=), so read the same way:
+      # a Tina4::Request responds to #[] (read-only param lookup) but NOT #[]=,
+      # so the tags live on instance variables, not the param hash.
+      if request.respond_to?(:[]=)
+        method = request[:_cache_method]
+        url = request[:_cache_url]
+      else
+        method = request.instance_variable_get(:@_cache_method)
+        url = request.instance_variable_get(:@_cache_url)
+      end
       return [request, response] if method.nil? || url.nil?
 
       status = if response.respond_to?(:status_code)
@@ -137,6 +139,9 @@ module Tina4
              end
 
       internal_store(method, url, status.to_i, content_type.to_s, body)
+      # The handler ran (cache miss) — annotate the response so clients can
+      # see this was a fresh response and how long it will be cached.
+      set_cache_headers(response, "MISS", @ttl)
       [request, response]
     end
 
@@ -279,6 +284,26 @@ module Tina4
       "#{method}:#{url}"
     end
 
+    # Stamp X-Cache / X-Cache-TTL on a response. `state` is "HIT" or "MISS";
+    # `ttl` is the remaining (HIT) or configured (MISS) TTL in seconds.
+    # Parity with Python/PHP/Node ResponseCache, which set the same two
+    # headers (no Cache-Control). No-op for responses that don't carry a
+    # mutable headers hash (e.g. test doubles).
+    def set_cache_headers(response, state, ttl)
+      return unless response.respond_to?(:headers) && response.headers.is_a?(Hash)
+
+      response.headers["X-Cache"] = state
+      response.headers["X-Cache-TTL"] = ttl.to_i.to_s
+    end
+
+    # Remaining whole seconds until `expires_at` (a monotonic-ish Time.now.to_f
+    # epoch), floored at 0 so an entry on the cusp of expiry never reports a
+    # negative TTL.
+    def remaining_ttl(expires_at)
+      remaining = (expires_at || 0) - Time.now.to_f
+      remaining.positive? ? remaining : 0
+    end
+
     # Internal: retrieve a cached response. Used by middleware hooks only.
     def internal_lookup(method, url)
       return nil unless enabled?

data/lib/tina4/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tina4
-  VERSION = "3.13.30"
+  VERSION = "3.13.32"
 end

data/lib/tina4/wsdl.rb

@@ -116,9 +116,18 @@ module Tina4
     def handle
       return generate_wsdl if @request.nil?
 
+      # SOAP bodies are raw XML, so read the raw bytes. On a real
+      # Tina4::Request use body_raw (request.body now returns the PARSED
+      # payload); test stubs that only expose `body` fall back to it.
+      raw_body = if @request.respond_to?(:body_raw)
+                   @request.body_raw
+                 elsif @request.respond_to?(:body)
+                   @request.body
+                 end
+
       method = if @request.respond_to?(:method)
                  @request.method.to_s.upcase
-               elsif @request.respond_to?(:body) && @request.body && !@request.body.to_s.empty?
+               elsif raw_body && !raw_body.to_s.empty?
                  "POST"
                else
                  "GET"
@@ -131,11 +140,7 @@ module Tina4
         return generate_wsdl
       end
 
-      body = if @request.respond_to?(:body)
-               @request.body.is_a?(String) ? @request.body : @request.body.to_s
-             else
-               ""
-             end
+      body = raw_body.is_a?(String) ? raw_body : raw_body.to_s
 
       process_soap(body)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.13.30
+  version: 3.13.32
 platform: ruby
 authors:
 - Tina4 Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-16 00:00:00.000000000 Z
+date: 2026-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack