Fixed issue where projections fallback was not possible. (#8139)

Author: michaelstaib

src/HotChocolate/Core/src/Execution.Projections/SelectionExpressionBuilder.cs

@@ -11,6 +11,32 @@ namespace HotChocolate.Execution.Projections;
 
 internal sealed class SelectionExpressionBuilder
 {
+    private static readonly NullabilityInfoContext _nullabilityInfoContext = new();
+    private static readonly HashSet<Type> _runtimeLeafTypes =
+    [
+        typeof(string),
+        typeof(byte),
+        typeof(short),
+        typeof(int),
+        typeof(long),
+        typeof(float),
+        typeof(byte),
+        typeof(decimal),
+        typeof(Guid),
+        typeof(bool),
+        typeof(char),
+        typeof(byte?),
+        typeof(short?),
+        typeof(int?),
+        typeof(long?),
+        typeof(float?),
+        typeof(byte?),
+        typeof(decimal?),
+        typeof(Guid?),
+        typeof(bool?),
+        typeof(char?)
+    ];
+
     public Expression<Func<TRoot, TRoot>> BuildExpression<TRoot>(ISelection selection)
     {
         var rootType = typeof(TRoot);
@@ -214,11 +240,27 @@ private static void TryAddAnyLeafField(
         }
         else
         {
+            // if id does not exist we will try to select any leaf field from the type.
             var anyProperty = selectionType.Fields.FirstOrDefault(t => t.Type.IsLeafType() && t.Member is PropertyInfo);
+
             if (anyProperty?.Member is PropertyInfo anyPropertyInfo)
             {
                 parent.AddOrGetNode(anyPropertyInfo);
             }
+            else
+            {
+                // if we still have not found any leaf we will inspect the runtime type and
+                // try to select any leaf property.
+                var properties = selectionType.RuntimeType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
+                foreach (var property in properties)
+                {
+                    if (_runtimeLeafTypes.Contains(property.PropertyType))
+                    {
+                        parent.AddOrGetNode(property);
+                        break;
+                    }
+                }
+            }
         }
     }
 

src/HotChocolate/Core/src/Execution/RequestExecutorResolver.cs

@@ -107,30 +107,37 @@ private async ValueTask ConsumeExecutorEvictionsAsync(
         ChannelReader<string> reader,
         CancellationToken cancellationToken)
     {
-        while (await reader.WaitToReadAsync(cancellationToken).ConfigureAwait(false))
+        try
         {
-            while (reader.TryRead(out var schemaName))
+            while (await reader.WaitToReadAsync(cancellationToken).ConfigureAwait(false))
             {
-                var semaphore = GetSemaphoreForSchema(schemaName);
-                await semaphore.WaitAsync(cancellationToken);
-
-                try
+                while (reader.TryRead(out var schemaName))
                 {
-                    if (_executors.TryGetValue(schemaName, out var previousExecutor))
+                    var semaphore = GetSemaphoreForSchema(schemaName);
+                    await semaphore.WaitAsync(cancellationToken);
+
+                    try
                     {
-                        await UpdateRequestExecutorAsync(schemaName, previousExecutor);
+                        if (_executors.TryGetValue(schemaName, out var previousExecutor))
+                        {
+                            await UpdateRequestExecutorAsync(schemaName, previousExecutor);
+                        }
+                    }
+                    catch
+                    {
+                        // Ignore
+                    }
+                    finally
+                    {
+                        semaphore.Release();
                     }
-                }
-                catch
-                {
-                    // Ignore
-                }
-                finally
-                {
-                    semaphore.Release();
                 }
             }
         }
+        catch (OperationCanceledException)
+        {
+            // ignore
+        }
     }
 
     private SemaphoreSlim GetSemaphoreForSchema(string schemaName)

src/HotChocolate/Data/test/Data.PostgreSQL.Tests/Data/CatalogContext.cs

@@ -12,6 +12,8 @@ public class CatalogContext(DbContextOptions<CatalogContext> options) : DbContex
 
     public DbSet<Brand> Brands => Set<Brand>();
 
+    public DbSet<SingleProperty> SingleProperties => Set<SingleProperty>();
+
     protected override void OnModelCreating(ModelBuilder builder)
     {
         builder.ApplyConfiguration(new BrandEntityTypeConfiguration());

src/HotChocolate/Data/test/Data.PostgreSQL.Tests/IntegrationTests.cs

@@ -360,6 +360,48 @@ public async Task Query_Products_Exclude_TotalCount()
         MatchSnapshot(result, interceptor);
     }
 
+    [Fact]
+    public async Task Ensure_That_Self_Requirement_Is_Honored()
+    {
+        // arrange
+        using var interceptor = new TestQueryInterceptor();
+
+        // act
+        var result = await ExecuteAsync(
+            """
+            {
+                singleProperties {
+                    id
+                }
+            }
+
+            """);
+
+        // assert
+        MatchSnapshot(result, interceptor);
+    }
+
+    [Fact]
+    public async Task Fallback_To_Runtime_Properties_When_No_Field_Is_Bindable()
+    {
+        // arrange
+        using var interceptor = new TestQueryInterceptor();
+
+        // act
+        var result = await ExecuteAsync(
+            """
+            {
+                singleProperties {
+                    __typename
+                }
+            }
+
+            """);
+
+        // assert
+        MatchSnapshot(result, interceptor);
+    }
+
     private static ServiceProvider CreateServer(string connectionString)
     {
         var services = new ServiceCollection();