graphql-java
diff --git a/performance-results/2025-04-07T01:27:42Z-154bb89d14e9701d1b9f0764cbf813ba3a3c050a-jdk17.json b/performance-results/2025-04-07T01:27:42Z-154bb89d14e9701d1b9f0764cbf813ba3a3c050a-jdk17.json
diff --git a/performance-results/2025-04-07T02:23:04Z-27b9defd98c4d044b6142c18773188f0dc9113c2-jdk17.json b/performance-results/2025-04-07T02:23:04Z-27b9defd98c4d044b6142c18773188f0dc9113c2-jdk17.json
diff --git a/src/jmh/java/performance/DataLoaderPerformance.java b/src/jmh/java/performance/DataLoaderPerformance.java
@@ -4,6 +4,7 @@
 import graphql.ExecutionInput;
 import graphql.ExecutionResult;
 import graphql.GraphQL;
+import graphql.execution.instrumentation.dataloader.DataLoaderDispatchingContextKeys;
 import graphql.schema.DataFetcher;
 import graphql.schema.GraphQLSchema;
 import graphql.schema.idl.RuntimeWiring;
@@ -184,6 +185,7 @@ public void executeRequestWithDataLoaders(MyState myState, Blackhole blackhole)
         DataLoaderRegistry registry = DataLoaderRegistry.newRegistry().register(ownerDLName, ownerDL).register(petDLName, petDL).build();
 
         ExecutionInput executionInput = ExecutionInput.newExecutionInput().query(myState.query).dataLoaderRegistry(registry).build();
+        executionInput.getGraphQLContext().put(DataLoaderDispatchingContextKeys.ENABLE_DATA_LOADER_CHAINING, true);
         ExecutionResult execute = myState.graphQL.execute(executionInput);
         Assert.assertTrue(execute.isDataPresent());
         Assert.assertTrue(execute.getErrors().isEmpty());

diff --git a/src/main/java/graphql/execution/DataLoaderDispatchStrategy.java b/src/main/java/graphql/execution/DataLoaderDispatchStrategy.java
@@ -2,8 +2,10 @@
 
 import graphql.Internal;
 import graphql.schema.DataFetcher;
+import graphql.schema.DataFetchingEnvironment;
 
 import java.util.List;
