feat: Update database seeding implementation to use EF Core 9 `UseAsy…

…ncSeeding` method

- Introduced `AddAsyncSeeding` extension method to integrate the new `UseAsyncSeeding` approach introduced in EF Core 9.
- Refactored `ApplicationDbContextInitialiser` seeding logic to align with the new asynchronous seeding mechanism.
- Updated `AddDbContext` configuration in `AddInfrastructureServices` to use the `AddAsyncSeeding` method for all database providers (`PostgreSQL`, `SQLite`, `SQL Server`).
- Separated database initialization (`InitialiseAsync`) and seeding (`SeedAsync`) into distinct operations for better alignment with the new seeding approach.
- Maintained compatibility with dependency injection for interceptors and service provider usage.

This change modernizes the database seeding process to leverage the improved EF Core 9 capabilities, ensuring better integration with async workflows.

src/Infrastructure/Data/ApplicationDbContextInitialiser.cs

@@ -11,15 +11,23 @@ namespace CleanArchitecture.Infrastructure.Data;
 
 public static class InitialiserExtensions
 {
+    public static void AddAsyncSeeding(this DbContextOptionsBuilder builder, IServiceProvider serviceProvider)
+    {
+        builder.UseAsyncSeeding(async (context, _, ct) =>
+        {
+            var initialiser = serviceProvider.GetRequiredService<ApplicationDbContextInitialiser>();
+
+            await initialiser.SeedAsync();
+        });
+    }
+
     public static async Task InitialiseDatabaseAsync(this WebApplication app)
     {
         using var scope = app.Services.CreateScope();
 
         var initialiser = scope.ServiceProvider.GetRequiredService<ApplicationDbContextInitialiser>();
 
         await initialiser.InitialiseAsync();
-
-        await initialiser.SeedAsync();
     }
 }
 

src/Infrastructure/DependencyInjection.cs

@@ -1,5 +1,7 @@
-using CleanArchitecture.Application.Common.Interfaces;
+using System;
+using CleanArchitecture.Application.Common.Interfaces;
 using CleanArchitecture.Domain.Constants;
+using CleanArchitecture.Domain.Entities;
 using CleanArchitecture.Infrastructure.Data;
 using CleanArchitecture.Infrastructure.Data.Interceptors;
 using CleanArchitecture.Infrastructure.Identity;
@@ -25,22 +27,22 @@ public static void AddInfrastructureServices(this IHostApplicationBuilder builde
         {
             options.AddInterceptors(sp.GetServices<ISaveChangesInterceptor>());
 #if (UsePostgreSQL)
-            options.UseNpgsql(connectionString);
+            options.UseNpgsql(connectionString).AddAsyncSeeding(sp);
 #elif (UseSqlite)
-            options.UseSqlite(connectionString);
+            options.UseSqlite(connectionString).AddAsyncSeeding(sp);
 #else
-            options.UseSqlServer(connectionString);
+            options.UseSqlServer(connectionString).AddAsyncSeeding(sp);
 #endif
-        });
-
+        });
+
 #if (UseAspire)
-    #if (UsePostgreSQL)
+#if (UsePostgreSQL)
         builder.EnrichNpgsqlDbContext<ApplicationDbContext>();
-    #elif (UseSqlServer)
+#elif (UseSqlServer)
         builder.EnrichSqlServerDbContext<ApplicationDbContext>();
-    #endif
 #endif
-
+#endif
+
         builder.Services.AddScoped<IApplicationDbContext>(provider => provider.GetRequiredService<ApplicationDbContext>());
 
         builder.Services.AddScoped<ApplicationDbContextInitialiser>();