Feature / Communication Beta

Directory.Packages.props

@@ -20,6 +20,7 @@
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
     <PackageVersion Include="Moq" Version="4.20.70" />
     <PackageVersion Include="MySql.Data" Version="8.3.0" />
+    <PackageVersion Include="Newtonsoft.Json" Version="13.0.3" />
     <PackageVersion Include="NHibernate" Version="5.5.0" />
     <PackageVersion Include="NUnit" Version="4.0.1" />
     <PackageVersion Include="NUnit3TestAdapter" Version="4.5.0" />
@@ -28,5 +29,5 @@
     <PackageVersion Include="Swashbuckle.AspNetCore" Version="6.5.0" />
     <PackageVersion Include="System.Data.SQLite" Version="1.0.118" />
   </ItemGroup>
-  
+
 </Project>

docs/blueprints/service.md

@@ -29,6 +29,7 @@ Layers in this blueprint are;
 | Data Access          | +   | +    |
 | Dependency Injection | +   | +    |
 | Domain               | +   | +    |
+| Http Client          | +   |      |
 | Http Server          | +   |      |
 | Monitoring           | +   | +    |
 | Rest Api             | +   | +    |
@@ -40,6 +41,7 @@ Features with default options are;
 | ------------------ | ------------- | --------------- | -------- |
 | Business           | Default       | Default         | Yes      |
 | Caching            | Scoped Memory | Scoped Memory   |          |
+| Communication      | Http          | Mock            |          |
 | Core               | Dotnet        | Mock            |          |
 | Database           | Sqlite        | InMemory        | Yes      |
 | Documentation      | Default       |                 |          |

docs/features/communication.md

@@ -0,0 +1,40 @@
+# Communication
+
+Add this feature using `AddCommunication()` extension;
+
+```csharp
+app.Features.AddCommunication(...);
+```
+
+## Http
+
+This feature provides an `IClient<>` implementation and adds descriptors for 
+configured named clients from _app.settings_
+
+```csharp
+c => c.Http()
+```
+```json
+"Communication": {
+    "Http": {
+        "MyService": {
+            "BaseAddress": "http://api.backend.com",
+            "DefaultHeaders": {
+                "User-Agent": ".NET Http Client"
+            }
+        }
+    }
+}
+```
+
+## Mock
+
+Adds a mock implementation to be used in testing with `MockClientConfiguration`
+
+```csharp
+communication: c => c.Mock(defaultResponses: response =>
+{
+    response.ForClient<MyService>("""{ "value": "test result" }""");
+    response.ForClient<MyOtherService>(new { value = "path1 response" }, when: r => r.UrlOrPath.Equals("path1"));
+})
+```

docs/layers/http-client.md

@@ -0,0 +1,30 @@
+# Http Client
+
+DO uses ASP.NET Core's `IHttpClientFactory` and related services for providing 
+clients for http requests and responses.
+
+```csharp
+app.Layers.AddHttpClient();
+```
+
+## Configuration Targets
+
+`HttpClient` layer provides `List<HttpClientDescriptor>` which is used to add
+named configuration delegates for `IHttpClientBuilder`. 
+
+### `List<HttpClientDescriptor>`
+
+This target is provided in `AddServices` phase as the target. To configure it 
+in a feature;
+
+```csharp
+configurator.ConfigureHttpClient(clients =>
+{
+    ...
+});
+```
+
+> :information_source:
+>
+> Descriptor with name "Default" is added as a default builder delegate for all
+> created http clients 

src/blueprints/Do.Blueprints.Service.Application/Communication/CommunicationConfigurator.cs

@@ -0,0 +1,3 @@
+namespace Do.Communication;
+
+public class CommunicationConfigurator { }

src/blueprints/Do.Blueprints.Service.Application/Communication/CommunicationExtensions.cs

@@ -0,0 +1,10 @@
+using Do.Architecture;
+using Do.Communication;
+
+namespace Do;
+
+public static class CommunicationExtensions
+{
+    public static void AddCommunication(this List<IFeature> source, Func<CommunicationConfigurator, IFeature<CommunicationConfigurator>> configure) =>
+        source.Add(configure(new()));
+}

src/blueprints/Do.Blueprints.Service.Application/Communication/Http/Client.cs

