Merge pull request #1061 from DuendeSoftware/mb/middleware

Migrate custom middleware implementations to dedicated classes

Author: maartenba

…Docs.Web/ContentNegotiationMiddleware.cs …e/MarkdownContentNegotationMiddleware.csserver/src/Docs.Web/ContentNegotiationMiddleware.cs renamed to server/src/Docs.Web/Middleware/MarkdownContentNegotationMiddleware.cs server/src/Docs.Web/ContentNegotiationMiddleware.cs renamed to server/src/Docs.Web/Middleware/MarkdownContentNegotationMiddleware.cs

@@ -1,9 +1,9 @@
-namespace Docs.Web;
+namespace Docs.Web.Middleware;
 
 /// <summary>
 /// Middleware that serves .md files when the client sends Accept: text/markdown.
 /// </summary>
-public class ContentNegotiationMiddleware(IWebHostEnvironment environment) : IMiddleware
+public class MarkdownContentNegotationMiddleware(IWebHostEnvironment environment) : IMiddleware
 {
     public async Task InvokeAsync(HttpContext context, RequestDelegate next)
     {

server/src/Docs.Web/Middleware/NotFoundMiddleware.cs

@@ -0,0 +1,23 @@
+namespace Docs.Web.Middleware;
+
+/// <summary>
+/// Middleware that serves a custom 404.html page when the response status code is 404.
+/// </summary>
+public class NotFoundMiddleware(IWebHostEnvironment environment) : IMiddleware
+{
+    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
+    {
+        await next(context);
+
+        if (context.Response.StatusCode == 404 && !context.Response.HasStarted)
+        {
+            var notFoundPath = Path.Combine(environment.WebRootPath, "404.html");
+
+            if (File.Exists(notFoundPath))
+            {
+                context.Response.ContentType = "text/html";
+                await context.Response.SendFileAsync(notFoundPath);
+            }
+        }
+    }
+}

server/src/Docs.Web/Middleware/RedirectMiddleware.cs

@@ -0,0 +1,22 @@
+namespace Docs.Web.Middleware;
+
+/// <summary>
+/// Middleware that redirects old URLs to new destinations using a preloaded redirect map (301 permanent).
+/// </summary>
+public class RedirectMiddleware(IReadOnlyDictionary<string, string> redirectMap) : IMiddleware
+{
+    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
+    {
+        var path = context.Request.Path.Value?.TrimEnd('/') ?? "";
+
+        if (redirectMap.TryGetValue(path, out var destination))
+        {
+            var queryString = context.Request.QueryString.HasValue ? context.Request.QueryString.Value : "";
+            context.Response.StatusCode = 301;
+            context.Response.Headers.Location = $"{destination}{queryString}";
+            return;
+        }
+
+        await next(context);
+    }
+}

server/src/Docs.Web/Middleware/TrailingSlashMiddleware.cs

@@ -0,0 +1,27 @@
+namespace Docs.Web.Middleware;
+
+/// <summary>
+/// Middleware that redirects requests without a trailing slash to the same path with a trailing slash (301 permanent).
+/// Skips paths with file extensions and health-check endpoints.
+/// </summary>
+public class TrailingSlashMiddleware : IMiddleware
+{
+    public Task InvokeAsync(HttpContext context, RequestDelegate next)
+    {
+        var path = context.Request.Path.Value;
+
+        if (!string.IsNullOrEmpty(path) &&
+            !path.EndsWith("/") &&
+            !Path.HasExtension(path) &&
+            !path.StartsWith("/health") &&
+            !path.StartsWith("/alive"))
+        {
+            var queryString = context.Request.QueryString.HasValue ? context.Request.QueryString.Value : "";
+            context.Response.StatusCode = 301;
+            context.Response.Headers.Location = $"{path}/{queryString}";
+            return Task.CompletedTask;
+        }
+
+        return next(context);
+    }
+}

server/src/Docs.Web/Program.cs

@@ -1,5 +1,6 @@
 using System.Text.Json;
 using Docs.Web;
+using Docs.Web.Middleware;
 
 var builder = WebApplication.CreateBuilder(args);
 
@@ -8,16 +9,14 @@
 // Add response compression
 builder.Services.AddResponseCompression();
 
-// Content negotiation middleware
-builder.Services.AddTransient<ContentNegotiationMiddleware>();
-
-var app = builder.Build();
-
-app.MapDefaultEndpoints();
+// Custom middlewares
+builder.Services.AddTransient<MarkdownContentNegotationMiddleware>();
+builder.Services.AddTransient<TrailingSlashMiddleware>();
+builder.Services.AddTransient<NotFoundMiddleware>();
 
 // Load redirect map from Astro-generated redirects.json
 var redirectMap = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
-var redirectsPath = Path.Combine(app.Environment.WebRootPath, "redirects.json");
+var redirectsPath = Path.Combine(builder.Environment.WebRootPath, "redirects.json");
 if (File.Exists(redirectsPath))
 {
     var json = File.ReadAllText(redirectsPath);
@@ -29,55 +28,34 @@
             redirectMap[key] = value;
         }
     }
+}
+builder.Services.AddSingleton<IReadOnlyDictionary<string, string>>(redirectMap);
+builder.Services.AddTransient<RedirectMiddleware>();
+
+var app = builder.Build();
+
+if (redirectMap.Count > 0)
+{
     app.Logger.LogInformation("Loaded {Count} redirects from redirects.json", redirectMap.Count);
 }
 else
 {
-    app.Logger.LogWarning("redirects.json not found at {Path}, no redirects will be applied", redirectsPath);
+    app.Logger.LogWarning("No redirects loaded (redirects.json missing or empty at {Path})", redirectsPath);
 }
 
