Wrap full graph insert with a transaction

Author: fabien.menager

src/PhenX.EntityFrameworkCore.BulkInsert/Graph/GraphBulkInsertOrchestrator.cs

@@ -5,6 +5,7 @@
 using Microsoft.Extensions.Logging;
 
 using PhenX.EntityFrameworkCore.BulkInsert.Abstractions;
+using PhenX.EntityFrameworkCore.BulkInsert.Extensions;
 using PhenX.EntityFrameworkCore.BulkInsert.Metadata;
 using PhenX.EntityFrameworkCore.BulkInsert.Options;
 
@@ -37,6 +38,10 @@ public async Task<GraphInsertResult<T>> InsertGraph<T>(
         IBulkInsertProvider provider,
         CancellationToken ctk) where T : class
     {
+
+        using var activity = Telemetry.ActivitySource.StartActivity("InsertGraph");
+        activity?.AddTag("synchronous", sync);
+
         // 1. Collect and sort entities
         var collector = new GraphEntityCollector(_context, options);
         var collectionResult = collector.Collect(entities);
@@ -68,42 +73,54 @@ public async Task<GraphInsertResult<T>> InsertGraph<T>(
                 $"Consider using client-generated keys (e.g., GUIDs with ValueGeneratedNever()).");
         }
 
-        // 2. Insert in dependency order (parents first)
-        foreach (var entityType in collectionResult.InsertionOrder)
+        var connection = await _context.GetConnection(sync, ctk);
+
+        try
         {
-            if (!collectionResult.EntitiesByType.TryGetValue(entityType, out var entitiesToInsert) ||
-                entitiesToInsert.Count == 0)
+            // 2. Insert in dependency order (parents first)
+            foreach (var entityType in collectionResult.InsertionOrder)
             {
-                continue;
-            }
+                if (!collectionResult.EntitiesByType.TryGetValue(entityType, out var entitiesToInsert) ||
+                    entitiesToInsert.Count == 0)
+                {
+                    continue;
+                }
 
-            // Propagate FK values from already-inserted parents
-            PropagateParentForeignKeys(entitiesToInsert, entityType, graphMetadata);
+                // Propagate FK values from already-inserted parents
+                PropagateParentForeignKeys(entitiesToInsert, entityType, graphMetadata);
 
-            // Insert entities of this type
-            await InsertEntitiesOfType(sync, _context, entityType, entitiesToInsert, options, provider, graphMetadata, ctk);
+                // Insert entities of this type
+                await InsertEntitiesOfType(sync, _context, entityType, entitiesToInsert, options, provider,
+                    graphMetadata, ctk);
 
-            totalInserted += entitiesToInsert.Count;
-        }
+                totalInserted += entitiesToInsert.Count;
+            }
 
-        // 3. Insert join table records for many-to-many relationships
-        var joinRecordsInserted = 0;
-        if (collectionResult.JoinRecords.Count > 0)
-        {
-            joinRecordsInserted = await InsertJoinRecords(sync, _context, collectionResult.JoinRecords, options, provider, graphMetadata, ctk);
-            totalInserted += joinRecordsInserted;
-        }
+            // 3. Insert join table records for many-to-many relationships
+            if (collectionResult.JoinRecords.Count > 0)
+            {
+                totalInserted += await InsertJoinRecords(sync, _context, collectionResult.JoinRecords, options,
+                    provider, graphMetadata, ctk);
+            }
+
+            // Return root entities
+            var rootEntities = collectionResult.EntitiesByType.TryGetValue(typeof(T), out var roots)
+                ? roots.Cast<T>().ToList()
+                : [];
 
-        // Return root entities
-        var rootEntities = collectionResult.EntitiesByType.TryGetValue(typeof(T), out var roots)
-            ? roots.Cast<T>().ToList()
-            : [];
+            // Commit the transaction if we own them.
+            await connection.Commit(sync, ctk);
 
-        return new GraphInsertResult<T>
+            return new GraphInsertResult<T>
+            {
+                RootEntities = rootEntities,
+                TotalInsertedCount = totalInserted,
+            };
+        }
+        finally
         {
-            RootEntities = rootEntities,
-            TotalInsertedCount = totalInserted,
-        };
+            await connection.Close(sync, ctk);
+        }
     }
 
     private static void PropagateParentForeignKeys(

tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Graph/GraphTestsBase.cs

@@ -714,4 +714,59 @@ await _context.ExecuteBulkInsertAsync(blogs, options =>
             $"Inserted {totalEntities:N0} entities in {stopwatch.Elapsed.TotalSeconds:F2}s " +
             $"({entitiesPerSecond:F0} entities/sec) using {_context.GetType().Name}");
     }
+
+    [SkippableFact]
+    public async Task InsertGraph_FailureMidRun_TransactionRolledBack()
+    {
+        // Arrange - Create a graph where the second blog has an invalid post (null Title)
+        // This should cause the entire transaction to be rolled back
+        var validBlog = new Blog
+        {
+            TestRun = _run,
+            Name = $"{_run}_ValidBlog",
+            Posts = new List<Post>
+            {
+                new Post { TestRun = _run, Title = $"{_run}_ValidPost" }
+            },
+            Settings = new BlogSettings
+            {
+                TestRun = _run,
+                EnableComments = true
+            }
+        };
+
+        var invalidBlog = new Blog
+        {
+            TestRun = _run,
+            Name = $"{_run}_InvalidBlog",
+            Posts = new List<Post>
+            {
+                new Post { TestRun = _run, Title = null! } // This should violate NOT NULL constraint
+            }
+        };
+
+        var blogs = new[] { validBlog, invalidBlog };
+
+        // Act & Assert - Expect an exception during insert
+        var act = async () => await _context.ExecuteBulkInsertAsync(blogs, options =>
+        {
+            options.IncludeGraph = true;
+        });
+
+        await act.Should().ThrowAsync<Exception>("Insert should fail due to NULL constraint violation");
+
+        // Assert - Verify that NOTHING was inserted due to transaction rollback
+        var insertedBlogs = _context.Blogs.Where(b => b.TestRun == _run).ToList();
+        insertedBlogs.Should().BeEmpty("Transaction should be rolled back - no blogs inserted");
+
+        var insertedPosts = _context.Posts.Where(p => p.TestRun == _run).ToList();
+        insertedPosts.Should().BeEmpty("Transaction should be rolled back - no posts inserted");
+
+        var insertedSettings = _context.BlogSettings.Where(s => s.TestRun == _run).ToList();
+        insertedSettings.Should().BeEmpty("Transaction should be rolled back - no settings inserted");
+
+        // Verify original entities do NOT have IDs populated (rollback means no database-generated values)
+        validBlog.Id.Should().Be(0, "Valid blog should not have ID after rollback");
+        invalidBlog.Id.Should().Be(0, "Invalid blog should not have ID after rollback");
+    }
 }