Merge branch 'dev', remote-tracking branch 'origin' into main

SchroterQuentin · SchroterQuentin · commit e549fa2ab8d2 · 2025-11-04T23:35:18.000+01:00
diff --git a/.github/workflows/publish-to-nuget.yml b/.github/workflows/publish-to-nuget.yml
@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        folder: [Bones, Bones.Akka, Bones.Converters, Bones.Flow, Bones.Grpc, Bones.Tests, Bones.X509, Bones.Akka.Monitoring, Bones.Monitoring]
+        folder: [Bones, Bones.Akka, Bones.AspNetCore, Bones.Converters, Bones.Flow, Bones.Grpc, Bones.Tests, Bones.X509, Bones.Akka.Monitoring, Bones.Monitoring]
     steps:
       # Checking out repository
       - name: Checkout 🛎️
diff --git a/dev/demo.flow/Demo.Flow.Console/Worker.cs b/dev/demo.flow/Demo.Flow.Console/Worker.cs
@@ -21,36 +21,48 @@ public Worker(IServiceProvider services)
         }
 
         public async Task StartAsync(CancellationToken cancellationToken)
-        {            
-                var logger = _services.GetRequiredService<ILogger<Program>>();
+        {
+            var logger = _services.GetRequiredService<ILogger<Program>>();
 
-                Activity.CurrentChanged += (sender, args) =>
+            Activity.CurrentChanged += (sender, args) =>
+            {
+                var current = Activity.Current;
+                if (current != null)
                 {
-                    var current = Activity.Current;
-                    if (current != null)
-                    {
-                        logger.LogInformation($"Activity.CurrentChanged: {current.OperationName}");
-                    }
-                };
-
-                ICommandHandler<HelloWorldCommand> helloCommandHandler = _services.GetRequiredService<ICommandHandler<HelloWorldCommand>>();
-                IQueryHandler<BoolQuery, bool> boolQueryHandler = _services.GetRequiredService<IQueryHandler<BoolQuery, bool>>();
-
-                var command = new HelloWorldCommand();
-                command.Message = "First Command";
-
-                var query = new BoolQuery();
-                query.Message = "First Query";
-
-                // while(true)
-                // {
-                    await helloCommandHandler.HandleAsync(command);
-                    // var res = await boolQueryHandler.HandleAsync(query);
-                    // System.Console.WriteLine(res);
-                    await Task.Delay(1000, cancellationToken);
-                // }
-
-                // return Task.CompletedTask;
+                    logger.LogInformation($"Activity.CurrentChanged: {current.OperationName}");
+                }
+            };
+
+            for (var i = 0; i < 10_000_000; i++)
+            {
+                using var scope = _services.CreateScope();
+
+                var stopWatch = Stopwatch.StartNew();
+                var handler = scope.ServiceProvider.GetRequiredService<ICommandHandler<HelloWorldCommand>>();
+                stopWatch.Stop();
+
+                if(i % 10_000 == 0)
+                    logger.LogInformation($"Resolved ICommandHandler<HelloWorldCommand> in {stopWatch.ElapsedMilliseconds} ms");
+            }
+
+            ICommandHandler<HelloWorldCommand> helloCommandHandler = _services.GetRequiredService<ICommandHandler<HelloWorldCommand>>();
+            IQueryHandler<BoolQuery, bool> boolQueryHandler = _services.GetRequiredService<IQueryHandler<BoolQuery, bool>>();
+
+            var command = new HelloWorldCommand();
+            command.Message = "First Command";
+
+            var query = new BoolQuery();
+            query.Message = "First Query";
+
+            // while(true)
+            // {
+            await helloCommandHandler.HandleAsync(command);
+            // var res = await boolQueryHandler.HandleAsync(query);
+            // System.Console.WriteLine(res);
+            await Task.Delay(1000, cancellationToken);
+            // }
+
+            // return Task.CompletedTask;
         }
 
         public Task StopAsync(CancellationToken cancellationToken)
