Add a generic promise support

Author: mcg-web

README.md

@@ -308,6 +308,8 @@ isTypeOf | `callback($value, $context, GraphQL\Type\Definition\ResolveInfo $info
 
 2. Object types are responsible for data fetching. Each of their fields may have optional `resolve` callback option. This callback takes `$value` that corresponds to instance of this type and returns `data` accepted by type of given field.
 If `resolve` option is not set, GraphQL will try to get `data` from `$value[$fieldName]`.
+`resolve` result can also be a promise implementing the interface `GraphQL\Promise\PromiseInterface`. If the result is a promise the executor will wait for 
+promise to complete before continuing.
 
 3. `resolve` callback is a place where you can use your existing data fetching logic. `$context` is defined by your application on the top level of query execution (useful for storing current user, environment details, etc)
 

src/Executor/Executor.php

@@ -10,6 +10,7 @@
 use GraphQL\Language\AST\NodeKind;
 use GraphQL\Language\AST\OperationDefinitionNode;
 use GraphQL\Language\AST\SelectionSetNode;
+use GraphQL\Promise\PromiseInterface;
 use GraphQL\Schema;
 use GraphQL\Type\Definition\AbstractType;
 use GraphQL\Type\Definition\Directive;
@@ -169,10 +170,13 @@ private static function executeOperation(ExecutionContext $exeContext, Operation
 
         $path = [];
         if ($operation->operation === 'mutation') {
-            return self::executeFieldsSerially($exeContext, $type, $rootValue, $path, $fields);
+            $results = self::executeFieldsSerially($exeContext, $type, $rootValue, $path, $fields);
+        } else {
+            $results = self::executeFields($exeContext, $type, $rootValue, $path, $fields);
         }
+        $finalResults = self::completePromiseIfNeeded($results);
 
-        return self::executeFields($exeContext, $type, $rootValue, $path, $fields);
+        return $finalResults;
     }
 
 
@@ -221,15 +225,34 @@ private static function getOperationRootType(Schema $schema, OperationDefinition
      */
     private static function executeFieldsSerially(ExecutionContext $exeContext, ObjectType $parentType, $sourceValue, $path, $fields)
     {
+        if (self::isThenable($sourceValue)) {
+            return $sourceValue->then(function($resolvedSourceValue) use ($exeContext, $parentType, $path, $fields) {
+                return self::executeFieldsSerially($exeContext, $parentType, $resolvedSourceValue, $path, $fields);
+            });
+        }
+
         $results = [];
-        foreach ($fields as $responseName => $fieldNodes) {
+
+        $process = function ($responseName, $fieldNodes, $results) use ($path, $exeContext, $parentType, $sourceValue) {
             $fieldPath = $path;
             $fieldPath[] = $responseName;
             $result = self::resolveField($exeContext, $parentType, $sourceValue, $fieldNodes, $fieldPath);
 
-            if ($result !== self::$UNDEFINED) {
-                // Undefined means that field is not defined in schema
-                $results[$responseName] = $result;
+            // Undefined means that field is not defined in schema
+            if ($result === self::$UNDEFINED) {
+                return $results;
+            }
+            $results[$responseName] = $result;
+            return $results;
+        };
+
+        foreach ($fields as $responseName => $fieldNodes) {
+            if (self::isThenable($results)) {
+                $results = $results->then(function ($resolvedResults) use ($responseName, $fieldNodes, $process) {
+                    return $process($responseName, $fieldNodes, $resolvedResults);
+                });
+            } else {
+                $results = $process($responseName, $fieldNodes, $results);
             }
         }
         // see #59
@@ -245,12 +268,9 @@ private static function executeFieldsSerially(ExecutionContext $exeContext, Obje
      */
     private static function executeFields(ExecutionContext $exeContext, ObjectType $parentType, $source, $path, $fields)
     {
-        // Native PHP doesn't support promises.
-        // Custom executor should be built for platforms like ReactPHP
         return self::executeFieldsSerially($exeContext, $parentType, $source, $path, $fields);
     }
 
-
     /**
      * Given a selectionSet, adds all of the fields in that selection to
      * the passed in map of fields, and returns it at the end.
@@ -529,14 +549,26 @@ private static function completeValueCatchingError(
         // Otherwise, error protection is applied, logging the error and resolving
         // a null value for this field if one is encountered.
         try {
-            return self::completeValueWithLocatedError(
+            $completed = self::completeValueWithLocatedError(
                 $exeContext,
                 $returnType,
                 $fieldNodes,
                 $info,
                 $path,
                 $result
             );
+            if (self::isThenable($completed)) {
+                // If `completeValueWithLocatedError` returned a rejected promise, log
+                // the rejection error and resolve to null.
+                // Note: we don't rely on a `catch` method, but we do expect "thenable"
+                // to take a second callback for the error case.
+                return $completed->then(null, function ($err) use ($exeContext) {
+                    $exeContext->addError($err);
+                    return null;
+                });
+            }
+
+            return $completed;
         } catch (Error $err) {
             // If `completeValueWithLocatedError` returned abruptly (threw an error), log the error
             // and return null.
@@ -545,7 +577,6 @@ private static function completeValueCatchingError(
         }
     }
 
-
     /**
      * This is a small wrapper around completeValue which annotates errors with
      * location information.
@@ -559,7 +590,7 @@ private static function completeValueCatchingError(
      * @return array|null
      * @throws Error
      */
-    static function completeValueWithLocatedError(
+    public static function completeValueWithLocatedError(
         ExecutionContext $exeContext,
         Type $returnType,
         $fieldNodes,
@@ -569,14 +600,20 @@ static function completeValueWithLocatedError(
     )
     {
         try {
-            return self::completeValue(
+            $completed = self::completeValue(
                 $exeContext,
                 $returnType,
                 $fieldNodes,
                 $info,
                 $path,
                 $result
             );
+            if (self::isThenable($completed)) {
+                return $completed->then(null, function ($error) use ($fieldNodes, $path) {
+                    throw Error::createLocatedError($error, $fieldNodes, $path);
+                });
+            }
+            return $completed;
         } catch (\Exception $error) {
             throw Error::createLocatedError($error, $fieldNodes, $path);
         }
@@ -622,6 +659,20 @@ private static function completeValue(
         &$result
     )
     {
+        // If result is a Promise, apply-lift over completeValue.
+        if (self::isThenable($result)) {
+            return $result->then(function ($resolved) use ($exeContext, $returnType, $fieldNodes, $info, $path) {
+                return self::completeValue(
+                    $exeContext,
+                    $returnType,
+                    $fieldNodes,
+                    $info,
+                    $path,
+                    $resolved
+                );
+            });
+        }
+
         if ($result instanceof \Exception) {
             throw $result;
         }
@@ -893,6 +944,27 @@ private static function inferTypeOf($value, $context, ResolveInfo $info, Abstrac
         return null;
     }
 
+    private static function isThenable($value)
+    {
+        return ($value instanceof PromiseInterface);
+    }
+
+    private static function completePromiseIfNeeded($value)
+    {
+        if (self::isThenable($value)) {
+            $results = self::completePromiseIfNeeded($value->wait());
+            return $results;
+        } elseif (is_array($value) || $value instanceof \Traversable) {
+            $results = [];
+            foreach ($value as $key => $item) {
+                $results[$key] = self::completePromiseIfNeeded($item);
+            }
+            return $results;
+        }
+
+        return $value;
+    }
+
     /**
      * @deprecated as of 19.11.2016
      */

src/Promise/PromiseInterface.php

@@ -0,0 +1,29 @@
+<?php
+namespace GraphQL\Promise;
+
+interface PromiseInterface
+{
+    /**
+     * Waits until the promise completes if possible.
+     *
+     * @return mixed
+     * @throws \LogicException if the promise has no wait function.
+     */
+    public function wait();
+
+    /**
+     * Appends fulfillment and rejection handlers to the promise, and returns
+     * a new promise resolving to the return value of the called handler.
+     *
+     * @param callable $onFulfilled Invoked when the promise fulfills
+     * @param callable $onRejected  Invoked when the promise is rejected
+     *
+     * @return PromiseInterface
+     *
+     * @throws \LogicException if the promise has no then function.
+     */
+    public function then(
+        callable $onFulfilled = null,
+        callable $onRejected = null
+    );
+}

src/Promise/PromiseWrapper.php

@@ -0,0 +1,88 @@
+<?php
+
+namespace GraphQL\Promise;
+
+class PromiseWrapper implements PromiseInterface
+{
+    private $wrappedPromise;
+
+    /**
+     * PromiseWrapper constructor.
+     * @param $promise
+     */
+    public function __construct($promise = null)
+    {
+        if (null !== $promise) {
+            $this->setWrappedPromise($promise);
+        }
+    }
+    /**
+     * @param $promise
+     * @return self
+     */
+    public static function wrap($promise)
+    {
+        return new static($promise);
+    }
+    /**
+     * Waits until the promise completes if possible.
+     *
+     * @return mixed
+     * @throws \LogicException if the promise has no wait function.
+     */
+    public function wait()
+    {
+        if (!$this->objectHasMethod($this->wrappedPromise, 'wait')) {
+            throw new \LogicException('Promise does not implement "wait" method');
+        }
+
+        return $this->wrappedPromise->wait();
+    }
+    /**
+     * Appends fulfillment and rejection handlers to the promise, and returns
+     * a new promise resolving to the return value of the called handler.
+     *
+     * @param callable $onFulfilled Invoked when the promise fulfills
+     * @param callable $onRejected Invoked when the promise is rejected
+     *
+     * @return self
+     *
+     * @throws \LogicException if the promise has no then function.
+     */
+    public function then(
+        callable $onFulfilled = null,
+        callable $onRejected = null
+    )
+    {
+        if (!$this->getWrappedPromise()) {
+            throw new \LogicException('No wrapped promise found!');
+        }
+
+        if (null === $onFulfilled && null === $onRejected) {
+            return $this;
+        }
+
+        return $this->wrap($this->getWrappedPromise()->then($onFulfilled, $onRejected));
+    }
+
+    public function getWrappedPromise()
+    {
+        return $this->wrappedPromise;
+    }
+
+    public function setWrappedPromise($wrappedPromise)
+    {
+        if (!$this->objectHasMethod($wrappedPromise, 'then')) {
+            throw new \LogicException('Promise does not implement "then" method');
+        }
+
+        $this->wrappedPromise = $wrappedPromise;
+
+        return $this;
+    }
+
+    protected function objectHasMethod($object, $method)
+    {
+        return is_object($object) && is_callable([$object, $method]);
+    }
+}

tests/Promise/CliPromise.php

@@ -0,0 +1,76 @@
+<?php
+namespace GraphQL\Tests\Promise;
+
+class CliPromise
+{
+    private $pid;
+    private $outputFile;
+    private $onFulfilledCallbacks = [];
+    private $onRejectedCallbacks = [];
+
+    public function __construct($cmd)
+    {
+        $outputFile = sys_get_temp_dir() . '/PromiseTest.' . time() . '.output';
+
+        exec(sprintf('(%s) > %s 2>&1 & echo $!', $cmd, $outputFile), $pidArr);
+
+        $this->pid = $pidArr[0];
+        $this->outputFile = $outputFile;
+    }
+
+    public function wait()
+    {
+        try {
+            while (!$this->isTerminated()) { usleep(1000); }
+
+            $log = new \stdClass();
+            $log->pid = $this->pid;
+            $log->output = shell_exec(sprintf('cat %s', $this->outputFile));
+
+            foreach ($this->onFulfilledCallbacks as $onFulfilled) {
+                $log = call_user_func($onFulfilled, $log);
+            }
+            return $log;
+        } catch (\Exception $e) {
+            foreach ($this->onRejectedCallbacks as $onRejected) {
+                call_user_func($onRejected, $e);
+            }
+        }
+    }
+
+    private function isTerminated()
+    {
+        try {
+            $result = shell_exec(sprintf('ps %d', $this->pid));
+            return count(preg_split("/\n/", $result)) <= 2;
+        } catch (\Exception $e) {
+        }
+
+        return false;
+    }
+
+    /**
+     * Appends fulfillment and rejection handlers to the promise, and returns
+     * a new promise resolving to the return value of the called handler.
+     *
+     * @param callable $onFulfilled Invoked when the promise fulfills
+     * @param callable $onRejected Invoked when the promise is rejected
+     *
+     * @return $this
+     */
+    public function then(
+        callable $onFulfilled = null,
+        callable $onRejected = null
+    )
+    {
+        if (null !== $onFulfilled) {
+            $this->onFulfilledCallbacks[] = $onFulfilled;
+        }
+
+        if (null !== $onFulfilled) {
+            $this->onRejectedCallbacks[] = $onRejected;
+        }
+
+        return $this;
+    }
+}