Add AOT support, annotations, and AOT-safe JSON overloads

Author: pwelter34

src/Arbiter.Mapping/Arbiter.Mapping.csproj

@@ -3,6 +3,7 @@
   <PropertyGroup>
     <TargetFrameworks>net8.0;net9.0;net10.0</TargetFrameworks>
     <Description>Source-generated, compile-time object mapping with support for custom property expressions and IQueryable projection.</Description>
+    <IsAotCompatible>true</IsAotCompatible>
   </PropertyGroup>
 
   <ItemGroup>

src/Arbiter.Mediation/Arbiter.Mediation.csproj

@@ -1,8 +1,9 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFrameworks>net8.0;net9.0;net10.0</TargetFrameworks>
     <Description>Simple mediator pattern implementation in .NET</Description>
+    <IsAotCompatible>true</IsAotCompatible>
   </PropertyGroup>
 
   <ItemGroup>

src/Arbiter.Mediation/IMediator.cs

@@ -54,6 +54,9 @@ namespace Arbiter.Mediation;
 /// </example>
 public interface IMediator
 {
+    private const string DynamicSendRequiresDynamicCode = "Non-generic mediator send requires runtime generic type construction. Use Send<TRequest, TResponse> when publishing with Native AOT.";
+    private const string DynamicSendRequiresUnreferencedCode = "Non-generic mediator send requires runtime type inspection. Use Send<TRequest, TResponse> when publishing a trimmed application.";
+
     /// <summary>
     /// Sends a request to the appropriate handler and returns the response.
     /// </summary>
@@ -76,6 +79,7 @@ public interface IMediator
     /// <param name="cancellationToken">Cancellation token.</param>
     /// <returns>Awaitable task returning the <typeparamref name="TResponse"/>.</returns>
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="request"/> is null.</exception>
+    [RequiresDynamicCode(DynamicSendRequiresDynamicCode)]
     ValueTask<TResponse?> Send<TResponse>(
         IRequest<TResponse> request,
         CancellationToken cancellationToken = default);
@@ -88,6 +92,8 @@ public interface IMediator
     /// <returns>Awaitable task returning the handler response.</returns>
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="request"/> is null.</exception>
     /// <exception cref="InvalidOperationException">Thrown when <paramref name="request"/> does not implement <see cref="IRequest{TResponse}"/> interface.</exception>
+    [RequiresDynamicCode(DynamicSendRequiresDynamicCode)]
+    [RequiresUnreferencedCode(DynamicSendRequiresUnreferencedCode)]
     ValueTask<object?> Send(
         object request,
         CancellationToken cancellationToken = default);

src/Arbiter.Mediation/Mediator.cs

@@ -1,5 +1,6 @@
 using System.Collections.Concurrent;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Metrics;
 
 using Microsoft.Extensions.DependencyInjection;
@@ -11,6 +12,9 @@ namespace Arbiter.Mediation;
 /// </summary>
 public sealed class Mediator : IMediator
 {
+    private const string DynamicSendRequiresDynamicCode = "Non-generic mediator send requires runtime generic type construction. Use Send<TRequest, TResponse> when publishing with Native AOT.";
+    private const string DynamicSendRequiresUnreferencedCode = "Non-generic mediator send requires runtime type inspection. Use Send<TRequest, TResponse> when publishing a trimmed application.";
+
     private static readonly ConcurrentDictionary<Type, IHandler> _handlerCache = new();
 
     private readonly IServiceProvider _serviceProvider;
@@ -93,6 +97,7 @@ public Mediator(IServiceProvider serviceProvider)
     }
 
     /// <inheritdoc />
+    [RequiresDynamicCode(DynamicSendRequiresDynamicCode)]
     public async ValueTask<TResponse?> Send<TResponse>(
         IRequest<TResponse> request,
         CancellationToken cancellationToken = default)
@@ -147,6 +152,8 @@ public Mediator(IServiceProvider serviceProvider)
     }
 
     /// <inheritdoc />
+    [RequiresDynamicCode(DynamicSendRequiresDynamicCode)]
+    [RequiresUnreferencedCode(DynamicSendRequiresUnreferencedCode)]
     public async ValueTask<object?> Send(
         object request,
         CancellationToken cancellationToken = default)

src/Arbiter.Services/Arbiter.Services.csproj

@@ -3,6 +3,7 @@
   <PropertyGroup>
     <TargetFrameworks>net8.0;net9.0;net10.0</TargetFrameworks>
     <Description>Arbiter utility services library providing CSV parsing, encryption, caching, token management, and URL building</Description>
+    <IsAotCompatible>true</IsAotCompatible>
   </PropertyGroup>
 
   <ItemGroup Condition="'$(TargetFramework)' == 'net8.0'">

src/Arbiter.Services/QueryStringEncoder.cs

@@ -1,6 +1,8 @@
 using System.Buffers.Text;
+using System.Diagnostics.CodeAnalysis;
 using System.IO.Compression;
 using System.Text.Json;
+using System.Text.Json.Serialization.Metadata;
 
 namespace Arbiter.Services;
 
