tina4ruby 3.13.12 → 3.13.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 303058fcf9f267e5034b659e75be74b7a5fba69740968063b7370ff046452c8c
-  data.tar.gz: 993d93df6a783588a4b6c33bd8737a522c5dba96aafefb9dcc701bc6a30eb6c0
+  metadata.gz: b1cf076eb39a57f9c1cbdff22ff957b6abf2bc24ab245d603a88f4fdc780ab1f
+  data.tar.gz: 87a49969a5de07822dfeee8f4d6792dd0260409344519396e108ee45d8c68245
 SHA512:
-  metadata.gz: a0c1c3f7a454e6cee7b4512290b8b0cf3de3c1683d1f797f64cc7efc8caa5e1cd6a245a0d96351f151b878b49e57e8a2461c6f120151b0f1bcc660d0f1dcdd0c
-  data.tar.gz: 0d4eb1114071ca5173b36b73ce1af9c705e23a69d8aff1b45b335b1ba5587ca9fee4825b6dba1f9cacdab5cde01e2c64e77d73bd70950a7f976f64f3e779c583
+  metadata.gz: a46003bec7bcaf5c5a4df7731a80b6d4e77b4eca9a9f467dcd061e94db7372192ba8751cf29d333518c49988224172adfab0a05bd16a14bc65fa2d2a5a209d98
+  data.tar.gz: ff0760e9a50bfe4f07dafc1c842060693a710de0ff5c3c9c5adfe606e858aee4219ea4e5bbdda600cd0252f89f83f749b619e426a884f0a6260e0c5552ce04bf

data/lib/tina4/database.rb

@@ -405,6 +405,18 @@ module Tina4
       nil
     end
 
+    # Return the normalised engine name for this connection.
+    #
+    # Cross-framework parity with Python/PHP/Node ``get_database_type()``.
+    # ORM.create_table needs this to emit engine-correct DDL (SERIAL vs
+    # AUTOINCREMENT, BOOLEAN vs INTEGER, TIMESTAMP vs DATETIME). Returns the
+    # resolved driver key ("postgres", "mysql", "mssql", "firebird",
+    # "sqlite", ...) — the same alias-normalised value used to pick the
+    # driver class, so callers don't have to re-parse the connection string.
+    def get_database_type
+      @driver_name
+    end
+
     # Execute a write statement. Returns true/false for simple writes.
     # Returns DatabaseResult if SQL contains RETURNING, CALL, EXEC, or SELECT.
     def execute(sql, params = [])
@@ -489,6 +501,12 @@ module Tina4
     alias get_columns columns
 
     def table_exists?(table_name)
+      drv = current_driver
+      # v3.13.14 (#48): drivers that can resolve a schema/catalog-qualified
+      # name ("gift_cards.gift_card", "dbo.widget", "attached.table") answer
+      # directly; the rest fall back to a case-insensitive scan of tables.
+      return drv.table_exists?(table_name) if drv.respond_to?(:table_exists?)
+
       tables.any? { |t| t.downcase == table_name.to_s.downcase }
     end
 

data/lib/tina4/database_result.rb

@@ -39,8 +39,21 @@ module Tina4
       @records.empty?
     end
 
-    def [](index)
-      @records[index]
+    # Index / slice access into the result rows.
+    #
+    # ``result[0]`` is documented (book ch5 §4 "Index Access"). Delegating
+    # straight to the materialised rows means every Array subscript form
+    # works — ``result[0]``, ``result[-1]``, ``result[1, 2]`` and
+    # ``result[1..3]`` — and matches Python's ``DatabaseResult.__getitem__``,
+    # which forwards to its records list.
+    def [](*args)
+      @records[*args]
+    end
+
+    # Implicit array coercion, so a DatabaseResult can be splatted and used
+    # anywhere an Array is expected (``a, b = result``, ``[*result]``).
+    def to_ary
+      @records.dup
     end
 
     def length

data/lib/tina4/drivers/mssql_driver.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
+require_relative "schema_split"
+
 module Tina4
   module Drivers
     class MssqlDriver
+      include SchemaSplit
       attr_reader :connection
 
       def connect(connection_string, username: nil, password: nil)
@@ -73,14 +76,28 @@ module Tina4
         @connection.execute("ROLLBACK").do
       end
 
