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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 3.13.11
+Version: 3.13.12
 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.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tina4-python"
-version = "3.13.11"
+version = "3.13.12"
 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.12}/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.12"
 
 # ── Route decorators ──
 from tina4_python.core.router import (  # noqa: E402, F401

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

@@ -349,6 +349,32 @@ 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
+
     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.12}/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.12}/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.12}/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 ())

{tina4_python-3.13.11 → tina4_python-3.13.12}/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 [])

{tina4_python-3.13.11 → tina4_python-3.13.12}/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)

{tina4_python-3.13.11 → tina4_python-3.13.12}/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