Allow explicit projections through abstract navigations

Author: SimonCropp

src/GraphQL.EntityFramework.Analyzers/FilterIdentityProjectionAnalyzer.cs

@@ -42,6 +42,8 @@ static void AnalyzeInvocation(SyntaxNodeAnalysisContext context)
             // Pattern 2: filters.For<T>().Add(projection: ..., filter: ...)
             if (!IsIdentityProjection(projectionLambda))
             {
+                // Explicit projections that extract specific properties from abstract navigations
+                // are ALLOWED - they produce efficient SQL. Only identity projections are problematic.
                 return;
             }
 

src/GraphQL.EntityFramework/Filters/FilterEntry.cs

@@ -42,6 +42,16 @@ static void ValidateProjectionCompatibility(
         Expression<Func<TEntity, TProjection>> projection,
         IReadOnlySet<string> requiredPropertyNames)
     {
+        // Only validate identity projections (x => x)
+        // Explicit projections that extract specific properties from abstract navigations are ALLOWED
+        // because EF Core can project scalar properties through abstract navigations efficiently.
+        // The problem only occurs with identity projections where the filter accesses abstract nav properties,
+        // which forces Include() to load all columns.
+        if (!IsIdentityProjection(projection))
+        {
+            return;
+        }
+
         // Extract navigation paths (e.g., "Parent.Property" -> navigation "Parent")
         var navigationPaths = requiredPropertyNames
             .Where(_ => _.Contains('.'))
@@ -55,7 +65,6 @@ static void ValidateProjectionCompatibility(
         }
 
         var entityType = typeof(TEntity);
-        var isIdentity = IsIdentityProjection(projection);
 
         // Check each navigation for abstract types
         foreach (var navPath in navigationPaths)
@@ -83,12 +92,11 @@ static void ValidateProjectionCompatibility(
 
             if (navType.IsAbstract)
             {
-                var projectionType = isIdentity ? "identity projection '_ => _'" : "projection that accesses abstract navigation";
                 throw new InvalidOperationException(
-                    $"Filter for '{entityType.Name}' uses {projectionType} " +
+                    $"Filter for '{entityType.Name}' uses identity projection '_ => _' " +
                     $"to access properties of abstract navigation '{navPath}' ({navType.Name}). " +
                     $"This forces Include() to load all columns from {navType.Name}. " +
-                    $"Abstract types cannot be projected. Extract only the required properties: " +
+                    $"Extract only the required properties in an explicit projection: " +
                     $"projection: e => new {{ e.Id, {navPath}Property = e.{navPath}.PropertyName }}, " +
                     $"filter: (_, _, _, proj) => proj.{navPath}Property == value");
             }

src/Tests/IntegrationTests/IntegrationTests_abstract_filter_validation.cs

@@ -1,46 +1,47 @@
 public partial class IntegrationTests
 {
     /// <summary>
-    /// Test that explicit projection accessing properties through abstract navigation throws.
-    /// DerivedChildEntity.Parent is BaseEntity (abstract), so projecting Parent.Property
-    /// should throw because abstract types cannot be projected by EF Core.
+    /// Test that explicit projection accessing properties through abstract navigation succeeds.
+    /// DerivedChildEntity.Parent is BaseEntity (abstract), but explicit projections that extract
+    /// specific scalar properties are ALLOWED because EF Core can project scalar properties
+    /// through abstract navigations efficiently. Only identity projections are problematic.
     /// </summary>
     [Fact]
-    public void Explicit_projection_with_abstract_navigation_property_throws()
+    public void Explicit_projection_with_abstract_navigation_property_succeeds()
     {
         var filters = new Filters<IntegrationDbContext>();
 
-        var exception = Assert.Throws<InvalidOperationException>(() =>
-        {
-            // Projection accesses Parent.Property where Parent is BaseEntity (abstract)
-            filters.For<DerivedChildEntity>().Add(
-                projection: c => c.Parent!.Property,
-                filter: (_, _, _, prop) => prop == "test");
-        });
+        // Projection accesses Parent.Property where Parent is BaseEntity (abstract)
+        // This is ALLOWED - EF Core generates efficient JOIN to get only the needed column
+        filters.For<DerivedChildEntity>().Add(
+            projection: c => c.Parent!.Property,
+            filter: (_, _, _, prop) => prop == "test");
 
-        Assert.Contains("abstract navigation", exception.Message, StringComparison.OrdinalIgnoreCase);
-        Assert.Contains("Parent", exception.Message);
+        // Verify the filter was registered with the expected property
+        var requiredProps = filters.GetRequiredFilterProperties<DerivedChildEntity>();
+        Assert.Contains("Parent.Property", requiredProps);
     }
 
     /// <summary>
-    /// Test that anonymous type projection with abstract navigation also throws.
-    /// Even with anonymous types, we cannot project from abstract navigations.
+    /// Test that anonymous type projection with abstract navigation succeeds.
+    /// Explicit projections (including anonymous types) that extract specific properties
+    /// through abstract navigations are ALLOWED - EF Core handles this efficiently.
     /// </summary>
     [Fact]
-    public void Anonymous_type_projection_with_abstract_navigation_throws()
+    public void Anonymous_type_projection_with_abstract_navigation_succeeds()
     {
         var filters = new Filters<IntegrationDbContext>();
 
-        var exception = Assert.Throws<InvalidOperationException>(() =>
-        {
-            // Even with anonymous type, projecting from abstract Parent throws
-            filters.For<DerivedChildEntity>().Add(
-                projection: c => new { c.Id, ParentProperty = c.Parent!.Property },
-                filter: (_, _, _, proj) => proj.ParentProperty == "test");
-        });
+        // Anonymous type projection extracting properties through abstract Parent
+        // This is ALLOWED - EF Core generates efficient SQL with JOINs
+        filters.For<DerivedChildEntity>().Add(
+            projection: c => new { c.Id, ParentProperty = c.Parent!.Property },
+            filter: (_, _, _, proj) => proj.ParentProperty == "test");
 
-        Assert.Contains("abstract navigation", exception.Message, StringComparison.OrdinalIgnoreCase);
-        Assert.Contains("Parent", exception.Message);
+        // Verify the filter was registered with expected properties
+        var requiredProps = filters.GetRequiredFilterProperties<DerivedChildEntity>();
+        Assert.Contains("Id", requiredProps);
+        Assert.Contains("Parent.Property", requiredProps);
     }
 
     /// <summary>
@@ -104,22 +105,43 @@ public void Four_parameter_filter_with_abstract_navigation_allowed_at_runtime()
     }
 
     /// <summary>
-    /// Test projecting from nested abstract navigation property.
+    /// Test projecting from nested abstract navigation property succeeds.
+    /// Explicit projections that extract specific scalar properties are allowed.
+    /// </summary>
+    [Fact]
+    public void Projection_with_nested_abstract_navigation_property_succeeds()
+    {
+        var filters = new Filters<IntegrationDbContext>();
+
+        // Accessing nested property through abstract parent is allowed for explicit projections
+        filters.For<DerivedChildEntity>().Add(
+            projection: c => c.Parent!.Status,
+            filter: (_, _, _, status) => status == "Active");
+
+        var requiredProps = filters.GetRequiredFilterProperties<DerivedChildEntity>();
+        Assert.Contains("Parent.Status", requiredProps);
+    }
+
+    /// <summary>
+    /// Test that identity projection with filter accessing abstract navigation is NOT caught at runtime.
+    /// The runtime cannot analyze the filter delegate. The GQLEF007 analyzer catches this at compile time.
     /// </summary>
     [Fact]
-    public void Projection_with_nested_abstract_navigation_property_throws()
+    public void Identity_projection_with_abstract_navigation_in_filter_not_caught_at_runtime()
     {
         var filters = new Filters<IntegrationDbContext>();
 
-        var exception = Assert.Throws<InvalidOperationException>(() =>
-        {
-            // Accessing nested property through abstract parent
-            filters.For<DerivedChildEntity>().Add(
-                projection: c => c.Parent!.Status,
-                filter: (_, _, _, status) => status == "Active");
-        });
+        // Identity projection where filter accesses abstract Parent
+        // This is NOT caught at runtime because:
+        // 1. The projection `c => c` has no property accesses to analyze
+        // 2. The filter is a compiled delegate, not an expression tree
+        // The GQLEF007 analyzer catches this at compile time instead.
+        filters.For<DerivedChildEntity>().Add(
+            projection: c => c,
+            filter: (_, _, _, c) => c.Parent!.Property == "test");
 
-        Assert.Contains("abstract navigation", exception.Message, StringComparison.OrdinalIgnoreCase);
-        Assert.Contains("Parent", exception.Message);
+        // Identity projection extracts no properties
+        var requiredProps = filters.GetRequiredFilterProperties<DerivedChildEntity>();
+        Assert.Empty(requiredProps);
     }
 }

src/Tests/UnitTests/FilterEntryValidationTests.cs

@@ -24,20 +24,20 @@ class ConcreteParent
     class TestDbContext : DbContext;
 
     [Fact]
-    public void Explicit_projection_with_abstract_navigation_property_throws()
+    public void Explicit_projection_with_abstract_navigation_property_succeeds()
     {
         var filters = new Filters<TestDbContext>();
 
-        // This should throw - projection directly accesses abstract navigation property
-        var exception = Assert.Throws<InvalidOperationException>(() =>
-        {
-            filters.For<TestEntity>().Add(
-                projection: e => e.Parent!.Property,
-                filter: (_, _, _, prop) => prop == "test");
-        });
+        // Explicit projections that extract specific properties through abstract navigations are ALLOWED
+        // because EF Core can project scalar properties through abstract navigations efficiently.
+        // Only identity projections are problematic.
+        filters.For<TestEntity>().Add(
+            projection: e => e.Parent!.Property,
+            filter: (_, _, _, prop) => prop == "test");
 
-        Assert.Contains("abstract navigation", exception.Message, StringComparison.OrdinalIgnoreCase);
-        Assert.Contains("Parent", exception.Message);
+        // Verify the filter was registered with the expected property
+        var requiredProps = filters.GetRequiredFilterProperties<TestEntity>();
+        Assert.Contains("Parent.Property", requiredProps);
     }
 
     [Fact]
@@ -52,20 +52,20 @@ public void Concrete_navigation_allows_identity_projection()
     }
 
     [Fact]
