graphql-java · bbakerman · Nov 25, 2022 · Sep 10, 2022 · Sep 10, 2022 · Sep 10, 2022
diff --git a/src/main/java/graphql/execution/ExecutionStrategy.java b/src/main/java/graphql/execution/ExecutionStrategy.java
@@ -37,6 +37,7 @@
 import graphql.schema.GraphQLScalarType;
 import graphql.schema.GraphQLSchema;
 import graphql.schema.GraphQLType;
+import graphql.schema.LightDataFetcher;
 import graphql.util.FpKit;
 import graphql.util.LogKit;
 import org.slf4j.Logger;
@@ -237,68 +238,59 @@ protected CompletableFuture<FetchedValue> fetchField(ExecutionContext executionC
         MergedField field = parameters.getField();
         GraphQLObjectType parentType = (GraphQLObjectType) parameters.getExecutionStepInfo().getUnwrappedNonNullType();
         GraphQLFieldDefinition fieldDef = getFieldDef(executionContext.getGraphQLSchema(), parentType, field.getSingleField());
-
         GraphQLCodeRegistry codeRegistry = executionContext.getGraphQLSchema().getCodeRegistry();
-        GraphQLOutputType fieldType = fieldDef.getType();
 
-        // if the DF (like PropertyDataFetcher) does not use the arguments of execution step info then dont build any
-        Supplier<ExecutionStepInfo> executionStepInfo = FpKit.intraThreadMemoize(
-                () -> createExecutionStepInfo(executionContext, parameters, fieldDef, parentType));
-        Supplier<Map<String, Object>> argumentValues = () -> executionStepInfo.get().getArguments();
+        // if the DF (like PropertyDataFetcher) does not use the arguments or execution step info then dont build any
 
-        Supplier<ExecutableNormalizedField> normalizedFieldSupplier = getNormalizedField(executionContext, parameters, executionStepInfo);
+        Supplier<DataFetchingEnvironment> dataFetchingEnvironment = FpKit.intraThreadMemoize(() -> {
 
-        // DataFetchingFieldSelectionSet and QueryDirectives is a supplier of sorts - eg a lazy pattern
-        DataFetchingFieldSelectionSet fieldCollector = DataFetchingFieldSelectionSetImpl.newCollector(executionContext.getGraphQLSchema(), fieldType, normalizedFieldSupplier);
-        QueryDirectives queryDirectives = new QueryDirectivesImpl(field,
-                executionContext.getGraphQLSchema(),
-                executionContext.getCoercedVariables().toMap(),
-                executionContext.getGraphQLContext(),
-                executionContext.getLocale());
+            Supplier<ExecutionStepInfo> executionStepInfo = FpKit.intraThreadMemoize(
+                    () -> createExecutionStepInfo(executionContext, parameters, fieldDef, parentType));
 
+            Supplier<Map<String, Object>> argumentValues = () -> executionStepInfo.get().getArguments();
+
+            Supplier<ExecutableNormalizedField> normalizedFieldSupplier = getNormalizedField(executionContext, parameters, executionStepInfo);
+
+            // DataFetchingFieldSelectionSet and QueryDirectives is a supplier of sorts - eg a lazy pattern
+            DataFetchingFieldSelectionSet fieldCollector = DataFetchingFieldSelectionSetImpl.newCollector(executionContext.getGraphQLSchema(), fieldDef.getType(), normalizedFieldSupplier);
+            QueryDirectives queryDirectives = new QueryDirectivesImpl(field,
+                    executionContext.getGraphQLSchema(),
+                    executionContext.getCoercedVariables().toMap(),
+                    executionContext.getGraphQLContext(),
+                    executionContext.getLocale());
 
-        DataFetchingEnvironment environment = newDataFetchingEnvironment(executionContext)
-                .source(parameters.getSource())
-                .localContext(parameters.getLocalContext())
-                .arguments(argumentValues)
-                .fieldDefinition(fieldDef)
-                .mergedField(parameters.getField())
-                .fieldType(fieldType)
-                .executionStepInfo(executionStepInfo)
-                .parentType(parentType)
-                .selectionSet(fieldCollector)
-                .queryDirectives(queryDirectives)
-                .build();
 
+            return newDataFetchingEnvironment(executionContext)
+                    .source(parameters.getSource())
+                    .localContext(parameters.getLocalContext())
+                    .arguments(argumentValues)
+                    .fieldDefinition(fieldDef)
+                    .mergedField(parameters.getField())
+                    .fieldType(fieldDef.getType())
+                    .executionStepInfo(executionStepInfo)
+                    .parentType(parentType)
+                    .selectionSet(fieldCollector)
+                    .queryDirectives(queryDirectives)
+                    .build();
+        });
         DataFetcher<?> dataFetcher = codeRegistry.getDataFetcher(parentType, fieldDef);
 
         Instrumentation instrumentation = executionContext.getInstrumentation();
 
-        InstrumentationFieldFetchParameters instrumentationFieldFetchParams = new InstrumentationFieldFetchParameters(executionContext, environment, parameters, dataFetcher instanceof TrivialDataFetcher);
+        InstrumentationFieldFetchParameters instrumentationFieldFetchParams = new InstrumentationFieldFetchParameters(executionContext, dataFetchingEnvironment, parameters, dataFetcher instanceof TrivialDataFetcher);
         InstrumentationContext<Object> fetchCtx = nonNullCtx(instrumentation.beginFieldFetch(instrumentationFieldFetchParams,
                 executionContext.getInstrumentationState())
         );
 
-        CompletableFuture<Object> fetchedValue;
         dataFetcher = instrumentation.instrumentDataFetcher(dataFetcher, instrumentationFieldFetchParams, executionContext.getInstrumentationState());
-        ExecutionId executionId = executionContext.getExecutionId();
-        try {
-            Object fetchedValueRaw = dataFetcher.get(environment);
-            fetchedValue = Async.toCompletableFuture(fetchedValueRaw);
-        } catch (Exception e) {
-            if (logNotSafe.isDebugEnabled()) {
-                logNotSafe.debug(String.format("'%s', field '%s' fetch threw exception", executionId, executionStepInfo.get().getPath()), e);
-            }
+        CompletableFuture<Object> fetchedValue = invokeDataFetcher(executionContext, parameters, fieldDef, dataFetchingEnvironment, dataFetcher);
 
-            fetchedValue = new CompletableFuture<>();
-            fetchedValue.completeExceptionally(e);
-        }
         fetchCtx.onDispatched(fetchedValue);
         return fetchedValue
                 .handle((result, exception) -> {
                     fetchCtx.onCompleted(result, exception);
                     if (exception != null) {
-                        return handleFetchingException(executionContext, environment, exception);
+                        return handleFetchingException(executionContext, dataFetchingEnvironment.get(), exception);
                     } else {
                         return CompletableFuture.completedFuture(result);
                     }
@@ -307,6 +299,25 @@ protected CompletableFuture<FetchedValue> fetchField(ExecutionContext executionC
                 .thenApply(result -> unboxPossibleDataFetcherResult(executionContext, parameters, result));
     }
 
+    private CompletableFuture<Object> invokeDataFetcher(ExecutionContext executionContext, ExecutionStrategyParameters parameters, GraphQLFieldDefinition fieldDef, Supplier<DataFetchingEnvironment> dataFetchingEnvironment, DataFetcher<?> dataFetcher) {
+        CompletableFuture<Object> fetchedValue;
+        try {
+            Object fetchedValueRaw;
+            if (dataFetcher instanceof LightDataFetcher) {
+                fetchedValueRaw = ((LightDataFetcher<?>) dataFetcher).get(fieldDef, parameters.getSource(), dataFetchingEnvironment);
+            } else {
+                fetchedValueRaw = dataFetcher.get(dataFetchingEnvironment.get());
+            }
+            fetchedValue = Async.toCompletableFuture(fetchedValueRaw);
+        } catch (Exception e) {
+            if (logNotSafe.isDebugEnabled()) {
+                logNotSafe.debug(String.format("'%s', field '%s' fetch threw exception", executionContext.getExecutionId(), parameters.getPath()), e);
+            }
+            fetchedValue = Async.exceptionallyCompletedFuture(e);
+        }
+        return fetchedValue;
+    }
+
     protected Supplier<ExecutableNormalizedField> getNormalizedField(ExecutionContext executionContext, ExecutionStrategyParameters parameters, Supplier<ExecutionStepInfo> executionStepInfo) {
         Supplier<ExecutableNormalizedOperation> normalizedQuery = executionContext.getNormalizedQueryTree();
         return () -> normalizedQuery.get().getNormalizedField(parameters.getField(), executionStepInfo.get().getObjectType(), executionStepInfo.get().getPath());

diff --git a/...ava/graphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters.java b/...ava/graphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters.java
@@ -8,24 +8,26 @@
 import graphql.execution.instrumentation.InstrumentationState;
 import graphql.schema.DataFetchingEnvironment;
 
+import java.util.function.Supplier;
+
 /**
  * Parameters sent to {@link Instrumentation} methods
  */
 @PublicApi
 public class InstrumentationFieldFetchParameters extends InstrumentationFieldParameters {
-    private final DataFetchingEnvironment environment;
+    private final Supplier<DataFetchingEnvironment> environment;
     private final ExecutionStrategyParameters executionStrategyParameters;
     private final boolean trivialDataFetcher;
 
-    public InstrumentationFieldFetchParameters(ExecutionContext getExecutionContext, DataFetchingEnvironment environment, ExecutionStrategyParameters executionStrategyParameters, boolean trivialDataFetcher) {
-        super(getExecutionContext, environment::getExecutionStepInfo);
+    public InstrumentationFieldFetchParameters(ExecutionContext getExecutionContext, Supplier<DataFetchingEnvironment> environment, ExecutionStrategyParameters executionStrategyParameters, boolean trivialDataFetcher) {
+        super(getExecutionContext, () -> environment.get().getExecutionStepInfo());
         this.environment = environment;
         this.executionStrategyParameters = executionStrategyParameters;
         this.trivialDataFetcher = trivialDataFetcher;
     }
 
-    private InstrumentationFieldFetchParameters(ExecutionContext getExecutionContext, DataFetchingEnvironment environment, InstrumentationState instrumentationState, ExecutionStrategyParameters executionStrategyParameters, boolean trivialDataFetcher) {
-        super(getExecutionContext, environment::getExecutionStepInfo, instrumentationState);
+    private InstrumentationFieldFetchParameters(ExecutionContext getExecutionContext, Supplier<DataFetchingEnvironment> environment, InstrumentationState instrumentationState, ExecutionStrategyParameters executionStrategyParameters, boolean trivialDataFetcher) {
+        super(getExecutionContext, () -> environment.get().getExecutionStepInfo(), instrumentationState);
         this.environment = environment;
         this.executionStrategyParameters = executionStrategyParameters;
         this.trivialDataFetcher = trivialDataFetcher;
@@ -45,13 +47,13 @@ private InstrumentationFieldFetchParameters(ExecutionContext getExecutionContext
     @Override
     public InstrumentationFieldFetchParameters withNewState(InstrumentationState instrumentationState) {
         return new InstrumentationFieldFetchParameters(
-                this.getExecutionContext(), this.getEnvironment(),
+                this.getExecutionContext(), this.environment,
                 instrumentationState, executionStrategyParameters, trivialDataFetcher);
     }
 
 
     public DataFetchingEnvironment getEnvironment() {
-        return environment;
+        return environment.get();
     }
 
     public boolean isTrivialDataFetcher() {

diff --git a/src/main/java/graphql/schema/LightDataFetcher.java b/src/main/java/graphql/schema/LightDataFetcher.java
@@ -0,0 +1,36 @@
+package graphql.schema;
+
+import graphql.TrivialDataFetcher;
+
+import java.util.function.Supplier;
+
+/**
+ * A {@link LightDataFetcher} is a specialised version of {@link DataFetcher} that is passed more lightweight arguments
+ * when it is asked to fetch values.  The most common example of this is the {@link PropertyDataFetcher} which does not need
+ * all the {@link DataFetchingEnvironment} values to perform its duties.
+ *
+ * @param <T> for two
+ */
+public interface LightDataFetcher<T> extends TrivialDataFetcher<T> {
+
+    /**
+     * This is called to by the engine to get a value from the source object in a lightweight fashion.  Only the field
+     * and source object are passed in a materialised way.  The more heavy weight {@link DataFetchingEnvironment} is wrapped
+     * in a supplier that is only created on demand.
+     * <p>
+     * If you are a lightweight data fetcher (like {@link PropertyDataFetcher} is) then you can implement this method to have a more lightweight
+     * method invocation.  However, if you need field arguments etc. during fetching (most custom fetchers will) then you should use implement
+     * {@link #get(DataFetchingEnvironment)}.
+     *
+     * @param fieldDefinition     the graphql field definition
+     * @param sourceObject        the source object to get a value from
+     * @param environmentSupplier a supplier of the {@link DataFetchingEnvironment} that creates it lazily
+     *
+     * @return a value of type T. May be wrapped in a {@link graphql.execution.DataFetcherResult}
+     *
+     * @throws Exception to relieve the implementations from having to wrap checked exceptions. Any exception thrown
+     *                   from a {@code DataFetcher} will eventually be handled by the registered {@link graphql.execution.DataFetcherExceptionHandler}
+     *                   and the related field will have a value of {@code null} in the result.
+     */
+    T get(GraphQLFieldDefinition fieldDefinition, Object sourceObject, Supplier<DataFetchingEnvironment> environmentSupplier) throws Exception;
+}
diff --git a/src/main/java/graphql/schema/PropertyDataFetcher.java b/src/main/java/graphql/schema/PropertyDataFetcher.java
@@ -3,9 +3,9 @@
 
 import graphql.Assert;
 import graphql.PublicApi;
-import graphql.TrivialDataFetcher;
 
 import java.util.function.Function;
+import java.util.function.Supplier;
 
 /**
  * This is the default data fetcher used in graphql-java, and it will examine
@@ -31,7 +31,7 @@
  * @see graphql.schema.DataFetcher
  */
 @PublicApi
-public class PropertyDataFetcher<T> implements DataFetcher<T>, TrivialDataFetcher<T> {
+public class PropertyDataFetcher<T> implements LightDataFetcher<T> {
 
     private final String propertyName;
     private final Function<Object, Object> function;
@@ -69,6 +69,7 @@ private <O> PropertyDataFetcher(Function<O, T> function) {
      *
      * @param propertyName the name of the property to retrieve
      * @param <T>          the type of result
+     *
      * @return a new PropertyDataFetcher using the provided function as its source of values
      */
     public static <T> PropertyDataFetcher<T> fetching(String propertyName) {
@@ -92,6 +93,7 @@ public static <T> PropertyDataFetcher<T> fetching(String propertyName) {
      * @param function the function to use to obtain a value from the source object
      * @param <O>      the type of the source object
      * @param <T>      the type of result
+     *
      * @return a new PropertyDataFetcher using the provided function as its source of values
      */
     public static <T, O> PropertyDataFetcher<T> fetching(Function<O, T> function) {
@@ -105,10 +107,19 @@ public String getPropertyName() {
         return propertyName;
     }
 
-    @SuppressWarnings("unchecked")
+    @Override
+    public T get(GraphQLFieldDefinition fieldDefinition, Object source, Supplier<DataFetchingEnvironment> environmentSupplier) throws Exception {
+        return getImpl(source, fieldDefinition.getType(), environmentSupplier);
+    }
+
     @Override
     public T get(DataFetchingEnvironment environment) {
         Object source = environment.getSource();
+        return getImpl(source, environment.getFieldType(), () -> environment);
+    }
+
+    @SuppressWarnings("unchecked")
+    private T getImpl(Object source, GraphQLOutputType fieldDefinition, Supplier<DataFetchingEnvironment> environmentSupplier) {
         if (source == null) {
             return null;
         }
@@ -117,7 +128,7 @@ public T get(DataFetchingEnvironment environment) {
             return (T) function.apply(source);
         }
 
-        return (T) PropertyDataFetcherHelper.getPropertyValue(propertyName, source, environment.getFieldType(), environment);
+        return (T) PropertyDataFetcherHelper.getPropertyValue(propertyName, source, fieldDefinition, environmentSupplier);
     }
 
     /**
@@ -138,6 +149,7 @@ public static void clearReflectionCache() {
      * values.  By default it PropertyDataFetcher WILL use setAccessible.
      *
      * @param flag whether to use setAccessible
+     *
      * @return the previous value of the flag
      */
     public static boolean setUseSetAccessible(boolean flag) {
@@ -148,6 +160,7 @@ public static boolean setUseSetAccessible(boolean flag) {
      * This can be used to control whether PropertyDataFetcher will cache negative lookups for a property for performance reasons.  By default it PropertyDataFetcher WILL cache misses.
      *
      * @param flag whether to cache misses
+     *
      * @return the previous value of the flag
      */
     public static boolean setUseNegativeCache(boolean flag) {

diff --git a/src/main/java/graphql/schema/PropertyDataFetcherHelper.java b/src/main/java/graphql/schema/PropertyDataFetcherHelper.java
@@ -3,6 +3,8 @@
 import graphql.Internal;
 import graphql.VisibleForTesting;
 
+import java.util.function.Supplier;
+
 /**
  * This class is the guts of a property data fetcher and also used in AST code to turn
  * in memory java objects into AST elements
@@ -13,11 +15,11 @@ public class PropertyDataFetcherHelper {
     private static final PropertyFetchingImpl impl = new PropertyFetchingImpl(DataFetchingEnvironment.class);
 
     public static Object getPropertyValue(String propertyName, Object object, GraphQLType graphQLType) {
-        return impl.getPropertyValue(propertyName, object, graphQLType, null);
+        return impl.getPropertyValue(propertyName, object, graphQLType, false, () -> null);
     }
 
-    public static Object getPropertyValue(String propertyName, Object object, GraphQLType graphQLType, DataFetchingEnvironment environment) {
-        return impl.getPropertyValue(propertyName, object, graphQLType, environment);
+    public static Object getPropertyValue(String propertyName, Object object, GraphQLType graphQLType, Supplier<DataFetchingEnvironment> environment) {
+        return impl.getPropertyValue(propertyName, object, graphQLType, true, environment::get);
     }
 
     public static void clearReflectionCache() {