GraphQL Object constraints (#5715)

* GraphQL Object constraints

Implements the GraphQL Object constraints, which allows us to filter queries results using the `$eq`, `$lt`, `$gt`, `$in`, and other Parse supported constraints.
Example:
```
query objects {
  findMyClass(where: {
    objField: {
      _eq: {
        key: 'foo.bar',
        value: 'hello'
      },
      _gt: {
        key: 'foo.number',
        value: 10
      },
      _lt: {
        key: 'anotherNumber',
        value: 5
      }
    }
  }) {
    results {
      objectId
    }
  }
}
```
In the example above, we have the `findMyClass` query (automatically generated for the `MyClass` class), and a field named `objField` whose type is Object. The object below represents a valid `objField` value and would satisfy all constraints:
```
{
  "foo": {
    "bar": "hello",
    "number": 11
  },
  "anotherNumber": 4
}
```
The Object constraint is applied only when using Parse class object type queries. When using "generic" queries such as `get` and `find`, this type of constraint is not available.

* Objects constraints not working on Postgres

Fixes the $eq, $ne, $gt, and $lt constraints when applied on an Object type field.

* Fix object constraint field name

* Fix Postgres constraints indexes

* fix: Object type composed constraints not working

* fix: Rename key and value fields

* refactor: Object constraints for generic queries

* fix: Object constraints not working on Postgres

src/GraphQL/loaders/objectsQueries.js

@@ -96,13 +96,51 @@ const parseMap = {
   _point: '$point',
 };
 
-const transformToParse = constraints => {
+const transformToParse = (constraints, parentFieldName, parentConstraints) => {
   if (!constraints || typeof constraints !== 'object') {
     return;
   }
   Object.keys(constraints).forEach(fieldName => {
     let fieldValue = constraints[fieldName];
-    if (parseMap[fieldName]) {
+
+    /**
+     * If we have a key-value pair, we need to change the way the constraint is structured.
+     *
+     * Example:
+     *   From:
+     *   {
+     *     "someField": {
+     *       "_lt": {
+     *         "_key":"foo.bar",
+     *         "_value": 100
+     *       },
+     *       "_gt": {
+     *         "_key":"foo.bar",
+     *         "_value": 10
+     *       }
+     *     }
+     *   }
+     *
+     *   To:
+     *   {
+     *     "someField.foo.bar": {
+     *       "$lt": 100,
+     *       "$gt": 10
+     *      }
+     *   }
+     */
+    if (
+      fieldValue._key &&
+      fieldValue._value &&
+      parentConstraints &&
+      parentFieldName
+    ) {
+      delete parentConstraints[parentFieldName];
+      parentConstraints[`${parentFieldName}.${fieldValue._key}`] = {
+        ...parentConstraints[`${parentFieldName}.${fieldValue._key}`],
+        [parseMap[fieldName]]: fieldValue._value,
+      };
+    } else if (parseMap[fieldName]) {
       delete constraints[fieldName];
       fieldName = parseMap[fieldName];
       constraints[fieldName] = fieldValue;
@@ -160,7 +198,7 @@ const transformToParse = constraints => {
         break;
     }
     if (typeof fieldValue === 'object') {
-      transformToParse(fieldValue);
+      transformToParse(fieldValue, fieldName, constraints);
     }
   });
 };