🐛 Unhandled rejection when submitting ops during hard rollback. (#692)

* 🐛 Unhandled rejection when submitting ops during hard rollback.

After doing the steps:
1. Create a doc with rich text type (or any other non irreversible type)
2. Make op submission fail
3. Now in the hard rollback we do `this._setType(null);`
4. If there is any op comming before the hard rollback `fetch` is finished, we get the error
```
Cannot submit op. Document has not been created.
```
as in the `_submit` we do:
```typescript
    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 (callback) return callback(err);
      return this.emit('error', err);
    }
```

We definitely do not handle this case properly. Possible solutions:
1. Just throw error whenever that happens, which is easy to implement
   and it is not really breaking. User would be then able to react on
   the error or just ignore it.
2. Store copy of cannonical snapshot in the doc itself, so that we do
   not have to do fetch for hard rollback. More difficult to implement
   and has a side effect of storing the doc twice in the memory.

* Update to call _isInHArdRollback at the top of fetch

Author: dawidreedsy

lib/client/doc.js

@@ -71,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
@@ -746,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);
     }
@@ -1028,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
@@ -1045,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

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',

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() {