Merge remote-tracking branch 'upstream/master'

Author: mtrezza

CHANGELOG.md

@@ -108,6 +108,7 @@ ___
 - ci: add node engine version check (Manuel Trezza) [#7574](https://github.com/parse-community/parse-server/pull/7574)
 
 ### Notable Changes
+- Alphabetical ordered GraphQL API, improved GraphQL Schema cache system and fix GraphQL input reassign issue (Moumouls) [#7344](https://github.com/parse-community/parse-server/issues/7344)
 - Added Parse Server Security Check to report weak security settings (Manuel Trezza, dblythy) [#7247](https://github.com/parse-community/parse-server/issues/7247)
 - EXPERIMENTAL: Added new page router with placeholder rendering and localization of custom and feature pages such as password reset and email verification (Manuel Trezza) [#7128](https://github.com/parse-community/parse-server/pull/7128)
 - EXPERIMENTAL: Added custom routes to easily customize flows for password reset, email verification or build entirely new flows (Manuel Trezza) [#7231](https://github.com/parse-community/parse-server/pull/7231)

CONTRIBUTING.md

@@ -19,8 +19,9 @@
     - [Wording Guideline](#wording-guideline)
   - [Parse Error](#parse-error)
   - [Parse Server Configuration](#parse-server-configuration)
-- [Commit Message](#commit-message)
+- [Pull Request](#pull-request)
   - [Breaking Change](#breaking-change)
+- [Merging](#merging)
 - [Code of Conduct](#code-of-conduct)
 
 ## Contributing
@@ -290,7 +291,7 @@ Introducing new [Parse Server configuration][config] parameters requires the fol
 5. Add test cases to ensure the correct parameter value validation. Parse Server throws an error at launch if an invalid value is set for any configuration parameter.
 6. Execute `npm run docs` to generate the documentation in the `/out` directory. Take a look at the documentation whether the description and formatting of the newly introduced parameters is satisfactory.
 
-## Commit Message
+## Pull Request
 
 For release automation, the title of pull requests needs to be written in a defined syntax. We loosely follow the [Conventional Commits](https://www.conventionalcommits.org) specification, which defines this syntax:
 
@@ -325,19 +326,23 @@ Currently, we are not making use of the commit _scope_, which would be written a
 
 ### Breaking Change
 
-If a pull request contains a braking change, the description of the pull request must contain a special chapter at the bottom.
+If a pull request contains a braking change, the description of the pull request must contain a dedicated chapter at the bottom to indicate this. This is to assist the committer of the pull request to avoid merging a breaking change as non-breaking.
 
-The chapter consists of the phrase `BREAKING CHANGE`, capitalized, in a single line without any formatting. It must be followed by an empty line, then a short description of the breaking change, and ideally how the developer should address it. This chapter should contain more details focusing on the "breaking” aspect of the change, as it is intended to assist the developer in adapting their deployment. However, keep it concise, as it will also become part of the changelog entry.
+## Merging
 
-For example:
-
-```
-Detailed pull request description...
+The following guide is for anyone who merges a contributor pull request into the working branch, the working branch into a release branch, a release branch into another release branch, or any other direct commits such as hotfixes into release branches or the working branch.
 
-BREAKING CHANGE
+- For changelog generation, only the commit message set when merging the pull request is relevant. The title and description of the GitHub pull request as authored by the contributor have no influence on the changelog generation. However, the title of the GitHub pull request should be used as the commit message.
+- If the pull request contains a breaking change, the commit message must contain the phrase `BREAKING CHANGE`, capitalized and without any formatting, followed by a short description of the breaking change and ideally how the developer should address it, all in a single line. This line should contain more details focusing on the "breaking” aspect of the change and is intended to assist the developer in adapting. Keep it concise, as it will become part of the changelog entry, for example:
 
-The door handle has be pulled up to open the door, not down. Adjust your habits accordingly by walking on your hands.
-```
+  ```
+  fix: remove handle from door
+  
+  BREAKING CHANGE: You cannot open the door anymore by using a handle. See the [#migration guide](http://example.com) for more details.
+  ```
+  Keep in mind that in a repository with release automation, merging such a commit message will trigger a release with a major version increment.
+- A contributor pull request must be merged into the working branch using `Squash and Merge`, to create a single commit message that describes the change.
+- A release branch or the default branch must be merged into another release branch using `Merge Commit`, to preserve each individual commit message that describes its respective change.
 
 ## Code of Conduct
 

spec/ParseGraphQLSchema.spec.js

@@ -57,7 +57,7 @@ describe('ParseGraphQLSchema', () => {
     it('should load a brand new GraphQL Schema if Parse Schema changes', async () => {
       await parseGraphQLSchema.load();
       const parseClasses = parseGraphQLSchema.parseClasses;
-      const parseClassesString = parseGraphQLSchema.parseClassesString;
+      const parseCachedClasses = parseGraphQLSchema.parseCachedClasses;
       const parseClassTypes = parseGraphQLSchema.parseClassTypes;
       const graphQLSchema = parseGraphQLSchema.graphQLSchema;
       const graphQLTypes = parseGraphQLSchema.graphQLTypes;
@@ -70,7 +70,7 @@ describe('ParseGraphQLSchema', () => {
       await new Promise(resolve => setTimeout(resolve, 200));
       await parseGraphQLSchema.load();
       expect(parseClasses).not.toBe(parseGraphQLSchema.parseClasses);
-      expect(parseClassesString).not.toBe(parseGraphQLSchema.parseClassesString);
+      expect(parseCachedClasses).not.toBe(parseGraphQLSchema.parseCachedClasses);
       expect(parseClassTypes).not.toBe(parseGraphQLSchema.parseClassTypes);
       expect(graphQLSchema).not.toBe(parseGraphQLSchema.graphQLSchema);
       expect(graphQLTypes).not.toBe(parseGraphQLSchema.graphQLTypes);
@@ -94,7 +94,7 @@ describe('ParseGraphQLSchema', () => {
       });
       await parseGraphQLSchema.load();
       const parseClasses = parseGraphQLSchema.parseClasses;
-      const parseClassesString = parseGraphQLSchema.parseClassesString;
+      const parseCachedClasses = parseGraphQLSchema.parseCachedClasses;
       const parseClassTypes = parseGraphQLSchema.parseClassTypes;
       const graphQLSchema = parseGraphQLSchema.graphQLSchema;
       const graphQLTypes = parseGraphQLSchema.graphQLTypes;
@@ -109,7 +109,7 @@ describe('ParseGraphQLSchema', () => {
       await new Promise(resolve => setTimeout(resolve, 200));
       await parseGraphQLSchema.load();
       expect(parseClasses).not.toBe(parseGraphQLSchema.parseClasses);
-      expect(parseClassesString).not.toBe(parseGraphQLSchema.parseClassesString);
+      expect(parseCachedClasses).not.toBe(parseGraphQLSchema.parseCachedClasses);
       expect(parseClassTypes).not.toBe(parseGraphQLSchema.parseClassTypes);
       expect(graphQLSchema).not.toBe(parseGraphQLSchema.graphQLSchema);
       expect(graphQLTypes).not.toBe(parseGraphQLSchema.graphQLTypes);

spec/ParseGraphQLServer.spec.js

@@ -25,6 +25,7 @@ const {
   GraphQLEnumType,
   GraphQLInputObjectType,
   GraphQLSchema,
+  GraphQLList,
 } = require('graphql');
 const { ParseServer } = require('../');
 const { ParseGraphQLServer } = require('../lib/GraphQL/ParseGraphQLServer');
@@ -10341,6 +10342,18 @@ describe('ParseGraphQLServer', () => {
             robot: { value: 'robot' },
           },
         });
+        const TypeEnumWhereInput = new GraphQLInputObjectType({
+          name: 'TypeEnumWhereInput',
+          fields: {
+            equalTo: { type: TypeEnum },
+          },
+        });
+        const SomeClass2WhereInput = new GraphQLInputObjectType({
+          name: 'SomeClass2WhereInput',
+          fields: {
+            type: { type: TypeEnumWhereInput },
+          },
+        });
         const SomeClassType = new GraphQLObjectType({
             name: 'SomeClass',
             fields: {
@@ -10386,6 +10399,18 @@ describe('ParseGraphQLServer', () => {
                       return obj.toJSON();
                     },
                   },
+                  customQueryWithAutoTypeReturnList: {
+                    type: new GraphQLList(SomeClassType),
+                    args: {
+                      id: { type: new GraphQLNonNull(GraphQLString) },
+                    },
+                    resolve: async (p, { id }) => {
+                      const obj = new Parse.Object('SomeClass');
+                      obj.id = id;
+                      await obj.fetch();
+                      return [obj.toJSON(), obj.toJSON(), obj.toJSON()];
+                    },
+                  },
                 },
               }),
               types: [
@@ -10401,7 +10426,17 @@ describe('ParseGraphQLServer', () => {
                     type: { type: TypeEnum },
                   },
                 }),
+                // Enhanced where input with a extended enum
+                new GraphQLInputObjectType({
+                  name: 'SomeClassWhereInput',
+                  fields: {
+                    type: {
+                      type: TypeEnumWhereInput,
+                    },
+                  },
+                }),
                 SomeClassType,
+                SomeClass2WhereInput,
               ],
             }),
           });
@@ -10463,6 +10498,65 @@ describe('ParseGraphQLServer', () => {
         expect(result.data.customQueryWithAutoTypeReturn.type).toEqual('robot');
       });
 
+      it('can resolve a custom query with auto type list return', async () => {
+        const obj = new Parse.Object('SomeClass');
+        await obj.save({ name: 'aname', type: 'robot' });
+        await parseGraphQLServer.parseGraphQLSchema.schemaCache.clear();
+        const result = await apolloClient.query({
+          variables: { id: obj.id },
+          query: gql`
+            query CustomQuery($id: String!) {
+              customQueryWithAutoTypeReturnList(id: $id) {
+                id
+                objectId
+                nameUpperCase
+                name
+                type
+              }
+            }
+          `,
+        });
+        result.data.customQueryWithAutoTypeReturnList.forEach(rObj => {
+          expect(rObj.objectId).toBeDefined();
+          expect(rObj.objectId).toEqual(obj.id);
+          expect(rObj.name).toEqual('aname');
+          expect(rObj.nameUpperCase).toEqual('ANAME');
+          expect(rObj.type).toEqual('robot');
+        });
+      });
+
+      it('can resolve a stacked query with same where variables on overloaded where input', async () => {
+        const objPointer = new Parse.Object('SomeClass2');
+        await objPointer.save({ name: 'aname', type: 'robot' });
+        const obj = new Parse.Object('SomeClass');
+        await obj.save({ name: 'aname', type: 'robot', pointer: objPointer });
+        await parseGraphQLServer.parseGraphQLSchema.schemaCache.clear();
+        const result = await apolloClient.query({
+          variables: { where: { OR: [{ pointer: { have: { objectId: { exists: true } } } }] } },
+          query: gql`
+            query someQuery($where: SomeClassWhereInput!) {
+              q1: someClasses(where: $where) {
+                edges {
+                  node {
+                    id
+                  }
+                }
+              }
+              q2: someClasses(where: $where) {
+                edges {
+                  node {
+                    id
+                  }
+                }
+              }
+            }
+          `,
+        });
+        expect(result.data.q1.edges.length).toEqual(1);
+        expect(result.data.q2.edges.length).toEqual(1);
+        expect(result.data.q1.edges[0].node.id).toEqual(result.data.q2.edges[0].node.id);
+      });
+
       it('can resolve a custom extend type', async () => {
         const obj = new Parse.Object('SomeClass');
         await obj.save({ name: 'aname', type: 'robot' });