sqlmodel-object-helpers 0.0.6__tar.gz → 0.0.7__tar.gz

{sqlmodel_object_helpers-0.0.6 → sqlmodel_object_helpers-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmodel-object-helpers
-Version: 0.0.6
+Version: 0.0.7
 Summary: Generic async query helpers for SQLModel: filtering, eager loading, pagination
 Project-URL: Homepage, https://github.com/itstandart/sqlmodel-object-helpers
 Project-URL: Repository, https://github.com/itstandart/sqlmodel-object-helpers

{sqlmodel_object_helpers-0.0.6 → sqlmodel_object_helpers-0.0.7}/src/sqlmodel_object_helpers/__init__.py

@@ -1,6 +1,6 @@
 """sqlmodel-object-helpers — reusable query helpers for SQLModel projects."""
 
-__version__ = "0.0.6"
+__version__ = "0.0.7"
 
 from .constants import QueryHelperSettings, settings
 from .dynamic_meta import (

{sqlmodel_object_helpers-0.0.6 → sqlmodel_object_helpers-0.0.7}/src/sqlmodel_object_helpers/query.py

@@ -4,6 +4,7 @@ from typing import Any
 
 from pydantic import BaseModel
 from sqlalchemy import exists as sa_exists
+from sqlalchemy.exc import DataError as SADataError
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.sql import func
 from sqlmodel import SQLModel, and_, or_, select
@@ -398,6 +399,10 @@ async def get_objects[T: SQLModel](
         if not suspend_error:
             raise
         return []
+    except SADataError as e:
+        if not suspend_error:
+            raise InvalidFilterError(str(e)) from e
+        return []
     except Exception as e:
         if not suspend_error:
             raise DatabaseError(str(e)) from e
@@ -467,6 +472,10 @@ async def count_objects[T: SQLModel](
         if not suspend_error:
             raise
         return 0
+    except SADataError as e:
+        if not suspend_error:
+            raise InvalidFilterError(str(e)) from e
+        return 0
     except Exception as e:
         if not suspend_error:
             raise DatabaseError(str(e)) from e
@@ -529,6 +538,10 @@ async def exists_object[T: SQLModel](
         if not suspend_error:
             raise
         return False
+    except SADataError as e:
+        if not suspend_error:
+            raise InvalidFilterError(str(e)) from e
+        return False
     except Exception as e:
         if not suspend_error:
             raise DatabaseError(str(e)) from e
@@ -721,6 +734,10 @@ async def get_projection[T: SQLModel](
         if suspend_error:
             return []
         raise
+    except SADataError as e:
+        if suspend_error:
+            return []
+        raise InvalidFilterError(str(e)) from e
     except Exception as e:
         if suspend_error:
             return []

{sqlmodel_object_helpers-0.0.6 → sqlmodel_object_helpers-0.0.7}/src/sqlmodel_object_helpers/types/filters.py

@@ -103,6 +103,12 @@ class FilterDate(BaseModel):
 
 
 class FilterNaiveDatetime(BaseModel):
+    """Filter for TIMESTAMP WITHOUT TIME ZONE columns.
+
+    Timezone-aware input is **rejected** (raises ``ValueError`` → HTTP 422)
+    because silently stripping timezone info hides conversion bugs on the caller side.
+    """
+
     eq: datetime | None = None
     ne: datetime | None = None
     gt: datetime | None = None
@@ -110,6 +116,17 @@ class FilterNaiveDatetime(BaseModel):
     ge: datetime | None = None
     le: datetime | None = None
 
+    @field_validator("eq", "ne", "gt", "lt", "ge", "le", mode="after")
+    @classmethod
+    def reject_timezone(cls, v: datetime | None) -> datetime | None:
+        if v is not None and v.tzinfo is not None:
+            msg = (
+                "Timezone-aware datetime is not allowed for naive datetime filters. "
+                "Send a naive datetime (without timezone offset), e.g. '2026-03-19T00:00:00'"
+            )
+            raise ValueError(msg)
+        return v
+
 
 class FilterDatetime(BaseModel):
     eq: UTCDatetime | None = None
@@ -207,7 +224,8 @@ class FilterNaiveDatetimeRange(BaseModel):
     """
     Same as :class:`FilterDatetimeRange` but produces **naive** (timezone-unaware) datetimes.
 
-    If the input contains timezone info, it is stripped (replaced with None).
+    Timezone-aware input is **rejected** (raises ``ValueError`` → HTTP 422)
+    because silently stripping timezone info hides conversion bugs on the caller side.
     """
 
     gt: datetime | None = None
@@ -220,6 +238,17 @@ class FilterNaiveDatetimeRange(BaseModel):
             return cls._parse_range(data)
         return data
 
+    @field_validator("gt", "lt", mode="after")
+    @classmethod
+    def reject_timezone(cls, v: datetime | None) -> datetime | None:
+        if v is not None and v.tzinfo is not None:
+            msg = (
+                "Timezone-aware datetime is not allowed for naive datetime range filters. "
+                "Send a naive datetime (without timezone offset), e.g. '2026-03-19T00:00:00'"
+            )
+            raise ValueError(msg)
+        return v
+
     @staticmethod
     def _parse_range(range_str: str) -> dict[str, datetime]:
         range_str = range_str.strip()
@@ -231,9 +260,9 @@ class FilterNaiveDatetimeRange(BaseModel):
         result: dict[str, datetime] = {}
 
         if left:
-            result["gt"] = _parse_range_part(left).replace(tzinfo=None)
+            result["gt"] = _parse_range_part(left)
         if right:
-            result["lt"] = _parse_range_part(right).replace(tzinfo=None)
+            result["lt"] = _parse_range_part(right)
 
         return result
 

sqlmodel_object_helpers-0.0.7/tests/test_data_error_handling.py

@@ -0,0 +1,153 @@
+"""
+Tests for SADataError → InvalidFilterError handling in query.py.
+
+SQLite does not raise sqlalchemy.exc.DataError, so we mock session methods
+to simulate the asyncpg DataError that occurs when e.g. a timezone-aware
+datetime is sent to a TIMESTAMP WITHOUT TIME ZONE column.
+
+Covers all query entry points: get_objects, count_objects, exists_object, get_projection.
+"""
+
+from unittest.mock import AsyncMock, patch
+
+import pytest
+from sqlalchemy.exc import DataError as SADataError
+
+import sqlmodel_object_helpers as soh
+
+from conftest import Applicant
+
+
+pytestmark = pytest.mark.asyncio
+
+
+def _make_sa_data_error() -> SADataError:
+    """Build a realistic SADataError matching the asyncpg timezone mismatch."""
+    return SADataError(
+        statement="SELECT ... WHERE gp_payment_date = $1::TIMESTAMP WITHOUT TIME ZONE",
+        params=(None,),
+        orig=Exception(
+            "can't subtract offset-naive and offset-aware datetimes"
+        ),
+    )
+
+
+# =============================================================================
+# get_objects — SADataError → InvalidFilterError(400)
+# =============================================================================
+
+
+async def test_get_objects_data_error_raises_invalid_filter(session):
+    """SADataError from DB must be re-raised as InvalidFilterError, not DatabaseError."""
+    with patch.object(session, "execute", new_callable=AsyncMock, side_effect=_make_sa_data_error()):
+        with pytest.raises(soh.InvalidFilterError) as exc_info:
+            await soh.get_objects(session, Applicant)
+
+        assert exc_info.value.status_code == 400
+        assert "offset-naive and offset-aware" in exc_info.value.message
+
+
+async def test_get_objects_data_error_suspend_returns_empty(session):
+    """SADataError with suspend_error=True returns empty list, not raises."""
+    with patch.object(session, "execute", new_callable=AsyncMock, side_effect=_make_sa_data_error()):
+        result = await soh.get_objects(session, Applicant, suspend_error=True)
+
+    assert result == []
+
+
+async def test_get_objects_data_error_not_database_error(session):
+    """SADataError must NOT become DatabaseError(500)."""
+    with patch.object(session, "execute", new_callable=AsyncMock, side_effect=_make_sa_data_error()):
+        with pytest.raises(soh.InvalidFilterError):
+            await soh.get_objects(session, Applicant)
+
+        # Verify it's NOT DatabaseError
+        try:
+            await soh.get_objects(session, Applicant)
+        except soh.DatabaseError:
+            pytest.fail("SADataError was incorrectly wrapped as DatabaseError(500)")
+        except soh.InvalidFilterError:
+            pass  # correct behavior
+
+
+# =============================================================================
+# count_objects — SADataError → InvalidFilterError(400)
+# =============================================================================
+
+
+async def test_count_objects_data_error_raises_invalid_filter(session):
+    """SADataError in count_objects must raise InvalidFilterError."""
+    with patch.object(session, "scalar", new_callable=AsyncMock, side_effect=_make_sa_data_error()):
+        with pytest.raises(soh.InvalidFilterError) as exc_info:
+            await soh.count_objects(session, Applicant)
+
+        assert exc_info.value.status_code == 400
+
+
+async def test_count_objects_data_error_suspend_returns_zero(session):
+    """SADataError in count_objects with suspend_error=True returns 0."""
+    with patch.object(session, "scalar", new_callable=AsyncMock, side_effect=_make_sa_data_error()):
+        result = await soh.count_objects(session, Applicant, suspend_error=True)
+
+    assert result == 0
+
+
+# =============================================================================
+# exists_object — SADataError → InvalidFilterError(400)
+# =============================================================================
+
+
+async def test_exists_object_data_error_raises_invalid_filter(session):
+    """SADataError in exists_object must raise InvalidFilterError."""
+    with patch.object(session, "scalar", new_callable=AsyncMock, side_effect=_make_sa_data_error()):
+        with pytest.raises(soh.InvalidFilterError) as exc_info:
+            await soh.exists_object(session, Applicant)
+
+        assert exc_info.value.status_code == 400
+
+
+async def test_exists_object_data_error_suspend_returns_false(session):
+    """SADataError in exists_object with suspend_error=True returns False."""
+    with patch.object(session, "scalar", new_callable=AsyncMock, side_effect=_make_sa_data_error()):
+        result = await soh.exists_object(session, Applicant, suspend_error=True)
+
+    assert result is False
+
+
+# =============================================================================
+# get_projection — SADataError → InvalidFilterError(400)
+# =============================================================================
+
+
+async def test_get_projection_data_error_raises_invalid_filter(session):
+    """SADataError in get_projection must raise InvalidFilterError."""
+    with patch.object(session, "execute", new_callable=AsyncMock, side_effect=_make_sa_data_error()):
+        with pytest.raises(soh.InvalidFilterError) as exc_info:
+            await soh.get_projection(session, Applicant, columns=["id", "last_name"])
+
+        assert exc_info.value.status_code == 400
+
+
+async def test_get_projection_data_error_suspend_returns_empty(session):
+    """SADataError in get_projection with suspend_error=True returns []."""
+    with patch.object(session, "execute", new_callable=AsyncMock, side_effect=_make_sa_data_error()):
+        result = await soh.get_projection(
+            session, Applicant, columns=["id", "last_name"], suspend_error=True,
+        )
+
+    assert result == []
+
+
+# =============================================================================
+# Contrast: non-DataError exceptions still become DatabaseError(500)
+# =============================================================================
+
+
+async def test_generic_exception_still_raises_database_error(session):
+    """Non-DataError exceptions must still become DatabaseError(500)."""
+    with patch.object(session, "execute", new_callable=AsyncMock, side_effect=RuntimeError("connection lost")):
+        with pytest.raises(soh.DatabaseError) as exc_info:
+            await soh.get_objects(session, Applicant)
+
+        assert exc_info.value.status_code == 500
+        assert "connection lost" in exc_info.value.message

{sqlmodel_object_helpers-0.0.6 → sqlmodel_object_helpers-0.0.7}/tests/test_datetime_range.py

@@ -293,3 +293,31 @@ class TestFilterNaiveDatetimeRange:
         assert f.lt == datetime(2026, 2, 1)
         assert f.gt.tzinfo is None
         assert f.lt.tzinfo is None
+
+    def test_rejects_tz_in_dict_input(self):
+        """Dict with timezone-aware ISO strings is rejected (was the 500 bug)."""
+        with pytest.raises(ValidationError, match="Timezone-aware datetime is not allowed"):
+            soh.FilterNaiveDatetimeRange.model_validate(
+                {"gt": "2026-03-20T12:24:00.000+03:00", "lt": "2026-03-20T23:59:59.999+03:00"},
+            )
+
+    def test_rejects_tz_in_dict_gt_only(self):
+        """Single gt with timezone in dict is rejected."""
+        with pytest.raises(ValidationError, match="Timezone-aware datetime is not allowed"):
+            soh.FilterNaiveDatetimeRange.model_validate(
+                {"gt": "2026-01-01T00:00:00+00:00"},
+            )
+
+    def test_rejects_tz_in_string_input(self):
+        """String range with timezone offset is rejected."""
+        with pytest.raises(ValidationError, match="Timezone-aware datetime is not allowed"):
+            soh.FilterNaiveDatetimeRange.model_validate(
+                "2026-04-01T03:00:00+03:00,2026-04-02T03:00:00+03:00"
+            )
+
+    def test_rejects_z_suffix_in_string_input(self):
+        """Z suffix means UTC (timezone-aware) — must be rejected for naive range."""
+        with pytest.raises(ValidationError, match="Timezone-aware datetime is not allowed"):
+            soh.FilterNaiveDatetimeRange.model_validate(
+                "2026-04-01T00:00:00Z,2026-04-02T00:00:00Z"
+            )

{sqlmodel_object_helpers-0.0.6 → sqlmodel_object_helpers-0.0.7}/tests/test_types.py

@@ -375,11 +375,24 @@ def test_filter_naive_datetime_accepts_iso_string():
     assert f.eq == datetime(2026, 6, 15, 10, 30, 0)
 
 
-def test_filter_naive_datetime_also_accepts_aware():
-    """FilterNaiveDatetime does not reject aware datetimes — no validation."""
+def test_filter_naive_datetime_rejects_aware():
+    """FilterNaiveDatetime rejects timezone-aware datetimes with ValidationError."""
     dt = datetime(2026, 1, 15, 10, 30, 0, tzinfo=timezone.utc)
-    f = soh.FilterNaiveDatetime(eq=dt)
-    assert f.eq is not None
+    with pytest.raises(ValidationError, match="Timezone-aware datetime is not allowed"):
+        soh.FilterNaiveDatetime(eq=dt)
+
+
+def test_filter_naive_datetime_rejects_aware_iso_string():
+    """FilterNaiveDatetime rejects ISO string with timezone offset."""
+    with pytest.raises(ValidationError, match="Timezone-aware datetime is not allowed"):
+        soh.FilterNaiveDatetime(gt="2026-03-20T12:24:00.000+03:00")
+
+
+def test_filter_naive_datetime_rejects_aware_all_operators():
+    """FilterNaiveDatetime rejects timezone-aware input on every operator."""
+    for field in ("eq", "ne", "gt", "lt", "ge", "le"):
+        with pytest.raises(ValidationError, match="Timezone-aware datetime is not allowed"):
+            soh.FilterNaiveDatetime(**{field: "2026-01-01T00:00:00+00:00"})
 
 
 def test_filter_naive_datetime_all_none():