Make sure that types are frozen before creating the schema

src/SchemaFactory.php

@@ -538,6 +538,8 @@ classBoundCache: $classBoundCache,
 
         $aggregateQueryProvider = new AggregateQueryProvider($queryProviders);
 
+        $typeRegistry->finalizeTypes();
+
         return new Schema($aggregateQueryProvider, $recursiveTypeMapper, $typeResolver, $topRootTypeMapper, $this->schemaConfig);
     }
 

src/TypeRegistry.php

@@ -97,4 +97,15 @@ public function getMutableInterface(string $typeName): MutableInterface
 
         return $type;
     }
+
+    public function finalizeTypes(): void
+    {
+        foreach ($this->types as $type) {
+            if (! ($type instanceof MutableObjectType) && ! ($type instanceof MutableInterfaceType)) {
+                continue;
+            }
+
+            $type->freeze();
+        }
+    }
 }

tests/TypeRegistryTest.php

@@ -1,19 +1,24 @@
 <?php
 
+declare(strict_types=1);
+
 namespace TheCodingMachine\GraphQLite;
 
 use GraphQL\Type\Definition\ObjectType;
+use PHPUnit\Framework\Attributes\Test;
 use PHPUnit\Framework\TestCase;
+use TheCodingMachine\GraphQLite\Types\MutableInterfaceType;
 use TheCodingMachine\GraphQLite\Types\MutableObjectType;
 
 class TypeRegistryTest extends TestCase
 {
-
     public function testRegisterTypeException(): void
     {
         $type = new ObjectType([
             'name' => 'Foo',
-            'fields' => function() {return [];}
+            'fields' => static function () {
+                return [];
+            },
         ]);
 
         $registry = new TypeRegistry();
@@ -27,7 +32,9 @@ public function testGetType(): void
     {
         $type = new ObjectType([
             'name' => 'Foo',
-            'fields' => function() {return [];}
+            'fields' => static function () {
+                return [];
+            },
         ]);
 
         $registry = new TypeRegistry();
@@ -43,26 +50,31 @@ public function testHasType(): void
     {
         $type = new ObjectType([
             'name' => 'Foo',
-            'fields' => function() {return [];}
+            'fields' => static function () {
+                return [];
+            },
         ]);
 
         $registry = new TypeRegistry();
         $registry->registerType($type);
 
         $this->assertTrue($registry->hasType('Foo'));
         $this->assertFalse($registry->hasType('Bar'));
-
     }
 
     public function testGetMutableObjectType(): void
     {
         $type = new MutableObjectType([
             'name' => 'Foo',
-            'fields' => function() {return [];}
+            'fields' => static function () {
+                return [];
+            },
         ]);
         $type2 = new ObjectType([
             'name' => 'FooBar',
-            'fields' => function() {return [];}
+            'fields' => static function () {
+                return [];
+            },
         ]);
 
         $registry = new TypeRegistry();
@@ -79,11 +91,15 @@ public function testGetMutableInterface(): void
     {
         $type = new MutableObjectType([
             'name' => 'Foo',
-            'fields' => function() {return [];}
+            'fields' => static function () {
+                return [];
+            },
         ]);
         $type2 = new ObjectType([
             'name' => 'FooBar',
-            'fields' => function() {return [];}
+            'fields' => static function () {
+                return [];
+            },
         ]);
 
         $registry = new TypeRegistry();
@@ -95,4 +111,47 @@ public function testGetMutableInterface(): void
         $this->expectException(GraphQLRuntimeException::class);
         $this->assertSame($type, $registry->getMutableInterface('FooBar'));
     }
+
+    public function testFinalizeTypesFreezesMutableTypesOnly(): void
+    {
+        $mutableObjectType = $this->getMockBuilder(MutableObjectType::class)
+            ->setConstructorArgs([
+                [
+                    'name' => 'Foo',
+                    'fields' => static function () {
+                        return [];
+                    },
+                ],
+            ])
+            ->onlyMethods(['freeze'])
+            ->getMock();
+
+        $mutableObjectType->expects($this->once())
+            ->method('freeze');
+
+        $mutableInterfaceType = $this->getMockBuilder(MutableInterfaceType::class)
+            ->setConstructorArgs([
+                [
+                    'name' => 'Bar',
+                    'fields' => static fn () => [],
+                ],
+            ])
+            ->onlyMethods(['freeze'])
+            ->getMock();
+
+        $mutableInterfaceType->expects($this->once())
+            ->method('freeze');
+
+        $regularObjectType = new ObjectType([
+            'name' => 'Baz',
+            'fields' => static fn () => [],
+        ]);
+
+        $registry = new TypeRegistry();
+        $registry->registerType($mutableObjectType);
+        $registry->registerType($mutableInterfaceType);
+        $registry->registerType($regularObjectType);
+
+        $registry->finalizeTypes();
+    }
 }