feat: Asynchronous initialization of Parse Server

.babelrc

@@ -7,7 +7,8 @@
         ["@babel/preset-env", {
             "targets": {
                 "node": "12"
-            }
+            },
+            "exclude": ["proposal-dynamic-import"]
         }]
     ],
     "sourceMaps": "inline"

spec/CloudCode.spec.js

@@ -1,6 +1,7 @@
 'use strict';
 const Config = require('../lib/Config');
 const Parse = require('parse/node');
+const ParseServer = require('../lib/index').ParseServer;
 const request = require('../lib/request');
 const InMemoryCacheAdapter = require('../lib/Adapters/Cache/InMemoryCacheAdapter')
   .InMemoryCacheAdapter;
@@ -39,6 +40,46 @@ describe('Cloud Code', () => {
     });
   });
 
+  it('can load cloud code as a module', async () => {
+    process.env.npm_package_type = 'module';
+    await reconfigureServer({ cloud: './spec/cloud/cloudCodeModuleFile.js' });
+    const result = await Parse.Cloud.run('cloudCodeInFile');
+    expect(result).toEqual('It is possible to define cloud code in a file.');
+    delete process.env.npm_package_type;
+  });
+
+  it('cloud code must be valid type', async () => {
+    await expectAsync(reconfigureServer({ cloud: true })).toBeRejectedWith(
+      "argument 'cloud' must either be a string or a function"
+    );
+  });
+
+  it('should wait for cloud code to load', async () => {
+    const initiated = new Date();
+    const parseServer = await new ParseServer({
+      appId: 'test2',
+      masterKey: 'abc',
+      serverURL: 'http://localhost:12668/parse',
+      async cloud() {
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        Parse.Cloud.beforeSave('Test', () => {
+          throw 'Cannot save.';
+        });
+      },
+    }).start();
+    const express = require('express');
+    const app = express();
+    app.use('/parse', parseServer);
+    const server = app.listen(12668);
+
+    const now = new Date();
+    expect(now.getTime() - initiated.getTime() > 1000).toBeTrue();
+    await expectAsync(new Parse.Object('Test').save()).toBeRejectedWith(
+      new Parse.Error(141, 'Cannot save.')
+    );
+    await new Promise(resolve => server.close(resolve));
+  });
+
   it('can create functions', done => {
     Parse.Cloud.define('hello', () => {
       return 'Hello world!';

spec/DefinedSchemas.spec.js

@@ -631,7 +631,7 @@ describe('DefinedSchemas', () => {
     const logger = require('../lib/logger').logger;
     spyOn(DefinedSchemas.prototype, 'wait').and.resolveTo();
     spyOn(logger, 'error').and.callThrough();
-    spyOn(Parse.Schema, 'all').and.callFake(() => {
+    spyOn(DefinedSchemas.prototype, 'createDeleteSession').and.callFake(() => {
       throw error;
     });
 

spec/ParseLiveQueryServer.spec.js

@@ -115,8 +115,8 @@ describe('ParseLiveQueryServer', function () {
   });
 
   describe_only_db('mongo')('initialization', () => {
-    it('can be initialized through ParseServer without liveQueryServerOptions', function (done) {
-      const parseServer = ParseServer.start({
+    it('can be initialized through ParseServer without liveQueryServerOptions', async () => {
+      const parseServer = await ParseServer.start({
         appId: 'hello',
         masterKey: 'world',
         port: 22345,
@@ -126,19 +126,14 @@ describe('ParseLiveQueryServer', function () {
           classNames: ['Yolo'],
         },
         startLiveQueryServer: true,
-        serverStartComplete: () => {
-          expect(parseServer.liveQueryServer).not.toBeUndefined();
-          expect(parseServer.liveQueryServer.server).toBe(parseServer.server);
-          parseServer.server.close(async () => {
-            await reconfigureServer();
-            done();
-          });
-        },
       });
+      expect(parseServer.liveQueryServer).not.toBeUndefined();
+      expect(parseServer.liveQueryServer.server).toBe(parseServer.server);
+      await new Promise(resolve => parseServer.server.close(resolve));
     });
 
-    it('can be initialized through ParseServer with liveQueryServerOptions', function (done) {
-      const parseServer = ParseServer.start({
+    it('can be initialized through ParseServer with liveQueryServerOptions', async () => {
+      const parseServer = await ParseServer.start({
         appId: 'hello',
         masterKey: 'world',
         port: 22346,
@@ -150,17 +145,10 @@ describe('ParseLiveQueryServer', function () {
         liveQueryServerOptions: {
           port: 22347,
         },
-        serverStartComplete: () => {
-          expect(parseServer.liveQueryServer).not.toBeUndefined();
-          expect(parseServer.liveQueryServer.server).not.toBe(parseServer.server);
-          parseServer.liveQueryServer.server.close(
-            parseServer.server.close.bind(parseServer.server, async () => {
-              await reconfigureServer();
-              done();
-            })
-          );
-        },
       });
+      expect(parseServer.liveQueryServer).not.toBeUndefined();
+      expect(parseServer.liveQueryServer.server).not.toBe(parseServer.server);
+      await new Promise(resolve => parseServer.server.close(resolve));
     });
   });
 

spec/cloud/cloudCodeModuleFile.js

@@ -0,0 +1,3 @@
+Parse.Cloud.define('cloudCodeInFile', () => {
+  return 'It is possible to define cloud code in a file.';
+});

spec/helper.js

@@ -148,47 +148,37 @@ let server;
 let didChangeConfiguration = false;
 
 // Allows testing specific configurations of Parse Server
-const reconfigureServer = (changedConfiguration = {}) => {
-  return new Promise((resolve, reject) => {
-    if (server) {
-      return server.close(() => {
-        server = undefined;
-        reconfigureServer(changedConfiguration).then(resolve, reject);
-      });
-    }
-    try {
-      let parseServer = undefined;
-      didChangeConfiguration = Object.keys(changedConfiguration).length !== 0;
-      const newConfiguration = Object.assign({}, defaultConfiguration, changedConfiguration, {
-        serverStartComplete: error => {
-          if (error) {
-            reject(error);
-          } else {
-            Parse.CoreManager.setRESTController(RESTController);
-            resolve(parseServer);
-          }
-        },
-        mountPath: '/1',
-        port,
-      });
-      cache.clear();
-      parseServer = ParseServer.start(newConfiguration);
-      parseServer.expressApp.use('/1', err => {
-        console.error(err);
-        fail('should not call next');
-      });
-      server = parseServer.server;
-      server.on('connection', connection => {
-        const key = `${connection.remoteAddress}:${connection.remotePort}`;
-        openConnections[key] = connection;
-        connection.on('close', () => {
-          delete openConnections[key];
-        });
-      });
-    } catch (error) {
-      reject(error);
-    }
+const reconfigureServer = async (changedConfiguration = {}) => {
+  if (server) {
+    await new Promise(resolve => server.close(resolve));
+    server = undefined;
+    return reconfigureServer(changedConfiguration);
+  }
+  didChangeConfiguration = Object.keys(changedConfiguration).length !== 0;
+  const newConfiguration = Object.assign({}, defaultConfiguration, changedConfiguration, {
+    mountPath: '/1',
+    port,
+  });
+  cache.clear();
+  const { parseServer, error } = await ParseServer.start(newConfiguration);
+  server = parseServer.server;
+  if (error) {
+    throw error;
+  }
+
+  Parse.CoreManager.setRESTController(RESTController);
+  parseServer.expressApp.use('/1', err => {
+    console.error(err);
+    fail('should not call next');
+  });
+  server.on('connection', connection => {
+    const key = `${connection.remoteAddress}:${connection.remotePort}`;
+    openConnections[key] = connection;
+    connection.on('close', () => {
+      delete openConnections[key];
+    });
   });
+  return parseServer;
 };
 
 // Set up a Parse client to talk to our test API server