Lazy loading of types

examples/01-blog/Blog/Type/Scalar/EmailType.php

@@ -6,15 +6,14 @@
 use GraphQL\Type\Definition\CustomScalarType;
 use GraphQL\Utils\Utils;
 
-class EmailType
+class EmailType extends CustomScalarType
 {
-    public static function create()
+    public function __construct(array $config = [])
     {
-        return new CustomScalarType([
-            'name' => 'Email',
-            'serialize' => [__CLASS__, 'serialize'],
-            'parseValue' => [__CLASS__, 'parseValue'],
-            'parseLiteral' => [__CLASS__, 'parseLiteral'],
+        parent::__construct([
+            'serialize' => [__CLASS__, 's_serialize'],
+            'parseValue' => [__CLASS__, 's_parseValue'],
+            'parseLiteral' => [__CLASS__, 's_parseLiteral'],
         ]);
     }
 
@@ -24,7 +23,7 @@ public static function create()
      * @param string $value
      * @return string
      */
-    public static function serialize($value)
+    public static function s_serialize($value)
     {
         // Assuming internal representation of email is always correct:
         return $value;
@@ -40,7 +39,7 @@ public static function serialize($value)
      * @param mixed $value
      * @return mixed
      */
-    public static function parseValue($value)
+    public static function s_parseValue($value)
     {
         if (!filter_var($value, FILTER_VALIDATE_EMAIL)) {
             throw new \UnexpectedValueException("Cannot represent value as email: " . Utils::printSafe($value));
@@ -55,7 +54,7 @@ public static function parseValue($value)
      * @return string
      * @throws Error
      */
-    public static function parseLiteral($valueNode)
+    public static function s_parseLiteral($valueNode)
     {
         // Note: throwing GraphQL\Error\Error vs \UnexpectedValueException to benefit from GraphQL
         // error location in query:

examples/01-blog/Blog/Types.php

@@ -1,13 +1,13 @@
 <?php
 namespace GraphQL\Examples\Blog;
 
+use Exception;
 use GraphQL\Examples\Blog\Type\CommentType;
 use GraphQL\Examples\Blog\Type\Enum\ContentFormatEnum;
 use GraphQL\Examples\Blog\Type\Enum\ImageSizeEnumType;
 use GraphQL\Examples\Blog\Type\Field\HtmlField;
 use GraphQL\Examples\Blog\Type\SearchResultType;
 use GraphQL\Examples\Blog\Type\NodeType;
-use GraphQL\Examples\Blog\Type\QueryType;
 use GraphQL\Examples\Blog\Type\Scalar\EmailType;
 use GraphQL\Examples\Blog\Type\StoryType;
 use GraphQL\Examples\Blog\Type\Scalar\UrlType;
@@ -25,113 +25,66 @@
  */
 class Types
 {
-    // Object types:
-    private static $user;
-    private static $story;
-    private static $comment;
-    private static $image;
-    private static $query;
-
-    /**
-     * @return UserType
-     */
-    public static function user()
-    {
-        return self::$user ?: (self::$user = new UserType());
-    }
-
-    /**
-     * @return StoryType
-     */
-    public static function story()
-    {
-        return self::$story ?: (self::$story = new StoryType());
-    }
-
-    /**
-     * @return CommentType
-     */
-    public static function comment()
-    {
-        return self::$comment ?: (self::$comment = new CommentType());
-    }
-
-    /**
-     * @return ImageType
-     */
-    public static function image()
-    {
-        return self::$image ?: (self::$image = new ImageType());
-    }
-
-    /**
-     * @return QueryType
-     */
-    public static function query()
-    {
-        return self::$query ?: (self::$query = new QueryType());
-    }
+    private static $types = [];
+    const LAZY_LOAD_GRAPHQL_TYPES = true;
 
+    public static function user() : callable { return static::get(UserType::class); }
+    public static function story() : callable { return static::get(StoryType::class); }
+    public static function comment() : callable { return static::get(CommentType::class); }
+    public static function image() : callable { return static::get(ImageType::class); }
+    public static function node() : callable { return static::get(NodeType::class); }
+    public static function mention() : callable { return static::get(SearchResultType::class); }
+    public static function imageSizeEnum() : callable { return static::get(ImageSizeEnumType::class); }
+    public static function contentFormatEnum() : callable { return static::get(ContentFormatEnum::class); }
+    public static function email() : callable { return static::get(EmailType::class); }
+    public static function url() : callable { return static::get(UrlType::class); }
 
-    // Interface types
-    private static $node;
-
-    /**
-     * @return NodeType
-     */
-    public static function node()
+    public static function get($classname)
     {
-        return self::$node ?: (self::$node = new NodeType());
+        return static::LAZY_LOAD_GRAPHQL_TYPES ? function() use ($classname) {
+            return static::byClassName($classname);
+        } : static::byClassName($classname);
     }
 
+    protected static function byClassName($classname) {
+        $parts = explode("\\", $classname);
+        $cacheName = strtolower(preg_replace('~Type$~', '', $parts[count($parts) - 1]));
+        $type = null;
 
-    // Unions types:
-    private static $mention;
-
-    /**
-     * @return SearchResultType
-     */
-    public static function mention()
-    {
-        return self::$mention ?: (self::$mention = new SearchResultType());
-    }
+        if (!isset(self::$types[$cacheName])) {
+            if (class_exists($classname)) {
+                $type = new $classname();
+            }
 
+            self::$types[$cacheName] = $type;
+        }
 
-    // Enum types
-    private static $imageSizeEnum;
-    private static $contentFormatEnum;
+        $type = self::$types[$cacheName];
 
-    /**
-     * @return ImageSizeEnumType
-     */
-    public static function imageSizeEnum()
-    {
-        return self::$imageSizeEnum ?: (self::$imageSizeEnum = new ImageSizeEnumType());
+        if (!$type) {
+            throw new Exception("Unknown graphql type: " . $classname);
+        }
+        return $type;
     }
 
-    /**
-     * @return ContentFormatEnum
-     */
-    public static function contentFormatEnum()
+    public static function byTypeName($shortName, $removeType=true)
     {
-        return self::$contentFormatEnum ?: (self::$contentFormatEnum = new ContentFormatEnum());
-    }
+        $cacheName = strtolower($shortName);
+        $type = null;
 
-    // Custom Scalar types:
-    private static $urlType;
-    private static $emailType;
+        if (isset(self::$types[$cacheName])) {
+            return self::$types[$cacheName];
+        }
 
-    public static function email()
-    {
-        return self::$emailType ?: (self::$emailType = EmailType::create());
-    }
+        $method = lcfirst($shortName);
+        if(method_exists(get_called_class(), $method)) {
+            $type = self::{$method}();
+        }
 
-    /**
-     * @return UrlType
-     */
-    public static function url()
-    {
-        return self::$urlType ?: (self::$urlType = new UrlType());
+        if(!$type) {
+            throw new Exception("Unknown graphql type: " . $shortName);
+        }
+        return $type;
     }
 
     /**

examples/01-blog/graphql.php

@@ -3,6 +3,7 @@
 // php -S localhost:8080 ./graphql.php
 require_once __DIR__ . '/../../vendor/autoload.php';
 
+use GraphQL\Examples\Blog\Type\QueryType;
 use \GraphQL\Examples\Blog\Types;
 use \GraphQL\Examples\Blog\AppContext;
 use \GraphQL\Examples\Blog\Data\DataSource;
@@ -48,7 +49,10 @@
 
     // GraphQL schema to be passed to query executor:
     $schema = new Schema([
-        'query' => Types::query()
+        'query' => new QueryType(),
+        'typeLoader' => function($name) {
+            return Types::byTypeName($name, true);
+        }
     ]);
 
     $result = GraphQL::executeQuery(

src/Executor/ReferenceExecutor.php

@@ -45,6 +45,7 @@
 use function array_values;
 use function get_class;
 use function is_array;
+use function is_callable;
 use function is_string;
 use function sprintf;
 
@@ -528,7 +529,6 @@ private function resolveField(ObjectType $parentType, $rootValue, $fieldNodes, $
         // The resolve function's optional 3rd argument is a context value that
         // is provided to every resolve function within an execution. It is commonly
         // used to represent an authenticated user, or request-specific caches.
-        $context = $exeContext->contextValue;
         // The resolve function's optional 4th argument is a collection of
         // information about the current execution state.
         $info = new ResolveInfo(
@@ -938,10 +938,15 @@ private function completeLeafValue(LeafType $returnType, &$result)
      */
     private function completeAbstractValue(AbstractType $returnType, $fieldNodes, ResolveInfo $info, $path, &$result)
     {
-        $exeContext  = $this->exeContext;
-        $runtimeType = $returnType->resolveType($result, $exeContext->contextValue, $info);
-        if ($runtimeType === null) {
+        $exeContext    = $this->exeContext;
+        $typeCandidate = $returnType->resolveType($result, $exeContext->contextValue, $info);
+
+        if ($typeCandidate === null) {
             $runtimeType = self::defaultTypeResolver($result, $exeContext->contextValue, $info, $returnType);
+        } elseif (is_callable($typeCandidate)) {
+            $runtimeType = Schema::resolveType($typeCandidate);
+        } else {
+            $runtimeType = $typeCandidate;
         }
         $promise = $this->getPromise($runtimeType);
         if ($promise !== null) {

src/Type/Definition/FieldArgument.php

@@ -6,6 +6,7 @@
 
 use GraphQL\Error\InvariantViolation;
 use GraphQL\Language\AST\InputValueDefinitionNode;
+use GraphQL\Type\Schema;
 use GraphQL\Utils\Utils;
 use function array_key_exists;
 use function is_array;
@@ -77,12 +78,9 @@ public static function createMap(array $config) : array
         return $map;
     }
 
-    /**
-     * @return InputType&Type
-     */
     public function getType() : Type
     {
-        return $this->type;
+        return Schema::resolveType($this->type);
     }
 
     public function defaultValueExists() : bool

src/Type/Definition/FieldDefinition.php

@@ -7,6 +7,7 @@
 use GraphQL\Error\Error;
 use GraphQL\Error\InvariantViolation;
 use GraphQL\Language\AST\FieldDefinitionNode;
+use GraphQL\Type\Schema;
 use GraphQL\Utils\Utils;
 use function is_array;
 use function is_callable;
@@ -58,7 +59,7 @@ class FieldDefinition
      */
     public $config;
 
-    /** @var OutputType&Type */
+    /** @var callable|(OutputType&Type) */
     public $type;
 
     /** @var callable|string */
@@ -174,12 +175,9 @@ public function getArg($name)
         return null;
     }
 
-    /**
-     * @return OutputType&Type
-     */
     public function getType() : Type
     {
-        return $this->type;
+        return Schema::resolveType($this->type);
     }
 
     /**
@@ -217,7 +215,7 @@ public function assertValid(Type $parentType)
             )
         );
 
-        $type = $this->type;
+        $type = $this->getType();
         if ($type instanceof WrappingType) {
             $type = $type->getWrappedType(true);
         }

src/Type/Definition/InputObjectField.php

@@ -7,6 +7,7 @@
 use GraphQL\Error\Error;
 use GraphQL\Error\InvariantViolation;
 use GraphQL\Language\AST\InputValueDefinitionNode;
+use GraphQL\Type\Schema;
 use GraphQL\Utils\Utils;
 use function array_key_exists;
 use function sprintf;
@@ -55,7 +56,12 @@ public function __construct(array $opts)
      */
     public function getType() : Type
     {
-        return $this->type;
+        /**
+         * TODO: Replace this cast with native assert
+         *
+         * @var Type&InputType
+         */
+        return Schema::resolveType($this->type);
     }
 
     public function defaultValueExists() : bool