add modified date support to dedupe strategies for finer control over which duplicate to keep

Author: purificant

src/bubble_data_api_client/client/raw_client.py

@@ -161,8 +161,10 @@ async def create_or_update(
         # - ERROR: raise MultipleMatchesError
         # - UPDATE_FIRST: update the first match (arbitrary order)
         # - UPDATE_ALL: update all matches (N API calls, no bulk update in Bubble)
-        # - DEDUPE_OLDEST: delete all but oldest, update oldest (N API calls)
-        # - DEDUPE_NEWEST: delete all but newest, update newest (N API calls)
+        # - DEDUPE_OLDEST_CREATED: delete all but oldest by created date (N API calls)
+        # - DEDUPE_NEWEST_CREATED: delete all but newest by created date (N API calls)
+        # - DEDUPE_OLDEST_MODIFIED: delete all but oldest by modified date (N API calls)
+        # - DEDUPE_NEWEST_MODIFIED: delete all but newest by modified date (N API calls)
 
         if on_multiple not in OnMultiple:
             raise InvalidOnMultipleError(on_multiple)
@@ -182,12 +184,15 @@ async def create_or_update(
             constraint(key=key, constraint_type=ConstraintType.EQUALS, value=value) for key, value in match.items()
         ]
 
-        # for dedupe strategies, sort by created date to determine oldest/newest
+        # for dedupe strategies, sort by date to determine oldest/newest
         sort_field: str | None = None
         descending: bool | None = None
-        if on_multiple in (OnMultiple.DEDUPE_OLDEST, OnMultiple.DEDUPE_NEWEST):
+        if on_multiple in (OnMultiple.DEDUPE_OLDEST_CREATED, OnMultiple.DEDUPE_NEWEST_CREATED):
             sort_field = BubbleField.CREATED_DATE
-            descending = on_multiple == OnMultiple.DEDUPE_NEWEST
+            descending = on_multiple == OnMultiple.DEDUPE_NEWEST_CREATED
+        elif on_multiple in (OnMultiple.DEDUPE_OLDEST_MODIFIED, OnMultiple.DEDUPE_NEWEST_MODIFIED):
+            sort_field = BubbleField.MODIFIED_DATE
+            descending = on_multiple == OnMultiple.DEDUPE_NEWEST_MODIFIED
 
         response = await self.find(
             typename=typename,
@@ -249,7 +254,12 @@ async def create_or_update(
                     )
                 return {"uids": uids, "created": False}
 
-            case OnMultiple.DEDUPE_OLDEST | OnMultiple.DEDUPE_NEWEST:
+            case (
+                OnMultiple.DEDUPE_OLDEST_CREATED
+                | OnMultiple.DEDUPE_NEWEST_CREATED
+                | OnMultiple.DEDUPE_OLDEST_MODIFIED
+                | OnMultiple.DEDUPE_NEWEST_MODIFIED
+            ):
                 # first result is the one to keep (already sorted)
                 keep_uid = results[0][BubbleField.ID]
                 delete_uids = [r[BubbleField.ID] for r in results[1:]]

src/bubble_data_api_client/types.py

@@ -24,8 +24,10 @@ class OnMultiple(StrEnum):
     ERROR = "error"
     UPDATE_ALL = "update_all"
     UPDATE_FIRST = "update_first"
-    DEDUPE_OLDEST = "dedupe_oldest"
-    DEDUPE_NEWEST = "dedupe_newest"
+    DEDUPE_OLDEST_CREATED = "dedupe_oldest_created"
+    DEDUPE_NEWEST_CREATED = "dedupe_newest_created"
+    DEDUPE_OLDEST_MODIFIED = "dedupe_oldest_modified"
+    DEDUPE_NEWEST_MODIFIED = "dedupe_newest_modified"
 
 
 class CreateOrUpdateResult(TypedDict):

src/tests/unit/client/test_create_or_update.py

@@ -176,8 +176,8 @@ async def test_create_or_update_update_all(configured_client: None) -> None:
 
 
 @respx.mock
-async def test_create_or_update_dedupe_oldest(configured_client: None) -> None:
-    """Test that DEDUPE_OLDEST keeps oldest and deletes others."""
+async def test_create_or_update_dedupe_oldest_created(configured_client: None) -> None:
+    """Test that DEDUPE_OLDEST_CREATED keeps oldest by created date and deletes others."""
     # find returns results sorted by Created Date ascending (oldest first)
     respx.get("https://test.example.com/customer").mock(
         return_value=httpx.Response(
@@ -200,7 +200,7 @@ async def test_create_or_update_dedupe_oldest(configured_client: None) -> None:
             typename="customer",
             match={"external_id": "abc"},
             data={"name": "John"},
-            on_multiple=OnMultiple.DEDUPE_OLDEST,
+            on_multiple=OnMultiple.DEDUPE_OLDEST_CREATED,
         )
 
     assert result["created"] is False
@@ -211,8 +211,8 @@ async def test_create_or_update_dedupe_oldest(configured_client: None) -> None:
 
 
 @respx.mock
-async def test_create_or_update_dedupe_newest(configured_client: None) -> None:
-    """Test that DEDUPE_NEWEST keeps newest and deletes others."""
+async def test_create_or_update_dedupe_newest_created(configured_client: None) -> None:
+    """Test that DEDUPE_NEWEST_CREATED keeps newest by created date and deletes others."""
     # find returns results sorted by Created Date descending (newest first)
     respx.get("https://test.example.com/customer").mock(
         return_value=httpx.Response(
@@ -235,7 +235,7 @@ async def test_create_or_update_dedupe_newest(configured_client: None) -> None:
             typename="customer",
             match={"external_id": "abc"},
             data={"name": "John"},
-            on_multiple=OnMultiple.DEDUPE_NEWEST,
+            on_multiple=OnMultiple.DEDUPE_NEWEST_CREATED,
         )
 
     assert result["created"] is False
@@ -245,6 +245,76 @@ async def test_create_or_update_dedupe_newest(configured_client: None) -> None:
     assert update_newest.call_count == 1
 
 
+@respx.mock
+async def test_create_or_update_dedupe_oldest_modified(configured_client: None) -> None:
+    """Test that DEDUPE_OLDEST_MODIFIED keeps oldest by modified date and deletes others."""
+    # find returns results sorted by Modified Date ascending (least recently modified first)
+    respx.get("https://test.example.com/customer").mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "response": {
+                    "results": [{"_id": "oldest_mod"}, {"_id": "newer_mod"}, {"_id": "newest_mod"}],
+                    "count": 3,
+                    "remaining": 0,
+                }
+            },
+        )
+    )
+    delete_newer = respx.delete("https://test.example.com/customer/newer_mod").mock(return_value=httpx.Response(204))
+    delete_newest = respx.delete("https://test.example.com/customer/newest_mod").mock(return_value=httpx.Response(204))
+    update_oldest = respx.patch("https://test.example.com/customer/oldest_mod").mock(return_value=httpx.Response(204))
+
+    async with RawClient() as client:
+        result = await client.create_or_update(
+            typename="customer",
+            match={"external_id": "abc"},
+            data={"name": "John"},
+            on_multiple=OnMultiple.DEDUPE_OLDEST_MODIFIED,
+        )
+
+    assert result["created"] is False
+    assert result["uids"] == ["oldest_mod"]
+    assert delete_newer.call_count == 1
+    assert delete_newest.call_count == 1
+    assert update_oldest.call_count == 1
+
+
+@respx.mock
+async def test_create_or_update_dedupe_newest_modified(configured_client: None) -> None:
+    """Test that DEDUPE_NEWEST_MODIFIED keeps newest by modified date and deletes others."""
+    # find returns results sorted by Modified Date descending (most recently modified first)
+    respx.get("https://test.example.com/customer").mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "response": {
+                    "results": [{"_id": "newest_mod"}, {"_id": "newer_mod"}, {"_id": "oldest_mod"}],
+                    "count": 3,
+                    "remaining": 0,
+                }
+            },
+        )
+    )
+    delete_newer = respx.delete("https://test.example.com/customer/newer_mod").mock(return_value=httpx.Response(204))
+    delete_oldest = respx.delete("https://test.example.com/customer/oldest_mod").mock(return_value=httpx.Response(204))
+    update_newest = respx.patch("https://test.example.com/customer/newest_mod").mock(return_value=httpx.Response(204))
+
+    async with RawClient() as client:
+        result = await client.create_or_update(
+            typename="customer",
+            match={"external_id": "abc"},
+            data={"name": "John"},
+            on_multiple=OnMultiple.DEDUPE_NEWEST_MODIFIED,
+        )
+
+    assert result["created"] is False
+    assert result["uids"] == ["newest_mod"]
+    assert delete_newer.call_count == 1
+    assert delete_oldest.call_count == 1
+    assert update_newest.call_count == 1
+
+
 async def test_create_or_update_invalid_on_multiple(configured_client: None) -> None:
     """Test that invalid on_multiple raises InvalidOnMultipleError."""
     async with RawClient() as client:
@@ -348,7 +418,7 @@ async def test_create_or_update_dedupe_partial_delete_failure(configured_client:
                 typename="customer",
                 match={"external_id": "abc"},
                 data={"name": "John"},
-                on_multiple=OnMultiple.DEDUPE_OLDEST,
+                on_multiple=OnMultiple.DEDUPE_OLDEST_CREATED,
             )
 
     error = exc_info.value