feat: allow order enricher (#423)

* feat: add enrich after attribute

* test: add enrichAfter tests

* feat: compile enrich plan on start

Author: ikesnowy

src/Cnblogs.Architecture.Ddd.Cqrs.Abstractions/EnrichAfterAttribute.cs

@@ -0,0 +1,24 @@
+namespace Cnblogs.Architecture.Ddd.Cqrs.Abstractions;
+
+/// <summary>
+///     Declares that the enricher must run after the specified enricher(s).
+///     Only references enrichers within the same <see cref="IEnricher{T}" /> group.
+/// </summary>
+[AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = false)]
+public sealed class EnrichAfterAttribute : Attribute
+{
+    /// <summary>
+    ///     The enricher types that must complete before this enricher runs.
+    /// </summary>
+    public Type[] DependencyTypes { get; }
+
+    /// <summary>
+    ///     Creates a new <see cref="EnrichAfterAttribute" /> with the specified dependency enricher types.
+    /// </summary>
+    /// <param name="dependencyTypes">The enricher types that must complete before this enricher runs.</param>
+    public EnrichAfterAttribute(params Type[] dependencyTypes)
+    {
+        ArgumentNullException.ThrowIfNull(dependencyTypes);
+        DependencyTypes = dependencyTypes;
+    }
+}

src/Cnblogs.Architecture.Ddd.Cqrs.Abstractions/EnricherBehavior.cs

@@ -1,5 +1,6 @@
 using System.Collections;
 using System.Diagnostics.CodeAnalysis;
+using Cnblogs.Architecture.Ddd.Cqrs.Abstractions.Internals;
 using MediatR;
 
 namespace Cnblogs.Architecture.Ddd.Cqrs.Abstractions;
@@ -48,23 +49,40 @@ public class EnricherBehavior<TRequest, TResponse>(IServiceProvider sp, Enricher
             return response;
         }
 
-        var typeInfo = cache.GetEnricherTypeInfo(elementType);
-        if (sp.GetService(typeInfo.EnrichersServiceType) is not IEnumerable<object> enricherObjects)
+        var enricherPlan = cache.GetEnricherPlan(elementType);
+        if (enricherPlan is null)
         {
             return response;
         }
 
-        var enrichers = enricherObjects
-            .Select(x => (IEnricher)x)
-            .OrderByDescending(x => x.AllowParallel)
-            .ToList();
+        foreach (var stage in enricherPlan)
+        {
+            await RunEnrichStageAsync(stage, isEnumerable, toEnrich, cancellationToken);
+        }
 
-        var method = isEnumerable ? typeInfo.BulkEnrichMethod : typeInfo.EnrichMethod;
+        return response;
+    }
+
+    private async Task RunEnrichStageAsync(
+        EnricherStage stage,
+        bool isEnumerable,
+        object toEnrich,
+        CancellationToken cancellationToken)
+    {
         var parallelTasks = new List<Task>();
-        foreach (var enricherObj in enrichers)
+
+        foreach (var descriptor in stage.Entries)
         {
+            var enricherObj = sp.GetService(descriptor.ImplType);
+            if (enricherObj is null)
+            {
+                continue;
+            }
+
+            var method = isEnumerable ? descriptor.BulkEnrichMethod : descriptor.EnrichMethod;
             var task = (Task)method.Invoke(enricherObj, [toEnrich, cancellationToken])!;
-            if (enricherObj.AllowParallel)
+
+            if (((IEnricher)enricherObj).AllowParallel)
             {
                 parallelTasks.Add(task);
             }
@@ -75,7 +93,6 @@ public class EnricherBehavior<TRequest, TResponse>(IServiceProvider sp, Enricher
         }
 
         await Task.WhenAll(parallelTasks);
-        return response;
     }
 
     private static object? UnwrapObjectResponse(object response)
@@ -153,4 +170,4 @@ private static IEnumerable Flatten(object items, ContainerInfo containerInfo)
 
         return flattened;
     }
-}
+}

src/Cnblogs.Architecture.Ddd.Cqrs.Abstractions/EnricherMappingCache.cs

@@ -1,5 +1,7 @@
 using System.Collections;
 using System.Collections.Concurrent;
+using System.Reflection;
+using Cnblogs.Architecture.Ddd.Cqrs.Abstractions.Internals;
 using Cnblogs.Architecture.Ddd.Infrastructure.Abstractions;
 
 namespace Cnblogs.Architecture.Ddd.Cqrs.Abstractions;
@@ -10,7 +12,7 @@ namespace Cnblogs.Architecture.Ddd.Cqrs.Abstractions;
 public class EnricherMappingCache
 {
     private readonly ConcurrentDictionary<Type, ContainerInfo> _containerInfoCache = new();
-    private readonly ConcurrentDictionary<Type, EnricherTypeInfo> _enricherTypeInfoCache = new();
+    private readonly ConcurrentDictionary<Type, List<EnricherStage>> _enricherPlans = new();
 
     /// <summary>
     ///     Get container info for a type, caching the result.
@@ -22,12 +24,104 @@ public ContainerInfo GetContainerInfo(Type type)
     }
 
     /// <summary>
