sharedb 6.0.0 → 6.0.2

package/lib/client/doc.js

@@ -968,11 +968,11 @@ Doc.prototype._opAcknowledged = function(message) {
   }
 
   if (message[ACTIONS.fixup]) {
-    for (var i = 0; i < message[ACTIONS.fixup].length; i++) {
-      var fixupOp = message[ACTIONS.fixup][i];
+    for (var fixupIndex = 0; fixupIndex < message[ACTIONS.fixup].length; fixupIndex++) {
+      var fixupOp = message[ACTIONS.fixup][fixupIndex];
 
-      for (var j = 0; j < this.pendingOps.length; j++) {
-        var transformErr = transformX(this.pendingOps[i], fixupOp);
+      for (var pendingIndex = 0; pendingIndex < this.pendingOps.length; pendingIndex++) {
+        var transformErr = transformX(this.pendingOps[pendingIndex], fixupOp);
         if (transformErr) return this._hardRollback(transformErr);
       }
 

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

@@ -76,12 +76,12 @@ RemoteDocPresence.prototype._handleOp = function(op, source, connectionId) {
   this._setPendingPresence();
 };
 
-RemotePresence.prototype._handleCreateDel = function() {
+RemoteDocPresence.prototype._handleCreateDel = function() {
   this._cacheOp(null);
   this._setPendingPresence();
 };
 
-RemotePresence.prototype._handleLoad = function() {
+RemoteDocPresence.prototype._handleLoad = function() {
   this.value = null;
   this._pending = null;
   this._opCache = null;

package/lib/submit-request.js

@@ -3,6 +3,7 @@ var projections = require('./projections');
 var ShareDBError = require('./error');
 var types = require('./types');
 var protocol = require('./protocol');
+var util = require('./util');
 
 var ERROR_CODE = ShareDBError.CODES;
 
@@ -43,6 +44,7 @@ function SubmitRequest(backend, agent, index, id, op, options) {
   this.ops = [];
   this.channels = null;
   this._fixupOps = [];
+  this._opBeforeFixups = null;
 }
 module.exports = SubmitRequest;
 
@@ -70,6 +72,12 @@ SubmitRequest.prototype.$fixup = function(op) {
     );
   }
 
+  if (!this._opBeforeFixups) {
+    this._opBeforeFixups = this.op.create ?
+      {data: util.clone(this.op.create.data)} :
+      {op: util.clone(this.op.op)};
+  }
+
   if (this.op.create) this.op.create.data = type.apply(this.op.create.data, op);
   else this.op.op = type.compose(this.op.op, op);
 
@@ -186,8 +194,6 @@ SubmitRequest.prototype.apply = function(callback) {
   // Always set the channels before each attempt to apply. If the channels are
   // modified in a middleware and we retry, we want to reset to a new array
   this.channels = this.backend.getChannels(this.collection, this.id);
-  this._fixupOps = [];
-  delete this.op.m.fixup;
 
   var request = this;
   this.backend.trigger(this.backend.MIDDLEWARE_ACTIONS.apply, this.agent, this, function(err) {
@@ -254,10 +260,21 @@ SubmitRequest.prototype.retry = function(callback) {
   if (this.maxRetries != null && this.retries > this.maxRetries) {
     return callback(this.maxRetriesError());
   }
+  this._resetFixups();
   this.backend.emit('timing', 'submit.retry', Date.now() - this.start, this);
   this.submit(callback);
 };
 
+// The fixups must be undone before the op is transformed forward again
+SubmitRequest.prototype._resetFixups = function() {
+  this._fixupOps = [];
+  delete this.op.m.fixup;
+  if (!this._opBeforeFixups) return;
+  if (this.op.create) this.op.create.data = this._opBeforeFixups.data;
+  else this.op.op = this._opBeforeFixups.op;
+  this._opBeforeFixups = null;
+};
+
 SubmitRequest.prototype._transformOp = function(ops) {
   var type = this.snapshot.type;
   for (var i = 0; i < ops.length; i++) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sharedb",
-  "version": "6.0.0",
+  "version": "6.0.2",
   "description": "JSON OT database backend",
   "main": "lib/index.js",
   "dependencies": {
@@ -21,7 +21,7 @@
     "ot-json1": "^1.0.2",
     "rich-text": "^4.1.0",
     "sharedb-legacy": "npm:sharedb@1.1.0",
-    "sinon": "^21.0.3",
+    "sinon": "^22.0.0",
     "sinon-chai": "^4.0.1"
   },
   "files": [

package/test/middleware.js

@@ -565,6 +565,68 @@ describe('middleware', function() {
       });
     });
 
+    it('transforms a pending op by multiple fixups', function(done) {
+      var applied = false;
+      backend.use('apply', function(request, next) {
+        if (applied) return next();
+        applied = true;
+        request.$fixup([{p: ['tricks', 0], li: 'sit'}]);
+        request.$fixup([{p: ['tricks', 0], li: 'stay'}]);
+        next();
+      });
+
+      var remoteConnection = backend.connect();
+      var remoteDoc = remoteConnection.get('dogs', 'fido');
+
+      remoteDoc.subscribe(function(error) {
+        if (error) return done(error);
+
+        expect(remoteDoc.data).to.eql({name: 'fido'});
+
+        remoteDoc.on('op batch', function() {
+          if (remoteDoc.version !== 3) return;
+          expect(remoteDoc.data.tricks).to.eql(['stay', 'sit', 'fetch', 'lie down']);
+          expect(remoteDoc.data).to.eql(doc.data);
+          done();
+        });
+
+        doc.preventCompose = true;
+        doc.submitOp([{p: ['tricks'], oi: ['fetch']}], errorHandler(done));
+        doc.submitOp([{p: ['tricks', 1], li: 'lie down'}], errorHandler(done));
+      });
+    });
+
+    it('transforms multiple pending ops by a fixup', function(done) {
+      var applied = false;
+      backend.use('apply', function(request, next) {
+        if (applied) return next();
+        applied = true;
+        request.$fixup([{p: ['tricks', 0], li: 'stay'}]);
+        next();
+      });
+
+      var remoteConnection = backend.connect();
+      var remoteDoc = remoteConnection.get('dogs', 'fido');
+
+      remoteDoc.subscribe(function(error) {
+        if (error) return done(error);
+
+        expect(remoteDoc.data).to.eql({name: 'fido'});
+
+        remoteDoc.on('op batch', function() {
+          if (remoteDoc.version !== 4) return;
+          expect(remoteDoc.data.tricks).to.eql(['stay', 'fetch', 'sit', 'roll over']);
+          expect(remoteDoc.data).to.eql(doc.data);
+          done();
+        });
+
+        doc.preventCompose = true;
+        doc.submitOp([{p: ['tricks'], oi: ['fetch']}], errorHandler(done));
+        doc.submitOp([{p: ['tricks', 1], li: 'sit'}], errorHandler(done));
+        doc.submitOp([{p: ['tricks', 2], li: 'roll over'}], errorHandler(done));
+      });
+    });
+
     it('applies a fixup to a creation op', function(done) {
       backend.use('apply', function(request, next) {
         request.$fixup([{p: ['goodBoy'], oi: true}]);
@@ -702,6 +764,79 @@ describe('middleware', function() {
       });
     });
 
+    it('applies the fixup once when the submit is retried', function(done) {
+      var remoteDoc = backend.connect().get('dogs', 'fido');
+
+      doc.submitOp([{p: ['fixups'], oi: 0}], function(error) {
+        if (error) return done(error);
+        remoteDoc.fetch(function(error) {
+          if (error) return done(error);
+
+          backend.use('apply', function(request, next) {
+            request.$fixup([{p: ['fixups'], na: 1}]);
+            next();
+          });
+
+          var commitDoc;
+          var commitRemoteDoc;
+          backend.use('commit', function(request, next) {
+            // Once we've forced the race, let the retry through untouched
+            if (commitDoc && commitRemoteDoc) return next();
+            if (request.op.src === doc.connection.id) commitDoc = next;
+            else commitRemoteDoc = next;
+            // Both ops have now been applied to the same snapshot, so
+            // committing one of them will force the other to retry
+            if (commitDoc && commitRemoteDoc) commitDoc();
+          });
+
+          doc.submitOp([{p: ['name', 0], si: 'a'}], function(error) {
+            if (error) return done(error);
+            commitRemoteDoc();
+          });
+
+          remoteDoc.submitOp([{p: ['name', 0], si: 'b'}], function(error) {
+            if (error) return done(error);
+            backend.db.getSnapshot('dogs', 'fido', null, null, function(error, snapshot) {
+              if (error) return done(error);
+              expect(snapshot.data.fixups).to.equal(2);
+              expect(snapshot.data).to.eql(remoteDoc.data);
+              expect(snapshot.v).to.equal(remoteDoc.version);
+              done();
+            });
+          });
+        });
+      });
+    });
+
+    it('applies the fixup once when a create is retried', function(done) {
+      backend.use('apply', function(request, next) {
+        request.$fixup([{p: ['fixups'], na: 1}]);
+        next();
+      });
+
+      // A create can only be retried if the database reports a failed commit
+      // without another op having landed, since a create that loses a genuine
+      // race is rejected during transform
+      var commit = backend.db.commit;
+      var lostRace = false;
+      sinon.stub(backend.db, 'commit').callsFake(function(collection, id, op, snapshot, options, callback) {
+        if (lostRace) return commit.call(this, collection, id, op, snapshot, options, callback);
+        lostRace = true;
+        process.nextTick(callback, null, false);
+      });
+
+      doc = connection.get('dogs', 'rover');
+      doc.create({name: 'rover', fixups: 0}, function(error) {
+        if (error) return done(error);
+        backend.db.getSnapshot('dogs', 'rover', null, null, function(error, snapshot) {
+          if (error) return done(error);
+          expect(snapshot.data.fixups).to.equal(1);
+          expect(snapshot.data).to.eql(doc.data);
+          done();
+        });
+      });
+    });
+
     it('applies two fixups', function(done) {
       backend.use('apply', function(request, next) {
         request.$fixup([{p: ['tricks', 0], li: 'sit'}]);