parse-server 2.8.4 → 8.6.2

package/lib/Error.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSanitizedError = createSanitizedError;
+exports.createSanitizedHttpError = createSanitizedHttpError;
+var _logger = _interopRequireDefault(require("./logger"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Creates a sanitized error that hides detailed information from clients
+ * while logging the detailed message server-side.
+ *
+ * @param {number} errorCode - The Parse.Error code (e.g., Parse.Error.OPERATION_FORBIDDEN)
+ * @param {string} detailedMessage - The detailed error message to log server-side
+ * @returns {Parse.Error} A Parse.Error with sanitized message
+ */
+function createSanitizedError(errorCode, detailedMessage, config) {
+  // On testing we need to add a prefix to the message to allow to find the correct call in the TestUtils.js file
+  if (process.env.TESTING) {
+    _logger.default.error('Sanitized error:', detailedMessage);
+  } else {
+    _logger.default.error(detailedMessage);
+  }
+  return new Parse.Error(errorCode, config?.enableSanitizedErrorResponse !== false ? 'Permission denied' : detailedMessage);
+}
+
+/**
+ * Creates a sanitized error from a regular Error object
+ * Used for non-Parse.Error errors (e.g., Express errors)
+ *
+ * @param {number} statusCode - HTTP status code (e.g., 403)
+ * @param {string} detailedMessage - The detailed error message to log server-side
+ * @returns {Error} An Error with sanitized message
+ */
+function createSanitizedHttpError(statusCode, detailedMessage, config) {
+  // On testing we need to add a prefix to the message to allow to find the correct call in the TestUtils.js file
+  if (process.env.TESTING) {
+    _logger.default.error('Sanitized error:', detailedMessage);
+  } else {
+    _logger.default.error(detailedMessage);
+  }
+  const error = new Error();
+  error.status = statusCode;
+  error.message = config?.enableSanitizedErrorResponse !== false ? 'Permission denied' : detailedMessage;
+  return error;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/GraphQL/ParseGraphQLSchema.js

@@ -0,0 +1,375 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ParseGraphQLSchema = void 0;
+var _node = _interopRequireDefault(require("parse/node"));
+var _graphql = require("graphql");
+var _schema = require("@graphql-tools/schema");
+var _merge = require("@graphql-tools/merge");
+var _util = require("util");
+var _requiredParameter = _interopRequireDefault(require("../requiredParameter"));
+var defaultGraphQLTypes = _interopRequireWildcard(require("./loaders/defaultGraphQLTypes"));
+var parseClassTypes = _interopRequireWildcard(require("./loaders/parseClassTypes"));
+var parseClassQueries = _interopRequireWildcard(require("./loaders/parseClassQueries"));
+var parseClassMutations = _interopRequireWildcard(require("./loaders/parseClassMutations"));
+var defaultGraphQLQueries = _interopRequireWildcard(require("./loaders/defaultGraphQLQueries"));
+var defaultGraphQLMutations = _interopRequireWildcard(require("./loaders/defaultGraphQLMutations"));
+var _ParseGraphQLController = _interopRequireWildcard(require("../Controllers/ParseGraphQLController"));
+var _DatabaseController = _interopRequireDefault(require("../Controllers/DatabaseController"));
+var _SchemaCache = _interopRequireDefault(require("../Adapters/Cache/SchemaCache"));
+var _parseGraphQLUtils = require("./parseGraphQLUtils");
+var schemaDirectives = _interopRequireWildcard(require("./loaders/schemaDirectives"));
+var schemaTypes = _interopRequireWildcard(require("./loaders/schemaTypes"));
+var _triggers = require("../triggers");
+var defaultRelaySchema = _interopRequireWildcard(require("./loaders/defaultRelaySchema"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const RESERVED_GRAPHQL_TYPE_NAMES = ['String', 'Boolean', 'Int', 'Float', 'ID', 'ArrayResult', 'Query', 'Mutation', 'Subscription', 'CreateFileInput', 'CreateFilePayload', 'Viewer', 'SignUpInput', 'SignUpPayload', 'LogInInput', 'LogInPayload', 'LogOutInput', 'LogOutPayload', 'CloudCodeFunction', 'CallCloudCodeInput', 'CallCloudCodePayload', 'CreateClassInput', 'CreateClassPayload', 'UpdateClassInput', 'UpdateClassPayload', 'DeleteClassInput', 'DeleteClassPayload', 'PageInfo'];
+const RESERVED_GRAPHQL_QUERY_NAMES = ['health', 'viewer', 'class', 'classes', 'cloudConfig'];
+const RESERVED_GRAPHQL_MUTATION_NAMES = ['signUp', 'logIn', 'logOut', 'createFile', 'callCloudCode', 'createClass', 'updateClass', 'deleteClass', 'updateCloudConfig'];
+class ParseGraphQLSchema {
+  constructor(params = {}) {
+    this.parseGraphQLController = params.parseGraphQLController || (0, _requiredParameter.default)('You must provide a parseGraphQLController instance!');
+    this.databaseController = params.databaseController || (0, _requiredParameter.default)('You must provide a databaseController instance!');
+    this.log = params.log || (0, _requiredParameter.default)('You must provide a log instance!');
+    this.graphQLCustomTypeDefs = params.graphQLCustomTypeDefs;
+    this.appId = params.appId || (0, _requiredParameter.default)('You must provide the appId!');
+    this.schemaCache = _SchemaCache.default;
+    this.logCache = {};
+  }
+  async load() {
+    const {
+      parseGraphQLConfig
+    } = await this._initializeSchemaAndConfig();
+    const parseClassesArray = await this._getClassesForSchema(parseGraphQLConfig);
+    const functionNames = await this._getFunctionNames();
+    const functionNamesString = functionNames.join();
+    const parseClasses = parseClassesArray.reduce((acc, clazz) => {
+      acc[clazz.className] = clazz;
+      return acc;
+    }, {});
+    if (!this._hasSchemaInputChanged({
+      parseClasses,
+      parseGraphQLConfig,
+      functionNamesString
+    })) {
+      return this.graphQLSchema;
+    }
+    this.parseClasses = parseClasses;
+    this.parseGraphQLConfig = parseGraphQLConfig;
+    this.functionNames = functionNames;
+    this.functionNamesString = functionNamesString;
+    this.parseClassTypes = {};
+    this.viewerType = null;
+    this.cloudConfigType = null;
+    this.graphQLAutoSchema = null;
+    this.graphQLSchema = null;
+    this.graphQLTypes = [];
+    this.graphQLQueries = {};
+    this.graphQLMutations = {};
+    this.graphQLSubscriptions = {};
+    this.graphQLSchemaDirectivesDefinitions = null;
+    this.graphQLSchemaDirectives = {};
+    this.relayNodeInterface = null;
+    defaultGraphQLTypes.load(this);
+    defaultRelaySchema.load(this);
+    schemaTypes.load(this);
+    this._getParseClassesWithConfig(parseClassesArray, parseGraphQLConfig).forEach(([parseClass, parseClassConfig]) => {
+      // Some times schema return the _auth_data_ field
+      // it will lead to unstable graphql generation order
+      if (parseClass.className === '_User') {
+        Object.keys(parseClass.fields).forEach(fieldName => {
+          if (fieldName.startsWith('_auth_data_')) {
+            delete parseClass.fields[fieldName];
+          }
+        });
+      }
+
+      // Fields order inside the schema seems to not be consistent across
+      // restart so we need to ensure an alphabetical order
+      // also it's better for the playground documentation
+      const orderedFields = {};
+      Object.keys(parseClass.fields).sort().forEach(fieldName => {
+        orderedFields[fieldName] = parseClass.fields[fieldName];
+      });
+      parseClass.fields = orderedFields;
+      parseClassTypes.load(this, parseClass, parseClassConfig);
+      parseClassQueries.load(this, parseClass, parseClassConfig);
+      parseClassMutations.load(this, parseClass, parseClassConfig);
+    });
+    defaultGraphQLTypes.loadArrayResult(this, parseClassesArray);
+    defaultGraphQLQueries.load(this);
+    defaultGraphQLMutations.load(this);
+    let graphQLQuery = undefined;
+    if (Object.keys(this.graphQLQueries).length > 0) {
+      graphQLQuery = new _graphql.GraphQLObjectType({
+        name: 'Query',
+        description: 'Query is the top level type for queries.',
+        fields: this.graphQLQueries
+      });
+      this.addGraphQLType(graphQLQuery, true, true);
+    }
+    let graphQLMutation = undefined;
+    if (Object.keys(this.graphQLMutations).length > 0) {
+      graphQLMutation = new _graphql.GraphQLObjectType({
+        name: 'Mutation',
+        description: 'Mutation is the top level type for mutations.',
+        fields: this.graphQLMutations
+      });
+      this.addGraphQLType(graphQLMutation, true, true);
+    }
+    let graphQLSubscription = undefined;
+    if (Object.keys(this.graphQLSubscriptions).length > 0) {
+      graphQLSubscription = new _graphql.GraphQLObjectType({
+        name: 'Subscription',
+        description: 'Subscription is the top level type for subscriptions.',
+        fields: this.graphQLSubscriptions
+      });
+      this.addGraphQLType(graphQLSubscription, true, true);
+    }
+    this.graphQLAutoSchema = new _graphql.GraphQLSchema({
+      types: this.graphQLTypes,
+      query: graphQLQuery,
+      mutation: graphQLMutation,
+      subscription: graphQLSubscription
+    });
+    if (this.graphQLCustomTypeDefs) {
+      schemaDirectives.load(this);
+      if (typeof this.graphQLCustomTypeDefs.getTypeMap === 'function') {
+        // In following code we use underscore attr to keep the direct variable reference
+        const customGraphQLSchemaTypeMap = this.graphQLCustomTypeDefs._typeMap;
+        const findAndReplaceLastType = (parent, key) => {
+          if (parent[key].name) {
+            if (this.graphQLAutoSchema._typeMap[parent[key].name] && this.graphQLAutoSchema._typeMap[parent[key].name] !== parent[key]) {
+              // To avoid unresolved field on overloaded schema
+              // replace the final type with the auto schema one
+              parent[key] = this.graphQLAutoSchema._typeMap[parent[key].name];
+            }
+          } else {
+            if (parent[key].ofType) {
+              findAndReplaceLastType(parent[key], 'ofType');
+            }
+          }
+        };
+        // Add non shared types from custom schema to auto schema
+        // note: some non shared types can use some shared types
+        // so this code need to be ran before the shared types addition
+        // we use sort to ensure schema consistency over restarts
+        Object.keys(customGraphQLSchemaTypeMap).sort().forEach(customGraphQLSchemaTypeKey => {
+          const customGraphQLSchemaType = customGraphQLSchemaTypeMap[customGraphQLSchemaTypeKey];
+          if (!customGraphQLSchemaType || !customGraphQLSchemaType.name || customGraphQLSchemaType.name.startsWith('__')) {
+            return;
+          }
+          const autoGraphQLSchemaType = this.graphQLAutoSchema._typeMap[customGraphQLSchemaType.name];
+          if (!autoGraphQLSchemaType) {
+            this.graphQLAutoSchema._typeMap[customGraphQLSchemaType.name] = customGraphQLSchemaType;
+          }
+        });
+        // Handle shared types
+        // We pass through each type and ensure that all sub field types are replaced
+        // we use sort to ensure schema consistency over restarts
+        Object.keys(customGraphQLSchemaTypeMap).sort().forEach(customGraphQLSchemaTypeKey => {
+          const customGraphQLSchemaType = customGraphQLSchemaTypeMap[customGraphQLSchemaTypeKey];
+          if (!customGraphQLSchemaType || !customGraphQLSchemaType.name || customGraphQLSchemaType.name.startsWith('__')) {
+            return;
+          }
+          const autoGraphQLSchemaType = this.graphQLAutoSchema._typeMap[customGraphQLSchemaType.name];
+          if (autoGraphQLSchemaType && typeof customGraphQLSchemaType.getFields === 'function') {
+            Object.keys(customGraphQLSchemaType._fields).sort().forEach(fieldKey => {
+              const field = customGraphQLSchemaType._fields[fieldKey];
+              findAndReplaceLastType(field, 'type');
+              autoGraphQLSchemaType._fields[field.name] = field;
+            });
+          }
+        });
+        this.graphQLSchema = this.graphQLAutoSchema;
+      } else if (typeof this.graphQLCustomTypeDefs === 'function') {
+        this.graphQLSchema = await this.graphQLCustomTypeDefs({
+          directivesDefinitionsSchema: this.graphQLSchemaDirectivesDefinitions,
+          autoSchema: this.graphQLAutoSchema,
+          graphQLSchemaDirectives: this.graphQLSchemaDirectives
+        });
+      } else {
+        this.graphQLSchema = (0, _schema.mergeSchemas)({
+          schemas: [this.graphQLAutoSchema],
+          typeDefs: (0, _merge.mergeTypeDefs)([this.graphQLCustomTypeDefs, this.graphQLSchemaDirectivesDefinitions])
+        });
+        this.graphQLSchema = this.graphQLSchemaDirectives(this.graphQLSchema);
+      }
+    } else {
+      this.graphQLSchema = this.graphQLAutoSchema;
+    }
+    return this.graphQLSchema;
+  }
+  _logOnce(severity, message) {
+    if (this.logCache[message]) {
+      return;
+    }
+    this.log[severity](message);
+    this.logCache[message] = true;
+  }
+  addGraphQLType(type, throwError = false, ignoreReserved = false, ignoreConnection = false) {
+    if (!ignoreReserved && RESERVED_GRAPHQL_TYPE_NAMES.includes(type.name) || this.graphQLTypes.find(existingType => existingType.name === type.name) || !ignoreConnection && type.name.endsWith('Connection')) {
+      const message = `Type ${type.name} could not be added to the auto schema because it collided with an existing type.`;
+      if (throwError) {
+        throw new Error(message);
+      }
+      this._logOnce('warn', message);
+      return undefined;
+    }
+    this.graphQLTypes.push(type);
+    return type;
+  }
+  addGraphQLQuery(fieldName, field, throwError = false, ignoreReserved = false) {
+    if (!ignoreReserved && RESERVED_GRAPHQL_QUERY_NAMES.includes(fieldName) || this.graphQLQueries[fieldName]) {
+      const message = `Query ${fieldName} could not be added to the auto schema because it collided with an existing field.`;
+      if (throwError) {
+        throw new Error(message);
+      }
+      this._logOnce('warn', message);
+      return undefined;
+    }
+    this.graphQLQueries[fieldName] = field;
+    return field;
+  }
+  addGraphQLMutation(fieldName, field, throwError = false, ignoreReserved = false) {
+    if (!ignoreReserved && RESERVED_GRAPHQL_MUTATION_NAMES.includes(fieldName) || this.graphQLMutations[fieldName]) {
+      const message = `Mutation ${fieldName} could not be added to the auto schema because it collided with an existing field.`;
+      if (throwError) {
+        throw new Error(message);
+      }
+      this._logOnce('warn', message);
+      return undefined;
+    }
+    this.graphQLMutations[fieldName] = field;
+    return field;
+  }
+  handleError(error) {
+    if (error instanceof _node.default.Error) {
+      this.log.error('Parse error: ', error);
+    } else {
+      this.log.error('Uncaught internal server error.', error, error.stack);
+    }
+    throw (0, _parseGraphQLUtils.toGraphQLError)(error);
+  }
+  async _initializeSchemaAndConfig() {
+    const [schemaController, parseGraphQLConfig] = await Promise.all([this.databaseController.loadSchema(), this.parseGraphQLController.getGraphQLConfig()]);
+    this.schemaController = schemaController;
+    return {
+      parseGraphQLConfig
+    };
+  }
+
+  /**
+   * Gets all classes found by the `schemaController`
+   * minus those filtered out by the app's parseGraphQLConfig.
+   */
+  async _getClassesForSchema(parseGraphQLConfig) {
+    const {
+      enabledForClasses,
+      disabledForClasses
+    } = parseGraphQLConfig;
+    const allClasses = await this.schemaController.getAllClasses();
+    if (Array.isArray(enabledForClasses) || Array.isArray(disabledForClasses)) {
+      let includedClasses = allClasses;
+      if (enabledForClasses) {
+        includedClasses = allClasses.filter(clazz => {
+          return enabledForClasses.includes(clazz.className);
+        });
+      }
+      if (disabledForClasses) {
+        // Classes included in `enabledForClasses` that
+        // are also present in `disabledForClasses` will
+        // still be filtered out
+        includedClasses = includedClasses.filter(clazz => {
+          return !disabledForClasses.includes(clazz.className);
+        });
+      }
+      this.isUsersClassDisabled = !includedClasses.some(clazz => {
+        return clazz.className === '_User';
+      });
+      return includedClasses;
+    } else {
+      return allClasses;
+    }
+  }
+
+  /**
+   * This method returns a list of tuples
+   * that provide the parseClass along with
+   * its parseClassConfig where provided.
+   */
+  _getParseClassesWithConfig(parseClasses, parseGraphQLConfig) {
+    const {
+      classConfigs
+    } = parseGraphQLConfig;
+
+    // Make sures that the default classes and classes that
+    // starts with capitalized letter will be generated first.
+    const sortClasses = (a, b) => {
+      a = a.className;
+      b = b.className;
+      if (a[0] === '_') {
+        if (b[0] !== '_') {
+          return -1;
+        }
+      }
+      if (b[0] === '_') {
+        if (a[0] !== '_') {
+          return 1;
+        }
+      }
+      if (a === b) {
+        return 0;
+      } else if (a < b) {
+        return -1;
+      } else {
+        return 1;
+      }
+    };
+    return parseClasses.sort(sortClasses).map(parseClass => {
+      let parseClassConfig;
+      if (classConfigs) {
+        parseClassConfig = classConfigs.find(c => c.className === parseClass.className);
+      }
+      return [parseClass, parseClassConfig];
+    });
+  }
+  async _getFunctionNames() {
+    return await (0, _triggers.getFunctionNames)(this.appId).filter(functionName => {
+      if (/^[_a-zA-Z][_a-zA-Z0-9]*$/.test(functionName)) {
+        return true;
+      } else {
+        this._logOnce('warn', `Function ${functionName} could not be added to the auto schema because GraphQL names must match /^[_a-zA-Z][_a-zA-Z0-9]*$/.`);
+        return false;
+      }
+    });
+  }
+
+  /**
+   * Checks for changes to the parseClasses
+   * objects (i.e. database schema) or to
+   * the parseGraphQLConfig object. If no
+   * changes are found, return true;
+   */
+  _hasSchemaInputChanged(params) {
+    const {
+      parseClasses,
+      parseGraphQLConfig,
+      functionNamesString
+    } = params;
+
+    // First init
+    if (!this.graphQLSchema) {
+      return true;
+    }
+    if ((0, _util.isDeepStrictEqual)(this.parseGraphQLConfig, parseGraphQLConfig) && this.functionNamesString === functionNamesString && (0, _util.isDeepStrictEqual)(this.parseClasses, parseClasses)) {
+      return false;
+    }
+    return true;
+  }
+}
+exports.ParseGraphQLSchema = ParseGraphQLSchema;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_node","_interopRequireDefault","require","_graphql","_schema","_merge","_util","_requiredParameter","defaultGraphQLTypes","_interopRequireWildcard","parseClassTypes","parseClassQueries","parseClassMutations","defaultGraphQLQueries","defaultGraphQLMutations","_ParseGraphQLController","_DatabaseController","_SchemaCache","_parseGraphQLUtils","schemaDirectives","schemaTypes","_triggers","defaultRelaySchema","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","RESERVED_GRAPHQL_TYPE_NAMES","RESERVED_GRAPHQL_QUERY_NAMES","RESERVED_GRAPHQL_MUTATION_NAMES","ParseGraphQLSchema","constructor","params","parseGraphQLController","requiredParameter","databaseController","log","graphQLCustomTypeDefs","appId","schemaCache","SchemaCache","logCache","load","parseGraphQLConfig","_initializeSchemaAndConfig","parseClassesArray","_getClassesForSchema","functionNames","_getFunctionNames","functionNamesString","join","parseClasses","reduce","acc","clazz","className","_hasSchemaInputChanged","graphQLSchema","viewerType","cloudConfigType","graphQLAutoSchema","graphQLTypes","graphQLQueries","graphQLMutations","graphQLSubscriptions","graphQLSchemaDirectivesDefinitions","graphQLSchemaDirectives","relayNodeInterface","_getParseClassesWithConfig","forEach","parseClass","parseClassConfig","keys","fields","fieldName","startsWith","orderedFields","sort","loadArrayResult","graphQLQuery","undefined","length","GraphQLObjectType","name","description","addGraphQLType","graphQLMutation","graphQLSubscription","GraphQLSchema","types","query","mutation","subscription","getTypeMap","customGraphQLSchemaTypeMap","_typeMap","findAndReplaceLastType","parent","key","ofType","customGraphQLSchemaTypeKey","customGraphQLSchemaType","autoGraphQLSchemaType","getFields","_fields","fieldKey","field","directivesDefinitionsSchema","autoSchema","mergeSchemas","schemas","typeDefs","mergeTypeDefs","_logOnce","severity","message","type","throwError","ignoreReserved","ignoreConnection","includes","find","existingType","endsWith","Error","push","addGraphQLQuery","addGraphQLMutation","handleError","error","Parse","stack","toGraphQLError","schemaController","Promise","all","loadSchema","getGraphQLConfig","enabledForClasses","disabledForClasses","allClasses","getAllClasses","Array","isArray","includedClasses","filter","isUsersClassDisabled","some","classConfigs","sortClasses","a","b","map","c","getFunctionNames","functionName","test","isDeepStrictEqual","exports"],"sources":["../../src/GraphQL/ParseGraphQLSchema.js"],"sourcesContent":["import Parse from 'parse/node';\nimport { GraphQLSchema, GraphQLObjectType, DocumentNode, GraphQLNamedType } from 'graphql';\nimport { mergeSchemas } from '@graphql-tools/schema';\nimport { mergeTypeDefs } from '@graphql-tools/merge';\nimport { isDeepStrictEqual } from 'util';\nimport requiredParameter from '../requiredParameter';\nimport * as defaultGraphQLTypes from './loaders/defaultGraphQLTypes';\nimport * as parseClassTypes from './loaders/parseClassTypes';\nimport * as parseClassQueries from './loaders/parseClassQueries';\nimport * as parseClassMutations from './loaders/parseClassMutations';\nimport * as defaultGraphQLQueries from './loaders/defaultGraphQLQueries';\nimport * as defaultGraphQLMutations from './loaders/defaultGraphQLMutations';\nimport ParseGraphQLController, { ParseGraphQLConfig } from '../Controllers/ParseGraphQLController';\nimport DatabaseController from '../Controllers/DatabaseController';\nimport SchemaCache from '../Adapters/Cache/SchemaCache';\nimport { toGraphQLError } from './parseGraphQLUtils';\nimport * as schemaDirectives from './loaders/schemaDirectives';\nimport * as schemaTypes from './loaders/schemaTypes';\nimport { getFunctionNames } from '../triggers';\nimport * as defaultRelaySchema from './loaders/defaultRelaySchema';\n\nconst RESERVED_GRAPHQL_TYPE_NAMES = [\n  'String',\n  'Boolean',\n  'Int',\n  'Float',\n  'ID',\n  'ArrayResult',\n  'Query',\n  'Mutation',\n  'Subscription',\n  'CreateFileInput',\n  'CreateFilePayload',\n  'Viewer',\n  'SignUpInput',\n  'SignUpPayload',\n  'LogInInput',\n  'LogInPayload',\n  'LogOutInput',\n  'LogOutPayload',\n  'CloudCodeFunction',\n  'CallCloudCodeInput',\n  'CallCloudCodePayload',\n  'CreateClassInput',\n  'CreateClassPayload',\n  'UpdateClassInput',\n  'UpdateClassPayload',\n  'DeleteClassInput',\n  'DeleteClassPayload',\n  'PageInfo',\n];\nconst RESERVED_GRAPHQL_QUERY_NAMES = ['health', 'viewer', 'class', 'classes', 'cloudConfig'];\nconst RESERVED_GRAPHQL_MUTATION_NAMES = [\n  'signUp',\n  'logIn',\n  'logOut',\n  'createFile',\n  'callCloudCode',\n  'createClass',\n  'updateClass',\n  'deleteClass',\n  'updateCloudConfig',\n];\n\nclass ParseGraphQLSchema {\n  databaseController: DatabaseController;\n  parseGraphQLController: ParseGraphQLController;\n  parseGraphQLConfig: ParseGraphQLConfig;\n  log: any;\n  appId: string;\n  graphQLCustomTypeDefs: ?(string | GraphQLSchema | DocumentNode | GraphQLNamedType[]);\n  schemaCache: any;\n\n  constructor(\n    params: {\n      databaseController: DatabaseController,\n      parseGraphQLController: ParseGraphQLController,\n      log: any,\n      appId: string,\n      graphQLCustomTypeDefs: ?(string | GraphQLSchema | DocumentNode | GraphQLNamedType[]),\n    } = {}\n  ) {\n    this.parseGraphQLController =\n      params.parseGraphQLController ||\n      requiredParameter('You must provide a parseGraphQLController instance!');\n    this.databaseController =\n      params.databaseController ||\n      requiredParameter('You must provide a databaseController instance!');\n    this.log = params.log || requiredParameter('You must provide a log instance!');\n    this.graphQLCustomTypeDefs = params.graphQLCustomTypeDefs;\n    this.appId = params.appId || requiredParameter('You must provide the appId!');\n    this.schemaCache = SchemaCache;\n    this.logCache = {};\n  }\n\n  async load() {\n    const { parseGraphQLConfig } = await this._initializeSchemaAndConfig();\n    const parseClassesArray = await this._getClassesForSchema(parseGraphQLConfig);\n    const functionNames = await this._getFunctionNames();\n    const functionNamesString = functionNames.join();\n\n    const parseClasses = parseClassesArray.reduce((acc, clazz) => {\n      acc[clazz.className] = clazz;\n      return acc;\n    }, {});\n    if (\n      !this._hasSchemaInputChanged({\n        parseClasses,\n        parseGraphQLConfig,\n        functionNamesString,\n      })\n    ) {\n      return this.graphQLSchema;\n    }\n\n    this.parseClasses = parseClasses;\n    this.parseGraphQLConfig = parseGraphQLConfig;\n    this.functionNames = functionNames;\n    this.functionNamesString = functionNamesString;\n    this.parseClassTypes = {};\n    this.viewerType = null;\n    this.cloudConfigType = null;\n    this.graphQLAutoSchema = null;\n    this.graphQLSchema = null;\n    this.graphQLTypes = [];\n    this.graphQLQueries = {};\n    this.graphQLMutations = {};\n    this.graphQLSubscriptions = {};\n    this.graphQLSchemaDirectivesDefinitions = null;\n    this.graphQLSchemaDirectives = {};\n    this.relayNodeInterface = null;\n\n    defaultGraphQLTypes.load(this);\n    defaultRelaySchema.load(this);\n    schemaTypes.load(this);\n\n    this._getParseClassesWithConfig(parseClassesArray, parseGraphQLConfig).forEach(\n      ([parseClass, parseClassConfig]) => {\n        // Some times schema return the _auth_data_ field\n        // it will lead to unstable graphql generation order\n        if (parseClass.className === '_User') {\n          Object.keys(parseClass.fields).forEach(fieldName => {\n            if (fieldName.startsWith('_auth_data_')) {\n              delete parseClass.fields[fieldName];\n            }\n          });\n        }\n\n        // Fields order inside the schema seems to not be consistent across\n        // restart so we need to ensure an alphabetical order\n        // also it's better for the playground documentation\n        const orderedFields = {};\n        Object.keys(parseClass.fields)\n          .sort()\n          .forEach(fieldName => {\n            orderedFields[fieldName] = parseClass.fields[fieldName];\n          });\n        parseClass.fields = orderedFields;\n        parseClassTypes.load(this, parseClass, parseClassConfig);\n        parseClassQueries.load(this, parseClass, parseClassConfig);\n        parseClassMutations.load(this, parseClass, parseClassConfig);\n      }\n    );\n\n    defaultGraphQLTypes.loadArrayResult(this, parseClassesArray);\n    defaultGraphQLQueries.load(this);\n    defaultGraphQLMutations.load(this);\n\n    let graphQLQuery = undefined;\n    if (Object.keys(this.graphQLQueries).length > 0) {\n      graphQLQuery = new GraphQLObjectType({\n        name: 'Query',\n        description: 'Query is the top level type for queries.',\n        fields: this.graphQLQueries,\n      });\n      this.addGraphQLType(graphQLQuery, true, true);\n    }\n\n    let graphQLMutation = undefined;\n    if (Object.keys(this.graphQLMutations).length > 0) {\n      graphQLMutation = new GraphQLObjectType({\n        name: 'Mutation',\n        description: 'Mutation is the top level type for mutations.',\n        fields: this.graphQLMutations,\n      });\n      this.addGraphQLType(graphQLMutation, true, true);\n    }\n\n    let graphQLSubscription = undefined;\n    if (Object.keys(this.graphQLSubscriptions).length > 0) {\n      graphQLSubscription = new GraphQLObjectType({\n        name: 'Subscription',\n        description: 'Subscription is the top level type for subscriptions.',\n        fields: this.graphQLSubscriptions,\n      });\n      this.addGraphQLType(graphQLSubscription, true, true);\n    }\n\n    this.graphQLAutoSchema = new GraphQLSchema({\n      types: this.graphQLTypes,\n      query: graphQLQuery,\n      mutation: graphQLMutation,\n      subscription: graphQLSubscription,\n    });\n\n    if (this.graphQLCustomTypeDefs) {\n      schemaDirectives.load(this);\n      if (typeof this.graphQLCustomTypeDefs.getTypeMap === 'function') {\n        // In following code we use underscore attr to keep the direct variable reference\n        const customGraphQLSchemaTypeMap = this.graphQLCustomTypeDefs._typeMap;\n        const findAndReplaceLastType = (parent, key) => {\n          if (parent[key].name) {\n            if (\n              this.graphQLAutoSchema._typeMap[parent[key].name] &&\n              this.graphQLAutoSchema._typeMap[parent[key].name] !== parent[key]\n            ) {\n              // To avoid unresolved field on overloaded schema\n              // replace the final type with the auto schema one\n              parent[key] = this.graphQLAutoSchema._typeMap[parent[key].name];\n            }\n          } else {\n            if (parent[key].ofType) {\n              findAndReplaceLastType(parent[key], 'ofType');\n            }\n          }\n        };\n        // Add non shared types from custom schema to auto schema\n        // note: some non shared types can use some shared types\n        // so this code need to be ran before the shared types addition\n        // we use sort to ensure schema consistency over restarts\n        Object.keys(customGraphQLSchemaTypeMap)\n          .sort()\n          .forEach(customGraphQLSchemaTypeKey => {\n            const customGraphQLSchemaType = customGraphQLSchemaTypeMap[customGraphQLSchemaTypeKey];\n            if (\n              !customGraphQLSchemaType ||\n              !customGraphQLSchemaType.name ||\n              customGraphQLSchemaType.name.startsWith('__')\n            ) {\n              return;\n            }\n            const autoGraphQLSchemaType = this.graphQLAutoSchema._typeMap[\n              customGraphQLSchemaType.name\n            ];\n            if (!autoGraphQLSchemaType) {\n              this.graphQLAutoSchema._typeMap[\n                customGraphQLSchemaType.name\n              ] = customGraphQLSchemaType;\n            }\n          });\n        // Handle shared types\n        // We pass through each type and ensure that all sub field types are replaced\n        // we use sort to ensure schema consistency over restarts\n        Object.keys(customGraphQLSchemaTypeMap)\n          .sort()\n          .forEach(customGraphQLSchemaTypeKey => {\n            const customGraphQLSchemaType = customGraphQLSchemaTypeMap[customGraphQLSchemaTypeKey];\n            if (\n              !customGraphQLSchemaType ||\n              !customGraphQLSchemaType.name ||\n              customGraphQLSchemaType.name.startsWith('__')\n            ) {\n              return;\n            }\n            const autoGraphQLSchemaType = this.graphQLAutoSchema._typeMap[\n              customGraphQLSchemaType.name\n            ];\n\n            if (autoGraphQLSchemaType && typeof customGraphQLSchemaType.getFields === 'function') {\n              Object.keys(customGraphQLSchemaType._fields)\n                .sort()\n                .forEach(fieldKey => {\n                  const field = customGraphQLSchemaType._fields[fieldKey];\n                  findAndReplaceLastType(field, 'type');\n                  autoGraphQLSchemaType._fields[field.name] = field;\n                });\n            }\n          });\n        this.graphQLSchema = this.graphQLAutoSchema;\n      } else if (typeof this.graphQLCustomTypeDefs === 'function') {\n        this.graphQLSchema = await this.graphQLCustomTypeDefs({\n          directivesDefinitionsSchema: this.graphQLSchemaDirectivesDefinitions,\n          autoSchema: this.graphQLAutoSchema,\n          graphQLSchemaDirectives: this.graphQLSchemaDirectives,\n        });\n      } else {\n        this.graphQLSchema = mergeSchemas({\n          schemas: [this.graphQLAutoSchema],\n          typeDefs: mergeTypeDefs([\n            this.graphQLCustomTypeDefs,\n            this.graphQLSchemaDirectivesDefinitions,\n          ]),\n        });\n        this.graphQLSchema = this.graphQLSchemaDirectives(this.graphQLSchema);\n      }\n    } else {\n      this.graphQLSchema = this.graphQLAutoSchema;\n    }\n\n    return this.graphQLSchema;\n  }\n\n  _logOnce(severity, message) {\n    if (this.logCache[message]) {\n      return;\n    }\n    this.log[severity](message);\n    this.logCache[message] = true;\n  }\n\n  addGraphQLType(type, throwError = false, ignoreReserved = false, ignoreConnection = false) {\n    if (\n      (!ignoreReserved && RESERVED_GRAPHQL_TYPE_NAMES.includes(type.name)) ||\n      this.graphQLTypes.find(existingType => existingType.name === type.name) ||\n      (!ignoreConnection && type.name.endsWith('Connection'))\n    ) {\n      const message = `Type ${type.name} could not be added to the auto schema because it collided with an existing type.`;\n      if (throwError) {\n        throw new Error(message);\n      }\n      this._logOnce('warn', message);\n      return undefined;\n    }\n    this.graphQLTypes.push(type);\n    return type;\n  }\n\n  addGraphQLQuery(fieldName, field, throwError = false, ignoreReserved = false) {\n    if (\n      (!ignoreReserved && RESERVED_GRAPHQL_QUERY_NAMES.includes(fieldName)) ||\n      this.graphQLQueries[fieldName]\n    ) {\n      const message = `Query ${fieldName} could not be added to the auto schema because it collided with an existing field.`;\n      if (throwError) {\n        throw new Error(message);\n      }\n      this._logOnce('warn', message);\n      return undefined;\n    }\n    this.graphQLQueries[fieldName] = field;\n    return field;\n  }\n\n  addGraphQLMutation(fieldName, field, throwError = false, ignoreReserved = false) {\n    if (\n      (!ignoreReserved && RESERVED_GRAPHQL_MUTATION_NAMES.includes(fieldName)) ||\n      this.graphQLMutations[fieldName]\n    ) {\n      const message = `Mutation ${fieldName} could not be added to the auto schema because it collided with an existing field.`;\n      if (throwError) {\n        throw new Error(message);\n      }\n      this._logOnce('warn', message);\n      return undefined;\n    }\n    this.graphQLMutations[fieldName] = field;\n    return field;\n  }\n\n  handleError(error) {\n    if (error instanceof Parse.Error) {\n      this.log.error('Parse error: ', error);\n    } else {\n      this.log.error('Uncaught internal server error.', error, error.stack);\n    }\n    throw toGraphQLError(error);\n  }\n\n  async _initializeSchemaAndConfig() {\n    const [schemaController, parseGraphQLConfig] = await Promise.all([\n      this.databaseController.loadSchema(),\n      this.parseGraphQLController.getGraphQLConfig(),\n    ]);\n\n    this.schemaController = schemaController;\n\n    return {\n      parseGraphQLConfig,\n    };\n  }\n\n  /**\n   * Gets all classes found by the `schemaController`\n   * minus those filtered out by the app's parseGraphQLConfig.\n   */\n  async _getClassesForSchema(parseGraphQLConfig: ParseGraphQLConfig) {\n    const { enabledForClasses, disabledForClasses } = parseGraphQLConfig;\n    const allClasses = await this.schemaController.getAllClasses();\n\n    if (Array.isArray(enabledForClasses) || Array.isArray(disabledForClasses)) {\n      let includedClasses = allClasses;\n      if (enabledForClasses) {\n        includedClasses = allClasses.filter(clazz => {\n          return enabledForClasses.includes(clazz.className);\n        });\n      }\n      if (disabledForClasses) {\n        // Classes included in `enabledForClasses` that\n        // are also present in `disabledForClasses` will\n        // still be filtered out\n        includedClasses = includedClasses.filter(clazz => {\n          return !disabledForClasses.includes(clazz.className);\n        });\n      }\n\n      this.isUsersClassDisabled = !includedClasses.some(clazz => {\n        return clazz.className === '_User';\n      });\n\n      return includedClasses;\n    } else {\n      return allClasses;\n    }\n  }\n\n  /**\n   * This method returns a list of tuples\n   * that provide the parseClass along with\n   * its parseClassConfig where provided.\n   */\n  _getParseClassesWithConfig(parseClasses, parseGraphQLConfig: ParseGraphQLConfig) {\n    const { classConfigs } = parseGraphQLConfig;\n\n    // Make sures that the default classes and classes that\n    // starts with capitalized letter will be generated first.\n    const sortClasses = (a, b) => {\n      a = a.className;\n      b = b.className;\n      if (a[0] === '_') {\n        if (b[0] !== '_') {\n          return -1;\n        }\n      }\n      if (b[0] === '_') {\n        if (a[0] !== '_') {\n          return 1;\n        }\n      }\n      if (a === b) {\n        return 0;\n      } else if (a < b) {\n        return -1;\n      } else {\n        return 1;\n      }\n    };\n\n    return parseClasses.sort(sortClasses).map(parseClass => {\n      let parseClassConfig;\n      if (classConfigs) {\n        parseClassConfig = classConfigs.find(c => c.className === parseClass.className);\n      }\n      return [parseClass, parseClassConfig];\n    });\n  }\n\n  async _getFunctionNames() {\n    return await getFunctionNames(this.appId).filter(functionName => {\n      if (/^[_a-zA-Z][_a-zA-Z0-9]*$/.test(functionName)) {\n        return true;\n      } else {\n        this._logOnce(\n          'warn',\n          `Function ${functionName} could not be added to the auto schema because GraphQL names must match /^[_a-zA-Z][_a-zA-Z0-9]*$/.`\n        );\n        return false;\n      }\n    });\n  }\n\n  /**\n   * Checks for changes to the parseClasses\n   * objects (i.e. database schema) or to\n   * the parseGraphQLConfig object. If no\n   * changes are found, return true;\n   */\n  _hasSchemaInputChanged(params: {\n    parseClasses: any,\n    parseGraphQLConfig: ?ParseGraphQLConfig,\n    functionNamesString: string,\n  }): boolean {\n    const { parseClasses, parseGraphQLConfig, functionNamesString } = params;\n\n    // First init\n    if (!this.graphQLSchema) {\n      return true;\n    }\n\n    if (\n      isDeepStrictEqual(this.parseGraphQLConfig, parseGraphQLConfig) &&\n      this.functionNamesString === functionNamesString &&\n      isDeepStrictEqual(this.parseClasses, parseClasses)\n    ) {\n      return false;\n    }\n    return true;\n  }\n}\n\nexport { ParseGraphQLSchema };\n"],"mappings":"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","ignoreList":[]}