velocity-python 0.0.205__tar.gz → 0.0.207__tar.gz

{velocity_python-0.0.205 → velocity_python-0.0.207}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.205
+Version: 0.0.207
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.0.205 → velocity_python-0.0.207}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "velocity-python"
-version = "0.0.205"
+version = "0.0.207"
 authors = [
   { name="Velocity Team", email="info@codeclubs.org" },
 ]

{velocity_python-0.0.205 → velocity_python-0.0.207}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.205"
+__version__ = version = "0.0.207"
 
 from . import aws
 from . import db

{velocity_python-0.0.205 → velocity_python-0.0.207}/src/velocity/aws/handlers/mixins/data_service.py

@@ -9,6 +9,7 @@ import base64
 import datetime
 import importlib
 import logging
+import re
 from io import BytesIO
 
 from velocity.misc import export
@@ -152,8 +153,116 @@ class DataServiceMixin:
         self._call_rwx_hook("before_query", "common", tx, table, payload, context)
         self._call_rwx_hook("before_query", table, tx, table, payload, context)
         params = payload.get("params", {})
-        result = tx.table(payload["obj"]).select(**params)
-        if payload.get("result_format") == "excel":
+        result_format = payload.get("result_format")
+
+        # Clear any previous swallowed-error details so we only report errors
+        # related to this query.
+        if hasattr(tx, "_last_return_default_error"):
+            tx._last_return_default_error = None
+
+        obj = payload["obj"]
+
+        def _normalize_identifier(identifier: str):
+            if identifier is None:
+                return None
+            identifier = str(identifier).strip()
+            if not identifier:
+                return None
+            if identifier[0] == identifier[-1] and identifier[0] in {'"', "'"}:
+                identifier = identifier[1:-1]
+            return identifier
+
+        def _extract_requested_column_names(columns_spec):
+            if not columns_spec:
+                return []
+            if isinstance(columns_spec, str):
+                columns_spec = [columns_spec]
+            if not isinstance(columns_spec, (list, tuple)):
+                return []
+
+            requested = []
+            simple_identifier = re.compile(
+                r"^([A-Za-z_][A-Za-z0-9_]*)(\\.([A-Za-z_][A-Za-z0-9_]*))?$"
+            )
+
+            for col in columns_spec:
+                if not isinstance(col, str):
+                    continue
+
+                raw = col.strip()
+                if not raw or raw == "*":
+                    continue
+
+                # If this looks like an expression (functions, casts, aliases, etc.),
+                # skip strict validation and let the DB error (which we will surface).
+                lowered = raw.lower()
+                if (
+                    "(" in raw
+                    or ")" in raw
+                    or " over " in lowered
+                    or "::" in raw
+                    or " as " in lowered
+                    or "+" in raw
+                    or "-" in raw
+                    or "/" in raw
+                    or "*" in raw
+                    or "||" in raw
+                ):
+                    continue
+
+                # Allow simple identifiers, optionally qualified (table.column).
+                match = simple_identifier.match(raw)
+                if not match:
+                    continue
+
+                colname = match.group(3) or match.group(1)
+                colname = _normalize_identifier(colname)
+                if colname:
+                    requested.append(colname)
+
+            return requested
+
+        # Optional: detect missing columns before running the query.
+        requested_cols = _extract_requested_column_names(params.get("columns"))
+        if requested_cols:
+            available_cols = {c.lower() for c in tx.table(obj).sys_columns()}
+            missing = sorted(
+                {c for c in requested_cols if c.lower() not in available_cols},
+                key=lambda v: v.lower(),
+            )
+            if missing:
+                message = (
+                    f"Query failed for '{obj}': requested columns not present in the database: "
+                    + ", ".join(missing)
+                )
+                context.response().toast(message, "error")
+                error_payload = {
+                    "type": "missing-columns",
+                    "message": message,
+                    "missing": missing,
+                }
+                if result_format == "excel":
+                    return {
+                        "headers": payload.get("headers", []),
+                        "rows": [],
+                        "error": error_payload,
+                    }
+                return {
+                    "rows": [],
+                    "config": {
+                        "lastFetch": datetime.datetime.now(),
+                        "query": None,
+                        "format": result_format,
+                        "error": error_payload,
+                    },
+                }
+
+        result = tx.table(obj).select(**params)
+
+        swallowed_error = getattr(tx, "_last_return_default_error", None)
+        if swallowed_error:
+            tx._last_return_default_error = None
+        if result_format == "excel":
             data = {
                 "headers": payload.get(
                     "headers", [x.replace("_", " ").title() for x in result.headers]
@@ -166,9 +275,34 @@ class DataServiceMixin:
                 "config": {
                     "lastFetch": datetime.datetime.now(),
                     "query": result.sql,
-                    "format": payload.get("result_format"),
+                    "format": result_format,
                 },
             }
+
+        # If the DB call failed but was swallowed (return_default), surface a reason.
+        # Common symptoms are empty rows + null SQL.
+        if swallowed_error and result_format == "excel":
+            error_message = swallowed_error.get("message") or "Unknown database error"
+            context.response().toast(
+                f"Query failed for '{obj}': {error_message.splitlines()[0]}",
+                "error",
+            )
+            data["error"] = {"type": "db-error", **swallowed_error}
+        elif swallowed_error and isinstance(data, dict) and data.get("config") is not None:
+            error_message = swallowed_error.get("message") or "Unknown database error"
+            context.response().toast(
+                f"Query failed for '{obj}': {error_message.splitlines()[0]}",
+                "error",
+            )
+            data["config"].update(
+                {
+                    "query": data["config"].get("query") or None,
+                    "error": {
+                        "type": "db-error",
+                        **swallowed_error,
+                    },
+                }
+            )
         if payload.get("count"):
             data["count"] = tx.table(payload["obj"]).count(
                 where=params.get("where", None)

{velocity_python-0.0.205 → velocity_python-0.0.207}/src/velocity/db/core/decorators.py

@@ -105,8 +105,21 @@ def return_default(
                 result = func(self, *args, **kwds)
                 if result is None:
                     result = default
-            except func.exceptions:
+            except func.exceptions as e:
                 self.tx.rollback_savepoint(sp, cursor=self.cursor())
+
+                # Capture swallowed exceptions for upstream diagnostics.
+                # This decorator intentionally returns a default value instead of
+                # raising, but consumers (e.g. API handlers) may still want to
+                # surface a reason to the caller.
+                try:
+                    self.tx._last_return_default_error = {
+                        "type": e.__class__.__name__,
+                        "message": str(e),
+                        "function": f"{func.__module__}.{getattr(func, '__qualname__', func.__name__)}",
+                    }
+                except Exception:
+                    pass
                 return default
             self.tx.release_savepoint(sp, cursor=self.cursor())
             return result

{velocity_python-0.0.205 → velocity_python-0.0.207}/src/velocity/db/servers/base/sql.py

@@ -59,35 +59,15 @@ class BaseSQLDialect(ABC):
         Dialects should override/extend this if they can do better than message matching.
         Engine uses this only as a fallback when no/unknown error code is available.
         """
-        if not msg:
-            return False
-        m = str(msg).strip().lower()
-        needles = (
-            "server closed the connection unexpectedly",
-            "no connection to the server",
-            "connection timed out",
-            "could not connect to server",
-            "cannot connect to server",
-            "connection already closed",
-            "cursor already closed",
-            "ssl syscall error",
-            "eof detected",
-            "connection reset by peer",
-            "broken pipe",
-            "terminating connection due to administrator command",
-            "could not receive data from server",
-            "could not send data to server",
-        )
-        return any(n in m for n in needles)
+        return False
 
     @classmethod
     def is_transient_connection_error_message(cls, msg: str) -> bool:
         """Return True if a connection error looks transient/retryable.
 
-        Default implementation treats most low-level disconnects as transient.
-        Dialects may override to be stricter.
+        Default implementation is disabled; dialects must implement this.
         """
-        return cls.is_connection_error_message(msg)
+        return False
 
     # Core CRUD Operations
     @classmethod

{velocity_python-0.0.205 → velocity_python-0.0.207}/src/velocity/db/servers/mysql/sql.py

@@ -72,6 +72,45 @@ class SQL(BaseSQLDialect):
         error_msg = getattr(e, "msg", None)
         return error_code, error_msg
 
+    @classmethod
+    def is_connection_error_message(cls, msg: str) -> bool:
+        if not msg:
+            return False
+        m = str(msg).strip().lower()
+
+        # Common MySQL connector / server disconnects.
+        needles = (
+            "mysql server has gone away",
+            "lost connection to mysql server",
+            "can't connect to mysql server",
+            "connection refused",
+            "connection reset by peer",
+            "broken pipe",
+            "connection timed out",
+            "read timed out",
+            "write timed out",
+            "server shutdown",
+            "too many connections",
+            "is dead or not enabled",
+        )
+        return any(n in m for n in needles)
+
+    @classmethod
+    def is_transient_connection_error_message(cls, msg: str) -> bool:
+        if not cls.is_connection_error_message(msg):
+            return False
+
+        # Do not treat auth/config problems as transient.
+        m = str(msg).strip().lower()
+        non_transient = (
+            "access denied",
+            "authentication",
+            "unknown database",
+            "unknown mysql server host",
+            "bad handshake",
+        )
+        return not any(n in m for n in non_transient)
+
     @classmethod
     def select(
         cls,

{velocity_python-0.0.205 → velocity_python-0.0.207}/src/velocity/db/servers/postgres/sql.py

@@ -77,6 +77,37 @@ class SQL(BaseSQLDialect):
         error_mesg = getattr(e, "pgerror", None)
         return error_code, error_mesg
 
+    @classmethod
+    def is_connection_error_message(cls, msg: str) -> bool:
+        if not msg:
+            return False
+        m = str(msg).strip().lower()
+        needles = (
+            "server closed the connection unexpectedly",
+            "no connection to the server",
+            "connection timed out",
+            "could not connect to server",
+            "cannot connect to server",
+            "could not translate host name",
+            "connection already closed",
+            "cursor already closed",
+            "ssl syscall error",
+            "eof detected",
+            "connection reset by peer",
+            "broken pipe",
+            "terminating connection due to administrator command",
+            "could not receive data from server",
+            "could not send data to server",
+            "the database system is starting up",
+            "the database system is shutting down",
+        )
+        return any(n in m for n in needles)
+
+    @classmethod
+    def is_transient_connection_error_message(cls, msg: str) -> bool:
+        # For Postgres, low-level disconnects/restarts are typically transient.
+        return cls.is_connection_error_message(msg)
+
     @staticmethod
     def _validate_where_string(where):
         """

{velocity_python-0.0.205 → velocity_python-0.0.207}/src/velocity/db/servers/sqlite/sql.py

@@ -72,6 +72,24 @@ class SQL(BaseSQLDialect):
         # SQLite exceptions don't have error codes like other databases
         return None, str(e)
 
+    @classmethod
+    def is_connection_error_message(cls, msg: str) -> bool:
+        if not msg:
+            return False
+        m = str(msg).strip().lower()
+        needles = (
+            "unable to open database file",
+            "disk i/o error",
+            "readonly database",
+            "file is not a database",
+        )
+        return any(n in m for n in needles)
+
+    @classmethod
+    def is_transient_connection_error_message(cls, msg: str) -> bool:
+        # SQLite connection/file errors are typically not transient in-process.
+        return False
+
     @classmethod
     def select(
         cls,

{velocity_python-0.0.205 → velocity_python-0.0.207}/src/velocity/db/servers/sqlserver/sql.py

@@ -74,6 +74,40 @@ class SQL(BaseSQLDialect):
         error_message = getattr(e, "message", None) or str(e)
         return error_number, error_message
 
+    @classmethod
+    def is_connection_error_message(cls, msg: str) -> bool:
+        if not msg:
+            return False
+        m = str(msg).strip().lower()
+
+        # pyodbc/pymssql/pytds typically surface these in message text.
+        needles = (
+            "communication link failure",
+            "transport-level error",
+            "tcp provider",
+            "a connection was successfully established with the server, but then an error occurred during the login process",
+            "connection is broken",
+            "connection was forcibly closed",
+            "connection reset",
+            "login timeout expired",
+            "server is not found or not accessible",
+            "could not open a connection",
+            "network-related",
+            "connection timed out",
+            "broken pipe",
+        )
+        return any(n in m for n in needles)
+
+    @classmethod
+    def is_transient_connection_error_message(cls, msg: str) -> bool:
+        if not cls.is_connection_error_message(msg):
+            return False
+        m = str(msg).strip().lower()
+        # "login failed" is usually credentials/permissions, not transient.
+        if "login failed" in m:
+            return False
+        return True
+
     @classmethod
     def select(
         cls,

{velocity_python-0.0.205 → velocity_python-0.0.207}/src/velocity_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.205
+Version: 0.0.207
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT