[DEVEX-222] Simplified the message serializer implementation

Now serializer creates a derived serializer merging operation settings with default settings if needed. That allowed to hide internal details and there's no need to pass content type explicitly, as it's already in settings.

Extended SchemaRegistry to provide wrapper methods to naming resolution context. Thanks to that MessageSerializer doesn't need to reference it internally.

To make responsibilities clearer made also naming resolution context part of serializer context.

Author: oskardudycz

src/KurrentDB.Client/Core/KurrentDBClientSerializationSettings.cs

@@ -71,7 +71,7 @@ public class KurrentDBClientSerializationSettings {
 	/// });
 	/// </code>
 	/// </example>
-	public static KurrentDBClientSerializationSettings Default(
+	public static KurrentDBClientSerializationSettings Get(
 		Action<KurrentDBClientSerializationSettings>? configure = null
 	) {
 		var settings = new KurrentDBClientSerializationSettings();
@@ -280,6 +280,17 @@ public KurrentDBClientSerializationSettings UseMetadataType(Type type) {
 
 		return this;
 	}
+	/// <summary>
+	/// Configures which serialization format (JSON or binary) is used by default when writing messages
+	/// where the content type isn't explicitly specified. The default content type is "application/json"
+	/// </summary>
+	/// <param name="contentType">The serialization format content type</param>
+	/// <returns>The current instance for method chaining.</returns>
+	public KurrentDBClientSerializationSettings UseContentType(ContentType contentType) {
+		DefaultContentType = contentType;
+
+		return this;
+	}
 
 	/// <summary>
 	/// Creates a deep copy of the current serialization settings.

src/KurrentDB.Client/Core/KurrentDBClientSettings.cs

@@ -62,6 +62,6 @@ public partial class KurrentDBClientSettings {
 		/// Provides configuration options for messages serialization and deserialization in the KurrentDB client.
 		/// If null, default settings are used.
 		/// </summary>
-		public KurrentDBClientSerializationSettings Serialization  { get; set; } = KurrentDBClientSerializationSettings.Default();
+		public KurrentDBClientSerializationSettings Serialization  { get; set; } = KurrentDBClientSerializationSettings.Get();
 	}
 }

src/KurrentDB.Client/Core/Serialization/MessageSerializer.cs

@@ -11,78 +11,53 @@ interface IMessageSerializer {
 #else
 	public bool TryDeserialize(EventRecord record, [NotNullWhen(true)] out Message? deserialized);
 #endif
-}
 
-record MessageSerializationContext(
-	string StreamName,
-	ContentType ContentType
-) {
-	public string CategoryName =>
-		StreamName.Split('-').FirstOrDefault() ?? "no_stream_category";
+	public IMessageSerializer With(OperationSerializationSettings? operationSettings);
 }
 
+record MessageSerializationContext(MessageTypeNamingResolutionContext NamingResolution);
+
 static class MessageSerializerExtensions {
 	public static MessageData[] Serialize(
 		this IMessageSerializer serializer,
 		IEnumerable<Message> messages,
-		MessageSerializationContext context
-	) {
-		return messages.Select(m => serializer.Serialize(m, context)).ToArray();
-	}
-
-	public static IMessageSerializer With(
-		this IMessageSerializer defaultMessageSerializer,
-		KurrentDBClientSerializationSettings defaultSettings,
-		OperationSerializationSettings? operationSettings
-	) {
-		if (operationSettings == null)
-			return defaultMessageSerializer;
-
-		if (operationSettings.AutomaticDeserialization == AutomaticDeserialization.Disabled)
-			return NullMessageSerializer.Instance;
-
-		if (operationSettings.ConfigureSettings == null)
-			return defaultMessageSerializer;
-
-		var settings = defaultSettings.Clone();
-		operationSettings.ConfigureSettings.Invoke(settings);
-
-		return new MessageSerializer(SchemaRegistry.From(settings));
-	}
+		MessageSerializationContext serializationContext
+	) =>
+		messages.Select(m => serializer.Serialize(m, serializationContext)).ToArray();
 }
 
-class MessageSerializer(SchemaRegistry schemaRegistry) : IMessageSerializer {
+class MessageSerializer(SchemaRegistry schemaRegistry, KurrentDBClientSerializationSettings serializationSettings)
+	: IMessageSerializer {
 	readonly SystemTextJsonSerializer _metadataSerializer =
 		new SystemTextJsonSerializer(
 			new SystemTextJsonSerializationSettings { Options = KurrentDBClient.StreamMetadataJsonSerializerOptions }
 		);
 
-	readonly IMessageTypeNamingStrategy _messageTypeNamingStrategy =
-		schemaRegistry.MessageTypeNamingStrategy;
+	readonly string _contentType = serializationSettings.DefaultContentType.ToMessageContentType();
 
 	public MessageData Serialize(Message message, MessageSerializationContext serializationContext) {
 		var (data, metadata, messageId) = message;
 
-		var eventType = _messageTypeNamingStrategy
+		var messageType = schemaRegistry
 			.ResolveTypeName(
 				message.Data.GetType(),
-				new MessageTypeNamingResolutionContext(serializationContext.CategoryName)
+				serializationContext.NamingResolution
 			);
 
 		var serializedData = schemaRegistry
-			.GetSerializer(serializationContext.ContentType)
+			.GetSerializer(serializationSettings.DefaultContentType)
 			.Serialize(data);
 
 		var serializedMetadata = metadata != null
 			? _metadataSerializer.Serialize(metadata)
 			: ReadOnlyMemory<byte>.Empty;
 
 		return new MessageData(
-			eventType,
+			messageType,
 			serializedData,
 			serializedMetadata,
 			messageId,
-			serializationContext.ContentType.ToMessageContentType()
+			_contentType
 		);
 	}
 
@@ -91,7 +66,7 @@ public bool TryDeserialize(EventRecord record, out Message? deserialized) {
 #else
 	public bool TryDeserialize(EventRecord record, [NotNullWhen(true)] out Message? deserialized) {
 #endif
-		if (!TryResolveClrType(record, out var clrType)) {
+		if (!schemaRegistry.TryResolveClrType(record.EventType, out var clrType)) {
 			deserialized = null;
 			return false;
 		}
@@ -105,29 +80,36 @@ public bool TryDeserialize(EventRecord record, [NotNullWhen(true)] out Message?
 			return false;
 		}
 
-		object? metadata = record.Metadata.Length > 0 && TryResolveClrMetadataType(record, out var clrMetadataType)
+		object? metadata = record.Metadata.Length > 0
+		                && schemaRegistry.TryResolveClrMetadataType(record.EventType, out var clrMetadataType)
 			? _metadataSerializer.Deserialize(record.Metadata, clrMetadataType!)
 			: null;
 
 		deserialized = Message.From(data, metadata, record.EventId);
 		return true;
 	}
 
-	public static MessageSerializer From(KurrentDBClientSerializationSettings? settings = null) {
-		settings ??= KurrentDBClientSerializationSettings.Default();
+	public IMessageSerializer With(OperationSerializationSettings? operationSettings) {
+		if (operationSettings == null)
+			return this;
+
+		if (operationSettings.AutomaticDeserialization == AutomaticDeserialization.Disabled)
+			return NullMessageSerializer.Instance;
+
+		if (operationSettings.ConfigureSettings == null)
+			return this;
 
-		return new MessageSerializer(SchemaRegistry.From(settings));
+		var settings = serializationSettings.Clone();
+		operationSettings.ConfigureSettings.Invoke(settings);
+
+		return new MessageSerializer(SchemaRegistry.From(settings), settings);
 	}
 
-	bool TryResolveClrType(EventRecord record, out Type? clrType) =>
-		schemaRegistry
-			.MessageTypeNamingStrategy
-			.TryResolveClrType(record.EventType, out clrType);
+	public static MessageSerializer From(KurrentDBClientSerializationSettings? settings = null) {
+		settings ??= KurrentDBClientSerializationSettings.Get();
 
-	bool TryResolveClrMetadataType(EventRecord record, out Type? clrMetadataType) =>
-		schemaRegistry
-			.MessageTypeNamingStrategy
-			.TryResolveClrMetadataType(record.EventType, out clrMetadataType);
+		return new MessageSerializer(SchemaRegistry.From(settings), settings);
+	}
 }
 
 class NullMessageSerializer : IMessageSerializer {
@@ -145,4 +127,8 @@ public bool TryDeserialize(EventRecord eventRecord, [NotNullWhen(true)] out Mess
 		deserialized = null;
 		return false;
 	}
+
+	public IMessageSerializer With(OperationSerializationSettings? operationSettings) {
+		return this;
+	}
 }

src/KurrentDB.Client/Core/Serialization/MessageTypeResolutionStrategy.cs

@@ -11,16 +11,18 @@ public interface IMessageTypeNamingStrategy {
 #else
 	bool TryResolveClrType(string messageTypeName, [NotNullWhen(true)] out Type? type);
 #endif
-	
-	
+
 #if NET48
 	bool TryResolveClrMetadataType(string messageTypeName, out Type? type);
 #else
 	bool TryResolveClrMetadataType(string messageTypeName, [NotNullWhen(true)] out Type? type);
 #endif
 }
 
-public record MessageTypeNamingResolutionContext(string CategoryName);
+public record MessageTypeNamingResolutionContext(string CategoryName) {
+	public static MessageTypeNamingResolutionContext FromStreamName(string streamName) =>
+		new(streamName.Split('-').FirstOrDefault() ?? "no_stream_category");
+}
 
 class MessageTypeNamingStrategyWrapper(
 	IMessageTypeRegistry messageTypeRegistry,
@@ -66,9 +68,9 @@ public bool TryResolveClrMetadataType(string messageTypeName, [NotNullWhen(true)
 
 public class DefaultMessageTypeNamingStrategy(Type? defaultMetadataType) : IMessageTypeNamingStrategy {
 	readonly Type _defaultMetadataType = defaultMetadataType ?? typeof(TracingMetadata);
-	
+
 	public string ResolveTypeName(Type messageType, MessageTypeNamingResolutionContext resolutionContext) =>
-		$"{resolutionContext.CategoryName}-{messageType.FullName}"; 
+		$"{resolutionContext.CategoryName}-{messageType.FullName}";
 
 #if NET48
 	public bool TryResolveClrType(string messageTypeName, out Type? type) {
@@ -83,7 +85,7 @@ public bool TryResolveClrType(string messageTypeName, [NotNullWhen(true)] out Ty
 		}
 
 		var clrTypeName = messageTypeName[(categorySeparatorIndex + 1)..];
-		
+
 		type = TypeProvider.GetTypeByFullName(clrTypeName);
 
 		return type != null;

src/KurrentDB.Client/Core/Serialization/SchemaRegistry.cs

@@ -1,4 +1,4 @@
-using KurrentDB.Client;
+using System.Diagnostics.CodeAnalysis;
 
 namespace KurrentDB.Client.Core.Serialization;
 
@@ -30,11 +30,26 @@ class SchemaRegistry(
 	IDictionary<ContentType, ISerializer> serializers,
 	IMessageTypeNamingStrategy messageTypeNamingStrategy
 ) {
-	public IMessageTypeNamingStrategy MessageTypeNamingStrategy { get; } = messageTypeNamingStrategy;
-
 	public ISerializer GetSerializer(ContentType schemaType) =>
 		serializers[schemaType];
 
+	public string ResolveTypeName(Type messageType, MessageTypeNamingResolutionContext resolutionContext) =>
+		messageTypeNamingStrategy.ResolveTypeName(messageType, resolutionContext);
+
+#if NET48
+	public bool TryResolveClrType(string messageTypeName, out Type? type) =>
+#else
+	public bool TryResolveClrType(string messageTypeName, [NotNullWhen(true)] out Type? type) =>
+#endif
+		messageTypeNamingStrategy.TryResolveClrType(messageTypeName, out type);
+
+#if NET48
+	public bool TryResolveClrMetadataType(string messageTypeName, out Type? type) =>
+#else
+	public bool TryResolveClrMetadataType(string messageTypeName, [NotNullWhen(true)] out Type? type) =>
+#endif
+		messageTypeNamingStrategy.TryResolveClrMetadataType(messageTypeName, out type);
+
 	public static SchemaRegistry From(KurrentDBClientSerializationSettings settings) {
 		var messageTypeNamingStrategy =
 			settings.MessageTypeNamingStrategy ?? new DefaultMessageTypeNamingStrategy(settings.DefaultMetadataType);

src/KurrentDB.Client/PersistentSubscriptions/KurrentDBPersistentSubscriptionsClient.Read.cs

@@ -269,7 +269,7 @@ public PersistentSubscriptionResult SubscribeToStream(
 				new() { Options = readOptions },
 				Settings,
 				options.UserCredentials,
-				_messageSerializer.With(Settings.Serialization, options.SerializationSettings),
+				_messageSerializer.With(options.SerializationSettings),
 				cancellationToken
 			);
 		}

src/KurrentDB.Client/Streams/KurrentDBClient.Append.cs

@@ -12,6 +12,7 @@
 using Kurrent.Diagnostics.Tracing;
 using static EventStore.Client.Streams.AppendResp.Types.WrongExpectedVersion;
 using static EventStore.Client.Streams.Streams;
+using static KurrentDB.Client.Core.Serialization.MessageTypeNamingResolutionContext;
 
 namespace KurrentDB.Client {
 	public partial class KurrentDBClient {
@@ -31,19 +32,17 @@ public Task<IWriteResult> AppendToStreamAsync(
 			AppendToStreamOptions? options = null,
 			CancellationToken cancellationToken = default
 		) {
-			var serializationContext 
-				= new MessageSerializationContext(streamName, Settings.Serialization.DefaultContentType);
-
-			var messageSerializer = _messageSerializer.With(Settings.Serialization, options?.SerializationSettings);
-
-			var messageData = messageSerializer.Serialize(messages, serializationContext);
+			var messageSerializationContext = new MessageSerializationContext(FromStreamName(streamName));
+			
+			var messageData = _messageSerializer.With(options?.SerializationSettings)
+				.Serialize(messages, messageSerializationContext);
 
 			return AppendToStreamAsync(streamName, expectedState, messageData, options, cancellationToken);
 		}
 
 		/// <summary>
 		/// Appends events asynchronously to a stream using raw message data.
-		/// If you want to use auto-serialization, use overload with <see cref="KurrentDB.Client.Core.Serialization.Message"/>.</param>.
+		/// If you want to use auto-serialization, use overload with <see cref="Message"/>.</param>.
 		/// This method intends to cover low-level scenarios in which you want to have full control of the serialization mechanism.
 		/// </summary>
 		/// <param name="streamName">The name of the stream to append events to.</param>

src/KurrentDB.Client/Streams/KurrentDBClient.Read.cs

@@ -52,7 +52,7 @@ public ReadAllStreamResult ReadAllAsync(
 				readReq,
 				Settings,
 				options,
-				_messageSerializer.With(Settings.Serialization, options.SerializationSettings),
+				_messageSerializer.With(options.SerializationSettings),
 				cancellationToken
 			);
 		}
@@ -229,7 +229,7 @@ public ReadStreamResult ReadStreamAsync(
 				Settings,
 				options.Deadline,
 				options.UserCredentials,
-				_messageSerializer.With(Settings.Serialization, options.SerializationSettings),
+				_messageSerializer.With(options.SerializationSettings),
 				cancellationToken
 			);
 		}

src/KurrentDB.Client/Streams/KurrentDBClient.Subscriptions.cs

@@ -190,7 +190,7 @@ public StreamSubscriptionResult SubscribeToAll(
 			},
 			Settings,
 			options.UserCredentials,
-			_messageSerializer.With(Settings.Serialization, options.SerializationSettings),
+			_messageSerializer.With(options.SerializationSettings),
 			cancellationToken
 		);
 
@@ -329,7 +329,7 @@ public StreamSubscriptionResult SubscribeToStream(
 			},
 			Settings,
 			options.UserCredentials,
-			_messageSerializer.With(Settings.Serialization, options.SerializationSettings),
+			_messageSerializer.With(options.SerializationSettings),
 			cancellationToken
 		);