tina4ruby 3.13.22 → 3.13.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aac2cabc3b10f9750282cfa834852508cc89b03c6263ceed9eb199e8154d5eea
-  data.tar.gz: 661574d030c88a3ad8c514954643479513ca85349fa368f5762e7aa7129dd73f
+  metadata.gz: baf95ed43a14f3bcfb80f371cfca547bb0605d7da81ec519c6d32d58287ad754
+  data.tar.gz: afafda038012638d1a98da325e03c42ac4d0517693abf3832f3e313ad414982a
 SHA512:
-  metadata.gz: 53a60f73e417cc8badad04fa10f801e7dc56088d4ab171c73d08790e3502fac4ab1902e3c19d571f031034debccc48afc58767876df2f48a0e3c1f60ef94e24f
-  data.tar.gz: e00f8a84ebe2c3f91c22ff868d9ce45b8e6d5fad4109f52ad887c793d465254e98ffcdb485c37969f0a9a038554846dffdda51f17a34bd10dc4ca1990ae6476e
+  metadata.gz: 6126339d81995e6d7199af287d4a8e909dd57f02f0ba58993f87e842c25716d40e80bad1af5a00a9c910a35e1025b7b5483986b29e57e983ee90ba4552b35540
+  data.tar.gz: a5fe6d009ccc270ecb27075da49ed1a8361a1ef59cffcaa4634f9b39a84896caf52e064b2129210c25d683c2a7b40048145a61e8ef206906b9cdc26a2e2c2af5

data/lib/tina4/database.rb

@@ -2,6 +2,7 @@
 require "json"
 require "uri"
 require "digest"
+require "weakref"
 
 module Tina4
   # Thread-safe connection pool with round-robin rotation.
@@ -68,6 +69,43 @@ module Tina4
   class Database
     attr_reader :driver, :driver_name, :connected, :pool
 
