feat: register IConfigurationWriter<T> as open generic via proxy

Replace the hardcoded IConfigurationWriter<RoleConfiguration> singleton
in AddAuthorization() with a generic ConfigurationWriterProxy<T> that
resolves any IConfigurationWriter<T> lazily from the factory. Any endpoint
can now inject a typed writer directly without per-type bridge registrations.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Mike Blair

src/FractalDataWorks.Configuration.Writers/ConfigurationWriterProxy.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using FractalDataWorks.Configuration;
+using FractalDataWorks.Results;
+
+namespace FractalDataWorks.Configuration.Writers;
+
+/// <summary>
+/// Open-generic proxy that resolves a typed <see cref="IConfigurationWriter{TConfiguration}"/>
+/// lazily from <see cref="IConfigurationWriterFactory"/> on first use.
+/// Registered as <c>services.AddSingleton(typeof(IConfigurationWriter&lt;&gt;), typeof(ConfigurationWriterProxy&lt;&gt;))</c>
+/// so that any endpoint can inject <c>IConfigurationWriter&lt;T&gt;</c> directly without
+/// requiring per-type registrations.
+/// </summary>
+/// <typeparam name="TConfiguration">The configuration type.</typeparam>
+internal sealed class ConfigurationWriterProxy<TConfiguration> : IConfigurationWriter<TConfiguration>
+    where TConfiguration : class, IGenericConfiguration
+{
+    private readonly Lazy<IConfigurationWriter<TConfiguration>> _inner;
+
+    public ConfigurationWriterProxy(IConfigurationWriterFactory factory)
+    {
+        if (factory == null) throw new ArgumentNullException(nameof(factory));
+
+        _inner = new Lazy<IConfigurationWriter<TConfiguration>>(() =>
+        {
+            var result = factory.Create<TConfiguration>();
+            if (result.IsFailure)
+            {
+                throw new InvalidOperationException(
+                    $"Failed to create IConfigurationWriter<{typeof(TConfiguration).Name}>: {result.CurrentMessage}");
+            }
+
+            return result.Value!;
+        });
+    }
+
+    /// <inheritdoc />
+    public Task<IGenericResult<TConfiguration>> Save(TConfiguration configuration, CancellationToken ct = default)
+        => _inner.Value.Save(configuration, ct);
+
+    /// <inheritdoc />
+    public Task<IGenericResult> Delete(Guid id, CancellationToken ct = default)
+        => _inner.Value.Delete(id, ct);
+
+    /// <inheritdoc />
+    public Task<IGenericResult> Delete(string name, CancellationToken ct = default)
+        => _inner.Value.Delete(name, ct);
+}

src/FractalDataWorks.Configuration.Writers/ConfigurationWriterServiceCollectionExtensions.cs

@@ -48,6 +48,10 @@ public static IServiceCollection AddConfigurationWriters(
         services.TryAddSingleton<IConfigurationReloader, DefaultConfigurationReloader>();
         services.TryAddSingleton<IConfigurationWriterFactory, DefaultConfigurationWriterFactory>();
 
+        // Open-generic proxy: any IConfigurationWriter<T> resolves lazily from the factory.
+        // Endpoints can inject IConfigurationWriter<T> directly instead of using IConfigurationWriterFactory.
+        services.TryAddSingleton(typeof(IConfigurationWriter<>), typeof(ConfigurationWriterProxy<>));
+
         return services;
     }
 

src/FractalDataWorks.Hosting/Builders/ServiceTypeRegistrationBuilder.cs

@@ -4,7 +4,6 @@
 using FractalDataWorks.Hosting.Logging;
 using FractalDataWorks.Services.Authentication;
 using FractalDataWorks.Services.Authorization;
-using FractalDataWorks.Services.Authorization.Configuration;
 using FractalDataWorks.Services.Connections;
 using FractalDataWorks.Services.Data;
 using FractalDataWorks.Services.Etl;
@@ -102,11 +101,6 @@ public ServiceTypeRegistrationBuilder AddAuthorization()
         HostingLog.ServiceTypeRegistrationPhase(_logger, "Configure", "Authorization");
         _builder.Services.AddFrameworkAuthorizationPolicies();
 
-        // Bridge typed configuration writer for role endpoints.
-        // The lambda resolves lazily after InitializeFrameworkServiceTypes() has set up the factory.
-        _builder.Services.AddSingleton<IConfigurationWriter<RoleConfiguration>>(sp =>
-            sp.GetRequiredService<IConfigurationWriterFactory>().Create<RoleConfiguration>().Value!);
-
         State.HasAuthorization = true;
         return this;
     }