Speed-up initial webhook response times by going lazy init

Breaking change: we now *require* invoking UseWhatsApp on the functions app builder. We throw an exception if we detect it's misisng:

```
var builder = FunctionsApplication.CreateBuilder(args);
builder.ConfigureFunctionsWebApplication();
builder.UseWhatsApp();
```

When the user's handler pipeline was non-trivial to spin-up, webhook responses were delayed until the full DI graph for it was built.

We now instead make that dependency fully lazy so that the webhook can respond immediately and send the typing/read indicators as needed right-away.

Both pipeline runner and handler are changed to Func<T> accordingly, and we had to bring the function context accessor to properly retrieve the instances from the right container at run-time in the isolated worker model.

Author: kzu

.netconfig

@@ -168,3 +168,8 @@
 	sha = cf76df0d6a218c26ebe117339fe3445050b0532a
 	etag = aed711a45e051edfddfcb76d9f8021d30f9817c342cfe8d1cc38f2af37b47aa8
 	weak
+[file "src/WhatsApp/Extensions/FunctionContextAccessor.cs"]
+	url = https://github.com/devlooped/catbag/blob/main/Microsoft/Azure/Functions/Worker/FunctionContextAccessor.cs
+	sha = 91ea14062eb6ac6b9dc85d41b90fdbb56c46efbf
+	etag = 3d9f39632c0a896dea7aa0cebcef77a7b668fdedfd8d2c8bf79826fa3a85121f
+	weak

readme.md

@@ -30,6 +30,9 @@ To pay the Maintenance Fee, [become a Sponsor](https://github.com/sponsors/devlo
 var builder = FunctionsApplication.CreateBuilder(args);
 builder.ConfigureFunctionsWebApplication();
 
+builder.UseWhatsApp(); // 👈 setup middleware
+
+// add your messages handler here 👇 
 builder.Services.AddWhatsApp<MyWhatsAppHandler>();
 
 builder.Build().Run();

src/SampleApp/Sample/Program.cs

@@ -48,6 +48,8 @@
     storage :
     CloudStorageAccount.Parse(builder.Configuration["AzureWebJobsStorage"]));
 
+builder.UseWhatsApp();
+
 var whatsapp = builder.Services
     .AddWhatsApp<ProcessHandler>(configure: options =>
     {

src/Tests/IntegrationTests.cs

@@ -1,5 +1,7 @@
-using Microsoft.Extensions.Configuration;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using Moq;
 
 namespace Devlooped.WhatsApp;
 
@@ -35,6 +37,7 @@ public async Task RunConversationAsync()
             .Build();
 
         var services = new ServiceCollection()
+            .AddSingleton<IFunctionContextAccessor>(Mock.Of<IFunctionContextAccessor>())
             .AddSingleton<IConfiguration>(configuration)
             .AddSingleton<IConversationStorage>(new TestConversationStorage(CloudStorageAccount.DevelopmentStorageAccount));
 

src/Tests/PipelineTests.cs

@@ -1,4 +1,5 @@
 using System.Runtime.CompilerServices;
+using Microsoft.Azure.Functions.Worker;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Moq;
@@ -122,6 +123,7 @@ public async Task ConversationCalledAfterCustom()
             .Callback(() => order.Add("storage:save"));
 
         var services = new ServiceCollection()
+            .AddSingleton<IFunctionContextAccessor>(Mock.Of<IFunctionContextAccessor>())
             .AddSingleton<IConfiguration>(configuration)
             .AddSingleton(conversation.Object);
 
@@ -183,6 +185,7 @@ public async Task ConversationRestored()
             });
 
         var services = new ServiceCollection()
+            .AddSingleton<IFunctionContextAccessor>(Mock.Of<IFunctionContextAccessor>())
             .AddSingleton<IConfiguration>(configuration)
             .AddSingleton<IConversationStorage>(storage);
 
@@ -237,6 +240,7 @@ public async Task CanSendMessagesThroughPipeline()
             });
 
         var services = new ServiceCollection()
+            .AddSingleton<IFunctionContextAccessor>(Mock.Of<IFunctionContextAccessor>())
             .AddSingleton<IConfiguration>(configuration);
 
         var sent = 0;

src/WhatsApp/AzureFunctionsConsole.cs

