refactor(commands): drop parameterless context factory in favor of explicit and seeded dispatch

Remove the redundant ICommandContextFactory<TContext> (arity-1) and the
context-less DispatchAsync<TCommand>(command) overload. In multi-session
servers a parameterless Create() cannot know which session a command belongs
to, making it a footgun. Callers now pass the context explicitly via
DispatchAsync(command, context) or build it from a seed through
ISeededCommandDispatcher<TContext, TSeed>.

- Delete ICommandContextFactory.cs (arity-1) and its RegisterCommandContextFactory extension
- Simplify CommandDispatcher to a single ctor and register it directly as a singleton
- Drop the context-less interface overload and implementation
- Update samples, tests, and Core/Services.Core READMEs accordingly

Author: tgiachi

samples/SquidStd.Samples.Commands/Program.cs

@@ -5,7 +5,6 @@
 using SquidStd.Services.Core.Extensions;
 
 var container = new Container();
-container.RegisterCommandContextFactory<Session, CurrentSessionFactory>();
 container.RegisterCommandDispatcher<Session>();
 container.RegisterCommandHandler<PingCommand, Session, PingHandler>();
 container.RegisterCommandHandler<EchoCommand, Session, EchoHandler>();
@@ -20,19 +19,23 @@
     registration.Subscribe(dispatcher, container);
 }
 
-await Dispatch(dispatcher, new PingCommand());
-await Dispatch(dispatcher, new EchoCommand("hello world"));
+// The context (here a Session) is passed explicitly at dispatch time — in a server this is the
+// session the message arrived on. See RegisterSeededCommandDispatcher for building it from a seed.
+var session = new Session();
+
+await Dispatch(dispatcher, new PingCommand(), session);
+await Dispatch(dispatcher, new EchoCommand("hello world"), session);
 
 // Unknown command path: nothing registered for UnknownCommand.
-var unknown = await dispatcher.DispatchAsync(new UnknownCommand());
+var unknown = await dispatcher.DispatchAsync(new UnknownCommand(), session);
 Console.WriteLine($"UnknownCommand -> matched={unknown.Matched} handlers={unknown.HandlerCount}");
 
 return;
 
-static async Task Dispatch<TCommand>(ICommandDispatcher<Session> dispatcher, TCommand command)
+static async Task Dispatch<TCommand>(ICommandDispatcher<Session> dispatcher, TCommand command, Session context)
     where TCommand : ICommand
 {
-    var result = await dispatcher.DispatchAsync(command);
+    var result = await dispatcher.DispatchAsync(command, context);
     Console.WriteLine(
         $"{typeof(TCommand).Name} -> matched={result.Matched} handlers={result.HandlerCount} errors={result.Errors.Count}"
     );
@@ -43,14 +46,6 @@ internal sealed class Session
     public string Id { get; } = Guid.NewGuid().ToString("N")[..8];
 }
 
-internal sealed class CurrentSessionFactory : ICommandContextFactory<Session>
-{
-    public Session Create()
-    {
-        return new Session();
-    }
-}
-
 internal sealed record PingCommand : ICommand;
 
 internal sealed record EchoCommand(string Text) : ICommand;

src/SquidStd.Core/Interfaces/Commands/ICommandContextFactory.cs

@@ -29,15 +29,4 @@ public interface ICommandDispatcher<TContext>
     /// <returns>The dispatch result.</returns>
     Task<CommandDispatchResult> DispatchAsync<TCommand>(TCommand command, TContext context, CancellationToken cancellationToken = default)
         where TCommand : ICommand;
-
-    /// <summary>
-    ///     Dispatches a command, building the context from the registered
-    ///     <see cref="ICommandContextFactory{TContext}" />.
-    /// </summary>
-    /// <typeparam name="TCommand">The command type.</typeparam>
-    /// <param name="command">The command payload.</param>
-    /// <param name="cancellationToken">The cancellation token.</param>
-    /// <returns>The dispatch result.</returns>
-    Task<CommandDispatchResult> DispatchAsync<TCommand>(TCommand command, CancellationToken cancellationToken = default)
-        where TCommand : ICommand;
 }

src/SquidStd.Core/Interfaces/Commands/ICommandDispatcher.cs

@@ -26,7 +26,7 @@ dotnet add package SquidStd.Core
 
 - Configuration contracts: `IConfigEntry` (a YAML section) and `IConfigManagerService`.
 - In-process messaging: `IEventBus` with `ISyncEventListener<T>` / `IAsyncEventListener<T>` over `IEvent`.
