respect field aliases on all write operations (create, update, create_or_update)

Author: purificant

src/bubble_data_api_client/client/orm.py

@@ -24,13 +24,28 @@ def __init_subclass__(cls, *, typename: str, **kwargs: typing.Any) -> None:
         super().__init_subclass__(**kwargs)
         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:
+                raise UnknownFieldError(field_name)
+            if field_info.alias:
+                resolved[field_info.alias] = value
+            else:
+                resolved[field_name] = value
+        return resolved
+
     @classmethod
     async def create(cls, **data: typing.Any) -> typing.Self:
+        aliased_data = cls._resolve_aliases(data)
         async with _get_client() as client:
-            response = await client.create(cls._typename, data)
+            response = await client.create(cls._typename, aliased_data)
             response.raise_for_status()
             uid = response.json()["id"]
-            return cls(**data, **{BubbleField.ID: uid})
+            return cls(**aliased_data, **{BubbleField.ID: uid})
 
     @classmethod
     async def get(cls, uid: str) -> typing.Self | None:
@@ -64,16 +79,7 @@ async def save(self) -> None:
     @classmethod
     async def update(cls, uid: str, **data: typing.Any) -> None:
         """Update specific fields on a thing by its unique ID."""
-        aliased_data: dict[str, typing.Any] = {}
-        for field_name, value in data.items():
-            field_info = cls.model_fields.get(field_name)
-            if field_info is None:
-                raise UnknownFieldError(field_name)
-            if field_info.alias:
-                aliased_data[field_info.alias] = value
-            else:
-                aliased_data[field_name] = value
-
+        aliased_data = cls._resolve_aliases(data)
         async with _get_client() as client:
             response = await client.update(cls._typename, uid, aliased_data)
             response.raise_for_status()
@@ -135,13 +141,15 @@ 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_data = cls._resolve_aliases(data)
         async with _get_client() as client:
             result = await client.create_or_update(
                 typename=cls._typename,
-                match=match,
-                data=data,
+                match=aliased_match,
+                data=aliased_data,
                 on_multiple=on_multiple,
             )
-            # construct instance from input data, similar to create()
+            # construct instance from aliased data
             # server-side fields like Modified Date won't be populated
-            return cls(**match, **data, **{BubbleField.ID: result["uids"][0]}), result["created"]
+            return cls(**aliased_match, **aliased_data, **{BubbleField.ID: result["uids"][0]}), result["created"]

src/tests/unit/client/test_orm.py

@@ -82,3 +82,130 @@ class User(BubbleBaseModel, typename="user"):
 
     with pytest.raises(UnknownFieldError, match="unknown field: nonexistent"):
         await User.update(uid="abc123", nonexistent="value")
+
+
+@respx.mock
+async def test_create_translates_field_aliases(configured_client: None) -> None:
+    """Verify create() translates Python field names to Bubble aliases."""
+
+    class Order(BubbleBaseModel, typename="order"):
+        company: str = Field(alias="Buying company")
+        status: str
+
+    route = respx.post("https://example.com/order").mock(
+        return_value=httpx.Response(200, json={"status": "success", "id": "new123"})
+    )
+
+    order = await Order.create(company="Acme Corp", status="pending")
+
+    assert route.call_count == 1
+    request_body = json.loads(route.calls[0].request.content)
+    assert request_body == {"Buying company": "Acme Corp", "status": "pending"}
+    assert order.company == "Acme Corp"
+    assert order.status == "pending"
+    assert order.uid == "new123"
+
+
+async def test_create_raises_for_unknown_field() -> None:
+    """Verify create() raises UnknownFieldError for fields not in the model."""
+
+    class User(BubbleBaseModel, typename="user"):
+        name: str
+
+    with pytest.raises(UnknownFieldError, match="unknown field: nonexistent"):
+        await User.create(name="test", nonexistent="value")
+
+
+@respx.mock
+async def test_create_or_update_translates_match_aliases(configured_client: None) -> None:
+    """Verify create_or_update() translates match field names to Bubble aliases."""
+    from bubble_data_api_client.types import OnMultiple
+
+    class Order(BubbleBaseModel, typename="order"):
+        external_id: str = Field(alias="External ID")
+        company: str = Field(alias="Buying company")
+
+    # mock find returning no results (will create)
+    find_route = respx.get("https://example.com/order").mock(
+        return_value=httpx.Response(200, json={"response": {"results": [], "count": 0, "remaining": 0}})
+    )
+    # mock create
+    create_route = respx.post("https://example.com/order").mock(
+        return_value=httpx.Response(200, json={"status": "success", "id": "new123"})
+    )
+
+    _order, created = await Order.create_or_update(
+        match={"external_id": "ext-001"},
+        data={"company": "Acme Corp"},
+        on_multiple=OnMultiple.ERROR,
+    )
+
+    assert created is True
+    assert find_route.call_count == 1
+    # verify find used aliased field name in constraint
+    find_request_url = str(find_route.calls[0].request.url)
+    assert "External%20ID" in find_request_url or "External+ID" in find_request_url
+
+    assert create_route.call_count == 1
+    request_body = json.loads(create_route.calls[0].request.content)
+    assert request_body == {"External ID": "ext-001", "Buying company": "Acme Corp"}
+
+
+@respx.mock
+async def test_create_or_update_translates_data_aliases(configured_client: None) -> None:
+    """Verify create_or_update() translates data field names to Bubble aliases."""
+    from bubble_data_api_client.types import OnMultiple
+
+    class Order(BubbleBaseModel, typename="order"):
+        external_id: str = Field(alias="External ID")
+        company: str = Field(alias="Buying company")
+
+    # mock find returning one result (will update)
+    respx.get("https://example.com/order").mock(
+        return_value=httpx.Response(
+            200, json={"response": {"results": [{"_id": "existing123"}], "count": 1, "remaining": 0}}
+        )
+    )
+    # mock update
+    update_route = respx.patch("https://example.com/order/existing123").mock(return_value=httpx.Response(204))
+
+    _order, created = await Order.create_or_update(
+        match={"external_id": "ext-001"},
+        data={"company": "Updated Corp"},
+        on_multiple=OnMultiple.ERROR,
+    )
+
+    assert created is False
+    assert update_route.call_count == 1
+    request_body = json.loads(update_route.calls[0].request.content)
+    assert request_body == {"Buying company": "Updated Corp"}
+
+
+async def test_create_or_update_raises_for_unknown_match_field() -> None:
+    """Verify create_or_update() raises UnknownFieldError for unknown match fields."""
+    from bubble_data_api_client.types import OnMultiple
+
+    class User(BubbleBaseModel, typename="user"):
+        name: str
+
+    with pytest.raises(UnknownFieldError, match="unknown field: nonexistent"):
+        await User.create_or_update(
+            match={"nonexistent": "value"},
+            data={"name": "test"},
+            on_multiple=OnMultiple.ERROR,
+        )
+
+
+async def test_create_or_update_raises_for_unknown_data_field() -> None:
+    """Verify create_or_update() raises UnknownFieldError for unknown data fields."""
+    from bubble_data_api_client.types import OnMultiple
+
+    class User(BubbleBaseModel, typename="user"):
+        name: str
+
+    with pytest.raises(UnknownFieldError, match="unknown field: nonexistent"):
+        await User.create_or_update(
+            match={"name": "test"},
+            data={"nonexistent": "value"},
+            on_multiple=OnMultiple.ERROR,
+        )