@@ -14,7 +14,7 @@ namespace Devlooped.WhatsApp;
 /// </summary>
 class AzureFunctionsConsole(
     IWhatsAppClient client,
-    IWhatsAppHandler handler,
+    Func<IWhatsAppHandler> handler,
     ILogger<AzureFunctionsWebhook> logger,
     IHostEnvironment environment)
 {
@@ -70,7 +70,7 @@ public async Task<IActionResult> MessageConsole([HttpTrigger(AuthorizationLevel.
 
             // Await all responses
             // No action needed, just make sure all items are processed
-            _ = Task.Run(() => handler.HandleAsync([message]).ToArrayAsync().AsTask()).Ignore();
+            _ = Task.Run(() => handler().HandleAsync([message]).ToArrayAsync().AsTask()).Ignore();
         }
         else
         {

src/WhatsApp/AzureFunctionsProcessors.cs

@@ -8,13 +8,13 @@
 
 namespace Devlooped.WhatsApp;
 
-class AzureFunctionsProcessors(PipelineRunner runner, IOptions<WhatsAppOptions> options)
+class AzureFunctionsProcessors(Func<PipelineRunner> runner, IOptions<WhatsAppOptions> options)
 {
     readonly WhatsAppOptions options = options.Value;
 
     [Function("whatsapp_dequeue")]
     public Task DequeueAsync([QueueTrigger("whatsappwebhook", Connection = "AzureWebJobsStorage")] string json)
-        => runner.ProcessAsync(json);
+        => runner().ProcessAsync(json);
 
     [Function("whatsapp_eventgrid")]
     public async Task<IActionResult> HandleEventGrid(
@@ -25,7 +25,7 @@ public async Task<IActionResult> HandleEventGrid(
         [Microsoft.Azure.Functions.Worker.Http.FromBody] EventGridEvent e)
 #endif
     {
-        await runner.ProcessAsync(Regex.Unescape(e.Data.ToString()).Trim('"'));
+        await runner().ProcessAsync(Regex.Unescape(e.Data.ToString()).Trim('"'));
         return new OkResult();
     }
 
@@ -41,7 +41,7 @@ public async Task<IActionResult> ProcessAsync(
         using var reader = new StreamReader(req.Body, Encoding.UTF8);
         var json = await reader.ReadToEndAsync();
 
-        await runner.ProcessAsync(json);
+        await runner().ProcessAsync(json);
         return new OkResult();
     }
 }

src/WhatsApp/AzureFunctionsWebhook.cs

@@ -24,7 +24,7 @@ namespace Devlooped.WhatsApp;
 class AzureFunctionsWebhook(
     IMessageProcessor messageProcessor,
     IWhatsAppClient whatsapp,
-    IWhatsAppHandler handler,
+    Func<IWhatsAppHandler> handler,
     IOptions<MetaOptions> metaOptions,
     IOptions<WhatsAppOptions> functionOptions,
     IHostEnvironment hosting,
@@ -116,7 +116,7 @@ async Task<IActionResult> ProcessFlowDataAsync(string json, EncryptedFlowData en
 
         FlowDataResponse? flowResponse = default;
 
-        await foreach (var response in handler.HandleAsync([flow]))
+        await foreach (var response in handler().HandleAsync([flow]))
         {
             if (response is FlowDataResponse fdr)
             {

src/WhatsApp/Extensions/FunctionContextAccessor.cs

@@ -0,0 +1,111 @@
+// <auto-generated />
+#region License
+// MIT License
+// 
+// Copyright (c) Daniel Cazzulino
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+#nullable enable
+
+using System.Diagnostics;
+using System.Threading.Tasks;
+using System.Threading;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Azure.Functions.Worker.Middleware;
+using Microsoft.Extensions.DependencyInjection;
+
+// Follows implementation of HttpContextAccessor at https://github.com/dotnet/aspnetcore/blob/main/src/Http/Http/src/HttpContextAccessor.cs
+
+namespace Microsoft.Azure.Functions.Worker
+{
+    /// <summary>
+    /// Provides access to the current <see cref="FunctionContext"/>, if one is available.
+    /// </summary>
+    public interface IFunctionContextAccessor
+    {
+        /// <summary>
+        /// Gets or sets the current <see cref="FunctionContext"/>. 
+        /// Returns <see langword="null" /> if there is no active <see cref="FunctionContext" />.
+        /// </summary>
+        FunctionContext? FunctionContext { get; set; }
+    }
+}
+
+namespace Microsoft.Extensions.Hosting
+{
+    /// <summary>
+    /// Extension method to allow access to the current <see cref="FunctionContext"/> 
+    /// from dependency injection.
+    /// </summary>
+    public static class FunctionContextAccessorExtensions
+    {
+        /// <summary>
+        /// Adds a default implementation for the <see cref="IFunctionContextAccessor"/> service.
+        /// </summary>
+        public static IFunctionsWorkerApplicationBuilder UseFunctionContextAccessor(this IFunctionsWorkerApplicationBuilder builder)
+        {
+            builder.UseMiddleware<FunctionContextAccessorMiddleware>();
+            builder.Services.AddSingleton<IFunctionContextAccessor, FunctionContextAccessor>();
+            return builder;
+        }
+    }
+
+    [DebuggerDisplay("FunctionContext = {FunctionContext}")]
+    class FunctionContextAccessor : IFunctionContextAccessor
+    {
+        static readonly AsyncLocal<FunctionContextHolder> current = new AsyncLocal<FunctionContextHolder>();
+
+        public virtual FunctionContext? FunctionContext
+        {
+            get => current.Value?.Context;
+            set
+            {
+                var holder = current.Value;
+                if (holder != null)
+                {
+                    // Clear current context trapped in the AsyncLocals, as its done.
+                    holder.Context = default;
+                }
+
+                if (value != null)
+                {
+                    // Use an object indirection to hold the context in the AsyncLocal,
+                    // so it can be cleared in all ExecutionContexts when its cleared.
+                    current.Value = new FunctionContextHolder { Context = value };
+                }
+            }
+        }
+
+        class FunctionContextHolder
+        {
+            public FunctionContext? Context;
+        }
+    }
+
+    class FunctionContextAccessorMiddleware(IFunctionContextAccessor accessor) : IFunctionsWorkerMiddleware
+    {
+        public Task Invoke(FunctionContext context, FunctionExecutionDelegate next)
+        {
+            accessor.FunctionContext = context;
+            return next(context);
+        }
+    }
+}

src/WhatsApp/PipelineRunner.cs

@@ -7,7 +7,7 @@ namespace Devlooped.WhatsApp;
 class PipelineRunner(
     Idempotency idempotency,
     IWhatsAppClient whatsapp,
-    IWhatsAppHandler handler,
+    Func<IWhatsAppHandler> handler,
     IOptions<WhatsAppOptions> functionOptions,
     ILogger<PipelineRunner> logger)
 {
@@ -45,7 +45,7 @@ public async Task ProcessAsync(string json)
             {
                 // Await all responses
                 // No action needed, just make sure all items are processed
-                await handler.HandleAsync([message]).ToArrayAsync();
+                await handler().HandleAsync([message]).ToArrayAsync();
                 logger.LogInformation($"Completed work item: {message.Id}");
             }
             catch (Exception e)