graphql-php: Using with dataloader-php throws "Could not resolve promise" Exception

I’ll submit it, thank you @vladar 😉

Works for me, pragmatically %) Can anyone prepare PR for this? I’ll merge it.

I forked your repo and replaced DataLoaders with regular GraphQL\Deferred calls. It works as expected.

I guess the bug is somewhere on DataLoader side.

@mcg-web Here is my reproduction repository: https://github.com/n1ru4l/laravel-graphql-dataloader-php-exception-reproduction

The relevant files are the Service Provider (app/Providers/AppServiceProvider.php), the types and queries app/GraphQL/* and the DataLoaders app/DataLoader/*.php

You will not need any database setup just use php artisan serve.

You can navigate to graphiql on /graphiql.

This query fails:

query type1 {
  type1 {
    __typename
    id
    items {
      __typename
      id
      items {
        __typename
        id
        items {
          __typename
          id
        }
      }
    }
  }

This query works:

query type1 {
  type1 {
    __typename
    id
    items {
      __typename
      id
    }
  }
}

Thanks! Merged and released 0.9.14

here a solution that works:

• we add two hooks to GraphQL lib

// src/Executor/Promise/Adapter/SyncPromiseAdapter.php

    /**
     * Synchronously wait when promise completes
     *
     * @param Promise $promise
     * @return mixed
     */
    public function wait(Promise $promise)
    {
        $this->beforeWait($promise);

        $dfdQueue = Deferred::getQueue();
        $promiseQueue = SyncPromise::getQueue();

        while (
            $promise->adoptedPromise->state === SyncPromise::PENDING &&
            !($dfdQueue->isEmpty() && $promiseQueue->isEmpty())
        ) {
            Deferred::runQueue();
            SyncPromise::runQueue();
            $this->onWait($promise);
        }

        /** @var SyncPromise $syncPromise */
        $syncPromise = $promise->adoptedPromise;

        if ($syncPromise->state === SyncPromise::FULFILLED) {
            return $syncPromise->result;
        } else if ($syncPromise->state === SyncPromise::REJECTED) {
            throw $syncPromise->result;
        }

        throw new InvariantViolation("Could not resolve promise");
    }

    /**
     * Execute just before starting to run promise completion
     *
     * @param Promise $promise
     */
    protected function beforeWait(Promise $promise)
    {
    }

    /**
     * While running promise completion
     *
     * @param Promise $promise
     */
    protected function onWait(Promise $promise)
    {
    }

• we modify DataLoader custom implementation to do the work

    protected function beforeWait(Promise $promise)
    {
        DataLoader::await();
    }

    protected function onWait(Promise $promise)
    {
        DataLoader::await();
    }

@vladar tell me what do you think of this solution please?

@mcg-web If I add DataLoader::await() to queue progression, it works, e.g.:

    /**
     * Synchronously wait when promise completes
     *
     * @param Promise $promise
     * @return mixed
     */
    public function wait(Promise $promise)
    {
        $dfdQueue = Deferred::getQueue();
        $promiseQueue = SyncPromise::getQueue();

        while (
            $promise->adoptedPromise->state === SyncPromise::PENDING &&
            !($dfdQueue->isEmpty() && $promiseQueue->isEmpty())
        ) {
            Deferred::runQueue();
            SyncPromise::runQueue();
            DataLoader::await();
        }

        /** @var SyncPromise $syncPromise */
        $syncPromise = $promise->adoptedPromise;

        if ($syncPromise->state === SyncPromise::FULFILLED) {
            return $syncPromise->result;
        } else if ($syncPromise->state === SyncPromise::REJECTED) {
            throw $syncPromise->result;
        }

        throw new InvariantViolation("Could not resolve promise");
    }

So the whole queue must be progressed together. I guess you guys will have to write your own wait implementation to make it behave as expected.

Obviously, I am not 100% sure that this is enough to fix it (as I am not aware of DataLoader::await implementation details).

But let me know if I can make it easier for you somehow (e.g. by changing an interface of SyncPromiseAdapter or maybe changing how Executor calls wait).