Merge pull request #89 from salihcantekin/dev

fix: Global Pipeline Feature Fixes and Improvements

Author: salihcantekin

README.md

@@ -105,6 +105,38 @@ public class LoggingPipeline
 }
 ```
 
+### Global Pipelines
+
+Global pipelines automatically apply to **all handlers** with matching request/response types - ideal for cross-cutting concerns like logging, validation, and exception handling.
+
+```csharp
+public class GlobalLoggingPipeline
+{
+    [GlobalPipeline(Order = 10, ExecutionStage = GlobalPipelineExecutionStage.BeforeHandler)]
+    public async ValueTask<TResponse> Log<TRequest, TResponse>(
+        PipelineContext<TRequest> ctx,
+        PipelineDelegate<TRequest, TResponse> next)
+    {
+        Console.WriteLine($"Handling {typeof(TRequest).Name}");
+        var response = await next(ctx);
+        Console.WriteLine($"Completed {typeof(TRequest).Name}");
+        return response;
+    }
+}
+```
+
+**Key Features:**
+- **Automatic application**: No need to attach to each handler individually
+- **Execution stages**: Control when pipelines run relative to handler-specific pipelines
+  - `BeforeHandler` (default): Outermost layer, runs first
+  - `BeforeHandlerInner`: After handler pipelines, before handler
+  - `AfterHandlerInner`: After handler, before handler pipelines unwind
+  - `AfterHandler`: Outermost post-handler layer
+- **Zero overhead**: When no global pipelines are registered, no performance impact
+- **Type-safe**: Validated at compile time by the source generator
+
+For complete documentation including execution flow, best practices, and common patterns, see [GlobalPipelines.md](docs/GlobalPipelines.md).
+
 ### Notifications
 ```csharp
 public sealed record UserLoggedIn(string UserName);
