Fix NRE when ParentRequires targets a composite type (#9789)

Author: tobias-tengler

src/HotChocolate/Data/src/Data/Projections/Optimizers/QueryableRequirementsProjectionOptimizer.cs

@@ -135,7 +135,7 @@ private static FieldNode CreateFieldNode(
     {
         if (requirements.Count == 0)
         {
-            return null;
+            return CreateWholeObjectSelectionSet(namedType);
         }
 
         var mergedNode = new TypeNode(requirements[0].Type);
@@ -170,6 +170,29 @@ private static FieldNode CreateFieldNode(
         return selections.Count == 0 ? null : new SelectionSetNode(selections);
     }
 
+    private static SelectionSetNode? CreateWholeObjectSelectionSet(ITypeDefinition namedType)
+    {
+        // A composite requirement without an explicit sub-selection requires the whole object.
+        // We emit a __typename-only selection set so the operation compiles, and the queryable
+        // projection then binds the entire object reference instead of reconstructing its
+        // members (see QueryableProjectionFieldHandler), matching SelectionExpressionBuilder.
+        if (namedType.IsLeafType())
+        {
+            return null;
+        }
+
+        return new SelectionSetNode(
+        [
+            new FieldNode(
+                null,
+                new NameNode(IntrospectionFieldNames.TypeName),
+                null,
+                [],
+                [],
+                null)
+        ]);
+    }
+
     private static bool TryGetField(
         ObjectType type,
         PropertyInfo property,

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

@@ -1,9 +1,11 @@
+using System.Data.Common;
+using System.Text.Json;
 using HotChocolate.Execution;
 using HotChocolate.Execution.Processing;
 using HotChocolate.Types;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.Extensions.DependencyInjection;
-using System.Text.Json;
 
 namespace HotChocolate.Data;
 
@@ -20,6 +22,91 @@ public IntegrationTests(AuthorFixture authorFixture)
         _singleOrDefaultAuthors = authorFixture.Context.SingleOrDefaultAuthors;
     }
 
+    [Fact]
+    public async Task Projection_Should_ProjectRequiredNavigation_When_ParentRequiresObject()
+    {
+        // arrange
+        var fileName = Guid.NewGuid().ToString("N") + ".db";
+        var connectionString = "Data Source=" + fileName;
+        var sql = new List<string>();
+
+        try
+        {
+            await using (var seed = new BookContext(
+                new DbContextOptionsBuilder<BookContext>().UseSqlite(connectionString).Options))
+            {
+                await seed.Database.EnsureCreatedAsync();
+                seed.Authors.Add(
+                    new Author { Id = 1, Name = "Foo", Books = { new Book { Id = 1, Title = "Foo1" } } });
+                await seed.SaveChangesAsync();
+            }
+
+            var result = await new ServiceCollection()
+                .AddDbContext<BookContext>(
+                    b => b
+                        .UseSqlite(connectionString)
+                        .AddInterceptors(new SqlCapturingInterceptor(sql)))
+                .AddGraphQL()
+                .AddProjections()
+                .AddQueryType(
+                    d => d
+                        .Name("Query")
+                        .Field("books")
+                        .Resolve(ctx => ctx.Service<BookContext>().Books)
+                        .UseProjection())
+                .AddObjectType<Book>(
+                    d =>
+                    {
+                        d.Field(b => b.Title);
+                        d.Field("authorInfo")
+                            .Type<ObjectType<Author>>()
+                            .Resolve(ctx => ctx.Parent<Book>().Author)
+                            .ParentRequires<Book>(b => b.Author!);
+                    })
+                .ModifyRequestOptions(o => o.IncludeExceptionDetails = true)
+                .ExecuteRequestAsync("{ books { title authorInfo { name } } }");
+
+            // assert
+            // The SQL must join and select the Authors columns, proving the required navigation
+            // is projected from the database rather than relying on an in-memory object graph.
+            Snapshot
+                .Create(
+                    postFix: TestEnvironment.TargetFramework == "NET10_0"
+                        ? TestEnvironment.TargetFramework
+                        : null)
+                .Add(string.Join("\n", sql), "SQL")
+                .Add(result, "Result")
+                .MatchMarkdownSnapshot();
+        }
+        finally
+        {
+            Microsoft.Data.Sqlite.SqliteConnection.ClearAllPools();
+            File.Delete(fileName);
+        }
+    }
+
+    private sealed class SqlCapturingInterceptor(List<string> queries) : DbCommandInterceptor
+    {
+        public override InterceptionResult<DbDataReader> ReaderExecuting(
+            DbCommand command,
+            CommandEventData eventData,
+            InterceptionResult<DbDataReader> result)
+        {
+            queries.Add(command.CommandText);
+            return base.ReaderExecuting(command, eventData, result);
+        }
+
+        public override ValueTask<InterceptionResult<DbDataReader>> ReaderExecutingAsync(
+            DbCommand command,
+            CommandEventData eventData,
+            InterceptionResult<DbDataReader> result,
+            CancellationToken cancellationToken = default)
+        {
+            queries.Add(command.CommandText);
+            return base.ReaderExecutingAsync(command, eventData, result, cancellationToken);
+        }
+    }
+
     [Fact]
     public async Task ExecuteAsync_Should_ReturnAllItems_When_ToListAsync()
     {

src/HotChocolate/Data/test/Data.EntityFramework.Tests/__snapshots__/IntegrationTests.Projection_Should_ProjectRequiredNavigation_When_ParentRequiresObject.md

@@ -0,0 +1,26 @@
+# Projection_Should_ProjectRequiredNavigation_When_ParentRequiresObject
+
+## SQL
+
+```text
+SELECT "b"."Title", "a"."Id", "a"."Name"
+FROM "Books" AS "b"
+INNER JOIN "Authors" AS "a" ON "b"."AuthorId" = "a"."Id"
+```
+
+## Result
+
+```json
+{
+  "data": {
+    "books": [
+      {
+        "title": "Foo1",
+        "authorInfo": {
+          "name": "Foo"
+        }
+      }
+    ]
+  }
+}
+```

src/HotChocolate/Data/test/Data.EntityFramework.Tests/__snapshots__/IntegrationTests.Projection_Should_ProjectRequiredNavigation_When_ParentRequiresObject_NET10_0.md

@@ -0,0 +1,26 @@
+# Projection_Should_ProjectRequiredNavigation_When_ParentRequiresObject
+
+## SQL
+
+```text
+SELECT "b"."Title", "a"."Id", "a"."Name"
+FROM "Books" AS "b"
+INNER JOIN "Authors" AS "a" ON "b"."AuthorId" = "a"."Id"
+```
+
+## Result
+
+```json
+{
+  "data": {
+    "books": [
+      {
+        "title": "Foo1",
+        "authorInfo": {
+          "name": "Foo"
+        }
+      }
+    ]
+  }
+}
+```

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

@@ -33,6 +33,42 @@ public async Task Projection_Should_NotBreakProjections_When_ExtensionsFieldRequ
         result.MatchSnapshot();
     }
 
+    [Fact]
+    public async Task Projection_Should_NotThrow_When_ParentRequiresObjectField()
+    {
+        // arrange
+        var executor = await new ServiceCollection()
+            .AddGraphQL()
+            .AddQueryType(q => q
+                .Field("foo")
+                .Resolve(_ => new[] { new RequiresFoo { Bar = new RequiresBar { Baz = "baz" } } }.AsQueryable())
+                .UseProjection())
+            .AddObjectType<RequiresFoo>(c =>
+            {
+                c.Field(f => f.Bar);
+                c.Field("quux")
+                    .Resolve(ctx => ctx.Parent<RequiresFoo>().Bar)
+                    .ParentRequires<RequiresFoo>(f => f.Bar!);
+            })
+            .AddProjections()
+            .BuildRequestExecutorAsync();
+
+        // act
+        var result = await executor.ExecuteAsync(
+            """
+            query {
+                foo {
+                    quux {
+                        baz
+                    }
+                }
+            }
+            """);
+
+        // assert
+        result.MatchSnapshot();
+    }
+
     [Fact]
     public async Task Projection_Should_NotBreakProjections_When_ExtensionsListRequested()
     {
@@ -652,6 +688,16 @@ public class Foo
     public string FieldOfFoo => "fieldOfFoo";
 }
 
+public class RequiresFoo
+{
+    public RequiresBar? Bar { get; set; }
+}
+
+public class RequiresBar
+{
+    public string? Baz { get; set; }
+}
+
 public class Baz
 {
     public string? Bar2 { get; set; }

src/HotChocolate/Data/test/Data.Projections.Tests/__snapshots__/IntegrationTests.Projection_Should_NotThrow_When_ParentRequiresObjectField.snap

@@ -0,0 +1,11 @@
+{
+  "data": {
+    "foo": [
+      {
+        "quux": {
+          "baz": "baz"
+        }
+      }
+    ]
+  }
+}