-    public void Anonymous_type_projection_with_abstract_navigation_throws()
+    public void Anonymous_type_projection_with_abstract_navigation_succeeds()
     {
         var filters = new Filters<TestDbContext>();
 
-        // This should also throw - even with anonymous type, we're projecting from abstract navigation
-        var exception = Assert.Throws<InvalidOperationException>(() =>
-        {
-            filters.For<TestEntity>().Add(
-                projection: e => new { e.Id, ParentProp = e.Parent!.Property },
-                filter: (_, _, _, proj) => proj.ParentProp == "test");
-        });
+        // Explicit projections (including anonymous types) that extract specific properties
+        // through abstract navigations are ALLOWED - EF Core handles this efficiently.
+        filters.For<TestEntity>().Add(
+            projection: e => new { e.Id, ParentProp = e.Parent!.Property },
+            filter: (_, _, _, proj) => proj.ParentProp == "test");
 
-        Assert.Contains("abstract navigation", exception.Message, StringComparison.OrdinalIgnoreCase);
-        Assert.Contains("Parent", exception.Message);
+        // Verify the filter was registered with expected properties
+        var requiredProps = filters.GetRequiredFilterProperties<TestEntity>();
+        Assert.Contains("Id", requiredProps);
+        Assert.Contains("Parent.Property", requiredProps);
     }
 
     [Fact]
@@ -90,4 +90,23 @@ public void Identity_projection_without_navigation_succeeds()
             projection: e => e,
             filter: (_, _, _, e) => e.Property == "test");
     }
+
+    [Fact]
+    public void Identity_projection_with_abstract_navigation_in_filter_not_caught_at_runtime()
+    {
+        var filters = new Filters<TestDbContext>();
+
+        // Identity projection where filter accesses abstract navigation
+        // This is NOT caught at runtime because:
+        // 1. The projection `e => e` has no property accesses to analyze
+        // 2. The filter is a compiled delegate, not an expression tree
+        // The GQLEF007 analyzer catches this at compile time instead.
+        filters.For<TestEntity>().Add(
+            projection: e => e,
+            filter: (_, _, _, e) => e.Parent!.Property == "test");
+
+        // Identity projection extracts no properties
+        var requiredProps = filters.GetRequiredFilterProperties<TestEntity>();
+        Assert.Empty(requiredProps);
+    }
 }