+    # Live Database instances, so the request dispatcher can reset the
+    # request-scoped query cache on every connection at the start of a request.
+    # WeakRefs avoid keeping closed connections (or short-lived script
+    # connections) alive — parity with Python's weakref.WeakSet. Guarded by a
+    # mutex because connections can be created from multiple threads.
+    @instances = []
+    @instances_mutex = Mutex.new
+
+    class << self
+      # Register a live connection in the class-level WeakRef registry.
+      def register_instance(db)
+        @instances_mutex.synchronize do
+          @instances << WeakRef.new(db)
+        end
+      end
+
+      # Clear the request-scoped query cache on every live Database instance.
+      #
+      # The request dispatcher calls this at the start of each HTTP request so
+      # request-scoped caching never serves rows across requests (zero
+      # cross-request staleness). Persistent-mode connections are left alone.
+      # Dead WeakRefs (closed/GC'd connections) are pruned as we go.
+      def reset_request_caches
+        @instances_mutex.synchronize do
+          @instances.reject! do |ref|
+            begin
+              inst = ref.__getobj__
+              inst.cache_new_request
+              false
+            rescue WeakRef::RefError, StandardError
+              true  # dead reference (or errored) — prune it
+            end
+          end
+        end
+      end
+    end
+
     DRIVERS = {
       "sqlite" => "Tina4::Drivers::SqliteDriver",
       "sqlite3" => "Tina4::Drivers::SqliteDriver",
@@ -162,14 +200,33 @@ module Tina4
       # driver for every call so the whole transaction runs on one connection.
       @tx_pin_key = :"tina4_pinned_adapter_#{object_id}"
 
-      # Query cache — off by default, opt-in via TINA4_DB_CACHE=true
-      @cache_enabled = truthy?(ENV["TINA4_DB_CACHE"])
-      @cache_ttl = (ENV["TINA4_DB_CACHE_TTL"] || "30").to_i
+      # Query cache. One store, two layers (parity with Python connection.py):
+      #   • request-scoped (DEFAULT ON, off-switch TINA4_AUTO_CACHING=false) —
+      #     dedupes identical SELECTs to protect the DB from rapid repeat reads.
+      #     Cleared at the START of every HTTP request (so it never serves rows
+      #     across requests) AND on any write, with a short safety TTL (5s) for
+      #     non-request contexts (scripts/workers).
+      #   • persistent (opt-in, TINA4_DB_CACHE=true) — cross-request TTL cache
+      #     that is NOT cleared per request; entries expire by TINA4_DB_CACHE_TTL.
+      @cache_persistent = truthy?(ENV["TINA4_DB_CACHE"])
+      # Default true; honour the same truthy semantics the framework uses
+      # (mirrors Python's is_truthy(get("TINA4_AUTO_CACHING", "true"))).
+      @cache_request_scoped = truthy?(ENV["TINA4_AUTO_CACHING"] || "true")
+      @cache_enabled = @cache_persistent || @cache_request_scoped
+      @cache_ttl = if @cache_persistent
+                     (ENV["TINA4_DB_CACHE_TTL"] || "30").to_i
+                   else
+                     (ENV["TINA4_AUTO_CACHING_TTL"] || "5").to_i
+                   end
       @query_cache = {}  # key => { expires_at:, value: }
       @cache_hits = 0
       @cache_misses = 0
       @cache_mutex = Mutex.new
 
+      # Register this connection so Tina4::Database.reset_request_caches can
+      # clear its request-scoped entries at the start of every HTTP request.
+      Tina4::Database.register_instance(self)
+
       if @pool_size > 0
         # Pooled mode — create a ConnectionPool with lazy driver creation
         @pool = ConnectionPool.new(
@@ -235,9 +292,11 @@ module Tina4
       @cache_mutex.synchronize do
         {
           enabled: @cache_enabled,
+          mode: cache_mode,
           hits: @cache_hits,
           misses: @cache_misses,
           size: @query_cache.size,
+          backend: "memory",
           ttl: @cache_ttl
         }
       end
@@ -251,6 +310,16 @@ module Tina4
       end
     end
 
+    # Clear the request-scoped query cache at the start of an HTTP request.
+    #
+    # No-op in persistent mode (TINA4_DB_CACHE=true) so cross-request entries
+    # survive up to their TTL. Cumulative hit/miss counters are preserved.
+    def cache_new_request
+      return unless @cache_request_scoped && !@cache_persistent
+
+      @cache_mutex.synchronize { @query_cache.clear }
+    end
+
     # Fetch rows and return the records array directly.
     #
     # Symmetric with fetch_one. Cross-framework parity with Python
@@ -677,6 +746,17 @@ module Tina4
       %w[true 1 yes on].include?((val || "").to_s.strip.downcase)
     end
 
+    # "persistent" / "request" / "off" — mirrors Python connection.py.
+    def cache_mode
+      if @cache_persistent
+        "persistent"
+      elsif @cache_request_scoped
+        "request"
+      else
+        "off"
+      end
+    end
+
     def cache_key(sql, params)
       Digest::SHA256.hexdigest(sql + params.to_s)
     end

data/lib/tina4/rack_app.rb

@@ -43,6 +43,13 @@ module Tina4
       path = env["PATH_INFO"] || "/"
       request_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
+      # Request-scoped query cache boundary (v3.13.23). Tina4 Ruby runs a
+      # long-running Rack server, so the request-scoped DB cache (default-on)
+      # would otherwise serve rows from a previous request. Clear it on every
+      # live connection at the very start of each request, before any routing.
+      # No-op for persistent-mode (TINA4_DB_CACHE=true) connections.
+      Tina4::Database.reset_request_caches if defined?(Tina4::Database)
+
       # Fast-path: CORS preflight. Real CORS preflight requests carry an
       # Origin header AND an Access-Control-Request-Method header — the
       # browser is asking "may I send this method?" before the actual

data/lib/tina4/response_cache.rb

@@ -22,7 +22,7 @@ module Tina4
   # Environment:
   #   TINA4_CACHE_BACKEND      — memory | redis | file  (default: memory)
   #   TINA4_CACHE_URL           — redis://localhost:6379  (redis only)
-  #   TINA4_CACHE_TTL           — default TTL in seconds  (default: 0 = disabled)
+  #   TINA4_CACHE_TTL           — default TTL in seconds  (default: 60)
   #   TINA4_CACHE_MAX_ENTRIES   — maximum cache entries   (default: 1000)
   #
   class ResponseCache
@@ -36,7 +36,7 @@ module Tina4
     # @param cache_dir [String, nil] File cache directory
     def initialize(ttl: nil, max_entries: nil, status_codes: [200],
                    backend: nil, cache_url: nil, cache_dir: nil)
-      @ttl = ttl || (ENV["TINA4_CACHE_TTL"] ? ENV["TINA4_CACHE_TTL"].to_i : 0)
+      @ttl = ttl || (ENV["TINA4_CACHE_TTL"] ? ENV["TINA4_CACHE_TTL"].to_i : 60)
       @max_entries = max_entries || (ENV["TINA4_CACHE_MAX_ENTRIES"] ? ENV["TINA4_CACHE_MAX_ENTRIES"].to_i : 1000)
       @status_codes = status_codes
       @backend_name = backend || ENV.fetch("TINA4_CACHE_BACKEND", "memory").downcase.strip

data/lib/tina4/version.rb

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

metadata

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