refactor: consolidate common usings into GlobalUsings.cs per project

src/Web/Data/BlogDbContext.cs

@@ -1,18 +1,16 @@
-using Microsoft.EntityFrameworkCore;
 using MongoDB.EntityFrameworkCore.Extensions;
-using MyBlog.Domain.Entities;
 
 namespace MyBlog.Web.Data;
 
 public sealed class BlogDbContext(DbContextOptions<BlogDbContext> options) : DbContext(options)
 {
-    public DbSet<BlogPost> BlogPosts => Set<BlogPost>();
+	public DbSet<BlogPost> BlogPosts => Set<BlogPost>();
 
-    protected override void OnModelCreating(ModelBuilder modelBuilder)
-    {
-        var entity = modelBuilder.Entity<BlogPost>();
-        entity.ToCollection("blogposts");
-        entity.HasKey(p => p.Id);
-        entity.Property(p => p.Version).IsConcurrencyToken();
-    }
+	protected override void OnModelCreating(ModelBuilder modelBuilder)
+	{
+		var entity = modelBuilder.Entity<BlogPost>();
+		entity.ToCollection("blogposts");
+		entity.HasKey(p => p.Id);
+		entity.Property(p => p.Version).IsConcurrencyToken();
+	}
 }

src/Web/Data/BlogPostMappings.cs

@@ -1,10 +1,8 @@
-using MyBlog.Domain.Entities;
-
 namespace MyBlog.Web.Data;
 
 internal static class BlogPostMappings
 {
-    internal static BlogPostDto ToDto(this BlogPost post) => new(
-        post.Id, post.Title, post.Content, post.Author,
-        post.CreatedAt, post.UpdatedAt, post.IsPublished);
+	internal static BlogPostDto ToDto(this BlogPost post) => new(
+			post.Id, post.Title, post.Content, post.Author,
+			post.CreatedAt, post.UpdatedAt, post.IsPublished);
 }

src/Web/Data/MongoDbBlogPostRepository.cs

@@ -1,53 +1,49 @@
-using Microsoft.EntityFrameworkCore;
-using MyBlog.Domain.Entities;
-using MyBlog.Domain.Interfaces;
-
 namespace MyBlog.Web.Data;
 
 public sealed class MongoDbBlogPostRepository(IDbContextFactory<BlogDbContext> contextFactory)
