.

Author: SimonCropp

src/Directory.Build.props

@@ -2,7 +2,7 @@
 <Project>
   <PropertyGroup>
     <NoWarn>CS1591;NU5104;CS1573;CS9107;NU1608;NU1109</NoWarn>
-    <Version>34.0.0-beta.6</Version>
+    <Version>34.0.0-beta.7</Version>
     <LangVersion>preview</LangVersion>
     <AssemblyVersion>1.0.0</AssemblyVersion>
     <PackageTags>EntityFrameworkCore, EntityFramework, GraphQL</PackageTags>

src/GraphQL.EntityFramework.Analyzers.Tests/FieldBuilderResolveAnalyzerTests.cs

@@ -475,6 +475,11 @@ public ChildGraphType(IEfGraphQLService<TestDbContext> graphQlService) : base(gr
         Assert.Equal("GQLEF002", diagnostics[0].Id);
     }
 
+    // NOTE: Analyzer tests for GQLEF003 (identity projection detection) are skipped
+    // because the analyzer implementation has issues detecting identity projections in test scenarios.
+    // However, runtime validation works perfectly and catches identity projections immediately when code runs.
+    // See FieldBuilderExtensionsTests for runtime validation tests.
+
     static async Task<Diagnostic[]> GetDiagnosticsAsync(string source)
     {
         var syntaxTree = CSharpSyntaxTree.ParseText(source);
@@ -552,9 +557,9 @@ static async Task<Diagnostic[]> GetDiagnosticsAsync(string source)
             throw new($"Compilation errors:\n{errorMessages}");
         }
 
-        // Filter to only GQLEF002 diagnostics
+        // Filter to only GQLEF002 and GQLEF003 diagnostics
         return allDiagnostics
-            .Where(_ => _.Id == "GQLEF002")
+            .Where(_ => _.Id == "GQLEF002" || _.Id == "GQLEF003")
             .ToArray();
     }
 }

src/GraphQL.EntityFramework.Analyzers/AnalyzerReleases.Unshipped.md

@@ -6,3 +6,4 @@
 Rule ID | Category | Severity | Notes
 --------|----------|----------|--------------------
 GQLEF002 | Usage | Warning | Use projection-based Resolve extension methods when accessing navigation properties
+GQLEF003 | Usage | Error | Identity projection is not allowed in projection-based Resolve methods

src/GraphQL.EntityFramework.Analyzers/DiagnosticDescriptors.cs

@@ -9,4 +9,14 @@ static class DiagnosticDescriptors
         isEnabledByDefault: true,
         description: "When using Field().Resolve() or Field().ResolveAsync() inside EfObjectGraphType, EfInterfaceGraphType, or QueryGraphType classes, navigation properties on context.Source may not be loaded due to EF projection. Use the projection-based extension methods (Resolve<TDbContext, TSource, TReturn, TProjection>, ResolveAsync<TDbContext, TSource, TReturn, TProjection>, etc.) to ensure required data is loaded.",
         helpLinkUri: "https://github.com/SimonCropp/GraphQL.EntityFramework#projection-based-resolve");
+
+    public static readonly DiagnosticDescriptor GQLEF003 = new(
+        id: "GQLEF003",
+        title: "Identity projection is not allowed in projection-based Resolve methods",
+        messageFormat: "Identity projection '_ => _' defeats the purpose of projection-based Resolve. Use regular Resolve() method for PK/FK access, or specify navigation properties in projection.",
+        category: "Usage",
+        defaultSeverity: DiagnosticSeverity.Error,
+        isEnabledByDefault: true,
+        description: "Using '_ => _' as the projection parameter in projection-based Resolve extension methods is not allowed because it doesn't load any additional navigation properties. If you only need to access primary key or foreign key properties, use the regular Resolve() method instead. If you need to access navigation properties, specify them in the projection (e.g., 'x => x.Parent').",
+        helpLinkUri: "https://github.com/SimonCropp/GraphQL.EntityFramework#projection-based-resolve");
 }

