parse-server 2.8.4 → 8.6.2

package/lib/ParseServer.js

@@ -1,168 +1,218 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-
-var _Options = require('./Options');
-
-var _defaults = require('./defaults');
-
-var _defaults2 = _interopRequireDefault(_defaults);
-
-var _logger = require('./logger');
-
-var logging = _interopRequireWildcard(_logger);
-
-var _Config = require('./Config');
-
-var _Config2 = _interopRequireDefault(_Config);
-
-var _PromiseRouter = require('./PromiseRouter');
-
-var _PromiseRouter2 = _interopRequireDefault(_PromiseRouter);
-
-var _requiredParameter = require('./requiredParameter');
-
-var _requiredParameter2 = _interopRequireDefault(_requiredParameter);
-
-var _AnalyticsRouter = require('./Routers/AnalyticsRouter');
-
-var _ClassesRouter = require('./Routers/ClassesRouter');
-
-var _FeaturesRouter = require('./Routers/FeaturesRouter');
-
-var _FilesRouter = require('./Routers/FilesRouter');
-
-var _FunctionsRouter = require('./Routers/FunctionsRouter');
-
-var _GlobalConfigRouter = require('./Routers/GlobalConfigRouter');
-
-var _HooksRouter = require('./Routers/HooksRouter');
-
-var _IAPValidationRouter = require('./Routers/IAPValidationRouter');
-
-var _InstallationsRouter = require('./Routers/InstallationsRouter');
-
-var _LogsRouter = require('./Routers/LogsRouter');
-
-var _ParseLiveQueryServer = require('./LiveQuery/ParseLiveQueryServer');
-
-var _PublicAPIRouter = require('./Routers/PublicAPIRouter');
-
-var _PushRouter = require('./Routers/PushRouter');
-
-var _CloudCodeRouter = require('./Routers/CloudCodeRouter');
-
-var _RolesRouter = require('./Routers/RolesRouter');
-
-var _SchemasRouter = require('./Routers/SchemasRouter');
-
-var _SessionsRouter = require('./Routers/SessionsRouter');
-
-var _UsersRouter = require('./Routers/UsersRouter');
-
-var _PurgeRouter = require('./Routers/PurgeRouter');
-
-var _AudiencesRouter = require('./Routers/AudiencesRouter');
-
-var _AggregateRouter = require('./Routers/AggregateRouter');
-
-var _ParseServerRESTController = require('./ParseServerRESTController');
-
-var _Controllers = require('./Controllers');
-
-var controllers = _interopRequireWildcard(_Controllers);
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+exports.default = void 0;
+var _defaults = _interopRequireDefault(require("./defaults"));
+var logging = _interopRequireWildcard(require("./logger"));
+var _Config = _interopRequireDefault(require("./Config"));
+var _PromiseRouter = _interopRequireDefault(require("./PromiseRouter"));
+var _requiredParameter = _interopRequireDefault(require("./requiredParameter"));
+var _AnalyticsRouter = require("./Routers/AnalyticsRouter");
+var _ClassesRouter = require("./Routers/ClassesRouter");
+var _FeaturesRouter = require("./Routers/FeaturesRouter");
+var _FilesRouter = require("./Routers/FilesRouter");
+var _FunctionsRouter = require("./Routers/FunctionsRouter");
+var _GlobalConfigRouter = require("./Routers/GlobalConfigRouter");
+var _GraphQLRouter = require("./Routers/GraphQLRouter");
+var _HooksRouter = require("./Routers/HooksRouter");
+var _IAPValidationRouter = require("./Routers/IAPValidationRouter");
+var _InstallationsRouter = require("./Routers/InstallationsRouter");
+var _LogsRouter = require("./Routers/LogsRouter");
+var _ParseLiveQueryServer = require("./LiveQuery/ParseLiveQueryServer");
+var _PagesRouter = require("./Routers/PagesRouter");
+var _PublicAPIRouter = require("./Routers/PublicAPIRouter");
+var _PushRouter = require("./Routers/PushRouter");
+var _CloudCodeRouter = require("./Routers/CloudCodeRouter");
+var _RolesRouter = require("./Routers/RolesRouter");
+var _SchemasRouter = require("./Routers/SchemasRouter");
+var _SessionsRouter = require("./Routers/SessionsRouter");
+var _UsersRouter = require("./Routers/UsersRouter");
+var _PurgeRouter = require("./Routers/PurgeRouter");
+var _AudiencesRouter = require("./Routers/AudiencesRouter");
+var _AggregateRouter = require("./Routers/AggregateRouter");
+var _ParseServerRESTController = require("./ParseServerRESTController");
+var controllers = _interopRequireWildcard(require("./Controllers"));
+var _ParseGraphQLServer = require("./GraphQL/ParseGraphQLServer");
+var _SecurityRouter = require("./Routers/SecurityRouter");
+var _CheckRunner = _interopRequireDefault(require("./Security/CheckRunner"));
+var _Deprecator = _interopRequireDefault(require("./Deprecator/Deprecator"));
+var _DefinedSchemas = require("./SchemaMigrations/DefinedSchemas");
+var _Definitions = _interopRequireDefault(require("./Options/Definitions"));
+var _TestUtils = require("./TestUtils");
+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 }; }
 // ParseServer - open-source compatible API Server for Parse apps
 
 var batch = require('./batch'),
-    bodyParser = require('body-parser'),
-    express = require('express'),
-    middlewares = require('./middlewares'),
-    Parse = require('parse/node').Parse,
-    path = require('path');
-
+  express = require('express'),
+  middlewares = require('./middlewares'),
+  Parse = require('parse/node').Parse,
+  {
+    parse
+  } = require('graphql'),
+  path = require('path'),
+  fs = require('fs');
 // Mutate the Parse object to add the Cloud Code handlers
 addParseCloud();
 
-// ParseServer works like a constructor of an express app.
-// The args that we understand are:
-// "analyticsAdapter": an adapter class for analytics
-// "filesAdapter": a class like GridStoreAdapter providing create, get,
-//                 and delete
-// "loggerAdapter": a class like WinstonLoggerAdapter providing info, error,
-//                 and query
-// "jsonLogs": log as structured JSON objects
-// "databaseURI": a uri like mongodb://localhost:27017/dbname to tell us
-//          what database this Parse API connects to.
-// "cloud": relative location to cloud code to require, or a function
-//          that is given an instance of Parse as a parameter.  Use this instance of Parse
-//          to register your cloud code hooks and functions.
-// "appId": the application id to host
-// "masterKey": the master key for requests to this app
-// "collectionPrefix": optional prefix for database collection names
-// "fileKey": optional key from Parse dashboard for supporting older files
-//            hosted by Parse
-// "clientKey": optional key from Parse dashboard
-// "dotNetKey": optional key from Parse dashboard
-// "restAPIKey": optional key from Parse dashboard
-// "webhookKey": optional key from Parse dashboard
-// "javascriptKey": optional key from Parse dashboard
-// "push": optional key from configure push
-// "sessionLength": optional length in seconds for how long Sessions should be valid for
-// "maxLimit": optional upper bound for what can be specified for the 'limit' parameter on queries
+// Track connections to destroy them on shutdown
+const connections = new _TestUtils.Connections();
 
