refactor: replace cross-assembly internal sharing with same-assembly-only dedup

Author: Vulthil

src/Vulthil.Messaging.Outbox/BrokerOutboxDispatcher.cs

@@ -30,6 +30,7 @@ internal sealed class BrokerOutboxDispatcher(
             && method.IsGenericMethodDefinition
             && method.GetParameters().Length == 3);
 
+    private static readonly ConcurrentDictionary<string, Type> TypeCache = [];
     private static readonly ConcurrentDictionary<Type, MethodInfo> PublishByType = [];
     private static readonly ConcurrentDictionary<Type, MethodInfo> SendByType = [];
 
@@ -38,7 +39,7 @@ public bool Handles(OutboxDestination destination) =>
 
     public async Task DispatchAsync(OutboxMessageData message, CancellationToken cancellationToken)
     {
-        var messageType = OutboxMessageTypeResolver.Resolve(message.Type, "message");
+        var messageType = ResolveType(message.Type);
         var payload = JsonSerializer.Deserialize(message.Content, messageType, messageConfigurationProvider.JsonSerializerOptions)!;
         var metadata = message.Metadata is null
             ? null
@@ -92,4 +93,16 @@ private static void Apply(BrokerOutboxMetadata? metadata, IPublishContext contex
             context.AddHeaders(headers);
         }
     }
+
+    private static Type ResolveType(string typeName) => TypeCache.GetOrAdd(typeName, static name =>
+    {
+        var type = Type.GetType(name)
+            ?? AppDomain.CurrentDomain.GetAssemblies()
+                .Select(assembly => assembly.GetType(name))
+                .FirstOrDefault(found => found is not null);
+
+        return type ?? throw new InvalidOperationException(
+            $"Unable to resolve the message type '{name}' for an outbox relay. " +
+            "Ensure the assembly that defines the type is loaded in the relay process.");
+    });
 }

src/Vulthil.Messaging.RabbitMq/Consumers/MessageContextFactory.cs

@@ -91,26 +91,28 @@ private static MessageContext<TMessage> BuildTypedMetadata<TMessage>(
         CancellationToken cancellationToken)
     {
         var metadata = ExtractMetadata(ea);
-        return MessageContext.BuildTyped(
-            message,
-            publisher,
-            sendEndpointProvider,
-            metadata.MessageId,
-            metadata.CorrelationId,
-            metadata.RequestId,
-            metadata.RoutingKey,
-            metadata.Headers,
-            metadata.Redelivered,
-            metadata.RetryCount,
-            metadata.ConversationId,
-            metadata.InitiatorId,
-            metadata.SourceAddress,
-            metadata.DestinationAddress,
-            metadata.ResponseAddress,
-            metadata.FaultAddress,
-            metadata.SentTime,
-            metadata.ExpirationTime,
-            cancellationToken);
+        return new MessageContext<TMessage>
+        {
+            Message = message,
+            Publisher = publisher,
+            SendEndpointProvider = sendEndpointProvider,
+            CancellationToken = cancellationToken,
+            MessageId = metadata.MessageId,
+            CorrelationId = metadata.CorrelationId,
+            RequestId = metadata.RequestId,
+            RoutingKey = metadata.RoutingKey,
+            Headers = metadata.Headers,
+            Redelivered = metadata.Redelivered,
+            RetryCount = metadata.RetryCount,
+            ConversationId = metadata.ConversationId,
+            InitiatorId = metadata.InitiatorId,
+            SourceAddress = metadata.SourceAddress,
+            DestinationAddress = metadata.DestinationAddress,
+            ResponseAddress = metadata.ResponseAddress,
+            FaultAddress = metadata.FaultAddress,
+            SentTime = metadata.SentTime,
+            ExpirationTime = metadata.ExpirationTime,
+        };
     }
 
     /// <summary>

src/Vulthil.Messaging/Transport/MessageContext.cs

@@ -110,76 +110,30 @@ public static MessageContext<TMessage> CreateFromEnvelope<TMessage>(
             userHeaders[key] = HeaderValueNormalizer.Normalize(value);
         }
 
