Add support for @experimental_disableErrorPropagation

.gitignore

@@ -1,7 +1,8 @@
 *.iml
 *.ipr
 *.iws
-.idea
+.idea/*
+!.idea/codeStyles
 .gradle
 build
 classes

src/main/java/graphql/Directives.java

@@ -7,6 +7,8 @@
 import graphql.language.StringValue;
 import graphql.schema.GraphQLDirective;
 
+import java.util.concurrent.atomic.AtomicBoolean;
+
 import static graphql.Scalars.GraphQLBoolean;
 import static graphql.Scalars.GraphQLString;
 import static graphql.introspection.Introspection.DirectiveLocation.ARGUMENT_DEFINITION;
@@ -17,7 +19,10 @@
 import static graphql.introspection.Introspection.DirectiveLocation.INLINE_FRAGMENT;
 import static graphql.introspection.Introspection.DirectiveLocation.INPUT_FIELD_DEFINITION;
 import static graphql.introspection.Introspection.DirectiveLocation.INPUT_OBJECT;
+import static graphql.introspection.Introspection.DirectiveLocation.MUTATION;
+import static graphql.introspection.Introspection.DirectiveLocation.QUERY;
 import static graphql.introspection.Introspection.DirectiveLocation.SCALAR;
+import static graphql.introspection.Introspection.DirectiveLocation.SUBSCRIPTION;
 import static graphql.language.DirectiveLocation.newDirectiveLocation;
 import static graphql.language.InputValueDefinition.newInputValueDefinition;
 import static graphql.language.NonNullType.newNonNullType;
@@ -37,6 +42,7 @@ public class Directives {
     private static final String SPECIFIED_BY = "specifiedBy";
     private static final String ONE_OF = "oneOf";
     private static final String DEFER = "defer";
+    private static final String DISABLE_ERROR_PROPAGATION = "experimental_disableErrorPropagation";
 
     public static final DirectiveDefinition DEPRECATED_DIRECTIVE_DEFINITION;
     public static final DirectiveDefinition INCLUDE_DIRECTIVE_DEFINITION;
@@ -46,6 +52,8 @@ public class Directives {
     public static final DirectiveDefinition ONE_OF_DIRECTIVE_DEFINITION;
     @ExperimentalApi
     public static final DirectiveDefinition DEFER_DIRECTIVE_DEFINITION;
+    @ExperimentalApi
+    public static final DirectiveDefinition DISABLE_ERROR_PROPAGATION_DIRECTIVE_DEFINITION;
 
     public static final String BOOLEAN = "Boolean";
     public static final String STRING = "String";
@@ -133,6 +141,13 @@ public class Directives {
                                 .type(newTypeName().name(STRING).build())
                                 .build())
                 .build();
+        DISABLE_ERROR_PROPAGATION_DIRECTIVE_DEFINITION = DirectiveDefinition.newDirectiveDefinition()
+                .name(DISABLE_ERROR_PROPAGATION)
+                .directiveLocation(newDirectiveLocation().name(QUERY.name()).build())
+                .directiveLocation(newDirectiveLocation().name(MUTATION.name()).build())
+                .directiveLocation(newDirectiveLocation().name(SUBSCRIPTION.name()).build())
+                .description(createDescription("This directive allows returning null in non-null positions that have an associated error"))
+                .build();
     }
 
     /**
@@ -226,7 +241,35 @@ public class Directives {
             .definition(ONE_OF_DIRECTIVE_DEFINITION)
             .build();
 
+    @ExperimentalApi
+    public static final GraphQLDirective DisableErrorPropagationDirective = GraphQLDirective.newDirective()
+            .name(DISABLE_ERROR_PROPAGATION)
+            .description("This directive disables error propagation for the given operation.")
+            .validLocations(QUERY, MUTATION, SUBSCRIPTION)
+            .definition(DISABLE_ERROR_PROPAGATION_DIRECTIVE_DEFINITION)
+            .build();
+
     private static Description createDescription(String s) {
         return new Description(s, null, false);
     }
+
+    private static final AtomicBoolean EXPERIMENTAL_DISABLE_ERROR_PROPAGATION_DIRECTIVE_ENABLED = new AtomicBoolean(true);
+
+    /**
+     * This can be used to get the state the `@experimental_disableErrorPropagation` directive support on a JVM wide basis .
+     * @return true if the `@experimental_disableErrorPropagation` directive will be respected
+     */
+    public static boolean isExperimentalDisableErrorPropagationDirectiveEnabled() {
+        return EXPERIMENTAL_DISABLE_ERROR_PROPAGATION_DIRECTIVE_ENABLED.get();
+    }
+
+    /**
+     * This can be used to disable the `@experimental_disableErrorPropagation` directive support on a JVM wide basis in case your server
+     * implementation does NOT want to act on this directive ever.
+     *
+     * @param flag the desired state of the flag
+     */
+    public static void setExperimentalDisableErrorPropagationEnabled(boolean flag) {
+        EXPERIMENTAL_DISABLE_ERROR_PROPAGATION_DIRECTIVE_ENABLED.set(flag);
+    }
 }

