title: Null response in query for Relay Modern interogation on GraphQL
body: <p>Maybe someone who has managed to pass this step is willing to provide some indications.</p>
  
  <p>I have a schema, a resolver, i request the query and i have a null response.
  Please can you help on topic?</p>
  
  <pre><code>module.exports = {
    Query: {
      allLinks: async (root, {filter}, {mongo: {Links, Users}}) =&gt; {
        let query = filter ? {$or: buildFilters(filter)} : {};
        return await Links.find(query).toArray();
      }
  </code></pre>
  
  <p>and the query request looks like this:</p>
  
  <pre><code>    query LinkListPageQuery {
    allLinks {
      ...LinkList_allLinks
    }
  }
  
  fragment LinkList_allLinks on LinkConnection {
    edges {
      cursor
      ...Link_link
    }
  }
  
  fragment Link_link on LinkEdge {
    node {
      id
      description 
      url
    }
  }
  </code></pre>
  
  <p>My schema looks like this:</p>
  
  <pre><code>const typeDefs = `
      type Link implements Node {
        id: ID!
        url: String!
        description: String!
        postedBy: User
        votes: [Vote!]!
      }
      interface Node {
        id: ID!
      }
      type Query {
        allLinks(filter: LinkFilter, first: Int): [LinkConnection]
        node(
          id: ID!
          ): Node
      }
      type LinkEdge {
        node: Link!
        cursor: String
      }
      type LinkConnection {
        pageInfo: PageInfo
        edges: LinkEdge
        count: Int
      }
      input LinkFilter {
        OR: [LinkFilter!]
        description_contains: String
        url_contains: String
      }
      }
    `;
  </code></pre>
  
  <p>PS: This language schema is done according to <code>graphql-tools</code> package.</p>
  
  <p><strong>Resolver:</strong></p>
  
  <pre><code> Query: {
          users: async (root, { first, after }, { mongo: { Users }, user }) =&gt; {
            const queryData = await Users.find(query).toArray();
            first = first || queryData.length;
            after = after ? parseInt(fromCursor(after), 10) : 0;
            const edges = queryData.map((node, i) =&gt; ({
              cursor: toCursor(i+1),
              node: node._id,
            })).slice(after, first + after);
            const slicedUser = edges.map(({ node }) =&gt; node);
            return {
              edges,
              pageInfo: {
                startCursor: edges.length &gt; 0 ? edges[0].cursor : null,
                hasNextPage: first + after &lt; queryData.length,
                endCursor: edges.length &gt; 0 ? edges[edges.length - 1].cursor : null
              },
              count: queryData.length,
            };
          },
  UserConnection: {
      edges: ({ edges }) =&gt; edges,
      pageInfo: ({ pageInfo }) =&gt; pageInfo,
      count: ({ count }) =&gt; count,
    },
  
    UserEdge: {
      node: async ({ node },data, {dataloaders: {userLoader}}) =&gt; {
        const user = await userLoader.load(node);
        return user;
      },
      cursor: ({ cursor }) =&gt; cursor,
    },
  </code></pre>