tina4ruby 3.13.31 → 3.13.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6140bb67a60387c462e70052c88bbde69ba3b669c0371380df401bd8f9a0b039
-  data.tar.gz: 7e0043ae026ed273a444f6185f289d0099458fc9ce605bfe4380c1fda9b6f672
+  metadata.gz: 02b84dbb5f8e4d009306495921ab7849a28fd769d81d13019b311523d970a0e5
+  data.tar.gz: e1b298c7bd03444def8787941f87a7e6fd0adcb6be23efe810990c6005d27910
 SHA512:
-  metadata.gz: 83b74a98d73ebcfdd0f22a9335b09382d5e518d51f3443b5e29dafdddb892374e41c8b9cbbc0b4a3d354e3bd405996a376c2e93df1f996778a73d349561a2879
-  data.tar.gz: 4eadb6a043ec78b5058465b73e4f10f2bf8d91ed19f5e22e5a5a00e2f4b57de8f59fe321b89b5e1e6417dc2dd15ff9142bb36635eed1275f85b59148149498fd
+  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/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.31"
+  VERSION = "3.13.32"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.13.31
+  version: 3.13.32
 platform: ruby
 authors:
 - Tina4 Team