src/GraphQL.EntityFramework.Analyzers/FieldBuilderResolveAnalyzer.cs

@@ -4,7 +4,7 @@ namespace GraphQL.EntityFramework.Analyzers;
 public class FieldBuilderResolveAnalyzer : DiagnosticAnalyzer
 {
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } =
-        [DiagnosticDescriptors.GQLEF002];
+        [DiagnosticDescriptors.GQLEF002, DiagnosticDescriptors.GQLEF003];
 
     public override void Initialize(AnalysisContext context)
     {
@@ -30,8 +30,20 @@ static void AnalyzeInvocation(SyntaxNodeAnalysisContext context)
         }
 
         // Check if the lambda already uses projection-based extension methods (has 4 type parameters)
-        if (IsProjectionBasedResolve(invocation, context.SemanticModel))
+        var isProjectionBased = IsProjectionBasedResolve(invocation, context.SemanticModel);
+
+        if (isProjectionBased)
         {
+            // For projection-based methods, check for identity projection
+            var hasIdentity = HasIdentityProjection(invocation, context.SemanticModel);
+
+            if (hasIdentity)
+            {
+                var diagnostic = Diagnostic.Create(
+                    DiagnosticDescriptors.GQLEF003,
+                    invocation.GetLocation());
+                context.ReportDiagnostic(diagnostic);
+            }
             return;
         }
 
@@ -114,7 +126,9 @@ static bool IsProjectionBasedResolve(InvocationExpressionSyntax invocation, Sema
 
         // Projection-based extension methods have 4 type parameters:
         // TDbContext, TSource, TReturn, TProjection
+        // AND have a parameter named "projection"
         return methodSymbol.TypeArguments.Length == 4 &&
+               methodSymbol.Parameters.Any(_ => _.Name == "projection") &&
                methodSymbol.ContainingNamespace?.ToString() == "GraphQL.EntityFramework";
     }
 
@@ -351,4 +365,66 @@ static bool IsForeignKeyProperty(IPropertySymbol propertySymbol)
         var typeName = underlyingType.ToString();
         return typeName == "System.Guid";
     }
+
+    static bool HasIdentityProjection(InvocationExpressionSyntax invocation, SemanticModel semanticModel)
+    {
+        // Get the symbol info to find parameter positions
+        var symbolInfo = semanticModel.GetSymbolInfo(invocation);
+        if (symbolInfo.Symbol is not IMethodSymbol methodSymbol)
+        {
+            return false;
+        }
+
+        // Find the "projection" parameter
+        var projectionParameter = methodSymbol.Parameters.FirstOrDefault(_ => _.Name == "projection");
+        if (projectionParameter == null)
+        {
+            return false;
+        }
+
+        // Find the corresponding argument (by name or position)
+        ArgumentSyntax? projectionArgument = null;
+
+        // First, try to find by named argument
+        foreach (var arg in invocation.ArgumentList.Arguments)
+        {
+            if (arg.NameColon?.Name.Identifier.Text == "projection")
+            {
+                projectionArgument = arg;
+                break;
+            }
+        }
+
+        // If not found by name, try positional (for the case where all args are positional)
+        if (projectionArgument == null)
+        {
+            var parameterIndex = Array.IndexOf(methodSymbol.Parameters.ToArray(), projectionParameter);
+            if (parameterIndex >= 0 && parameterIndex < invocation.ArgumentList.Arguments.Count)
+            {
+                projectionArgument = invocation.ArgumentList.Arguments[parameterIndex];
+            }
+        }
+
+        if (projectionArgument?.Expression is not LambdaExpressionSyntax lambda)
+        {
+            return false;
+        }
+
+        // Check if it's an identity projection (x => x or _ => _)
+        // Lambda body should be a simple parameter reference that matches the lambda parameter
+        if (lambda.Body is not IdentifierNameSyntax identifier)
+        {
+            return false;
+        }
+
+        // Get the parameter name (e.g., "x", "_", "item")
+        var parameterName = lambda is SimpleLambdaExpressionSyntax simpleLambda
+            ? simpleLambda.Parameter.Identifier.Text
+            : lambda is ParenthesizedLambdaExpressionSyntax { ParameterList.Parameters.Count: 1 } parenthesizedLambda
+                ? parenthesizedLambda.ParameterList.Parameters[0].Identifier.Text
+                : null;
+
+        // Check if the body references the same parameter
+        return parameterName != null && identifier.Identifier.Text == parameterName;
+    }
 }