src/main/java/graphql/execution/Execution.java

@@ -1,6 +1,7 @@
 package graphql.execution;
 
 
+import graphql.Directives;
 import graphql.ExecutionInput;
 import graphql.ExecutionResult;
 import graphql.ExecutionResultImpl;
@@ -20,6 +21,7 @@
 import graphql.extensions.ExtensionsBuilder;
 import graphql.incremental.DelayedIncrementalPartialResult;
 import graphql.incremental.IncrementalExecutionResultImpl;
+import graphql.language.Directive;
 import graphql.language.Document;
 import graphql.language.NodeUtil;
 import graphql.language.OperationDefinition;
@@ -36,6 +38,7 @@
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 
+import static graphql.Directives.DISABLE_ERROR_PROPAGATION_DIRECTIVE_DEFINITION;
 import static graphql.execution.ExecutionContextBuilder.newExecutionContextBuilder;
 import static graphql.execution.ExecutionStepInfo.newExecutionStepInfo;
 import static graphql.execution.ExecutionStrategyParameters.newParameters;
@@ -81,6 +84,8 @@ public CompletableFuture<ExecutionResult> execute(Document document, GraphQLSche
             throw rte;
         }
 
+        boolean propagateErrorsOnNonNullContractFailure = propagateErrorsOnNonNullContractFailure(getOperationResult.operationDefinition.getDirectives());
+
         ExecutionContext executionContext = newExecutionContextBuilder()
                 .instrumentation(instrumentation)
                 .instrumentationState(instrumentationState)
@@ -101,6 +106,7 @@ public CompletableFuture<ExecutionResult> execute(Document document, GraphQLSche
                 .locale(executionInput.getLocale())
                 .valueUnboxer(valueUnboxer)
                 .executionInput(executionInput)
+                .propagapropagateErrorsOnNonNullContractFailureeErrors(propagateErrorsOnNonNullContractFailure)
                 .build();
 
         executionContext.getGraphQLContext().put(ResultNodesInfo.RESULT_NODES_INFO, executionContext.getResultNodesInfo());
@@ -263,4 +269,13 @@ private ExecutionResult mergeExtensionsBuilderIfPresent(ExecutionResult executio
         }
         return executionResult;
     }
+
+    private boolean propagateErrorsOnNonNullContractFailure(List<Directive> directives) {
+        boolean jvmWideEnabled = Directives.isExperimentalDisableErrorPropagationDirectiveEnabled();
+        if (! jvmWideEnabled) {
+            return true;
+        }
+        Directive foundDirective = NodeUtil.findNodeByName(directives, DISABLE_ERROR_PROPAGATION_DIRECTIVE_DEFINITION.getName());
+        return foundDirective == null;
+    }
 }

src/main/java/graphql/execution/ExecutionContext.java

@@ -3,11 +3,7 @@
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
-import graphql.ExecutionInput;
-import graphql.GraphQLContext;
-import graphql.GraphQLError;
-import graphql.Internal;
-import graphql.PublicApi;
+import graphql.*;
 import graphql.collect.ImmutableKit;
 import graphql.execution.incremental.IncrementalCallState;
 import graphql.execution.instrumentation.Instrumentation;
@@ -22,11 +18,7 @@
 import graphql.util.LockKit;
 import org.dataloader.DataLoaderRegistry;
 
