allow different data for create vs update in create_or_update

Author: purificant

src/bubble_data_api_client/client/orm.py

@@ -163,19 +163,23 @@ async def create_or_update(
         cls,
         *,
         match: dict[str, typing.Any],
-        data: dict[str, typing.Any],
+        create_data: dict[str, typing.Any] | None = None,
+        update_data: dict[str, typing.Any] | None = None,
         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)
+        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
         async with _get_client() as client:
             result = await client.create_or_update(
                 typename=cls._typename,
                 match=aliased_match,
-                data=aliased_data,
+                create_data=aliased_create_data,
+                update_data=aliased_update_data,
                 on_multiple=on_multiple,
             )
             # construct instance from aliased data
             # server-side fields like Modified Date won't be populated
-            return cls(**aliased_match, **aliased_data, **{BubbleField.ID: result["uids"][0]}), result["created"]
+            instance_data = (aliased_create_data or {}) if result["created"] else (aliased_update_data or {})
+            return cls(**aliased_match, **instance_data, **{BubbleField.ID: result["uids"][0]}), result["created"]

src/bubble_data_api_client/client/raw_client.py

@@ -147,7 +147,8 @@ async def create_or_update(
         typename: str,
         *,
         match: dict[str, typing.Any],
-        data: dict[str, typing.Any],
+        create_data: dict[str, typing.Any] | None = None,
+        update_data: dict[str, typing.Any] | None = None,
         on_multiple: OnMultiple,
     ) -> CreateOrUpdateResult:
         """Create a thing if it doesn't exist, or update if it does."""