+      # v3.13.14 (#48): honour a schema-qualified name ("dbo.widget"); a bare
+      # name matches in any schema (NULL guard skips the schema filter).
+      def table_exists?(name)
+        schema, tbl = split_schema(name)
+        sql = "SELECT 1 FROM INFORMATION_SCHEMA.TABLES " \
+              "WHERE TABLE_TYPE = 'BASE TABLE' AND TABLE_NAME = ? " \
+              "AND (? IS NULL OR TABLE_SCHEMA = ?)"
+        rows = execute_query(sql, [tbl, schema, schema])
+        !rows.empty?
+      end
+
       def tables
         rows = execute_query("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE'")
         rows.map { |r| r[:TABLE_NAME] || r[:table_name] }
       end
 
       def columns(table_name)
-        sql = "SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = ?"
-        rows = execute_query(sql, [table_name])
+        # v3.13.14 (#48): honour a schema-qualified name; bare names match any schema.
+        schema, tbl = split_schema(table_name)
+        sql = "SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT FROM INFORMATION_SCHEMA.COLUMNS " \
+              "WHERE TABLE_NAME = ? AND (? IS NULL OR TABLE_SCHEMA = ?)"
+        rows = execute_query(sql, [tbl, schema, schema])
         rows.map do |r|
           {
             name: r[:COLUMN_NAME] || r[:column_name],
@@ -109,7 +126,14 @@ module Tina4
         return sql if params.empty?
         result = sql.dup
         params.each do |param|
-          escaped = param.is_a?(String) ? "'#{param.gsub("'", "''")}'" : param.to_s
+          escaped =
+            if param.nil?
+              "NULL"
+            elsif param.is_a?(String)
+              "'#{param.gsub("'", "''")}'"
+            else
+              param.to_s
+            end
           result = result.sub("?", escaped)
         end
         result

data/lib/tina4/drivers/mysql_driver.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
+require_relative "schema_split"
+
 module Tina4
   module Drivers
     class MysqlDriver
+      include SchemaSplit
       attr_reader :connection
 
       def connect(connection_string, username: nil, password: nil)
@@ -75,6 +78,19 @@ module Tina4
         @connection.query("ROLLBACK")
       end
 
+      # v3.13.14 (#48): MySQL's "schema" is the database. A qualified name
+      # ("otherdb.table") checks that catalog; a bare name defaults to the
+      # connection's current database via DATABASE().
+      def table_exists?(name)
+        schema, tbl = split_schema(name)
+        rows = execute_query(
+          "SELECT 1 FROM information_schema.tables " \
+          "WHERE table_schema = COALESCE(?, DATABASE()) AND table_name = ?",
+          [schema, tbl]
+        )
+        !rows.empty?
+      end
+
       def tables
         rows = execute_query("SHOW TABLES")
         rows.map { |r| r.values.first }

data/lib/tina4/drivers/postgres_driver.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
+require_relative "schema_split"
+
 module Tina4
   module Drivers
     class PostgresDriver
+      include SchemaSplit
       attr_reader :connection
 
       def connect(connection_string, username: nil, password: nil)
@@ -112,15 +115,29 @@ module Tina4
         @connection.exec("ROLLBACK")
       end
 
+      # v3.13.14 (#48): to_regclass resolves a (possibly schema-qualified)
+      # relation name and search_path like a FROM clause; nil if absent.
+      def table_exists?(name)
+        rows = execute_query("SELECT to_regclass($1) AS oid", [name.to_s])
+        !rows.empty? && !rows[0][:oid].nil?
+      end
+
       def tables
-        sql = "SELECT tablename FROM pg_tables WHERE schemaname = 'public'"
+        # v3.13.14 (#48): list every user schema; public tables stay bare,
+        # others are returned schema-qualified.
+        sql = "SELECT schemaname, tablename FROM pg_tables " \
+              "WHERE schemaname NOT IN ('pg_catalog', 'information_schema') " \
+              "ORDER BY schemaname, tablename"
         rows = execute_query(sql)
-        rows.map { |r| r[:tablename] }
+        rows.map { |r| r[:schemaname] == "public" ? r[:tablename] : "#{r[:schemaname]}.#{r[:tablename]}" }
       end
 
       def columns(table_name)
-        sql = "SELECT column_name, data_type, is_nullable, column_default FROM information_schema.columns WHERE table_name = $1"
-        rows = execute_query(sql, [table_name])
+        # v3.13.14 (#48): honour a schema-qualified name; default to public.
+        schema, tbl = split_schema(table_name)
+        schema ||= "public"
+        sql = "SELECT column_name, data_type, is_nullable, column_default FROM information_schema.columns WHERE table_name = $1 AND table_schema = $2"
+        rows = execute_query(sql, [tbl, schema])
         rows.map do |r|
           {
             name: r[:column_name],

data/lib/tina4/drivers/schema_split.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Tina4
+  module Drivers
+    # v3.13.14 (#48): split a possibly-qualified table name into [schema, table].
+    #
+    # A model whose table name is qualified — PostgreSQL "gift_cards.gift_card",
+    # MSSQL "dbo.widget", MySQL "otherdb.table", SQLite "attached.table" — lives
+    # in that schema/catalog, not the default. Drivers use this so table_exists?
+    # / columns query the right namespace instead of matching the whole dotted
+    # string as one flat name. Returns [nil, name] for a bare name. Splits on the
+    # first dot. Firebird has no schemas, so its driver ignores this.
+    module SchemaSplit
+      def split_schema(name)
+        str = name.to_s
+        idx = str.index(".")
+        return [nil, str] if idx.nil?
+
+        [str[0...idx], str[(idx + 1)..]]
+      end
+    end
+  end
+end

data/lib/tina4/drivers/sqlite_driver.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
+require_relative "schema_split"
+
 module Tina4
   module Drivers
     class SqliteDriver
+      include SchemaSplit
       attr_reader :connection
 
       def connect(connection_string, username: nil, password: nil)
@@ -92,13 +95,26 @@ module Tina4
         @connection.execute("ROLLBACK")
       end
 
+      # v3.13.14 (#48): a SQLite "schema" is an ATTACH alias ("extra.widget").
+      # Query that database's own sqlite_master when the prefix is a plain
+      # identifier; otherwise treat the whole string as a bare table name.
+      def table_exists?(name)
+        schema, tbl = split_schema(name)
+        master = schema && identifier?(schema) ? "#{schema}.sqlite_master" : "sqlite_master"
+        rows = execute_query("SELECT 1 FROM #{master} WHERE type='table' AND name=?", [tbl])
+        !rows.empty?
+      end
+
       def tables
         rows = execute_query("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'")
         rows.map { |r| r[:name] }
       end
 
       def columns(table_name)
-        rows = execute_query("PRAGMA table_info(#{table_name})")
+        # v3.13.14 (#48): PRAGMA accepts an attached-schema prefix.
+        schema, tbl = split_schema(table_name)
+        pragma = schema && identifier?(schema) && identifier?(tbl) ? "#{schema}.table_info(#{tbl})" : "table_info(#{table_name})"
+        rows = execute_query("PRAGMA #{pragma}")
         rows.map do |r|
           {
             name: r[:name],
@@ -112,6 +128,11 @@ module Tina4
 
       private
 
+      # A safe-to-interpolate SQL identifier (no quoting/escaping needed).
+      def identifier?(str)
+        str.to_s.match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/)
+      end
+
       def symbolize_keys(hash)
         hash.each_with_object({}) do |(k, v), h|
           h[k.to_s.to_sym] = v if k.is_a?(String) || k.is_a?(Symbol)

data/lib/tina4/log.rb

@@ -80,6 +80,13 @@ module Tina4
         @current_context = {}
         @mutex = Mutex.new
 
+        # v3.13.14: unbuffer stdout so logs reach `docker logs` / k8s
+        # immediately. A non-TTY $stdout (every container) is block-buffered
+        # by default — logs sat in the buffer until it filled or the process
+        # exited, so operators "weren't getting logs". No-op when output is
+        # file-only.
+        $stdout.sync = true if @output != "file"
+
         # Build the file logger via stdlib Logger which handles rotation natively.
         # Logger.new(path, shift_age, shift_size):
         #   shift_age  = number of files to keep
@@ -175,8 +182,15 @@ module Tina4
       end
 
       def resolve_level
-        env_level = ENV["TINA4_LOG_LEVEL"] || "[TINA4_LOG_ALL]"
-        LEVELS[env_level] || 0
+        # v3.13.14: default is INFO (was ALL) so a deployed app surfaces
+        # request/startup/warn/error without debug noise, matching
+        # Python/PHP/Node. Accept BOTH the legacy bracket form
+        # ("[TINA4_LOG_ERROR]") AND plain names ("ERROR") so the env value
+        # is portable across all four frameworks.
+        raw = (ENV["TINA4_LOG_LEVEL"] || "").strip
+        return 1 if raw.empty? # INFO
+        key = raw.start_with?("[") ? raw.upcase : "[TINA4_LOG_#{raw.upcase}]"
+        LEVELS[key] || 1
       end
 
       def severity_to_level(level)

data/lib/tina4/middleware.rb

@@ -295,7 +295,9 @@ module Tina4
           elapsed_ms = 0.0
         end
 
-        Tina4::Log.info("[RequestLogger] #{request.method} #{request.path} -> #{response.status_code} (#{elapsed_ms}ms)")
+        # v3.13.14: dropped the "[RequestLogger]" prefix for format parity
+        # with Python/PHP/Node — the line is just METHOD PATH -> STATUS (Nms).
+        Tina4::Log.info("#{request.method} #{request.path} -> #{response.status_code} (#{elapsed_ms}ms)")
         [request, response]
       end
 

data/lib/tina4/orm.rb

@@ -306,13 +306,29 @@ module Tina4
       def create_table
         return true if db.table_exists?(table_name)
 
-        # v3.13.11 (BooleanField parity): pick each engine's native
-        # bool type where it's reliable. SQLite has no native bool;
-        # Firebird's driver round-trip for native BOOLEAN is uneven —
-        # both stay on INTEGER. PG/MySQL/MSSQL use their native types
-        # so Python ``True``/Ruby ``true`` bind cleanly without
-        # ``operator does not exist: boolean = integer`` errors.
+        # v3.13.16: engine-aware DDL. Ruby used to emit SQLite-only DDL on
+        # every driver — INTEGER for booleans, DATETIME for datetimes, and a
+        # raw AUTOINCREMENT keyword — then ignore db.execute()'s return value
+        # and report success. On PostgreSQL the CREATE blew up
+        # ("syntax error at or near AUTOINCREMENT"), db.execute() swallowed it
+        # into get_error() and returned false, yet create_table still returned
+        # true with no table created — a silent, misleading pass.
+        #
+        # The fix mirrors the Python reference (tina4_python.orm.model):
+        #   • get_database_type() now exists on Database (it didn't before, so
+        #     the v3.13.11 BooleanField check never actually fired on Ruby).
+        #   • BooleanField → native BOOLEAN (PG/MySQL) / BIT (MSSQL) /
+        #     INTEGER (sqlite, firebird) — both PG aliases are matched.
+        #   • DateTimeField → TIMESTAMP on PG/Firebird (neither has a DATETIME
+        #     type), DATETIME elsewhere.
+        #   • boolean DEFAULT is engine-aware: TRUE/FALSE for a native BOOLEAN,
+        #     1/0 for INTEGER/BIT-backed bools.
+        #   • AUTOINCREMENT is translated per engine via SQLTranslator
+        #     (SERIAL on PG, AUTO_INCREMENT on MySQL, IDENTITY on MSSQL, dropped
+        #     on Firebird) instead of being emitted raw.
+        #   • return false (not true) when the DDL fails.
         engine = (db.respond_to?(:get_database_type) ? db.get_database_type : "").to_s.downcase
+
         bool_sql = case engine
                    when "postgres", "postgresql" then "BOOLEAN"
                    when "mysql" then "BOOLEAN" # alias for TINYINT(1)
@@ -320,6 +336,15 @@ module Tina4
                    else "INTEGER" # sqlite, firebird, odbc, anything else
                    end
 
+        # PostgreSQL and Firebird have no DATETIME type — CREATE TABLE fails
+        # with `type "datetime" does not exist`. Emit each engine's real
+        # timestamp type. (MySQL/MSSQL/SQLite keep DATETIME: valid there, and
+        # on MySQL it avoids TIMESTAMP's auto-update + 2038 surprises.)
+        datetime_sql = case engine
+                       when "postgres", "postgresql", "firebird" then "TIMESTAMP"
+                       else "DATETIME"
+                       end
+
         type_map = {
           integer: "INTEGER",
           string: "VARCHAR(255)",
@@ -328,7 +353,7 @@ module Tina4
           decimal: "REAL",
           boolean: bool_sql,
           date: "DATE",
-          datetime: "DATETIME",
+          datetime: datetime_sql,
           timestamp: "TIMESTAMP",
           blob: "BLOB",
           json: "TEXT"
@@ -346,15 +371,29 @@ module Tina4
           parts << "AUTOINCREMENT" if opts[:auto_increment]
           parts << "NOT NULL" if !opts[:nullable] && !opts[:primary_key]
           if opts[:default] && !opts[:auto_increment]
-            default_val = opts[:default].is_a?(String) ? "'#{opts[:default]}'" : opts[:default]
-            parts << "DEFAULT #{default_val}"
+            parts << "DEFAULT #{default_literal(opts[:default], opts[:type], bool_sql)}"
           end
           col_defs << parts.join(" ")
         end
 
         sql = "CREATE TABLE IF NOT EXISTS #{table_name} (#{col_defs.join(', ')})"
-        db.execute(sql)
+
+        # Translate AUTOINCREMENT to the engine's auto-increment syntax
+        # (INTEGER PRIMARY KEY AUTOINCREMENT -> SERIAL PRIMARY KEY on PG, etc.).
+        # SQLTranslator keys off the -ql spelling for postgres.
+        translator_engine = %w[postgres postgresql].include?(engine) ? "postgresql" : engine
+        sql = SQLTranslator.auto_increment_syntax(sql, translator_engine)
+
+        # Don't claim success when the DDL failed. db.execute() swallows the
+        # driver error into get_error() and returns false, so a bad type (or
+        # any DDL error) used to leave create_table returning true while no
+        # table was actually created.
+        ok = db.execute(sql)
         db.commit
+        if ok == false
+          Tina4::Log.error("create_table failed for #{table_name}: #{db.get_error}", { sql: sql })
+          return false
+        end
         true
       end
 
@@ -427,6 +466,28 @@ module Tina4
         results = db.fetch(sql, filter.values)
         results.map { |row| from_hash(row) }
       end
+
+      # Render a column DEFAULT literal for create_table.
+      #
+      # Strings are quoted. Booleans are engine-aware: a native BOOLEAN
+      # column (PG/MySQL) needs TRUE/FALSE, while INTEGER- and BIT-backed
+      # bools (SQLite, Firebird, MSSQL) need 1/0 — `DEFAULT 0` on a PG
+      # BOOLEAN raises "default expression is of type integer". Everything
+      # else is emitted as-is.
+      def default_literal(value, type, bool_sql)
+        if value.is_a?(String)
+          "'#{value}'"
+        elsif value == true || value == false || type == :boolean
+          truthy = value == true || value == 1 || value == "1"
+          if bool_sql == "BOOLEAN"
+            truthy ? "TRUE" : "FALSE"
+          else
+            truthy ? "1" : "0"
+          end
+        else
+          value.to_s
+        end
+      end
     end
 
     def initialize(attributes = {})

data/lib/tina4/rack_app.rb

@@ -163,6 +163,16 @@ module Tina4
         )
       end
 
+      # Request log line (v3.13.14). The dev inspector above only feeds the
+      # /__dev UI — it never reached stdout, so `tina4ruby serve` printed the
+      # banner then went silent. Emit a per-request line through Tina4::Log so
+      # it lands on stdout (docker logs / k8s). On by default in dev, opt-in in
+      # production via TINA4_LOG_REQUESTS. Same format across all four frameworks.
+      if request_logging_enabled? && !path.start_with?("/__dev")
+        log_elapsed = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - request_start) * 1000).round(3)
+        Tina4::Log.info("#{method} #{path} -> #{rack_response[0]} (#{log_elapsed}ms)")
+      end
+
       # Inject dev overlay button for HTML responses in dev mode
       if dev_mode? && !path.start_with?("/__dev")
         status, headers, body_parts = rack_response
