Replace middleware with simple endpoints

src/OrchardCore.Modules/OrchardCore.Facebook/Endpoints/GetSdkEndpoints.cs

@@ -0,0 +1,126 @@
+using System.Text;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Routing;
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Primitives;
+using OrchardCore.Environment.Shell.Configuration;
+using OrchardCore.Facebook.Settings;
+using OrchardCore.Settings;
+
+#nullable enable
+
+namespace OrchardCore.Facebook.Endpoints;
+
+public static class GetSdkEndpoints
+{
+    public static IEndpointRouteBuilder AddSdkEndpoints(this IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("/OrchardCore.Facebook/sdk/fbsdk.js", HandleFbsdkScriptRequestAsync)
+            .AllowAnonymous()
+            .DisableAntiforgery();
+
+        builder.MapGet("/OrchardCore.Facebook/sdk/fb.js", HandleFbScriptRequestAsync)
+            .AllowAnonymous()
+            .DisableAntiforgery();
+
+        return builder;
+    }
+
+    private static uint GetHashCode(byte[] bytes)
+    {
+        uint hash = 0;
+        foreach (byte b in bytes)
+        {
+            hash += b;
+            hash *= 17;
+        }
+        return hash;
+    }
+
+    private static IResult HandleFbsdkScriptRequestAsync([FromQuery(Name = "lang")] string language, [FromQuery(Name = "sdkf")] string sdkFilename, HttpContext context, IMemoryCache cache)
+    {
+        // Set the cache timeout to the maximum allowed length of one year
+        // max-age is needed because immutable is not widly supported
+        context.Response.Headers.CacheControl = $"public, max-age=31536000, immutable";
+
+        string scriptCacheKey = $"~/OrchardCore.Facebook/sdk/fbsdk.js?sdkf={sdkFilename}&lang={language}";
+
+        var scriptBytes = cache.Get(scriptCacheKey) as byte[];
+        if (scriptBytes == null)
+        {
+            // Note: Update script version in ResourceManagementOptionsConfiguration.cs after editing
+            scriptBytes = Encoding.UTF8.GetBytes($@"(function(d){{
+                var js, id = 'facebook-jssdk'; if (d.getElementById(id)) {{ return; }}
+                js = d.createElement('script'); js.id = id; js.async = true;
+                js.src = ""https://connect.facebook.net/{language.Replace('-', '_')}/{sdkFilename}"";
+                d.getElementsByTagName('head')[0].appendChild(js);
+            }} (document));");
+
+            cache.Set(scriptCacheKey, scriptBytes);
+        }
+
+        return Results.Bytes(scriptBytes, "application/javascript");
+    }
+
+    private static async Task<IResult> HandleFbScriptRequestAsync(HttpContext context, ISiteService siteService, IMemoryCache cache, IShellConfiguration shellConfiguration)
+    {
+        var settings = await siteService.GetSettingsAsync<FacebookSettings>();
+
+        if (string.IsNullOrWhiteSpace(settings.AppId))
+        {
+            return Results.Forbid();
+        }
+
+        context.Response.Headers.CacheControl = shellConfiguration.GetValue(
+                "StaticFileOptions:CacheControl",
+                // Fallback value
+                $"public, max-age={TimeSpan.FromDays(30).TotalSeconds}");
+
+        // Assumes IfNoneMatch has only one ETag for performance
+        var requestETag = context.Request.Headers.IfNoneMatch;
+        if (!StringValues.IsNullOrEmpty(requestETag) && cache.Get(requestETag) != null)
+        {
+            context.Response.Headers.ETag = requestETag;
+
+            return Results.StatusCode(304);
+        }
+
+        string scriptCacheKey = $"/OrchardCore.Facebook/sdk/fb.js.{settings.AppId}.{settings.Version}";
+
+        var scriptBytes = (byte[]?)cache.Get(scriptCacheKey);
+        if (scriptBytes == null)
+        {
+            // Generate script
+            var options = $"{{ appId:'{settings.AppId}',version:'{settings.Version}'";
+            options = string.IsNullOrWhiteSpace(settings.FBInitParams)
+                ? string.Concat(options, "}")
+                : string.Concat(options, ",", settings.FBInitParams, "}");
+            scriptBytes = Encoding.UTF8.GetBytes($"window.fbAsyncInit = function(){{ FB.init({options});}};");
+
+            cache.Set(scriptCacheKey, scriptBytes);
+        }
+
+// False positive: No comparison is taking place here
+#pragma warning disable RS1024
+        // Uses a custom GetHashCode because Object.GetHashCode differs across processes
+        StringValues eTag = $"\"{GetHashCode(scriptBytes)}\"";
+#pragma warning restore RS1024
+
+        // Mark that the eTag corresponds to a fresh file
+        cache.Set(eTag, true);
+
+        context.Response.Headers.ETag = eTag;
+
+        // Can be true if the cache was reset after the last client request
+        if (requestETag.Equals(eTag))
+        {
+            return Results.StatusCode(304);
+        }
+
+        return Results.Bytes(scriptBytes, "application/javascript");
+    }
+}

