Add saveEventually and destroyEventually

Author: dplewis

integration/test/ParseEventuallyQueueTest.js

@@ -1,22 +1,10 @@
 'use strict';
 
 const assert = require('assert');
-const clear = require('./clear');
 const Parse = require('../../node');
 const sleep = require('./sleep');
 
-const TestObject = Parse.Object.extend('TestObject');
-
 describe('Parse EventuallyQueue', () => {
-  beforeEach(done => {
-    Parse.initialize('integration', null, 'notsosecret');
-    Parse.CoreManager.set('SERVER_URL', 'http://localhost:1337/parse');
-    Parse.Storage._clear();
-    clear().then(() => {
-      done();
-    });
-  });
-
   it('can queue save object', async () => {
     const object = new TestObject({ test: 'test' });
     await object.save();
@@ -175,4 +163,55 @@ describe('Parse EventuallyQueue', () => {
     const length = await Parse.EventuallyQueue.length();
     assert.strictEqual(length, 0);
   });
+
+  it('can saveEventually', async done => {
+    const parseServer = await reconfigureServer();
+    const object = new TestObject({ hash: 'saveSecret' });
+    await parseServer.handleShutdown();
+    parseServer.server.close(async () => {
+      await object.saveEventually();
+      let length = await Parse.EventuallyQueue.length();
+      assert(Parse.EventuallyQueue.polling);
+      assert.strictEqual(length, 1);
+
+      await reconfigureServer({});
+      await sleep(3000); // Wait for polling
+
+      assert.strictEqual(Parse.EventuallyQueue.polling, undefined);
+      length = await Parse.EventuallyQueue.length();
+      assert.strictEqual(length, 0);
+
+      const query = new Parse.Query(TestObject);
+      query.equalTo('hash', 'saveSecret');
+      const results = await query.find();
+      assert.strictEqual(results.length, 1);
+      done();
+    });
+  });
+
+  it('can destroyEventually', async done => {
+    const parseServer = await reconfigureServer();
+    const object = new TestObject({ hash: 'deleteSecret' });
+    await object.save();
+    await parseServer.handleShutdown();
+    parseServer.server.close(async () => {
+      await object.destroyEventually();
+      let length = await Parse.EventuallyQueue.length();
+      assert(Parse.EventuallyQueue.polling);
+      assert.strictEqual(length, 1);
+
+      await reconfigureServer({});
+      await sleep(3000); // Wait for polling
+
+      assert.strictEqual(Parse.EventuallyQueue.polling, undefined);
+      length = await Parse.EventuallyQueue.length();
+      assert.strictEqual(length, 0);
+
+      const query = new Parse.Query(TestObject);
+      query.equalTo('hash', 'deleteSecret');
+      const results = await query.find();
+      assert.strictEqual(results.length, 0);
+      done();
+    });
+  });
 });

integration/test/helper.js

@@ -1,4 +1,4 @@
-jasmine.DEFAULT_TIMEOUT_INTERVAL = 5000;
+jasmine.DEFAULT_TIMEOUT_INTERVAL = 10000;
 
 const ParseServer = require('parse-server').default;
 const CustomAuth = require('./CustomAuth');

jasmine.json

@@ -7,5 +7,5 @@
     "*Test.js"
   ],
   "random": false,
-  "timeout": 5000
+  "timeout": 10000
 }

src/EventuallyQueue.js