-import java.util.HashSet;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
@@ -59,6 +51,7 @@ public class ExecutionContext {
     private final ValueUnboxer valueUnboxer;
     private final ExecutionInput executionInput;
     private final Supplier<ExecutableNormalizedOperation> queryTree;
+    private final boolean propagateErrorsOnNonNullContractFailure;
 
     // this is modified after creation so it needs to be volatile to ensure visibility across Threads
     private volatile DataLoaderDispatchStrategy dataLoaderDispatcherStrategy = DataLoaderDispatchStrategy.NO_OP;
@@ -88,6 +81,7 @@ public class ExecutionContext {
         this.executionInput = builder.executionInput;
         this.dataLoaderDispatcherStrategy = builder.dataLoaderDispatcherStrategy;
         this.queryTree = FpKit.interThreadMemoize(() -> ExecutableNormalizedOperationFactory.createExecutableNormalizedOperation(graphQLSchema, operationDefinition, fragmentsByName, coercedVariables));
+        this.propagateErrorsOnNonNullContractFailure = builder.propagateErrorsOnNonNullContractFailure;
     }
 
 
@@ -129,9 +123,7 @@ public CoercedVariables getCoercedVariables() {
 
     /**
      * @param <T> for two
-     *
      * @return the legacy context
-     *
      * @deprecated use {@link #getGraphQLContext()} instead
      */
     @Deprecated(since = "2021-07-05")
@@ -170,6 +162,17 @@ public ValueUnboxer getValueUnboxer() {
         return valueUnboxer;
     }
 
+    /**
+     * @return true if the current operation should propagate errors in non-null positions
+     * Propagating errors is the default. Error aware clients may opt in returning null in non-null positions
+     * by using the `@experimental_disableErrorPropagation` directive.
+     * @see graphql.Directives#setExperimentalDisableErrorPropagationEnabled(boolean) to change the JVM wide default
+     */
+    @ExperimentalApi
+    public boolean propagateErrorsOnNonNullContractFailure() {
+        return propagateErrorsOnNonNullContractFailure;
+    }
+
     /**
      * @return true if the current operation is a Query
      */
@@ -317,7 +320,6 @@ public DataLoaderDispatchStrategy getDataLoaderDispatcherStrategy() {
      * the current values and allows you to transform it how you want.
      *
      * @param builderConsumer the consumer code that will be given a builder to transform
-     *
      * @return a new ExecutionContext object based on calling build on that builder
      */
     public ExecutionContext transform(Consumer<ExecutionContextBuilder> builderConsumer) {

src/main/java/graphql/execution/ExecutionContextBuilder.java

@@ -3,6 +3,7 @@
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import graphql.ExecutionInput;
+import graphql.ExperimentalApi;
 import graphql.GraphQLContext;
 import graphql.GraphQLError;
 import graphql.Internal;
@@ -46,6 +47,7 @@ public class ExecutionContextBuilder {
     Object localContext;
     ExecutionInput executionInput;
     DataLoaderDispatchStrategy dataLoaderDispatcherStrategy = DataLoaderDispatchStrategy.NO_OP;
+    boolean propagateErrorsOnNonNullContractFailure = true;
 
     /**
      * @return a new builder of {@link graphql.execution.ExecutionContext}s
@@ -92,6 +94,7 @@ public ExecutionContextBuilder() {
         valueUnboxer = other.getValueUnboxer();
         executionInput = other.getExecutionInput();
         dataLoaderDispatcherStrategy = other.getDataLoaderDispatcherStrategy();
+        propagateErrorsOnNonNullContractFailure = other.propagateErrorsOnNonNullContractFailure();
     }
 
     public ExecutionContextBuilder instrumentation(Instrumentation instrumentation) {
@@ -216,6 +219,13 @@ public ExecutionContextBuilder resetErrors() {
         return this;
     }
 
+    @ExperimentalApi
+    public ExecutionContextBuilder propagapropagateErrorsOnNonNullContractFailureeErrors(boolean propagateErrorsOnNonNullContractFailure) {
+        this.propagateErrorsOnNonNullContractFailure = propagateErrorsOnNonNullContractFailure;
+        return this;
+    }
+
+
     public ExecutionContext build() {
         // preconditions
         assertNotNull(executionId, () -> "You must provide a query identifier");

src/main/java/graphql/execution/NonNullableFieldValidator.java

@@ -56,7 +56,9 @@ public <T> T validate(ExecutionStrategyParameters parameters, T result) throws N
                 } else {
                     executionContext.addError(error, path);
                 }
-                throw nonNullException;
+                if (executionContext.propagateErrorsOnNonNullContractFailure()) {
+                    throw nonNullException;
+                }
             }
         }
         return result;

src/main/java/graphql/schema/idl/SchemaGeneratorAppliedDirectiveHelper.java

@@ -35,7 +35,7 @@
 import static java.util.stream.Collectors.toMap;
 
 /**
- * This contains helper code to build out appliedm directives on schema element
+ * This contains helper code to build out applied directives on schema element
  */
 @Internal
 class SchemaGeneratorAppliedDirectiveHelper {

src/main/java/graphql/schema/idl/SchemaGeneratorHelper.java

@@ -56,7 +56,6 @@
 import graphql.schema.GraphQLTypeReference;
 import graphql.schema.GraphQLUnionType;
 import graphql.schema.GraphqlTypeComparatorRegistry;
-import graphql.schema.PropertyDataFetcher;
 import graphql.schema.SingletonPropertyDataFetcher;
 import graphql.schema.TypeResolver;
 import graphql.schema.TypeResolverProxy;