tina4-python 3.13.11__tar.gz → 3.13.14__tar.gz

{tina4_python-3.13.11 → tina4_python-3.13.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 3.13.11
+Version: 3.13.14
 Summary: Tina4 Python v3 — Zero-dependency, lightweight web framework
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 License: MIT

{tina4_python-3.13.11 → tina4_python-3.13.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tina4-python"
-version = "3.13.11"
+version = "3.13.14"
 description = "Tina4 Python v3 — Zero-dependency, lightweight web framework"
 authors = [
     {name = "Andre van Zuydam", email = "andrevanzuydam@gmail.com"}

{tina4_python-3.13.11 → tina4_python-3.13.14}/tina4_python/__init__.py

@@ -8,7 +8,7 @@ Tina4 Python v3.0 — Zero-dependency, lightweight web framework.
 
 One import, everything works.
 """
-__version__ = "3.13.11"
+__version__ = "3.13.14"
 
 # ── Route decorators ──
 from tina4_python.core.router import (  # noqa: E402, F401

{tina4_python-3.13.11 → tina4_python-3.13.14}/tina4_python/core/middleware.py

@@ -361,9 +361,15 @@ class RequestLoggerMiddleware:
     """Request logger — stamps start time before the handler and logs elapsed time after.
 
     Mirrors the PHP, Ruby and Node.js RequestLogger classes.
+
+    v3.13.14: routes through the Tina4 ``Log`` class (was stdlib
+    ``logging.getLogger``, whose ``info()`` is silently dropped by an
+    unconfigured root logger — so these lines never reached stdout).
+    The dev server also logs every request globally (see
+    ``server._finalize_response``); this middleware remains for callers
+    that want per-route request logging.
     """
 
-    _logger = logging.getLogger("tina4.request")
     _start_times: dict = {}
     _lock = threading.Lock()
 
@@ -385,7 +391,6 @@ class RequestLoggerMiddleware:
         method = getattr(request, "method", "?")
         path = getattr(request, "url", None) or getattr(request, "path", "/")
         status = getattr(response, "status_code", None) or getattr(response, "status", 0)
-        RequestLoggerMiddleware._logger.info(
-            "[RequestLogger] %s %s -> %s (%sms)", method, path, status, elapsed_ms
-        )
+        from tina4_python.debug import Log
+        Log.info(f"{method} {path} -> {status} ({elapsed_ms}ms)")
         return request, response

{tina4_python-3.13.11 → tina4_python-3.13.14}/tina4_python/core/server.py

@@ -1404,6 +1404,21 @@ def _handle_no_route(request: Request, response: Response, request_id: str) -> R
     return response
 
 
+def _request_logging_enabled(is_dev: bool) -> bool:
+    """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 (so prod doesn't pay the per-request logging cost unless the
+    operator opts in). Same contract across all four frameworks.
+    """
+    from tina4_python.dotenv import is_truthy
+    val = os.environ.get("TINA4_LOG_REQUESTS")
+    if val is not None and val != "":
+        return is_truthy(val)
+    return is_dev
+
+
 def _finalize_response(
     request: Request, response: Response, route: dict | None,
     request_id: str, is_dev: bool, req_start: float,
@@ -1444,6 +1459,22 @@ def _finalize_response(
         except Exception:
             pass
 
+    # Request log line (v3.13.14). The dev dashboard's RequestInspector above
+    # only feeds the /__dev UI — it never reached stdout, so `tina4 serve`
+    # printed the startup banner then went silent even as requests flowed.
+    # Emit a per-request line through the Tina4 Log so it lands on stdout
+    # (docker logs / k8s) like every other log. On by default in dev; opt-in
+    # in production via TINA4_LOG_REQUESTS to avoid per-request overhead.
+    if _request_logging_enabled(is_dev):
+        try:
+            import time as _time
+            elapsed_ms = round((_time.perf_counter() - req_start) * 1000, 3)
+            Log.info(
+                f"{request.method} {request.path} -> {response.status_code} ({elapsed_ms}ms)"
+            )
+        except Exception:
+            pass
+
     # Session save + cookie.
     # Skip saving if this was a brand-new session that the route never wrote to —
     # that prevents empty orphaned session files accumulating on disk.
@@ -2081,7 +2112,12 @@ def run(host: str | None = None, port: int | None = None, no_browser: bool = Fal
 
     # Init logger
     is_production = os.environ.get("TINA4_ENV", "development") == "production"
-    log_level = os.environ.get("TINA4_LOG_LEVEL", "error" if not is_production else "error")
+    # v3.13.14: default level is INFO (was ERROR). ERROR-by-default meant a
+    # deployed app that logged at info/debug appeared silent — operators
+    # "weren't getting logs". INFO shows request/startup/warn/error without
+    # debug noise, and matches PHP/Ruby/Node defaults. Override per-deploy
+    # with TINA4_LOG_LEVEL.
+    log_level = os.environ.get("TINA4_LOG_LEVEL", "info")
     Log.configure(level=log_level, production=is_production)
 
     # Install a top-level exception hook so uncaught exceptions bubbling

{tina4_python-3.13.11 → tina4_python-3.13.14}/tina4_python/database/adapter.py

@@ -349,6 +349,53 @@ class DatabaseAdapter:
             last_id=last_id,
         )
 
+    @staticmethod
+    def _strip_trailing_semicolons(sql: str) -> str:
+        """v3.13.12: normalize user-supplied SQL by stripping trailing
+        semicolons and whitespace.
+
+        ``fetch()`` and ``fetch_one()`` wrap the user's SQL — fetch()
+        builds a ``SELECT COUNT(*) FROM ({sql}) AS _count_subquery``
+        for the pagination probe and appends ``LIMIT/OFFSET`` to the
+        real query. A trailing ``;`` in the user's SQL breaks both:
+
+            user input:  "SELECT * FROM users;"
+            wrapped:     "SELECT COUNT(*) FROM (SELECT * FROM users;) ..."   ← syntax error
+            paginated:   "SELECT * FROM users; LIMIT 100 OFFSET 0"           ← invalid
+
+        Stripping trailing semicolons before any wrapping is the
+        single-line defence. Internal semicolons (between meaningful
+        SQL statements) are left alone — the driver will reject those
+        if multi-statement isn't supported on the engine.
+        """
+        if not sql:
+            return sql
+        stripped = sql.rstrip()
+        while stripped.endswith(";"):
+            stripped = stripped[:-1].rstrip()
+        return stripped
+
+    @staticmethod
+    def _split_schema(name: str) -> tuple[str | None, str]:
+        """Split a possibly-qualified table name into (schema, table).
+
+        v3.13.14 (#48): 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. Each adapter's
+        ``table_exists`` / ``get_columns`` use this to query the right
+        namespace instead of matching the whole dotted string as one
+        flat table name. Returns ``(None, name)`` for a bare name so
+        callers default to the engine's current namespace. Splits on the
+        first dot; quoted identifiers with embedded dots aren't supported
+        (they weren't before either). Firebird has no schemas, so its
+        adapter ignores this.
+        """
+        if "." in name:
+            schema, _, table = name.partition(".")
+            return schema, table
+        return None, name
+
     def fetch(self, sql: str, params: list = None,
               limit: int = 100, offset: int = 0) -> DatabaseResult:
         """Execute a read query and return multiple rows."""

{tina4_python-3.13.11 → tina4_python-3.13.14}/tina4_python/database/connection.py

@@ -457,8 +457,8 @@ class Database:
             raise
 
     def fetch_all(self, sql: str, params: list = None,
-                  limit: int = 100, offset: int = 0) -> list[dict]:
-        """Fetch rows and return the records list directly.
+                  limit: int = 0, offset: int = 0) -> list[dict]:
+        """Fetch ALL rows and return the records list directly.
 
         Symmetric with ``fetch_one``. For the common case where you just
         want the rows and don't need the ``DatabaseResult`` metadata
@@ -469,6 +469,10 @@ class Database:
             for row in rows:
                 print(row["name"])
 
+        v3.13.12: default ``limit`` is **0** (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=N`` to cap.
+
         Returns ``[]`` (not ``None``) when no rows match.
         """
         return self.fetch(sql, params, limit, offset).records

{tina4_python-3.13.11 → tina4_python-3.13.14}/tina4_python/database/firebird.py

@@ -283,6 +283,9 @@ class FirebirdAdapter(DatabaseAdapter):
 
     def fetch(self, sql: str, params: list = None,
               limit: int = 100, offset: int = 0) -> DatabaseResult:
+        # v3.13.12: strip trailing `;` — Firebird wraps with COUNT(*)
+        # and appends ROWS pagination; a trailing semicolon breaks both.
+        sql = self._strip_trailing_semicolons(sql)
         sql = self._translate_sql(sql)
         cursor = self._conn.cursor()
 
@@ -297,10 +300,15 @@ class FirebirdAdapter(DatabaseAdapter):
             # paginated query below regardless of whether count succeeded.
             cursor = self._conn.cursor()
 
-        # Apply Firebird pagination — ROWS start TO end
-        start = offset + 1
-        end = offset + limit
-        paginated_sql = f"{sql} ROWS {start} TO {end}"
+        # Apply Firebird pagination — ROWS start TO end.
+        # v3.13.12: limit <= 0 means "no pagination" (fetch_all's
+        # default — give me ALL rows).
+        if limit is None or limit <= 0:
+            paginated_sql = sql
+        else:
+            start = offset + 1
+            end = offset + limit
+            paginated_sql = f"{sql} ROWS {start} TO {end}"
         cursor = self._safe_cursor_execute(cursor, paginated_sql, params)
 
         desc = cursor.description
@@ -310,6 +318,7 @@ class FirebirdAdapter(DatabaseAdapter):
         return DatabaseResult(records=rows, count=total, limit=limit, offset=offset, sql=sql, adapter=self)
 
     def fetch_one(self, sql: str, params: list = None) -> dict | None:
+        sql = self._strip_trailing_semicolons(sql)
         sql = self._translate_sql(sql)
         cursor = self._conn.cursor()
         cursor = self._safe_cursor_execute(cursor, sql, params)

{tina4_python-3.13.11 → tina4_python-3.13.14}/tina4_python/database/mssql.py

@@ -105,6 +105,8 @@ class MSSQLAdapter(DatabaseAdapter):
 
     def fetch(self, sql: str, params: list = None,
               limit: int = 100, offset: int = 0) -> DatabaseResult:
+        # v3.13.12: strip trailing `;` — see DatabaseAdapter helper.
+        sql = self._strip_trailing_semicolons(sql)
         sql = self._translate_sql(sql)
         cursor = self._conn.cursor(as_dict=True)
 
@@ -116,20 +118,26 @@ class MSSQLAdapter(DatabaseAdapter):
         except Exception:
             total = 0
 
-        # Apply pagination — MSSQL uses OFFSET/FETCH
-        # This requires an ORDER BY; if none exists, add a default
-        if not re.search(r"\bORDER\s+BY\b", sql, re.IGNORECASE):
-            paginated_sql = f"{sql} ORDER BY (SELECT NULL) OFFSET %s ROWS FETCH NEXT %s ROWS ONLY"
+        # Apply pagination — MSSQL uses OFFSET/FETCH.
+        # v3.13.12: limit <= 0 means "no pagination" (fetch_all's
+        # default — give me ALL rows).
+        if limit is None or limit <= 0:
+            paginated_sql = sql
+            paginated_params = tuple(params or [])
         else:
-            paginated_sql = f"{sql} OFFSET %s ROWS FETCH NEXT %s ROWS ONLY"
-
-        paginated_params = tuple(params or []) + (offset, limit)
+            # OFFSET/FETCH requires an ORDER BY; if none exists, add a default
+            if not re.search(r"\bORDER\s+BY\b", sql, re.IGNORECASE):
+                paginated_sql = f"{sql} ORDER BY (SELECT NULL) OFFSET %s ROWS FETCH NEXT %s ROWS ONLY"
+            else:
+                paginated_sql = f"{sql} OFFSET %s ROWS FETCH NEXT %s ROWS ONLY"
+            paginated_params = tuple(params or []) + (offset, limit)
         cursor.execute(paginated_sql, paginated_params)
         rows = [dict(row) for row in cursor.fetchall()]
 
         return DatabaseResult(records=rows, count=total, limit=limit, offset=offset, sql=sql, adapter=self)
 
     def fetch_one(self, sql: str, params: list = None) -> dict | None:
+        sql = self._strip_trailing_semicolons(sql)
         sql = self._translate_sql(sql)
         cursor = self._conn.cursor(as_dict=True)
         cursor.execute(sql, tuple(params) if params else ())
@@ -182,10 +190,17 @@ class MSSQLAdapter(DatabaseAdapter):
         self._in_transaction = False
 
     def table_exists(self, name: str) -> bool:
+        # v3.13.14 (#48): honour a schema-qualified name ("dbo.widget",
+        # "sales.orders"). Schemas are everyday in SQL Server; pre-fix this
+        # had no schema filter and matched the whole dotted string as a flat
+        # TABLE_NAME, so any qualified table_name was invisible. A bare name
+        # still matches in any schema (unchanged behaviour).
+        schema, tbl = self._split_schema(name)
         row = self.fetch_one(
             "SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES "
-            "WHERE TABLE_TYPE = 'BASE TABLE' AND TABLE_NAME = %s",
-            [name],
+            "WHERE TABLE_TYPE = 'BASE TABLE' AND TABLE_NAME = %s "
+            "AND (%s IS NULL OR TABLE_SCHEMA = %s)",
+            [tbl, schema, schema],
         )
         return row is not None
 
@@ -198,6 +213,9 @@ class MSSQLAdapter(DatabaseAdapter):
         return [r["TABLE_NAME"] for r in result.records]
 
     def get_columns(self, table: str) -> list[dict]:
+        # v3.13.14 (#48): honour a schema-qualified name; a bare name matches
+        # in any schema (unchanged).
+        schema, tbl = self._split_schema(table)
         sql = """
             SELECT c.COLUMN_NAME, c.DATA_TYPE, c.IS_NULLABLE, c.COLUMN_DEFAULT,
                    CASE WHEN pk.COLUMN_NAME IS NOT NULL THEN 1 ELSE 0 END AS is_primary
@@ -207,12 +225,13 @@ class MSSQLAdapter(DatabaseAdapter):
                 FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
                 JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE ku
                   ON tc.CONSTRAINT_NAME = ku.CONSTRAINT_NAME
-                WHERE tc.TABLE_NAME = %s AND tc.CONSTRAINT_TYPE = 'PRIMARY KEY'
+                WHERE tc.TABLE_NAME = %s AND (%s IS NULL OR tc.TABLE_SCHEMA = %s)
+                  AND tc.CONSTRAINT_TYPE = 'PRIMARY KEY'
             ) pk ON c.COLUMN_NAME = pk.COLUMN_NAME
-            WHERE c.TABLE_NAME = %s
+            WHERE c.TABLE_NAME = %s AND (%s IS NULL OR c.TABLE_SCHEMA = %s)
             ORDER BY c.ORDINAL_POSITION
         """
-        result = self.fetch(sql, [table, table], limit=10000)
+        result = self.fetch(sql, [tbl, schema, schema, tbl, schema, schema], limit=10000)
         return [
             {
                 "name": r["COLUMN_NAME"],

{tina4_python-3.13.11 → tina4_python-3.13.14}/tina4_python/database/mysql.py

@@ -94,6 +94,9 @@ class MySQLAdapter(DatabaseAdapter):
 
     def fetch(self, sql: str, params: list = None,
               limit: int = 100, offset: int = 0) -> DatabaseResult:
+        # v3.13.12: strip trailing `;` before wrapping with COUNT(*)
+        # and appending LIMIT/OFFSET — see DatabaseAdapter helper.
+        sql = self._strip_trailing_semicolons(sql)
         sql = self._translate_sql(sql)
         cursor = self._conn.cursor(dictionary=True)
 
@@ -105,15 +108,21 @@ class MySQLAdapter(DatabaseAdapter):
         except Exception:
             total = 0
 
-        # Apply pagination
-        paginated_sql = f"{sql} LIMIT %s OFFSET %s"
-        paginated_params = (params or []) + [limit, offset]
+        # Apply pagination — v3.13.12: limit <= 0 means "no pagination"
+        # (fetch_all's default — give me ALL rows).
+        if limit is None or limit <= 0:
+            paginated_sql = sql
+            paginated_params = params or []
+        else:
+            paginated_sql = f"{sql} LIMIT %s OFFSET %s"
+            paginated_params = (params or []) + [limit, offset]
         cursor.execute(paginated_sql, paginated_params)
         rows = [dict(row) for row in cursor.fetchall()]
 
         return DatabaseResult(records=rows, count=total, limit=limit, offset=offset, sql=sql, adapter=self)
 
     def fetch_one(self, sql: str, params: list = None) -> dict | None:
+        sql = self._strip_trailing_semicolons(sql)
         sql = self._translate_sql(sql)
         cursor = self._conn.cursor(dictionary=True)
         cursor.execute(sql, params or [])
@@ -165,10 +174,16 @@ class MySQLAdapter(DatabaseAdapter):
         self._in_transaction = False
 
     def table_exists(self, name: str) -> bool:
+        # v3.13.14 (#48): honour a database-qualified name ("otherdb.table").
+        # In MySQL "schema" == database; default to the connected database.
+        # Pre-fix this matched the whole dotted string as a flat TABLE_NAME
+        # under DATABASE() only, so a cross-database qualified name was never
+        # found and create_table()/migrations misfired.
+        schema, tbl = self._split_schema(name)
         row = self.fetch_one(
             "SELECT TABLE_NAME FROM information_schema.TABLES "
-            "WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = %s",
-            [name],
+            "WHERE TABLE_SCHEMA = COALESCE(%s, DATABASE()) AND TABLE_NAME = %s",
+            [schema, tbl],
         )
         return row is not None
 

{tina4_python-3.13.11 → tina4_python-3.13.14}/tina4_python/database/postgres.py

@@ -306,6 +306,10 @@ class PostgreSQLAdapter(DatabaseAdapter):
               limit: int = 100, offset: int = 0) -> DatabaseResult:
         import psycopg2.extras
 
+        # v3.13.12: strip trailing `;` before the framework wraps with
+        # COUNT(*) and appends LIMIT/OFFSET — otherwise a user-supplied
+        # `"SELECT * FROM users;"` produces invalid wrapped SQL.
+        sql = self._strip_trailing_semicolons(sql)
         sql = self._translate_sql(sql)
 
         # v3.13.8: heal first so the COUNT probe below doesn't open on a
@@ -342,8 +346,14 @@ class PostgreSQLAdapter(DatabaseAdapter):
         # Apply pagination — the real query, so use the error-handling
         # wrapper. The count probe above is best-effort and stays on
         # _safe_execute (a failed probe shouldn't taint last_error).
-        paginated_sql = f"{sql} LIMIT %s OFFSET %s"
-        paginated_params = (params or []) + [limit, offset]
+        # v3.13.12: limit <= 0 means "no pagination" (fetch_all's
+        # default — give me ALL rows, not a silent first-100 slice).
+        if limit is None or limit <= 0:
+            paginated_sql = sql
+            paginated_params = params or []
+        else:
+            paginated_sql = f"{sql} LIMIT %s OFFSET %s"
+            paginated_params = (params or []) + [limit, offset]
         self._exec_with_handling(cursor, paginated_sql, paginated_params)
         rows = [self._decode_blobs(dict(row)) for row in cursor.fetchall()]
 
@@ -352,6 +362,8 @@ class PostgreSQLAdapter(DatabaseAdapter):
     def fetch_one(self, sql: str, params: list = None) -> dict | None:
         import psycopg2.extras
 
+        # v3.13.12: see fetch() — trailing semicolons break the wrappers.
+        sql = self._strip_trailing_semicolons(sql)
         sql = self._translate_sql(sql)
         cursor = self._conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
         self._exec_with_handling(cursor, sql, params)
@@ -411,20 +423,40 @@ class PostgreSQLAdapter(DatabaseAdapter):
         self._in_transaction = False
 
     def table_exists(self, name: str) -> bool:
-        row = self.fetch_one(
-            "SELECT tablename FROM pg_tables WHERE schemaname = 'public' AND tablename = %s",
-            [name],
-        )
-        return row is not None
+        # v3.13.x (#48): support schema-qualified names ("schema.table") and the
+        # connection search_path. to_regclass() resolves a (possibly qualified)
+        # relation name to its OID using the SAME rules Postgres applies to a
+        # FROM clause, returning NULL when absent. Pre-fix this hardcoded
+        # schemaname='public' AND matched the whole dotted string as a flat
+        # tablename, so a table in a non-public schema was invisible —
+        # table_exists() always returned False, so create_table()/migrations
+        # misfired and ORM introspection saw nothing.
+        row = self.fetch_one("SELECT to_regclass(%s) AS oid", [name])
+        return bool(row and row.get("oid") is not None)
 
     def get_tables(self) -> list[str]:
+        # v3.13.x (#48): list tables from every user schema, not just public.
+        # public tables stay bare ("users"); tables in other schemas are
+        # returned schema-qualified ("gift_cards.gift_card") so the names round
+        # -trip back through table_exists()/get_columns().
         result = self.fetch(
-            "SELECT tablename FROM pg_tables WHERE schemaname = 'public' ORDER BY tablename",
+            """
+            SELECT schemaname, tablename FROM pg_tables
+            WHERE schemaname NOT IN ('pg_catalog', 'information_schema')
+            ORDER BY schemaname, tablename
+            """,
             limit=10000,
         )
-        return [r["tablename"] for r in result.records]
+        return [
+            r["tablename"] if r["schemaname"] == "public"
+            else f"{r['schemaname']}.{r['tablename']}"
+            for r in result.records
+        ]
 
     def get_columns(self, table: str) -> list[dict]:
+        # v3.13.x (#48): honour a schema-qualified name; default to public.
+        schema, tbl = self._split_schema(table)
+        schema = schema or "public"
         sql = """
             SELECT c.column_name, c.data_type, c.is_nullable, c.column_default,
                    CASE WHEN pk.column_name IS NOT NULL THEN true ELSE false END AS is_primary
@@ -434,12 +466,12 @@ class PostgreSQLAdapter(DatabaseAdapter):
                 FROM information_schema.table_constraints tc
                 JOIN information_schema.key_column_usage ku
                   ON tc.constraint_name = ku.constraint_name
-                WHERE tc.table_name = %s AND tc.constraint_type = 'PRIMARY KEY'
+                WHERE tc.table_name = %s AND tc.table_schema = %s AND tc.constraint_type = 'PRIMARY KEY'
             ) pk ON c.column_name = pk.column_name
-            WHERE c.table_name = %s AND c.table_schema = 'public'
+            WHERE c.table_name = %s AND c.table_schema = %s
             ORDER BY c.ordinal_position
         """
-        result = self.fetch(sql, [table, table], limit=10000)
+        result = self.fetch(sql, [tbl, schema, tbl, schema], limit=10000)
         return [
             {
                 "name": r["column_name"],

{tina4_python-3.13.11 → tina4_python-3.13.14}/tina4_python/database/sqlite.py

@@ -108,6 +108,8 @@ class SQLiteAdapter(DatabaseAdapter):
 
     def fetch(self, sql: str, params: list = None,
               limit: int = 100, offset: int = 0) -> DatabaseResult:
+        # v3.13.12: strip trailing `;` before wrapping — see DatabaseAdapter.
+        sql = self._strip_trailing_semicolons(sql)
         # Count total rows (without LIMIT/OFFSET)
         count_sql = f"SELECT COUNT(*) as cnt FROM ({sql})"
         try:
@@ -115,8 +117,12 @@ class SQLiteAdapter(DatabaseAdapter):
         except Exception:
             total = 0
 
-        # Apply pagination — skip if SQL already has LIMIT
-        if "LIMIT" in sql.upper().split("--")[0]:
+        # Apply pagination — skip if SQL already has LIMIT, or if
+        # limit <= 0 (v3.13.12: fetch_all's "give me all rows" path).
+        if limit is None or limit <= 0:
+            paginated_sql = sql
+            paginated_params = params or []
+        elif "LIMIT" in sql.upper().split("--")[0]:
             paginated_sql = sql
             paginated_params = params or []
         else:
@@ -128,6 +134,7 @@ class SQLiteAdapter(DatabaseAdapter):
         return DatabaseResult(records=rows, count=total, limit=limit, offset=offset, sql=sql, adapter=self)
 
     def fetch_one(self, sql: str, params: list = None) -> dict | None:
+        sql = self._strip_trailing_semicolons(sql)
         cursor = self._conn.execute(sql, params or [])
         row = cursor.fetchone()
         return dict(row) if row else None
@@ -172,9 +179,16 @@ class SQLiteAdapter(DatabaseAdapter):
         self._in_transaction = False
 
     def table_exists(self, name: str) -> bool:
+        # v3.13.14 (#48): honour an attached-database prefix ("attached.table").
+        # SQLite's "schema" is an ATTACH alias; each has its own sqlite_master.
+        # Bare names use the main database (unchanged). The alias must be a
+        # plain identifier (it's developer-supplied, but guard against the dot
+        # being part of an odd name).
+        schema, tbl = self._split_schema(name)
+        master = f"{schema}.sqlite_master" if schema and schema.isidentifier() else "sqlite_master"
         row = self.fetch_one(
-            "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
-            [name]
+            f"SELECT name FROM {master} WHERE type='table' AND name=?",
+            [tbl if (schema and schema.isidentifier()) else name]
         )
         return row is not None
 
@@ -186,7 +200,13 @@ class SQLiteAdapter(DatabaseAdapter):
         return [r["name"] for r in result.records]
 
     def get_columns(self, table: str) -> list[dict]:
-        cursor = self._conn.execute(f"PRAGMA table_info({table})")
+        # v3.13.14 (#48): honour an attached-database prefix via
+        # `PRAGMA <schema>.table_info(<table>)`.
+        schema, tbl = self._split_schema(table)
+        if schema and schema.isidentifier() and tbl.isidentifier():
+            cursor = self._conn.execute(f"PRAGMA {schema}.table_info({tbl})")
+        else:
+            cursor = self._conn.execute(f"PRAGMA table_info({table})")
         return [
             {
                 "name": row["name"],

{tina4_python-3.13.11 → tina4_python-3.13.14}/tina4_python/debug/__init__.py

@@ -412,10 +412,18 @@ class Log:
         # File always gets ALL levels (no filtering for file output)
         line = cls._format_line(level, message, **kwargs)
 
-        # Console output respects TINA4_LOG_LEVEL and the stdout toggle
-        if cls._stdout_enabled and not cls._is_production and cls._should_log(level):
-            color = cls.COLORS.get(level, "")
-            print(f"{color}{line}{cls.RESET}")
+        # Console output respects TINA4_LOG_LEVEL and the stdout toggle.
+        # v3.13.14: stdout is NOT suppressed in production — containers
+        # treat stdout as the canonical log sink (docker logs / k8s read
+        # PID 1 stdout), and the pre-v3.13.14 `not _is_production` gate
+        # meant deployed containers got nothing. Production still emits
+        # JSON (see _format_line / _is_production), just on stdout now.
+        # flush=True so logs appear immediately on a non-TTY pipe rather
+        # than sitting in Python's block buffer until the process exits.
+        if cls._stdout_enabled and cls._should_log(level):
+            color = "" if cls._is_production else cls.COLORS.get(level, "")
+            reset = "" if cls._is_production else cls.RESET
+            print(f"{color}{line}{reset}", flush=True)
 
         # Always write ALL levels to the main file (raw log, no filtering)
         if cls._writer: