Avoid eager-loading schema unnecessarily

CHANGELOG.md

@@ -2,7 +2,7 @@
 
 All notable changes to this project will be documented in this file.
 
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 You can find and compare releases at the [GitHub release page](https://github.com/webonyx/graphql-php/releases).
@@ -42,6 +42,7 @@ You can find and compare releases at the [GitHub release page](https://github.co
 - Reorganize abstract class `ASTValidationContext` to interface `ValidationContext`
 - Reorganize AST interfaces related to schema and type extensions
 - Align `Utils::suggestionList()` with the reference implementation (#1075)
+- Order schema topologically and according to the user-defined order, affects introspection and printing
 
 ### Added
 
@@ -116,6 +117,8 @@ You can find and compare releases at the [GitHub release page](https://github.co
 - Remove `GraphQL\Exception\InvalidArgument`
 - Remove `Utils::find()`, `Utils::every()` and `Utils::invariant()`
 - Remove argument `bool $exitWhenDone` from `StandardServer::send500Error()` and `StandardServer::handleRequest()`
+- Remove `Schema::getAstNode()` in favor of `Schema::$astNode`
+- Remove ability to override standard types through `Schema` option `types`, use `Type::overrideStandardTypes()`
 
 ## 14.11.6
 

src/Type/Definition/Directive.php

@@ -125,9 +125,7 @@ public static function getInternalDirectives(): array
                 'args' => [
                     self::REASON_ARGUMENT_NAME => [
                         'type' => Type::string(),
-                        'description' => 'Explains why this element was deprecated, usually also including a '
-                            . 'suggestion for how to access supported similar data. Formatted using '
-                            . 'the Markdown syntax (as specified by [CommonMark](https://commonmark.org/).',
+                        'description' => 'Explains why this element was deprecated, usually also including a suggestion for how to access supported similar data. Formatted using the Markdown syntax, as specified by [CommonMark](https://commonmark.org/).',
                         'defaultValue' => self::DEFAULT_DEPRECATION_REASON,
                     ],
                 ],

src/Type/Introspection.php

@@ -586,10 +586,6 @@ public static function _directive(): ObjectType
                     'type' => Type::string(),
                     'resolve' => static fn (Directive $directive): ?string => $directive->description,
                 ],
-                'args' => [
-                    'type' => Type::nonNull(Type::listOf(Type::nonNull(self::_inputValue()))),
-                    'resolve' => static fn (Directive $directive): array => $directive->args,
-                ],
                 'isRepeatable' => [
                     'type' => Type::nonNull(Type::boolean()),
                     'resolve' => static fn (Directive $directive): bool => $directive->isRepeatable,
@@ -600,6 +596,10 @@ public static function _directive(): ObjectType
                     ))),
                     'resolve' => static fn (Directive $directive): array => $directive->locations,
                 ],
+                'args' => [
+                    'type' => Type::nonNull(Type::listOf(Type::nonNull(self::_inputValue()))),
+                    'resolve' => static fn (Directive $directive): array => $directive->args,
+                ],
             ],
         ]);
     }

src/Type/Schema.php

@@ -2,7 +2,6 @@
 
 namespace GraphQL\Type;
 
-use Generator;
 use GraphQL\Error\Error;
 use GraphQL\Error\InvariantViolation;
 use GraphQL\GraphQL;
@@ -22,7 +21,6 @@
 use function implode;
 use function is_array;
 use function is_callable;
-use function is_iterable;
 
 /**
  * Schema Definition (see [schema definition docs](schema-definition.md)).
@@ -70,6 +68,8 @@ class Schema
     /** @var array<int, Error> */
     private array $validationErrors;
 
+    public ?SchemaDefinitionNode $astNode;
+
     /** @var array<int, SchemaExtensionNode> */
     public array $extensionASTNodes = [];
 
@@ -90,77 +90,10 @@ public function __construct($config)
             $this->validationErrors = [];
         }
 
-        $this->config = $config;
+        $this->astNode = $config->astNode;
         $this->extensionASTNodes = $config->extensionASTNodes;
 