diff --git a/src/Bones.AspNetCore/Bones.AspNetCore.csproj b/src/Bones.AspNetCore/Bones.AspNetCore.csproj
@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <ProjectReference Include="..\Bones.Monitoring\Bones.Monitoring.csproj" />
+  </ItemGroup>
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <Version>$(VERSION)</Version>
+    <Authors>dative-gpi</Authors>
+    <Company>dative-gpi</Company>
+  </PropertyGroup>
+
+</Project>
diff --git a/src/Bones.AspNetCore/PostAsGetMiddleware.cs b/src/Bones.AspNetCore/PostAsGetMiddleware.cs
@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using System.Threading.Tasks;
+
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Primitives;
+
+using Bones.Monitoring.Core;
+
+namespace Bones.AspNetCore
+{
+    public class PostAsGetMiddleware : MonitoredMiddleware
+    {
+        public PostAsGetMiddleware(
+            IServiceProvider serviceProvider,
+            RequestDelegate next) : base(next, serviceProvider)
+        {
+        }
+
+        protected override async Task HandleAsync(HttpContext context, RequestDelegate next)
+        {
+            if (context.Request.Method == "POST"
+                && context.Request.Query.ContainsKey("_method")
+                && context.Request.Query["_method"] == "GET"
+                && context.Request.HasJsonContentType())
+            {
+                // Convert the request to a GET request
+                context.Request.Method = "GET";
+                var doc = await JsonSerializer.DeserializeAsync<Dictionary<string, JsonElement>>(context.Request.Body);
+                if (doc != null)
+                {
+                    var props = Flat(doc);
+                    var query = $"?{String.Join("&", props.Select(kv => $"{Uri.EscapeDataString(kv.Key)}={Uri.EscapeDataString(kv.Value)}"))}";
+                    context.Request.QueryString = new QueryString(query);
+                    context.Request.Body = Stream.Null;
+                    context.Request.ContentLength = 0;
+                }
+            }
+            await next(context);
+            return;
+        }
+
+        private Dictionary<string, StringValues> Flat(Dictionary<string, JsonElement> payload)
+        {
+            Dictionary<string, StringValues> result = new Dictionary<string, StringValues>();
+            foreach (var item in payload)
+            {
+                var flatted = DeepFlat(item.Key, item.Value);
+                foreach (var flat in flatted)
+                {
+                    result.Add(flat.Key, flat.Value);
+                }
+            }
+            return result;
+        }
+
+        private IEnumerable<KeyValuePair<string, string>> DeepFlat(string key, JsonElement value)
+        {
+            switch (value.ValueKind)
+            {
+                case JsonValueKind.Array when value.GetArrayLength() == 0:
+                    return new[] { new KeyValuePair<string, string>($"{key}[]", "") };
+                case JsonValueKind.Array when value.GetArrayLength() != 0:
+                    return value.EnumerateArray().SelectMany((item, index) => DeepFlat($"{key}[{index}]", item));
+                case JsonValueKind.Object:
+                    return value.EnumerateObject().SelectMany(prop => DeepFlat($"{key}.{prop.Name}", prop.Value));
+                default:
+                    return new[] { new KeyValuePair<string, string>(key, value.ToString()) };
+            }
+        }
+    }
+}
diff --git a/src/Bones.AspNetCore/PostAsGetMiddlewareExtension.cs b/src/Bones.AspNetCore/PostAsGetMiddlewareExtension.cs
@@ -0,0 +1,12 @@
+using Microsoft.AspNetCore.Builder;
+
+namespace Bones.AspNetCore
+{
+    public static class PostAsGetMiddlewareExtension
+    {
+        public static IApplicationBuilder UsePostAsGetMiddleware(this IApplicationBuilder builder)
+        {
+            return builder.UseMiddleware<PostAsGetMiddleware>();
+        }
+    }
+}
diff --git a/src/Bones.Monitoring/Metrics/MetricFactory.cs b/src/Bones.Monitoring/Metrics/MetricFactory.cs
@@ -14,7 +14,17 @@ public MetricFactory()
 
         public ICounter<T> GetCounter<T>(string key, Meter meter, string unit = null, string description = null) where T : struct
         {
-            var counter = counters.GetOrAdd(key, new CounterMetric<T>(meter, key, unit, description));
+            object counter;
+            if (!counters.ContainsKey(key))
+            {
+                counter = new CounterMetric<T>(meter, key, unit, description);
+                counters.TryAdd(key, counter);
+            }
+            else
+            {
+                counter = counters[key];
+            }
+            
             if(counter is CounterMetric<T> typedCounter)
             {
                 return typedCounter;
@@ -27,8 +37,18 @@ public ICounter<T> GetCounter<T>(string key, Meter meter, string unit = null, st
 
         public IHistogram<T> GetHistogram<T>(string key, Meter meter, string unit = null, string description = null) where T : struct
         {
-            var counter = counters.GetOrAdd(key, new HistogramMetric<T>(meter, key, unit, description));
-            if(counter is HistogramMetric<T> typedCounter)
+            object counter;
+            if (!counters.ContainsKey(key))
+            {
+                counter = new HistogramMetric<T>(meter, key, unit, description);
+                counters.TryAdd(key, counter);
+            }
+            else
+            {
+                counter = counters[key];
+            }
+            
+            if (counter is HistogramMetric<T> typedCounter)
             {
                 return typedCounter;
             }
diff --git a/src/Bones.UI/core/composableFactory.ts b/src/Bones.UI/core/composableFactory.ts
@@ -1,4 +1,4 @@
-import { Ref, onUnmounted, ref, computed } from "vue";
+import { Ref, onUnmounted, ref, computed, computed } from "vue";
 
 import { FilterFactory } from "./filterFactory";
 import { INotifyService } from "../abstractions";
@@ -25,27 +25,6 @@ export class ComposableFactory {
         return ComposableFactory.customRemove(service.remove);
     }
 
-    public static subscribe<TDetails>(service: INotifyService<TDetails>) {
-        return () => {
-            let subscribersIds: number[] = [];
-
-            onUnmounted(() => {
-                subscribersIds.forEach(id => service.unsubscribe(id));
-                subscribersIds = [];
-            });
-
-            const subscribe: INotifyService<TDetails>["subscribe"] = (ev: any, callback: any) => {
-                const subscriberId = service.subscribe(ev, callback);
-                subscribersIds.push(subscriberId);
-                return subscriberId;
-            }
-
-            return {
-                subscribe
-            }
-        }
-    }
-
     public static custom<TDetails, TArgs extends any[]>(method: (...args: TArgs) => Promise<TDetails>, applyFactory?: () => (entity: Ref<TDetails>) => void) {
         return () => {
             const apply = applyFactory ? applyFactory() : () => { };
diff --git a/src/Bones.UI/core/serviceFactory.ts b/src/Bones.UI/core/serviceFactory.ts
@@ -36,20 +36,24 @@ export class ServiceFactory<TDetailsDTO, TDetails> {
     }
 
     addGetMany<TInfosDTO, TInfos, TFilter>(url: string | (() => string), entity: new (dto: TInfosDTO) => TInfos)
-        : { getMany: (filter?: TFilter) => Promise<TInfos[]> } {
+        : { getMany: (filter?: TFilter, controller?: AbortController) => Promise<TInfos[]> } {
 
-        const getMany = async (filter?: TFilter) => {
+        const getMany = async (filter?: TFilter, controller?: AbortController) => {
             const realUrl = typeof url === "string" ? url : url();
 
             let response;
 
             // If the service is configured to use GET as POST to prevent issues with large query strings,
             // we send the filter as a POST request with a "_method" parameter to indicate it's a GET request.
             if (ServiceFactory.getAsPost && filter) {
-                response = await ServiceFactory.http.post(buildURL(realUrl, { "_method": "GET" }), filter);
+                response = await ServiceFactory.http.post(buildURL(realUrl, { "_method": "GET" }), filter, {
+                    signal: controller?.signal
+                });
             }
             else {
-                response = await ServiceFactory.http.get(buildURL(realUrl, filter));
+                response = await ServiceFactory.http.get(buildURL(realUrl, filter), {
+                    signal: controller?.signal
+                });
             }
 
             const dtos: TInfosDTO[] = response.data;
@@ -76,7 +80,7 @@ export class ServiceFactory<TDetailsDTO, TDetails> {
         return { get };
     }
 
-    static addCustom<T extends string, TArgs extends any[], TResultDTO, TResult>(name: T, call: (axios: AxiosInstance, ...args: TArgs) => Promise<AxiosResponse>, mapper: (dto: TResultDTO) => TResult): Record<T, (...args: TArgs) => Promise<TResult>> {
+    static addCustom<T extends string, TArgs extends any[], TResultDTO, TResult>(name: T, call: (axios: AxiosInstance, ...args: TArgs) => Promise<AxiosResponse>, mapper: (dto: TResultDTO) => TResult) {
 
         const fetch = async (...args: TArgs) => {
             const response = await call(ServiceFactory.http, ...args);
@@ -90,6 +94,21 @@ export class ServiceFactory<TDetailsDTO, TDetails> {
         return { [name]: fetch } as Record<T, (...args: TArgs) => Promise<TResult>>;
     }
 
+
+    static addCustomCancellable<T extends string, TArgs extends any[], TResultDTO, TResult>(name: T, call: (axios: AxiosInstance, ...args: [...TArgs, AbortController]) => Promise<AxiosResponse>, mapper: (dto: TResultDTO) => TResult) {
+
+        const fetch = async (...args: [...TArgs, AbortController]) => {
+            const response = await call(ServiceFactory.http, ...args);
+            const dto: TResultDTO = response.data;
+
+            const result = mapper(dto);
+
+            return result;
+        }
+
+        return { [name]: fetch } as Record<T, (...args: [...TArgs, AbortController]) => Promise<TResult>>;
+    }
+
     addCreate<TCreateDTO>(url: string | (() => string))
         : { create: (dto: TCreateDTO) => Promise<TDetails> } {
 
diff --git a/tests/Bones.UI.Tests/services/testUserService.ts b/tests/Bones.UI.Tests/services/testUserService.ts
@@ -17,7 +17,7 @@ const AccountLoginFactory = new ServiceFactory<TestUserDetailsDTO, TestUserDetai
         ServiceFactory.addCustom("logout", axios => axios.get(TEST_USERS_URL), (dto: TestUserDetailsDTO) => new TestUserDetails(dto)),
         ServiceFactory.addCustom("current", axios => axios.get(TEST_USERS_URL), (dto: TestUserDetailsDTO) => new TestUserDetails(dto)),
         ServiceFactory.addCustom("complexCurrent", (axios, p1: string, p2: number) => axios.get(TEST_USERS_URL), (dto: TestUserDetailsDTO) => new TestUserDetails(dto)),
-        ServiceFactory.addCustom("complexGetMany", (axios, p1: string, p2: number) => axios.get(TEST_USERS_URL), (dto: TestUserDetailsDTO) => new Array(5).map(a => new TestUserDetails(dto))),
+        ServiceFactory.addCustomCancellable("complexGetMany", (axios, p1: string, p2: number, controller: AbortController) => axios.get(TEST_USERS_URL, { signal: controller.signal }), (dto: TestUserDetailsDTO) => new Array(5).map(a => new TestUserDetails(dto))),
     ));
 
 export const useTestUsersSync = ComposableFactory.sync<TestUserDetails, TestUserInfos>(testUserServiceFactory);
