Rename BatchResult.created_ids to entity_ids

The OData-EntityId header is returned by both POST (create) and PATCH
(update) operations, not just creates. The name created_ids was misleading.

entity_ids accurately reflects that it collects GUIDs from the standard
OData-EntityId response header across all successful operations that
return it (creates and updates). GET and DELETE operations do not return
this header.

For CreateMultiple/UpsertMultiple bulk action responses, callers access
IDs via response.data['Ids'] as documented in the property's docstring.

Updated all references across src, tests, examples, README, and SKILL
files.

Author: Saurabh Badenkal

.claude/skills/dataverse-sdk-use/SKILL.md

@@ -407,7 +407,7 @@ print(f"Succeeded: {len(result.succeeded)}, Failed: {len(result.failed)}")
 - `result.succeeded` -- responses with 2xx status codes
 - `result.failed` -- responses with non-2xx status codes
 - `result.has_errors` -- True if any response failed
-- `result.created_ids` -- GUIDs from successful create operations
+- `result.entity_ids` -- GUIDs from successful create operations
 
 **Batch limitations:**
 - Maximum 1000 operations per batch

README.md

@@ -461,7 +461,7 @@ with batch.changeset() as cs:
         "primarycontactid@odata.bind": contact_ref,
     })
 result = batch.execute()
