Allow context to be scoped

By implementing the ScopedContext marker interface in your context object, you can ensure that
scope is only passed downwards and not shared with other fields.

Example:
```graphql
query {
  a {
    b {
      c
    }
    d {
      e {
        f
      }
    }
  }
  g {
    h {
      i
    }
  }
}
```

In the above situation, the following will happen:
* `a` receives the cloned context from the executor
* `b` receives the cloned context from `a`
* `c` receives the cloned context from `b`
* `d` receives the cloned context from `d`
* `f` receives the cloned context from `d`
* `g` receives the cloned context from the executor
* `h` receives the cloned context from `g`
* `i` receives the cloned context from `h`

For now I decided to use a marker interface `ScopedContext`. Although I'm not fan of marker
interfaces, it was the easiest way to get this working. We could also make this an option that
needs to be passed to the `Executor`. Something like `$useScopedContext = false` (disabled by
default).

References:
graphql/graphql-js#2692
rmosolgo/graphql-ruby#2634

Author: ruudk

src/Executor/ReferenceExecutor.php

@@ -294,8 +294,8 @@ protected function executeOperation(OperationDefinitionNode $operation, $rootVal
         // Similar to completeValueCatchingError.
         try {
             $result = $operation->operation === 'mutation'
-                ? $this->executeFieldsSerially($type, $rootValue, $path, $fields)
-                : $this->executeFields($type, $rootValue, $path, $fields);
+                ? $this->executeFieldsSerially($type, $rootValue, $path, $fields, $this->exeContext->contextValue)
+                : $this->executeFields($type, $rootValue, $path, $fields, $this->exeContext->contextValue);
 
             $promise = $this->getPromise($result);
             if ($promise !== null) {
@@ -522,22 +522,23 @@ protected function doesFragmentConditionMatch(Node $fragment, ObjectType $type):
      *
      * @param mixed             $rootValue
      * @param array<string|int> $path
+     * @param mixed             $contextValue
      *
      * @phpstan-param Fields $fields
      *
      * @return array<mixed>|Promise|\stdClass
      */
-    protected function executeFieldsSerially(ObjectType $parentType, $rootValue, array $path, \ArrayObject $fields)
+    protected function executeFieldsSerially(ObjectType $parentType, $rootValue, array $path, \ArrayObject $fields, $contextValue)
     {
         $result = $this->promiseReduce(
             \array_keys($fields->getArrayCopy()),
-            function ($results, $responseName) use ($path, $parentType, $rootValue, $fields) {
+            function ($results, $responseName) use ($contextValue, $path, $parentType, $rootValue, $fields) {
                 $fieldNodes = $fields[$responseName];
                 assert($fieldNodes instanceof \ArrayObject, 'The keys of $fields populate $responseName');
 
                 $fieldPath = $path;
                 $fieldPath[] = $responseName;
-                $result = $this->resolveField($parentType, $rootValue, $fieldNodes, $fieldPath);
+                $result = $this->resolveField($parentType, $rootValue, $fieldNodes, $fieldPath, $contextValue);
                 if ($result === static::$UNDEFINED) {
                     return $results;
                 }
@@ -577,6 +578,7 @@ function ($results, $responseName) use ($path, $parentType, $rootValue, $fields)
      *
      * @param mixed                       $rootValue
      * @param array<int, string|int>      $path
+     * @param mixed                       $contextValue
      *
      * @phpstan-param Path                $path
      *
@@ -587,7 +589,7 @@ function ($results, $responseName) use ($path, $parentType, $rootValue, $fields)
      *
      * @return array<mixed>|\Throwable|mixed|null
      */
-    protected function resolveField(ObjectType $parentType, $rootValue, \ArrayObject $fieldNodes, array $path)
+    protected function resolveField(ObjectType $parentType, $rootValue, \ArrayObject $fieldNodes, array $path, $contextValue)
     {
         $exeContext = $this->exeContext;
         $fieldNode = $fieldNodes[0];
@@ -631,15 +633,17 @@ protected function resolveField(ObjectType $parentType, $rootValue, \ArrayObject
             $fieldNode,
             $resolveFn,
             $rootValue,
-            $info
+            $info,
+            $contextValue
         );
 
         return $this->completeValueCatchingError(
             $returnType,
             $fieldNodes,
             $info,
             $path,
-            $result
+            $result,
+            $contextValue
         );
     }
 
@@ -684,6 +688,7 @@ protected function getFieldDef(Schema $schema, ObjectType $parentType, string $f
      * Returns the result of resolveFn or the abrupt-return Error object.
      *
      * @param mixed $rootValue
+     * @param mixed $contextValue
      *
      * @phpstan-param FieldResolver $resolveFn
      *
@@ -694,7 +699,8 @@ protected function resolveFieldValueOrError(
         FieldNode $fieldNode,
         callable $resolveFn,
         $rootValue,
-        ResolveInfo $info
+        ResolveInfo $info,
+        $contextValue
     ) {
         try {
             // Build a map of arguments from the field.arguments AST, using the
@@ -704,7 +710,6 @@ protected function resolveFieldValueOrError(
                 $fieldNode,
                 $this->exeContext->variableValues
             );
-            $contextValue = $this->exeContext->contextValue;
 
             return $resolveFn($rootValue, $args, $contextValue, $info);
         } catch (\Throwable $error) {
@@ -718,6 +723,7 @@ protected function resolveFieldValueOrError(
      *
      * @param \ArrayObject<int, FieldNode> $fieldNodes
      * @param array<string|int>           $path
+     * @param mixed                       $contextValue
      *
      * @phpstan-param Path                $path
      *
@@ -732,18 +738,19 @@ protected function completeValueCatchingError(
         \ArrayObject $fieldNodes,
         ResolveInfo $info,
         array $path,
-        $result
+        $result,
+        $contextValue
     ) {
         // Otherwise, error protection is applied, logging the error and resolving
         // a null value for this field if one is encountered.
         try {
             $promise = $this->getPromise($result);
             if ($promise !== null) {
-                $completed = $promise->then(function (&$resolved) use ($returnType, $fieldNodes, $info, $path) {
-                    return $this->completeValue($returnType, $fieldNodes, $info, $path, $resolved);
+                $completed = $promise->then(function (&$resolved) use ($contextValue, $returnType, $fieldNodes, $info, $path) {
+                    return $this->completeValue($returnType, $fieldNodes, $info, $path, $resolved, $contextValue);
                 });
             } else {
-                $completed = $this->completeValue($returnType, $fieldNodes, $info, $path, $result);
+                $completed = $this->completeValue($returnType, $fieldNodes, $info, $path, $result, $contextValue);
             }
 
             $promise = $this->getPromise($completed);
@@ -811,6 +818,7 @@ protected function handleFieldError($rawError, \ArrayObject $fieldNodes, array $
      * @param \ArrayObject<int, FieldNode> $fieldNodes
      * @param array<string|int>           $path
      * @param mixed                       $result
+     * @param mixed                       $contextValue
      *
      * @throws \Throwable
      * @throws Error
@@ -822,7 +830,8 @@ protected function completeValue(
         \ArrayObject $fieldNodes,
         ResolveInfo $info,
         array $path,
-        &$result
+        &$result,
+        $contextValue
     ) {
         // If result is an Error, throw a located error.
         if ($result instanceof \Throwable) {
@@ -837,7 +846,8 @@ protected function completeValue(
                 $fieldNodes,
                 $info,
                 $path,
-                $result
+                $result,
+                $contextValue
             );
             if ($completed === null) {
                 throw new InvariantViolation("Cannot return null for non-nullable field \"{$info->parentType}.{$info->fieldName}\".");
@@ -858,7 +868,7 @@ protected function completeValue(
                 throw new InvariantViolation("Expected field {$info->parentType}.{$info->fieldName} to return iterable, but got: {$resultType}.");
             }
 
-            return $this->completeListValue($returnType, $fieldNodes, $info, $path, $result);
+            return $this->completeListValue($returnType, $fieldNodes, $info, $path, $result, $contextValue);
         }
 
         assert($returnType instanceof NamedType, 'Wrapping types should return early');
@@ -875,12 +885,12 @@ protected function completeValue(
         }
 
         if ($returnType instanceof AbstractType) {
-            return $this->completeAbstractValue($returnType, $fieldNodes, $info, $path, $result);
+            return $this->completeAbstractValue($returnType, $fieldNodes, $info, $path, $result, $contextValue);
         }
 
         // Field type must be and Object, Interface or Union and expect sub-selections.
         if ($returnType instanceof ObjectType) {
-            return $this->completeObjectValue($returnType, $fieldNodes, $info, $path, $result);
+            return $this->completeObjectValue($returnType, $fieldNodes, $info, $path, $result, $contextValue);
         }
 
         $safeReturnType = Utils::printSafe($returnType);
@@ -949,17 +959,19 @@ function ($previous, $value) use ($callback) {
      * @param \ArrayObject<int, FieldNode> $fieldNodes
      * @param list<string|int> $path
      * @param iterable<mixed> $results
-     *
-     * @throws Error
+     * @param mixed           $contextValue
      *
      * @return array<mixed>|Promise|\stdClass
+     *@throws Error
+     *
      */
     protected function completeListValue(
         ListOfType $returnType,
         \ArrayObject $fieldNodes,
         ResolveInfo $info,
         array $path,
-        iterable &$results
+        iterable &$results,
+        $contextValue
     ) {
         $itemType = $returnType->getWrappedType();
 
@@ -970,7 +982,7 @@ protected function completeListValue(
             $fieldPath = [...$path, $i++];
             $info->path = $fieldPath;
 
-            $completedItem = $this->completeValueCatchingError($itemType, $fieldNodes, $info, $fieldPath, $item);
+            $completedItem = $this->completeValueCatchingError($itemType, $fieldNodes, $info, $fieldPath, $item, $contextValue);
 
             if (! $containsPromise && $this->getPromise($completedItem) !== null) {
                 $containsPromise = true;
@@ -1016,6 +1028,7 @@ protected function completeLeafValue(LeafType $returnType, &$result)
      * @param \ArrayObject<int, FieldNode> $fieldNodes
      * @param array<string|int> $path
      * @param array<mixed> $result
+     * @param mixed $contextValue
      *
      * @throws \Exception
      * @throws Error
@@ -1028,7 +1041,8 @@ protected function completeAbstractValue(
         \ArrayObject $fieldNodes,
         ResolveInfo $info,
         array $path,
-        &$result
+        &$result,
+        $contextValue
     ) {
         $exeContext = $this->exeContext;
         $typeCandidate = $returnType->resolveType($result, $exeContext->contextValue, $info);
@@ -1053,7 +1067,8 @@ protected function completeAbstractValue(
                 $fieldNodes,
                 $info,
                 $path,
-                $result
+                $result,
+                $contextValue
             ));
         }
 
@@ -1067,7 +1082,8 @@ protected function completeAbstractValue(
             $fieldNodes,
             $info,
             $path,
-            $result
+            $result,
+            $contextValue
         );
     }
 
@@ -1143,6 +1159,7 @@ protected function defaultTypeResolver($value, $contextValue, ResolveInfo $info,
      * @param \ArrayObject<int, FieldNode> $fieldNodes
      * @param array<string|int>           $path
      * @param mixed                       $result
+     * @param mixed                       $contextValue
      *
      * @throws \Exception
      * @throws Error
@@ -1154,7 +1171,8 @@ protected function completeObjectValue(
         \ArrayObject $fieldNodes,
         ResolveInfo $info,
         array $path,
-        &$result
+        &$result,
+        $contextValue
     ) {
         // If there is an isTypeOf predicate function, call it with the
         // current result. If isTypeOf returns false, then raise an error rather
@@ -1164,6 +1182,7 @@ protected function completeObjectValue(
             $promise = $this->getPromise($isTypeOf);
             if ($promise !== null) {
                 return $promise->then(function ($isTypeOfResult) use (
+                    $contextValue,
                     $returnType,
                     $fieldNodes,
                     $path,
@@ -1177,7 +1196,8 @@ protected function completeObjectValue(
                         $returnType,
                         $fieldNodes,
                         $path,
-                        $result
+                        $result,
+                        $contextValue
                     );
                 });
             }
@@ -1192,7 +1212,8 @@ protected function completeObjectValue(
             $returnType,
             $fieldNodes,
             $path,
-            $result
+            $result,
+            $contextValue
         );
     }
 
@@ -1217,6 +1238,7 @@ protected function invalidReturnTypeError(
      * @param \ArrayObject<int, FieldNode> $fieldNodes
      * @param array<string|int>           $path
      * @param mixed                       $result
+     * @param mixed                       $contextValue
      *
      * @throws \Exception
      * @throws Error
@@ -1227,11 +1249,12 @@ protected function collectAndExecuteSubfields(
         ObjectType $returnType,
         \ArrayObject $fieldNodes,
         array $path,
-        &$result
+        &$result,
+        $contextValue
     ) {
         $subFieldNodes = $this->collectSubFields($returnType, $fieldNodes);
 
-        return $this->executeFields($returnType, $result, $path, $subFieldNodes);
+        return $this->executeFields($returnType, $result, $path, $subFieldNodes, $contextValue);
     }
 
     /**
@@ -1276,6 +1299,7 @@ protected function collectSubFields(ObjectType $returnType, \ArrayObject $fieldN
      *
      * @param mixed             $rootValue
      * @param array<string|int> $path
+     * @param mixed             $contextValue
      *
      * @phpstan-param Fields $fields
      *
@@ -1284,14 +1308,14 @@ protected function collectSubFields(ObjectType $returnType, \ArrayObject $fieldN
      *
      * @return Promise|\stdClass|array<mixed>
      */
-    protected function executeFields(ObjectType $parentType, $rootValue, array $path, \ArrayObject $fields)
+    protected function executeFields(ObjectType $parentType, $rootValue, array $path, \ArrayObject $fields, $contextValue)
     {
         $containsPromise = false;
         $results = [];
         foreach ($fields as $responseName => $fieldNodes) {
             $fieldPath = $path;
             $fieldPath[] = $responseName;
-            $result = $this->resolveField($parentType, $rootValue, $fieldNodes, $fieldPath);
+            $result = $this->resolveField($parentType, $rootValue, $fieldNodes, $fieldPath, $this->maybeScopeContext($contextValue));
             if ($result === static::$UNDEFINED) {
                 continue;
             }
@@ -1393,4 +1417,18 @@ protected function ensureValidRuntimeType(
 
         return $runtimeType;
     }
+
+    /**
+     * @param mixed $contextValue
+     *
+     * @return mixed
+     */
+    private function maybeScopeContext($contextValue)
+    {
+        if ($contextValue instanceof ScopedContext) {
+            return clone $contextValue;
+        }
+
+        return $contextValue;
+    }
 }

src/Executor/ScopedContext.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace GraphQL\Executor;
+
+/**
+ * This interface can be used to indicate that your context should be scoped.
+ *
+ * A scoped context will only delegate information to children.
+ */
+interface ScopedContext
+{
+}