feat: Add GraphQL query cloudConfig to retrieve and mutation updateCloudConfig to update Cloud Config

spec/ParseGraphQLServer.spec.js

@@ -7080,6 +7080,284 @@ describe('ParseGraphQLServer', () => {
         });
       });
 
+      describe("Config Queries", () => {
+        beforeEach(async () => {
+          // Setup initial config data
+          await Parse.Config.save(
+            { publicParam: 'publicValue', privateParam: 'privateValue' },
+            { privateParam: true },
+            { useMasterKey: true }
+          );
+        });
+
+        it("should return the config value for a specific parameter", async () => {
+          const query = gql`
+            query configValue($paramName: String!) {
+              configValue(paramName: $paramName) {
+                value
+                isMasterKeyOnly
+              }
+            }
+          `;
+
+          const result = await apolloClient.query({
+            query,
+            variables: { paramName: 'publicParam' },
+            context: {
+              headers: {
+                'X-Parse-Master-Key': 'test',
+              },
+            },
+          });
+
+          expect(result.errors).toBeUndefined();
+          expect(result.data.configValue.value).toEqual('publicValue');
+          expect(result.data.configValue.isMasterKeyOnly).toEqual(false);
+        });
+
+        it("should return null for non-existent parameter", async () => {
+          const query = gql`
+            query configValue($paramName: String!) {
+              configValue(paramName: $paramName) {
+                value
+                isMasterKeyOnly
+              }
+            }
+          `;
+
+          const result = await apolloClient.query({
+            query,
+            variables: { paramName: 'nonExistentParam' },
+            context: {
+              headers: {
+                'X-Parse-Master-Key': 'test',
+              },
+            },
+          });
+
+          expect(result.errors).toBeUndefined();
+          expect(result.data.configValue.value).toBeNull();
+          expect(result.data.configValue.isMasterKeyOnly).toBeNull();
+        });
+      });
+
+      describe("Config Mutations", () => {
+        it("should update a config value using mutation and retrieve it with query", async () => {
+          const mutation = gql`
+            mutation updateConfigValue($input: UpdateConfigValueInput!) {
+              updateConfigValue(input: $input) {
+                clientMutationId
+                configValue {
+                  value
+                  isMasterKeyOnly
+                }
+              }
+            }
+          `;
+
+          const query = gql`
+            query configValue($paramName: String!) {
+              configValue(paramName: $paramName) {
+                value
+                isMasterKeyOnly
+              }
+            }
+          `;
+
+          const mutationResult = await apolloClient.mutate({
+            mutation,
+            variables: {
+              input: {
+                clientMutationId: 'test-mutation-id',
+                paramName: 'testParam',
+                value: 'testValue',
+                isMasterKeyOnly: false,
+              },
+            },
+            context: {
+              headers: {
+                'X-Parse-Master-Key': 'test',
+              },
+            },
+          });
+
+          expect(mutationResult.errors).toBeUndefined();
+          expect(mutationResult.data.updateConfigValue.configValue.value).toEqual('testValue');
+          expect(mutationResult.data.updateConfigValue.configValue.isMasterKeyOnly).toEqual(false);
+
+          const queryResult = await apolloClient.query({
+            query,
+            variables: { paramName: 'testParam' },
+            context: {
+              headers: {
+                'X-Parse-Master-Key': 'test',
+              },
+            },
+          });
+
+          expect(queryResult.errors).toBeUndefined();
+          expect(queryResult.data.configValue.value).toEqual('testValue');
+          expect(queryResult.data.configValue.isMasterKeyOnly).toEqual(false);
+        });
+
+        it("should update a config value with isMasterKeyOnly set to true", async () => {
+          const mutation = gql`
+            mutation updateConfigValue($input: UpdateConfigValueInput!) {
+              updateConfigValue(input: $input) {
+                clientMutationId
+                configValue {
+                  value
+                  isMasterKeyOnly
+                }
+              }
+            }
+          `;
+
+          const query = gql`
+            query configValue($paramName: String!) {
+              configValue(paramName: $paramName) {
+                value
+                isMasterKeyOnly
+              }
+            }
+          `;
+
+          const mutationResult = await apolloClient.mutate({
+            mutation,
+            variables: {
+              input: {
+                clientMutationId: 'test-mutation-id-2',
+                paramName: 'privateTestParam',
+                value: 'privateValue',
+                isMasterKeyOnly: true,
+              },
+            },
+            context: {
+              headers: {
+                'X-Parse-Master-Key': 'test',
+              },
+            },
+          });
+
+          expect(mutationResult.errors).toBeUndefined();
+          expect(mutationResult.data.updateConfigValue.configValue.value).toEqual('privateValue');
+          expect(mutationResult.data.updateConfigValue.configValue.isMasterKeyOnly).toEqual(true);
+
+          const queryResult = await apolloClient.query({
+            query,
+            variables: { paramName: 'privateTestParam' },
+            context: {
+              headers: {
+                'X-Parse-Master-Key': 'test',
+              },
+            },
+          });
+
+          expect(queryResult.errors).toBeUndefined();
+          expect(queryResult.data.configValue.value).toEqual('privateValue');
+          expect(queryResult.data.configValue.isMasterKeyOnly).toEqual(true);
+        });
+
+        it("should update an existing config value", async () => {
+          await Parse.Config.save(
+            { existingParam: 'initialValue' },
+            {},
+            { useMasterKey: true }
+          );
+
+          const mutation = gql`
+            mutation updateConfigValue($input: UpdateConfigValueInput!) {
+              updateConfigValue(input: $input) {
+                clientMutationId
+                configValue {
+                  value
+                  isMasterKeyOnly
+                }
+              }
+            }
+          `;
+
+          const query = gql`
+            query configValue($paramName: String!) {
+              configValue(paramName: $paramName) {
+                value
+                isMasterKeyOnly
+              }
+            }
+          `;
+
+          const mutationResult = await apolloClient.mutate({
+            mutation,
+            variables: {
+              input: {
+                clientMutationId: 'test-mutation-id-3',
+                paramName: 'existingParam',
+                value: 'updatedValue',
+                isMasterKeyOnly: false,
+              },
+            },
+            context: {
+              headers: {
+                'X-Parse-Master-Key': 'test',
+              },
+            },
+          });
+
+          expect(mutationResult.errors).toBeUndefined();
+          expect(mutationResult.data.updateConfigValue.configValue.value).toEqual('updatedValue');
+
+          const queryResult = await apolloClient.query({
+            query,
+            variables: { paramName: 'existingParam' },
+            context: {
+              headers: {
+                'X-Parse-Master-Key': 'test',
+              },
+            },
+          });
+
+          expect(queryResult.errors).toBeUndefined();
+          expect(queryResult.data.configValue.value).toEqual('updatedValue');
+        });
+
+        it("should require master key to update config", async () => {
+          const mutation = gql`
+            mutation updateConfigValue($input: UpdateConfigValueInput!) {
+              updateConfigValue(input: $input) {
+                clientMutationId
+                configValue {
+                  value
+                  isMasterKeyOnly
+                }
+              }
+            }
+          `;
+
+          try {
+            await apolloClient.mutate({
+              mutation,
+              variables: {
+                input: {
+                  clientMutationId: 'test-mutation-id-4',
+                  paramName: 'testParam',
+                  value: 'testValue',
+                  isMasterKeyOnly: false,
+                },
+              },
+              context: {
+                headers: {
+                  'X-Parse-Application-Id': 'test',
+                },
+              },
+            });
+            fail('Should have thrown an error');
+          } catch (error) {
+            expect(error.graphQLErrors).toBeDefined();
+            expect(error.graphQLErrors[0].message).toContain('Permission denied');
+          }
+        });
+      })
+
       describe('Users Queries', () => {
         it('should return current logged user', async () => {
           const userName = 'user1',

src/GraphQL/ParseGraphQLSchema.js

@@ -49,7 +49,7 @@ const RESERVED_GRAPHQL_TYPE_NAMES = [
   'DeleteClassPayload',
   'PageInfo',
 ];
-const RESERVED_GRAPHQL_QUERY_NAMES = ['health', 'viewer', 'class', 'classes'];
+const RESERVED_GRAPHQL_QUERY_NAMES = ['health', 'viewer', 'class', 'classes', 'configValue'];
 const RESERVED_GRAPHQL_MUTATION_NAMES = [
   'signUp',
   'logIn',
@@ -59,6 +59,7 @@ const RESERVED_GRAPHQL_MUTATION_NAMES = [
   'createClass',
   'updateClass',
   'deleteClass',
+  'updateConfigValue',
 ];
 
 class ParseGraphQLSchema {
@@ -118,6 +119,7 @@ class ParseGraphQLSchema {
     this.functionNamesString = functionNamesString;
     this.parseClassTypes = {};
     this.viewerType = null;
+    this.configValueType = null;
     this.graphQLAutoSchema = null;
     this.graphQLSchema = null;
     this.graphQLTypes = [];

src/GraphQL/loaders/configMutations.js

@@ -0,0 +1,76 @@
+import { GraphQLNonNull, GraphQLString, GraphQLBoolean } from 'graphql';
+import { mutationWithClientMutationId } from 'graphql-relay';
+import Parse from 'parse/node';
+import { createSanitizedError } from '../../Error';
+import GlobalConfigRouter from '../../Routers/GlobalConfigRouter';
+
+const globalConfigRouter = new GlobalConfigRouter();
+
+const updateConfigValue = async (context, paramName, value, isMasterKeyOnly = false) => {
+  const { config, auth } = context;
+
+  if (!auth.isMaster) {
+    throw createSanitizedError(
+      Parse.Error.OPERATION_FORBIDDEN,
+      'Master Key is required to update GlobalConfig.'
+    );
+  }
+
+  await globalConfigRouter.updateGlobalConfig({
+    body: {
+      params: { [paramName]: value },
+      masterKeyOnly: { [paramName]: isMasterKeyOnly },
+    },
+    config,
+    auth,
+    context,
+  });
+
+  return { value, isMasterKeyOnly };
+};
+
+const load = parseGraphQLSchema => {
+  const updateConfigValueMutation = mutationWithClientMutationId({
+    name: 'UpdateConfigValue',
+    description: 'Updates the value of a specific parameter in GlobalConfig.',
+    inputFields: {
+      paramName: {
+        description: 'The name of the parameter to set.',
+        type: new GraphQLNonNull(GraphQLString),
+      },
+      value: {
+        description: 'The value to set for the parameter.',
+        type: new GraphQLNonNull(GraphQLString),
+      },
+      isMasterKeyOnly: {
+        description: 'Whether this parameter should only be accessible with master key.',
+        type: GraphQLBoolean,
+        defaultValue: false,
+      },
+    },
+    outputFields: {
+      configValue: {
+        description: 'The updated config value.',
+        type: new GraphQLNonNull(parseGraphQLSchema.configValueType),
+      },
+    },
+    mutateAndGetPayload: async (args, context) => {
+      try {
+        const { paramName, value, isMasterKeyOnly } = args;
+        const result = await updateConfigValue(context, paramName, value, isMasterKeyOnly);
+        return {
+          configValue: result,
+        };
+      } catch (e) {
+        parseGraphQLSchema.handleError(e);
+      }
+    },
+  });
+
+  parseGraphQLSchema.addGraphQLType(updateConfigValueMutation.args.input.type.ofType, true, true);
+  parseGraphQLSchema.addGraphQLType(updateConfigValueMutation.type, true, true);
+  parseGraphQLSchema.addGraphQLMutation('updateConfigValue', updateConfigValueMutation, true, true);
+};
+
+export { load, updateConfigValue };
+