@@ -816,6 +826,17 @@ module Tina4
       Tina4::Env.is_truthy(ENV["TINA4_DEBUG"])
     end
 
+    # Whether to emit a per-request log line (v3.13.14). TINA4_LOG_REQUESTS
+    # is the explicit control (true/false); when unset, request logging
+    # follows dev mode (on under TINA4_DEBUG, off in production). Same
+    # contract across all four frameworks.
+    def request_logging_enabled?
+      val = ENV["TINA4_LOG_REQUESTS"]
+      return Tina4::Env.is_truthy(val) if val && !val.empty?
+
+      dev_mode?
+    end
+
     def websocket_upgrade?(env)
       upgrade = env["HTTP_UPGRADE"] || ""
       upgrade.downcase == "websocket"

data/lib/tina4/version.rb

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

data/lib/tina4.rb

@@ -62,6 +62,7 @@ require_relative "tina4/mcp"
 module Tina4
   # ── Lazy-loaded: database drivers ─────────────────────────────────────
   module Drivers
+    autoload :SchemaSplit,    File.expand_path("tina4/drivers/schema_split", __dir__)
     autoload :SqliteDriver,   File.expand_path("tina4/drivers/sqlite_driver", __dir__)
     autoload :PostgresDriver, File.expand_path("tina4/drivers/postgres_driver", __dir__)
     autoload :MysqlDriver,    File.expand_path("tina4/drivers/mysql_driver", __dir__)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.13.12
+  version: 3.13.16
 platform: ruby
 authors:
 - Tina4 Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-11 00:00:00.000000000 Z
+date: 2026-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -302,6 +302,7 @@ files:
 - lib/tina4/drivers/mysql_driver.rb
 - lib/tina4/drivers/odbc_driver.rb
 - lib/tina4/drivers/postgres_driver.rb
+- lib/tina4/drivers/schema_split.rb
 - lib/tina4/drivers/sqlite_driver.rb
 - lib/tina4/env.rb
 - lib/tina4/error_overlay.rb