@@ -13,20 +13,22 @@ const EventuallyQueue = {
   localStorageKey: 'Parse.Eventually.Queue',
   polling: undefined,
 
-  save(object) {
-    return this.enqueue('save', object);
+  save(object, serverOptions = {}) {
+    return this.enqueue('save', object, serverOptions);
   },
 
-  destroy(object) {
-    return this.enqueue('delete', object);
+  destroy(object, serverOptions = {}) {
+    return this.enqueue('destroy', object, serverOptions);
   },
-
-  async enqueue(action, object) {
-    const queueData = await this.getQueue();
+  generateQueueId(action, object) {
     object._getId();
     const { className, id, _localId } = object;
-    const hash = object.get('hash') || _localId;
-    const queueId = [action, className, id, hash].join('_');
+    const uniqueId = object.get('hash') || _localId;
+    return [action, className, id, uniqueId].join('_');
+  },
+  async enqueue(action, object, serverOptions) {
+    const queueData = await this.getQueue();
+    const queueId = this.generateQueueId(action, object);
 
     let index = this.queueItemExists(queueData, queueId);
     if (index > -1) {
@@ -40,11 +42,12 @@ const EventuallyQueue = {
       index = queueData.length;
     }
     queueData[index] = {
-      id,
       queueId,
-      className,
       action,
       object,
+      serverOptions,
+      id: object.id,
+      className: object.className,
       hash: object.get('hash'),
       createdAt: new Date(),
     };
@@ -85,25 +88,25 @@ const EventuallyQueue = {
     return queueData.length;
   },
 
-  async sendQueue(sessionToken) {
+  async sendQueue() {
     const queueData = await this.getQueue();
     if (queueData.length === 0) {
       return false;
     }
     for (let i = 0; i < queueData.length; i += 1) {
       const ObjectType = ParseObject.extend(queueData[i].className);
       if (queueData[i].id) {
-        await this.reprocess.byId(ObjectType, queueData[i], sessionToken);
+        await this.reprocess.byId(ObjectType, queueData[i]);
       } else if (queueData[i].hash) {
-        await this.reprocess.byHash(ObjectType, queueData[i], sessionToken);
+        await this.reprocess.byHash(ObjectType, queueData[i]);
       } else {
-        await this.reprocess.create(ObjectType, queueData[i], sessionToken);
+        await this.reprocess.create(ObjectType, queueData[i]);
       }
     }
     return true;
   },
 
-  async sendQueueCallback(object, queueObject, sessionToken) {
+  async sendQueueCallback(object, queueObject) {
     if (!object) {
       return this.remove(queueObject.queueId);
     }
@@ -117,63 +120,67 @@ const EventuallyQueue = {
         return this.remove(queueObject.queueId);
       }
       try {
-        await object.save(queueObject.object, { sessionToken });
+        await object.save(queueObject.object, queueObject.serverOptions);
         await this.remove(queueObject.queueId);
       } catch (e) {
-        // Do Nothing
+        if (e.message !== 'XMLHttpRequest failed: "Unable to connect to the Parse API"') {
+          await this.remove(queueObject.queueId);
+        }
       }
       break;
-    case 'delete':
+    case 'destroy':
       try {
-        await object.destroy({ sessionToken });
+        await object.destroy(queueObject.serverOptions);
+        await this.remove(queueObject.queueId);
       } catch (e) {
-        // Do Nothing
+        if (e.message !== 'XMLHttpRequest failed: "Unable to connect to the Parse API"') {
+          await this.remove(queueObject.queueId);
+        }
       }
-      await this.remove(queueObject.queueId);
       break;
     }
   },
 
-  poll(sessionToken) {
+  poll() {
     if (this.polling) {
       return;
     }
     this.polling = setInterval(() => {
-      let url = CoreManager.get('SERVER_URL');
-      url += url[url.length - 1] !== '/' ? '/health' : 'health';
-
       const RESTController = CoreManager.getRESTController();
-      RESTController.ajax('GET', url)
-        .then(async () => {
+      RESTController.ajax('GET', CoreManager.get('SERVER_URL')).catch(error => {
+        if (error !== 'Unable to connect to the Parse API') {
           clearInterval(this.polling);
-          delete this.polling;
-          await this.sendQueue(sessionToken);
-        })
-        .catch(() => {
-          // Can't connect to server, continue
-        });
+          this.polling = undefined;
+          return this.sendQueue();
+        }
+      });
     }, 2000);
   },
-
+  stopPoll() {
+    clearInterval(this.polling);
+    this.polling = undefined;
+  },
   reprocess: {
-    create(ObjectType, queueObject, sessionToken) {
+    create(ObjectType, queueObject) {
       const newObject = new ObjectType();
-      return EventuallyQueue.sendQueueCallback(newObject, queueObject, sessionToken);
+      return EventuallyQueue.sendQueueCallback(newObject, queueObject);
     },
-    async byId(ObjectType, queueObject, sessionToken) {
+    async byId(ObjectType, queueObject) {
+      const { sessionToken } = queueObject.serverOptions;
       const query = new ParseQuery(ObjectType);
       query.equalTo('objectId', queueObject.id);
       const results = await query.find({ sessionToken });
-      return EventuallyQueue.sendQueueCallback(results[0], queueObject, sessionToken);
+      return EventuallyQueue.sendQueueCallback(results[0], queueObject);
     },
-    async byHash(ObjectType, queueObject, sessionToken) {
+    async byHash(ObjectType, queueObject) {
+      const { sessionToken } = queueObject.serverOptions;
       const query = new ParseQuery(ObjectType);
       query.equalTo('hash', queueObject.hash);
       const results = await query.find({ sessionToken });
       if (results.length > 0) {
-        return EventuallyQueue.sendQueueCallback(results[0], queueObject, sessionToken);
+        return EventuallyQueue.sendQueueCallback(results[0], queueObject);
       }
-      return EventuallyQueue.reprocess.create(ObjectType, queueObject, sessionToken);
+      return EventuallyQueue.reprocess.create(ObjectType, queueObject);
     },
   },
 };

src/Parse.js

@@ -11,6 +11,7 @@ import decode from './decode';
 import encode from './encode';
 import CoreManager from './CoreManager';
 import CryptoController from './CryptoController';
+import EventuallyQueue from './EventuallyQueue';
 import InstallationController from './InstallationController';
 import * as ParseOp from './ParseOp';
 import RESTController from './RESTController';
@@ -46,6 +47,7 @@ const Parse = {
       /* eslint-enable no-console */
     }
     Parse._initialize(applicationId, javaScriptKey);
+    EventuallyQueue.poll();
   },
 
   _initialize(applicationId: string, javaScriptKey: string, masterKey: string) {
@@ -197,7 +199,7 @@ Parse.CLP = require('./ParseCLP').default;
 Parse.CoreManager = require('./CoreManager');
 Parse.Config = require('./ParseConfig').default;
 Parse.Error = require('./ParseError').default;
-Parse.EventuallyQueue = require('./EventuallyQueue');
+Parse.EventuallyQueue = EventuallyQueue;
 Parse.FacebookUtils = require('./FacebookUtils').default;
 Parse.File = require('./ParseFile').default;
 Parse.GeoPoint = require('./ParseGeoPoint').default;

src/ParseObject.js

@@ -14,6 +14,7 @@ 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';
@@ -1200,6 +1201,42 @@ class ParseObject {
     return this.fetch(options);
   }
 
+  /**
+   * Saves this object to the server at some unspecified time in the future,
+   * even if Parse is currently inaccessible.
+   *
+   * Use this when you may not have a solid network connection, and don't need to know when the save completes.
+   * If there is some problem with the object such that it can't be saved, it will be silently discarded.
+   *
+   * Objects saved with this method will be stored locally in an on-disk cache until they can be delivered to Parse.
+   * They will be sent immediately if possible. Otherwise, they will be sent the next time a network connection is
+   * available. Objects saved this way will persist even after the app is closed, in which case they will be sent the
+   * next time the app is opened.
+   *
+   * @param {object} [options]
+   * Used to pass option parameters to method if arg1 and arg2 were both passed as strings.
+   * Valid options are:
+   * <ul>
+   * <li>sessionToken: A valid session token, used for making a request on
+   * behalf of a specific user.
+   * <li>cascadeSave: If `false`, nested objects will not be saved (default is `true`).
+   * <li>context: A dictionary that is accessible in Cloud Code `beforeSave` and `afterSave` triggers.
+   * </ul>
+   * @returns {Promise} A promise that is fulfilled when the save
+   * completes.
+   */
+  async saveEventually(options: SaveOptions): Promise {
+    try {
+      await this.save(null, options);
+    } catch (e) {
+      if (e.message === 'XMLHttpRequest failed: "Unable to connect to the Parse API"') {
+        await EventuallyQueue.save(this, options);
+        EventuallyQueue.poll();
+      }
+    }
+    return this;
+  }
+
   /**
    * Set a hash of model attributes, and save the model to the server.
    * updatedAt will be updated when the request returns.
@@ -1305,6 +1342,40 @@ class ParseObject {
     });
   }
 
+  /**
+   * Deletes this object from the server at some unspecified time in the future,
+   * even if Parse is currently inaccessible.
+   *
+   * Use this when you may not have a solid network connection,
+   * and don't need to know when the delete completes. If there is some problem with the object
+   * such that it can't be deleted, the request will be silently discarded.
+   *
+   * Delete instructions made with this method will be stored locally in an on-disk cache until they can be transmitted
+   * to Parse. They will be sent immediately if possible. Otherwise, they will be sent the next time a network connection
+   * is available. Delete requests will persist even after the app is closed, in which case they will be sent the
+   * next time the app is opened.
+   *
+   * @param {object} [options]
+   * Valid options are:<ul>
+   *   <li>sessionToken: A valid session token, used for making a request on
+   *       behalf of a specific user.
+   *   <li>context: A dictionary that is accessible in Cloud Code `beforeDelete` and `afterDelete` triggers.
+   * </ul>
+   * @returns {Promise} A promise that is fulfilled when the destroy
+   *     completes.
+   */
+  async destroyEventually(options: RequestOptions): Promise {
+    try {
+      await this.destroy(options);
+    } catch (e) {
+      if (e.message === 'XMLHttpRequest failed: "Unable to connect to the Parse API"') {
+        await EventuallyQueue.destroy(this, options);
+        EventuallyQueue.poll();
+      }
+    }
+    return this;
+  }
+
   /**
    * Destroy this model on the server if it was already persisted.
    *