feat: Add Dependency Injection support (#459)

Signed-off-by: André Silva <[email protected]>
Signed-off-by: Kyle Julian <[email protected]>
Co-authored-by: Kyle Julian <[email protected]>
Co-authored-by: Copilot <[email protected]>

Author: 3 people

src/OpenFeature.Providers.Ofrep/Client/OfrepClient.cs

@@ -42,6 +42,26 @@ public OfrepClient(OfrepOptions configuration, ILogger? logger = null)
     {
     }
 
+    /// <summary>
+    /// Creates a new instance of <see cref="OfrepClient"/> using a provided <see cref="HttpClient"/>.
+    /// </summary>
+    /// <param name="httpClient">The HttpClient to use for requests. Caller may provide one from IHttpClientFactory.</param>
+    /// <param name="logger">The logger for the client.</param>
+    internal OfrepClient(HttpClient httpClient, ILogger? logger = null)
+    {
+#if NET8_0_OR_GREATER
+        ArgumentNullException.ThrowIfNull(httpClient);
+#else
+        if (httpClient == null)
+        {
+            throw new ArgumentNullException(nameof(httpClient));
+        }
+#endif
+
+        this._logger = logger ?? NullLogger<OfrepClient>.Instance;
+        this._httpClient = httpClient;
+    }
+
     /// <summary>
     /// Internal constructor for testing purposes.
     /// </summary>

src/OpenFeature.Providers.Ofrep/DependencyInjection/FeatureBuilderExtensions.cs

@@ -0,0 +1,90 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using OpenFeature.DependencyInjection;
+using OpenFeature.Providers.Ofrep.Configuration;
+#if NETFRAMEWORK
+using System.Net.Http;
+#endif
+using Microsoft.Extensions.Logging;
+using OpenFeature.Providers.Ofrep.Client;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+
+namespace OpenFeature.Providers.Ofrep.DependencyInjection;
+
+/// <summary>
+/// Extension methods for configuring the OpenFeatureBuilder with Ofrep provider.
+/// </summary>
+public static class FeatureBuilderExtensions
+{
+    /// <summary>
+    /// Adds the OfrepProvider with configured options.
+    /// </summary>
+    public static OpenFeatureBuilder AddOfrepProvider(this OpenFeatureBuilder builder, Action<OfrepProviderOptions> configure)
+    {
+        builder.Services.Configure(OfrepProviderOptions.DefaultName, configure);
+        builder.Services.TryAddSingleton<IValidateOptions<OfrepProviderOptions>, OfrepProviderOptionsValidator>();
+        return builder.AddProvider(sp => CreateProvider(sp, null));
+    }
+
+    /// <summary>
+    /// Adds the OfrepProvider for a named domain with configured options.
+    /// </summary>
+    public static OpenFeatureBuilder AddOfrepProvider(this OpenFeatureBuilder builder, string domain, Action<OfrepProviderOptions> configure)
+    {
+        builder.Services.Configure(domain, configure);
+        builder.Services.TryAddSingleton<IValidateOptions<OfrepProviderOptions>, OfrepProviderOptionsValidator>();
+        return builder.AddProvider(domain, CreateProvider);
+    }
+
+    private static OfrepProvider CreateProvider(IServiceProvider sp, string? domain)
+    {
+        var monitor = sp.GetRequiredService<IOptionsMonitor<OfrepProviderOptions>>();
+        var opts = string.IsNullOrWhiteSpace(domain) ? monitor.Get(OfrepProviderOptions.DefaultName) : monitor.Get(domain);
+
+        // Options validation is handled by OfrepProviderOptionsValidator during service registration
+        var ofrepOptions = new OfrepOptions(opts.BaseUrl)
+        {
+            Timeout = opts.Timeout,
+            Headers = opts.Headers
+        };
+
+        // Resolve or create HttpClient if caller wants to manage it
+        HttpClient? httpClient = null;
+
+        // Prefer IHttpClientFactory if available
+        var factory = sp.GetService<IHttpClientFactory>();
+        if (factory != null)
+        {
+            httpClient = string.IsNullOrWhiteSpace(opts.HttpClientName) ? factory.CreateClient() : factory.CreateClient(opts.HttpClientName!);
+        }
+
+        // If no factory/client, let OfrepClient create its own HttpClient
+        if (httpClient == null)
+        {
+            return new OfrepProvider(ofrepOptions); // internal client management
+        }
+
+        // Allow user to configure the HttpClient
+        opts.ConfigureHttpClient?.Invoke(sp, httpClient);
+
+        // Ensure base address/timeout/headers align with options unless already set by user
+        if (httpClient.BaseAddress == null)
+        {
+            httpClient.BaseAddress = new Uri(ofrepOptions.BaseUrl);
+        }
+        httpClient.Timeout = ofrepOptions.Timeout;
+        foreach (var header in ofrepOptions.Headers)
+        {
+            if (!httpClient.DefaultRequestHeaders.Contains(header.Key))
+            {
+                httpClient.DefaultRequestHeaders.TryAddWithoutValidation(header.Key, header.Value);
+            }
+        }
+
+        // Build OfrepClient using provided HttpClient and wire into OfrepProvider
+        var loggerFactory = sp.GetService<ILoggerFactory>();
+        var logger = loggerFactory?.CreateLogger<OfrepClient>();
+        var ofrepClient = new OfrepClient(httpClient, logger);
+        return new OfrepProvider(ofrepClient);
+    }
+}

src/OpenFeature.Providers.Ofrep/DependencyInjection/OfrepProviderOptions.cs

@@ -0,0 +1,45 @@
+#if NETFRAMEWORK
+using System.Net.Http;
+#endif
+
+namespace OpenFeature.Providers.Ofrep.DependencyInjection;
+
+/// <summary>
+/// Configuration options for registering the OfrepProvider via DI.
+/// </summary>
+public record OfrepProviderOptions
+{
+    /// <summary>
+    /// Default options name for Ofrep provider registrations.
+    /// </summary>
+    public const string DefaultName = "OfrepProvider";
+
+    /// <summary>
+    /// The base URL for the OFREP endpoint. Required.
+    /// </summary>
+    public string BaseUrl { get; set; } = string.Empty;
+
+    /// <summary>
+    /// HTTP request timeout. Defaults to 10 seconds.
+    /// </summary>
+    public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(10);
+
+    /// <summary>
+    /// Optional additional HTTP headers.
+    /// </summary>
+    public Dictionary<string, string> Headers { get; set; } = new();
+
+    /// <summary>
+    /// Optional named HttpClient to use via IHttpClientFactory.
+    /// If set, the provider will resolve an IHttpClientFactory and create the named client.
+    /// You must register the client in your ServiceCollection using AddHttpClient(name, ...).
+    /// </summary>
+    public string? HttpClientName { get; set; }
+
+    /// <summary>
+    /// Optional callback to configure the HttpClient used by the provider.
+    /// If <see cref="HttpClientName"/> is set, the named client will be resolved first and then this delegate is invoked.
+    /// If not set, a default client will be created (preferably from IHttpClientFactory if available) and then configured.
+    /// </summary>
+    public Action<IServiceProvider, HttpClient>? ConfigureHttpClient { get; set; }
+}

src/OpenFeature.Providers.Ofrep/DependencyInjection/OfrepProviderOptionsValidator.cs

@@ -0,0 +1,31 @@
+using Microsoft.Extensions.Options;
+
+namespace OpenFeature.Providers.Ofrep.DependencyInjection;
+
+/// <summary>
+/// Validator for OfrepProviderOptions to ensure required fields are set during service registration.
+/// </summary>
+internal class OfrepProviderOptionsValidator : IValidateOptions<OfrepProviderOptions>
+{
+    public ValidateOptionsResult Validate(string? name, OfrepProviderOptions options)
+    {
+        if (string.IsNullOrWhiteSpace(options.BaseUrl))
+        {
+            return ValidateOptionsResult.Fail("Ofrep BaseUrl is required. Set it on OfrepProviderOptions.BaseUrl.");
+        }
+
+        // Validate that it's a valid absolute URI
+        if (!Uri.TryCreate(options.BaseUrl, UriKind.Absolute, out var uri))
+        {
+            return ValidateOptionsResult.Fail("Ofrep BaseUrl must be a valid absolute URI.");
+        }
+
+        // Validate that it uses HTTP or HTTPS scheme (required for OFREP)
+        if (uri.Scheme != Uri.UriSchemeHttp && uri.Scheme != Uri.UriSchemeHttps)
+        {
+            return ValidateOptionsResult.Fail("Ofrep BaseUrl must use HTTP or HTTPS scheme.");
+        }
+
+        return ValidateOptionsResult.Success;
+    }
+}

src/OpenFeature.Providers.Ofrep/OfrepProvider.cs

@@ -31,6 +31,15 @@ public OfrepProvider(OfrepOptions configuration)
         this._client = new OfrepClient(configuration);
     }
 