@@ -173,6 +205,7 @@ For complete details, migration guidance, and troubleshooting, see [MultiProject
 - Minimal boilerplate: annotate methods directly with `[Handle]`, `[Pipeline]`, `[Notification]`
 - Named handlers (multiple strategies for same request/response)
 - Orderable pipelines + early system module execution
+- **Global pipelines** for cross-cutting concerns (logging, validation, exception handling)
 - Extensible module model (e.g., cache) before user pipelines
 - High-performance async signatures (`ValueTask`)
 - Parallel or sequential notification dispatch
@@ -197,6 +230,7 @@ Primary docs in `docs/`:
 | Project Overview | [ProjectDoc.en.md](docs/ProjectDoc.en.md) |
 | Handlers | [Handlers](docs/Handlers.md) |
 | Pipelines | [Pipelines](docs/Pipelines.md) |
+| Global Pipelines | [GlobalPipelines](docs/GlobalPipelines.md) |
 | Notifications | [Notifications](docs/Notifications.md) |
 | Modules | [Modules](docs/Modules.md) |
 | Multi-Project Setup | [MultiProjectSetup](docs/MultiProjectSetup.md) |
@@ -241,6 +275,7 @@ Space is a high-performance, source-generator powered mediator/messaging framewo
 ## Quick links
 - Handlers: docs/Handlers.md
 - Pipelines: docs/Pipelines.md
+- Global Pipelines: docs/GlobalPipelines.md
 - Notifications: docs/Notifications.md
 - Known Issues: docs/KnownIssues.md
 - Developer Recommendations: docs/DeveloperRecommendations.md
@@ -253,3 +288,62 @@ See `.github/copilot-instructions.md` for environment and common commands.
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

src/Space.Abstraction/Registry/HandlerEntry.cs

@@ -27,7 +27,6 @@ internal abstract class HandlerEntry<TRequest, TResponse> : IObjectHandlerEntry
         // Pipeline storage - separating handler pipelines from global pipelines
         private readonly List<(int Order, PipelineInvoker<TRequest, TResponse> Invoker)> handlerPipelines;
         private readonly List<(int Order, int ExecutionStage, PipelineInvoker<TRequest, TResponse> Invoker)> globalPipelines;
-        private bool hasPipelines;
 
         private readonly object composeLock = new();
         private PipelineInvoker<TRequest, TResponse>[] orderedPipelines;
@@ -41,9 +40,9 @@ internal abstract class HandlerEntry<TRequest, TResponse> : IObjectHandlerEntry
         private PipelineInvoker<TRequest, TResponse> singlePipelineInvoker;
         private PipelineDelegate<TRequest, TResponse> cachedFinalDelegate;
 
-        // Virtual properties so specialized entries can override
-        internal virtual bool IsPipelineFree => !hasPipelines;
-        internal virtual bool HasLightInvoker => lightInvoker != null && !hasPipelines;
+        // Dynamic check for pipeline-free status (supports AddPipeline after construction)
+        internal virtual bool IsPipelineFree => handlerPipelines.Count == 0 && globalPipelines.Count == 0;
+        internal virtual bool HasLightInvoker => lightInvoker != null && IsPipelineFree;
 
         protected HandlerEntry(
             HandlerInvoker<TRequest, TResponse> handlerInvoker,
@@ -75,10 +74,8 @@ protected HandlerEntry(
                 }
             }
 
-            hasPipelines = handlerPipelines.Count > 0 || globalPipelines.Count > 0;
-            
             // Pre-compose at construction time for performance
-            if (hasPipelines)
+            if (!IsPipelineFree)
             {
                 EnsureComposed();
             }
@@ -92,9 +89,9 @@ protected HandlerEntry(
         internal void AddPipeline(PipelineInvoker<TRequest, TResponse> invoker, PipelineConfig pipelineConfig)
         {
             handlerPipelines.Add((pipelineConfig.Order, invoker));
-            hasPipelines = true;
-            orderedPipelines = null;
+            // Mark composition as dirty so it will be recomposed on next Invoke
             compositionDirty = true;
+            orderedPipelines = null; // Clear cached ordered list
         }
 
         private PipelineInvoker<TRequest, TResponse>[] GetOrdered()
@@ -168,6 +165,7 @@ protected void EnsureComposed()
 
                 if (totalPipelines == 0)
                 {
+                    // Pipeline-free: composed invoke is just the handler
                     composedInvoke = handlerInvoker;
                 }
                 else
@@ -254,6 +252,12 @@ internal virtual ValueTask<TResponse> InvokeLight(IServiceProvider sp, ISpace sp
         public virtual ValueTask<TResponse> Invoke(HandlerContext<TRequest> handlerContext)
         {
             handlerContext.CancellationToken.ThrowIfCancellationRequested();
+
+            // Ultra-fast path: no pipelines or global pipelines attached
+            if (IsPipelineFree)
+            {
+                return handlerInvoker(handlerContext);
+            }
 
             if (compositionDirty)
                 EnsureComposed();

src/Space.DependencyInjection/Space.cs

@@ -85,33 +85,45 @@ private ValueTask<TResponse> SendCore<TRequest, TResponse>(in TRequest request,
         where TRequest : notnull
         where TResponse : notnull
     {
-        // ULTRA-FAST PATH: Singleton/Transient + unnamed + pipeline-free
-        // Uses direct delegate invocation - NO virtual calls
+        // ULTRA-FAST PATH: Singleton/Transient + unnamed + pipeline-free (LightHandlerEntry)
         if (string.IsNullOrEmpty(name) && IsFastPath(spaceRegistry.HandlerLifetime))
         {
-            // Hot path: Already initialized and is light handler
             if (DirectInvokerCache<TRequest, TResponse>.Initialized)
             {
                 if (DirectInvokerCache<TRequest, TResponse>.IsLight)
                 {
                     // Single cancellation check - ThrowIfCancellationRequested handles both
                     ct.ThrowIfCancellationRequested();
-                    var lctx = new LightHandlerContext<TRequest>(request, rootProvider, this, ct);
-                    return DirectInvokerCache<TRequest, TResponse>.LightInvoker(in lctx);
+                    return DirectInvokerCache<TRequest, TResponse>.LightInvoker(
+                        new LightHandlerContext<TRequest>(request, rootProvider, this, ct));
                 }
-                // Not light - fall through to standard path (has pipelines)
-            }
-            else
-            {
-                // Cold path: Initialize cache (NoInlining to keep hot path small)
-                return InitializeAndInvoke<TRequest, TResponse>(in request, ct);
+                // Has pipelines - use entry path
+                return SendViaEntry<TRequest, TResponse>(in request, ct);
             }
+            
+            // Cold path: Initialize and invoke
+            return InitializeAndInvoke<TRequest, TResponse>(in request, ct);
         }
 
-        // Standard path (named handlers, pipeline handlers, scoped)
+        // Named or scoped path
         return SendCoreStandard<TRequest, TResponse>(in request, name, ct);
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private ValueTask<TResponse> SendViaEntry<TRequest, TResponse>(in TRequest request, CancellationToken ct)
+        where TRequest : notnull
+        where TResponse : notnull
+    {
+        ct.ThrowIfCancellationRequested();
+        var entry = EntryCache<TRequest, TResponse>.Entry;
+        
+        if (entry.HasLightInvoker)
+            return entry.InvokeLight(rootProvider, this, request, ct);
+
+        var ctx = HandlerContext<TRequest>.Create(rootProvider, request, ct);
+        return entry.Invoke(ctx).AwaitAndReturnHandlerInvoke(ctx);
+    }
+
     [MethodImpl(MethodImplOptions.NoInlining)]
     private ValueTask<TResponse> InitializeAndInvoke<TRequest, TResponse>(in TRequest request, CancellationToken ct)
         where TRequest : notnull
@@ -130,19 +142,14 @@ private ValueTask<TResponse> InitializeAndInvoke<TRequest, TResponse>(in TReques
                 DirectInvokerCache<TRequest, TResponse>.Initialized = true;
 
                 ct.ThrowIfCancellationRequested();
-                var lctx = new LightHandlerContext<TRequest>(request, rootProvider, this, ct);
-                return DirectInvokerCache<TRequest, TResponse>.LightInvoker(in lctx);
+                return DirectInvokerCache<TRequest, TResponse>.LightInvoker(
+                    new LightHandlerContext<TRequest>(request, rootProvider, this, ct));
             }
 
             DirectInvokerCache<TRequest, TResponse>.IsLight = false;
             DirectInvokerCache<TRequest, TResponse>.Initialized = true;
 
-            // Has pipelines - invoke through entry
-            if (entry.HasLightInvoker)
-                return entry.InvokeLight(rootProvider, this, request, ct);
-
-            var ctx = HandlerContext<TRequest>.Create(rootProvider, request, ct);
-            return entry.Invoke(ctx).AwaitAndReturnHandlerInvoke(ctx);
+            return SendViaEntry<TRequest, TResponse>(in request, ct);
         }
 
         DirectInvokerCache<TRequest, TResponse>.IsLight = false;
@@ -285,10 +292,7 @@ public ValueTask<TResponse> Send<TResponse>(IRequest<TResponse> request, string
                 if (vto.IsCompletedSuccessfully)
                     return new ValueTask<TResponse>((TResponse)vto.Result!);
 
-                return AwaitFast1(vto);
-
-                static async ValueTask<TResponse> AwaitFast1(ValueTask<object> vt)
-                    => (TResponse)await vt.ConfigureAwait(false);
+                return AwaitCast<TResponse>(vto);
             }
 
             // Fallback: object dispatch through registry (still no expression compile)
@@ -297,10 +301,7 @@ static async ValueTask<TResponse> AwaitFast1(ValueTask<object> vt)
             if (vtoFallback.IsCompletedSuccessfully)
                 return new ValueTask<TResponse>((TResponse)vtoFallback.Result!);
 
-            return AwaitFast2(vtoFallback);
-
-            static async ValueTask<TResponse> AwaitFast2(ValueTask<object> vt)
-                => (TResponse)await vt.ConfigureAwait(false);
+            return AwaitCast<TResponse>(vtoFallback);
         }
 
         // Scoped path
@@ -312,14 +313,15 @@ static async ValueTask<TResponse> AwaitFast2(ValueTask<object> vt)
         }
 
         var vts = spaceRegistry.DispatchHandler(request, name, typeof(TResponse), scope.ServiceProvider, ct);
-
         if (vts.IsCompletedSuccessfully)
         {
             scope.Dispose();
             return new ValueTask<TResponse>((TResponse)vts.Result!);
         }
-
         return AwaitDispose(vts.ContinueWithCast<TResponse>(), scope);
+
+        static async ValueTask<T> AwaitCast<T>(ValueTask<object> vt)
+            => (T)await vt.ConfigureAwait(false);
     }
 
     #endregion
@@ -339,34 +341,28 @@ public ValueTask<TResponse> Send<TResponse>(object request, string name = null,
             var key = (type, name ?? string.Empty);
 
             if (GenericDispatcherCache<TResponse>.Map.TryGetValue(key, out var f))
-            {
                 return f(this, request, ct);
-            }
 
             // Build and cache dispatcher to typed Send<TRuntime,TResponse> when possible,
             // otherwise fall back to registry object dispatch.
             var del = BuildTypedDispatcher<TResponse>(type, name);
             GenericDispatcherCache<TResponse>.Map[key] = del;
-
             return del(this, request, ct);
         }
 
         var scope = scopeFactory.CreateScope();
-
         if (ct.IsCancellationRequested)
         {
             scope.Dispose();
             return ValueTask.FromCanceled<TResponse>(ct);
         }
 
         var vt = spaceRegistry.DispatchHandler(request, name, typeof(TResponse), scope.ServiceProvider, ct);
-
         if (vt.IsCompletedSuccessfully)
         {
             scope.Dispose();
             return new ValueTask<TResponse>((TResponse)vt.Result!);
         }
-
         return AwaitDispose(vt.ContinueWithCast<TResponse>(), scope);
     }
 
@@ -377,12 +373,10 @@ public ValueTask Send(object request, string name = null, CancellationToken ct =
         var vt = Send<Nothing>(request, name, ct);
         if (vt.IsCompletedSuccessfully)
             return default;
-        return Await(vt);
+        return AwaitNothing(vt);
 
-        static async ValueTask Await(ValueTask<Nothing> inner)
-        {
-            await inner.ConfigureAwait(false);
-        }
+        static async ValueTask AwaitNothing(ValueTask<Nothing> inner)
+            => await inner.ConfigureAwait(false);
     }
 
     private static Func<Space, object, CancellationToken, ValueTask<TRes>> BuildTypedDispatcher<TRes>(Type requestType, string name)
@@ -435,8 +429,7 @@ public ValueTask Publish<TRequest>(TRequest request, CancellationToken ct = defa
         if (IsFastPath(spaceRegistry.HandlerLifetime))
         {
             var ctxFast = NotificationContext<TRequest>.Create(rootProvider, request, ct);
-            var vt = spaceRegistry.FastDispatchNotification(ctxFast).AwaitAndReturnNotificationInvoke(ctxFast);
-            return vt;
+            return spaceRegistry.FastDispatchNotification(ctxFast).AwaitAndReturnNotificationInvoke(ctxFast);
         }
 
         return SlowPublishScoped(request, ct);
@@ -465,8 +458,7 @@ public ValueTask Publish<TRequest>(TRequest request, NotificationDispatchType di
         if (IsFastPath(spaceRegistry.HandlerLifetime))
         {
             var ctxFast = NotificationContext<TRequest>.Create(rootProvider, request, ct);
-            var vt = spaceRegistry.FastDispatchNotification(ctxFast, dispatchType).AwaitAndReturnNotificationInvoke(ctxFast);
-            return vt;
+            return spaceRegistry.FastDispatchNotification(ctxFast, dispatchType).AwaitAndReturnNotificationInvoke(ctxFast);
         }
 
         return SlowPublishScoped(request, dispatchType, ct);