Avoid the need to pass urlPrefix/defaultPage to any middleware but one, enforcing a particular structure of middleware

Author: SteveSandersonMS

src/Microsoft.AspNetCore.SpaServices/AngularCli/AngularCliMiddleware.cs

@@ -22,7 +22,7 @@ internal class AngularCliMiddleware
         private readonly INodeServices _nodeServices;
         private readonly string _middlewareScriptPath;
 
-        public AngularCliMiddleware(IApplicationBuilder appBuilder, string sourcePath, string urlPrefix, string defaultPage)
+        public AngularCliMiddleware(IApplicationBuilder appBuilder, string sourcePath, SpaDefaultPageMiddleware defaultPageMiddleware)
         {
             if (string.IsNullOrEmpty(sourcePath))
             {
@@ -39,7 +39,7 @@ public AngularCliMiddleware(IApplicationBuilder appBuilder, string sourcePath, s
             // Proxy the corresponding requests through ASP.NET and into the Node listener
             // Anything under /<publicpath> (e.g., /dist) is proxied as a normal HTTP request
             // with a typical timeout (100s is the default from HttpClient).
-            UseProxyToLocalAngularCliMiddleware(appBuilder, urlPrefix, defaultPage,
+            UseProxyToLocalAngularCliMiddleware(appBuilder, defaultPageMiddleware,
                 angularCliServerInfoTask, TimeSpan.FromSeconds(100));
 
             // Advertise the availability of this feature to other SPA middleware
@@ -105,7 +105,7 @@ private async Task<AngularCliServerInfo> StartAngularCliServerAsync()
         }
 
         private static void UseProxyToLocalAngularCliMiddleware(
-            IApplicationBuilder appBuilder, string urlPrefix, string defaultPage,
+            IApplicationBuilder appBuilder, SpaDefaultPageMiddleware defaultPageMiddleware,
             Task<AngularCliServerInfo> serverInfoTask, TimeSpan requestTimeout)
         {
             // This is hardcoded to use http://localhost because:
@@ -119,8 +119,8 @@ private static void UseProxyToLocalAngularCliMiddleware(
 
             // Requests outside /<urlPrefix> are proxied to the default page
             var hasRewrittenUrlMarker = new object();
-            var defaultPageUrl = SpaDefaultPageExtensions.GetDefaultPageUrl(
-                urlPrefix, defaultPage);
+            var defaultPageUrl = defaultPageMiddleware.DefaultPageUrl;
+            var urlPrefix = defaultPageMiddleware.UrlPrefix;
             var urlPrefixIsRoot = string.IsNullOrEmpty(urlPrefix) || urlPrefix == "/";
             appBuilder.Use((context, next) =>
             {

src/Microsoft.AspNetCore.SpaServices/AngularCli/AngularCliMiddlewareExtensions.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using Microsoft.AspNetCore.Builder;
+using System;
 
 namespace Microsoft.AspNetCore.SpaServices.AngularCli
 {
@@ -19,16 +20,18 @@ public static class AngularCliMiddlewareExtensions
         /// sure not to enable the Angular CLI server.
         /// </summary>
         /// <param name="app">The <see cref="IApplicationBuilder"/>.</param>
-        /// <param name="urlPrefix">The URL prefix from which your SPA's files are served. This needs to match the <c>--deploy-url</c> option passed to Angular CLI.</param>
         /// <param name="sourcePath">The disk path, relative to the current directory, of the directory containing the SPA source files. When Angular CLI executes, this will be its working directory.</param>
-        /// <param name="defaultPage">Optional. Specifies the URL, relative to <paramref name="urlPrefix"/>, of the default HTML page that starts up your SPA. Defaults to <c>index.html</c>.</param>
         public static void UseAngularCliServer(
             this IApplicationBuilder app,
-            string urlPrefix,
-            string sourcePath,
-            string defaultPage = null)
+            string sourcePath)
         {
-            new AngularCliMiddleware(app, sourcePath, urlPrefix, defaultPage);
+            var defaultPageMiddleware = SpaDefaultPageMiddleware.FindInPipeline(app);
+            if (defaultPageMiddleware == null)
+            {
+                throw new Exception($"{nameof(UseAngularCliServer)} should be called inside the 'configue' callback of a call to {nameof(SpaApplicationBuilderExtensions.UseSpa)}.");
+            }
+
+            new AngularCliMiddleware(app, sourcePath, defaultPageMiddleware);
         }
     }
 }

src/Microsoft.AspNetCore.SpaServices/Prerendering/SpaPrerenderingExtensions.cs

@@ -5,6 +5,7 @@
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Http.Extensions;
 using Microsoft.AspNetCore.NodeServices;
+using Microsoft.AspNetCore.SpaServices;
 using Microsoft.AspNetCore.SpaServices.Prerendering;
 using Microsoft.Extensions.DependencyInjection;
 using System;
@@ -22,21 +23,24 @@ public static class SpaPrerenderingExtensions
         /// </summary>
         /// <param name="appBuilder">The <see cref="IApplicationBuilder"/>.</param>
         /// <param name="entryPoint">The path, relative to your application root, of the JavaScript file containing prerendering logic.</param>
-        /// <param name="urlPrefix">The URL prefix from which your SPA's files are served.</param>
         /// <param name="buildOnDemand">Optional. If specified, executes the supplied <see cref="ISpaPrerendererBuilder"/> before looking for the <paramref name="entryPoint"/> file. This is only intended to be used during development.</param>
-        /// <param name="defaultPage">Optional. Specifies the URL, relative to <paramref name="urlPrefix"/>, of the default HTML page that starts up your SPA. Defaults to <c>index.html</c>.</param>
         public static void UseSpaPrerendering(
             this IApplicationBuilder appBuilder,
             string entryPoint,
-            string urlPrefix,
-            ISpaPrerendererBuilder buildOnDemand = null,
-            string defaultPage = null)
+            ISpaPrerendererBuilder buildOnDemand = null)
         {
             if (string.IsNullOrEmpty(entryPoint))
             {
                 throw new ArgumentException("Cannot be null or empty", nameof(entryPoint));
             }
 
+            var defaultPageMiddleware = SpaDefaultPageMiddleware.FindInPipeline(appBuilder);
+            if (defaultPageMiddleware == null)
+            {
+                throw new Exception($"{nameof(UseSpaPrerendering)} should be called inside the 'configure' callback of a call to {nameof(SpaApplicationBuilderExtensions.UseSpa)}.");
+            }
+
+            var urlPrefix = defaultPageMiddleware.UrlPrefix;
             if (urlPrefix == null || urlPrefix.Length < 2)
             {
                 throw new ArgumentException(
@@ -59,8 +63,6 @@ public static void UseSpaPrerendering(
             var applicationBasePath = serviceProvider.GetRequiredService<IHostingEnvironment>()
                 .ContentRootPath;
             var moduleExport = new JavaScriptModuleExport(entryPoint);
-            var defaultPageUrl = SpaDefaultPageExtensions.GetDefaultPageUrl(
-                urlPrefix, defaultPage);
             var urlPrefixAsPathString = new PathString(urlPrefix);
 
             // Add the actual middleware that intercepts requests for the SPA default file
@@ -87,7 +89,7 @@ public static void UseSpaPrerendering(
                 // remove this.
                 var customData = new
                 {
-                    templateUrl = GetDefaultFileAbsoluteUrl(context, defaultPageUrl)
+                    templateUrl = GetDefaultFileAbsoluteUrl(context, defaultPageMiddleware.DefaultPageUrl)
                 };
 
                 // TODO: Add an optional "supplyCustomData" callback param so people using

src/Microsoft.AspNetCore.SpaServices/SpaApplicationBuilderExtensions.cs

@@ -0,0 +1,49 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using Microsoft.AspNetCore.SpaServices;
+using System;
+
+namespace Microsoft.AspNetCore.Builder
+{
+    /// <summary>
+    /// Provides extension methods used for configuring an application to
+    /// host a client-side Single Page Application (SPA).
+    /// </summary>
+    public static class SpaApplicationBuilderExtensions
+    {
+        /// <summary>
+        /// Handles all requests from this point in the middleware chain by returning
+        /// the default page for the Single Page Application (SPA).
+        /// 
+        /// This middleware should be placed late in the chain, so that other middleware
+        /// for serving static files, MVC actions, etc., takes precedence.
+        /// </summary>
+        /// <param name="app">The <see cref="IApplicationBuilder"/>.</param>
+        /// <param name="urlPrefix">
+        /// The URL path, relative to your application's <c>PathBase</c>, from which the
+        /// SPA files are served.
+        ///
+        /// For example, if your SPA files are located in <c>wwwroot/dist</c>, then
+        /// the value should usually be <c>"dist"</c>, because that is the URL prefix
+        /// from which browsers can request those files.
+        /// </param>
+        /// <param name="defaultPage">
+        /// Optional. If specified, configures the path (relative to <paramref name="urlPrefix"/>)
+        /// of the default page that hosts your SPA user interface.
+        /// If not specified, the default value is <c>"index.html"</c>.
+        /// </param>
+        /// <param name="configure">
+        /// Optional. If specified, this callback will be invoked so that additional middleware
+        /// can be registered within the context of this SPA.
+        /// </param>
+        public static void UseSpa(
+            this IApplicationBuilder app,
+            string urlPrefix,
+            string defaultPage = null,
+            Action configure = null)
+        {
+            new SpaDefaultPageMiddleware(app, urlPrefix, defaultPage, configure);
+        }
+    }
+}

src/Microsoft.AspNetCore.SpaServices/SpaDefaultPageExtensions.cs

@@ -0,0 +1,91 @@
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Http;
+using System;
+
+namespace Microsoft.AspNetCore.SpaServices
+{
+    internal class SpaDefaultPageMiddleware
+    {
+        private static readonly string _propertiesKey = Guid.NewGuid().ToString();
+
+        public static SpaDefaultPageMiddleware FindInPipeline(IApplicationBuilder app)
+        {
+            return app.Properties.TryGetValue(_propertiesKey, out var instance)
+                ? (SpaDefaultPageMiddleware)instance
+                : null;
+        }
+
+        public string UrlPrefix { get; }
+        public string DefaultPageUrl { get; }
+
+        public SpaDefaultPageMiddleware(IApplicationBuilder app, string urlPrefix,
+            string defaultPage, Action configure)
+        {
+            if (app == null)
+            {
+                throw new ArgumentNullException(nameof(app));
+            }
+
+            UrlPrefix = urlPrefix ?? throw new ArgumentNullException(nameof(urlPrefix));
+            DefaultPageUrl = ConstructDefaultPageUrl(urlPrefix, defaultPage);
+
+            // Attach to pipeline, but invoke 'configure' to give the developer a chance
+            // to insert extra middleware before the 'default page' pipeline entries
+            RegisterSoleInstanceInPipeline(app);
+            configure?.Invoke();
+            AttachMiddlewareToPipeline(app);
+        }
+
+        private void RegisterSoleInstanceInPipeline(IApplicationBuilder app)
+        {
+            if (app.Properties.ContainsKey(_propertiesKey))
+            {
+                throw new Exception($"Only one usage of {nameof(SpaApplicationBuilderExtensions.UseSpa)} is allowed in any single branch of the middleware pipeline. This is because one instance would handle all requests.");
+            }
+
+            app.Properties[_propertiesKey] = this;
+        }
+
+        private void AttachMiddlewareToPipeline(IApplicationBuilder app)
+        {
+            // Rewrite all requests to the default page
+            app.Use((context, next) =>
+            {
+                context.Request.Path = DefaultPageUrl;
+                return next();
+            });
+
+            // Serve it as file from disk
+            app.UseStaticFiles();
+
+            // If the default file didn't get served as a static file (because it
+            // was not present on disk), the SPA is definitely not going to work.
+            app.Use((context, next) =>
+            {
+                var message = $"The SPA default page middleware could not return the default page '{DefaultPageUrl}' because it was not found on disk, and no other middleware handled the request.\n";
+
+                // Try to clarify the common scenario where someone runs an application in
+                // Production environment without first publishing the whole application
+                // or at least building the SPA.
+                var hostEnvironment = (IHostingEnvironment)context.RequestServices.GetService(typeof(IHostingEnvironment));
+                if (hostEnvironment != null && hostEnvironment.IsProduction())
+                {
+                    message += "Your application is running in Production mode, so make sure it has been published, or that you have built your SPA manually. Alternatively you may wish to switch to the Development environment.\n";
+                }
+
+                throw new Exception(message);
+            });
+        }
+
+        private static string ConstructDefaultPageUrl(string urlPrefix, string defaultPage)
+        {
+            if (string.IsNullOrEmpty(defaultPage))
+            {
+                defaultPage = "index.html";
+            }
+
+            return new PathString(urlPrefix).Add(new PathString("/" + defaultPage));
+        }
+    }
+}