feat: validate presence of optional @requires dependencies (#1297)

In GraphQL Federation, when a field has @requires dependencies on
external nullable field and those dependencies fail to resolve, 
the entire entity resolution would lead to malformed data being sent 
to later fetches.

For example, 2 subgraphs:

	# Subgraph 1
	type Entity @key(fields: "id") {
		id: ID
		info: String
	}

	# Subgraph 2, where fullInfo requires 
	# the "info" field to be resolved first.
	type Query {
		entity: [Entity]
	}
	type Entity @key(fields: "id") {
		id: ID
		info: String @external
		fullInfo: String @requires(fields: "info")
	}

If the fetch from Subgraph1 returned the null value for 
the "info" field along with error pointing to that field, then 
this bit of information should not be used in the fetch
from Subgraph 2 that provides info to get the value of
the "fullInfo" field.

This change implements validation of optional @requires dependencies 
in GraphQL Federation. The core feature allows the system to 
gracefully handle scenarios where entities fail to resolve their 
@requires dependencies, particularly for nullable fields.

This change introduces selective handling where only nullable @requires
fields are treated as "optional" - if they fail, 
the entity is marked as "tainted" but
processing continues for other entities.

Author: ysmolski

execution/engine/execution_engine_helpers_test.go

@@ -44,14 +44,54 @@ func createTestRoundTripper(t *testing.T, testCase roundTripperTestCase) testRou
 				receivedBodyBytes, err = io.ReadAll(req.Body)
 				require.NoError(t, err)
 			}
-			require.Equal(t, testCase.expectedBody, string(receivedBodyBytes), "roundTripperTestCase body do not match")
+			require.Equal(t, testCase.expectedBody, string(receivedBodyBytes), "roundTripperTestCase received unexpected body")
 		}
 
 		body := bytes.NewBuffer([]byte(testCase.sendResponseBody))
 		return &http.Response{StatusCode: testCase.sendStatusCode, Body: io.NopCloser(body)}
 	}
 }
 
+type conditionalTestCase struct {
+	expectedHost   string
+	expectedPath   string
+	expectedMethod string
+
+	// responses map an expected body to the output that should be sent
+	responses map[string]sendResponse
+}
+
+type sendResponse struct {
+	statusCode int
+	body       string
+}
+
+func createConditionalTestRoundTripper(t *testing.T, testCase conditionalTestCase) testRoundTripper {
+	t.Helper()
+
+	require.True(t, len(testCase.responses) > 0, "no responses defined")
+
+	return func(req *http.Request) *http.Response {
+		t.Helper()
+
+		assert.Equal(t, testCase.expectedHost, req.URL.Host)
+		assert.Equal(t, testCase.expectedPath, req.URL.Path)
+
+		require.NotNil(t, req.Body, "roundTripperTestCase received nil body")
+
+		gotBody, err := io.ReadAll(req.Body)
+		require.NoError(t, err)
+		defer req.Body.Close()
+
+		require.Containsf(t, testCase.responses, string(gotBody), "received unexpected body: %v", string(gotBody))
+		response := testCase.responses[string(gotBody)]
+		return &http.Response{
+			StatusCode: response.statusCode,
+			Body:       io.NopCloser(bytes.NewBuffer([]byte(response.body))),
+		}
+	}
+}
+
 func stringify(any interface{}) []byte {
 	out, _ := json.Marshal(any)
 	return out