refactor(GraphQL): Pointer constraint input type as ID

spec/ParseGraphQLServer.spec.js

@@ -3416,11 +3416,7 @@ describe('ParseGraphQLServer', () => {
                   _or: [
                     {
                       pointerToUser: {
-                        _eq: {
-                          __type: 'Pointer',
-                          className: '_User',
-                          objectId: user5.id,
-                        },
+                        _eq: user5.id,
                       },
                     },
                     {
@@ -3445,6 +3441,40 @@ describe('ParseGraphQLServer', () => {
             ).toEqual(['someValue1', 'someValue3']);
           });
 
+          it('should support _in pointer operator using class specific query', async () => {
+            await prepareData();
+
+            await parseGraphQLServer.parseGraphQLSchema.databaseController.schemaCache.clear();
+
+            const result = await apolloClient.query({
+              query: gql`
+                query FindSomeObjects($where: GraphQLClassWhereInput) {
+                  graphQLClasses(where: $where) {
+                    results {
+                      someField
+                    }
+                  }
+                }
+              `,
+              variables: {
+                where: {
+                  pointerToUser: {
+                    _in: [user5.id],
+                  },
+                },
+              },
+              context: {
+                headers: {
+                  'X-Parse-Master-Key': 'test',
+                },
+              },
+            });
+
+            const { results } = result.data.graphQLClasses;
+            expect(results.length).toBe(1);
+            expect(results[0].someField).toEqual('someValue3');
+          });
+
           it('should support _or operation', async () => {
             await prepareData();
 
@@ -3543,11 +3573,7 @@ describe('ParseGraphQLServer', () => {
               _or: [
                 {
                   pointerToUser: {
-                    _eq: {
-                      __type: 'Pointer',
-                      className: '_User',
-                      objectId: user5.id,
-                    },
+                    _eq: user5.id,
                   },
                 },
                 {
@@ -3599,11 +3625,7 @@ describe('ParseGraphQLServer', () => {
               _or: [
                 {
                   pointerToUser: {
-                    _eq: {
-                      __type: 'Pointer',
-                      className: '_User',
-                      objectId: user5.id,
-                    },
+                    _eq: user5.id,
                   },
                 },
                 {

src/GraphQL/helpers/objectsQueries.js

@@ -62,12 +62,13 @@ const findObjects = async (
   config,
   auth,
   info,
-  selectedFields
+  selectedFields,
+  fields
 ) => {
   if (!where) {
     where = {};
   }
-  transformQueryInputToParse(where);
+  transformQueryInputToParse(where, fields);
 
   const options = {};
 

src/GraphQL/loaders/parseClassQueries.js

@@ -120,7 +120,8 @@ const load = function(
             config,
             auth,
             info,
-            selectedFields.map(field => field.split('.', 1)[0])
+            selectedFields.map(field => field.split('.', 1)[0]),
+            parseClass.fields
           );
         } catch (e) {
           parseGraphQLSchema.handleError(e);

src/GraphQL/loaders/parseClassTypes.js

@@ -1,12 +1,10 @@
 import {
-  Kind,
   GraphQLID,
   GraphQLObjectType,
   GraphQLString,
   GraphQLList,
   GraphQLInputObjectType,
   GraphQLNonNull,
-  GraphQLScalarType,
   GraphQLEnumType,
 } from 'graphql';
 import getFieldNames from 'graphql-list-fields';
@@ -138,86 +136,6 @@ const load = (
     update: isUpdateEnabled = true,
   } = getParseClassMutationConfig(parseClassConfig);
 
-  const classGraphQLScalarTypeName = `${graphQLClassName}Pointer`;
-  const parseScalarValue = value => {
-    if (typeof value === 'string') {
-      return {
-        __type: 'Pointer',
-        className: className,
-        objectId: value,
-      };
-    } else if (
-      typeof value === 'object' &&
-      value.__type === 'Pointer' &&
-      value.className === className &&
-      typeof value.objectId === 'string'
-    ) {
-      return { ...value, className };
-    }
-
-    throw new defaultGraphQLTypes.TypeValidationError(
-      value,
-      classGraphQLScalarTypeName
-    );
-  };
-  let classGraphQLScalarType = new GraphQLScalarType({
-    name: classGraphQLScalarTypeName,
-    description: `The ${classGraphQLScalarTypeName} is used in operations that involve ${graphQLClassName} pointers.`,
-    parseValue: parseScalarValue,
-    serialize(value) {
-      if (typeof value === 'string') {
-        return value;
-      } else if (
-        typeof value === 'object' &&
-        value.__type === 'Pointer' &&
-        value.className === className &&
-        typeof value.objectId === 'string'
-      ) {
-        return value.objectId;
-      }
-
-      throw new defaultGraphQLTypes.TypeValidationError(
-        value,
-        classGraphQLScalarTypeName
-      );
-    },
-    parseLiteral(ast) {
-      if (ast.kind === Kind.STRING) {
-        return parseScalarValue(ast.value);
-      } else if (ast.kind === Kind.OBJECT) {
-        const __type = ast.fields.find(field => field.name.value === '__type');
-        const className = ast.fields.find(
-          field => field.name.value === 'className'
-        );
-        const objectId = ast.fields.find(
-          field => field.name.value === 'objectId'
-        );
-        if (
-          __type &&
-          __type.value &&
-          className &&
-          className.value &&
-          objectId &&
-          objectId.value
-        ) {
-          return parseScalarValue({
-            __type: __type.value.value,
-            className: className.value.value,
-            objectId: objectId.value.value,
-          });
-        }
-      }
-
-      throw new defaultGraphQLTypes.TypeValidationError(
-        ast.kind,
-        classGraphQLScalarTypeName
-      );
-    },
-  });
-  classGraphQLScalarType =
-    parseGraphQLSchema.addGraphQLType(classGraphQLScalarType) ||
-    defaultGraphQLTypes.OBJECT;
-
   const classGraphQLCreateTypeName = `Create${graphQLClassName}FieldsInput`;
   let classGraphQLCreateType = new GraphQLInputObjectType({
     name: classGraphQLCreateTypeName,
@@ -341,10 +259,10 @@ const load = (
     name: classGraphQLConstraintTypeName,
     description: `The ${classGraphQLConstraintTypeName} input type is used in operations that involve filtering objects by a pointer field to ${graphQLClassName} class.`,
     fields: {
-      _eq: defaultGraphQLTypes._eq(classGraphQLScalarType),
-      _ne: defaultGraphQLTypes._ne(classGraphQLScalarType),
-      _in: defaultGraphQLTypes._in(classGraphQLScalarType),
-      _nin: defaultGraphQLTypes._nin(classGraphQLScalarType),
+      _eq: defaultGraphQLTypes._eq(GraphQLID),
+      _ne: defaultGraphQLTypes._ne(GraphQLID),
+      _in: defaultGraphQLTypes._in(defaultGraphQLTypes.OBJECT_ID),
+      _nin: defaultGraphQLTypes._nin(defaultGraphQLTypes.OBJECT_ID),
       _exists: defaultGraphQLTypes._exists,
       _select: defaultGraphQLTypes._select,
       _dontSelect: defaultGraphQLTypes._dontSelect,
@@ -513,7 +431,8 @@ const load = (
                   config,
                   auth,
                   info,
-                  selectedFields.map(field => field.split('.', 1)[0])
+                  selectedFields.map(field => field.split('.', 1)[0]),
+                  parseClass.fields
                 );
               } catch (e) {
                 parseGraphQLSchema.handleError(e);
@@ -609,7 +528,6 @@ const load = (
   parseGraphQLSchema.parseClassTypes[className] = {
     classGraphQLPointerType,
     classGraphQLRelationType,
-    classGraphQLScalarType,
     classGraphQLCreateType,
     classGraphQLUpdateType,
     classGraphQLConstraintType,

src/GraphQL/transformers/query.js

@@ -43,6 +43,7 @@ const parseMap = {
 
 const transformQueryInputToParse = (
   constraints,
+  fields,
   parentFieldName,
   parentConstraints
 ) => {
@@ -93,6 +94,21 @@ const transformQueryInputToParse = (
       delete constraints[fieldName];
       fieldName = parseMap[fieldName];
       constraints[fieldName] = fieldValue;
+
+      // If parent field type is Pointer, changes constraint value to format expected
+      // by Parse.
+      if (
+        fields[parentFieldName] &&
+        fields[parentFieldName].type === 'Pointer' &&
+        typeof fieldValue === 'string'
+      ) {
+        const { targetClass } = fields[parentFieldName];
+        constraints[fieldName] = {
+          __type: 'Pointer',
+          className: targetClass,
+          objectId: fieldValue,
+        };
+      }
     }
     switch (fieldName) {
       case '$point':
@@ -147,7 +163,7 @@ const transformQueryInputToParse = (
         break;
     }
     if (typeof fieldValue === 'object') {
-      transformQueryInputToParse(fieldValue, fieldName, constraints);
+      transformQueryInputToParse(fieldValue, fields, fieldName, constraints);
     }
   });
 };