-    : IBlogPostRepository
+		: IBlogPostRepository
 {
-    public async Task<BlogPost?> GetByIdAsync(Guid id, CancellationToken ct = default)
-    {
-        await using var ctx = await contextFactory.CreateDbContextAsync(ct);
-        return await ctx.BlogPosts.AsNoTracking()
-            .FirstOrDefaultAsync(p => p.Id == id, ct);
-    }
+	public async Task<BlogPost?> GetByIdAsync(Guid id, CancellationToken ct = default)
+	{
+		await using var ctx = await contextFactory.CreateDbContextAsync(ct);
+		return await ctx.BlogPosts.AsNoTracking()
+				.FirstOrDefaultAsync(p => p.Id == id, ct);
+	}
 
-    public async Task<IReadOnlyList<BlogPost>> GetAllAsync(CancellationToken ct = default)
-    {
-        await using var ctx = await contextFactory.CreateDbContextAsync(ct);
-        return await ctx.BlogPosts.AsNoTracking()
-            .OrderByDescending(p => p.CreatedAt)
-            .ToListAsync(ct);
-    }
+	public async Task<IReadOnlyList<BlogPost>> GetAllAsync(CancellationToken ct = default)
+	{
+		await using var ctx = await contextFactory.CreateDbContextAsync(ct);
+		return await ctx.BlogPosts.AsNoTracking()
+				.OrderByDescending(p => p.CreatedAt)
+				.ToListAsync(ct);
+	}
 
-    public async Task AddAsync(BlogPost post, CancellationToken ct = default)
-    {
-        await using var ctx = await contextFactory.CreateDbContextAsync(ct);
-        await ctx.BlogPosts.AddAsync(post, ct);
-        await ctx.SaveChangesAsync(ct);
-    }
+	public async Task AddAsync(BlogPost post, CancellationToken ct = default)
+	{
+		await using var ctx = await contextFactory.CreateDbContextAsync(ct);
+		await ctx.BlogPosts.AddAsync(post, ct);
+		await ctx.SaveChangesAsync(ct);
+	}
 
-    public async Task UpdateAsync(BlogPost post, CancellationToken ct = default)
-    {
-        await using var ctx = await contextFactory.CreateDbContextAsync(ct);
-        var entry = ctx.Attach(post);
-        // Version was incremented by post.Update(); the original value in the DB is Version - 1.
-        // EF Core uses OriginalValue in the WHERE filter to detect concurrent modifications.
-        entry.Property(p => p.Version).OriginalValue = post.Version - 1;
-        entry.State = EntityState.Modified;
-        await ctx.SaveChangesAsync(ct);
-    }
+	public async Task UpdateAsync(BlogPost post, CancellationToken ct = default)
+	{
+		await using var ctx = await contextFactory.CreateDbContextAsync(ct);
+		var entry = ctx.Attach(post);
+		// Version was incremented by post.Update(); the original value in the DB is Version - 1.
+		// EF Core uses OriginalValue in the WHERE filter to detect concurrent modifications.
+		entry.Property(p => p.Version).OriginalValue = post.Version - 1;
+		entry.State = EntityState.Modified;
+		await ctx.SaveChangesAsync(ct);
+	}
 
-    public async Task DeleteAsync(Guid id, CancellationToken ct = default)
-    {
-        await using var ctx = await contextFactory.CreateDbContextAsync(ct);
-        var post = await ctx.BlogPosts.FindAsync([id], ct);
-        if (post is not null)
-        {
-            ctx.BlogPosts.Remove(post);
-            await ctx.SaveChangesAsync(ct);
-        }
-    }
+	public async Task DeleteAsync(Guid id, CancellationToken ct = default)
+	{
+		await using var ctx = await contextFactory.CreateDbContextAsync(ct);
+		var post = await ctx.BlogPosts.FindAsync([id], ct);
+		if (post is not null)
+		{
+			ctx.BlogPosts.Remove(post);
+			await ctx.SaveChangesAsync(ct);
+		}
+	}
 }

src/Web/Features/BlogPosts/Create/CreateBlogPostCommand.cs

@@ -1,7 +1,4 @@
-using MediatR;
-using Domain.Abstractions;
-
 namespace MyBlog.Web.Features.BlogPosts.Create;
 
 public sealed record CreateBlogPostCommand(string Title, string Content, string Author)
-    : IRequest<Result<Guid>>;
+		: IRequest<Result<Guid>>;

src/Web/Features/BlogPosts/Create/CreateBlogPostHandler.cs

@@ -1,30 +1,23 @@
-using MediatR;
-using Microsoft.Extensions.Caching.Distributed;
-using Microsoft.Extensions.Caching.Memory;
-using MyBlog.Domain.Entities;
-using MyBlog.Domain.Interfaces;
-using Domain.Abstractions;
-
 namespace MyBlog.Web.Features.BlogPosts.Create;
 
 public sealed class CreateBlogPostHandler(
-    IBlogPostRepository repo,
-    IMemoryCache localCache,
-    IDistributedCache distributedCache) : IRequestHandler<CreateBlogPostCommand, Result<Guid>>
+		IBlogPostRepository repo,
+		IMemoryCache localCache,
+		IDistributedCache distributedCache) : IRequestHandler<CreateBlogPostCommand, Result<Guid>>
 {
-    public async Task<Result<Guid>> Handle(CreateBlogPostCommand request, CancellationToken ct)
-    {
-        try
-        {
-            var post = BlogPost.Create(request.Title, request.Content, request.Author);
-            await repo.AddAsync(post, ct);
-            localCache.Remove("blog:all");
-            _ = distributedCache.RemoveAsync("blog:all", ct);
-            return Result.Ok<Guid>(post.Id);
-        }
-        catch (Exception ex)
-        {
-            return Result.Fail<Guid>(ex.Message);
-        }
-    }
+	public async Task<Result<Guid>> Handle(CreateBlogPostCommand request, CancellationToken ct)
+	{
+		try
+		{
+			var post = BlogPost.Create(request.Title, request.Content, request.Author);
+			await repo.AddAsync(post, ct);
+			localCache.Remove("blog:all");
+			_ = distributedCache.RemoveAsync("blog:all", ct);
+			return Result.Ok<Guid>(post.Id);
+		}
+		catch (Exception ex)
+		{
+			return Result.Fail<Guid>(ex.Message);
+		}
+	}
 }