-- Command dispatch: `ICommandDispatcher<TContext>` with `ICommandHandler<TCommand,TContext>`, fan-out, fault isolation, and a `CommandDispatchResult`; `ICommandContextFactory<TContext>` builds the current context.
+- Command dispatch: `ICommandDispatcher<TContext>` with `ICommandHandler<TCommand,TContext>`, fan-out, fault isolation, and a `CommandDispatchResult`; `ICommandContextFactory<TContext,TSeed>` builds the context from a seed for `ISeededCommandDispatcher<TContext,TSeed>`.
 - Background work & timing: `IJobSystem`, `ITimerService`, `IMainThreadDispatcher`.
 - Metrics & secrets: `IMetricProvider` and secret-protection contracts.
 - Serialization: `IDataSerializer` / `IDataDeserializer` (default `JsonDataSerializer`), plus `YamlUtils` / `JsonUtils`.

src/SquidStd.Core/README.md

@@ -20,31 +20,12 @@ public static class RegisterCommandDispatcherExtensions
         /// <returns>The same container for chaining.</returns>
         public IContainer RegisterCommandDispatcher<TContext>()
         {
-            container.RegisterDelegate<ICommandDispatcher<TContext>>(
-                resolver => new CommandDispatcher<TContext>(
-                    resolver.Resolve<ICommandContextFactory<TContext>>(IfUnresolved.ReturnDefault)
-                ),
-                Reuse.Singleton
-            );
+            container.Register<ICommandDispatcher<TContext>, CommandDispatcher<TContext>>(Reuse.Singleton);
             container.RegisterStdService<CommandDispatcherActivator<TContext>, CommandDispatcherActivator<TContext>>(-900);
 
             return container;
         }
 
-        /// <summary>
-        ///     Registers the context factory used by the context-less dispatch overload.
-        /// </summary>
-        /// <typeparam name="TContext">The dispatcher context type.</typeparam>
-        /// <typeparam name="TFactory">The factory implementation type.</typeparam>
-        /// <returns>The same container for chaining.</returns>
-        public IContainer RegisterCommandContextFactory<TContext, TFactory>()
-            where TFactory : class, ICommandContextFactory<TContext>
-        {
-            container.Register<ICommandContextFactory<TContext>, TFactory>(Reuse.Singleton);
-
-            return container;
-        }
-
         /// <summary>
         ///     Registers a seeded context factory and an <see cref="ISeededCommandDispatcher{TContext,TSeed}" />
         ///     singleton over the existing <see cref="ICommandDispatcher{TContext}" /> (which must already be

src/SquidStd.Services.Core/Extensions/RegisterCommandDispatcherExtensions.cs

@@ -26,7 +26,7 @@ dotnet add package SquidStd.Services.Core
 - One-line bootstrap: `container.RegisterCoreServices()` registers the full default service set.
 - `ConfigManagerService` — loads/saves YAML config sections and substitutes `$ENV_VAR` tokens.
 - `EventBusService` — in-process publish/subscribe over `IEvent`.
-- `CommandDispatcher<TContext>` — typed protocol command dispatch with fan-out, fault isolation, and a `CommandDispatchResult` (`RegisterCommandDispatcher` / `RegisterCommandHandler` / `RegisterCommandContextFactory`).
+- `CommandDispatcher<TContext>` — typed protocol command dispatch with fan-out, fault isolation, and a `CommandDispatchResult` (`RegisterCommandDispatcher` / `RegisterCommandHandler` / `RegisterSeededCommandDispatcher`).
 - `JobSystemService` — background job execution; `TimerWheelService` + cron scheduling for timed work.
 - `MainThreadDispatcherService` — marshal work back onto a main thread.
 - `MetricsCollectionService` — aggregates `IMetricProvider` samples.