@@ -0,0 +1,47 @@
+using Microsoft.Extensions.Logging;
+using System.Text;
+
+namespace Do.Communication.Http;
+
+public class Client<T>(
+    ILogger<Client<T>> _logger,
+    HttpClientFactory<T> _clientFactory
+) : IClient<T>
+{
+    public async Task<Response> Send(Request request)
+    {
+        var req = new HttpRequestMessage(request.Method, request.UrlOrPath);
+
+        if (request.Content is not null && !string.IsNullOrWhiteSpace(request.Content.Body))
+        {
+            req.Content = new StringContent(request.Content.Body, Encoding.UTF8, request.Content.Type);
+        }
+
+        foreach (var (name, value) in request.Headers)
+        {
+            if (string.IsNullOrWhiteSpace(value)) { continue; }
+
+            req.Headers.Add(name, value);
+        }
+
+        var client = _clientFactory.Create();
+        var res = await client.SendAsync(req);
+        var content = await res.Content.ReadAsStringAsync();
+
+        try
+        {
+            res.EnsureSuccessStatusCode();
+        }
+        catch (HttpRequestException ex)
+        {
+            if (ex.StatusCode is not null && (int)ex.StatusCode >= 500)
+            {
+                _logger.LogError(ex, ex.Message);
+            }
+
+            throw new ClientException(content, ex);
+        }
+
+        return new(content);
+    }
+}

src/blueprints/Do.Blueprints.Service.Application/Communication/Http/ClientConfig.cs

@@ -0,0 +1,6 @@
+namespace Do.Communication.Http;
+
+public record ClientConfig(
+    Uri? BaseAddress = default,
+    Dictionary<string, string>? DefaultHeaders = default
+);

src/blueprints/Do.Blueprints.Service.Application/Communication/Http/DictionaryExtensions.cs

@@ -0,0 +1,21 @@
+namespace System;
+
+internal static class DictionaryExtensions
+{
+    internal static Dictionary<string, string> Merge(this Dictionary<string, string>? source, Dictionary<string, string>? input)
+    {
+        source ??= [];
+        input ??= [];
+
+        foreach (var (key, value) in input)
+        {
+            if (!source.ContainsKey(key))
+            {
+                source[key] = value;
+            }
+        }
+
+        return source;
+    }
+}
+

src/blueprints/Do.Blueprints.Service.Application/Communication/Http/HttpClientFactory.cs

@@ -0,0 +1,6 @@
+namespace Do.Communication.Http;
+
+public class HttpClientFactory<T>(IHttpClientFactory _httpClientFactory)
+{
+    public System.Net.Http.HttpClient Create() => _httpClientFactory.CreateClient(typeof(T).Name);
+}

src/blueprints/Do.Blueprints.Service.Application/Communication/Http/HttpCommunicationExtensions.cs

@@ -0,0 +1,9 @@
+using Do.Communication;
+using Do.Communication.Http;
+
+namespace Do;
+
+public static class HttpCommunicationExtensions
+{
+    public static HttpCommunicationFeature Http(this CommunicationConfigurator _) => new();
+}

src/blueprints/Do.Blueprints.Service.Application/Communication/Http/HttpCommunicationFeature.cs

@@ -0,0 +1,36 @@
+using Do.Architecture;
+using Do.HttpClient;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Do.Communication.Http;
+
+public class HttpCommunicationFeature : IFeature<CommunicationConfigurator>
+{
+    public void Configure(LayerConfigurator configurator)
+    {
+        configurator.ConfigureTypeCollection(types => types.Add(typeof(IClient<>)));
+
+        configurator.ConfigureHttpClients(descriptors =>
+        {
+            var configurations = Settings.Optional<Dictionary<string, ClientConfig>>("Communication:Http", []).GetSection() ?? [];
+            configurations.TryGetValue(HttpClientLayer.DefaultConfigKey, out var defaultSettings);
+
+            foreach (var (key, (baseAddress, defaultHeaders)) in configurations)
+            {
+                descriptors.Add(
+                    new(
+                        Name: key,
+                        BaseAddress: baseAddress ?? defaultSettings?.BaseAddress,
+                        DefaultHeaders: defaultHeaders.Merge(defaultSettings?.DefaultHeaders)
+                    )
+                );
+            }
+        });
+
+        configurator.ConfigureServiceCollection(serviceCollection =>
+        {
+            serviceCollection.AddSingleton(typeof(HttpClientFactory<>));
+            serviceCollection.AddSingleton(typeof(IClient<>), typeof(Client<>));
+        });
+    }
+}

src/blueprints/Do.Blueprints.Service.Application/Communication/Mock/DefaultResponseBuilder.cs

