feat: improve resolve performance by solving merge abstract nodes in postprocessing (#826)

Previously, we've generated too many fields for abstract nodes. This
meant that after resolving, we had to deduplicate and merge some fields.
This new approach solves the problem in a post processing step as part
of the planning. This means that the runtime does less work during
resolving, and a little bit more work during planning, which gets cached
anyways.

---------

Co-authored-by: Sergiy 🇺🇦 <818351+devsergiy@users.noreply.github.com>

Author: jensneuse

execution/engine/execution_engine_test.go

@@ -1811,6 +1811,18 @@ func newFederationEngineStaticConfig(ctx context.Context, setup *federationtesti
 					TypeName:   "WalletType2",
 					FieldNames: []string{"currency", "amount", "specialField2"},
 				},
+				{
+					TypeName:   "Namer",
+					FieldNames: []string{"name"},
+				},
+				{
+					TypeName:   "A",
+					FieldNames: []string{"name"},
+				},
+				{
+					TypeName:   "B",
+					FieldNames: []string{"name"},
+				},
 			},
 			FederationMetaData: plan.FederationMetaData{
 				Keys: plan.FederationFieldConfigurations{

execution/engine/federation_integration_test.go

@@ -80,25 +80,33 @@ func TestFederationIntegrationTestWithArt(t *testing.T) {
 // This tests produces data races in the generated gql code. Disable it when the race
 // detector is enabled.
 func TestFederationIntegrationTest(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	setup := federationtesting.NewFederationSetup(addGateway(false))
-	defer setup.Close()
-
-	gqlClient := NewGraphqlClient(http.DefaultClient)
 
 	t.Run("single upstream query operation", func(t *testing.T) {
+		setup := federationtesting.NewFederationSetup(addGateway(false))
+		t.Cleanup(setup.Close)
+		gqlClient := NewGraphqlClient(http.DefaultClient)
+		ctx, cancel := context.WithCancel(context.Background())
+		t.Cleanup(cancel)
 		resp := gqlClient.Query(ctx, setup.GatewayServer.URL, testQueryPath("queries/single_upstream.query"), nil, t)
 		assert.Equal(t, `{"data":{"me":{"id":"1234","username":"Me"}}}`, string(resp))
 	})
 
 	t.Run("query spans multiple federated servers", func(t *testing.T) {
+		setup := federationtesting.NewFederationSetup(addGateway(false))
+		t.Cleanup(setup.Close)
+		gqlClient := NewGraphqlClient(http.DefaultClient)
+		ctx, cancel := context.WithCancel(context.Background())
+		t.Cleanup(cancel)
 		resp := gqlClient.Query(ctx, setup.GatewayServer.URL, testQueryPath("queries/multiple_upstream.query"), nil, t)
 		assert.Equal(t, `{"data":{"topProducts":[{"name":"Trilby","reviews":[{"body":"A highly effective form of birth control.","author":{"username":"Me"}}]},{"name":"Fedora","reviews":[{"body":"Fedoras are one of the most fashionable hats around and can look great with a variety of outfits.","author":{"username":"Me"}}]}]}}`, string(resp))
 	})
 
 	t.Run("mutation operation with variables", func(t *testing.T) {
+		setup := federationtesting.NewFederationSetup(addGateway(false))
+		t.Cleanup(setup.Close)
+		gqlClient := NewGraphqlClient(http.DefaultClient)
+		ctx, cancel := context.WithCancel(context.Background())
+		t.Cleanup(cancel)
 		resp := gqlClient.Query(ctx, setup.GatewayServer.URL, testQueryPath("mutations/mutation_with_variables.query"), queryVariables{
 			"authorID": "3210",
 			"upc":      "top-1",
@@ -108,18 +116,31 @@ func TestFederationIntegrationTest(t *testing.T) {
 	})
 
 	t.Run("union query", func(t *testing.T) {
+		setup := federationtesting.NewFederationSetup(addGateway(false))
+		t.Cleanup(setup.Close)
+		gqlClient := NewGraphqlClient(http.DefaultClient)
+		ctx, cancel := context.WithCancel(context.Background())
+		t.Cleanup(cancel)
 		resp := gqlClient.Query(ctx, setup.GatewayServer.URL, testQueryPath("queries/union.query"), nil, t)
 		assert.Equal(t, `{"data":{"me":{"username":"Me","history":[{"__typename":"Purchase","wallet":{"amount":123}},{"__typename":"Sale","rating":5},{"__typename":"Purchase","wallet":{"amount":123}}]}}}`, string(resp))
 	})
 
 	t.Run("interface query", func(t *testing.T) {
+		setup := federationtesting.NewFederationSetup(addGateway(false))
+		t.Cleanup(setup.Close)
+		gqlClient := NewGraphqlClient(http.DefaultClient)
+		ctx, cancel := context.WithCancel(context.Background())
+		t.Cleanup(cancel)
 		resp := gqlClient.Query(ctx, setup.GatewayServer.URL, testQueryPath("queries/interface.query"), nil, t)
 		assert.Equal(t, `{"data":{"me":{"username":"Me","history":[{"wallet":{"amount":123,"specialField1":"some special value 1"}},{"rating":5},{"wallet":{"amount":123,"specialField2":"some special value 2"}}]}}}`, string(resp))
 	})
 
 	t.Run("subscription query through WebSocket transport", func(t *testing.T) {
-		ctx, cancel := context.WithCancel(ctx)
-		defer cancel()
+		setup := federationtesting.NewFederationSetup(addGateway(false))
+		t.Cleanup(setup.Close)
+		gqlClient := NewGraphqlClient(http.DefaultClient)
+		ctx, cancel := context.WithCancel(context.Background())
+		t.Cleanup(cancel)
 		// Reset the products slice to the original state
 		defer products.Reset()
 
@@ -134,8 +155,11 @@ func TestFederationIntegrationTest(t *testing.T) {
 	})
 
 	t.Run("Multiple queries and nested fragments", func(t *testing.T) {
-		ctx, cancel := context.WithCancel(ctx)
-		defer cancel()
+		setup := federationtesting.NewFederationSetup(addGateway(false))
+		t.Cleanup(setup.Close)
+		gqlClient := NewGraphqlClient(http.DefaultClient)
+		ctx, cancel := context.WithCancel(context.Background())
+		t.Cleanup(cancel)
 		resp := gqlClient.Query(ctx, setup.GatewayServer.URL, testQueryPath("queries/multiple_queries_with_nested_fragments.query"), nil, t)
 		expected := `
 {
@@ -181,8 +205,11 @@ func TestFederationIntegrationTest(t *testing.T) {
 	})
 
 	t.Run("Multiple queries with __typename", func(t *testing.T) {
-		ctx, cancel := context.WithCancel(ctx)
-		defer cancel()
+		setup := federationtesting.NewFederationSetup(addGateway(false))
+		t.Cleanup(setup.Close)
+		gqlClient := NewGraphqlClient(http.DefaultClient)
+		ctx, cancel := context.WithCancel(context.Background())
+		t.Cleanup(cancel)
 		resp := gqlClient.Query(ctx, setup.GatewayServer.URL, testQueryPath("queries/multiple_queries.query"), nil, t)
 		expected := `
 {
@@ -210,8 +237,11 @@ func TestFederationIntegrationTest(t *testing.T) {
 	})
 
 	t.Run("Query that returns union", func(t *testing.T) {
-		ctx, cancel := context.WithCancel(ctx)
-		defer cancel()
+		setup := federationtesting.NewFederationSetup(addGateway(false))
+		t.Cleanup(setup.Close)
+		gqlClient := NewGraphqlClient(http.DefaultClient)
+		ctx, cancel := context.WithCancel(context.Background())
+		t.Cleanup(cancel)
 		resp := gqlClient.Query(ctx, setup.GatewayServer.URL, testQueryPath("queries/multiple_queries_with_union_return.query"), nil, t)
 		expected := `
 {
@@ -286,8 +316,11 @@ func TestFederationIntegrationTest(t *testing.T) {
 	})
 
 	t.Run("Object response type with interface and object fragment", func(t *testing.T) {
-		ctx, cancel := context.WithCancel(ctx)
-		defer cancel()
+		setup := federationtesting.NewFederationSetup(addGateway(false))
+		t.Cleanup(setup.Close)
+		gqlClient := NewGraphqlClient(http.DefaultClient)
+		ctx, cancel := context.WithCancel(context.Background())
+		t.Cleanup(cancel)
 		resp := gqlClient.Query(ctx, setup.GatewayServer.URL, testQueryPath("queries/interface_fragment_on_object.graphql"), nil, t)
 		expected := `
 {
@@ -302,8 +335,11 @@ func TestFederationIntegrationTest(t *testing.T) {
 	})
 
 	t.Run("Interface response type with object fragment", func(t *testing.T) {
-		ctx, cancel := context.WithCancel(ctx)
-		defer cancel()
+		setup := federationtesting.NewFederationSetup(addGateway(false))
+		t.Cleanup(setup.Close)
+		gqlClient := NewGraphqlClient(http.DefaultClient)
+		ctx, cancel := context.WithCancel(context.Background())
+		t.Cleanup(cancel)
 		resp := gqlClient.Query(ctx, setup.GatewayServer.URL, testQueryPath("queries/object_fragment_on_interface.graphql"), nil, t)
 		expected := `
 {
@@ -319,8 +355,11 @@ func TestFederationIntegrationTest(t *testing.T) {
 	})
 
 	t.Run("Union response type with interface fragments", func(t *testing.T) {
-		ctx, cancel := context.WithCancel(ctx)
-		defer cancel()
+		setup := federationtesting.NewFederationSetup(addGateway(false))
+		t.Cleanup(setup.Close)
+		gqlClient := NewGraphqlClient(http.DefaultClient)
+		ctx, cancel := context.WithCancel(context.Background())
+		t.Cleanup(cancel)
 		resp := gqlClient.Query(ctx, setup.GatewayServer.URL, testQueryPath("queries/interface_fragments_on_union.graphql"), nil, t)
 		expected := `
 {
@@ -360,98 +399,97 @@ func TestFederationIntegrationTest(t *testing.T) {
 	// Duplicated properties (and therefore invalid JSON) are usually removed during normalization processes.
 	// It is not yet decided whether this should be addressed before these normalization processes.
 	t.Run("Complex nesting", func(t *testing.T) {
-		ctx, cancel := context.WithCancel(ctx)
-		defer cancel()
+		setup := federationtesting.NewFederationSetup(addGateway(false))
+		defer setup.Close()
+
+		gqlClient := NewGraphqlClient(http.DefaultClient)
+		ctx, cancel := context.WithCancel(context.Background())
+		t.Cleanup(cancel)
 		resp := gqlClient.Query(ctx, setup.GatewayServer.URL, testQueryPath("queries/complex_nesting.graphql"), nil, t)
-		expected := `
-{
-  "data": {
-    "me": {
-      "id": "1234",
-      "username": "Me",
-      "history": [
-        {
-          "wallet": {
-            "currency": "USD"
-          }
-        },
-        {
-          "location": "Germany",
-          "product": {
-            "upc": "top-2",
-            "name": "Fedora"
-          }
-        },
-        {
-          "wallet": {
-            "currency": "USD"
-          }
-        }
-      ],
-      "reviews": [
-        {
-          "__typename": "Review",
-          "attachments": [
-            {
-              "upc": "top-1",
-              "body": "How do I turn it on?"
-            }
-          ]
-        },
-        {
-          "__typename": "Review",
-          "attachments": [
-            {
-              "upc": "top-2",
-              "body": "The best hat I have ever bought in my life."
-            },
-            {
-              "upc": "top-2",
-              "size": 13.37
-            }
-          ]
-        }
-      ]
-    }
-  }
-}
-`
+		expected := `{"data":{"me":{"id":"1234","username":"Me","history":[{"wallet":{"currency":"USD"}},{"location":"Germany","product":{"upc":"top-2","name":"Fedora"}},{"wallet":{"currency":"USD"}}],"reviews":[{"__typename":"Review","attachments":[{"__typename":"Question","upc":"top-1","body":"How do I turn it on?"}]},{"__typename":"Review","attachments":[{"__typename":"Rating","upc":"top-2","body":"The best hat I have ever bought in my life."},{"__typename":"Video","upc":"top-2","size":13.37}]}]}}}`
 		assert.Equal(t, compact(expected), string(resp))
 	})
 
-	t.Run("Merged fields are still resolved", func(t *testing.T) {
+	t.Run("More complex nesting", func(t *testing.T) {
+		setup := federationtesting.NewFederationSetup(addGateway(false))
+		defer setup.Close()
 
-		ctx, cancel := context.WithCancel(ctx)
-		defer cancel()
+		gqlClient := NewGraphqlClient(http.DefaultClient)
+		ctx, cancel := context.WithCancel(context.Background())
+		t.Cleanup(cancel)
+		resp := gqlClient.Query(ctx, setup.GatewayServer.URL, testQueryPath("queries/more_complex_nesting.graphql"), nil, t)
+		expected := `{"data":{"me":{"id":"1234","username":"Me","history":[{"wallet":{"currency":"USD"}},{"location":"Germany","product":{"name":"Fedora","upc":"top-2"}},{"wallet":{"currency":"USD"}}],"reviews":[{"__typename":"Review","attachments":[{"__typename":"Question","upc":"top-1","body":"How do I turn it on?"}],"comment":{"__typename":"Question","subject":"Life"}},{"__typename":"Review","attachments":[{"__typename":"Rating","upc":"top-2","body":"The best hat I have ever bought in my life."},{"__typename":"Video","upc":"top-2","size":13.37}],"comment":{"__typename":"Question","subject":"Life"}}]}}}`
+		assert.Equal(t, compact(expected), string(resp))
+	})
+
+	t.Run("Multiple nested interfaces", func(t *testing.T) {
+		setup := federationtesting.NewFederationSetup(addGateway(false))
+		defer setup.Close()
+
+		gqlClient := NewGraphqlClient(http.DefaultClient)
+		ctx, cancel := context.WithCancel(context.Background())
+		t.Cleanup(cancel)
+		resp := gqlClient.Query(ctx, setup.GatewayServer.URL, testQueryPath("queries/titlename.graphql"), nil, t)
+		expected := `{"data":{"titleName":{"__typename":"TitleName","title":"Title","a":"A","b":"B","name":"Name","c":"C"}}}`
+		assert.Equal(t, compact(expected), string(resp))
+	})
+
+	t.Run("Multiple nested unions", func(t *testing.T) {
+		setup := federationtesting.NewFederationSetup(addGateway(false))
+		defer setup.Close()
+
+		gqlClient := NewGraphqlClient(http.DefaultClient)
+		ctx, cancel := context.WithCancel(context.Background())
+		t.Cleanup(cancel)
+		resp := gqlClient.Query(ctx, setup.GatewayServer.URL, testQueryPath("queries/cd.graphql"), nil, t)
+		expected := `{"data":{"cds":[{"name":{"first":"Leonie","middle":"Johanna"}},{"name":{"first":"Jannik","last":"Neuse"}}]}}`
+		assert.Equal(t, compact(expected), string(resp))
+	})
+
+	t.Run("More complex nesting typename variant", func(t *testing.T) {
+		setup := federationtesting.NewFederationSetup(addGateway(false))
+		defer setup.Close()
+
+		gqlClient := NewGraphqlClient(http.DefaultClient)
+		ctx, cancel := context.WithCancel(context.Background())
+		t.Cleanup(cancel)
+		resp := gqlClient.Query(ctx, setup.GatewayServer.URL, testQueryPath("queries/more_complex_nesting_typename_variant.graphql"), nil, t)
+		expected := `{"data":{"me":{"id":"1234","username":"Me","history":[{"wallet":{"currency":"USD"}},{"location":"Germany","product":{"name":"Fedora","upc":"top-2"}},{"wallet":{"currency":"USD"}}],"reviews":[{"__typename":"Review","attachments":[{"__typename":"Question","upc":"top-1","body":"How do I turn it on?"}]},{"__typename":"Review","attachments":[{"__typename":"Rating","upc":"top-2","body":"The best hat I have ever bought in my life."},{"__typename":"Video","upc":"top-2","size":13.37}]}]}}}`
+		assert.Equal(t, compact(expected), string(resp))
+	})
+
+	t.Run("Abstract object", func(t *testing.T) {
+		setup := federationtesting.NewFederationSetup(addGateway(false))
+		defer setup.Close()
+
+		gqlClient := NewGraphqlClient(http.DefaultClient)
+		ctx, cancel := context.WithCancel(context.Background())
+		t.Cleanup(cancel)
+		resp := gqlClient.Query(ctx, setup.GatewayServer.URL, testQueryPath("queries/abstract_object.graphql"), nil, t)
+		expected := `{"data":{"abstractList":[{"__typename":"ConcreteListItem1","obj":{"__typename":"SomeType1","name":"1","age":1}},{"__typename":"ConcreteListItem2","obj":{"__typename":"SomeType2","name":"2","height":2}}]}}`
+		assert.Equal(t, compact(expected), string(resp))
+	})
+
+	t.Run("Abstract interface field", func(t *testing.T) {
+		setup := federationtesting.NewFederationSetup(addGateway(false))
+		defer setup.Close()
+
+		gqlClient := NewGraphqlClient(http.DefaultClient)
+		ctx, cancel := context.WithCancel(context.Background())
+		t.Cleanup(cancel)
+		resp := gqlClient.Query(ctx, setup.GatewayServer.URL, testQueryPath("queries/ab.graphql"), nil, t)
+		expected := `{"data":{"interfaceUnion":{"__typename":"A","name":"A"}}}`
+		assert.Equal(t, compact(expected), string(resp))
+	})
+
+	t.Run("Merged fields are still resolved", func(t *testing.T) {
+		setup := federationtesting.NewFederationSetup(addGateway(false))
+		t.Cleanup(setup.Close)
+		gqlClient := NewGraphqlClient(http.DefaultClient)
+		ctx, cancel := context.WithCancel(context.Background())
+		t.Cleanup(cancel)
 		resp := gqlClient.Query(ctx, setup.GatewayServer.URL, testQueryPath("queries/merged_field.graphql"), nil, t)
-		expected := `
-{
-	"data": {
-		"cat": {
-			"name": "Pepper"
-		},
-		"me": {
-			"id": "1234",
-			"username": "Me",
-			"realName": "User Usington",
-			"reviews": [
-				{
-					"body": "A highly effective form of birth control."
-				},
-				{
-					"body": "Fedoras are one of the most fashionable hats around and can look great with a variety of outfits."
-				}
-			],
-			"history": [
-				{},
-				{
-					"rating": 5
-				},
-				{}
-			]
-		}
-	}
-}`
+		expected := `{"data":{"cat":{"name":"Pepper"},"me":{"id":"1234","username":"Me","realName":"User Usington","reviews":[{"body":"A highly effective form of birth control."},{"body":"Fedoras are one of the most fashionable hats around and can look great with a variety of outfits."}],"history":[{},{"rating":5},{}]}}}`
 		assert.Equal(t, compact(expected), string(resp))
 	})
 }

execution/engine/testdata/complex_nesting_query_with_art.json

@@ -27,6 +27,7 @@
           "__typename": "Review",
           "attachments": [
             {
+              "__typename": "Question",
               "upc": "top-1",
               "body": "How do I turn it on?"
             }
@@ -36,10 +37,12 @@
           "__typename": "Review",
           "attachments": [
             {
+              "__typename": "Rating",
               "upc": "top-2",
               "body": "The best hat I have ever bought in my life."
             },
             {
+              "__typename": "Video",
               "upc": "top-2",
               "size": 13.37
             }