-    ///     Get enricher type info for an element type, caching the result.
+    ///     Build enrich plan with given <paramref name="targetType"/> and <paramref name="enricherTypes"/>
     /// </summary>
-    /// <param name="elementType">The element type to resolve enrichers for.</param>
-    public EnricherTypeInfo GetEnricherTypeInfo(Type elementType)
+    /// <param name="targetType">The element type to enrich.</param>
+    /// <param name="enricherTypes">Types of enrichers.</param>
+    public void BuildEnrichPlan(Type targetType, ICollection<Type> enricherTypes)
     {
-        return _enricherTypeInfoCache.GetOrAdd(elementType, static t => new EnricherTypeInfo(t));
+        // ReSharper disable once HeapView.CanAvoidClosure
+        _enricherPlans.GetOrAdd(targetType, _ => CompileEnricherPlan(enricherTypes));
+    }
+
+    internal List<EnricherStage>? GetEnricherPlan(Type elementType)
+    {
+        var success = _enricherPlans.TryGetValue(elementType, out var list);
+        return success ? list : null;
+    }
+
+    private static List<EnricherStage> CompileEnricherPlan(ICollection<Type> enricherTypes)
+    {
+        if (enricherTypes.Count == 0)
+        {
+            return [];
+        }
+
+        var descriptors = enricherTypes.ToDictionary(t => t, CreateDescriptor);
+        var typeSet = enricherTypes.ToHashSet();
+        var inDegree = enricherTypes.ToDictionary(x => x, _ => 0);
+        var adjacencyList = enricherTypes.ToDictionary(x => x, _ => new List<Type>());
+
+        // Resolve the enricher interface for type checking
+        var elementType = descriptors.Values.First().EnrichMethod.GetParameters()[0].ParameterType;
+        var enricherType = typeof(IEnricher<>).MakeGenericType(elementType);
+
+        // Build edges from EnrichAfterAttribute
+        foreach (var type in enricherTypes)
+        {
+            var attrs = type.GetCustomAttributes<EnrichAfterAttribute>();
+            foreach (var dep in attrs.SelectMany(x => x.DependencyTypes).Where(x => x.IsAssignableTo(enricherType)))
+            {
+                if (typeSet.Contains(dep))
+                {
+                    // Edge: dep -> type (dep must run BEFORE type)
+                    adjacencyList[dep].Add(type);
+                    inDegree[type]++;
+                    continue;
+                }
+
+                // Dependency is not in the same group, this is a configuration error
+                throw new InvalidOperationException(
+                    $"Enricher '{type}' depends on '{dep}', but '{dep}' is not registered/resolved for this element type.");
+            }
+        }
+
+        return BuildDag(enricherTypes, descriptors, inDegree, adjacencyList);
+    }
+
+    private static EnricherDescriptor CreateDescriptor(Type enricherType)
+    {
+        var enricherInterface = enricherType.GetInterfaces()
+            .First(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEnricher<>));
+        return new EnricherDescriptor(
+            enricherType,
+            enricherInterface.GetMethod("EnrichAsync")!,
+            enricherInterface.GetMethod("BulkEnrichAsync")!);
+    }
+
+    private static List<EnricherStage> BuildDag(
+        ICollection<Type> enricherTypes,
+        Dictionary<Type, EnricherDescriptor> descriptors,
+        Dictionary<Type, int> inDegree,
+        Dictionary<Type, List<Type>> adjacencyList)
+    {
+        var stages = new List<EnricherStage>();
+        var currentStageNodes = inDegree.Where(x => x.Value == 0).Select(x => x.Key).ToList();
+        var processedCount = 0;
+
+        // Process level by level
+        while (currentStageNodes.Count > 0)
+        {
+            stages.Add(new EnricherStage(currentStageNodes.Select(t => descriptors[t]).ToList()));
+            processedCount += currentStageNodes.Count;
+
+            var nextStageNodes = new List<Type>();
+            foreach (var dependent in currentStageNodes.SelectMany(node => adjacencyList[node]))
+            {
+                inDegree[dependent]--;
+                if (inDegree[dependent] == 0)
+                {
+                    nextStageNodes.Add(dependent);
+                }
+            }
+
+            currentStageNodes = nextStageNodes;
+        }
+
+        // Circular dependency check
+        return processedCount == enricherTypes.Count
+            ? stages
+            : throw new InvalidOperationException("Circular dependency detected among enrichers.");
     }
 
     private static ContainerInfo ResolveContainerInfo(Type t)

src/Cnblogs.Architecture.Ddd.Cqrs.Abstractions/EnricherTypeInfo.cs

@@ -0,0 +1,5 @@
+using System.Reflection;
+
+namespace Cnblogs.Architecture.Ddd.Cqrs.Abstractions.Internals;
+
+internal record EnricherDescriptor(Type ImplType, MethodInfo EnrichMethod, MethodInfo BulkEnrichMethod);

src/Cnblogs.Architecture.Ddd.Cqrs.Abstractions/Internals/EnricherDescriptor.cs

@@ -0,0 +1,3 @@
+namespace Cnblogs.Architecture.Ddd.Cqrs.Abstractions.Internals;
+
+internal record EnricherStage(List<EnricherDescriptor> Entries);