sharedb 5.1.1 → 5.2.1

package/lib/client/doc.js

@@ -61,6 +61,7 @@ function Doc(connection, collection, id) {
   this.id = id;
 
   this.version = null;
+  // The OT type of this document. An uncreated document has type `null`
   this.type = null;
   this.data = undefined;
 
@@ -70,6 +71,8 @@ function Doc(connection, collection, id) {
   this.pendingFetch = [];
   this.pendingSubscribe = [];
 
+  this._isInHardRollback = false;
+
   // Whether we think we are subscribed on the server. Synchronously set to
   // false on calls to unsubscribe and disconnect. Should never be true when
   // this.wantSubscribe is false
@@ -93,9 +96,6 @@ function Doc(connection, collection, id) {
   // This is a list of {[create:{...}], [del:true], [op:...], callbacks:[...]}
   this.pendingOps = [];
 
-  // The OT type of this document. An uncreated document has type `null`
-  this.type = null;
-
   // The applyStack enables us to track any ops submitted while we are
   // applying an op incrementally. This value is an array when we are
   // performing an incremental apply and null otherwise. When it is an array,
@@ -748,10 +748,18 @@ Doc.prototype._submit = function(op, source, callback) {
   // The op contains either op, create, delete, or none of the above (a no-op).
   if ('op' in op) {
     if (!this.type) {
-      var err = new ShareDBError(
-        ERROR_CODE.ERR_DOC_DOES_NOT_EXIST,
-        'Cannot submit op. Document has not been created. ' + this.collection + '.' + this.id
-      );
+      if (this._isInHardRollback) {
+        var err = new ShareDBError(
+          ERROR_CODE.ERR_DOC_IN_HARD_ROLLBACK,
+          'Cannot submit op. Document is performing hard rollback. ' + this.collection + '.' + this.id
+        );
+      } else {
+        var err = new ShareDBError(
+          ERROR_CODE.ERR_DOC_DOES_NOT_EXIST,
+          'Cannot submit op. Document has not been created. ' + this.collection + '.' + this.id
+        );
+      }
+
       if (callback) return callback(err);
       return this.emit('error', err);
     }
@@ -1030,6 +1038,7 @@ Doc.prototype._rollback = function(err) {
 };
 
 Doc.prototype._hardRollback = function(err) {
+  this._isInHardRollback = true;
   // Store pending ops so that we can notify their callbacks of the error.
   // We combine the inflight op and the pending ops, because it's possible
   // to hit a condition where we have no inflight op, but we do have pending
@@ -1047,6 +1056,8 @@ Doc.prototype._hardRollback = function(err) {
   // Fetch the latest version from the server to get us back into a working state
   var doc = this;
   this._fetch({force: true}, function(fetchError) {
+    doc._isInHardRollback = false;
+
     // We want to check that no errors are swallowed, so we check that:
     // - there are callbacks to call, and
     // - that every single pending op called a callback

package/lib/client/presence/local-doc-presence.js

@@ -30,10 +30,20 @@ LocalDocPresence.prototype.submit = function(value, callback) {
     // be null. Let's early return, instead of error since this is a harmless
     // no-op
     if (value === null) return this._callbackOrEmit(null, callback);
-    var error = {
-      code: ERROR_CODE.ERR_DOC_DOES_NOT_EXIST,
-      message: 'Cannot submit presence. Document has not been created'
-    };
+
+    var error = null;
+    if (this._doc._isInHardRollback) {
+      error = {
+        code: ERROR_CODE.ERR_DOC_IN_HARD_ROLLBACK,
+        message: 'Cannot submit presence. Document is processing hard rollback'
+      };
+    } else {
+      error = {
+        code: ERROR_CODE.ERR_DOC_DOES_NOT_EXIST,
+        message: 'Cannot submit presence. Document has not been created'
+      };
+    }
+
     return this._callbackOrEmit(error, callback);
   };
 

package/lib/error.js

@@ -30,6 +30,7 @@ ShareDBError.CODES = {
   ERR_DOC_DOES_NOT_EXIST: 'ERR_DOC_DOES_NOT_EXIST',
   ERR_DOC_TYPE_NOT_RECOGNIZED: 'ERR_DOC_TYPE_NOT_RECOGNIZED',
   ERR_DOC_WAS_DELETED: 'ERR_DOC_WAS_DELETED',
+  ERR_DOC_IN_HARD_ROLLBACK: 'ERR_DOC_IN_HARD_ROLLBACK',
   ERR_INFLIGHT_OP_MISSING: 'ERR_INFLIGHT_OP_MISSING',
   ERR_INGESTED_SNAPSHOT_HAS_NO_VERSION: 'ERR_INGESTED_SNAPSHOT_HAS_NO_VERSION',
   ERR_MAX_SUBMIT_RETRIES_EXCEEDED: 'ERR_MAX_SUBMIT_RETRIES_EXCEEDED',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sharedb",
-  "version": "5.1.1",
+  "version": "5.2.1",
   "description": "JSON OT database backend",
   "main": "lib/index.js",
   "dependencies": {

package/test/client/doc.js

@@ -636,6 +636,25 @@ describe('Doc', function() {
         }
       ], done);
     });
+
+    it('rejects ops with ERR_DOC_IN_HARD_ROLLBACK error when in hard rollback', function(done) {
+      var backend = this.backend;
+      var doc = backend.connect().get('dogs', 'snoopy');
+
+      async.series([
+        doc.create.bind(doc, {color: 'red'}),
+        function(next) {
+          doc.on('error', function(error) {
+            expect(error.code).to.be.equal('TEST_ERROR');
+          });
+          doc._hardRollback(new ShareDBError('TEST_ERROR'));
+          doc.submitOp({p: ['color'], oi: 'blue', od: 'red'}, function(error) {
+            expect(error.code).to.be.equal('ERR_DOC_IN_HARD_ROLLBACK');
+            next();
+          });
+        }
+      ], done);
+    });
   });
 
   describe('errors on ops that could cause prototype corruption', function() {

package/test/client/presence/doc-presence.js

@@ -829,6 +829,20 @@ describe('DocPresence', function() {
     ], done);
   });
 
+
+  it('errors local presence when doc is in hard rollback', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+
+    doc1.on('error', function(error) {
+      expect(error).to.be.equal('some error');
+    });
+    doc1._hardRollback('some error');
+    localPresence1.submit({index: 1}, function(error) {
+      expect(error.code).to.be.equal('ERR_DOC_IN_HARD_ROLLBACK');
+      done();
+    });
+  });
+
   it('returns errors sent from the middleware', function(done) {
     backend.use(backend.MIDDLEWARE_ACTIONS.sendPresence, function(request, callback) {
       callback('some error');