Fix: Enum-deserialization from _Any-type with ReferenceResolver

src/HotChocolate/ApolloFederation/src/ApolloFederation/Resolvers/ArgumentParser.cs

@@ -64,8 +64,14 @@ private static bool TryGetValue<T>(
             case SyntaxKind.IntValue:
             case SyntaxKind.FloatValue:
             case SyntaxKind.BooleanValue:
-                if (type.NamedType() is not ScalarType scalarType)
+                var namedType = type.NamedType();
+                if (namedType is not ScalarType scalarType)
                 {
+                    if (namedType is EnumType)
+                    {
+                        goto case SyntaxKind.EnumValue;
+                    }
+
                     break;
                 }
 

src/HotChocolate/ApolloFederation/test/ApolloFederation.Tests/EntitiesResolverForObjectTests.cs

@@ -242,10 +242,38 @@ public async Task TestDetailFieldResolver_Optional()
         Assert.Equal("testId", obj.Detail!.Id);
     }
 
+    [Fact]
+    public async Task TestResolveViaStronglyTypedEntityResolver_EnumType()
+    {
+        var schema = await new ServiceCollection()
+            .AddGraphQL()
+            .AddApolloFederation()
+            .AddQueryType<Query>()
+            .BuildSchemaAsync();
+
+        var context = CreateResolverContext(schema);
+
+        // act
+        var representations = new List<Representation>
+        {
+            new("TypeWithEnumAndStronglyTypedReferenceResolver",
+                new ObjectValueNode(
+                    new ObjectFieldNode("id", "42"),
+                    new ObjectFieldNode("enumValue", "BAR")))
+        };
+
+        // assert
+        var result = await EntitiesResolver.ResolveAsync(schema, representations, context);
+        var obj = Assert.IsType<TypeWithEnumAndStronglyTypedReferenceResolver>(result[0]);
+        Assert.Equal("42", obj.Id);
+        Assert.Equal(TestEnum.Bar, obj.EnumValue);
+    }
+
     public class Query
     {
         public ForeignType ForeignType { get; set; } = null!;
         public TypeWithReferenceResolver TypeWithReferenceResolver { get; set; } = null!;
+        public TypeWithEnumAndStronglyTypedReferenceResolver TypeWithEnumAndStronglyTypedReferenceResolver { get; set; } = null!;
         public TypeWithoutRefResolver TypeWithoutRefResolver { get; set; } = null!;
         public MixedFieldTypes MixedFieldTypes { get; set; } = null!;
         public FederatedType TypeWithReferenceResolverMany { get; set; } = null!;
@@ -261,7 +289,6 @@ public class TypeWithReferenceResolver
     {
         public string Id { get; set; } = null!;
         public string SomeField { get; set; } = null!;
-
         public static TypeWithReferenceResolver Get([LocalState] ObjectValueNode data)
         {
             return new TypeWithReferenceResolver { Id = "1", SomeField = "SomeField" };
@@ -402,4 +429,24 @@ public class FederatedTypeDetail
     {
         public string Id { get; set; } = null!;
     }
+
+    public enum TestEnum
+    {
+        Default,
+        Foo,
+        Bar
+    }
+
+    [ReferenceResolver(EntityResolver = nameof(Get))]
+    public class TypeWithEnumAndStronglyTypedReferenceResolver
+    {
+        public string Id { get; set; } = null!;
+
+        public TestEnum EnumValue { get; set; }
+
+        public static TypeWithEnumAndStronglyTypedReferenceResolver Get(string id, TestEnum enumValue)
+        {
+            return new TypeWithEnumAndStronglyTypedReferenceResolver { Id = id, EnumValue = enumValue };
+        }
+    }
 }

src/HotChocolate/ApolloFederation/test/ApolloFederation.Tests/_AnyTypeTests.cs

@@ -25,7 +25,8 @@ public void Deserialize()
         var serialized = new ObjectValueNode(
             new ObjectFieldNode(AnyType.TypeNameField, "test"),
             new ObjectFieldNode("faa", "foo"),
-            new ObjectFieldNode("foo", "bar")
+            new ObjectFieldNode("foo", "bar"),
+            new ObjectFieldNode("fooEnum", new EnumValueNode("enum"))
         );
 
         // act
@@ -65,6 +66,16 @@ public void Deserialize()
                 Assert.Equal(
                     "bar",
                     node.Value.Value);
+            },
+            node =>
+            {
+                Assert.Equal(
+                    "fooEnum",
+                    node.Name.Value);
+
+                Assert.Equal(
+                    "enum",
+                    node.Value.Value);
             }
         );
     }