fix: graphql query transformer drop the condition when where argument has false value on object field

Author: yomybaby

spec/ParseGraphQLServer.spec.js

@@ -9515,6 +9515,118 @@ describe('ParseGraphQLServer', () => {
           }
         });
 
+        it('should support where argument on object field that contains boolean value', async () => {
+          try {
+            const someObjectFieldValue = {
+              foo: { bar: 'baz', qux: true },
+              number: 10,
+            };
+
+            await apolloClient.mutate({
+              mutation: gql`
+                mutation CreateClass($schemaFields: SchemaFieldsInput) {
+                  createClass(input: { name: "SomeClass", schemaFields: $schemaFields }) {
+                    clientMutationId
+                  }
+                }
+              `,
+              variables: {
+                schemaFields: {
+                  addObjects: [{ name: 'someObjectField' }],
+                },
+              },
+              context: {
+                headers: {
+                  'X-Parse-Master-Key': 'test',
+                },
+              },
+            });
+            await parseGraphQLServer.parseGraphQLSchema.schemaCache.clear();
+
+            const schema = await new Parse.Schema('SomeClass').get();
+            expect(schema.fields.someObjectField.type).toEqual('Object');
+
+            const createResult = await apolloClient.mutate({
+              mutation: gql`
+                mutation CreateSomeObject($fields: CreateSomeClassFieldsInput) {
+                  createSomeClass(input: { fields: $fields }) {
+                    someClass {
+                      id
+                    }
+                  }
+                }
+              `,
+              variables: {
+                fields: {
+                  someObjectField: someObjectFieldValue,
+                },
+              },
+            });
+
+            const whereWithQuxFalse = {
+              someObjectField: {
+                notEqualTo: { key: 'foo.bar', value: 'bat' },
+                greaterThan: { key: 'number', value: 9 },
+                lessThan: { key: 'number', value: 11 },
+                equalTo: { key: 'foo.qux', value: false },
+              },
+            };
+            const whereWithQuxTrue = {
+              someObjectField: {
+                ...whereWithQuxFalse.someObjectField,
+                equalTo: { key: 'foo.qux', value: true },
+              },
+            };
+            const queryResult = await apolloClient.query({
+              query: gql`
+                query GetSomeObject(
+                  $id: ID!
+                  $whereWithQuxFalse: SomeClassWhereInput
+                  $whereWithQuxTrue: SomeClassWhereInput
+                ) {
+                  someClass(id: $id) {
+                    id
+                    someObjectField
+                  }
+                  someClasses(where: $whereWithQuxFalse) {
+                    edges {
+                      node {
+                        id
+                        someObjectField
+                      }
+                    }
+                  }
+                  someClassesWithQuxTrue: someClasses(where: $whereWithQuxTrue) {
+                    edges {
+                      node {
+                        id
+                        someObjectField
+                      }
+                    }
+                  }
+                }
+              `,
+              variables: {
+                id: createResult.data.createSomeClass.someClass.id,
+                whereWithQuxFalse,
+                whereWithQuxTrue,
+              },
+            });
+
+            const { someClass: getResult, someClasses, someClassesWithQuxTrue } = queryResult.data;
+
+            const { someObjectField } = getResult;
+            expect(typeof someObjectField).toEqual('object');
+            expect(someObjectField).toEqual(someObjectFieldValue);
+
+            // Checks class query results
+            expect(someClasses.edges.length).toEqual(0);
+            expect(someClassesWithQuxTrue.edges.length).toEqual(1);
+          } catch (e) {
+            handleError(e);
+          }
+        });
+
         it('should support object composed queries', async () => {
           try {
             const someObjectFieldValue1 = {

src/GraphQL/transformers/query.js

@@ -108,7 +108,7 @@ const transformQueryConstraintInputToParse = (
      *      }
      *   }
      */
-    if (fieldValue.key && fieldValue.value && parentConstraints && parentFieldName) {
+    if (fieldValue.key && fieldValue.value !== undefined && parentConstraints && parentFieldName) {
       delete parentConstraints[parentFieldName];
       parentConstraints[`${parentFieldName}.${fieldValue.key}`] = {
         ...parentConstraints[`${parentFieldName}.${fieldValue.key}`],