[DEVEX-222] Nested Message type mapping into settings object

Author: oskardudycz

src/KurrentDB.Client/Core/KurrentDBClientSerializationSettings.cs

@@ -38,23 +38,7 @@ public class KurrentDBClientSerializationSettings {
 	/// </summary>
 	public IMessageTypeNamingStrategy? MessageTypeNamingStrategy { get; set; }
 
-	/// <summary>
-	/// Allows to register mapping of CLR message types to their corresponding message type names used in serialized messages.
-	/// </summary>
-	public IDictionary<string, Type> MessageTypeMap { get; set; } = new Dictionary<string, Type>();
-
-	/// <summary>
-	/// Registers CLR message types that can be appended to the specific stream category.
-	/// Types will have message type names resolved based on the used <see cref="KurrentDB.Client.Core.Serialization.IMessageTypeNamingStrategy"/>
-	/// </summary>
-	public IDictionary<string, Type[]> CategoryMessageTypesMap { get; set; } = new Dictionary<string, Type[]>();
-
-	/// <summary>
-	/// Specifies the CLR type that should be used when deserializing metadata for all events.
-	/// When set, the client will attempt to deserialize event metadata into this type.
-	/// If not provided, <see cref="Kurrent.Diagnostics.Tracing.TracingMetadata"/> will be used.
-	/// </summary>
-	public Type? DefaultMetadataType { get; set; }
+	public MessageTypeMappingSettings MessageTypeMapping { get; set; } = new MessageTypeMappingSettings();
 
 	/// <summary>
 	/// Creates a new instance of serialization settings with either default values or custom configuration.
@@ -181,113 +165,24 @@ IMessageTypeNamingStrategy messageTypeNamingStrategy
 	}
 
 	/// <summary>
-	/// Associates a message type with a specific stream category to enable automatic deserialization.
-	/// In event sourcing, streams are often prefixed with a category (e.g., "user-123", "order-456").
-	/// This method tells the client which message types can appear in streams of a given category.
-	/// </summary>
-	/// <typeparam name="T">The event or message type that can appear in the category's streams.</typeparam>
-	/// <param name="categoryName">The category prefix (e.g., "user", "order", "account").</param>
-	/// <returns>The current instance for method chaining.</returns>
-	/// <example>
-	/// <code>
-	/// // Register event types that can appear in user streams
-	/// settings.RegisterMessageTypeForCategory&lt;UserCreated&gt;("user")
-	///        .RegisterMessageTypeForCategory&lt;UserUpdated&gt;("user")
-	///        .RegisterMessageTypeForCategory&lt;UserDeleted&gt;("user");
-	/// </code>
-	/// </example>
-	public KurrentDBClientSerializationSettings RegisterMessageTypeForCategory<T>(string categoryName) =>
-		RegisterMessageTypeForCategory(categoryName, typeof(T));
-
-	/// <summary>
-	/// Registers multiple message types for a specific stream category.
-	/// </summary>
-	/// <param name="categoryName">The category name to register the types with.</param>
-	/// <param name="types">The message types to register.</param>
-	/// <returns>The current instance for method chaining.</returns>
-	public KurrentDBClientSerializationSettings RegisterMessageTypeForCategory(string categoryName, params Type[] types) {
-		CategoryMessageTypesMap[categoryName] = CategoryMessageTypesMap.TryGetValue(categoryName, out var current)
-			? [..current, ..types]
-			: types;
-
-		return this;
-	}
-
-	/// <summary>
-	/// Maps a .NET type to a specific message type name that will be stored in the message metadata.
-	/// This mapping is used during automatic deserialization, as it tells the client which CLR type
-	/// to instantiate when encountering a message with a particular type name in the database.
-	/// </summary>
-	/// <typeparam name="T">The .NET type to register (typically a message class).</typeparam>
-	/// <param name="typeName">The string identifier to use for this type in the database.</param>
-	/// <returns>The current instance for method chaining.</returns>
-	/// <remarks>
-	/// The type name is often different from the .NET type name to support versioning and evolution
-	/// of your domain model without breaking existing stored messages.
-	/// </remarks>
-	/// <example>
-	/// <code>
-	/// // Register me types with their corresponding type identifiers
-	/// settings.RegisterMessageType&lt;UserCreated&gt;("user-created-v1")
-	///        .RegisterMessageType&lt;OrderPlaced&gt;("order-placed-v2");
-	/// </code>
-	/// </example>
-	public KurrentDBClientSerializationSettings RegisterMessageType<T>(string typeName) =>
-		RegisterMessageType(typeName, typeof(T));
-
-	/// <summary>
-	/// Registers a message type with a specific type name.
-	/// </summary>
-	/// <param name="type">The message type to register.</param>
-	/// <param name="typeName">The type name to register for the message type.</param>
-	/// <returns>The current instance for method chaining.</returns>
-	public KurrentDBClientSerializationSettings RegisterMessageType(string typeName, Type type) {
-		MessageTypeMap[typeName] = type;
-
-		return this;
-	}
-
-	/// <summary>
-	/// Registers multiple message types with their corresponding type names.
+	/// 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="typeMap">Dictionary mapping types to their type names.</param>
+	/// <param name="contentType">The serialization format content type</param>
 	/// <returns>The current instance for method chaining.</returns>