-        // TODO can we make the following assumption hold true?
-        // No need to check for the existence of the root query type
-        // since we already validated the schema thus it must exist.
-        $query = $config->query;
-        if ($query !== null) {
-            $this->resolvedTypes[$query->name] = $query;
-        }
-
-        $mutation = $config->mutation;
-        if ($mutation !== null) {
-            $this->resolvedTypes[$mutation->name] = $mutation;
-        }
-
-        $subscription = $config->subscription;
-        if ($subscription !== null) {
-            $this->resolvedTypes[$subscription->name] = $subscription;
-        }
-
-        $types = $this->config->types;
-        if (is_array($types)) {
-            foreach ($this->resolveAdditionalTypes() as $type) {
-                $typeName = $type->name;
-                if (isset($this->resolvedTypes[$typeName])) {
-                    if ($type !== $this->resolvedTypes[$typeName]) {
-                        throw new InvariantViolation("Schema must contain unique named types but contains multiple types named \"{$type}\" (see https://webonyx.github.io/graphql-php/type-definitions/#type-registry).");
-                    }
-                }
-
-                $this->resolvedTypes[$typeName] = $type;
-            }
-            // @phpstan-ignore-next-line not strictly enforced until we can use actual union types
-        } elseif (! is_callable($types)) {
-            $invalidTypes = Utils::printSafe($types);
-
-            throw new InvariantViolation("\"types\" must be array or callable if provided but got: {$invalidTypes}");
-        }
-
-        $this->resolvedTypes += Introspection::getTypes();
-
-        if (isset($this->config->typeLoader)) {
-            return;
-        }
-
-        // Perform full scan of the schema
-        $this->getTypeMap();
-    }
-
-    /**
-     * @return Generator<Type&NamedType>
-     */
-    private function resolveAdditionalTypes(): Generator
-    {
-        $types = $this->config->types;
-
-        if (is_callable($types)) {
-            $types = $types();
-        }
-
-        // @phpstan-ignore-next-line not strictly enforced unless PHP supports function types
-        if (! is_iterable($types)) {
-            $notIterable = Utils::printSafe($types);
-
-            throw new InvariantViolation("Schema types callable must return iterable but got: {$notIterable}");
-        }
-
-        foreach ($types as $type) {
-            yield self::resolveType($type);
-        }
+        $this->config = $config;
     }
 
     /**
@@ -175,39 +108,57 @@ private function resolveAdditionalTypes(): Generator
     public function getTypeMap(): array
     {
         if (! $this->fullyLoaded) {
-            $this->resolvedTypes = $this->collectAllTypes();
-            $this->fullyLoaded = true;
-        }
+            $types = $this->config->types;
+            if (is_callable($types)) {
+                $types = $types();
+            }
 
-        return $this->resolvedTypes;
-    }
+            // Reset order of user provided types, since calls to getType() may have loaded them
+            $this->resolvedTypes = [];
 
-    /**
-     * @return array<string, Type&NamedType>
-     */
-    private function collectAllTypes(): array
-    {
-        /** @var array<string, Type&NamedType> $typeMap */
-        $typeMap = [];
-        foreach ($this->resolvedTypes as $type) {
-            TypeInfo::extractTypes($type, $typeMap);
-        }
+            foreach ($types as $typeOrLazyType) {
+                $type = self::resolveType($typeOrLazyType);
 
-        foreach ($this->getDirectives() as $directive) {
-            // @phpstan-ignore-next-line generics are not strictly enforceable, error will be caught during schema validation
-            if ($directive instanceof Directive) {
-                TypeInfo::extractTypesFromDirectives($directive, $typeMap);
+                $typeName = $type->name;
+                if (isset($this->resolvedTypes[$typeName])) {
+                    if ($type !== $this->resolvedTypes[$typeName]) {
+                        throw new InvariantViolation("Schema must contain unique named types but contains multiple types named \"$type\" (see https://webonyx.github.io/graphql-php/type-definitions/#type-registry).");
+                    }
+                }
+
+                $this->resolvedTypes[$typeName] = $type;
+            }
+
+            // To preserve order of user-provided types, we add first to add them to
+            // the set of "collected" types, so `collectReferencedTypes` ignore them.
+            /** @var array<string, Type&NamedType> $allReferencedTypes */
+            $allReferencedTypes = [];
+            foreach ($this->resolvedTypes as $type) {
+                // When we ready to process this type, we remove it from "collected" types
+                // and then add it together with all dependent types in the correct position.
+                unset($allReferencedTypes[$type->name]);
+                TypeInfo::extractTypes($type, $allReferencedTypes);
             }
-        }
 
-        // When types are set as array they are resolved in constructor
-        if (is_callable($this->config->types)) {
-            foreach ($this->resolveAdditionalTypes() as $type) {
-                TypeInfo::extractTypes($type, $typeMap);
+            foreach ([$this->config->query, $this->config->mutation, $this->config->subscription] as $rootType) {
+                if ($rootType instanceof ObjectType) {
+                    TypeInfo::extractTypes($rootType, $allReferencedTypes);
+                }
             }
+
+            foreach ($this->getDirectives() as $directive) {
+                // @phpstan-ignore-next-line generics are not strictly enforceable, error will be caught during schema validation
+                if ($directive instanceof Directive) {
+                    TypeInfo::extractTypesFromDirectives($directive, $allReferencedTypes);
+                }
+            }
+            TypeInfo::extractTypes(Introspection::_schema(), $allReferencedTypes);
+
+            $this->resolvedTypes = $allReferencedTypes;
+            $this->fullyLoaded = true;
         }
 
-        return $typeMap;
+        return $this->resolvedTypes;
     }
 
     /**
@@ -303,9 +254,17 @@ public function getConfig(): SchemaConfig
     public function getType(string $name): ?Type
     {
         if (! isset($this->resolvedTypes[$name])) {
-            $type = Type::getStandardTypes()[$name]
-                ?? $this->loadType($name);
+            $introspectionTypes = Introspection::getTypes();
+            if (isset($introspectionTypes[$name])) {
+                return $introspectionTypes[$name];
+            }
+
+            $standardTypes = Type::getStandardTypes();
+            if (isset($standardTypes[$name])) {
+                return $standardTypes[$name];
+            }
 
+            $type = $this->loadType($name);
             if ($type === null) {
                 return null;
             }
@@ -328,7 +287,7 @@ private function loadType(string $typeName): ?Type
     {
         $typeLoader = $this->config->typeLoader;
         if ($typeLoader === null) {
-            return $this->defaultTypeLoader($typeName);
+            return $this->getTypeMap()[$typeName] ?? null;
         }
 
         $type = $typeLoader($typeName);
@@ -348,15 +307,6 @@ private function loadType(string $typeName): ?Type
         return $type;
     }
 
-    /**
-     * @return (Type&NamedType)|null
-     */
-    private function defaultTypeLoader(string $typeName): ?Type
-    {
-        // Default type loader simply falls back to collecting all types
-        return $this->getTypeMap()[$typeName] ?? null;
-    }
-
     /**
      * @template T of Type
      *
@@ -494,11 +444,6 @@ public function getDirective(string $name): ?Directive
         return null;
     }
 
-    public function getAstNode(): ?SchemaDefinitionNode
-    {
-        return $this->config->astNode;
-    }
-
     /**
      * Throws if the schema is not valid.
      *

src/Type/SchemaValidationContext.php

@@ -78,10 +78,7 @@ public function getErrors(): array
     public function validateRootTypes(): void
     {
         if ($this->schema->getQueryType() === null) {
-            $this->reportError(
-                'Query root type must be provided.',
-                $this->schema->getAstNode()
-            );
+            $this->reportError('Query root type must be provided.', $this->schema->astNode);
         }
 
         // Triggers a type error if wrong
@@ -475,7 +472,7 @@ private function validateFields(Type $type): void
     private function getAllNodes(object $obj): array
     {
         if ($obj instanceof Schema) {
-            $astNode = $obj->getAstNode();
+            $astNode = $obj->astNode;
             $extensionNodes = $obj->extensionASTNodes;
         } elseif ($obj instanceof Directive) {
             $astNode = $obj->astNode;