feat: Allow setting custom queue for handling offline operations via …

…`Parse.EventuallyQueue` (#2106)

src/CoreManager.js

@@ -6,7 +6,7 @@ import type { AttributeMap, ObjectCache, OpsMap, State } from './ObjectStateMuta
 import type ParseFile from './ParseFile';
 import type { FileSource } from './ParseFile';
 import type { Op } from './ParseOp';
-import type ParseObject from './ParseObject';
+import type ParseObject, {SaveOptions} from './ParseObject';
 import type { QueryJSON } from './ParseQuery';
 import type ParseUser from './ParseUser';
 import type { AuthData } from './ParseUser';
@@ -73,6 +73,11 @@ type QueryController = {
   find: (className: string, params: QueryJSON, options: RequestOptions) => Promise,
   aggregate: (className: string, params: any, options: RequestOptions) => Promise,
 };
+type EventuallyQueue = {
+  save: (object: ParseObject, serverOptions: SaveOptions) => Promise,
+  destroy: (object: ParseObject, serverOptions: RequestOptions) => Promise,
+  poll: (ms: number) => void
+};
 type RESTController = {
   request: (method: string, path: string, data: mixed, options: RequestOptions) => Promise,
   ajax: (method: string, url: string, data: any, headers?: any, options: FullOptions) => Promise,
@@ -363,6 +368,15 @@ const CoreManager = {
     return config['RESTController'];
   },
 
+  setEventuallyQueue(controller: EventuallyQueue) {
+    requireMethods('EventuallyQueue', ['poll', 'save', 'destroy'], controller);
+    config['EventuallyQueue'] = controller;
+  },
+
+  getEventuallyQueue(): EventuallyQueue {
+    return config['EventuallyQueue'];
+  },
+
   setSchemaController(controller: SchemaController) {
     requireMethods(
       'SchemaController',

src/Parse.ts

@@ -123,7 +123,6 @@ const Parse: ParseType = {
   CoreManager:  CoreManager,
   Config:  Config,
   Error:  ParseError,
-  EventuallyQueue:  EventuallyQueue,
   FacebookUtils: FacebookUtils,
   File:  File,
   GeoPoint:  GeoPoint,
@@ -153,6 +152,18 @@ const Parse: ParseType = {
   Hooks: undefined,
   Parse: undefined,
 
+  /**
+   * @member {EventuallyQueue} Parse.EventuallyQueue
+   * @static
+   */
+  set EventuallyQueue(queue: EventuallyQueue) {
+    CoreManager.setEventuallyQueue(queue);
+  },
+
+  get EventuallyQueue() {
+    return CoreManager.getEventuallyQueue();
+  },
+
   /**
    * Call this method first to set up your authentication tokens for Parse.
    *
@@ -189,6 +200,8 @@ const Parse: ParseType = {
     CoreManager.setIfNeeded('StorageController', StorageController);
     CoreManager.setIfNeeded('WebSocketController', WebSocketController);
 
+    CoreManager.setIfNeeded('EventuallyQueue', EventuallyQueue);
+
     if (process.env.PARSE_BUILD === 'browser') {
       Parse.IndexedDB = CoreManager.setIfNeeded('IndexedDBStorageController', IndexedDBStorageController);
     }
@@ -395,7 +408,7 @@ const Parse: ParseType = {
     if (!this.LocalDatastore.isEnabled) {
       this.LocalDatastore.isEnabled = true;
       if (polling) {
-        EventuallyQueue.poll(ms);
+        CoreManager.getEventuallyQueue().poll(ms);
       }
     }
   },

src/ParseObject.js

@@ -7,7 +7,6 @@ import canBeSerialized from './canBeSerialized';
 import decode from './decode';
 import encode from './encode';
 import escape from './escape';
-import EventuallyQueue from './EventuallyQueue';
 import ParseACL from './ParseACL';
 import parseDate from './parseDate';
 import ParseError from './ParseError';
@@ -1220,8 +1219,8 @@ class ParseObject {
       await this.save(null, options);
     } catch (e) {
       if (e.code === ParseError.CONNECTION_FAILED) {
-        await EventuallyQueue.save(this, options);
-        EventuallyQueue.poll();
+        await CoreManager.getEventuallyQueue().save(this, options);
+        CoreManager.getEventuallyQueue().poll();
       }
     }
     return this;
@@ -1366,8 +1365,8 @@ class ParseObject {
       await this.destroy(options);
     } catch (e) {
       if (e.code === ParseError.CONNECTION_FAILED) {
-        await EventuallyQueue.destroy(this, options);
-        EventuallyQueue.poll();
+        await CoreManager.getEventuallyQueue().destroy(this, options);
+        CoreManager.getEventuallyQueue().poll();
       }
     }
     return this;

src/__tests__/Parse-test.js

@@ -94,6 +94,14 @@ describe('Parse module', () => {
     expect(CoreManager.getLocalDatastoreController()).toBe(controller);
   });
 
+  it('cannot set EventuallyQueue controller with missing functions', () => {
+    const controller = {
+    };
+    expect(() => Parse.EventuallyQueue = controller).toThrow(
+      'EventuallyQueue must implement poll()'
+    );
+  });
+
   it('can set AsyncStorage', () => {
     const controller = {
       getItem: function () {},
@@ -258,4 +266,16 @@ describe('Parse module', () => {
       process.env.PARSE_BUILD = 'node';
     });
   });
+
+  it('can set EventuallyQueue', () => {
+    const controller = {
+      poll: function () {},
+      save: function () {},
+      destroy: function () {},
+    };
+
+    Parse.EventuallyQueue = controller;
+    expect(CoreManager.getEventuallyQueue()).toBe(controller);
+    expect(Parse.EventuallyQueue).toBe(controller);
+  });
 });

src/__tests__/ParseObject-test.js

@@ -160,6 +160,7 @@ const flushPromises = require('./test_helpers/flushPromises');
 
 CoreManager.setLocalDatastore(mockLocalDatastore);
 CoreManager.setRESTController(RESTController);
+CoreManager.setEventuallyQueue(EventuallyQueue);
 CoreManager.setInstallationController({
   currentInstallationId() {
     return Promise.resolve('iid');