@@ -0,0 +1,59 @@
+using Do.Testing;
+using Moq;
+using Newtonsoft.Json;
+using System.Reflection;
+
+namespace Do.Communication.Mock;
+
+public class DefaultResponseBuilder
+{
+    static readonly MethodInfo _setupClient = typeof(DefaultResponseBuilder).GetMethod(nameof(SetupClient), BindingFlags.Static | BindingFlags.NonPublic)
+        ?? throw new("SetupClient<T> should have existed");
+
+    static void SetupClient<T>(Mock<IClient<T>> mock, List<(string response, Func<Request, bool> when)> setups)
+        where T : class
+    {
+        foreach (var (response, when) in setups)
+        {
+            mock.Setup(c => c.Send(It.Is<Request>(r => when(r))))
+                .ReturnsAsync(new Response(response));
+        }
+    }
+
+    readonly Dictionary<Type, List<(string? response, Func<Request, bool> when)>> _setups = [];
+
+    public void ForClient<T>(object response,
+        Func<Request, bool>? when = default
+    ) where T : class =>
+        ForClient<T>(JsonConvert.SerializeObject(response), when);
+
+    public void ForClient<T>(string responseString,
+        Func<Request, bool>? when = default
+    ) where T : class
+    {
+        when ??= _ => true;
+
+        if (!_setups.TryGetValue(typeof(T), out var setups))
+        {
+            setups = _setups[typeof(T)] = [];
+        }
+
+        setups.Add((responseString, when));
+    }
+
+    internal IMockCollection BuildMockClients()
+    {
+        var result = new MockCollection();
+
+        foreach (var (type, setups) in _setups)
+        {
+            result.Add(
+                service: typeof(IClient<>).MakeGenericType(type),
+                singleton: true,
+                setup: mock => _setupClient.MakeGenericMethod(type).Invoke(null, [mock, setups])
+            );
+        }
+
+        return result;
+    }
+}

src/blueprints/Do.Blueprints.Service.Application/Communication/Mock/MockCommunicationExtensions.cs

@@ -0,0 +1,9 @@
+using Do.Communication;
+using Do.Communication.Mock;
+
+namespace Do;
+
+public static class MockCommunicationExtensions
+{
+    public static MockCommunicationFeature Mock(this CommunicationConfigurator _, Action<DefaultResponseBuilder>? defaultResponses = default) => new(defaultResponses ?? (_ => { }));
+}

src/blueprints/Do.Blueprints.Service.Application/Communication/Mock/MockCommunicationFeature.cs

@@ -0,0 +1,21 @@
+using Do.Architecture;
+
+namespace Do.Communication.Mock;
+
+public class MockCommunicationFeature(Action<DefaultResponseBuilder> _setupDefaultResponses)
+    : IFeature<CommunicationConfigurator>
+{
+    public void Configure(LayerConfigurator configurator)
+    {
+        configurator.ConfigureTestConfiguration(tests =>
+        {
+            var builder = new DefaultResponseBuilder();
+            _setupDefaultResponses(builder);
+
+            foreach (var descriptor in builder.BuildMockClients())
+            {
+                tests.Mocks.Add(descriptor);
+            }
+        });
+    }
+}

src/blueprints/Do.Blueprints.Service.Application/Configuration/Setting.cs

@@ -18,4 +18,8 @@ internal Setting(Func<IConfiguration> getConfiguration, string? key, T? defaultV
     public T GetValue() =>
         (_key is not null ? _getConfiguration().GetValue(_key, _defaultValue) : _defaultValue) ??
         throw new ConfigurationRequiredException($"Config required for {_key}");
+
+    public T? GetSection() =>
+        _key is not null ? _getConfiguration().GetSection(_key).Get<T>() ?? _defaultValue :
+        throw new ConfigurationRequiredException($"Config required for {_key}");
 }

src/blueprints/Do.Blueprints.Service.Application/Database/FlatTransactionMiddleware.cs

@@ -1,4 +1,5 @@
 using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Features;
 using Microsoft.Extensions.DependencyInjection;
 using NHibernate;
 
@@ -10,6 +11,14 @@ public class FlatTransactionMiddleware(RequestDelegate _next)
 {
     public async Task InvokeAsync(HttpContext context)
     {
+        var metadata = context.Features.Get<IEndpointFeature>()?.Endpoint?.Metadata;
+        if (metadata?.GetMetadata<NoTransactionAttribute>() is not null)
+        {
+            await _next(context);
+
+            return;
+        }
+
         using (var session = context.RequestServices.GetRequiredService<ISession>())
         {
             session.BeginTransaction();

src/blueprints/Do.Blueprints.Service.Application/Database/NoTransactionAttribute.cs

@@ -0,0 +1,3 @@
+namespace Do.Database;
+
+public class NoTransactionAttribute : Attribute { }