GraphQL: /me pointers not working (#5745)

When using the `/me` endpoint to fetch the current user, it does not fetches data from any Pointer data type field, even though the field was defined in the GraphQL schema.

Author: douglasmuraoka

spec/ParseGraphQLServer.spec.js

@@ -3104,6 +3104,56 @@ describe('ParseGraphQLServer', () => {
           expect(resultUserName).toEqual(userName);
           expect(resultEmail).toEqual(email);
         });
+
+        it('should return logged user including pointer', async () => {
+          const foo = new Parse.Object('Foo');
+          foo.set('bar', 'hello');
+
+          const userName = 'user1',
+            password = 'user1',
+            email = '[email protected]';
+
+          const user = new Parse.User();
+          user.setUsername(userName);
+          user.setPassword(password);
+          user.setEmail(email);
+          user.set('userFoo', foo);
+          await user.signUp();
+
+          await parseGraphQLServer.parseGraphQLSchema.databaseController.schemaCache.clear();
+
+          const session = await Parse.Session.current();
+          const result = await apolloClient.query({
+            query: gql`
+              query GetCurrentUser {
+                users {
+                  me {
+                    objectId
+                    sessionToken
+                    userFoo {
+                      bar
+                    }
+                  }
+                }
+              }
+            `,
+            context: {
+              headers: {
+                'X-Parse-Session-Token': session.getSessionToken(),
+              },
+            },
+          });
+
+          const {
+            objectId,
+            sessionToken,
+            userFoo: resultFoo,
+          } = result.data.users.me;
+          expect(objectId).toEqual(user.id);
+          expect(sessionToken).toBeDefined();
+          expect(resultFoo).toBeDefined();
+          expect(resultFoo.bar).toEqual('hello');
+        });
       });
 
       describe('Users Mutations', () => {

src/GraphQL/loaders/usersQueries.js

@@ -1,18 +1,57 @@
 import { GraphQLNonNull, GraphQLObjectType } from 'graphql';
-import UsersRouter from '../../Routers/UsersRouter';
-
-const usersRouter = new UsersRouter();
+import getFieldNames from 'graphql-list-fields';
+import Parse from 'parse/node';
+import rest from '../../rest';
+import Auth from '../../Auth';
+import { extractKeysAndInclude } from './parseClassTypes';
 
 const load = parseGraphQLSchema => {
   const fields = {};
 
   fields.me = {
     description: 'The Me query can be used to return the current user data.',
     type: new GraphQLNonNull(parseGraphQLSchema.meType),
-    async resolve(_source, _args, context) {
+    async resolve(_source, _args, context, queryInfo) {
       try {
-        const { config, auth, info } = context;
-        return (await usersRouter.handleMe({ config, auth, info })).response;
+        const { config, info } = context;
+
+        if (!info || !info.sessionToken) {
+          throw new Parse.Error(
+            Parse.Error.INVALID_SESSION_TOKEN,
+            'Invalid session token'
+          );
+        }
+        const sessionToken = info.sessionToken;
+        const selectedFields = getFieldNames(queryInfo);
+
+        const { include } = extractKeysAndInclude(selectedFields);
+        const response = await rest.find(
+          config,
+          Auth.master(config),
+          '_Session',
+          { sessionToken },
+          {
+            include: include
+              .split(',')
+              .map(included => `user.${included}`)
+              .join(','),
+          },
+          info.clientVersion
+        );
+        if (
+          !response.results ||
+          response.results.length == 0 ||
+          !response.results[0].user
+        ) {
+          throw new Parse.Error(
+            Parse.Error.INVALID_SESSION_TOKEN,
+            'Invalid session token'
+          );
+        } else {
+          const user = response.results[0].user;
+          user.sessionToken = sessionToken;
+          return user;
+        }
       } catch (e) {
         parseGraphQLSchema.handleError(e);
       }