+import java.util.function.Supplier;
 
 @Internal
 public interface DataLoaderDispatchStrategy {
@@ -44,7 +46,8 @@ default void executeObjectOnFieldValuesException(Throwable t, ExecutionStrategyP
     default void fieldFetched(ExecutionContext executionContext,
                               ExecutionStrategyParameters executionStrategyParameters,
                               DataFetcher<?> dataFetcher,
-                              Object fetchedValue) {
+                              Object fetchedValue,
+                              Supplier<DataFetchingEnvironment> dataFetchingEnvironment) {
 
     }
 

diff --git a/src/main/java/graphql/execution/Execution.java b/src/main/java/graphql/execution/Execution.java
@@ -60,6 +60,7 @@ public class Execution {
     private final ResponseMapFactory responseMapFactory;
     private final boolean doNotAutomaticallyDispatchDataLoader;
 
+
     public Execution(ExecutionStrategy queryStrategy,
                      ExecutionStrategy mutationStrategy,
                      ExecutionStrategy subscriptionStrategy,

diff --git a/src/main/java/graphql/execution/ExecutionStrategy.java b/src/main/java/graphql/execution/ExecutionStrategy.java
@@ -400,6 +400,7 @@ private Object fetchField(GraphQLFieldDefinition fieldDef, ExecutionContext exec
         }
 
         MergedField field = parameters.getField();
+        String pathString = parameters.getPath().toString();
         GraphQLObjectType parentType = (GraphQLObjectType) parameters.getExecutionStepInfo().getUnwrappedNonNullType();
 
         // if the DF (like PropertyDataFetcher) does not use the arguments or execution step info then dont build any
@@ -450,7 +451,7 @@ private Object fetchField(GraphQLFieldDefinition fieldDef, ExecutionContext exec
         dataFetcher = instrumentation.instrumentDataFetcher(dataFetcher, instrumentationFieldFetchParams, executionContext.getInstrumentationState());
         dataFetcher = executionContext.getDataLoaderDispatcherStrategy().modifyDataFetcher(dataFetcher);
         Object fetchedObject = invokeDataFetcher(executionContext, parameters, fieldDef, dataFetchingEnvironment, dataFetcher);
-        executionContext.getDataLoaderDispatcherStrategy().fieldFetched(executionContext, parameters, dataFetcher, fetchedObject);
+        executionContext.getDataLoaderDispatcherStrategy().fieldFetched(executionContext, parameters, dataFetcher, fetchedObject, dataFetchingEnvironment);
         fetchCtx.onDispatched();
         fetchCtx.onFetchedValue(fetchedObject);
         // if it's a subscription, leave any reactive objects alone

diff --git a/src/main/java/graphql/execution/ResultPath.java b/src/main/java/graphql/execution/ResultPath.java
@@ -38,20 +38,36 @@ public static ResultPath rootPath() {
 
     // hash is effective immutable but lazily initialized similar to the hash code of java.lang.String
     private int hash;
+    private final String toStringValue;
 
     private ResultPath() {
         parent = null;
         segment = null;
+        this.toStringValue = initString();
     }
 
     private ResultPath(ResultPath parent, String segment) {
         this.parent = assertNotNull(parent, () -> "Must provide a parent path");
         this.segment = assertNotNull(segment, () -> "Must provide a sub path");
+        this.toStringValue = initString();
     }
 
     private ResultPath(ResultPath parent, int segment) {
         this.parent = assertNotNull(parent, () -> "Must provide a parent path");
         this.segment = segment;
+        this.toStringValue = initString();
+    }
+
+    private String initString() {
+        if (parent == null) {
+            return "";
+        }
+
+        if (ROOT_PATH.equals(parent)) {
+            return segmentToString();
+        }
+        return parent + segmentToString();
+
     }
 
     public int getLevel() {
@@ -294,15 +310,7 @@ public List<String> getKeysOnly() {
      */
     @Override
     public String toString() {
-        if (parent == null) {
-            return "";
-        }
-
-        if (ROOT_PATH.equals(parent)) {
-            return segmentToString();
-        }
-
-        return parent.toString() + segmentToString();
+        return toStringValue;
     }
 
     public String segmentToString() {

diff --git a/...n/java/graphql/execution/instrumentation/dataloader/DataLoaderDispatchingContextKeys.java b/...n/java/graphql/execution/instrumentation/dataloader/DataLoaderDispatchingContextKeys.java
@@ -0,0 +1,83 @@
+package graphql.execution.instrumentation.dataloader;
+
+
+import graphql.ExperimentalApi;
+import graphql.GraphQLContext;
+import org.jspecify.annotations.NullMarked;
+
+import java.time.Duration;
+
+/**
+ * GraphQLContext keys related to DataLoader dispatching.
+ */
+@ExperimentalApi
+@NullMarked
+public final class DataLoaderDispatchingContextKeys {
+    private DataLoaderDispatchingContextKeys() {
+    }
+
+    /**
+     * In nano seconds, the batch window size for delayed DataLoaders.
+     * That is for DataLoaders, that are not batched as part of the normal per level
+     * dispatching, because they were created after the level was already dispatched.
+     * <p>
+     * Expect Long values
+     * <p>
+     * Default is 500_000 (0.5 ms)
+     */
+    public static final String DELAYED_DATA_LOADER_BATCH_WINDOW_SIZE_NANO_SECONDS = "__GJ_delayed_data_loader_batch_window_size_nano_seconds";
+
+    /**
+     * An instance of {@link DelayedDataLoaderDispatcherExecutorFactory} that is used to create the
+     * {@link java.util.concurrent.ScheduledExecutorService} for the delayed DataLoader dispatching.
+     * <p>
+     * Default is one static executor thread pool with a single thread.
+     */
+    public static final String DELAYED_DATA_LOADER_DISPATCHING_EXECUTOR_FACTORY = "__GJ_delayed_data_loader_dispatching_executor_factory";
+
+
+    /**
+     * Enables the ability to chain DataLoader dispatching.
+     * <p>
+     * Because this requires that all DataLoaders are accessed via DataFetchingEnvironment.getLoader()
+     * this is not completely backwards compatible and therefore disabled by default.
+     * <p>
+     * Expects a boolean value.
+     */
+    public static final String ENABLE_DATA_LOADER_CHAINING = "__GJ_enable_data_loader_chaining";
+
+
+    /**
+     * Enables the ability that chained DataLoaders are dispatched automatically.
+     *
+     * @param graphQLContext
+     */
+    public static void setEnableDataLoaderChaining(GraphQLContext graphQLContext, boolean enabled) {
+        graphQLContext.put(ENABLE_DATA_LOADER_CHAINING, enabled);
+    }
+
+
+    /**
+     * Sets nanoseconds the batch window duration size for delayed DataLoaders.
+     * That is for DataLoaders, that are not batched as part of the normal per level
+     * dispatching, because they were created after the level was already dispatched.
+     *
+     * @param graphQLContext
+     * @param batchWindowSize
+     */
+    public static void setDelayedDataLoaderBatchWindowSize(GraphQLContext graphQLContext, Duration batchWindowSize) {
+        graphQLContext.put(DELAYED_DATA_LOADER_BATCH_WINDOW_SIZE_NANO_SECONDS, batchWindowSize.toNanos());
+    }
+
+    /**
+     * Sets the instance of {@link DelayedDataLoaderDispatcherExecutorFactory} that is used to create the
+     * {@link java.util.concurrent.ScheduledExecutorService} for the delayed DataLoader dispatching.
+     * <p>
+     *
+     * @param graphQLContext
+     * @param delayedDataLoaderDispatcherExecutorFactory
+     */
+    public static void setDelayedDataLoaderDispatchingExecutorFactory(GraphQLContext graphQLContext, DelayedDataLoaderDispatcherExecutorFactory delayedDataLoaderDispatcherExecutorFactory) {
+        graphQLContext.put(DELAYED_DATA_LOADER_DISPATCHING_EXECUTOR_FACTORY, delayedDataLoaderDispatcherExecutorFactory);
+    }
+}
diff --git a/...phql/execution/instrumentation/dataloader/DelayedDataLoaderDispatcherExecutorFactory.java b/...phql/execution/instrumentation/dataloader/DelayedDataLoaderDispatcherExecutorFactory.java
@@ -0,0 +1,29 @@
+package graphql.execution.instrumentation.dataloader;
+
+import graphql.ExperimentalApi;
+import graphql.GraphQLContext;
+import graphql.execution.ExecutionId;
+import org.jspecify.annotations.NullMarked;
+
+import java.util.concurrent.ScheduledExecutorService;
+
+/**
+ * See {@link DataLoaderDispatchingContextKeys} for how to set it.
+ */
+@ExperimentalApi
+@NullMarked
+@FunctionalInterface
+public interface DelayedDataLoaderDispatcherExecutorFactory {
+
+    /**
+     * Called once per execution to create the {@link ScheduledExecutorService} for the delayed DataLoader dispatching.
+     *
+     * Will only called if needed, i.e. if there are delayed DataLoaders.
+     *
+     * @param executionId
+     * @param graphQLContext
+     *
+     * @return
+     */
+    ScheduledExecutorService createExecutor(ExecutionId executionId, GraphQLContext graphQLContext);
+}