+// ParseServer works like a constructor of an express app.
+// https://parseplatform.org/parse-server/api/master/ParseServerOptions.html
 class ParseServer {
-
+  /**
+   * @constructor
+   * @param {ParseServerOptions} options the parse server initialization options
+   */
   constructor(options) {
+    // Scan for deprecated Parse Server options
+    _Deprecator.default.scanParseServerOptions(options);
+    const interfaces = JSON.parse(JSON.stringify(_Definitions.default));
+    function getValidObject(root) {
+      const result = {};
+      for (const key in root) {
+        if (Object.prototype.hasOwnProperty.call(root[key], 'type')) {
+          if (root[key].type.endsWith('[]')) {
+            result[key] = [getValidObject(interfaces[root[key].type.slice(0, -2)])];
+          } else {
+            result[key] = getValidObject(interfaces[root[key].type]);
+          }
+        } else {
+          result[key] = '';
+        }
+      }
+      return result;
+    }
+    const optionsBlueprint = getValidObject(interfaces['ParseServerOptions']);
+    function validateKeyNames(original, ref, name = '') {
+      let result = [];
+      const prefix = name + (name !== '' ? '.' : '');
+      for (const key in original) {
+        if (!Object.prototype.hasOwnProperty.call(ref, key)) {
+          result.push(prefix + key);
+        } else {
+          if (ref[key] === '') {
+            continue;
+          }
+          let res = [];
+          if (Array.isArray(original[key]) && Array.isArray(ref[key])) {
+            const type = ref[key][0];
+            original[key].forEach((item, idx) => {
+              if (typeof item === 'object' && item !== null) {
+                res = res.concat(validateKeyNames(item, type, prefix + key + `[${idx}]`));
+              }
+            });
+          } else if (typeof original[key] === 'object' && typeof ref[key] === 'object') {
+            res = validateKeyNames(original[key], ref[key], prefix + key);
+          }
+          result = result.concat(res);
+        }
+      }
+      return result;
+    }
+    const diff = validateKeyNames(options, optionsBlueprint);
+    if (diff.length > 0) {
+      const logger = logging.logger;
+      logger.error(`Invalid key(s) found in Parse Server configuration: ${diff.join(', ')}`);
+    }
+
+    // Set option defaults
     injectDefaults(options);
     const {
-      appId = (0, _requiredParameter2.default)('You must provide an appId!'),
-      masterKey = (0, _requiredParameter2.default)('You must provide a masterKey!'),
-      cloud,
+      appId = (0, _requiredParameter.default)('You must provide an appId!'),
+      masterKey = (0, _requiredParameter.default)('You must provide a masterKey!'),
       javascriptKey,
-      serverURL = (0, _requiredParameter2.default)('You must provide a serverURL!'),
-      __indexBuildCompletionCallbackForTests = () => {}
+      serverURL = (0, _requiredParameter.default)('You must provide a serverURL!')
     } = options;
     // Initialize the node client SDK automatically
     Parse.initialize(appId, javascriptKey || 'unused', masterKey);
     Parse.serverURL = serverURL;
-
+    _Config.default.validateOptions(options);
     const allControllers = controllers.getControllers(options);
+    options.state = 'initialized';
+    this.config = _Config.default.put(Object.assign({}, options, allControllers));
+    this.config.masterKeyIpsStore = new Map();
+    this.config.maintenanceKeyIpsStore = new Map();
+    logging.setLogger(allControllers.loggerController);
+  }
 
-    const {
-      loggerController,
-      databaseController,
-      hooksController
-    } = allControllers;
-    this.config = _Config2.default.put(Object.assign({}, options, allControllers));
-
-    logging.setLogger(loggerController);
-    const dbInitPromise = databaseController.performInitialization();
-    hooksController.load();
+  /**
+   * Starts Parse Server as an express app; this promise resolves when Parse Server is ready to accept requests.
+   */
 
-    // Note: Tests will start to fail if any validation happens after this is called.
-    if (process.env.TESTING) {
-      __indexBuildCompletionCallbackForTests(dbInitPromise);
-    }
-
-    if (cloud) {
-      addParseCloud();
-      if (typeof cloud === 'function') {
-        cloud(Parse);
-      } else if (typeof cloud === 'string') {
-        require(path.resolve(process.cwd(), cloud));
-      } else {
-        throw "argument 'cloud' must either be a string or a function";
+  async start() {
+    try {
+      if (this.config.state === 'ok') {
+        return this;
+      }
+      this.config.state = 'starting';
+      _Config.default.put(this.config);
+      const {
+        databaseController,
+        hooksController,
+        cacheController,
+        cloud,
+        security,
+        schema,
+        liveQueryController
+      } = this.config;
+      try {
+        await databaseController.performInitialization();
+      } catch (e) {
+        if (e.code !== Parse.Error.DUPLICATE_VALUE) {
+          throw e;
+        }
+      }
+      const pushController = await controllers.getPushController(this.config);
+      await hooksController.load();
+      const startupPromises = [this.config.loadMasterKey?.()];
+      if (schema) {
+        startupPromises.push(new _DefinedSchemas.DefinedSchemas(schema, this.config).execute());
+      }
+      if (cacheController.adapter?.connect && typeof cacheController.adapter.connect === 'function') {
+        startupPromises.push(cacheController.adapter.connect());
       }
+      startupPromises.push(liveQueryController.connect());
+      await Promise.all(startupPromises);
+      if (cloud) {
+        addParseCloud();
+        if (typeof cloud === 'function') {
+          await Promise.resolve(cloud(Parse));
+        } else if (typeof cloud === 'string') {
+          let json;
+          if (process.env.npm_package_json) {
+            json = require(process.env.npm_package_json);
+          }
+          if (process.env.npm_package_type === 'module' || json?.type === 'module') {
+            await import(path.resolve(process.cwd(), cloud));
+          } else {
+            require(path.resolve(process.cwd(), cloud));
+          }
+        } else {
+          throw "argument 'cloud' must either be a string or a function";
+        }
+        await new Promise(resolve => setTimeout(resolve, 10));
+      }
+      if (security && security.enableCheck && security.enableCheckLog) {
+        new _CheckRunner.default(security).run();
+      }
+      this.config.state = 'ok';
+      this.config = {
+        ...this.config,
+        ...pushController
+      };
+      _Config.default.put(this.config);
+      return this;
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.error(error);
+      this.config.state = 'error';
+      throw error;
     }
   }
-
   get app() {
     if (!this._app) {
       this._app = ParseServer.app(this.config);
@@ -170,39 +220,131 @@ class ParseServer {
     return this._app;
   }
 
-  handleShutdown() {
-    const { adapter } = this.config.databaseController;
-    if (adapter && typeof adapter.handleShutdown === 'function') {
-      adapter.handleShutdown();
+  /**
+   * Stops the parse server, cancels any ongoing requests and closes all connections.
+   *
+   * Currently, express doesn't shut down immediately after receiving SIGINT/SIGTERM
+   * if it has client connections that haven't timed out.
+   * (This is a known issue with node - https://github.com/nodejs/node/issues/2642)
+   *
+   * @returns {Promise<void>} a promise that resolves when the server is stopped
+   */
+  async handleShutdown() {
+    const serverClosePromise = (0, _TestUtils.resolvingPromise)();
+    const liveQueryServerClosePromise = (0, _TestUtils.resolvingPromise)();
+    const promises = [];
+    this.server.close(error => {
+      /* istanbul ignore next */
+      if (error) {
+        // eslint-disable-next-line no-console
+        console.error('Error while closing parse server', error);
+      }
+      serverClosePromise.resolve();
+    });
+    if (this.liveQueryServer?.server?.close && this.liveQueryServer.server !== this.server) {
+      this.liveQueryServer.server.close(error => {
+        /* istanbul ignore next */
+        if (error) {
+          // eslint-disable-next-line no-console
+          console.error('Error while closing live query server', error);
+        }
+        liveQueryServerClosePromise.resolve();
+      });
+    } else {
+      liveQueryServerClosePromise.resolve();
+    }
+    const {
+      adapter: databaseAdapter
+    } = this.config.databaseController;
+    if (databaseAdapter && typeof databaseAdapter.handleShutdown === 'function') {
+      promises.push(databaseAdapter.handleShutdown());
+    }
+    const {
+      adapter: fileAdapter
+    } = this.config.filesController;
+    if (fileAdapter && typeof fileAdapter.handleShutdown === 'function') {
+      promises.push(fileAdapter.handleShutdown());
+    }
+    const {
+      adapter: cacheAdapter
+    } = this.config.cacheController;
+    if (cacheAdapter && typeof cacheAdapter.handleShutdown === 'function') {
+      promises.push(cacheAdapter.handleShutdown());
+    }
+    if (this.liveQueryServer) {
+      promises.push(this.liveQueryServer.shutdown());
+    }
+    await Promise.all(promises);
+    connections.destroyAll();
+    await Promise.all([serverClosePromise, liveQueryServerClosePromise]);
+    if (this.config.serverCloseComplete) {
+      this.config.serverCloseComplete();
     }
   }
 
-  static app({ maxUploadSize = '20mb', appId }) {
+  /**
+   * @static
+   * Allow developers to customize each request with inversion of control/dependency injection
+   */
+  static applyRequestContextMiddleware(api, options) {
+    if (options.requestContextMiddleware) {
+      if (typeof options.requestContextMiddleware !== 'function') {
+        throw new Error('requestContextMiddleware must be a function');
+      }
+      api.use(options.requestContextMiddleware);
+    }
+  }
+  /**
+   * @static
+   * Create an express app for the parse server
+   * @param {Object} options let you specify the maxUploadSize when creating the express app  */
+  static app(options) {
+    const {
+      maxUploadSize = '20mb',
+      appId,
+      directAccess,
+      pages,
+      rateLimit = []
+    } = options;
     // This app serves the Parse API directly.
     // It's the equivalent of https://api.parse.com/1 in the hosted Parse API.
     var api = express();
     //api.use("/apps", express.static(__dirname + "/public"));
+    api.use(middlewares.allowCrossDomain(appId));
+    api.use(middlewares.allowDoubleForwardSlash);
     // File handling needs to be before default middlewares are applied
-    api.use('/', middlewares.allowCrossDomain, new _FilesRouter.FilesRouter().expressRouter({
+    api.use('/', new _FilesRouter.FilesRouter().expressRouter({
       maxUploadSize: maxUploadSize
     }));
-
     api.use('/health', function (req, res) {
+      res.status(options.state === 'ok' ? 200 : 503);
+      if (options.state === 'starting') {
+        res.set('Retry-After', 1);
+      }
       res.json({
-        status: 'ok'
+        status: options.state
       });
     });
-
-    api.use('/', bodyParser.urlencoded({ extended: false }), new _PublicAPIRouter.PublicAPIRouter().expressRouter());
-
-    api.use(bodyParser.json({ 'type': '*/*', limit: maxUploadSize }));
-    api.use(middlewares.allowCrossDomain);
+    api.use('/', express.urlencoded({
+      extended: false
+    }), pages.enableRouter ? new _PagesRouter.PagesRouter(pages).expressRouter() : new _PublicAPIRouter.PublicAPIRouter().expressRouter());
+    api.use(express.json({
+      type: '*/*',
+      limit: maxUploadSize
+    }));
     api.use(middlewares.allowMethodOverride);
     api.use(middlewares.handleParseHeaders);
-
-    const appRouter = ParseServer.promiseRouter({ appId });
+    api.set('query parser', 'extended');
+    const routes = Array.isArray(rateLimit) ? rateLimit : [rateLimit];
+    for (const route of routes) {
+      middlewares.addRateLimit(route, options);
+    }
+    api.use(middlewares.handleParseSession);
+    this.applyRequestContextMiddleware(api, options);
+    const appRouter = ParseServer.promiseRouter({
+      appId
+    });
     api.use(appRouter.expressRouter());
-
     api.use(middlewares.handleParseErrors);
 
     // run the following when not testing
@@ -210,40 +352,54 @@ class ParseServer {
       //This causes tests to spew some useless warnings, so disable in test
       /* istanbul ignore next */
       process.on('uncaughtException', err => {
-        if (err.code === "EADDRINUSE") {
+        if (err.code === 'EADDRINUSE') {
           // user-friendly message for this common error
           process.stderr.write(`Unable to listen on port ${err.port}. The port is already in use.`);
           process.exit(0);
         } else {
-          throw err;
+          if (err.message) {
+            process.stderr.write('An uncaught exception occurred: ' + err.message);
+          }
+          if (err.stack) {
+            process.stderr.write('Stack Trace:\n' + err.stack);
+          } else {
+            process.stderr.write(err);
+          }
+          process.exit(1);
         }
       });
-      // verify the server url after a 'mount' event is received
-      /* istanbul ignore next */
-      api.on('mount', function () {
-        ParseServer.verifyServerUrl();
-      });
     }
-    if (process.env.PARSE_SERVER_ENABLE_EXPERIMENTAL_DIRECT_ACCESS === '1') {
+    if (process.env.PARSE_SERVER_ENABLE_EXPERIMENTAL_DIRECT_ACCESS === '1' || directAccess) {
       Parse.CoreManager.setRESTController((0, _ParseServerRESTController.ParseServerRESTController)(appId, appRouter));
     }
     return api;
   }
-
-  static promiseRouter({ appId }) {
-    const routers = [new _ClassesRouter.ClassesRouter(), new _UsersRouter.UsersRouter(), new _SessionsRouter.SessionsRouter(), new _RolesRouter.RolesRouter(), new _AnalyticsRouter.AnalyticsRouter(), new _InstallationsRouter.InstallationsRouter(), new _FunctionsRouter.FunctionsRouter(), new _SchemasRouter.SchemasRouter(), new _PushRouter.PushRouter(), new _LogsRouter.LogsRouter(), new _IAPValidationRouter.IAPValidationRouter(), new _FeaturesRouter.FeaturesRouter(), new _GlobalConfigRouter.GlobalConfigRouter(), new _PurgeRouter.PurgeRouter(), new _HooksRouter.HooksRouter(), new _CloudCodeRouter.CloudCodeRouter(), new _AudiencesRouter.AudiencesRouter(), new _AggregateRouter.AggregateRouter()];
-
+  static promiseRouter({
+    appId
+  }) {
+    const routers = [new _ClassesRouter.ClassesRouter(), new _UsersRouter.UsersRouter(), new _SessionsRouter.SessionsRouter(), new _RolesRouter.RolesRouter(), new _AnalyticsRouter.AnalyticsRouter(), new _InstallationsRouter.InstallationsRouter(), new _FunctionsRouter.FunctionsRouter(), new _SchemasRouter.SchemasRouter(), new _PushRouter.PushRouter(), new _LogsRouter.LogsRouter(), new _IAPValidationRouter.IAPValidationRouter(), new _FeaturesRouter.FeaturesRouter(), new _GlobalConfigRouter.GlobalConfigRouter(), new _GraphQLRouter.GraphQLRouter(), new _PurgeRouter.PurgeRouter(), new _HooksRouter.HooksRouter(), new _CloudCodeRouter.CloudCodeRouter(), new _AudiencesRouter.AudiencesRouter(), new _AggregateRouter.AggregateRouter(), new _SecurityRouter.SecurityRouter()];
     const routes = routers.reduce((memo, router) => {
       return memo.concat(router.routes);
     }, []);
-
-    const appRouter = new _PromiseRouter2.default(routes, appId);
-
+    const appRouter = new _PromiseRouter.default(routes, appId);
     batch.mountOnto(appRouter);
     return appRouter;
   }
 
-  start(options, callback) {
+  /**
+   * starts the parse server's express app
+   * @param {ParseServerOptions} options to use to start the server
+   * @returns {ParseServer} the parse server instance
+   */
+
+  async startApp(options) {
+    try {
+      await this.start();
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.error('Error on ParseServer.startApp: ', e);
+      throw e;
+    }
     const app = express();
     if (options.middleware) {
       let middleware;
@@ -254,118 +410,201 @@ class ParseServer {
       }
       app.use(middleware);
     }
-
     app.use(options.mountPath, this.app);
-    const server = app.listen(options.port, options.host, callback);
+    if (options.mountGraphQL === true || options.mountPlayground === true) {
+      let graphQLCustomTypeDefs = undefined;
+      if (typeof options.graphQLSchema === 'string') {
+        graphQLCustomTypeDefs = parse(fs.readFileSync(options.graphQLSchema, 'utf8'));
+      } else if (typeof options.graphQLSchema === 'object' || typeof options.graphQLSchema === 'function') {
+        graphQLCustomTypeDefs = options.graphQLSchema;
+      }
+      const parseGraphQLServer = new _ParseGraphQLServer.ParseGraphQLServer(this, {
+        graphQLPath: options.graphQLPath,
+        playgroundPath: options.playgroundPath,
+        graphQLCustomTypeDefs
+      });
+      if (options.mountGraphQL) {
+        parseGraphQLServer.applyGraphQL(app);
+      }
+      if (options.mountPlayground) {
+        parseGraphQLServer.applyPlayground(app);
+      }
+    }
+    const server = await new Promise(resolve => {
+      app.listen(options.port, options.host, function () {
+        resolve(this);
+      });
+    });
     this.server = server;
-
+    connections.track(server);
     if (options.startLiveQueryServer || options.liveQueryServerOptions) {
-      this.liveQueryServer = ParseServer.createLiveQueryServer(server, options.liveQueryServerOptions);
+      this.liveQueryServer = await ParseServer.createLiveQueryServer(server, options.liveQueryServerOptions, options);
+      if (this.liveQueryServer.server !== this.server) {
+        connections.track(this.liveQueryServer.server);
+      }
+    }
+    if (options.trustProxy) {
+      app.set('trust proxy', options.trustProxy);
     }
     /* istanbul ignore next */
     if (!process.env.TESTING) {
       configureListeners(this);
+      if (options.verifyServerUrl !== false) {
+        await ParseServer.verifyServerUrl();
+      }
     }
     this.expressApp = app;
     return this;
   }
 
-  static start(options, callback) {
+  /**
+   * Creates a new ParseServer and starts it.
+   * @param {ParseServerOptions} options used to start the server
+   * @returns {ParseServer} the parse server instance
+   */
+  static async startApp(options) {
     const parseServer = new ParseServer(options);
-    return parseServer.start(options, callback);
+    return parseServer.startApp(options);
   }
 
-  static createLiveQueryServer(httpServer, config) {
+  /**
+   * Helper method to create a liveQuery server
+   * @static
+   * @param {Server} httpServer an optional http server to pass
+   * @param {LiveQueryServerOptions} config options for the liveQueryServer
+   * @param {ParseServerOptions} options options for the ParseServer
+   * @returns {Promise<ParseLiveQueryServer>} the live query server instance
+   */
+  static async createLiveQueryServer(httpServer, config, options) {
     if (!httpServer || config && config.port) {
       var app = express();
       httpServer = require('http').createServer(app);
       httpServer.listen(config.port);
     }
-    return new _ParseLiveQueryServer.ParseLiveQueryServer(httpServer, config);
+    const server = new _ParseLiveQueryServer.ParseLiveQueryServer(httpServer, config, options);
+    await server.connect();
+    return server;
   }
-
-  static verifyServerUrl(callback) {
+  static async verifyServerUrl() {
     // perform a health check on the serverURL value
     if (Parse.serverURL) {
-      const request = require('request');
-      request(Parse.serverURL.replace(/\/$/, "") + "/health", function (error, response, body) {
-        let json;
+      const isValidHttpUrl = string => {
+        let url;
         try {
-          json = JSON.parse(body);
-        } catch (e) {
-          json = null;
+          url = new URL(string);
+        } catch (_) {
+          return false;
         }
-        if (error || response.statusCode !== 200 || !json || json && json.status !== 'ok') {
-          /* eslint-disable no-console */
-          console.warn(`\nWARNING, Unable to connect to '${Parse.serverURL}'.` + ` Cloud code and push notifications may be unavailable!\n`);
-          /* eslint-enable no-console */
-          if (callback) {
-            callback(false);
-          }
-        } else {
-          if (callback) {
-            callback(true);
-          }
-        }
-      });
+        return url.protocol === 'http:' || url.protocol === 'https:';
+      };
+      const url = `${Parse.serverURL.replace(/\/$/, '')}/health`;
+      if (!isValidHttpUrl(url)) {
+        // eslint-disable-next-line no-console
+        console.warn(`\nWARNING, Unable to connect to '${Parse.serverURL}' as the URL is invalid.` + ` Cloud code and push notifications may be unavailable!\n`);
+        return;
+      }
+      const request = require('./request');
+      const response = await request({
+        url
+      }).catch(response => response);
+      const json = response.data || null;
+      const retry = response.headers?.['retry-after'];
+      if (retry) {
+        await new Promise(resolve => setTimeout(resolve, retry * 1000));
+        return this.verifyServerUrl();
+      }
+      if (response.status !== 200 || json?.status !== 'ok') {
+        /* eslint-disable no-console */
+        console.warn(`\nWARNING, Unable to connect to '${Parse.serverURL}'.` + ` Cloud code and push notifications may be unavailable!\n`);
+        /* eslint-enable no-console */
+        return;
+      }
+      return true;
     }
   }
 }
-
 function addParseCloud() {
-  const ParseCloud = require("./cloud-code/Parse.Cloud");
+  const ParseCloud = require('./cloud-code/Parse.Cloud');
+  const ParseServer = require('./cloud-code/Parse.Server');
+  Object.defineProperty(Parse, 'Server', {
+    get() {
+      const conf = _Config.default.get(Parse.applicationId);
+      return {
+        ...conf,
+        ...ParseServer
+      };
+    },
+    set(newVal) {
+      newVal.appId = Parse.applicationId;
+      _Config.default.put(newVal);
+    },
+    configurable: true
+  });
   Object.assign(Parse.Cloud, ParseCloud);
   global.Parse = Parse;
 }
-
 function injectDefaults(options) {
-  Object.keys(_defaults2.default).forEach(key => {
-    if (!options.hasOwnProperty(key)) {
-      options[key] = _defaults2.default[key];
+  Object.keys(_defaults.default).forEach(key => {
+    if (!Object.prototype.hasOwnProperty.call(options, key)) {
+      options[key] = _defaults.default[key];
     }
   });
-
-  if (!options.hasOwnProperty('serverURL')) {
+  if (!Object.prototype.hasOwnProperty.call(options, 'serverURL')) {
     options.serverURL = `http://localhost:${options.port}${options.mountPath}`;
   }
 
-  options.userSensitiveFields = Array.from(new Set(options.userSensitiveFields.concat(_defaults2.default.userSensitiveFields, options.userSensitiveFields)));
+  // Reserved Characters
+  if (options.appId) {
+    const regex = /[!#$%'()*+&/:;=?@[\]{}^,|<>]/g;
+    if (options.appId.match(regex)) {
+      // eslint-disable-next-line no-console
+      console.warn(`\nWARNING, appId that contains special characters can cause issues while using with urls.\n`);
+    }
+  }
 
-  options.masterKeyIps = Array.from(new Set(options.masterKeyIps.concat(_defaults2.default.masterKeyIps, options.masterKeyIps)));
+  // Backwards compatibility
+  if (options.userSensitiveFields) {
+    /* eslint-disable no-console */
+    !process.env.TESTING && console.warn(`\nDEPRECATED: userSensitiveFields has been replaced by protectedFields allowing the ability to protect fields in all classes with CLP. \n`);
+    /* eslint-enable no-console */
+
+    const userSensitiveFields = Array.from(new Set([...(_defaults.default.userSensitiveFields || []), ...(options.userSensitiveFields || [])]));
+
+    // If the options.protectedFields is unset,
+    // it'll be assigned the default above.
+    // Here, protect against the case where protectedFields
+    // is set, but doesn't have _User.
+    if (!('_User' in options.protectedFields)) {
+      options.protectedFields = Object.assign({
+        _User: []
+      }, options.protectedFields);
+    }
+    options.protectedFields['_User']['*'] = Array.from(new Set([...(options.protectedFields['_User']['*'] || []), ...userSensitiveFields]));
+  }
+
+  // Merge protectedFields options with defaults.
+  Object.keys(_defaults.default.protectedFields).forEach(c => {
+    const cur = options.protectedFields[c];
+    if (!cur) {
+      options.protectedFields[c] = _defaults.default.protectedFields[c];
+    } else {
+      Object.keys(_defaults.default.protectedFields[c]).forEach(r => {
+        const unq = new Set([...(options.protectedFields[c][r] || []), ..._defaults.default.protectedFields[c][r]]);
+        options.protectedFields[c][r] = Array.from(unq);
+      });
+    }
+  });
 }
 
 // Those can't be tested as it requires a subprocess
 /* istanbul ignore next */
 function configureListeners(parseServer) {
-  const server = parseServer.server;
-  const sockets = {};
-  /* Currently, express doesn't shut down immediately after receiving SIGINT/SIGTERM if it has client connections that haven't timed out. (This is a known issue with node - https://github.com/nodejs/node/issues/2642)
-    This function, along with `destroyAliveConnections()`, intend to fix this behavior such that parse server will close all open connections and initiate the shutdown process as soon as it receives a SIGINT/SIGTERM signal. */
-  server.on('connection', socket => {
-    const socketId = socket.remoteAddress + ':' + socket.remotePort;
-    sockets[socketId] = socket;
-    socket.on('close', () => {
-      delete sockets[socketId];
-    });
-  });
-
-  const destroyAliveConnections = function () {
-    for (const socketId in sockets) {
-      try {
-        sockets[socketId].destroy();
-      } catch (e) {/* */}
-    }
-  };
-
   const handleShutdown = function () {
     process.stdout.write('Termination signal received. Shutting down.');
-    destroyAliveConnections();
-    server.close();
     parseServer.handleShutdown();
   };
   process.on('SIGTERM', handleShutdown);
   process.on('SIGINT', handleShutdown);
 }
-
-exports.default = ParseServer;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/ParseServer.js"],"names":["logging","controllers","batch","require","bodyParser","express","middlewares","Parse","path","addParseCloud","ParseServer","constructor","options","injectDefaults","appId","masterKey","cloud","javascriptKey","serverURL","__indexBuildCompletionCallbackForTests","initialize","allControllers","getControllers","loggerController","databaseController","hooksController","config","Config","put","Object","assign","setLogger","dbInitPromise","performInitialization","load","process","env","TESTING","resolve","cwd","app","_app","handleShutdown","adapter","maxUploadSize","api","use","allowCrossDomain","FilesRouter","expressRouter","req","res","json","status","urlencoded","extended","PublicAPIRouter","limit","allowMethodOverride","handleParseHeaders","appRouter","promiseRouter","handleParseErrors","on","err","code","stderr","write","port","exit","verifyServerUrl","PARSE_SERVER_ENABLE_EXPERIMENTAL_DIRECT_ACCESS","CoreManager","setRESTController","routers","ClassesRouter","UsersRouter","SessionsRouter","RolesRouter","AnalyticsRouter","InstallationsRouter","FunctionsRouter","SchemasRouter","PushRouter","LogsRouter","IAPValidationRouter","FeaturesRouter","GlobalConfigRouter","PurgeRouter","HooksRouter","CloudCodeRouter","AudiencesRouter","AggregateRouter","routes","reduce","memo","router","concat","PromiseRouter","mountOnto","start","callback","middleware","mountPath","server","listen","host","startLiveQueryServer","liveQueryServerOptions","liveQueryServer","createLiveQueryServer","configureListeners","expressApp","parseServer","httpServer","createServer","ParseLiveQueryServer","request","replace","error","response","body","JSON","parse","e","statusCode","console","warn","ParseCloud","Cloud","global","keys","defaults","forEach","key","hasOwnProperty","userSensitiveFields","Array","from","Set","masterKeyIps","sockets","socket","socketId","remoteAddress","remotePort","destroyAliveConnections","destroy","stdout","close"],"mappings":"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","file":"ParseServer.js","sourcesContent":["// ParseServer - open-source compatible API Server for Parse apps\n\nvar batch = require('./batch'),\n  bodyParser = require('body-parser'),\n  express = require('express'),\n  middlewares = require('./middlewares'),\n  Parse = require('parse/node').Parse,\n  path = require('path');\n\nimport { ParseServerOptions,\n  LiveQueryServerOptions }      from './Options';\nimport defaults                 from './defaults';\nimport * as logging             from './logger';\nimport Config                   from './Config';\nimport PromiseRouter            from './PromiseRouter';\nimport requiredParameter        from './requiredParameter';\nimport { AnalyticsRouter }      from './Routers/AnalyticsRouter';\nimport { ClassesRouter }        from './Routers/ClassesRouter';\nimport { FeaturesRouter }       from './Routers/FeaturesRouter';\nimport { FilesRouter }          from './Routers/FilesRouter';\nimport { FunctionsRouter }      from './Routers/FunctionsRouter';\nimport { GlobalConfigRouter }   from './Routers/GlobalConfigRouter';\nimport { HooksRouter }          from './Routers/HooksRouter';\nimport { IAPValidationRouter }  from './Routers/IAPValidationRouter';\nimport { InstallationsRouter }  from './Routers/InstallationsRouter';\nimport { LogsRouter }           from './Routers/LogsRouter';\nimport { ParseLiveQueryServer } from './LiveQuery/ParseLiveQueryServer';\nimport { PublicAPIRouter }      from './Routers/PublicAPIRouter';\nimport { PushRouter }           from './Routers/PushRouter';\nimport { CloudCodeRouter }      from './Routers/CloudCodeRouter';\nimport { RolesRouter }          from './Routers/RolesRouter';\nimport { SchemasRouter }        from './Routers/SchemasRouter';\nimport { SessionsRouter }       from './Routers/SessionsRouter';\nimport { UsersRouter }          from './Routers/UsersRouter';\nimport { PurgeRouter }          from './Routers/PurgeRouter';\nimport { AudiencesRouter }      from './Routers/AudiencesRouter';\nimport { AggregateRouter }      from './Routers/AggregateRouter';\n\nimport { ParseServerRESTController } from './ParseServerRESTController';\nimport * as controllers from './Controllers';\n// Mutate the Parse object to add the Cloud Code handlers\naddParseCloud();\n\n// ParseServer works like a constructor of an express app.\n// The args that we understand are:\n// \"analyticsAdapter\": an adapter class for analytics\n// \"filesAdapter\": a class like GridStoreAdapter providing create, get,\n//                 and delete\n// \"loggerAdapter\": a class like WinstonLoggerAdapter providing info, error,\n//                 and query\n// \"jsonLogs\": log as structured JSON objects\n// \"databaseURI\": a uri like mongodb://localhost:27017/dbname to tell us\n//          what database this Parse API connects to.\n// \"cloud\": relative location to cloud code to require, or a function\n//          that is given an instance of Parse as a parameter.  Use this instance of Parse\n//          to register your cloud code hooks and functions.\n// \"appId\": the application id to host\n// \"masterKey\": the master key for requests to this app\n// \"collectionPrefix\": optional prefix for database collection names\n// \"fileKey\": optional key from Parse dashboard for supporting older files\n//            hosted by Parse\n// \"clientKey\": optional key from Parse dashboard\n// \"dotNetKey\": optional key from Parse dashboard\n// \"restAPIKey\": optional key from Parse dashboard\n// \"webhookKey\": optional key from Parse dashboard\n// \"javascriptKey\": optional key from Parse dashboard\n// \"push\": optional key from configure push\n// \"sessionLength\": optional length in seconds for how long Sessions should be valid for\n// \"maxLimit\": optional upper bound for what can be specified for the 'limit' parameter on queries\n\nclass ParseServer {\n\n  constructor(options: ParseServerOptions) {\n    injectDefaults(options);\n    const {\n      appId = requiredParameter('You must provide an appId!'),\n      masterKey = requiredParameter('You must provide a masterKey!'),\n      cloud,\n      javascriptKey,\n      serverURL = requiredParameter('You must provide a serverURL!'),\n      __indexBuildCompletionCallbackForTests = () => {},\n    } = options;\n    // Initialize the node client SDK automatically\n    Parse.initialize(appId, javascriptKey || 'unused', masterKey);\n    Parse.serverURL = serverURL;\n\n    const allControllers = controllers.getControllers(options);\n\n    const {\n      loggerController,\n      databaseController,\n      hooksController,\n    } = allControllers;\n    this.config = Config.put(Object.assign({}, options, allControllers));\n\n    logging.setLogger(loggerController);\n    const dbInitPromise = databaseController.performInitialization();\n    hooksController.load();\n\n    // Note: Tests will start to fail if any validation happens after this is called.\n    if (process.env.TESTING) {\n      __indexBuildCompletionCallbackForTests(dbInitPromise);\n    }\n\n    if (cloud) {\n      addParseCloud();\n      if (typeof cloud === 'function') {\n        cloud(Parse)\n      } else if (typeof cloud === 'string') {\n        require(path.resolve(process.cwd(), cloud));\n      } else {\n        throw \"argument 'cloud' must either be a string or a function\";\n      }\n    }\n  }\n\n  get app() {\n    if (!this._app) {\n      this._app = ParseServer.app(this.config);\n    }\n    return this._app;\n  }\n\n  handleShutdown() {\n    const { adapter } = this.config.databaseController;\n    if (adapter && typeof adapter.handleShutdown === 'function') {\n      adapter.handleShutdown();\n    }\n  }\n\n  static app({maxUploadSize = '20mb', appId}) {\n    // This app serves the Parse API directly.\n    // It's the equivalent of https://api.parse.com/1 in the hosted Parse API.\n    var api = express();\n    //api.use(\"/apps\", express.static(__dirname + \"/public\"));\n    // File handling needs to be before default middlewares are applied\n    api.use('/', middlewares.allowCrossDomain, new FilesRouter().expressRouter({\n      maxUploadSize: maxUploadSize\n    }));\n\n    api.use('/health', (function(req, res) {\n      res.json({\n        status: 'ok'\n      });\n    }));\n\n    api.use('/', bodyParser.urlencoded({extended: false}), new PublicAPIRouter().expressRouter());\n\n    api.use(bodyParser.json({ 'type': '*/*' , limit: maxUploadSize }));\n    api.use(middlewares.allowCrossDomain);\n    api.use(middlewares.allowMethodOverride);\n    api.use(middlewares.handleParseHeaders);\n\n    const appRouter = ParseServer.promiseRouter({ appId });\n    api.use(appRouter.expressRouter());\n\n    api.use(middlewares.handleParseErrors);\n\n    // run the following when not testing\n    if (!process.env.TESTING) {\n      //This causes tests to spew some useless warnings, so disable in test\n      /* istanbul ignore next */\n      process.on('uncaughtException', (err) => {\n        if (err.code === \"EADDRINUSE\") { // user-friendly message for this common error\n          process.stderr.write(`Unable to listen on port ${err.port}. The port is already in use.`);\n          process.exit(0);\n        } else {\n          throw err;\n        }\n      });\n      // verify the server url after a 'mount' event is received\n      /* istanbul ignore next */\n      api.on('mount', function() {\n        ParseServer.verifyServerUrl();\n      });\n    }\n    if (process.env.PARSE_SERVER_ENABLE_EXPERIMENTAL_DIRECT_ACCESS === '1') {\n      Parse.CoreManager.setRESTController(ParseServerRESTController(appId, appRouter));\n    }\n    return api;\n  }\n\n  static promiseRouter({appId}) {\n    const routers = [\n      new ClassesRouter(),\n      new UsersRouter(),\n      new SessionsRouter(),\n      new RolesRouter(),\n      new AnalyticsRouter(),\n      new InstallationsRouter(),\n      new FunctionsRouter(),\n      new SchemasRouter(),\n      new PushRouter(),\n      new LogsRouter(),\n      new IAPValidationRouter(),\n      new FeaturesRouter(),\n      new GlobalConfigRouter(),\n      new PurgeRouter(),\n      new HooksRouter(),\n      new CloudCodeRouter(),\n      new AudiencesRouter(),\n      new AggregateRouter()\n    ];\n\n    const routes = routers.reduce((memo, router) => {\n      return memo.concat(router.routes);\n    }, []);\n\n    const appRouter = new PromiseRouter(routes, appId);\n\n    batch.mountOnto(appRouter);\n    return appRouter;\n  }\n\n  start(options: ParseServerOptions, callback: ?()=>void) {\n    const app = express();\n    if (options.middleware) {\n      let middleware;\n      if (typeof options.middleware == 'string') {\n        middleware = require(path.resolve(process.cwd(), options.middleware));\n      } else {\n        middleware = options.middleware; // use as-is let express fail\n      }\n      app.use(middleware);\n    }\n\n    app.use(options.mountPath, this.app);\n    const server = app.listen(options.port, options.host, callback);\n    this.server = server;\n\n    if (options.startLiveQueryServer || options.liveQueryServerOptions) {\n      this.liveQueryServer = ParseServer.createLiveQueryServer(server, options.liveQueryServerOptions);\n    }\n    /* istanbul ignore next */\n    if (!process.env.TESTING) {\n      configureListeners(this);\n    }\n    this.expressApp = app;\n    return this;\n  }\n\n  static start(options: ParseServerOptions, callback: ?()=>void) {\n    const parseServer = new ParseServer(options);\n    return parseServer.start(options, callback);\n  }\n\n  static createLiveQueryServer(httpServer, config: LiveQueryServerOptions) {\n    if (!httpServer || (config && config.port)) {\n      var app = express();\n      httpServer = require('http').createServer(app);\n      httpServer.listen(config.port);\n    }\n    return new ParseLiveQueryServer(httpServer, config);\n  }\n\n  static verifyServerUrl(callback) {\n    // perform a health check on the serverURL value\n    if(Parse.serverURL) {\n      const request = require('request');\n      request(Parse.serverURL.replace(/\\/$/, \"\") + \"/health\", function (error, response, body) {\n        let json;\n        try {\n          json = JSON.parse(body);\n        } catch(e) {\n          json = null;\n        }\n        if (error || response.statusCode !== 200 || !json || json && json.status !== 'ok') {\n          /* eslint-disable no-console */\n          console.warn(`\\nWARNING, Unable to connect to '${Parse.serverURL}'.` +\n            ` Cloud code and push notifications may be unavailable!\\n`);\n          /* eslint-enable no-console */\n          if(callback) {\n            callback(false);\n          }\n        } else {\n          if(callback) {\n            callback(true);\n          }\n        }\n      });\n    }\n  }\n}\n\nfunction addParseCloud() {\n  const ParseCloud = require(\"./cloud-code/Parse.Cloud\");\n  Object.assign(Parse.Cloud, ParseCloud);\n  global.Parse = Parse;\n}\n\nfunction injectDefaults(options: ParseServerOptions) {\n  Object.keys(defaults).forEach((key) => {\n    if (!options.hasOwnProperty(key)) {\n      options[key] = defaults[key];\n    }\n  });\n\n  if (!options.hasOwnProperty('serverURL')) {\n    options.serverURL = `http://localhost:${options.port}${options.mountPath}`;\n  }\n\n  options.userSensitiveFields = Array.from(new Set(options.userSensitiveFields.concat(\n    defaults.userSensitiveFields,\n    options.userSensitiveFields\n  )));\n\n  options.masterKeyIps = Array.from(new Set(options.masterKeyIps.concat(\n    defaults.masterKeyIps,\n    options.masterKeyIps\n  )));\n}\n\n// Those can't be tested as it requires a subprocess\n/* istanbul ignore next */\nfunction configureListeners(parseServer) {\n  const server = parseServer.server;\n  const sockets = {};\n  /* Currently, express doesn't shut down immediately after receiving SIGINT/SIGTERM if it has client connections that haven't timed out. (This is a known issue with node - https://github.com/nodejs/node/issues/2642)\n    This function, along with `destroyAliveConnections()`, intend to fix this behavior such that parse server will close all open connections and initiate the shutdown process as soon as it receives a SIGINT/SIGTERM signal. */\n  server.on('connection', (socket) => {\n    const socketId = socket.remoteAddress + ':' + socket.remotePort;\n    sockets[socketId] = socket;\n    socket.on('close', () => {\n      delete sockets[socketId];\n    });\n  });\n\n  const destroyAliveConnections = function() {\n    for (const socketId in sockets) {\n      try {\n        sockets[socketId].destroy();\n      } catch (e) { /* */ }\n    }\n  }\n\n  const handleShutdown = function() {\n    process.stdout.write('Termination signal received. Shutting down.');\n    destroyAliveConnections();\n    server.close();\n    parseServer.handleShutdown();\n  };\n  process.on('SIGTERM', handleShutdown);\n  process.on('SIGINT', handleShutdown);\n}\n\nexport default ParseServer;\n"]}
+var _default = exports.default = ParseServer;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_defaults","_interopRequireDefault","require","logging","_interopRequireWildcard","_Config","_PromiseRouter","_requiredParameter","_AnalyticsRouter","_ClassesRouter","_FeaturesRouter","_FilesRouter","_FunctionsRouter","_GlobalConfigRouter","_GraphQLRouter","_HooksRouter","_IAPValidationRouter","_InstallationsRouter","_LogsRouter","_ParseLiveQueryServer","_PagesRouter","_PublicAPIRouter","_PushRouter","_CloudCodeRouter","_RolesRouter","_SchemasRouter","_SessionsRouter","_UsersRouter","_PurgeRouter","_AudiencesRouter","_AggregateRouter","_ParseServerRESTController","controllers","_ParseGraphQLServer","_SecurityRouter","_CheckRunner","_Deprecator","_DefinedSchemas","_Definitions","_TestUtils","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","batch","express","middlewares","Parse","parse","path","fs","addParseCloud","connections","Connections","ParseServer","constructor","options","Deprecator","scanParseServerOptions","interfaces","JSON","stringify","OptionsDefinitions","getValidObject","root","result","key","prototype","type","endsWith","slice","optionsBlueprint","validateKeyNames","original","ref","name","prefix","push","res","Array","isArray","forEach","item","idx","concat","diff","length","logger","error","join","injectDefaults","appId","requiredParameter","masterKey","javascriptKey","serverURL","initialize","Config","validateOptions","allControllers","getControllers","state","config","put","assign","masterKeyIpsStore","Map","maintenanceKeyIpsStore","setLogger","loggerController","start","databaseController","hooksController","cacheController","cloud","security","schema","liveQueryController","performInitialization","code","Error","DUPLICATE_VALUE","pushController","getPushController","load","startupPromises","loadMasterKey","DefinedSchemas","execute","adapter","connect","Promise","all","resolve","json","process","env","npm_package_json","npm_package_type","cwd","setTimeout","enableCheck","enableCheckLog","CheckRunner","run","console","app","_app","handleShutdown","serverClosePromise","resolvingPromise","liveQueryServerClosePromise","promises","server","close","liveQueryServer","databaseAdapter","fileAdapter","filesController","cacheAdapter","shutdown","destroyAll","serverCloseComplete","applyRequestContextMiddleware","api","requestContextMiddleware","use","maxUploadSize","directAccess","pages","rateLimit","allowCrossDomain","allowDoubleForwardSlash","FilesRouter","expressRouter","req","status","urlencoded","extended","enableRouter","PagesRouter","PublicAPIRouter","limit","allowMethodOverride","handleParseHeaders","routes","route","addRateLimit","handleParseSession","appRouter","promiseRouter","handleParseErrors","TESTING","on","err","stderr","write","port","exit","message","stack","PARSE_SERVER_ENABLE_EXPERIMENTAL_DIRECT_ACCESS","CoreManager","setRESTController","ParseServerRESTController","routers","ClassesRouter","UsersRouter","SessionsRouter","RolesRouter","AnalyticsRouter","InstallationsRouter","FunctionsRouter","SchemasRouter","PushRouter","LogsRouter","IAPValidationRouter","FeaturesRouter","GlobalConfigRouter","GraphQLRouter","PurgeRouter","HooksRouter","CloudCodeRouter","AudiencesRouter","AggregateRouter","SecurityRouter","reduce","memo","router","PromiseRouter","mountOnto","startApp","middleware","mountPath","mountGraphQL","mountPlayground","graphQLCustomTypeDefs","undefined","graphQLSchema","readFileSync","parseGraphQLServer","ParseGraphQLServer","graphQLPath","playgroundPath","applyGraphQL","applyPlayground","listen","host","track","startLiveQueryServer","liveQueryServerOptions","createLiveQueryServer","trustProxy","configureListeners","verifyServerUrl","expressApp","parseServer","httpServer","createServer","ParseLiveQueryServer","isValidHttpUrl","string","url","URL","_","protocol","replace","warn","request","response","catch","data","retry","headers","ParseCloud","conf","applicationId","newVal","configurable","Cloud","global","keys","defaults","regex","match","userSensitiveFields","from","Set","protectedFields","_User","c","cur","unq","stdout","_default","exports"],"sources":["../src/ParseServer.ts"],"sourcesContent":["// ParseServer - open-source compatible API Server for Parse apps\n\nvar batch = require('./batch'),\n  express = require('express'),\n  middlewares = require('./middlewares'),\n  Parse = require('parse/node').Parse,\n  { parse } = require('graphql'),\n  path = require('path'),\n  fs = require('fs');\n\nimport { ParseServerOptions, LiveQueryServerOptions } from './Options';\nimport defaults from './defaults';\nimport * as logging from './logger';\nimport Config from './Config';\nimport PromiseRouter from './PromiseRouter';\nimport requiredParameter from './requiredParameter';\nimport { AnalyticsRouter } from './Routers/AnalyticsRouter';\nimport { ClassesRouter } from './Routers/ClassesRouter';\nimport { FeaturesRouter } from './Routers/FeaturesRouter';\nimport { FilesRouter } from './Routers/FilesRouter';\nimport { FunctionsRouter } from './Routers/FunctionsRouter';\nimport { GlobalConfigRouter } from './Routers/GlobalConfigRouter';\nimport { GraphQLRouter } from './Routers/GraphQLRouter';\nimport { HooksRouter } from './Routers/HooksRouter';\nimport { IAPValidationRouter } from './Routers/IAPValidationRouter';\nimport { InstallationsRouter } from './Routers/InstallationsRouter';\nimport { LogsRouter } from './Routers/LogsRouter';\nimport { ParseLiveQueryServer } from './LiveQuery/ParseLiveQueryServer';\nimport { PagesRouter } from './Routers/PagesRouter';\nimport { PublicAPIRouter } from './Routers/PublicAPIRouter';\nimport { PushRouter } from './Routers/PushRouter';\nimport { CloudCodeRouter } from './Routers/CloudCodeRouter';\nimport { RolesRouter } from './Routers/RolesRouter';\nimport { SchemasRouter } from './Routers/SchemasRouter';\nimport { SessionsRouter } from './Routers/SessionsRouter';\nimport { UsersRouter } from './Routers/UsersRouter';\nimport { PurgeRouter } from './Routers/PurgeRouter';\nimport { AudiencesRouter } from './Routers/AudiencesRouter';\nimport { AggregateRouter } from './Routers/AggregateRouter';\nimport { ParseServerRESTController } from './ParseServerRESTController';\nimport * as controllers from './Controllers';\nimport { ParseGraphQLServer } from './GraphQL/ParseGraphQLServer';\nimport { SecurityRouter } from './Routers/SecurityRouter';\nimport CheckRunner from './Security/CheckRunner';\nimport Deprecator from './Deprecator/Deprecator';\nimport { DefinedSchemas } from './SchemaMigrations/DefinedSchemas';\nimport OptionsDefinitions from './Options/Definitions';\nimport { resolvingPromise, Connections } from './TestUtils';\n\n// Mutate the Parse object to add the Cloud Code handlers\naddParseCloud();\n\n// Track connections to destroy them on shutdown\nconst connections = new Connections();\n\n// ParseServer works like a constructor of an express app.\n// https://parseplatform.org/parse-server/api/master/ParseServerOptions.html\nclass ParseServer {\n  _app: any;\n  config: any;\n  server: any;\n  expressApp: any;\n  liveQueryServer: any;\n  /**\n   * @constructor\n   * @param {ParseServerOptions} options the parse server initialization options\n   */\n  constructor(options: ParseServerOptions) {\n    // Scan for deprecated Parse Server options\n    Deprecator.scanParseServerOptions(options);\n\n    const interfaces = JSON.parse(JSON.stringify(OptionsDefinitions));\n\n    function getValidObject(root) {\n      const result = {};\n      for (const key in root) {\n        if (Object.prototype.hasOwnProperty.call(root[key], 'type')) {\n          if (root[key].type.endsWith('[]')) {\n            result[key] = [getValidObject(interfaces[root[key].type.slice(0, -2)])];\n          } else {\n            result[key] = getValidObject(interfaces[root[key].type]);\n          }\n        } else {\n          result[key] = '';\n        }\n      }\n      return result;\n    }\n\n    const optionsBlueprint = getValidObject(interfaces['ParseServerOptions']);\n\n    function validateKeyNames(original, ref, name = '') {\n      let result = [];\n      const prefix = name + (name !== '' ? '.' : '');\n      for (const key in original) {\n        if (!Object.prototype.hasOwnProperty.call(ref, key)) {\n          result.push(prefix + key);\n        } else {\n          if (ref[key] === '') { continue; }\n          let res = [];\n          if (Array.isArray(original[key]) && Array.isArray(ref[key])) {\n            const type = ref[key][0];\n            original[key].forEach((item, idx) => {\n              if (typeof item === 'object' && item !== null) {\n                res = res.concat(validateKeyNames(item, type, prefix + key + `[${idx}]`));\n              }\n            });\n          } else if (typeof original[key] === 'object' && typeof ref[key] === 'object') {\n            res = validateKeyNames(original[key], ref[key], prefix + key);\n          }\n          result = result.concat(res);\n        }\n      }\n      return result;\n    }\n\n    const diff = validateKeyNames(options, optionsBlueprint);\n    if (diff.length > 0) {\n      const logger = (logging as any).logger;\n      logger.error(`Invalid key(s) found in Parse Server configuration: ${diff.join(', ')}`);\n    }\n\n    // Set option defaults\n    injectDefaults(options);\n    const {\n      appId = requiredParameter('You must provide an appId!'),\n      masterKey = requiredParameter('You must provide a masterKey!'),\n      javascriptKey,\n      serverURL = requiredParameter('You must provide a serverURL!'),\n    } = options;\n    // Initialize the node client SDK automatically\n    Parse.initialize(appId, javascriptKey || 'unused', masterKey);\n    Parse.serverURL = serverURL;\n    Config.validateOptions(options);\n    const allControllers = controllers.getControllers(options);\n\n    (options as any).state = 'initialized';\n    this.config = Config.put(Object.assign({}, options, allControllers));\n    this.config.masterKeyIpsStore = new Map();\n    this.config.maintenanceKeyIpsStore = new Map();\n    logging.setLogger(allControllers.loggerController);\n  }\n\n  /**\n   * Starts Parse Server as an express app; this promise resolves when Parse Server is ready to accept requests.\n   */\n\n  async start(): Promise<this> {\n    try {\n      if (this.config.state === 'ok') {\n        return this;\n      }\n      this.config.state = 'starting';\n      Config.put(this.config);\n      const {\n        databaseController,\n        hooksController,\n        cacheController,\n        cloud,\n        security,\n        schema,\n        liveQueryController,\n      } = this.config;\n      try {\n        await databaseController.performInitialization();\n      } catch (e) {\n        if (e.code !== Parse.Error.DUPLICATE_VALUE) {\n          throw e;\n        }\n      }\n      const pushController = await controllers.getPushController(this.config);\n      await hooksController.load();\n      const startupPromises = [this.config.loadMasterKey?.()];\n      if (schema) {\n        startupPromises.push(new DefinedSchemas(schema, this.config).execute());\n      }\n      if (\n        cacheController.adapter?.connect &&\n        typeof cacheController.adapter.connect === 'function'\n      ) {\n        startupPromises.push(cacheController.adapter.connect());\n      }\n      startupPromises.push(liveQueryController.connect());\n      await Promise.all(startupPromises);\n      if (cloud) {\n        addParseCloud();\n        if (typeof cloud === 'function') {\n          await Promise.resolve(cloud(Parse));\n        } else if (typeof cloud === 'string') {\n          let json;\n          if (process.env.npm_package_json) {\n            json = require(process.env.npm_package_json);\n          }\n          if (process.env.npm_package_type === 'module' || json?.type === 'module') {\n            await import(path.resolve(process.cwd(), cloud));\n          } else {\n            require(path.resolve(process.cwd(), cloud));\n          }\n        } else {\n          throw \"argument 'cloud' must either be a string or a function\";\n        }\n        await new Promise(resolve => setTimeout(resolve, 10));\n      }\n      if (security && security.enableCheck && security.enableCheckLog) {\n        new CheckRunner(security).run();\n      }\n      this.config.state = 'ok';\n      this.config = { ...this.config, ...pushController };\n      Config.put(this.config);\n      return this;\n    } catch (error) {\n      // eslint-disable-next-line no-console\n      console.error(error);\n      this.config.state = 'error';\n      throw error;\n    }\n  }\n\n  get app() {\n    if (!this._app) {\n      this._app = ParseServer.app(this.config);\n    }\n    return this._app;\n  }\n\n  /**\n   * Stops the parse server, cancels any ongoing requests and closes all connections.\n   *\n   * Currently, express doesn't shut down immediately after receiving SIGINT/SIGTERM\n   * if it has client connections that haven't timed out.\n   * (This is a known issue with node - https://github.com/nodejs/node/issues/2642)\n   *\n   * @returns {Promise<void>} a promise that resolves when the server is stopped\n   */\n  async handleShutdown() {\n    const serverClosePromise = resolvingPromise();\n    const liveQueryServerClosePromise = resolvingPromise();\n    const promises = [];\n    this.server.close((error) => {\n      /* istanbul ignore next */\n      if (error) {\n        // eslint-disable-next-line no-console\n        console.error('Error while closing parse server', error);\n      }\n      serverClosePromise.resolve();\n    });\n    if (this.liveQueryServer?.server?.close && this.liveQueryServer.server !== this.server) {\n      this.liveQueryServer.server.close((error) => {\n        /* istanbul ignore next */\n        if (error) {\n          // eslint-disable-next-line no-console\n          console.error('Error while closing live query server', error);\n        }\n        liveQueryServerClosePromise.resolve();\n      });\n    } else {\n      liveQueryServerClosePromise.resolve();\n    }\n    const { adapter: databaseAdapter } = this.config.databaseController;\n    if (databaseAdapter && typeof databaseAdapter.handleShutdown === 'function') {\n      promises.push(databaseAdapter.handleShutdown());\n    }\n    const { adapter: fileAdapter } = this.config.filesController;\n    if (fileAdapter && typeof fileAdapter.handleShutdown === 'function') {\n      promises.push(fileAdapter.handleShutdown());\n    }\n    const { adapter: cacheAdapter } = this.config.cacheController;\n    if (cacheAdapter && typeof cacheAdapter.handleShutdown === 'function') {\n      promises.push(cacheAdapter.handleShutdown());\n    }\n    if (this.liveQueryServer) {\n      promises.push(this.liveQueryServer.shutdown());\n    }\n    await Promise.all(promises);\n    connections.destroyAll();\n    await Promise.all([serverClosePromise, liveQueryServerClosePromise]);\n    if (this.config.serverCloseComplete) {\n      this.config.serverCloseComplete();\n    }\n  }\n\n  /**\n   * @static\n   * Allow developers to customize each request with inversion of control/dependency injection\n   */\n  static applyRequestContextMiddleware(api, options) {\n    if (options.requestContextMiddleware) {\n      if (typeof options.requestContextMiddleware !== 'function') {\n        throw new Error('requestContextMiddleware must be a function');\n      }\n      api.use(options.requestContextMiddleware);\n    }\n  }\n  /**\n   * @static\n   * Create an express app for the parse server\n   * @param {Object} options let you specify the maxUploadSize when creating the express app  */\n  static app(options) {\n    const {\n      maxUploadSize = '20mb',\n      appId,\n      directAccess,\n      pages,\n      rateLimit = [],\n    } = options;\n    // This app serves the Parse API directly.\n    // It's the equivalent of https://api.parse.com/1 in the hosted Parse API.\n    var api = express();\n    //api.use(\"/apps\", express.static(__dirname + \"/public\"));\n    api.use(middlewares.allowCrossDomain(appId));\n    api.use(middlewares.allowDoubleForwardSlash);\n    // File handling needs to be before default middlewares are applied\n    api.use(\n      '/',\n      new FilesRouter().expressRouter({\n        maxUploadSize: maxUploadSize,\n      })\n    );\n\n    api.use('/health', function (req, res) {\n      res.status(options.state === 'ok' ? 200 : 503);\n      if (options.state === 'starting') {\n        res.set('Retry-After', 1);\n      }\n      res.json({\n        status: options.state,\n      });\n    });\n\n    api.use(\n      '/',\n      express.urlencoded({ extended: false }),\n      pages.enableRouter\n        ? new PagesRouter(pages).expressRouter()\n        : new PublicAPIRouter().expressRouter()\n    );\n\n    api.use(express.json({ type: '*/*', limit: maxUploadSize }));\n    api.use(middlewares.allowMethodOverride);\n    api.use(middlewares.handleParseHeaders);\n    api.set('query parser', 'extended');\n    const routes = Array.isArray(rateLimit) ? rateLimit : [rateLimit];\n    for (const route of routes) {\n      middlewares.addRateLimit(route, options);\n    }\n    api.use(middlewares.handleParseSession);\n    this.applyRequestContextMiddleware(api, options);\n    const appRouter = ParseServer.promiseRouter({ appId });\n    api.use(appRouter.expressRouter());\n\n    api.use(middlewares.handleParseErrors);\n\n    // run the following when not testing\n    if (!process.env.TESTING) {\n      //This causes tests to spew some useless warnings, so disable in test\n      /* istanbul ignore next */\n      process.on('uncaughtException', (err: any) => {\n        if (err.code === 'EADDRINUSE') {\n          // user-friendly message for this common error\n          process.stderr.write(`Unable to listen on port ${err.port}. The port is already in use.`);\n          process.exit(0);\n        } else {\n          if (err.message) {\n            process.stderr.write('An uncaught exception occurred: ' + err.message);\n          }\n          if (err.stack) {\n            process.stderr.write('Stack Trace:\\n' + err.stack);\n          } else {\n            process.stderr.write(err);\n          }\n          process.exit(1);\n        }\n      });\n    }\n    if (process.env.PARSE_SERVER_ENABLE_EXPERIMENTAL_DIRECT_ACCESS === '1' || directAccess) {\n      Parse.CoreManager.setRESTController(ParseServerRESTController(appId, appRouter));\n    }\n    return api;\n  }\n\n  static promiseRouter({ appId }) {\n    const routers = [\n      new ClassesRouter(),\n      new UsersRouter(),\n      new SessionsRouter(),\n      new RolesRouter(),\n      new AnalyticsRouter(),\n      new InstallationsRouter(),\n      new FunctionsRouter(),\n      new SchemasRouter(),\n      new PushRouter(),\n      new LogsRouter(),\n      new IAPValidationRouter(),\n      new FeaturesRouter(),\n      new GlobalConfigRouter(),\n      new GraphQLRouter(),\n      new PurgeRouter(),\n      new HooksRouter(),\n      new CloudCodeRouter(),\n      new AudiencesRouter(),\n      new AggregateRouter(),\n      new SecurityRouter(),\n    ];\n\n    const routes = routers.reduce((memo, router) => {\n      return memo.concat(router.routes);\n    }, []);\n\n    const appRouter = new PromiseRouter(routes, appId);\n\n    batch.mountOnto(appRouter);\n    return appRouter;\n  }\n\n  /**\n   * starts the parse server's express app\n   * @param {ParseServerOptions} options to use to start the server\n   * @returns {ParseServer} the parse server instance\n   */\n\n  async startApp(options: ParseServerOptions) {\n    try {\n      await this.start();\n    } catch (e) {\n      // eslint-disable-next-line no-console\n      console.error('Error on ParseServer.startApp: ', e);\n      throw e;\n    }\n    const app = express();\n    if (options.middleware) {\n      let middleware;\n      if (typeof options.middleware == 'string') {\n        middleware = require(path.resolve(process.cwd(), options.middleware));\n      } else {\n        middleware = options.middleware; // use as-is let express fail\n      }\n      app.use(middleware);\n    }\n    app.use(options.mountPath, this.app);\n\n    if (options.mountGraphQL === true || options.mountPlayground === true) {\n      let graphQLCustomTypeDefs = undefined;\n      if (typeof options.graphQLSchema === 'string') {\n        graphQLCustomTypeDefs = parse(fs.readFileSync(options.graphQLSchema, 'utf8'));\n      } else if (\n        typeof options.graphQLSchema === 'object' ||\n        typeof options.graphQLSchema === 'function'\n      ) {\n        graphQLCustomTypeDefs = options.graphQLSchema;\n      }\n\n      const parseGraphQLServer = new ParseGraphQLServer(this, {\n        graphQLPath: options.graphQLPath,\n        playgroundPath: options.playgroundPath,\n        graphQLCustomTypeDefs,\n      });\n\n      if (options.mountGraphQL) {\n        parseGraphQLServer.applyGraphQL(app);\n      }\n\n      if (options.mountPlayground) {\n        parseGraphQLServer.applyPlayground(app);\n      }\n    }\n    const server = await new Promise(resolve => {\n      app.listen(options.port, options.host, function () {\n        resolve(this);\n      });\n    });\n    this.server = server;\n    connections.track(server);\n\n    if (options.startLiveQueryServer || options.liveQueryServerOptions) {\n      this.liveQueryServer = await ParseServer.createLiveQueryServer(\n        server,\n        options.liveQueryServerOptions,\n        options\n      );\n      if (this.liveQueryServer.server !== this.server) {\n        connections.track(this.liveQueryServer.server);\n      }\n    }\n    if (options.trustProxy) {\n      app.set('trust proxy', options.trustProxy);\n    }\n    /* istanbul ignore next */\n    if (!process.env.TESTING) {\n      configureListeners(this);\n      if (options.verifyServerUrl !== false) {\n        await ParseServer.verifyServerUrl();\n      }\n    }\n    this.expressApp = app;\n    return this;\n  }\n\n  /**\n   * Creates a new ParseServer and starts it.\n   * @param {ParseServerOptions} options used to start the server\n   * @returns {ParseServer} the parse server instance\n   */\n  static async startApp(options: ParseServerOptions) {\n    const parseServer = new ParseServer(options);\n    return parseServer.startApp(options);\n  }\n\n  /**\n   * Helper method to create a liveQuery server\n   * @static\n   * @param {Server} httpServer an optional http server to pass\n   * @param {LiveQueryServerOptions} config options for the liveQueryServer\n   * @param {ParseServerOptions} options options for the ParseServer\n   * @returns {Promise<ParseLiveQueryServer>} the live query server instance\n   */\n  static async createLiveQueryServer(\n    httpServer,\n    config: LiveQueryServerOptions,\n    options: ParseServerOptions\n  ): Promise<ParseLiveQueryServer> {\n    if (!httpServer || (config && config.port)) {\n      var app = express();\n      httpServer = require('http').createServer(app);\n      httpServer.listen(config.port);\n    }\n    const server = new ParseLiveQueryServer(httpServer, config, options);\n    await server.connect();\n    return server;\n  }\n\n  static async verifyServerUrl() {\n    // perform a health check on the serverURL value\n    if (Parse.serverURL) {\n      const isValidHttpUrl = string => {\n        let url;\n        try {\n          url = new URL(string);\n        } catch (_) {\n          return false;\n        }\n        return url.protocol === 'http:' || url.protocol === 'https:';\n      };\n      const url = `${Parse.serverURL.replace(/\\/$/, '')}/health`;\n      if (!isValidHttpUrl(url)) {\n        // eslint-disable-next-line no-console\n        console.warn(\n          `\\nWARNING, Unable to connect to '${Parse.serverURL}' as the URL is invalid.` +\n            ` Cloud code and push notifications may be unavailable!\\n`\n        );\n        return;\n      }\n      const request = require('./request');\n      const response = await request({ url }).catch(response => response);\n      const json = response.data || null;\n      const retry = response.headers?.['retry-after'];\n      if (retry) {\n        await new Promise(resolve => setTimeout(resolve, retry * 1000));\n        return this.verifyServerUrl();\n      }\n      if (response.status !== 200 || json?.status !== 'ok') {\n        /* eslint-disable no-console */\n        console.warn(\n          `\\nWARNING, Unable to connect to '${Parse.serverURL}'.` +\n            ` Cloud code and push notifications may be unavailable!\\n`\n        );\n        /* eslint-enable no-console */\n        return;\n      }\n      return true;\n    }\n  }\n}\n\nfunction addParseCloud() {\n  const ParseCloud = require('./cloud-code/Parse.Cloud');\n  const ParseServer = require('./cloud-code/Parse.Server');\n  Object.defineProperty(Parse, 'Server', {\n    get() {\n      const conf = Config.get(Parse.applicationId);\n      return { ...conf, ...ParseServer };\n    },\n    set(newVal) {\n      newVal.appId = Parse.applicationId;\n      Config.put(newVal);\n    },\n    configurable: true,\n  });\n  Object.assign(Parse.Cloud, ParseCloud);\n  global.Parse = Parse;\n}\n\nfunction injectDefaults(options: ParseServerOptions) {\n  Object.keys(defaults).forEach(key => {\n    if (!Object.prototype.hasOwnProperty.call(options, key)) {\n      options[key] = defaults[key];\n    }\n  });\n\n  if (!Object.prototype.hasOwnProperty.call(options, 'serverURL')) {\n    options.serverURL = `http://localhost:${options.port}${options.mountPath}`;\n  }\n\n  // Reserved Characters\n  if (options.appId) {\n    const regex = /[!#$%'()*+&/:;=?@[\\]{}^,|<>]/g;\n    if (options.appId.match(regex)) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        `\\nWARNING, appId that contains special characters can cause issues while using with urls.\\n`\n      );\n    }\n  }\n\n  // Backwards compatibility\n  if (options.userSensitiveFields) {\n    /* eslint-disable no-console */\n    !process.env.TESTING &&\n      console.warn(\n        `\\nDEPRECATED: userSensitiveFields has been replaced by protectedFields allowing the ability to protect fields in all classes with CLP. \\n`\n      );\n    /* eslint-enable no-console */\n\n    const userSensitiveFields = Array.from(\n      new Set([...(defaults.userSensitiveFields || []), ...(options.userSensitiveFields || [])])\n    );\n\n    // If the options.protectedFields is unset,\n    // it'll be assigned the default above.\n    // Here, protect against the case where protectedFields\n    // is set, but doesn't have _User.\n    if (!('_User' in options.protectedFields)) {\n      options.protectedFields = Object.assign({ _User: [] }, options.protectedFields);\n    }\n\n    options.protectedFields['_User']['*'] = Array.from(\n      new Set([...(options.protectedFields['_User']['*'] || []), ...userSensitiveFields])\n    );\n  }\n\n  // Merge protectedFields options with defaults.\n  Object.keys(defaults.protectedFields).forEach(c => {\n    const cur = options.protectedFields[c];\n    if (!cur) {\n      options.protectedFields[c] = defaults.protectedFields[c];\n    } else {\n      Object.keys(defaults.protectedFields[c]).forEach(r => {\n        const unq = new Set([\n          ...(options.protectedFields[c][r] || []),\n          ...defaults.protectedFields[c][r],\n        ]);\n        options.protectedFields[c][r] = Array.from(unq);\n      });\n    }\n  });\n}\n\n// Those can't be tested as it requires a subprocess\n/* istanbul ignore next */\nfunction configureListeners(parseServer) {\n  const handleShutdown = function () {\n    process.stdout.write('Termination signal received. Shutting down.');\n    parseServer.handleShutdown();\n  };\n  process.on('SIGTERM', handleShutdown);\n  process.on('SIGINT', handleShutdown);\n}\n\nexport default ParseServer;\n"],"mappings":"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","ignoreList":[]}