-	public KurrentDBClientSerializationSettings RegisterMessageTypes(IDictionary<string, Type> typeMap) {
-		foreach (var map in typeMap) {
-			MessageTypeMap[map.Key] = map.Value;
-		}
+	public KurrentDBClientSerializationSettings UseContentType(ContentType contentType) {
+		DefaultContentType = contentType;
 
 		return this;
 	}
 
 	/// <summary>
-	/// Configures a strongly-typed metadata class for all mes in the system.
-	/// This enables accessing metadata properties in a type-safe manner rather than using dynamic objects.
-	/// </summary>
-	/// <typeparam name="T">The metadata class type containing properties matching the expected metadata fields.</typeparam>
-	/// <returns>The current instance for method chaining.</returns>
-	public KurrentDBClientSerializationSettings UseMetadataType<T>() =>
-		UseMetadataType(typeof(T));
-
-	/// <summary>
-	/// Configures a strongly-typed metadata class for all mes in the system.
-	/// This enables accessing metadata properties in a type-safe manner rather than using dynamic objects.
-	/// </summary>
-	/// <param name="type">The metadata class type containing properties matching the expected metadata fields.</param>
-	/// <returns>The current instance for method chaining.</returns>
-	public KurrentDBClientSerializationSettings UseMetadataType(Type type) {
-		DefaultMetadataType = 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"
+	/// Allows to configure message type mapping
 	/// </summary>
-	/// <param name="contentType">The serialization format content type</param>
+	/// <param name="configure"></param>
 	/// <returns>The current instance for method chaining.</returns>
-	public KurrentDBClientSerializationSettings UseContentType(ContentType contentType) {
-		DefaultContentType = contentType;
+	public KurrentDBClientSerializationSettings ConfigureTypeMap(Action<MessageTypeMappingSettings> configure) {
+		configure(MessageTypeMapping);
 
 		return this;
 	}
@@ -301,8 +196,7 @@ internal KurrentDBClientSerializationSettings Clone() {
 			BytesSerializer           = BytesSerializer,
 			JsonSerializer            = JsonSerializer,
 			DefaultContentType        = DefaultContentType,
-			MessageTypeMap            = new Dictionary<string, Type>(MessageTypeMap),
-			CategoryMessageTypesMap   = new Dictionary<string, Type[]>(CategoryMessageTypesMap),
+			MessageTypeMapping            = MessageTypeMapping.Clone(),
 			MessageTypeNamingStrategy = MessageTypeNamingStrategy
 		};
 	}
@@ -369,3 +263,134 @@ public enum AutomaticDeserialization {
 	/// </summary>
 	Enabled = 1
 }
+
+/// <summary>
+/// Represents message type mapping settings
+/// </summary>
+public class MessageTypeMappingSettings {
+	/// <summary>
+	/// Allows to register mapping of CLR message types to their corresponding message type names used in serialized messages.
+	/// </summary>
+	public IDictionary<string, Type> TypeMap { get; set; } = new Dictionary<string, Type>();
+
+	/// <summary>
+	/// Registers CLR message types that can be appended to the specific stream category.
+	/// Types will have message type names resolved based on the used <see cref="KurrentDB.Client.Core.Serialization.IMessageTypeNamingStrategy"/>
+	/// </summary>
+	public IDictionary<string, Type[]> CategoryTypesMap { get; set; } = new Dictionary<string, Type[]>();
+
+	/// <summary>
+	/// Specifies the CLR type that should be used when deserializing metadata for all events.
+	/// When set, the client will attempt to deserialize event metadata into this type.
+	/// If not provided, <see cref="Kurrent.Diagnostics.Tracing.TracingMetadata"/> will be used.
+	/// </summary>
+	public Type? DefaultMetadataType { get; set; }
+
+	/// <summary>
+	/// Associates a message type with a specific stream category to enable automatic deserialization.
+	/// In event sourcing, streams are often prefixed with a category (e.g., "user-123", "order-456").
+	/// This method tells the client which message types can appear in streams of a given category.
+	/// </summary>
+	/// <typeparam name="T">The event or message type that can appear in the category's streams.</typeparam>
+	/// <param name="categoryName">The category prefix (e.g., "user", "order", "account").</param>
+	/// <returns>The current instance for method chaining.</returns>
+	/// <example>
+	/// <code>
+	/// // Register event types that can appear in user streams
+	/// settings.RegisterMessageTypeForCategory&lt;UserCreated&gt;("user")
+	///        .RegisterMessageTypeForCategory&lt;UserUpdated&gt;("user")
+	///        .RegisterMessageTypeForCategory&lt;UserDeleted&gt;("user");
+	/// </code>
+	/// </example>
+	public MessageTypeMappingSettings RegisterForCategory<T>(string categoryName) =>
+		RegisterForCategory(categoryName, typeof(T));
+
+	/// <summary>
+	/// Registers multiple message types for a specific stream category.
+	/// </summary>
+	/// <param name="categoryName">The category name to register the types with.</param>
+	/// <param name="types">The message types to register.</param>
+	/// <returns>The current instance for method chaining.</returns>
+	public MessageTypeMappingSettings RegisterForCategory(string categoryName, params Type[] types) {
+		CategoryTypesMap[categoryName] =
+			CategoryTypesMap.TryGetValue(categoryName, out var current)
+				? [..current, ..types]
+				: types;
+
+		return this;
+	}
+
+	/// <summary>
+	/// Maps a .NET type to a specific message type name that will be stored in the message metadata.
+	/// This mapping is used during automatic deserialization, as it tells the client which CLR type
+	/// to instantiate when encountering a message with a particular type name in the database.
+	/// </summary>
+	/// <typeparam name="T">The .NET type to register (typically a message class).</typeparam>
+	/// <param name="typeName">The string identifier to use for this type in the database.</param>
+	/// <returns>The current instance for method chaining.</returns>
+	/// <remarks>
+	/// The type name is often different from the .NET type name to support versioning and evolution
+	/// of your domain model without breaking existing stored messages.
+	/// </remarks>
+	/// <example>
+	/// <code>
+	/// // Register me types with their corresponding type identifiers
+	/// settings.RegisterMessageType&lt;UserCreated&gt;("user-created-v1")
+	///        .RegisterMessageType&lt;OrderPlaced&gt;("order-placed-v2");
+	/// </code>
+	/// </example>
+	public MessageTypeMappingSettings Register<T>(string typeName) =>
+		Register(typeName, typeof(T));
+
+	/// <summary>
+	/// Registers a message type with a specific type name.
+	/// </summary>
+	/// <param name="type">The message type to register.</param>
+	/// <param name="typeName">The type name to register for the message type.</param>
+	/// <returns>The current instance for method chaining.</returns>
+	public MessageTypeMappingSettings Register(string typeName, Type type) {
+		TypeMap[typeName] = type;
+
+		return this;
+	}
+
+	/// <summary>
+	/// Registers multiple message types with their corresponding type names.
+	/// </summary>
+	/// <param name="typeMap">Dictionary mapping types to their type names.</param>
+	/// <returns>The current instance for method chaining.</returns>
+	public MessageTypeMappingSettings Register(IDictionary<string, Type> typeMap) {
+		foreach (var map in typeMap) {
+			TypeMap[map.Key] = map.Value;
+		}
+
+		return this;
+	}
+
+	/// <summary>
+	/// Configures a strongly-typed metadata class for all mes in the system.
+	/// This enables accessing metadata properties in a type-safe manner rather than using dynamic objects.
+	/// </summary>
+	/// <typeparam name="T">The metadata class type containing properties matching the expected metadata fields.</typeparam>
+	/// <returns>The current instance for method chaining.</returns>
+	public MessageTypeMappingSettings UseMetadataType<T>() =>
+		UseMetadataType(typeof(T));
+
+	/// <summary>
+	/// Configures a strongly-typed metadata class for all mes in the system.
+	/// This enables accessing metadata properties in a type-safe manner rather than using dynamic objects.
+	/// </summary>
+	/// <param name="type">The metadata class type containing properties matching the expected metadata fields.</param>
+	/// <returns>The current instance for method chaining.</returns>
+	public MessageTypeMappingSettings UseMetadataType(Type type) {
+		DefaultMetadataType = type;
+
+		return this;
+	}
+
+	internal MessageTypeMappingSettings Clone() =>
+		new MessageTypeMappingSettings {
+			TypeMap          = new Dictionary<string, Type>(TypeMap),
+			CategoryTypesMap = new Dictionary<string, Type[]>(CategoryTypesMap),
+		};
+}

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

@@ -52,15 +52,16 @@ public bool TryResolveClrMetadataType(EventRecord record, [NotNullWhen(true)] ou
 
 	public static SchemaRegistry From(KurrentDBClientSerializationSettings settings) {
 		var messageTypeNamingStrategy =
-			settings.MessageTypeNamingStrategy ?? new DefaultMessageTypeNamingStrategy(settings.DefaultMetadataType);
+			settings.MessageTypeNamingStrategy
+		 ?? new DefaultMessageTypeNamingStrategy(settings.MessageTypeMapping.DefaultMetadataType);
 
 		var categoriesTypeMap = ResolveMessageTypeUsingNamingStrategy(
-			settings.CategoryMessageTypesMap,
+			settings.MessageTypeMapping,
 			messageTypeNamingStrategy
 		);
 
 		var messageTypeRegistry = new MessageTypeRegistry();
-		messageTypeRegistry.Register(settings.MessageTypeMap);
+		messageTypeRegistry.Register(settings.MessageTypeMapping.TypeMap);
 		messageTypeRegistry.Register(categoriesTypeMap);
 
 		var serializers = new Dictionary<ContentType, ISerializer> {
@@ -77,16 +78,17 @@ public static SchemaRegistry From(KurrentDBClientSerializationSettings settings)
 			serializers,
 			new MessageTypeNamingStrategyWrapper(
 				messageTypeRegistry,
-				settings.MessageTypeNamingStrategy ?? new DefaultMessageTypeNamingStrategy(settings.DefaultMetadataType)
+				settings.MessageTypeNamingStrategy
+			 ?? new DefaultMessageTypeNamingStrategy(settings.MessageTypeMapping.DefaultMetadataType)
 			)
 		);
 	}
 
 	static Dictionary<string, Type> ResolveMessageTypeUsingNamingStrategy(
-		IDictionary<string, Type[]> categoryMessageTypesMap,
+		MessageTypeMappingSettings messageTypeMappingSettings,
 		IMessageTypeNamingStrategy messageTypeNamingStrategy
 	) =>
-		categoryMessageTypesMap
+		messageTypeMappingSettings.CategoryTypesMap
 			.SelectMany(
 				categoryTypes => categoryTypes.Value.Select(
 					type =>

test/KurrentDB.Client.Tests/Core/Serialization/MessageSerializerTests.cs

@@ -276,7 +276,7 @@ public void With_ConfigureSettings_CreatesNewMessageSerializer() {
 
 		var operationSettings = OperationSerializationSettings.Configure(
 			s =>
-				s.RegisterMessageType<UserRegistered>("CustomMessageName")
+				s.MessageTypeMapping.Register<UserRegistered>("CustomMessageName")
 		);
 
 		// When
@@ -309,9 +309,10 @@ public void Serialize_WithMultipleMessages_ReturnsArrayOfMessageData() {
 
 	static KurrentDBClientSerializationSettings CreateTestSettings() {
 		var settings = new KurrentDBClientSerializationSettings();
-		settings.RegisterMessageType<UserRegistered>("UserRegistered");
-		settings.RegisterMessageType<UserAssignedToRole>("UserAssignedToRole");
-		settings.UseMetadataType<TestMetadata>();
+		settings.MessageTypeMapping
+			.Register<UserRegistered>("UserRegistered")
+			.Register<UserAssignedToRole>("UserAssignedToRole")
+			.UseMetadataType<TestMetadata>();
 
 		return settings;
 	}

test/KurrentDB.Client.Tests/Core/Serialization/SchemaRegistryTests.cs

@@ -101,8 +101,8 @@ public void From_WithCustomBytesSerializer_UsesProvidedSerializer() {
 	public void From_WithMessageTypeMap_RegistersTypes() {
 		// Given
 		var settings = new KurrentDBClientSerializationSettings();
-		settings.RegisterMessageType<TestEvent1>("test-event-1");
-		settings.RegisterMessageType<TestEvent2>("test-event-2");
+		settings.MessageTypeMapping.Register<TestEvent1>("test-event-1");
+		settings.MessageTypeMapping.Register<TestEvent2>("test-event-2");
 
 		// When
 		var registry = SchemaRegistry.From(settings);
@@ -120,7 +120,7 @@ public void From_WithMessageTypeMap_RegistersTypes() {
 	public void From_WithCategoryMessageTypesMap_WithDefaultMessageAutoRegistration() {
 		// Given
 		var settings                         = new KurrentDBClientSerializationSettings();
-		var defaultMessageTypeNamingStrategy = new DefaultMessageTypeNamingStrategy(settings.DefaultMetadataType);
+		var defaultMessageTypeNamingStrategy = new DefaultMessageTypeNamingStrategy(settings.MessageTypeMapping.DefaultMetadataType);
 
 		// When
 		var registry = SchemaRegistry.From(settings);
@@ -179,9 +179,9 @@ public void From_WithCategoryMessageTypesMap_WithDefaultMessageAutoRegistration(
 	public void From_WithCategoryMessageTypesMap_RegistersTypesWithCategories() {
 		// Given
 		var settings = new KurrentDBClientSerializationSettings();
-		settings.RegisterMessageTypeForCategory<TestEvent1>("category1");
-		settings.RegisterMessageTypeForCategory<TestEvent2>("category1");
-		settings.RegisterMessageTypeForCategory<TestEvent3>("category2");
+		settings.MessageTypeMapping.RegisterForCategory<TestEvent1>("category1");
+		settings.MessageTypeMapping.RegisterForCategory<TestEvent2>("category1");
+		settings.MessageTypeMapping.RegisterForCategory<TestEvent3>("category2");
 
 		// When
 		var registry = SchemaRegistry.From(settings);
@@ -242,8 +242,7 @@ public void From_WithNoMessageTypeNamingStrategy_UsesDefaultStrategy() {
 		// Given
 		var settings = new KurrentDBClientSerializationSettings {
 			MessageTypeNamingStrategy = null,
-			DefaultMetadataType       = typeof(TestMetadata)
-		};
+		}.ConfigureTypeMap(setting => setting.DefaultMetadataType = typeof(TestMetadata));
 
 		// When
 		var registry = SchemaRegistry.From(settings);