@@ -48,13 +48,12 @@ container.RegisterCoreServices("squidstd", Directory.GetCurrentDirectory());
 ## Command dispatch
 
 ```csharp
-// Register a dispatcher for your context type, a context factory, and handlers.
-container.RegisterCommandContextFactory<Session, CurrentSessionFactory>();
+// Register a dispatcher for your context type and handlers.
 container.RegisterCommandDispatcher<Session>();
 container.RegisterCommandHandler<PingCommand, Session, PingHandler>();
 
-// Dispatch (handlers auto-subscribed at bootstrap). Build the context from the factory:
-var result = await dispatcher.DispatchAsync(new PingCommand("hi"));
+// Dispatch (handlers auto-subscribed at bootstrap). Pass the context explicitly:
+var result = await dispatcher.DispatchAsync(new PingCommand("hi"), session);
 if (!result.Matched)
 {
     // unknown command

src/SquidStd.Services.Core/README.md

@@ -15,23 +15,9 @@ namespace SquidStd.Services.Core.Services;
 public sealed class CommandDispatcher<TContext> : ICommandDispatcher<TContext>, IDisposable
 {
     private readonly ConcurrentDictionary<Type, List<object>> _handlers = new();
-    private readonly ICommandContextFactory<TContext>? _contextFactory;
     private readonly ILogger _logger = Log.ForContext<CommandDispatcher<TContext>>();
     private bool _disposed;
 
-    /// <summary>Initializes the dispatcher without a context factory.</summary>
-    public CommandDispatcher()
-        : this(null)
-    {
-    }
-
-    /// <summary>Initializes the dispatcher with an optional context factory.</summary>
-    /// <param name="contextFactory">Factory used by the context-less dispatch overload, if any.</param>
-    public CommandDispatcher(ICommandContextFactory<TContext>? contextFactory)
-    {
-        _contextFactory = contextFactory;
-    }
-
     /// <inheritdoc />
     public IDisposable RegisterHandler<TCommand>(ICommandHandler<TCommand, TContext> handler)
         where TCommand : ICommand
@@ -78,22 +64,6 @@ public async Task<CommandDispatchResult> DispatchAsync<TCommand>(
         return new CommandDispatchResult(true, handlers.Length, errors);
     }
 
-    /// <inheritdoc />
-    public Task<CommandDispatchResult> DispatchAsync<TCommand>(
-        TCommand command, CancellationToken cancellationToken = default
-    )
-        where TCommand : ICommand
-    {
-        if (_contextFactory is null)
-        {
-            throw new InvalidOperationException(
-                "No ICommandContextFactory<TContext> is registered; pass an explicit context instead."
-            );
-        }
-
-        return DispatchAsync(command, _contextFactory.Create(), cancellationToken);
-    }
-
     private CommandSubscription Add(Type commandType, object handler)
     {
         ThrowIfDisposed();

src/SquidStd.Services.Core/Services/CommandDispatcher.cs

@@ -111,32 +111,6 @@ public async Task Subscribe_DeliversToDelegate()
         Assert.Same(session, seenContext);
     }
 
-    [Fact]
-    public async Task DispatchAsync_WithoutContext_UsesFactory()
-    {
-        var factory = new CountingFactory();
-        using var dispatcher = new CommandDispatcher<Session>(factory);
-        var handler = new RecordingHandler();
-        dispatcher.RegisterHandler(handler);
-
-        var result = await dispatcher.DispatchAsync(new PingCommand("auto"));
-
-        Assert.True(result.Matched);
-        Assert.Equal("auto", handler.LastText);
-        Assert.Same(factory.Last, handler.LastContext);
-        Assert.Equal(1, factory.CreateCount);
-    }
-
-    [Fact]
-    public async Task DispatchAsync_WithoutContext_WhenNoFactory_Throws()
-    {
-        using var dispatcher = new CommandDispatcher<Session>();
-
-        await Assert.ThrowsAsync<InvalidOperationException>(
-            () => dispatcher.DispatchAsync(new PingCommand("x"))
-        );
-    }
-
     private sealed class Session
     {
     }
@@ -165,19 +139,4 @@ public Task HandleAsync(PingCommand command, Session context, CancellationToken
             throw new InvalidOperationException("Synthetic failure.");
         }
     }
-
-    private sealed class CountingFactory : ICommandContextFactory<Session>
-    {
-        public int CreateCount { get; private set; }
-
-        public Session? Last { get; private set; }
-
-        public Session Create()
-        {
-            CreateCount++;
-            Last = new Session();
-
-            return Last;
-        }
-    }
 }

tests/SquidStd.Tests/Services/Core/CommandDispatcherTests.cs

@@ -40,23 +40,6 @@ public async Task Activator_SubscribesRegisteredHandlers()
         Assert.Equal("hi", container.Resolve<PingHandler>().LastText);
     }
 
-    [Fact]
-    public async Task RegisterCommandContextFactory_IsUsedByContextlessDispatch()
-    {
-        using var container = new Container();
-        container.RegisterCommandContextFactory<Session, SessionFactory>();
-        container.RegisterCommandDispatcher<Session>();
-        container.RegisterCommandHandler<PingCommand, Session, PingHandler>();
-
-        await container.Resolve<CommandDispatcherActivator<Session>>().StartAsync(CancellationToken.None);
-
-        var dispatcher = container.Resolve<ICommandDispatcher<Session>>();
-        var result = await dispatcher.DispatchAsync(new PingCommand("auto"));
-
-        Assert.True(result.Matched);
-        Assert.Equal("auto", container.Resolve<PingHandler>().LastText);
-    }
-
     private sealed class Session
     {
     }
@@ -74,12 +57,4 @@ public Task HandleAsync(PingCommand command, Session context, CancellationToken
             return Task.CompletedTask;
         }
     }
-
-    private sealed class SessionFactory : ICommandContextFactory<Session>
-    {
-        public Session Create()
-        {
-            return new Session();
-        }
-    }
 }