@@ -9,13 +11,18 @@ namespace Arbiter.Services;
 /// </summary>
 public static class QueryStringEncoder
 {
+    private const string JsonSerializerOptionsRequiresDynamicCode = "JSON serialization with JsonSerializerOptions might require runtime code generation. Use the JsonTypeInfo<T> overload for Native AOT applications.";
+    private const string JsonSerializerOptionsRequiresUnreferencedCode = "JSON serialization with JsonSerializerOptions might require types that cannot be statically analyzed. Use the JsonTypeInfo<T> overload for trimmed applications.";
+
     /// <summary>
     /// Encodes a value to a query string format.
     /// </summary>
     /// <typeparam name="T">The type of the value</typeparam>
     /// <param name="value">The value to encode</param>
     /// <param name="options">The JSON options to use for serialization</param>
     /// <returns>A query string encode value</returns>
+    [RequiresDynamicCode(JsonSerializerOptionsRequiresDynamicCode)]
+    [RequiresUnreferencedCode(JsonSerializerOptionsRequiresUnreferencedCode)]
     public static string? Encode<T>(T value, JsonSerializerOptions? options = null)
     {
         if (value is null)
@@ -34,13 +41,40 @@ public static class QueryStringEncoder
         return Base64Url.EncodeToString(jsonBytes);
     }
 
+    /// <summary>
+    /// Encodes a value to a query string format using source-generated JSON metadata.
+    /// </summary>
+    /// <typeparam name="T">The type of the value</typeparam>
+    /// <param name="value">The value to encode</param>
+    /// <param name="jsonTypeInfo">The source-generated JSON metadata to use for serialization</param>
+    /// <returns>A query string encode value</returns>
+    public static string? Encode<T>(T value, JsonTypeInfo<T> jsonTypeInfo)
+    {
+        ArgumentNullException.ThrowIfNull(jsonTypeInfo);
+
+        if (value is null)
+            return null;
+
+        using var outputStream = new MemoryStream();
+        using var compressionStream = new BrotliStream(outputStream, CompressionLevel.Optimal);
+        using var jsonWriter = new Utf8JsonWriter(compressionStream);
+
+        JsonSerializer.Serialize(jsonWriter, value, jsonTypeInfo);
+
+        var jsonBytes = outputStream.ToArray();
+
+        return Base64Url.EncodeToString(jsonBytes);
+    }
+
     /// <summary>
     /// Decodes a query string value to its original format.
     /// </summary>
     /// <typeparam name="T">The type of the value</typeparam>
     /// <param name="encodedQueryString">The encoded query string format</param>
     /// <param name="options">The JSON options to use for serialization</param>
     /// <returns>The instance decoded from the query string format</returns>
+    [RequiresDynamicCode(JsonSerializerOptionsRequiresDynamicCode)]
+    [RequiresUnreferencedCode(JsonSerializerOptionsRequiresUnreferencedCode)]
     public static T? Decode<T>(string? encodedQueryString, JsonSerializerOptions? options = null)
     {
         if (string.IsNullOrWhiteSpace(encodedQueryString))
@@ -55,4 +89,26 @@ public static class QueryStringEncoder
 
         return JsonSerializer.Deserialize<T>(compressionStream, options);
     }
+
+    /// <summary>
+    /// Decodes a query string value to its original format using source-generated JSON metadata.
+    /// </summary>
+    /// <typeparam name="T">The type of the value</typeparam>
+    /// <param name="encodedQueryString">The encoded query string format</param>
+    /// <param name="jsonTypeInfo">The source-generated JSON metadata to use for serialization</param>
+    /// <returns>The instance decoded from the query string format</returns>
+    public static T? Decode<T>(string? encodedQueryString, JsonTypeInfo<T> jsonTypeInfo)
+    {
+        ArgumentNullException.ThrowIfNull(jsonTypeInfo);
+
+        if (string.IsNullOrWhiteSpace(encodedQueryString))
+            return default;
+
+        var jsonBytes = Base64Url.DecodeFromChars(encodedQueryString);
+
+        using var inputStream = new MemoryStream(jsonBytes);
+        using var compressionStream = new BrotliStream(inputStream, CompressionMode.Decompress);
+
+        return JsonSerializer.Deserialize(compressionStream, jsonTypeInfo);
+    }
 }

test/Arbiter.Mediation.Tests/MediatorTests.cs

@@ -107,6 +107,27 @@ public async Task SendWithBehaviorPipelineReflection()
         await Assert.That(logger.Messages[4]).Contains("Outer after");
     }
 
+    [Test]
+    public async Task SendWithInterfaceRequestType()
+    {
+        var logger = new Logger();
+
+        var services = new ServiceCollection();
+        services.AddMediator();
+
+        services.TryAddSingleton(logger);
+        services.TryAddTransient<IRequestHandler<Ping, Pong>, PingHandler>();
+
+        var provider = services.BuildServiceProvider();
+        var mediator = provider.GetRequiredService<IMediator>();
+
+        IRequest<Pong> request = new Ping { Message = "Ping" };
+        var response = await mediator.Send(request);
+
+        await Assert.That(response).IsNotNull();
+        await Assert.That(response!.Message).IsEqualTo("Ping Pong");
+    }
+
     [Test]
     public async Task SendWithBehaviorPipelineObjectType()
     {