-// Redirect middleware — match old URLs to new destinations (301 permanent)
-app.Use(async (context, next) =>
-{
-    var path = context.Request.Path.Value?.TrimEnd('/') ?? "";
-
-    if (redirectMap.TryGetValue(path, out var destination))
-    {
-        var queryString = context.Request.QueryString.HasValue ? context.Request.QueryString.Value : "";
-        context.Response.StatusCode = 301;
-        context.Response.Headers.Location = $"{destination}{queryString}";
-        return;
-    }
+app.MapDefaultEndpoints();
 
-    await next();
-});
+// Redirect middleware — match old URLs to new destinations (301 permanent)
+app.UseMiddleware<RedirectMiddleware>();
 
 // Enable response compression
 app.UseResponseCompression();
 
-// Content negotiation: serve .md file when Accept: text/markdown
-app.UseMiddleware<ContentNegotiationMiddleware>();
+// Serve .md file when Accept: text/markdown
+app.UseMiddleware<MarkdownContentNegotationMiddleware>();
 
 // Add trailing slash redirect middleware (replicate nginx behavior)
-app.Use(async (context, next) =>
-{
-    var path = context.Request.Path.Value;
-
-    // If path doesn't end with slash and doesn't have a file extension, redirect with trailing slash
-    if (!string.IsNullOrEmpty(path) &&
-        !path.EndsWith("/") &&
-        !Path.HasExtension(path) &&
-        !path.StartsWith("/health") &&
-        !path.StartsWith("/alive"))
-    {
-        var queryString = context.Request.QueryString.HasValue ? context.Request.QueryString.Value : "";
-        context.Response.StatusCode = 301;
-        context.Response.Headers.Location = $"{path}/{queryString}";
-        return;
-    }
-
-    await next();
-});
+app.UseMiddleware<TrailingSlashMiddleware>();
 
 // Add version header if APPLICATION_VERSION is set
 var applicationVersion = Environment.GetEnvironmentVariable("APPLICATION_VERSION");
@@ -164,22 +142,7 @@
 });
 
 // Handle 404 with custom page
-app.Use(async (context, next) =>
-{
-    await next();
-
-    if (context.Response.StatusCode == 404 && !context.Response.HasStarted)
-    {
-        var webHostEnvironment = context.RequestServices.GetRequiredService<IWebHostEnvironment>();
-        var notFoundPath = Path.Combine(webHostEnvironment.WebRootPath, "404.html");
-
-        if (File.Exists(notFoundPath))
-        {
-            context.Response.ContentType = "text/html";
-            await context.Response.SendFileAsync(notFoundPath);
-        }
-    }
-});
+app.UseMiddleware<NotFoundMiddleware>();
 
 // Fallback to index.html for directory requests
 app.MapFallback(async context =>