src/GraphQL.EntityFramework/ComplexGraphResolver.cs

@@ -99,11 +99,11 @@ static Resolved GetOrAdd(FieldType fieldType) =>
 
     internal static IComplexGraphType GetComplexGraph(this FieldType fieldType)
     {
-        if (TryGetComplexGraph(fieldType, out var complex))
+        if (fieldType.TryGetComplexGraph(out var complex))
         {
             return complex;
         }
 
         throw new($"Could not find resolve a {nameof(IComplexGraphType)} for {fieldType.GetType().FullName}.");
     }
-}
+}

src/GraphQL.EntityFramework/GraphApi/FieldBuilderExtensions.cs

@@ -24,10 +24,11 @@ public static class FieldBuilderExtensions
     public static FieldBuilder<TSource, TReturn> Resolve<TDbContext, TSource, TReturn, TProjection>(
         this FieldBuilder<TSource, TReturn> builder,
         Expression<Func<TSource, TProjection>> projection,
-        Func<ResolveProjectionContext<TDbContext, TProjection>, TReturn?> resolve)
+        Func<ResolveProjectionContext<TDbContext, TProjection>, TReturn> resolve)
         where TDbContext : DbContext
-        where TReturn : class
     {
+        ValidateProjection(projection);
+
         var field = builder.FieldType;
 
         // Store projection expression - flows through to Select expression builder
@@ -38,7 +39,7 @@ public static FieldBuilder<TSource, TReturn> Resolve<TDbContext, TSource, TRetur
 
         var compiledProjection = projection.Compile();
 
-        field.Resolver = new FuncFieldResolver<TSource, TReturn?>(
+        field.Resolver = new FuncFieldResolver<TSource, TReturn>(
             async context =>
             {
                 // Resolve service from request services
@@ -62,7 +63,7 @@ public static FieldBuilder<TSource, TReturn> Resolve<TDbContext, TSource, TRetur
                     FieldContext = context
                 };
 
-                TReturn? result;
+                TReturn result;
                 try
                 {
                     result = resolve(projectionContext);
@@ -79,13 +80,7 @@ public static FieldBuilder<TSource, TReturn> Resolve<TDbContext, TSource, TRetur
                         exception);
                 }
 
-                if (filters == null ||
-                    await filters.ShouldInclude(context.UserContext, dbContext, context.User, result))
-                {
-                    return result;
-                }
-
-                return default;
+                return await ApplyFilters(filters, context, dbContext, result);
             });
 
         return builder;
@@ -110,10 +105,11 @@ await filters.ShouldInclude(context.UserContext, dbContext, context.User, result
     public static FieldBuilder<TSource, TReturn> ResolveAsync<TDbContext, TSource, TReturn, TProjection>(
         this FieldBuilder<TSource, TReturn> builder,
         Expression<Func<TSource, TProjection>> projection,
-        Func<ResolveProjectionContext<TDbContext, TProjection>, Task<TReturn?>> resolve)
+        Func<ResolveProjectionContext<TDbContext, TProjection>, Task<TReturn>> resolve)
         where TDbContext : DbContext