@@ -174,9 +175,9 @@ async def create_or_update(
             msg = "match cannot be empty"
             raise ValueError(msg)
 
-        # empty data means nothing to update/set beyond match fields
-        if not data:
-            msg = "data cannot be empty"
+        # at least one of create_data or update_data must be provided
+        if not create_data and not update_data:
+            msg = "at least one of create_data or update_data must be provided"
             raise ValueError(msg)
 
         # build equals constraints from match fields to find existing thing
@@ -204,17 +205,18 @@ async def create_or_update(
 
         # no matches: create new thing
         if not results:
-            create_data = {**match, **data}
-            response = await self.create(typename=typename, data=create_data)
+            merged_create_data = {**match, **(create_data or {})}
+            response = await self.create(typename=typename, data=merged_create_data)
             response.raise_for_status()
             uid: str = response.json()["id"]
             return {"uids": [uid], "created": True}
 
-        # single match: update it
+        # single match: update it (or skip if no update_data)
         if len(results) == 1:
             uid = results[0][BubbleField.ID]
-            response = await self.update(typename=typename, uid=uid, data=data)
-            response.raise_for_status()
+            if update_data:
+                response = await self.update(typename=typename, uid=uid, data=update_data)
+                response.raise_for_status()
             return {"uids": [uid], "created": False}
 
         # multiple matches: handle according to strategy
@@ -224,34 +226,36 @@ async def create_or_update(
 
             case OnMultiple.UPDATE_FIRST:
                 uid = results[0][BubbleField.ID]
-                response = await self.update(typename=typename, uid=uid, data=data)
-                response.raise_for_status()
+                if update_data:
+                    response = await self.update(typename=typename, uid=uid, data=update_data)
+                    response.raise_for_status()
                 return {"uids": [uid], "created": False}
 
             case OnMultiple.UPDATE_ALL:
                 # bubble does not support bulk PATCH, so we update concurrently
                 uids = [result[BubbleField.ID] for result in results]
-                results_or_errors = await asyncio.gather(
-                    *[self.update(typename=typename, uid=uid, data=data) for uid in uids],
-                    return_exceptions=True,
-                )
-
-                # check for failures, letting all operations complete before raising
-                succeeded: list[str] = []
-                failed: list[tuple[str, BaseException]] = []
-                for uid, item in zip(uids, results_or_errors, strict=True):
-                    if isinstance(item, BaseException):
-                        failed.append((uid, item))
-                    else:
-                        item.raise_for_status()
-                        succeeded.append(uid)
-
-                if failed:
-                    raise PartialFailureError(
-                        operation="update",
-                        succeeded=succeeded,
-                        failed=failed,
+                if update_data:
+                    results_or_errors = await asyncio.gather(
+                        *[self.update(typename=typename, uid=uid, data=update_data) for uid in uids],
+                        return_exceptions=True,
                     )
+
+                    # check for failures, letting all operations complete before raising
+                    succeeded: list[str] = []
+                    failed: list[tuple[str, BaseException]] = []
+                    for uid, item in zip(uids, results_or_errors, strict=True):
+                        if isinstance(item, BaseException):
+                            failed.append((uid, item))
+                        else:
+                            item.raise_for_status()
+                            succeeded.append(uid)
+
+                    if failed:
+                        raise PartialFailureError(
+                            operation="update",
+                            succeeded=succeeded,
+                            failed=failed,
+                        )
                 return {"uids": uids, "created": False}
 
             case (
@@ -265,8 +269,9 @@ async def create_or_update(
                 delete_uids = [r[BubbleField.ID] for r in results[1:]]
 
                 # update first so data is preserved even if deletes fail
-                response = await self.update(typename=typename, uid=keep_uid, data=data)
-                response.raise_for_status()
+                if update_data:
+                    response = await self.update(typename=typename, uid=keep_uid, data=update_data)
+                    response.raise_for_status()
 
                 # delete duplicates concurrently, letting all complete before checking errors
                 delete_results = await asyncio.gather(

src/tests/unit/client/test_create_or_update.py

@@ -45,7 +45,7 @@ async def test_create_or_update_creates_when_no_match(configured_client: None) -
         result = await client.create_or_update(
             typename="customer",
             match={"external_id": "abc"},
-            data={"name": "John"},
+            create_data={"name": "John"},
             on_multiple=OnMultiple.ERROR,
         )
 
@@ -55,6 +55,86 @@ async def test_create_or_update_creates_when_no_match(configured_client: None) -
     assert create_route.call_count == 1
 
 
+@respx.mock
+async def test_create_or_update_with_both_create_and_update_data_creates(configured_client: None) -> None:
+    """Test that create_data is used when creating, not update_data."""
+    import json
+
+    respx.get("https://test.example.com/customer").mock(
+        return_value=httpx.Response(200, json={"response": {"results": [], "count": 0, "remaining": 0}})
+    )
+    create_route = respx.post("https://test.example.com/customer").mock(
+        return_value=httpx.Response(200, json={"status": "success", "id": "new123"})
+    )
+
+    async with RawClient() as client:
+        result = await client.create_or_update(
+            typename="customer",
+            match={"external_id": "abc"},
+            create_data={"status": "new", "created_by": "system"},
+            update_data={"status": "active", "last_seen": "2024-01-01"},
+            on_multiple=OnMultiple.ERROR,
+        )
+
+    assert result["created"] is True
+    assert result["uids"] == ["new123"]
+    # verify create was called with match + create_data (not update_data)
+    request_body = json.loads(create_route.calls[0].request.content)
+    assert request_body == {"external_id": "abc", "status": "new", "created_by": "system"}
+
+
+@respx.mock
+async def test_create_or_update_with_both_create_and_update_data_updates(configured_client: None) -> None:
+    """Test that update_data is used when updating, not create_data."""
+    import json
+
+    respx.get("https://test.example.com/customer").mock(
+        return_value=httpx.Response(
+            200, json={"response": {"results": [{"_id": "existing123"}], "count": 1, "remaining": 0}}
+        )
+    )
+    update_route = respx.patch("https://test.example.com/customer/existing123").mock(return_value=httpx.Response(204))
+
+    async with RawClient() as client:
+        result = await client.create_or_update(
+            typename="customer",
+            match={"external_id": "abc"},
+            create_data={"status": "new", "created_by": "system"},
+            update_data={"status": "active", "last_seen": "2024-01-01"},
+            on_multiple=OnMultiple.ERROR,
+        )
+
+    assert result["created"] is False
+    assert result["uids"] == ["existing123"]
+    # verify update was called with update_data (not create_data)
+    request_body = json.loads(update_route.calls[0].request.content)
+    assert request_body == {"status": "active", "last_seen": "2024-01-01"}
+
+
+@respx.mock
+async def test_create_or_update_with_only_create_data_skips_update(configured_client: None) -> None:
+    """Test that when only create_data is provided, updates are skipped."""
+    find_route = respx.get("https://test.example.com/customer").mock(
+        return_value=httpx.Response(
+            200, json={"response": {"results": [{"_id": "existing123"}], "count": 1, "remaining": 0}}
+        )
+    )
+    # no update route - should not be called
+
+    async with RawClient() as client:
+        result = await client.create_or_update(
+            typename="customer",
+            match={"external_id": "abc"},
+            create_data={"status": "new"},
+            on_multiple=OnMultiple.ERROR,
+        )
+
+    assert result["created"] is False
+    assert result["uids"] == ["existing123"]
+    assert find_route.call_count == 1
+    # no PATCH call should have been made
+
+
 @respx.mock
 async def test_create_or_update_updates_when_single_match(configured_client: None) -> None:
     """Test that create_or_update updates when exactly one match is found."""
@@ -71,7 +151,7 @@ async def test_create_or_update_updates_when_single_match(configured_client: Non
         result = await client.create_or_update(
             typename="customer",
             match={"external_id": "abc"},
-            data={"name": "John"},
+            update_data={"name": "John"},
             on_multiple=OnMultiple.ERROR,
         )
 
@@ -103,7 +183,7 @@ async def test_create_or_update_error_on_multiple_matches(configured_client: Non
             await client.create_or_update(
                 typename="customer",
                 match={"external_id": "abc"},
-                data={"name": "John"},
+                update_data={"name": "John"},
                 on_multiple=OnMultiple.ERROR,
             )
 
@@ -132,7 +212,7 @@ async def test_create_or_update_update_first(configured_client: None) -> None:
         result = await client.create_or_update(
             typename="customer",
             match={"external_id": "abc"},
-            data={"name": "John"},
+            update_data={"name": "John"},
             on_multiple=OnMultiple.UPDATE_FIRST,
         )
 
@@ -164,7 +244,7 @@ async def test_create_or_update_update_all(configured_client: None) -> None:
         result = await client.create_or_update(
             typename="customer",
             match={"external_id": "abc"},
-            data={"name": "John"},
+            update_data={"name": "John"},
             on_multiple=OnMultiple.UPDATE_ALL,
         )
 
@@ -199,7 +279,7 @@ async def test_create_or_update_dedupe_oldest_created(configured_client: None) -
         result = await client.create_or_update(
             typename="customer",
             match={"external_id": "abc"},
-            data={"name": "John"},
+            update_data={"name": "John"},
             on_multiple=OnMultiple.DEDUPE_OLDEST_CREATED,
         )
 
@@ -234,7 +314,7 @@ async def test_create_or_update_dedupe_newest_created(configured_client: None) -
         result = await client.create_or_update(
             typename="customer",
             match={"external_id": "abc"},
-            data={"name": "John"},
+            update_data={"name": "John"},
             on_multiple=OnMultiple.DEDUPE_NEWEST_CREATED,
         )
 
@@ -269,7 +349,7 @@ async def test_create_or_update_dedupe_oldest_modified(configured_client: None)
         result = await client.create_or_update(
             typename="customer",
             match={"external_id": "abc"},
-            data={"name": "John"},
+            update_data={"name": "John"},
             on_multiple=OnMultiple.DEDUPE_OLDEST_MODIFIED,
         )
 
@@ -304,7 +384,7 @@ async def test_create_or_update_dedupe_newest_modified(configured_client: None)
         result = await client.create_or_update(
             typename="customer",
             match={"external_id": "abc"},
-            data={"name": "John"},
+            update_data={"name": "John"},
             on_multiple=OnMultiple.DEDUPE_NEWEST_MODIFIED,
         )
 
@@ -322,7 +402,7 @@ async def test_create_or_update_invalid_on_multiple(configured_client: None) ->
             await client.create_or_update(
                 typename="customer",
                 match={"external_id": "abc"},
-                data={"name": "John"},
+                update_data={"name": "John"},
                 on_multiple="invalid",  # type: ignore[arg-type]
             )
 
@@ -334,19 +414,18 @@ async def test_create_or_update_empty_match_raises(configured_client: None) -> N
             await client.create_or_update(
                 typename="customer",
                 match={},
-                data={"name": "John"},
+                update_data={"name": "John"},
                 on_multiple=OnMultiple.ERROR,
             )
 
 
-async def test_create_or_update_empty_data_raises(configured_client: None) -> None:
-    """Test that empty data dict raises ValueError."""
+async def test_create_or_update_no_data_raises(configured_client: None) -> None:
+    """Test that no data provided raises ValueError."""
     async with RawClient() as client:
-        with pytest.raises(ValueError, match="data cannot be empty"):
+        with pytest.raises(ValueError, match="at least one of create_data or update_data must be provided"):
             await client.create_or_update(
                 typename="customer",
                 match={"external_id": "abc"},
-                data={},
                 on_multiple=OnMultiple.ERROR,
             )
 
@@ -378,7 +457,7 @@ async def test_create_or_update_update_all_partial_failure(configured_client: No
             await client.create_or_update(
                 typename="customer",
                 match={"external_id": "abc"},
-                data={"name": "John"},
+                update_data={"name": "John"},
                 on_multiple=OnMultiple.UPDATE_ALL,
             )
 
@@ -417,7 +496,7 @@ async def test_create_or_update_dedupe_partial_delete_failure(configured_client:
             await client.create_or_update(
                 typename="customer",
                 match={"external_id": "abc"},
-                data={"name": "John"},
+                update_data={"name": "John"},
                 on_multiple=OnMultiple.DEDUPE_OLDEST_CREATED,
             )
 

src/tests/unit/client/test_orm.py

@@ -136,7 +136,7 @@ class Order(BubbleModel, typename="order"):
 
     _order, created = await Order.create_or_update(
         match={"external_id": "ext-001"},
-        data={"company": "Acme Corp"},
+        create_data={"company": "Acme Corp"},
         on_multiple=OnMultiple.ERROR,
     )
 
@@ -171,7 +171,7 @@ class Order(BubbleModel, typename="order"):
 
     _order, created = await Order.create_or_update(
         match={"external_id": "ext-001"},
-        data={"company": "Updated Corp"},
+        update_data={"company": "Updated Corp"},
         on_multiple=OnMultiple.ERROR,
     )
 
@@ -191,7 +191,7 @@ class User(BubbleModel, typename="user"):
     with pytest.raises(UnknownFieldError, match="unknown field: nonexistent"):
         await User.create_or_update(
             match={"nonexistent": "value"},
-            data={"name": "test"},
+            update_data={"name": "test"},
             on_multiple=OnMultiple.ERROR,
         )
 
@@ -206,6 +206,6 @@ class User(BubbleModel, typename="user"):
     with pytest.raises(UnknownFieldError, match="unknown field: nonexistent"):
         await User.create_or_update(
             match={"name": "test"},
-            data={"nonexistent": "value"},
+            update_data={"nonexistent": "value"},
             on_multiple=OnMultiple.ERROR,
         )