-        return BuildTyped(
-            message,
-            publisher,
-            sendEndpointProvider,
-            envelope.MessageId,
-            envelope.CorrelationId ?? string.Empty,
-            envelope.RequestId ?? envelope.CorrelationId,
-            routingKey,
-            userHeaders,
-            redelivered,
-            retryCount,
-            envelope.ConversationId,
-            envelope.InitiatorId,
-            ParseAddress(envelope.SourceAddress),
-            ParseAddress(envelope.DestinationAddress),
-            ParseAddress(envelope.ResponseAddress)
-                ?? (string.IsNullOrEmpty(replyToFallback) ? null : new Uri($"queue:{replyToFallback}")),
-            ParseAddress(envelope.FaultAddress),
-            envelope.SentTime,
-            envelope.ExpirationTime,
-            cancellationToken);
-    }
-
-    /// <summary>
-    /// Constructs a live typed <see cref="MessageContext{TMessage}"/> from already-resolved metadata. Shared by
-    /// <see cref="CreateFromEnvelope{TMessage}"/> (the standard envelope receive path) and the RabbitMQ transport's
-    /// bare-JSON compat path, which resolve these values from their own wire representations — a parsed
-    /// <see cref="MessageEnvelope"/> versus raw AMQP properties/headers — before delegating the final mapping here.
-    /// </summary>
-    internal static MessageContext<TMessage> BuildTyped<TMessage>(
-        TMessage message,
-        IPublisher? publisher,
-        ISendEndpointProvider? sendEndpointProvider,
-        string? messageId,
-        string? correlationId,
-        string? requestId,
-        string routingKey,
-        IReadOnlyDictionary<string, object?> headers,
-        bool redelivered,
-        int retryCount,
-        string? conversationId,
-        string? initiatorId,
-        Uri? sourceAddress,
-        Uri? destinationAddress,
-        Uri? responseAddress,
-        Uri? faultAddress,
-        DateTimeOffset? sentTime,
-        DateTimeOffset? expirationTime,
-        CancellationToken cancellationToken) => new MessageContext<TMessage>
+        return new MessageContext<TMessage>
         {
             Message = message,
             Publisher = publisher,
             SendEndpointProvider = sendEndpointProvider,
             CancellationToken = cancellationToken,
-            MessageId = messageId,
-            CorrelationId = correlationId,
-            RequestId = requestId,
+            MessageId = envelope.MessageId,
+            CorrelationId = envelope.CorrelationId ?? string.Empty,
+            RequestId = envelope.RequestId ?? envelope.CorrelationId,
             RoutingKey = routingKey,
-            Headers = headers,
+            Headers = userHeaders,
             Redelivered = redelivered,
             RetryCount = retryCount,
-            ConversationId = conversationId,
-            InitiatorId = initiatorId,
-            SourceAddress = sourceAddress,
-            DestinationAddress = destinationAddress,
-            ResponseAddress = responseAddress,
-            FaultAddress = faultAddress,
-            SentTime = sentTime,
-            ExpirationTime = expirationTime,
+            ConversationId = envelope.ConversationId,
+            InitiatorId = envelope.InitiatorId,
+            SourceAddress = ParseAddress(envelope.SourceAddress),
+            DestinationAddress = ParseAddress(envelope.DestinationAddress),
+            ResponseAddress = ParseAddress(envelope.ResponseAddress)
+                ?? (string.IsNullOrEmpty(replyToFallback) ? null : new Uri($"queue:{replyToFallback}")),
+            FaultAddress = ParseAddress(envelope.FaultAddress),
+            SentTime = envelope.SentTime,
+            ExpirationTime = envelope.ExpirationTime,
         };
+    }
 
     /// <summary>
     /// Auto-propagates correlation metadata (correlation, conversation, initiator) from this incoming context onto

src/Vulthil.Messaging/Vulthil.Messaging.csproj

@@ -17,10 +17,4 @@
 	  <ProjectReference Include="..\Vulthil.Messaging.Abstractions\Vulthil.Messaging.Abstractions.csproj" />
 	</ItemGroup>
 
-	<ItemGroup>
-		<!-- The RabbitMQ transport's bare-JSON compat receive path shares MessageContext's internal typed-context
-		     builder instead of duplicating the envelope-receive mapping. -->
-		<InternalsVisibleTo Include="Vulthil.Messaging.RabbitMq" />
-	</ItemGroup>
-
 </Project>

src/Vulthil.SharedKernel.Outbox/DomainEventOutboxDispatcher.cs

@@ -1,3 +1,4 @@
+using System.Collections.Concurrent;
 using System.Text.Json;
 using Vulthil.SharedKernel.Application.Messaging.DomainEvents;
 
@@ -10,13 +11,27 @@ namespace Vulthil.SharedKernel.Outbox;
 /// </summary>
 internal sealed class DomainEventOutboxDispatcher(IDomainEventPublisher domainEventPublisher) : IOutboxDispatcher
 {
+    private static readonly ConcurrentDictionary<string, Type> _typeCache = [];
+
     public bool Handles(OutboxDestination destination) => destination == OutboxDestination.DomainEvent;
 
     public async Task DispatchAsync(OutboxMessageData message, CancellationToken cancellationToken)
     {
-        var messageType = OutboxMessageTypeResolver.Resolve(message.Type, "domain-event");
+        var messageType = GetOrAddMessageType(message.Type);
         var domainEvent = JsonSerializer.Deserialize(message.Content, messageType)!;
 
         await domainEventPublisher.PublishAsync(domainEvent, cancellationToken);
     }
+
+    private static Type GetOrAddMessageType(string typeName) => _typeCache.GetOrAdd(typeName, static t =>
+    {
+        var type = Type.GetType(t)
+            ?? AppDomain.CurrentDomain.GetAssemblies()
+                .Select(a => a.GetType(t))
+                .FirstOrDefault(found => found is not null);
+
+        return type ?? throw new InvalidOperationException(
+            $"Unable to resolve the domain-event type '{t}' for an outbox relay. " +
+            "Ensure the assembly that defines the type is loaded in the relay process.");
+    });
 }

src/Vulthil.SharedKernel.Outbox/OutboxMessageTypeResolver.cs

@@ -18,10 +18,4 @@
 		<ProjectReference Include="..\Vulthil.SharedKernel.Application\Vulthil.SharedKernel.Application.csproj" />
 	</ItemGroup>
 
-	<ItemGroup>
-		<!-- Vulthil.Messaging.Outbox's BrokerOutboxDispatcher shares OutboxMessageTypeResolver with this
-		     assembly's DomainEventOutboxDispatcher instead of duplicating the type-resolution cache. -->
-		<InternalsVisibleTo Include="Vulthil.Messaging.Outbox" />
-	</ItemGroup>
-
 </Project>