velocity-python 0.0.206__tar.gz → 0.0.208__tar.gz

{velocity_python-0.0.206 → velocity_python-0.0.208}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.206
+Version: 0.0.208
 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.206 → velocity_python-0.0.208}/pyproject.toml

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

{velocity_python-0.0.206 → velocity_python-0.0.208}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.206"
+__version__ = version = "0.0.208"
 
 from . import aws
 from . import db

{velocity_python-0.0.206 → velocity_python-0.0.208}/src/velocity/aws/handlers/base_handler.py

@@ -13,6 +13,7 @@ from typing import Any, Dict, List, Optional
 
 from velocity.aws.handlers import context as VelocityContext
 from velocity.aws.handlers.context_factory import ContextFactory
+from velocity.aws.handlers.exceptions import AlertError
 
 logger = logging.getLogger(__name__)
 
@@ -221,6 +222,30 @@ class BaseHandler:
             local_context: The context object
             exception: The exception that occurred
         """
+        if isinstance(exception, AlertError):
+            payload = {}
+            try:
+                payload = exception.get_payload() or {}
+            except Exception:
+                payload = {"message": str(exception)}
+
+            title = payload.get("title") or "Notification"
+            message = payload.get("message") or str(exception)
+
+            logger.warning(
+                "AlertError during action execution",
+                exc_info=True,
+                extra={
+                    "handler": self.__class__.__name__,
+                    "action": getattr(local_context, "action", lambda: None)(),
+                    "tx_present": tx is not None,
+                },
+            )
+
+            # Historical behavior: raising AlertError should surface a UI alert.
+            local_context.response().alert(message=message, title=title)
+            return
+
         # Always log the original exception so it isn't lost if the error-path
         # (e.g. job-status updates) fails due to a transient DB disconnect.
         logger.exception(

{velocity_python-0.0.206 → velocity_python-0.0.208}/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.206 → velocity_python-0.0.208}/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.206 → velocity_python-0.0.208}/src/velocity_python.egg-info/PKG-INFO

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