src/OrchardCore.Modules/OrchardCore.Facebook/ResourceManagementOptionsConfiguration.cs

@@ -1,25 +1,38 @@
+using System.Globalization;
 using Microsoft.Extensions.Options;
+using OrchardCore.Facebook.Settings;
 using OrchardCore.ResourceManagement;
+using OrchardCore.Settings;
 
 namespace OrchardCore.Facebook;
 
 public sealed class ResourceManagementOptionsConfiguration : IConfigureOptions<ResourceManagementOptions>
 {
-    private static readonly ResourceManifest _manifest;
+    private readonly ResourceManifest _manifest;
+    private readonly ISiteService _siteService;
 
-    static ResourceManagementOptionsConfiguration()
+    public ResourceManagementOptionsConfiguration(ISiteService siteService)
     {
+        _siteService = siteService;
+
         _manifest = new ResourceManifest();
 
         _manifest
             .DefineScript("fb")
             .SetDependencies("fbsdk")
             .SetUrl("~/OrchardCore.Facebook/sdk/fb.js");
+    }
+
+    public async void Configure(ResourceManagementOptions options)
+    {
+        var settings = await _siteService.GetSettingsAsync<FacebookSettings>();
+        var language = CultureInfo.CurrentUICulture.Name;
 
         _manifest
             .DefineScript("fbsdk")
-            .SetUrl("~/OrchardCore.Facebook/sdk/fbsdk.js");
-    }
+            // v parameter is for cache busting
+            .SetUrl($"~/OrchardCore.Facebook/sdk/fbsdk.js?sdkf={settings.SdkJs}&lang={language}&v=1.0");
 
-    public void Configure(ResourceManagementOptions options) => options.ResourceManifests.Add(_manifest);
+        options.ResourceManifests.Add(_manifest);
+    }
 }

src/OrchardCore.Modules/OrchardCore.Facebook/Startup.cs

@@ -4,6 +4,8 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 using OrchardCore.DisplayManagement.Handlers;
+using OrchardCore.Facebook.Endpoints;
+using OrchardCore.Environment.Shell.Configuration;
 using OrchardCore.Facebook.Drivers;
 using OrchardCore.Facebook.Filters;
 using OrchardCore.Facebook.Recipes;
