tina4ruby 3.13.22 → 3.13.24

data/lib/tina4/cache_backends/redis_backend.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require "json"
+require "socket"
+require "uri"
+require_relative "base_backend"
+
+module Tina4
+  module CacheBackends
+    # Redis / Valkey backend (parity with Python _RedisBackend). Uses the
+    # `redis` gem if it is installed, otherwise falls back to the raw RESP
+    # protocol over a TCP socket — so it works with zero runtime dependencies.
+    #
+    # URL form: scheme://[user[:password]@]host[:port][/db]. Credentials may
+    # also be supplied via TINA4_CACHE_USERNAME / TINA4_CACHE_PASSWORD (parity
+    # with TINA4_DATABASE_USERNAME / TINA4_DATABASE_PASSWORD). Wrong credentials
+    # cause available? to return false, so the factory falls back to file.
+    class RedisBackend < BaseBackend
+      PREFIX = "tina4:cache:"
+
+      def initialize(url: "redis://localhost:6379", max_entries: 1000, name: "redis")
+        @max_entries = max_entries
+        @name = name
+        @hits = 0
+        @misses = 0
+        @client = nil
+        @use_raw = false
+
+        parse_url(url)
+
+        # Try the redis gem first.
+        begin
+          require "redis"
+          kwargs = { host: @host, port: @port, db: @db, timeout: 5 }
+          kwargs[:password] = @password if @password
+          kwargs[:username] = @username if @username
+          @client = Redis.new(**kwargs)
+          @client.ping
+          @available = true
+        rescue LoadError, StandardError
+          @client = nil
+          @use_raw = true
+          # No gem — usable only if the server answers (and authenticates).
+          @available = probe
+        end
+      end
+
+      def available?
+        @available
+      end
+
+      def get(key)
+        full_key = PREFIX + key
+        raw = if @client
+                begin
+                  @client.get(full_key)
+                rescue StandardError
+                  nil
+                end
+              elsif @use_raw
+                resp_command("GET", full_key)
+              end
+
+        if raw.nil?
+          @misses += 1
+          return nil
+        end
+        @hits += 1
+        begin
+          JSON.parse(raw)
+        rescue JSON::ParserError, TypeError
+          raw
+        end
+      end
+
+      def set(key, value, ttl)
+        full_key = PREFIX + key
+        serialized = JSON.generate(value)
+        if @client
+          begin
+            if ttl > 0
+              @client.setex(full_key, ttl, serialized)
+            else
+              @client.set(full_key, serialized)
+            end
+          rescue StandardError
+          end
+        elsif @use_raw
+          if ttl > 0
+            resp_command("SETEX", full_key, ttl.to_s, serialized)
+          else
+            resp_command("SET", full_key, serialized)
+          end
+        end
+      end
+
+      def delete(key)
+        full_key = PREFIX + key
+        if @client
+          begin
+            @client.del(full_key) > 0
+          rescue StandardError
+            false
+          end
+        elsif @use_raw
+          resp_command("DEL", full_key) == "1"
+        else
+          false
+        end
+      end
+
+      def clear
+        @hits = 0
+        @misses = 0
+        if @client
+          begin
+            keys = @client.keys("#{PREFIX}*")
+            @client.del(*keys) unless keys.empty?
+          rescue StandardError
+          end
+        elsif @use_raw
+          # Raw RESP doesn't support pattern delete easily; rely on TTL.
+        end
+      end
+
+      def stats
+        size = 0
+        if @client
+          begin
+            size = @client.keys("#{PREFIX}*").size
+          rescue StandardError
+          end
+        end
+        { hits: @hits, misses: @misses, size: size, backend: @name }
+      end
+
+      def name
+        @name
+      end
+
+      private
+
+      def parse_url(url)
+        url = "redis://#{url}" unless url.include?("://")
+        # Normalise valkey:// → redis:// so URI parses host/port/userinfo.
+        normalised = url.sub(%r{^valkey://}, "redis://")
+        uri = URI.parse(normalised)
+        @host = uri.host || "localhost"
+        @port = uri.port || 6379
+        db_path = (uri.path || "").sub(%r{^/}, "")
+        @db = db_path =~ /\A\d+\z/ ? db_path.to_i : 0
+        url_user = uri.user && !uri.user.empty? ? URI.decode_www_form_component(uri.user) : nil
+        url_pass = uri.password && !uri.password.empty? ? URI.decode_www_form_component(uri.password) : nil
+        @username = url_user || (env_nonempty("TINA4_CACHE_USERNAME"))
+        @password = url_pass || (env_nonempty("TINA4_CACHE_PASSWORD"))
+      rescue URI::InvalidURIError
+        @host = "localhost"
+        @port = 6379
+        @db = 0
+        @username = env_nonempty("TINA4_CACHE_USERNAME")
+        @password = env_nonempty("TINA4_CACHE_PASSWORD")
+      end
+
+      def env_nonempty(key)
+        v = ENV[key]
+        v && !v.empty? ? v : nil
+      end
+
+      # Real AUTH+PING handshake so wrong credentials also fall back to file.
+      def probe
+        resp_command("PING") == "PONG"
+      rescue StandardError
+        false
+      end
+
+      # Send a command using the raw RESP protocol over TCP. Returns the simple
+      # string / bulk string / integer as a String, or nil on miss/error.
+      def resp_command(*args)
+        cmd = +"*#{args.size}\r\n"
+        args.each do |arg|
+          s = arg.to_s
+          cmd << "$#{s.bytesize}\r\n#{s}\r\n"
+        end
+
+        sock = TCPSocket.new(@host, @port)
+        sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, [5, 0].pack("l_2"))
+
+        if @password
+          auth = if @username
+                   "*3\r\n$4\r\nAUTH\r\n$#{@username.bytesize}\r\n#{@username}\r\n" \
+                   "$#{@password.bytesize}\r\n#{@password}\r\n"
+                 else
+                   "*2\r\n$4\r\nAUTH\r\n$#{@password.bytesize}\r\n#{@password}\r\n"
+                 end
+          sock.write(auth)
+          unless sock.recv(1024).start_with?("+")
+            sock.close
+            return nil
+          end
+        end
+
+        if @db != 0
+          select_cmd = "*2\r\n$6\r\nSELECT\r\n$#{@db.to_s.bytesize}\r\n#{@db}\r\n"
+          sock.write(select_cmd)
+          sock.recv(1024)
+        end
+
+        sock.write(cmd)
+        response = sock.recv(65_536)
+        sock.close
+
+        if response.nil? || response.empty?
+          nil
+        elsif response.start_with?("+")
+          response[1..].strip
+        elsif response.start_with?("$-1")
+          nil
+        elsif response.start_with?("$")
+          lines = response.split("\r\n")
+          lines[1]
+        elsif response.start_with?(":")
+          response[1..].strip
+        elsif response.start_with?("-")
+          nil
+        else
+          response.strip
+        end
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/tina4/cache_backends/valkey_backend.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "redis_backend"
+
+module Tina4
+  module CacheBackends
+    # Valkey backend (parity with Python _ValkeyBackend). Valkey speaks the
+    # Redis wire protocol, so it reuses the Redis client / raw-RESP transport
+    # and only reports a different name.
+    class ValkeyBackend < RedisBackend
+      def initialize(url: "valkey://localhost:6379", max_entries: 1000)
+        super(url: url.sub(%r{^valkey://}, "redis://"), max_entries: max_entries, name: "valkey")
+      end
+    end
+  end
+end

data/lib/tina4/cache_backends.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "cache_backends/base_backend"
+require_relative "cache_backends/memory_backend"
+require_relative "cache_backends/file_backend"
+require_relative "cache_backends/redis_backend"
+require_relative "cache_backends/valkey_backend"
+require_relative "cache_backends/memcached_backend"
+require_relative "cache_backends/mongo_backend"
+require_relative "cache_backends/database_backend"
+
+module Tina4
+  # Unified cache backend family (parity with Python tina4_python.cache).
+  #
+  # Backends are key/value stores with TTL semantics, selected via env vars:
+  #
+  #   memory    — in-process LRU cache (default, zero deps)
+  #   file      — JSON files in data/cache/
+  #   redis     — Redis (redis gem or raw RESP over TCP)
+  #   valkey    — Valkey (Redis wire protocol; reports "valkey")
+  #   memcached — Memcached (zero-dep text protocol over TCP)
+  #   mongodb   — MongoDB TTL collection (requires the mongo gem)
+  #   database  — tina4_cache table in any Tina4-supported database
+  #
+  # Environment:
+  #   TINA4_CACHE_BACKEND     — memory|file|redis|valkey|memcached|mongodb|database
+  #   TINA4_CACHE_URL         — connection URL (redis/valkey/memcached/mongo) OR
+  #                             SQL URL for database (falls back to TINA4_DATABASE_URL)
+  #   TINA4_CACHE_TTL         — default TTL in seconds (default: 60)
+  #   TINA4_CACHE_MAX_ENTRIES — max cached entries (default: 1000)
+  #   TINA4_CACHE_DIR         — file backend directory (default: data/cache)
+  #   TINA4_CACHE_USERNAME / TINA4_CACHE_PASSWORD — credentials when not in the URL
+  module CacheBackends
+    module_function
+
+    # Create a cache backend from explicit params or env vars.
+    #
+    # Graceful degradation: if the configured backend's driver is missing or its
+    # service is unreachable, the factory logs a warning and falls back to the
+    # file backend (persistent, zero-dep, always available) — never a silent
+    # no-op cache.
+    #
+    # @param backend [String, nil]
+    # @param url [String, nil]
+    # @param max_entries [Integer, nil]
+    # @param cache_dir [String, nil]
+    # @return [Tina4::CacheBackends::BaseBackend]
+    def create_backend(backend: nil, url: nil, max_entries: nil, cache_dir: nil)
+      backend ||= ENV.fetch("TINA4_CACHE_BACKEND", "memory")
+      max_entries ||= (ENV["TINA4_CACHE_MAX_ENTRIES"] || "1000").to_i
+      backend = backend.to_s.downcase.strip
+
+      be =
+        case backend
+        when "redis"
+          RedisBackend.new(url: url || ENV.fetch("TINA4_CACHE_URL", "redis://localhost:6379"),
+                           max_entries: max_entries)
+        when "valkey"
+          ValkeyBackend.new(url: url || ENV.fetch("TINA4_CACHE_URL", "valkey://localhost:6379"),
+                            max_entries: max_entries)
+        when "memcached", "memcache"
+          MemcachedBackend.new(url: url || ENV.fetch("TINA4_CACHE_URL", "memcached://localhost:11211"),
+                               max_entries: max_entries)
+        when "mongodb", "mongo"
+          MongoBackend.new(url: url || ENV.fetch("TINA4_CACHE_URL", "mongodb://localhost:27017"),
+                           max_entries: max_entries)
+        when "database", "db"
+          DatabaseBackend.new(url: url, max_entries: max_entries)
+        when "file"
+          dir = cache_dir || ENV.fetch("TINA4_CACHE_DIR", "data/cache")
+          return FileBackend.new(cache_dir: dir, max_entries: max_entries)
+        else
+          return MemoryBackend.new(max_entries: max_entries)
+        end
+
+      return be if be.available?
+
+      # Configured backend unusable — degrade to the file backend.
+      begin
+        Tina4::Log.warning(
+          "Cache backend '#{backend}' is unavailable " \
+          "(driver missing or service unreachable) — falling back to 'file'."
+        )
+      rescue StandardError
+        # Logging must never break cache construction.
+      end
+      dir = cache_dir || ENV.fetch("TINA4_CACHE_DIR", "data/cache")
+      FileBackend.new(cache_dir: dir, max_entries: max_entries)
+    end
+  end
+end

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,52 @@ 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
 
+      # Persistent mode may route through the unified CacheBackend (redis/
+      # valkey/memcached/mongodb/database via TINA4_DB_CACHE_BACKEND) so
+      # multiple instances can share one cache with global write-invalidation.
+      # Request-scoped mode always stays in-process (the @query_cache dict).
+      # The DatabaseResult is serialized to a JSON-friendly Hash before storing
+      # and reconstructed on read so shared backends work cross-instance.
+      @cache_backend = nil
+      if @cache_persistent
+        begin
+          @cache_backend = Tina4::CacheBackends.create_backend(
+            backend: ENV["TINA4_DB_CACHE_BACKEND"] || "memory",
+            url: ENV["TINA4_DB_CACHE_URL"],
+            max_entries: 1000
+          )
+        rescue StandardError
+          @cache_backend = nil # fall back to the in-process dict
+        end
+      end
+
+      # 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(
@@ -232,18 +308,34 @@ module Tina4
     # ── Query Cache ──────────────────────────────────────────────
 
     def cache_stats
+      if @cache_backend
+        bs = @cache_backend.stats
+        return {
+          enabled: @cache_enabled,
+          mode: cache_mode,
+          hits: @cache_hits,
+          misses: @cache_misses,
+          size: bs[:size],
+          backend: bs[:backend] || @cache_backend.name,
+          ttl: @cache_ttl
+        }
+      end
+
       @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
     end
 
     def cache_clear
+      @cache_backend.clear if @cache_backend
       @cache_mutex.synchronize do
         @query_cache.clear
         @cache_hits = 0
@@ -251,6 +343,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,11 +779,29 @@ 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
 
     def cache_get(key)
+      # Shared backend (persistent + TINA4_DB_CACHE_BACKEND) — reconstruct the
+      # DatabaseResult from the serialized Hash so cross-instance reads work.
+      if @cache_backend
+        raw = @cache_backend.get(key)
+        return raw.is_a?(Hash) ? deserialize_result(raw) : nil
+      end
+
       @cache_mutex.synchronize do
         entry = @query_cache[key]
         return nil unless entry
@@ -694,6 +814,11 @@ module Tina4
     end
 
     def cache_set(key, value)
+      if @cache_backend
+        @cache_backend.set(key, serialize_result(value), @cache_ttl)
+        return
+      end
+
       @cache_mutex.synchronize do
         @query_cache[key] = {
           expires_at: Process.clock_gettime(Process::CLOCK_MONOTONIC) + @cache_ttl,
@@ -703,9 +828,59 @@ module Tina4
     end
 
     def cache_invalidate
+      @cache_backend.clear if @cache_backend
       @cache_mutex.synchronize { @query_cache.clear }
     end
 
+    # Flatten a DatabaseResult (or a single fetch_one Hash) into a JSON-friendly
+    # Hash for shared backends. fetch_one stores a plain Hash row, so we tag the
+    # shape so deserialize can return the right thing.
+    def serialize_result(value)
+      if value.is_a?(Tina4::DatabaseResult)
+        {
+          "kind" => "result",
+          "records" => value.records,
+          "count" => value.count,
+          "limit" => value.limit,
+          "offset" => value.offset,
+          "affected_rows" => value.affected_rows,
+          "last_id" => value.last_id
+        }
+      else
+        # fetch_one row (Hash) or nil
+        { "kind" => "row", "row" => value }
+      end
+    end
+
+    # Reconstruct from a backend-cached Hash. JSON round-trips string keys, so
+    # accept both string and symbol keys. Records are re-symbolised so a cached
+    # result is byte-for-byte equivalent to an uncached fetch (driver rows use
+    # symbol keys) regardless of which backend stored it.
+    def deserialize_result(data)
+      kind = data["kind"] || data[:kind]
+      if kind == "row"
+        row = data["row"] || data[:row]
+        symbolize_row(row)
+      else
+        records = (data["records"] || data[:records] || []).map { |r| symbolize_row(r) }
+        Tina4::DatabaseResult.new(
+          records,
+          count: data["count"] || data[:count] || 0,
+          limit: data["limit"] || data[:limit] || 0,
+          offset: data["offset"] || data[:offset] || 0,
+          affected_rows: data["affected_rows"] || data[:affected_rows] || 0,
+          last_id: data["last_id"] || data[:last_id]
+        )
+      end
+    end
+
+    # Driver rows use symbol keys; re-key a JSON-round-tripped Hash to match.
+    def symbolize_row(row)
+      return row unless row.is_a?(Hash)
+
+      row.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+    end
+
     def detect_driver(conn)
       case conn.to_s.downcase
       when /\.db$/, /\.sqlite/, /sqlite/

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