Improve federation resolver selection (#3029)

* Improve federation resolver selection

Just checking for existence of keys in the representations isn't enough.  If the values are null, we should skip the resolver.

* Run go generate ./...

* Add test cases

* Fix linter

plugin/federation/federation.gotpl

@@ -253,19 +253,30 @@ func (ec *executionContext) __resolve_entities(ctx context.Context, representati
 						ok bool
 					)
 					_ = val
+					// if all of the KeyFields values for this resolver are null,
+					// we shouldn't use use it
+					allNull := true
 					{{- range $_, $keyField := .KeyFields }}
 						m = rep
 						{{- range $i, $field := .Field }}
-							if {{ if (ne $i $keyField.Field.LastIndex ) -}}val{{- else -}}_{{- end -}}, ok = m["{{.}}"]; !ok {
+							val, ok = m["{{.}}"]
+							if !ok {
 								break
 							}
 							{{- if (ne $i $keyField.Field.LastIndex ) }}
 								if m, ok = val.(map[string]interface{}); !ok {
 									break
 								}
+							{{- else}}
+								if allNull {
+									allNull = val == nil
+								}
 							{{- end}}
 						{{- end}}
 					{{- end }}
+					if allNull {
+						break
+					}
 					return "{{.ResolverName}}", nil
 				}
 			{{- end }}

plugin/federation/federation_entityresolver_test.go

@@ -186,6 +186,43 @@ func TestEntityResolver(t *testing.T) {
 		require.Equal(t, 11, resp.Entities[1].Bar)
 	})
 
+	t.Run("World entities with one single-key nil should hit resolver without nils", func(t *testing.T) {
+		representations := []map[string]interface{}{
+			{
+				"__typename": "WorldWithMultipleKeys",
+				"hello": map[string]interface{}{
+					"name": "world name - 1",
+				},
+				"foo": "foo 1",
+				"bar": nil,
+			},
+		}
+
+		var resp struct {
+			Entities []struct {
+				Foo   string `json:"foo"`
+				Hello struct {
+					Name string `json:"name"`
+				} `json:"hello"`
+				Bar int `json:"bar"`
+			} `json:"_entities"`
+		}
+
+		err := c.Post(
+			entityQuery([]string{
+				"WorldWithMultipleKeys {foo hello {name} bar}",
+			}),
+			&resp,
+			client.Var("representations", representations),
+		)
+
+		require.NoError(t, err)
+		require.Len(t, resp.Entities, 1)
+		require.Equal(t, "foo 1", resp.Entities[0].Foo)
+		require.Equal(t, "world name - 1", resp.Entities[0].Hello.Name)
+		require.Equal(t, entityresolver.FindWorldWithMultipleKeysByHelloNameAndFooBarValue, resp.Entities[0].Bar)
+	})
+
 	t.Run("Hello WorldName entities (heterogeneous)", func(t *testing.T) {
 		// Entity resolution can handle heterogenenous representations. Meaning,
 		// the representations for resolving entities can be of different