@@ -20,11 +22,13 @@ public sealed class Startup : StartupBase
 {
     public override void Configure(IApplicationBuilder builder, IEndpointRouteBuilder routes, IServiceProvider serviceProvider)
     {
-        builder.UseMiddleware<ScriptsMiddleware>();
+        routes.AddSdkEndpoints();
     }
 
     public override void ConfigureServices(IServiceCollection services)
     {
+        services.AddSingleton<IShellConfiguration, ShellConfiguration>();
+
         services.AddPermissionProvider<Permissions>();
         services.AddNavigationProvider<AdminMenu>();
 

src/OrchardCore.Modules/OrchardCore.Liquid/Endpoints/Scripts/GetIntellisenseEndpoint.cs

@@ -0,0 +1,98 @@
+using System.Text;
+using Fluid;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using Microsoft.Extensions.Primitives;
+using Microsoft.Net.Http.Headers;
+using OrchardCore.DisplayManagement.Liquid;
+using OrchardCore.Environment.Shell.Configuration;
+
+#nullable enable
+
+namespace OrchardCore.Liquid.Endpoints.Scripts;
+
+public static class GetIntellisenseEndpoint
+{
+    public static IEndpointRouteBuilder AddGetIntellisenseScriptEndpoint(this IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("OrchardCore.Liquid/Scripts/liquid-intellisense.js", HandleRequest)
+            .AllowAnonymous()
+            .DisableAntiforgery();
+
+        return builder;
+    }
+
+    private static byte[] GenerateScript(IServiceProvider serviceProvider)
+    {
+        var templateOptions = serviceProvider.GetRequiredService<IOptions<TemplateOptions>>();
+        var liquidViewParser = serviceProvider.GetRequiredService<LiquidViewParser>();
+        var filters = string.Join(',', templateOptions.Value.Filters.Select(x => $"'{x.Key}'"));
+        var tags = string.Join(',', liquidViewParser.RegisteredTags.Select(x => $"'{x.Key}'"));
+        var script = $@"[{filters}].forEach(value=>{{if(!liquidFilters.includes(value)){{ liquidFilters.push(value);}}}});
+                    [{tags}].forEach(value=>{{if(!liquidTags.includes(value)){{ liquidTags.push(value);}}}});";
+
+        return Encoding.UTF8.GetBytes(script);
+    }
+
+    private static uint GetHashCode(byte[] bytes)
+    {
+        uint hash = 0;
+        foreach (byte b in bytes)
+        {
+            hash += b;
+            hash *= 17;
+        }
+        return hash;
+    }
+
+    private static IResult HandleRequest(HttpContext context, IMemoryCache cache, IShellConfiguration shellConfiguration)
+    {
+        context.Response.Headers.CacheControl = shellConfiguration.GetValue(
+                "StaticFileOptions:CacheControl",
+                // Fallback value
+                $"public, max-age={TimeSpan.FromDays(30).TotalSeconds}");
+
+        // Assumes IfNoneMatch has only one ETag for performance
+        var requestETag = context.Request.Headers.IfNoneMatch;
+        if (!StringValues.IsNullOrEmpty(requestETag) && cache.Get(requestETag) != null)
+        {
+            context.Response.Headers.ETag = requestETag;
+
+            return Results.StatusCode(304);
+        }
+
+        const string scriptCacheKey = "OrchardCore.Liquid/Scripts/liquid-intellisense.js";
+
+        var scriptBytes = (byte[]?)cache.Get(scriptCacheKey);
+        if (scriptBytes == null)
+        {
+            scriptBytes = GenerateScript(context.RequestServices);
+
+            cache.Set(scriptCacheKey, scriptBytes);
+        }
+
+// False positive: No comparison is taking place here
+#pragma warning disable RS1024
+        // Uses a custom GetHashCode because Object.GetHashCode differs across processes
+        StringValues eTag = $"\"{GetHashCode(scriptBytes)}\"";
+#pragma warning restore RS1024
+
+        // Mark that the eTag corresponds to a fresh file
+        cache.Set(eTag, true);
+
+        context.Response.Headers.ETag = eTag;
+
+        // Can be true if the cache was reset after the last client request
+        if (requestETag.Equals(eTag))
+        {
+            return Results.StatusCode(304);
+        }
+
+        return Results.Bytes(scriptBytes, "application/javascript");
+    }
+}