src/Web/Features/BlogPosts/Delete/DeleteBlogPostCommand.cs

@@ -1,6 +1,3 @@
-using MediatR;
-using Domain.Abstractions;
-
 namespace MyBlog.Web.Features.BlogPosts.Delete;
 
 public sealed record DeleteBlogPostCommand(Guid Id) : IRequest<Result>;

src/Web/Features/BlogPosts/Delete/DeleteBlogPostHandler.cs

@@ -1,37 +1,30 @@
-using MediatR;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Caching.Distributed;
-using Microsoft.Extensions.Caching.Memory;
-using MyBlog.Domain.Interfaces;
-using Domain.Abstractions;
-
 namespace MyBlog.Web.Features.BlogPosts.Delete;
 
 public sealed class DeleteBlogPostHandler(
-    IBlogPostRepository repo,
-    IMemoryCache localCache,
-    IDistributedCache distributedCache) : IRequestHandler<DeleteBlogPostCommand, Result>
+		IBlogPostRepository repo,
+		IMemoryCache localCache,
+		IDistributedCache distributedCache) : IRequestHandler<DeleteBlogPostCommand, Result>
 {
-    public async Task<Result> Handle(DeleteBlogPostCommand request, CancellationToken ct)
-    {
-        try
-        {
-            await repo.DeleteAsync(request.Id, ct);
-            localCache.Remove("blog:all");
-            localCache.Remove($"blog:{request.Id}");
-            await distributedCache.RemoveAsync("blog:all", ct);
-            await distributedCache.RemoveAsync($"blog:{request.Id}", ct);
-            return Result.Ok();
-        }
-        catch (DbUpdateConcurrencyException)
-        {
-            return Result.Fail(
-                "This post was modified by another user. Please reload and try again.",
-                ResultErrorCode.Concurrency);
-        }
-        catch (Exception ex)
-        {
-            return Result.Fail(ex.Message);
-        }
-    }
+	public async Task<Result> Handle(DeleteBlogPostCommand request, CancellationToken ct)
+	{
+		try
+		{
+			await repo.DeleteAsync(request.Id, ct);
+			localCache.Remove("blog:all");
+			localCache.Remove($"blog:{request.Id}");
+			await distributedCache.RemoveAsync("blog:all", ct);
+			await distributedCache.RemoveAsync($"blog:{request.Id}", ct);
+			return Result.Ok();
+		}
+		catch (DbUpdateConcurrencyException)
+		{
+			return Result.Fail(
+					"This post was modified by another user. Please reload and try again.",
+					ResultErrorCode.Concurrency);
+		}
+		catch (Exception ex)
+		{
+			return Result.Fail(ex.Message);
+		}
+	}
 }

src/Web/Features/BlogPosts/Edit/EditBlogPostCommand.cs

@@ -1,6 +1,3 @@
-using MediatR;
-using Domain.Abstractions;
-
 namespace MyBlog.Web.Features.BlogPosts.Edit;
 
 public sealed record EditBlogPostCommand(Guid Id, string Title, string Content) : IRequest<Result>;