Fix "Cannot traverse an already closed generator" in Schema::getTypeMap()

When `SchemaConfig::$types` is configured with a 'bare' `Generator` (an
iterable that can only be traversed once, which is allowed according to
the private property type), both `getScalarOverrides()`
and `getTypeMap()` need to iterate over it. Previously, each method
independently resolved `config->types` — calling the callable if needed
and then iterating the result. This caused a problem: if the generator
was consumed by `getScalarOverrides()` (either called from `getType()`
beforehand, or from within `getTypeMap()` itself), the subsequent
`foreach` in `getTypeMap()` would fail with "Cannot traverse an already
closed generator".

This fix extracts a `materializeTypes()` method that both
`getScalarOverrides()` and `getTypeMap()` now call. This method resolves
`config->types` by invoking the callable (if applicable) and converting
any non-array iterable (such as a `Generator`) into an array via
`iterator_to_array()`, storing the result back in `config->types`. This
ensures the generator is consumed exactly once and all subsequent access
operates on the materialized array.

Author: jerowork

src/Type/Schema.php

@@ -122,17 +122,12 @@ public function __construct($config)
     public function getTypeMap(): array
     {
         if (! $this->fullyLoaded) {
-            $types = $this->config->types;
-            if (is_callable($types)) {
-                $types = $types();
-            }
-
             // Reset order of user provided types, since calls to getType() may have loaded them
             $this->resolvedTypes = [];
 
             $scalarOverrides = $this->getScalarOverrides();
 
-            foreach ($types as $typeOrLazyType) {
+            foreach ($this->materializeTypes() as $typeOrLazyType) {
                 /** @var Type|callable(): Type $typeOrLazyType */
                 $type = self::resolveType($typeOrLazyType);
                 assert($type instanceof NamedType);
@@ -380,20 +375,8 @@ private function getScalarOverrides(): array
         if ($this->scalarOverrides === null) {
             $this->scalarOverrides = [];
 
-            $types = $this->config->types;
-            if (is_callable($types)) {
-                $types = $types();
-            }
-
-            // Materialize the iterable in case it is a generator, so that
-            // getTypeMap() can still iterate config->types later.
-            if (! is_array($types)) {
-                $types = iterator_to_array($types);
-                $this->config->types = $types;
-            }
-
             $builtInScalars = Type::builtInScalars();
-            foreach ($types as $typeOrLazyType) {
+            foreach ($this->materializeTypes() as $typeOrLazyType) {
                 /** @var Type|callable(): Type $typeOrLazyType */
                 $type = self::resolveType($typeOrLazyType);
                 if ($type instanceof ScalarType
@@ -408,6 +391,26 @@ private function getScalarOverrides(): array
         return $this->scalarOverrides;
     }
 
+    /**
+     * Resolve config->types to an array, materializing callables and generators.
+     *
+     * @return array<Type|callable(): Type>
+     */
+    private function materializeTypes(): array
+    {
+        $types = $this->config->types;
+        if (is_callable($types)) {
+            $types = $types();
+        }
+
+        if (! is_array($types)) {
+            $types = iterator_to_array($types);
+            $this->config->types = $types;
+        }
+
+        return $types;
+    }
+
     /**
      * @template T of Type
      *

tests/Type/ScalarOverridesTest.php

@@ -487,7 +487,7 @@ public function testTypesOverrideWorksWithCallableTypesConfig(): void
         self::assertSame(['data' => ['greeting' => 'HELLO WORLD']], $result->toArray());
     }
 
-    public function testTypesOverrideWorksWithGeneratorTypesConfig(): void
+    public function testTypesOverrideWorksWithCallableGeneratorTypesConfig(): void
     {
         $uppercaseString = self::createUppercaseString();
         $queryType = self::createQueryType();
@@ -507,6 +507,26 @@ public function testTypesOverrideWorksWithGeneratorTypesConfig(): void
         $schema->assertValid();
     }
 
+    public function testTypesOverrideWorksWithGeneratorTypesConfig(): void
+    {
+        $uppercaseString = self::createUppercaseString();
+        $queryType = self::createQueryType();
+
+        /** @var \Generator<int, CustomScalarType> $types */
+        $types = self::generateTypes($uppercaseString);
+
+        $schema = new Schema([
+            'query' => $queryType,
+            'types' => $types,
+        ]);
+
+        $result = GraphQL::executeQuery($schema, '{ greeting }');
+
+        self::assertSame(['data' => ['greeting' => 'HELLO WORLD']], $result->toArray());
+
+        $schema->assertValid();
+    }
+
     public function testGetTypeThenAssertValidBothWorkWithTypeLoader(): void
     {
         $uppercaseString = self::createUppercaseString();
@@ -610,6 +630,12 @@ private static function createUppercaseString(): CustomScalarType
         ]);
     }
 
+    /** @return \Generator<int|string, ScalarType> */
+    private static function generateTypes(ScalarType ...$types): \Generator
+    {
+        yield from $types;
+    }
+
     /** @throws InvariantViolation */
     private static function createQueryType(): ObjectType
     {