GraphQL Configuration Options

spec/ParseGraphQLServer.spec.js

@@ -685,12 +685,15 @@ describe('ParseGraphQLServer', () => {
           const expectedTypes = [
             '_RoleClass',
             '_RoleConstraints',
-            '_RoleFields',
+            '_RoleCreateFields',
+            '_RoleUpdateFields',
             '_RoleFindResult',
             '_UserClass',
             '_UserConstraints',
             '_UserFindResult',
-            '_UserFields',
+            '_UserSignUpFields',
+            '_UserCreateFields',
+            '_UserUpdateFields',
           ];
           expect(
             expectedTypes.every(type => schemaTypes.indexOf(type) !== -1)

src/Controllers/CacheController.js

@@ -45,6 +45,7 @@ export class CacheController extends AdaptableController {
 
     this.role = new SubCache('role', this);
     this.user = new SubCache('user', this);
+    this.graphQL = new SubCache('graphQL', this);
   }
 
   get(key) {

src/Controllers/GraphQLController.js

@@ -0,0 +1,168 @@
+import requiredParameter from '../../lib/requiredParameter';
+import DatabaseController from './DatabaseController';
+import CacheController from './CacheController';
+
+const GraphQLConfigClass = '_GraphQLConfig';
+const GraphQLConfigId = '1';
+const GraphQLConfigKey = 'config';
+
+class GraphQLController {
+  databaseController: DatabaseController;
+  cacheController: CacheController;
+  isEnabled: boolean;
+
+  constructor(params: {
+    databaseController: DatabaseController,
+    cacheController: CacheController,
+    mountGraphQL: boolean,
+  }) {
+    this.databaseController =
+      params.databaseController ||
+      requiredParameter(
+        `GraphQLController requires a "databaseController" to be instantiated.`
+      );
+    this.cacheController =
+      params.cacheController ||
+      requiredParameter(
+        `GraphQLController requires a "cacheController" to be instantiated.`
+      );
+    this.isEnabled = !!params.mountGraphQL;
+  }
+
+  async getGraphQLConfig(): Promise<ParseGraphQLConfig> {
+    const _cachedConfig = await this._getCachedGraphQLConfig();
+    if (_cachedConfig) {
+      return _cachedConfig;
+    }
+
+    const results = await this.databaseController.find(
+      GraphQLConfigClass,
+      { objectId: GraphQLConfigId },
+      { limit: 1 }
+    );
+
+    let graphQLConfig;
+    if (results.length != 1) {
+      // If there is no config in the database - return empty config.
+      return {};
+    } else {
+      graphQLConfig = results[0][GraphQLConfigKey];
+    }
+
+    await this._putCachedGraphQLConfig(graphQLConfig);
+
+    return graphQLConfig;
+  }
+
+  async updateGraphQLConfig(
+    graphQLConfig: ParseGraphQLConfig
+  ): Promise<ParseGraphQLConfig> {
+    if(!this.isEnabled) {
+      throw new Error('GraphQL is not enabled on this application.');
+    }
+    // throws if invalid
+    this._validateGraphQLConfig(graphQLConfig);
+
+    // Transform in dot notation to make sure it works
+    const update = Object.keys(graphQLConfig).reduce((acc, key) => {
+      acc[`${GraphQLConfigKey}.${key}`] = graphQLConfig[key];
+      return acc;
+    }, {});
+
+    await this.databaseController.update(
+      GraphQLConfigClass,
+      { objectId: GraphQLConfigId },
+      update,
+      { upsert: true }
+    );
+
+    await this._putCachedGraphQLConfig(graphQLConfig);
+
+    return { response: { result: true } };
+  }
+
+  async _getCachedGraphQLConfig() {
+    return this.cacheController.graphQL.get(GraphQLConfigKey);
+  }
+
+  async _putCachedGraphQLConfig(graphQLConfig: ParseGraphQLConfig) {
+    return this.cacheController.graphQL.put(
+      GraphQLConfigKey,
+      graphQLConfig,
+      60000
+    );
+  }
+
+  _validateGraphQLConfig(graphQLConfig: ?ParseGraphQLConfig): void {
+    let errorMessage: string;
+    if (!graphQLConfig) {
+      errorMessage = 'cannot be undefined, null or empty.';
+    } else if (typeof graphQLConfig !== 'object') {
+      errorMessage = 'must be a valid object.';
+    } else {
+      const {
+        enabledForClasses,
+        disabledForClasses,
+        classConfigs,
+        ...invalidKeys
+      } = graphQLConfig;
+
+      if (invalidKeys.length) {
+        errorMessage = `encountered invalid keys: ${invalidKeys}`;
+      }
+      // TODO use more rigirous structural validations
+      if (enabledForClasses && !Array.isArray(enabledForClasses)) {
+        errorMessage = `"enabledForClasses" is not a valid array.`;
+      }
+      if (disabledForClasses && !Array.isArray(disabledForClasses)) {
+        errorMessage = `"disabledForClasses" is not a valid array.`;
+      }
+      if (classConfigs && !Array.isArray(classConfigs)) {
+        errorMessage = `"classConfigs" is not a valid array.`;
+      }
+    }
+    if (errorMessage) {
+      throw new Error(`Invalid graphQLConfig: ${errorMessage}`);
+    }
+  }
+}
+
+export interface ParseGraphQLConfig {
+  enabledForClasses?: string[];
+  disabledForClasses?: string[];
+  classConfigs?: ParseGraphQLClassConfig[];
+}
+
+export interface ParseGraphQLClassConfig {
+  className: string;
+  /* The `type` object contains options for how the class types are generated */
+  type: ?{
+    /* Fields that are allowed when creating or updating an object. */
+    inputFields:
+      | ?(string[])
+      | ?{
+          /* Leave blank to allow all available fields in the schema. */
+          create?: string[],
+          update?: string[],
+        },
+    /* Fields on the edges that can be resolved from a query, i.e. the Result Type. */
+    outputFields: ?(string[]),
+    /* Fields by which a query can be filtered, i.e. the `where` object. */
+    constraintFields: ?(string[]),
+    /* Fields by which a query can be sorted; suffix with _ASC or _DESC to enforce direction. */
+    sortFields: ?(string[]),
+  };
+  /* The `query` object contains options for which class queries are generated */
+  query: ?{
+    get: ?boolean,
+    find: ?boolean,
+  };
+  /* The `mutation` object contains options for which class mutations are generated */
+  mutation: ?{
+    create: ?boolean,
+    update: ?boolean,
+    delete: ?boolean,
+  };
+}
+
+export default GraphQLController;

src/Controllers/index.js

@@ -25,6 +25,7 @@ import { AnalyticsAdapter } from '../Adapters/Analytics/AnalyticsAdapter';
 import MongoStorageAdapter from '../Adapters/Storage/Mongo/MongoStorageAdapter';
 import PostgresStorageAdapter from '../Adapters/Storage/Postgres/PostgresStorageAdapter';
 import ParsePushAdapter from '@parse/push-adapter';
+import GraphQLController from './GraphQLController';
 
 export function getControllers(options: ParseServerOptions) {
   const loggerController = getLoggerController(options);
@@ -43,6 +44,10 @@ export function getControllers(options: ParseServerOptions) {
   const databaseController = getDatabaseController(options, cacheController);
   const hooksController = getHooksController(options, databaseController);
   const authDataManager = getAuthDataManager(options);
+  const graphQLController = getGraphQLController(options, {
+    databaseController,
+    cacheController,
+  });
   return {
     loggerController,
     filesController,
@@ -54,6 +59,7 @@ export function getControllers(options: ParseServerOptions) {
     pushControllerQueue,
     analyticsController,
     cacheController,
+    graphQLController,
     liveQueryController,
     databaseController,
     hooksController,
@@ -123,6 +129,16 @@ export function getCacheController(
   return new CacheController(cacheControllerAdapter, appId);
 }
 
+export function getGraphQLController(
+  options: ParseServerOptions,
+  controllerDeps
+): GraphQLController {
+  return new GraphQLController({
+    mountGraphQL: options.mountGraphQL,
+    ...controllerDeps,
+  });
+}
+
 export function getAnalyticsController(
   options: ParseServerOptions
 ): AnalyticsController {