-print(f"Created {len(result.created_ids)} records atomically")
+print(f"Created {len(result.entity_ids)} records atomically")
 ```
 
 **Table metadata and SQL queries in a batch:**

examples/advanced/batch.py

@@ -51,7 +51,7 @@
 result = batch.execute()
 
 print(f"[OK] Total: {len(result.responses)}, Succeeded: {len(result.succeeded)}, Failed: {len(result.failed)}")
-for guid in result.created_ids:
+for guid in result.entity_ids:
     print(f"[OK] Created: {guid}")
 for item in result.failed:
     print(f"[ERR] {item.status_code}: {item.error_message}")
@@ -93,7 +93,7 @@
     for item in result.failed:
         print(f"  {item.status_code}: {item.error_message}")
 else:
-    print(f"[OK] {len(result.created_ids)} records created atomically")
+    print(f"[OK] {len(result.entity_ids)} records created atomically")
 
 
 # ---------------------------------------------------------------------------
@@ -194,7 +194,7 @@
 batch.dataframe.create("account", df)
 result = batch.execute()
 print(f"[OK] DataFrame create: {len(result.succeeded)} succeeded")
-created_ids = list(result.created_ids)
+created_ids = list(result.entity_ids)
 
 # Update records from a DataFrame
 if len(created_ids) >= 2:

examples/advanced/walkthrough.py

@@ -357,7 +357,7 @@ def _run_walkthrough(client):
         },
     )
     result = batch.execute()
-    batch_ids = list(result.created_ids)
+    batch_ids = list(result.entity_ids)
     print(
         f"[OK] Batch create: {len(result.succeeded)} operations in one HTTP request, {len(batch_ids)} records created"
     )
@@ -390,7 +390,7 @@ def _run_walkthrough(client):
         cs.records.update(table_name, cs_ref, {"new_Completed": True})
     result = batch.execute()
     if not result.has_errors:
-        batch_ids.extend(result.created_ids)
+        batch_ids.extend(result.entity_ids)
         print(f"[OK] Changeset: {len(result.succeeded)} operations committed atomically")
     else:
         for item in result.failed:

examples/basic/functional_testing.py

@@ -497,7 +497,7 @@ def test_batch_all_operations(client: DataverseClient, table_info: Dict[str, Any
             ],
         )
         result = batch.execute()
-        all_ids = list(result.created_ids)
+        all_ids = list(result.entity_ids)
         if result.has_errors:
             for item in result.failed:
                 print(f"[WARN] {item.status_code}: {item.error_message}")
@@ -572,7 +572,7 @@ def test_batch_all_operations(client: DataverseClient, table_info: Dict[str, Any
                 for item in result.failed:
                     print(f"[WARN] Changeset error {item.status_code}: {item.error_message}")
             else:
-                new_id = next(iter(result.created_ids), None)
+                new_id = next(iter(result.entity_ids), None)
                 if new_id:
                     all_ids[-1] = new_id  # replace deleted id with the new one
                 print(f"[OK] {len(result.succeeded)} ops committed atomically (create + update + delete)")
@@ -598,15 +598,15 @@ def test_batch_all_operations(client: DataverseClient, table_info: Dict[str, Any
         # 404 to the outer batch HTTP status (which some environments do).
         result = batch.execute(continue_on_error=True)
         if result.has_errors:
-            leaked = list(result.created_ids)
+            leaked = list(result.entity_ids)
             if not leaked:
                 print("[OK] Changeset rollback verified: changeset failed, no records created")
             else:
                 print(f"[WARN] Changeset failed but {len(leaked)} IDs leaked — queuing for cleanup")
                 all_ids.extend(leaked)
         else:
             print("[WARN] Expected rollback but changeset succeeded (unexpected)")
-            all_ids.extend(result.created_ids)
+            all_ids.extend(result.entity_ids)
 
         # -------------------------------------------------------------------
         # [6/11] TWO CHANGESETS — Content-IDs are unique across the entire batch
@@ -639,7 +639,7 @@ def test_batch_all_operations(client: DataverseClient, table_info: Dict[str, Any
             for item in result.failed:
                 print(f"[WARN] Two-changeset error {item.status_code}: {item.error_message}")
         else:
-            cs_ids = list(result.created_ids)
+            cs_ids = list(result.entity_ids)
             all_ids.extend(cs_ids)
             print(
                 f"[OK] Both changesets committed — {len(cs_ids)} records created "
@@ -678,7 +678,7 @@ def test_batch_all_operations(client: DataverseClient, table_info: Dict[str, Any
             for item in result.failed:
                 print(f"[WARN] Chaining error {item.status_code}: {item.error_message}")
         else:
-            chain_ids = list(result.created_ids)
+            chain_ids = list(result.entity_ids)
             all_ids.extend(chain_ids)
             print(f"[OK] Both records created and updated via content-ID refs " f"{ref_a} and {ref_b}: {chain_ids}")
 
@@ -727,7 +727,7 @@ def test_batch_all_operations(client: DataverseClient, table_info: Dict[str, Any
             if result.has_errors:
                 print(f"[WARN] Upsert failed as expected (no alternate key configured): {result.failed[0].status_code}")
             else:
-                upsert_ids = list(result.created_ids)
+                upsert_ids = list(result.entity_ids)
                 all_ids.extend(upsert_ids)
                 print(f"[OK] Upsert succeeded: {len(upsert_ids)} record(s) — alternate key was accepted")
         except Exception as e:

src/PowerPlatform/Dataverse/claude_skill/dataverse-sdk-use/SKILL.md

@@ -407,7 +407,7 @@ print(f"Succeeded: {len(result.succeeded)}, Failed: {len(result.failed)}")
 - `result.succeeded` -- responses with 2xx status codes
 - `result.failed` -- responses with non-2xx status codes
 - `result.has_errors` -- True if any response failed
-- `result.created_ids` -- GUIDs from successful create operations
+- `result.entity_ids` -- GUIDs from successful create operations
 
 **Batch limitations:**
 - Maximum 1000 operations per batch

src/PowerPlatform/Dataverse/models/batch.py

@@ -64,8 +64,8 @@ class BatchResult:
 
         result = client.batch.new().execute()
         print(f"Succeeded: {len(result.succeeded)}, Failed: {len(result.failed)}")
-        for guid in result.created_ids:
-            print(f"[OK] Created: {guid}")
+        for guid in result.entity_ids:
+            print(f"[OK] entity_id: {guid}")
     """
 
     responses: List[BatchItemResponse] = field(default_factory=list)
@@ -86,12 +86,13 @@ def has_errors(self) -> bool:
         return any(not r.is_success for r in self.responses)
 
     @property
-    def created_ids(self) -> List[str]:
+    def entity_ids(self) -> List[str]:
         """GUIDs extracted from ``OData-EntityId`` headers of successful responses.
 
         Returns entity IDs from any successful (2xx) response that includes an
-        ``OData-EntityId`` header.  Individual ``POST`` creates return this
-        header with the new record's GUID.
+        ``OData-EntityId`` header.  Both individual ``POST`` (create) and
+        ``PATCH`` (update) operations return this header with the record's GUID.
+        ``GET`` and ``DELETE`` operations do not.
 
         .. note::
             ``CreateMultiple`` and ``UpsertMultiple`` action responses do **not**

tests/unit/data/test_batch_edge_cases.py

@@ -182,7 +182,7 @@ def test_successful_changeset_returns_all_items(self):
 
         self.assertFalse(result.has_errors)
         self.assertEqual(len(result.succeeded), 3)
-        self.assertEqual(len(result.created_ids), 3)
+        self.assertEqual(len(result.entity_ids), 3)
         # Verify content-IDs were extracted
         content_ids = [r.content_id for r in result.responses]
         self.assertEqual(content_ids, ["1", "2", "3"])
@@ -518,7 +518,7 @@ def test_mixed_success_and_failure(self):
         self.assertEqual(len(result.succeeded), 2)
         self.assertEqual(len(result.failed), 1)
         self.assertEqual(result.failed[0].error_code, "0x80040237")
-        self.assertEqual(len(result.created_ids), 2)
+        self.assertEqual(len(result.entity_ids), 2)
 
 
 # ---------------------------------------------------------------------------
@@ -603,24 +603,24 @@ def test_absolute_urls_in_batch_parts(self):
 class TestBatchResultProperties(unittest.TestCase):
     """Verify computed properties of BatchResult."""
 
-    def test_created_ids_only_from_201_and_204(self):
-        """created_ids should include entity_ids from all 2xx (including 201 and 204)."""
+    def test_entity_ids_only_from_201_and_204(self):
+        """entity_ids should include entity_ids from all 2xx (including 201 and 204)."""
         responses = [
             BatchItemResponse(status_code=201, entity_id="id-201"),
             BatchItemResponse(status_code=204, entity_id="id-204"),
             BatchItemResponse(status_code=200, entity_id=None),  # GET success, no entity_id
             BatchItemResponse(status_code=400, entity_id=None),
         ]
         result = BatchResult(responses=responses)
-        self.assertEqual(result.created_ids, ["id-201", "id-204"])
+        self.assertEqual(result.entity_ids, ["id-201", "id-204"])
 
     def test_empty_batch_result_properties(self):
         """Empty BatchResult has correct defaults."""
         result = BatchResult()
         self.assertEqual(result.succeeded, [])
         self.assertEqual(result.failed, [])
         self.assertFalse(result.has_errors)
-        self.assertEqual(result.created_ids, [])
+        self.assertEqual(result.entity_ids, [])
 
     def test_all_success_no_errors(self):
         """All 2xx responses means has_errors is False."""
@@ -643,10 +643,10 @@ def test_single_failure_makes_has_errors_true(self):
         self.assertTrue(result.has_errors)
         self.assertEqual(len(result.failed), 1)
 
-    def test_created_ids_from_create_multiple_not_in_created_ids(self):
-        """CreateMultiple IDs are in data['Ids'], NOT in created_ids property.
+    def test_entity_ids_from_create_multiple_not_in_created_ids(self):
+        """CreateMultiple IDs are in data['Ids'], NOT in entity_ids property.
 
-        created_ids only returns entity_id from OData-EntityId headers.
+        entity_ids only returns entity_id from OData-EntityId headers.
         Callers access CreateMultiple IDs via response.data['Ids'] directly.
         """
         responses = [
@@ -658,17 +658,17 @@ def test_created_ids_from_create_multiple_not_in_created_ids(self):
             ),
         ]
         result = BatchResult(responses=responses)
-        # created_ids does NOT include bulk IDs (no OData-EntityId header)
-        self.assertEqual(result.created_ids, [])
+        # entity_ids does NOT include bulk IDs (no OData-EntityId header)
+        self.assertEqual(result.entity_ids, [])
         # Callers access them from the response data
         self.assertEqual(result.succeeded[0].data["Ids"], ["guid-1", "guid-2", "guid-3"])
 
-    def test_created_ids_only_from_odata_entity_id_header(self):
-        """created_ids only collects entity_id from OData-EntityId headers."""
+    def test_entity_ids_only_from_odata_entity_id_header(self):
+        """entity_ids only collects entity_id from OData-EntityId headers."""
         responses = [
             # Single create: entity_id from header
             BatchItemResponse(status_code=204, entity_id="single-id"),
-            # CreateMultiple: Ids from body (not in created_ids)
+            # CreateMultiple: Ids from body (not in entity_ids)
             BatchItemResponse(
                 status_code=200,
                 entity_id=None,
@@ -677,7 +677,7 @@ def test_created_ids_only_from_odata_entity_id_header(self):
         ]
         result = BatchResult(responses=responses)
         # Only the header-based entity_id
-        self.assertEqual(result.created_ids, ["single-id"])
+        self.assertEqual(result.entity_ids, ["single-id"])
         # Bulk IDs accessed via response.data
         self.assertEqual(result.responses[1].data["Ids"], ["bulk-id-1", "bulk-id-2"])
 
@@ -693,7 +693,7 @@ def test_bulk_ids_accessible_via_response_data(self):
         ]
         result = BatchResult(responses=responses)
         # Collect all IDs from both sources (what a caller would do)
-        all_ids = list(result.created_ids)
+        all_ids = list(result.entity_ids)
         for resp in result.succeeded:
             if resp.data and isinstance(resp.data.get("Ids"), list):
                 all_ids.extend(resp.data["Ids"])
@@ -740,7 +740,7 @@ def test_create_multiple_response_parsed(self):
         # But data should contain the Ids array
         self.assertEqual(result.succeeded[0].data["Ids"], ["aaa-111", "bbb-222", "ccc-333"])
         # created_ids won't have these (no OData-EntityId header)
-        self.assertEqual(result.created_ids, [])
+        self.assertEqual(result.entity_ids, [])
         # Callers access bulk IDs via response.data["Ids"]
         bulk_ids = result.succeeded[0].data["Ids"]
         self.assertEqual(len(bulk_ids), 3)
@@ -784,8 +784,8 @@ def test_mixed_single_and_bulk_creates(self):
 
         self.assertFalse(result.has_errors)
         self.assertEqual(len(result.succeeded), 2)
-        # created_ids only has the individual create's entity_id
-        self.assertEqual(result.created_ids, [single_guid])
+        # entity_ids only has the individual create's entity_id
+        self.assertEqual(result.entity_ids, [single_guid])
         # CreateMultiple IDs are in the second response's data
         self.assertEqual(result.responses[1].data["Ids"], ["bulk-1", "bulk-2"])
 

tests/unit/test_batch_operations.py

@@ -439,7 +439,7 @@ def test_has_errors_false(self):
         )
         self.assertFalse(result.has_errors)
 
-    def test_created_ids(self):
+    def test_entity_ids(self):
         result = BatchResult(
             responses=[
                 BatchItemResponse(status_code=201, entity_id="guid-1"),
@@ -448,15 +448,15 @@ def test_created_ids(self):
                 BatchItemResponse(status_code=400),
             ]
         )
-        self.assertEqual(result.created_ids, ["guid-1", "guid-2"])
+        self.assertEqual(result.entity_ids, ["guid-1", "guid-2"])
 
     def test_empty_result(self):
         result = BatchResult()
         self.assertEqual(result.responses, [])
         self.assertEqual(result.succeeded, [])
         self.assertEqual(result.failed, [])
         self.assertFalse(result.has_errors)
-        self.assertEqual(result.created_ids, [])
+        self.assertEqual(result.entity_ids, [])
 
 
 if __name__ == "__main__":