Add ProjectionNameResolver and update all components to use it

Co-authored-by: JeanMarcMbouma <16613177+JeanMarcMbouma@users.noreply.github.com>

Author: Copilot

src/BbQ.Events/Engine/DefaultProjectionEngine.cs

@@ -377,16 +377,20 @@ private static ProjectionOptions GetProjectionOptions(Type concreteType)
         // Fall back to reading from attribute
         var attribute = concreteType.GetCustomAttribute<ProjectionAttribute>();
 
-        return new ProjectionOptions
+        var options = new ProjectionOptions
         {
-            ProjectionName = concreteType.Name,
             MaxDegreeOfParallelism = attribute?.MaxDegreeOfParallelism ?? 1,
             CheckpointBatchSize = attribute?.CheckpointBatchSize ?? 100,
             StartupMode = attribute?.StartupMode ?? ProjectionStartupMode.Resume,
             ChannelCapacity = attribute?.ChannelCapacity ?? 1000,
             BackpressureStrategy = attribute?.BackpressureStrategy ?? BackpressureStrategy.Block,
             // ErrorHandling is already initialized by property initializer to default values
         };
+        
+        // Use ProjectionNameResolver for consistent name resolution
+        options.ProjectionName = ProjectionNameResolver.Resolve(concreteType, registeredOptions);
+        
+        return options;
     }
 
     /// <summary>

src/BbQ.Events/Engine/DefaultProjectionRebuilder.cs

@@ -134,7 +134,9 @@ public IEnumerable<string> GetRegisteredProjections()
                 var registration = ProjectionHandlerRegistry.GetHandlerRegistration(eventType, handlerType);
                 if (registration != null)
                 {
-                    projectionNames.Add(registration.ConcreteType.Name);
+                    var projectionOptions = ProjectionHandlerRegistry.GetProjectionOptions(registration.ConcreteType.Name);
+                    var resolvedName = ProjectionNameResolver.Resolve(registration.ConcreteType, projectionOptions);
+                    projectionNames.Add(resolvedName);
                 }
             }
         }

src/BbQ.Events/Engine/DefaultReplayService.cs

@@ -102,7 +102,9 @@ public async Task ReplayAsync(
                 var registration = ProjectionHandlerRegistry.GetHandlerRegistration(eventType, handlerType);
                 if (registration != null)
                 {
-                    registeredProjections.Add(registration.ConcreteType.Name);
+                    var projectionOptions = ProjectionHandlerRegistry.GetProjectionOptions(registration.ConcreteType.Name);
+                    var resolvedName = ProjectionNameResolver.Resolve(registration.ConcreteType, projectionOptions);
+                    registeredProjections.Add(resolvedName);
                 }
             }
         }
@@ -241,13 +243,18 @@ private async Task StreamEventsAndProcessAsync(
             foreach (var handlerType in handlers)
             {
                 var registration = ProjectionHandlerRegistry.GetHandlerRegistration(eventType, handlerType);
-                if (registration != null && registration.ConcreteType.Name == projectionName)
+                if (registration != null)
                 {
-                    if (!projectionHandlers.ContainsKey(eventType))
+                    var projectionOptions = ProjectionHandlerRegistry.GetProjectionOptions(registration.ConcreteType.Name);
+                    var resolvedName = ProjectionNameResolver.Resolve(registration.ConcreteType, projectionOptions);
+                    if (resolvedName == projectionName)
                     {
-                        projectionHandlers[eventType] = new List<Type>();
+                        if (!projectionHandlers.ContainsKey(eventType))
+                        {
+                            projectionHandlers[eventType] = new List<Type>();
+                        }
+                        projectionHandlers[eventType].Add(handlerType);
                     }
-                    projectionHandlers[eventType].Add(handlerType);
                 }
             }
         }

src/BbQ.Events/Engine/ProjectionNameResolver.cs

@@ -0,0 +1,43 @@
+namespace BbQ.Events.Engine;
+
+/// <summary>
+/// Provides consistent projection name resolution across all projection components.
+/// </summary>
+/// <remarks>
+/// This resolver ensures that projection names are resolved using the same logic everywhere:
+/// - DefaultProjectionEngine (runtime processing)
+/// - DefaultReplayService (replay operations)
+/// - DefaultProjectionRebuilder (rebuild operations)
+/// 
+/// Resolution logic:
+/// 1. If ProjectionOptions.ProjectionName is set and not empty → use it
+/// 2. Otherwise → use the projection type name
+/// 
+/// This consistency prevents mismatched projection identifiers between runtime processing
+/// and replay/rebuild operations.
+/// </remarks>
+public static class ProjectionNameResolver
+{
+    /// <summary>
+    /// Resolves the projection name for a given projection type and options.
+    /// </summary>
+    /// <param name="projectionType">The concrete type of the projection handler.</param>
+    /// <param name="options">Optional projection options that may contain an explicit projection name.</param>
+    /// <returns>The resolved projection name.</returns>
+    public static string Resolve(Type projectionType, ProjectionOptions? options)
+    {
+        if (projectionType == null)
+        {
+            throw new ArgumentNullException(nameof(projectionType));
+        }
+
+        // If ProjectionOptions.ProjectionName is explicitly set, use it
+        if (!string.IsNullOrWhiteSpace(options?.ProjectionName))
+        {
+            return options.ProjectionName;
+        }
+
+        // Otherwise, fall back to the projection type name
+        return projectionType.Name;
+    }
+}