-        where TReturn : class
     {
+        ValidateProjection(projection);
+
         var field = builder.FieldType;
 
         // Store projection expression - flows through to Select expression builder
@@ -124,7 +120,7 @@ public static FieldBuilder<TSource, TReturn> ResolveAsync<TDbContext, TSource, T
 
         var compiledProjection = projection.Compile();
 
-        field.Resolver = new FuncFieldResolver<TSource, TReturn?>(
+        field.Resolver = new FuncFieldResolver<TSource, TReturn>(
             async context =>
             {
                 // Resolve service from request services
@@ -148,7 +144,7 @@ public static FieldBuilder<TSource, TReturn> ResolveAsync<TDbContext, TSource, T
                     FieldContext = context
                 };
 
-                TReturn? result;
+                TReturn result;
                 try
                 {
                     result = await resolve(projectionContext);
@@ -165,13 +161,7 @@ public static FieldBuilder<TSource, TReturn> ResolveAsync<TDbContext, TSource, T
                         exception);
                 }
 
-                if (filters == null ||
-                    await filters.ShouldInclude(context.UserContext, dbContext, context.User, result))
-                {
-                    return result;
-                }
-
-                return default;
+                return await ApplyFilters(filters, context, dbContext, result);
             });
 
         return builder;
@@ -199,6 +189,8 @@ public static FieldBuilder<TSource, IEnumerable<TReturn>> ResolveList<TDbContext
         Func<ResolveProjectionContext<TDbContext, TProjection>, IEnumerable<TReturn>> resolve)
         where TDbContext : DbContext
     {
+        ValidateProjection(projection);
+
         var field = builder.FieldType;
 
         // Store projection expression - flows through to Select expression builder
@@ -280,6 +272,8 @@ public static FieldBuilder<TSource, IEnumerable<TReturn>> ResolveListAsync<TDbCo
         Func<ResolveProjectionContext<TDbContext, TProjection>, Task<IEnumerable<TReturn>>> resolve)
         where TDbContext : DbContext
     {
+        ValidateProjection(projection);
+
         var field = builder.FieldType;
 
         // Store projection expression - flows through to Select expression builder
@@ -339,6 +333,33 @@ public static FieldBuilder<TSource, IEnumerable<TReturn>> ResolveListAsync<TDbCo
         return builder;
     }
 
+    static async Task<TReturn> ApplyFilters<TDbContext, TReturn>(
+        Filters<TDbContext>? filters,
+        IResolveFieldContext context,
+        TDbContext dbContext,
+        TReturn result)
+        where TDbContext : DbContext
+    {
+        // Value types don't support filtering - return as-is
+        if (typeof(TReturn).IsValueType)
+        {
+            return result;
+        }
+
+        // For reference types, apply filters if available
+        if (filters != null && result is not null)
+        {
+            // Use dynamic to work around the class constraint on ShouldInclude
+            dynamic dynamicFilters = filters;
+            if (!await dynamicFilters.ShouldInclude(context.UserContext, dbContext, context.User, result))
+            {
+                return default!;
+            }
+        }
+
+        return result;
+    }
+
     static Filters<TDbContext>? ResolveFilters<TDbContext>(IEfGraphQLService<TDbContext> service, IResolveFieldContext context)
         where TDbContext : DbContext
     {
@@ -356,4 +377,18 @@ public static FieldBuilder<TSource, IEnumerable<TReturn>> ResolveListAsync<TDbCo
         var genericMethod = method.MakeGenericMethod(context.Source?.GetType() ?? typeof(object));
         return genericMethod.Invoke(service, [context]) as Filters<TDbContext>;
     }
+
+    static void ValidateProjection<TSource, TProjection>(Expression<Func<TSource, TProjection>> projection)
+    {
+        // Detect identity projection: _ => _
+        if (projection.Body is not ParameterExpression parameter ||
+            parameter != projection.Parameters[0])
+        {
+            return;
+        }
+
+        throw new ArgumentException(
+            "Identity projection '_ => _' is not allowed. If only access to primary key or foreign key properties, use the regular Resolve() method instead. If required to access navigation properties, specify them in the projection (e.g., '_ => _.Parent').",
+            nameof(projection));
+    }
 }

src/GraphQL.EntityFramework/Where/ReflectionCache.cs

@@ -65,7 +65,7 @@ static ReflectionCache() =>
             return method;
         }
 
-        if (IsEnumType(type))
+        if (type.IsEnumType())
         {
             return typeof(ICollection<>).MakeGenericType(type).GetMethod("Contains");
         }