+    /// <summary>
+    /// Creates new instance of <see cref="OfrepProvider"/> with a pre-constructed client.
+    /// </summary>
+    /// <param name="client">The OFREP client.</param>
+    internal OfrepProvider(IOfrepClient client)
+    {
+        this._client = client ?? throw new ArgumentNullException(nameof(client));
+    }
+
     /// <inheritdoc/>
     public override Task ShutdownAsync(CancellationToken cancellationToken = default)
     {

src/OpenFeature.Providers.Ofrep/OpenFeature.Providers.Ofrep.csproj

@@ -21,7 +21,8 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.Logging" Version="8.0.0"/>
-    <PackageReference Include="OpenFeature" Version="$(OpenFeatureVersion)"/>
+    <PackageReference Include="Microsoft.Extensions.Http" Version="8.0.0"/>
+    <PackageReference Include="OpenFeature.DependencyInjection" Version="$(OpenFeatureVersion)"/>
   </ItemGroup>
   <PropertyGroup>
     <OpenFeatureVersion>[2.2,2.99999]</OpenFeatureVersion>

test/OpenFeature.Providers.Ofrep.Test/Client/OfrepClientTest.cs

@@ -59,7 +59,7 @@ public void Constructor_WithValidConfiguration_ShouldInitializeSuccessfully()
     public void Constructor_WithNullConfiguration_ShouldThrowArgumentNullException()
     {
         // Arrange, Act & Assert
-        Assert.Throws<ArgumentNullException>(() => new OfrepClient(null!, this._mockLogger));
+        Assert.Throws<ArgumentNullException>(() => new OfrepClient((OfrepOptions)null!, this._mockLogger));
     }
 
     [Fact]