serialize python types to json in orm api requests

Author: purificant

src/bubble_data_api_client/client/orm.py

@@ -30,7 +30,7 @@ class User(BubbleModel, typename="user"):
 from bubble_data_api_client.client.raw_client import AdditionalSortField, RawClient
 from bubble_data_api_client.constraints import Constraint, ConstraintType, constraint
 from bubble_data_api_client.exceptions import BubbleAPIError, UnknownFieldError
-from bubble_data_api_client.types import BubbleField, OnMultiple
+from bubble_data_api_client.types import BUILTIN_FIELDS, BubbleField, OnMultiple
 
 
 def _get_client() -> RawClient:
@@ -69,18 +69,17 @@ def __init_subclass__(cls, *, typename: str, **kwargs: typing.Any) -> None:
         cls._typename = typename
 
     @classmethod
-    def _resolve_aliases(cls, data: dict[str, typing.Any]) -> dict[str, typing.Any]:
-        """Translate ORM field names to their aliases for API requests."""
-        resolved: dict[str, typing.Any] = {}
-        for field_name, value in data.items():
-            field_info = cls.model_fields.get(field_name)
-            if field_info is None:
+    def _serialize_for_api(cls, data: dict[str, typing.Any]) -> dict[str, typing.Any]:
+        """Serialize field data for API requests with aliasing and JSON conversion."""
+        for field_name in data:
+            if field_name not in cls.model_fields:
                 raise UnknownFieldError(field_name)
-            if field_info.alias:
-                resolved[field_info.alias] = value
-            else:
-                resolved[field_name] = value
-        return resolved
+        partial = cls.model_construct(**data)
+        return partial.model_dump(
+            mode="json",
+            include=set(data.keys()),
+            by_alias=True,
+        )
 
     @classmethod
     async def create(cls, **data: typing.Any) -> typing.Self:
@@ -92,7 +91,7 @@ async def create(cls, **data: typing.Any) -> typing.Self:
         Returns:
             A new model instance with the assigned Bubble UID.
         """
-        aliased_data = cls._resolve_aliases(data)
+        aliased_data = cls._serialize_for_api(data)
         async with _get_client() as client:
             response = await client.create(cls._typename, aliased_data)
             uid = response.json()["id"]
@@ -129,15 +128,16 @@ async def save(self) -> None:
         async with _get_client() as client:
             # exclude uid and server-managed fields
             data = self.model_dump(
-                exclude={"uid", "created_date", "modified_date", "slug"},
+                mode="json",
+                exclude=BUILTIN_FIELDS,
                 by_alias=True,
             )
             await client.update(self._typename, self.uid, data)
 
     @classmethod
     async def update(cls, uid: str, **data: typing.Any) -> None:
         """Update specific fields on a thing by its unique ID."""
-        aliased_data = cls._resolve_aliases(data)
+        aliased_data = cls._serialize_for_api(data)
         async with _get_client() as client:
             await client.update(cls._typename, uid, aliased_data)
 
@@ -284,9 +284,9 @@ async def create_or_update(
         on_multiple: OnMultiple,
     ) -> tuple[typing.Self, bool]:
         """Create a thing if it doesn't exist, or update if it does."""
-        aliased_match = cls._resolve_aliases(match)
-        aliased_create_data = cls._resolve_aliases(create_data) if create_data else None
-        aliased_update_data = cls._resolve_aliases(update_data) if update_data else None
+        aliased_match = cls._serialize_for_api(match)
+        aliased_create_data = cls._serialize_for_api(create_data) if create_data else None
+        aliased_update_data = cls._serialize_for_api(update_data) if update_data else None
         async with _get_client() as client:
             result = await client.create_or_update(
                 typename=cls._typename,

src/bubble_data_api_client/types.py

@@ -18,6 +18,19 @@ class BubbleField(StrEnum):
     SLUG = "Slug"
 
 
+class BuiltinField(StrEnum):
+    """Python ORM attribute names for Bubble's built-in fields."""
+
+    UID = "uid"
+    CREATED_DATE = "created_date"
+    MODIFIED_DATE = "modified_date"
+    SLUG = "slug"
+
+
+BUILTIN_FIELDS: set[str] = set(BuiltinField)
+"""Python ORM attribute names for Bubble's built-in fields, as a set."""
+
+
 class OnMultiple(StrEnum):
     """Strategy for handling multiple matches in create_or_update."""
 

src/tests/unit/client/test_orm.py

@@ -41,6 +41,23 @@ class Order(BubbleModel, typename="order"):
     assert request_body == {"Buying company": "Acme Corp"}
 
 
+@respx.mock
+async def test_update_serializes_datetime(configured_client: None) -> None:
+    """Verify update() serializes datetime values to ISO strings."""
+
+    class Event(BubbleModel, typename="event"):
+        name: str
+        start_time: datetime
+
+    route = respx.patch("https://example.com/event/abc123").mock(return_value=httpx.Response(204))
+
+    await Event.update(uid="abc123", start_time=datetime(2026, 1, 15, 14, 30, 0))
+
+    assert route.call_count == 1
+    request_body = json.loads(route.calls[0].request.content)
+    assert request_body == {"start_time": "2026-01-15T14:30:00"}
+
+
 @respx.mock
 async def test_update_single_field(configured_client: None) -> None:
     """Verify update() sends only the specified field."""