Merge branch 'master' into dominik/eng-7125-allow-header-forwarding

Author: dkorittki

execution/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [1.8.0](https://github.com/wundergraph/graphql-go-tools/compare/execution/v1.7.0...execution/v1.8.0) (2026-02-16)
+
+
+### Features
+
+* add flag for relaxed nullability checks on same shape ([#1378](https://github.com/wundergraph/graphql-go-tools/issues/1378)) ([6be2e74](https://github.com/wundergraph/graphql-go-tools/commit/6be2e74036a027f44adaff7f6bfbdbce1d1fb03b))
+
+
+### Bug Fixes
+
+* enable parallel execution for federation integration tests ([#1385](https://github.com/wundergraph/graphql-go-tools/issues/1385)) ([09d9348](https://github.com/wundergraph/graphql-go-tools/commit/09d934802ed1549881123c2e805159ec81981c37))
+
 ## [1.7.0](https://github.com/wundergraph/graphql-go-tools/compare/execution/v1.6.0...execution/v1.7.0) (2026-02-06)
 
 

execution/engine/execution_engine.go

@@ -17,6 +17,7 @@ import (
 	"github.com/wundergraph/graphql-go-tools/v2/pkg/ast"
 	"github.com/wundergraph/graphql-go-tools/v2/pkg/astnormalization"
 	"github.com/wundergraph/graphql-go-tools/v2/pkg/astprinter"
+	"github.com/wundergraph/graphql-go-tools/v2/pkg/astvalidation"
 	"github.com/wundergraph/graphql-go-tools/v2/pkg/engine/datasource/introspection_datasource"
 	"github.com/wundergraph/graphql-go-tools/v2/pkg/engine/plan"
 	"github.com/wundergraph/graphql-go-tools/v2/pkg/engine/postprocess"
@@ -62,6 +63,7 @@ type ExecutionEngine struct {
 	resolver                 *resolve.Resolver
 	executionPlanCache       *lru.Cache
 	apolloCompatibilityFlags apollocompatibility.Flags
+	validationOptions        []astvalidation.Option
 }
 
 type WebsocketBeforeStartHook interface {
@@ -130,6 +132,11 @@ func NewExecutionEngine(ctx context.Context, logger abstractlogger.Logger, engin
 		dsIDs[ds.Id()] = struct{}{}
 	}
 
+	var validationOpts []astvalidation.Option
+	if engineConfig.plannerConfig.RelaxSubgraphOperationFieldSelectionMergingNullability {
+		validationOpts = append(validationOpts, astvalidation.WithRelaxFieldSelectionMergingNullability())
+	}
+
 	return &ExecutionEngine{
 		logger:             logger,
 		config:             engineConfig,
@@ -138,6 +145,7 @@ func NewExecutionEngine(ctx context.Context, logger abstractlogger.Logger, engin
 		apolloCompatibilityFlags: apollocompatibility.Flags{
 			ReplaceInvalidVarError: resolverOptions.ResolvableOptions.ApolloCompatibilityReplaceInvalidVarError,
 		},
+		validationOptions: validationOpts,
 	}, nil
 }
 
@@ -159,7 +167,7 @@ func (e *ExecutionEngine) Execute(ctx context.Context, operation *graphql.Reques
 	}
 
 	// Validate the operation against the schema.
-	if result, err := operation.ValidateForSchema(e.config.schema); err != nil {
+	if result, err := operation.ValidateForSchema(e.config.schema, e.validationOptions...); err != nil {
 		return err
 	} else if !result.Valid {
 		return result.Errors

execution/engine/execution_engine_test.go

@@ -223,6 +223,7 @@ type _executionTestOptions struct {
 	propagateFetchReasons                        bool
 	validateRequiredExternalFields               bool
 	computeStaticCost                            bool
+	relaxFieldSelectionMergingNullability        bool
 }
 
 type executionTestOptions func(*_executionTestOptions)
@@ -253,6 +254,12 @@ func computeStaticCost() executionTestOptions {
 	}
 }
 
+func relaxFieldSelectionMergingNullability() executionTestOptions {
+	return func(options *_executionTestOptions) {
+		options.relaxFieldSelectionMergingNullability = true
+	}
+}
+
 func TestExecutionEngine_Execute(t *testing.T) {
 	run := func(testCase ExecutionEngineTestCase, withError bool, expectedErrorMessage string, options ...executionTestOptions) func(t *testing.T) {
 		t.Helper()
@@ -289,6 +296,7 @@ func TestExecutionEngine_Execute(t *testing.T) {
 			engineConf.plannerConfig.ValidateRequiredExternalFields = opts.validateRequiredExternalFields
 			engineConf.plannerConfig.ComputeStaticCost = opts.computeStaticCost
 			engineConf.plannerConfig.StaticCostDefaultListSize = 10
+			engineConf.plannerConfig.RelaxSubgraphOperationFieldSelectionMergingNullability = opts.relaxFieldSelectionMergingNullability
 			resolveOpts := resolve.ResolverOptions{
 				MaxConcurrency:    1024,
 				ResolvableOptions: opts.resolvableOptions,
@@ -321,7 +329,7 @@ func TestExecutionEngine_Execute(t *testing.T) {
 			if withError {
 				require.Error(t, err)
 				if expectedErrorMessage != "" {
-					assert.Contains(t, err.Error(), expectedErrorMessage)
+					assert.Equal(t, expectedErrorMessage, err.Error())
 				}
 			} else {
 				require.NoError(t, err)
@@ -6812,6 +6820,134 @@ func TestExecutionEngine_Execute(t *testing.T) {
 		})
 
 	})
+
+	t.Run("field merging with different nullability on non-overlapping union types", func(t *testing.T) {
+		unionSchema := `
+			union Entity = User | Organization
+			type Query { entity: Entity }
+			type User { id: ID!, email: String! }
+			type Organization { id: ID!, email: String }
+		`
+		schema, err := graphql.NewSchemaFromString(unionSchema)
+		require.NoError(t, err)
+
+		rootNodes := []plan.TypeField{
+			{TypeName: "Query", FieldNames: []string{"entity"}},
+			{TypeName: "User", FieldNames: []string{"id", "email"}},
+			{TypeName: "Organization", FieldNames: []string{"id", "email"}},
+		}
+
+		customConfig := mustConfiguration(t, graphql_datasource.ConfigurationInput{
+			Fetch: &graphql_datasource.FetchConfiguration{
+				URL:    "https://example.com/",
+				Method: "POST",
+			},
+			SchemaConfiguration: mustSchemaConfig(t, nil, unionSchema),
+		})
+
+		fieldConfig := []plan.FieldConfiguration{
+			{
+				TypeName:  "Query",
+				FieldName: "entity",
+				Path:      []string{"entity"},
+			},
+		}
+
+		t.Run("without relaxation flag, validation rejects differing nullability", runWithAndCompareError(
+			ExecutionEngineTestCase{
+				schema: schema,
+				operation: func(t *testing.T) graphql.Request {
+					return graphql.Request{
+						OperationName: "O",
+						Query:         `query O { entity { ... on User { email } ... on Organization { email } } }`,
+					}
+				},
+				dataSources: []plan.DataSource{
+					mustGraphqlDataSourceConfiguration(t, "ds-id",
+						mustFactory(t,
+							testNetHttpClient(t, roundTripperTestCase{
+								expectedHost:     "example.com",
+								expectedPath:     "/",
+								expectedBody:     "",
+								sendResponseBody: `{"data":{"entity":{"__typename":"User","email":"user@test.com"}}}`,
+								sendStatusCode:   200,
+							}),
+						),
+						&plan.DataSourceMetadata{
+							RootNodes: rootNodes,
+						},
+						customConfig,
+					),
+				},
+				fields: fieldConfig,
+			},
+			`fields 'email' conflict because they return conflicting types 'String!' and 'String', locations: [], path: [query,entity,$1Organization]`,
+		))
+
+		t.Run("non-null email from User type", runWithoutError(
+			ExecutionEngineTestCase{
+				schema: schema,
+				operation: func(t *testing.T) graphql.Request {
+					return graphql.Request{
+						OperationName: "O",
+						Query:         `query O { entity { ... on User { email } ... on Organization { email } } }`,
+					}
+				},
+				dataSources: []plan.DataSource{
+					mustGraphqlDataSourceConfiguration(t, "ds-id",
+						mustFactory(t,
+							testNetHttpClient(t, roundTripperTestCase{
+								expectedHost:     "example.com",
+								expectedPath:     "/",
+								expectedBody:     "",
+								sendResponseBody: `{"data":{"entity":{"__typename":"User","email":"user@test.com"}}}`,
+								sendStatusCode:   200,
+							}),
+						),
+						&plan.DataSourceMetadata{
+							RootNodes: rootNodes,
+						},
+						customConfig,
+					),
+				},
+				fields:           fieldConfig,
+				expectedResponse: `{"data":{"entity":{"email":"user@test.com"}}}`,
+			},
+			relaxFieldSelectionMergingNullability(),
+		))
+
+		t.Run("null email from Organization type", runWithoutError(
+			ExecutionEngineTestCase{
+				schema: schema,
+				operation: func(t *testing.T) graphql.Request {
+					return graphql.Request{
+						OperationName: "O",
+						Query:         `query O { entity { ... on User { email } ... on Organization { email } } }`,
+					}
+				},
+				dataSources: []plan.DataSource{
+					mustGraphqlDataSourceConfiguration(t, "ds-id",
+						mustFactory(t,
+							testNetHttpClient(t, roundTripperTestCase{
+								expectedHost:     "example.com",
+								expectedPath:     "/",
+								expectedBody:     "",
+								sendResponseBody: `{"data":{"entity":{"__typename":"Organization","email":null}}}`,
+								sendStatusCode:   200,
+							}),
+						),
+						&plan.DataSourceMetadata{
+							RootNodes: rootNodes,
+						},
+						customConfig,
+					),
+				},
+				fields:           fieldConfig,
+				expectedResponse: `{"data":{"entity":{"email":null}}}`,
+			},
+			relaxFieldSelectionMergingNullability(),
+		))
+	})
 }
 
 func testNetHttpClient(t *testing.T, testCase roundTripperTestCase) *http.Client {

execution/engine/federation_integration_static_test.go

@@ -1,5 +1,3 @@
-//go:build !race
-
 package engine
 
 import (
@@ -16,14 +14,15 @@ import (
 	"github.com/wundergraph/graphql-go-tools/v2/pkg/testing/flags"
 )
 
-// This tests produces data races in the generated gql code. Disable it when the race
-// detector is enabled.
 func TestExecutionEngine_FederationAndSubscription_IntegrationTest(t *testing.T) {
+	t.Parallel()
+
 	if flags.IsWindows {
 		t.Skip("skip on windows - test is timing dependent")
 	}
 
 	t.Run("operation", func(t *testing.T) {
+		t.Parallel()
 		ctx, cancelFn := context.WithCancel(context.Background())
 		setup := federationtesting.NewFederationSetup()
 		t.Cleanup(func() {
@@ -60,6 +59,7 @@ func TestExecutionEngine_FederationAndSubscription_IntegrationTest(t *testing.T)
 	})
 
 	t.Run("subscription", func(t *testing.T) {
+		t.Parallel()
 		ctx, cancelFn := context.WithCancel(context.Background())
 		setup := federationtesting.NewFederationSetup()
 		t.Cleanup(func() {