sharedb 7.0.1 → 7.0.3

package/lib/agent.js

@@ -188,7 +188,9 @@ Agent.prototype._subscribeToPresenceStream = function(channel, stream) {
   stream.on('data', function(data) {
     if (data.error) {
       logger.error('Presence subscription stream error', channel, data.error);
+      return;
     }
+    if (!isPresenceOrRequestFor(channel, data)) return;
     agent._handlePresenceData(data);
   });
 
@@ -199,6 +201,12 @@ Agent.prototype._subscribeToPresenceStream = function(channel, stream) {
   });
 };
 
+function isPresenceOrRequestFor(channel, data) {
+  var isPresence = data.a === ACTIONS.presence;
+  var isPresenceRequest = !!data.r;
+  return (isPresence || isPresenceRequest) && data.ch === channel;
+}
+
 Agent.prototype._retractPresences = function(channel) {
   var pendingBroadcasts = this._pendingPresenceBroadcasts;
   for (var i = 0; i < pendingBroadcasts.length; i++) {
@@ -486,6 +494,7 @@ Agent.prototype._checkRequest = function(request) {
     if (request.a === ACTIONS.presence) {
       if (isInvalidName(request.id)) return 'Invalid presence ID';
       if (isInvalidVersion(request.pv)) return 'Invalid presence version';
+      if (isDocPresence(request) && !util.isInteger(request.v)) return 'Invalid version';
     }
   } else if (
     request.a === ACTIONS.bulkFetch ||
@@ -945,17 +954,8 @@ Agent.prototype._broadcastPresence = function(presence, supersededBroadcasts, ca
         requests[presence.id] = presence;
       }
 
-      var transformer = function(agent, presence, callback) {
-        callback(null, presence);
-      };
-
-      var latestDocVersion = util.dig(agent.latestDocVersions, presence.c, presence.d);
-      var presenceIsUpToDate = presence.v === latestDocVersion;
-      if (!presenceIsUpToDate) {
-        transformer = backend.transformPresenceToLatestVersion.bind(backend);
-      }
-
-      transformer(agent, presence, function(error, transformedPresence) {
+      var trackedVersion = util.dig(agent.latestDocVersions, presence.c, presence.d);
+      backend._transformPresenceToLatestVersion(agent, presence, trackedVersion, function(error, transformedPresence) {
         if (error) {
           agent._withdrawPresenceRequest(requests, presence, previousRequest);
           return callback(error);
@@ -1016,6 +1016,7 @@ Agent.prototype._subscribeDocVersion = function(collection, id, callback) {
     versions[id] = snapshot.v;
 
     agent._subscribeMapToStream(agent.latestDocVersionStreams, collection, id, stream, function(op) {
+      if (agent._isOpFromCollidingChannel(collection, id, op)) return;
       // op.v behind snapshot.v by 1
       latestDocVersions[collection][id] = op.v + 1;
     });

package/lib/backend.js

@@ -809,10 +809,9 @@ Backend.prototype.fetchSnapshot = function(agent, index, id, version, callback)
 
   this._fetchSnapshot(collection, id, version, function(error, snapshot) {
     if (error) return callback(error);
-    var snapshotProjection = backend._getSnapshotProjection(backend.db, projection);
     var snapshots = [snapshot];
     var snapshotType = backend.SNAPSHOT_TYPES.byVersion;
-    backend._sanitizeSnapshots(agent, snapshotProjection, collection, snapshots, snapshotType, function(error) {
+    backend._sanitizeSnapshots(agent, projection, collection, snapshots, snapshotType, function(error) {
       if (error) return callback(error);
       backend.emit('timing', 'fetchSnapshot', Date.now() - start, request);
       callback(null, snapshot);
@@ -875,10 +874,9 @@ Backend.prototype.fetchSnapshotByTimestamp = function(agent, index, id, timestam
 
   this._fetchSnapshotByTimestamp(collection, id, timestamp, function(error, snapshot) {
     if (error) return callback(error);
-    var snapshotProjection = backend._getSnapshotProjection(backend.db, projection);
     var snapshots = [snapshot];
     var snapshotType = backend.SNAPSHOT_TYPES.byTimestamp;
-    backend._sanitizeSnapshots(agent, snapshotProjection, collection, snapshots, snapshotType, function(error) {
+    backend._sanitizeSnapshots(agent, projection, collection, snapshots, snapshotType, function(error) {
       if (error) return callback(error);
       backend.emit('timing', 'fetchSnapshot', Date.now() - start, request);
       callback(null, snapshot);
@@ -938,18 +936,47 @@ Backend.prototype._buildSnapshotFromOps = function(id, startingSnapshot, ops, ca
 };
 
 Backend.prototype.transformPresenceToLatestVersion = function(agent, presence, callback) {
+  this._transformPresenceToLatestVersion(agent, presence, null, callback);
+};
+
+Backend.prototype._transformPresenceToLatestVersion = function(agent, presence, trackedVersion, callback) {
   if (!presence.c || !presence.d) return callback(null, presence);
-  this.getOps(agent, presence.c, presence.d, presence.v, null, function(error, ops) {
+  var backend = this;
+  this._getDocVersionForPresence(agent, presence, trackedVersion, function(error, docVersion) {
     if (error) return callback(error);
-    for (var i = 0; i < ops.length; i++) {
-      var op = ops[i];
-      var isOwnOp = op.src === presence.src;
-      var transformError = ot.transformPresence(presence, op, isOwnOp);
-      if (transformError) {
-        return callback(transformError);
-      }
+    var leaving = presence.p === null;
+    if (leaving) presence.v = docVersion;
+    if (presence.v > docVersion) {
+      return callback(new ShareDBError(
+        ERROR_CODE.ERR_OP_VERSION_NEWER_THAN_CURRENT_SNAPSHOT,
+        'Presence version newer than current snapshot'
+      ));
     }
-    callback(null, presence);
+    if (presence.v === docVersion) return callback(null, presence);
+    backend.getOps(agent, presence.c, presence.d, presence.v, null, function(error, ops) {
+      if (error) return callback(error);
+      for (var i = 0; i < ops.length; i++) {
+        var op = ops[i];
+        var isOwnOp = op.src === presence.src;
+        var transformError = ot.transformPresence(presence, op, isOwnOp);
+        if (transformError) {
+          return callback(transformError);
+        }
+      }
+      callback(null, presence);
+    });
+  });
+};
+
+Backend.prototype._getDocVersionForPresence = function(agent, presence, trackedVersion, callback) {
+  var leaving = presence.p === null;
+  var presenceIsWithinTrackedVersion = trackedVersion != null && presence.v <= trackedVersion;
+  if (!leaving && presenceIsWithinTrackedVersion) return callback(null, trackedVersion);
+  var projection = this.projections[presence.c];
+  var collection = (projection) ? projection.target : presence.c;
+  this.db.getSnapshot(collection, presence.d, {}, {agentCustom: agent.custom}, function(error, snapshot) {
+    if (error) return callback(error);
+    callback(null, snapshot.v);
   });
 };
 

package/package.json

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

package/test/agent.js

@@ -341,6 +341,64 @@ describe('Agent', function() {
         });
       });
     });
+
+    describe('with presence', function() {
+      beforeEach(function(done) {
+        backend.close(function(error) {
+          if (error) return done(error);
+          backend = new Backend({presence: true});
+          writer = backend.connect();
+          subscriber = backend.connect();
+          done();
+        });
+      });
+
+      function expectOnlyPresence(presence, callback) {
+        var messages = [];
+        subscriber.on('receive', function(request) {
+          messages.push(request.data);
+        });
+        presence.once('receive', function() {
+          expect(messages).to.have.length(1);
+          expect(messages[0].a).to.equal(ACTIONS.presence);
+          callback();
+        });
+      }
+
+      it('does not deliver ops from a collection whose channel matches the presence channel', function(done) {
+        var presence = subscriber.getPresence('secrets');
+        presence.subscribe(function(error) {
+          if (error) return done(error);
+          expectOnlyPresence(presence, done);
+          writer.get('$presence.secrets', 'alice').create({pin: '1234'}, function(error) {
+            if (error) return done(error);
+            writer.getPresence('secrets').create('writer').submit({name: 'Writer'}, function(error) {
+              if (error) done(error);
+            });
+          });
+        });
+      });
+
+      it('does not deliver ops from a doc whose channel matches the doc presence channel', function(done) {
+        var writerDoc = writer.get('notes', 'alice');
+        var subscriberDoc = subscriber.get('notes', 'alice');
+        var presence = subscriber.getDocPresence('notes', 'alice');
+        async.series([
+          writerDoc.create.bind(writerDoc, 'Hello', presenceTestType.type.name),
+          subscriberDoc.fetch.bind(subscriberDoc),
+          presence.subscribe.bind(presence),
+          function(next) {
+            expectOnlyPresence(presence, next);
+            writer.get('$presence', 'notes.alice').create({pin: '1234'}, function(error) {
+              if (error) return next(error);
+              writer.getDocPresence('notes', 'alice').create('writer').submit({index: 1}, function(error) {
+                if (error) next(error);
+              });
+            });
+          }
+        ], done);
+      });
+    });
   });
 
   describe('cleanup', function() {

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

@@ -585,6 +585,327 @@ describe('DocPresence', function() {
     connection1.send(message);
   });
 
+  it('rejects a presence message with a non-integer version', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    localPresence1.on('error', function(error) {
+      expect(error.code).to.eql('ERR_MESSAGE_BADLY_FORMED');
+      done();
+    });
+
+    var message = localPresence1._message();
+    message.v = 1.5;
+    message.t = presenceTestType.type.uri;
+    connection1.send(message);
+  });
+
+  it('rejects a presence message without a version', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    localPresence1.on('error', function(error) {
+      expect(error.code).to.eql('ERR_MESSAGE_BADLY_FORMED');
+      done();
+    });
+
+    var message = localPresence1._message();
+    message.t = presenceTestType.type.uri;
+    connection1.send(message);
+  });
+
+  [
+    {description: 'without doc coordinates', c: undefined, d: undefined},
+    {description: 'for another doc', c: 'books', d: 'subtle-knife'}
+  ].forEach(function(test) {
+    it('ignores remote presence on its channel ' + test.description, function(done) {
+      sinon.spy(doc2, 'fetch');
+
+      [doc2.version, doc2.version + 1].forEach(function(version, index) {
+        var message = presence1.create('presence-' + index)._message();
+        message.c = test.c;
+        message.d = test.d;
+        message.p = {index: 1};
+        message.v = version;
+        message.t = presenceTestType.type.uri;
+        connection2.handleMessage(message);
+      });
+
+      doc2.whenNothingPending(function() {
+        expect(presence2.remotePresences).to.be.empty;
+        expect(presence2._remotePresenceInstances).to.be.empty;
+        expect(doc2.fetch).not.to.have.been.called;
+        done();
+      });
+    });
+  });
+
+  it('rejects presence whose version is ahead of the doc', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    presence2.on('receive', function() {
+      done(new Error('Should not broadcast presence from the future'));
+    });
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        localPresence1.on('error', function(error) {
+          expect(error.code).to.equal('ERR_OP_VERSION_NEWER_THAN_CURRENT_SNAPSHOT');
+          expect(connection1.agent.presenceRequests[presence1.channel]['presence-1'].p).to.be.null;
+          next();
+        });
+
+        var message = localPresence1._message();
+        message.p = {index: 1};
+        message.v = doc1.version + 1;
+        message.t = presenceTestType.type.uri;
+        connection1.send(message);
+      }
+    ], done);
+  });
+
+  it('rejects presence ahead of a tracked doc', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+
+    async.series([
+      localPresence1.submit.bind(localPresence1, {index: 1}),
+      function(next) {
+        localPresence1.on('error', function(error) {
+          expect(error.code).to.equal('ERR_OP_VERSION_NEWER_THAN_CURRENT_SNAPSHOT');
+          next();
+        });
+
+        var message = localPresence1._message();
+        message.p = {index: 1};
+        message.v = doc1.version + 1;
+        message.t = presenceTestType.type.uri;
+        connection1.send(message);
+      }
+    ], done);
+  });
+
+  it('rejects presence ahead of a tracked doc after ops to a doc on the same channel', function(done) {
+    var notesDoc1 = connection1.get('notes', 'private.alice');
+    var diaryDoc1 = connection1.get('notes.private', 'alice');
+    var diaryDoc2 = connection2.get('notes.private', 'alice');
+    var localNotesPresence1 = connection1.getDocPresence('notes', 'private.alice').create('notes-presence');
+
+    async.series([
+      notesDoc1.create.bind(notesDoc1, 'Hello', presenceTestType.type.name),
+      localNotesPresence1.submit.bind(localNotesPresence1, {index: 1}),
+      diaryDoc2.create.bind(diaryDoc2, 'Dear diary', presenceTestType.type.name),
+      diaryDoc1.subscribe.bind(diaryDoc1),
+      function(next) {
+        diaryDoc1.once('op', function() {
+          next();
+        });
+        diaryDoc2.submitOp({index: 0, value: 'Oh, '}, errorHandler(done));
+      },
+      function(next) {
+        localNotesPresence1.on('error', function(error) {
+          expect(error.code).to.equal('ERR_OP_VERSION_NEWER_THAN_CURRENT_SNAPSHOT');
+          next();
+        });
+
+        expect(diaryDoc2.version).to.be.above(notesDoc1.version);
+        var message = localNotesPresence1._message();
+        message.p = {index: 1};
+        message.v = diaryDoc2.version;
+        message.t = presenceTestType.type.uri;
+        connection1.send(message);
+      }
+    ], done);
+  });
+
+  it('does not read the snapshot for presence after its own client\'s op', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        localPresence1.submit({index: 1}, errorHandler(done));
+        presence2.once('receive', function() {
+          next();
+        });
+      },
+      function(next) {
+        doc2.once('op', function() {
+          next();
+        });
+        doc1.submitOp({index: 0, value: 'The '}, errorHandler(done));
+      },
+      function(next) {
+        sinon.spy(backend.db, 'getSnapshot');
+        localPresence1.submit({index: 6}, errorHandler(done));
+        presence2.once('receive', function(id, presence) {
+          expect(presence).to.eql({index: 6});
+          expect(backend.db.getSnapshot).not.to.have.been.called;
+          next();
+        });
+      }
+    ], done);
+  });
+
+  it('does not read the snapshot for presence at the tracked doc version', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        localPresence1.submit({index: 1}, errorHandler(done));
+        presence2.once('receive', function() {
+          next();
+        });
+      },
+      function(next) {
+        sinon.spy(backend.db, 'getSnapshot');
+        localPresence1.submit({index: 2}, errorHandler(done));
+        presence2.once('receive', function(id, presence) {
+          expect(presence).to.eql({index: 2});
+          expect(backend.db.getSnapshot).not.to.have.been.called;
+          next();
+        });
+      }
+    ], done);
+  });
+
+  it('clamps a leave ahead of the doc to the doc version', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    localPresence1.on('error', done);
+    sinon.spy(doc2, 'fetch');
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        presence2.once('receive', function(id, presence) {
+          expect(id).to.equal('presence-1');
+          expect(presence).to.be.null;
+          expect(connection1.agent.presenceRequests[presence1.channel]['presence-1'].v).to.equal(doc1.version);
+          expect(doc2.fetch).not.to.have.been.called;
+          next();
+        });
+
+        var leave = localPresence1._message();
+        leave.p = null;
+        leave.v = doc1.version + 1;
+        leave.t = presenceTestType.type.uri;
+        connection1.send(leave);
+      }
+    ], done);
+  });
+
+  it('broadcasts null presence on disconnect after rejecting presence ahead of the doc', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+
+    async.series([
+      presence1.subscribe.bind(presence1),
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        localPresence1.submit({index: 1}, errorHandler(done));
+        presence2.once('receive', function() {
+          next();
+        });
+      },
+      function(next) {
+        localPresence1.once('error', function(error) {
+          expect(error.code).to.equal('ERR_OP_VERSION_NEWER_THAN_CURRENT_SNAPSHOT');
+          next();
+        });
+
+        var message = localPresence1._message();
+        message.v = doc1.version + 1;
+        message.t = presenceTestType.type.uri;
+        connection1.send(message);
+      },
+      function(next) {
+        presence2.once('receive', function(id, presence) {
+          expect(id).to.equal('presence-1');
+          expect(presence).to.be.null;
+          next();
+        });
+        connection1.close();
+      }
+    ], done);
+  });
+
+  it('accepts up-to-date presence when the agent\'s tracked doc version lags behind', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        localPresence1.submit({index: 1}, errorHandler(done));
+        presence2.once('receive', function() {
+          next();
+        });
+      },
+      function(next) {
+        doc1.submitOp({index: 5, value: 'ern'}, errorHandler(done));
+        doc2.once('op', function() {
+          next();
+        });
+      },
+      function(next) {
+        connection1.agent.latestDocVersions.books['northern-lights'] = 1;
+        localPresence1.submit({index: 12}, errorHandler(done));
+        presence2.once('receive', function(id, presence) {
+          expect(doc2.version).to.eql(2);
+          expect(presence).to.eql({index: 12});
+          next();
+        });
+      }
+    ], done);
+  });
+
+  it('transforms presence ahead of the agent\'s lagging tracked doc version by later ops', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        localPresence1.submit({index: 1}, errorHandler(done));
+        presence2.once('receive', function() {
+          next();
+        });
+      },
+      function(next) {
+        doc1.submitOp({index: 5, value: 'ern'}, errorHandler(done));
+        doc2.once('op', function() {
+          next();
+        });
+      },
+      function(next) {
+        doc2.submitOp({index: 0, value: 'The '}, errorHandler(done));
+        doc1.once('op', function() {
+          next();
+        });
+      },
+      function(next) {
+        connection1.agent.latestDocVersions.books['northern-lights'] = 1;
+        presence2.once('receive', function(id, presence) {
+          expect(presence).to.eql({index: 16});
+          next();
+        });
+
+        var message = localPresence1._message();
+        message.p = {index: 12};
+        message.v = 2;
+        message.t = presenceTestType.type.uri;
+        connection1.send(message);
+      }
+    ], done);
+  });
+
+  it('rejects presence ahead of the doc when transformed without a tracked version', function(done) {
+    var presence = {
+      c: 'books',
+      d: 'northern-lights',
+      p: {index: 1},
+      v: doc1.version + 1,
+      t: presenceTestType.type.uri
+    };
+    backend.transformPresenceToLatestVersion(connection1.agent, presence, function(error) {
+      expect(error.code).to.equal('ERR_OP_VERSION_NEWER_THAN_CURRENT_SNAPSHOT');
+      done();
+    });
+  });
+
   it('rejects a presence message without an ID', function(done) {
     var localPresence1 = presence1.create('presence-1');
     // Have to catch the error on the Presence instance, because obviously
@@ -682,6 +1003,43 @@ describe('DocPresence', function() {
     });
   });
 
+  it('clears presence when a client that has lost read access disconnects', function(done) {
+    var agent1 = connection1.agent;
+    var canRead = true;
+    [backend.MIDDLEWARE_ACTIONS.readSnapshots, backend.MIDDLEWARE_ACTIONS.op].forEach(function(action) {
+      backend.use(action, function(context, next) {
+        if (canRead || context.agent !== agent1) return next();
+        next(new Error('Forbidden'));
+      });
+    });
+    var localPresence1 = presence1.create('presence-1');
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        localPresence1.submit({index: 1}, errorHandler(done));
+        presence2.once('receive', function() {
+          next();
+        });
+      },
+      function(next) {
+        doc2.submitOp({index: 5, value: 'ern'}, errorHandler(done));
+        doc1.once('op', function() {
+          next();
+        });
+      },
+      function(next) {
+        canRead = false;
+        presence2.once('receive', function(id, presence) {
+          expect(id).to.equal('presence-1');
+          expect(presence).to.be.null;
+          next();
+        });
+        connection1.close();
+      }
+    ], done);
+  });
+
   it('ignores untyped presence on its channel', function(done) {
     var connection3 = backend.connect();
     var untypedPresence3 = connection3.getPresence('books.northern-lights');

package/test/client/projections.js

@@ -26,6 +26,26 @@ module.exports = function(options) {
       });
     });
 
+    [null, 1].forEach(function(version) {
+      it('snapshot fetchSnapshot at version ' + version, function(done) {
+        this.backend.connect().fetchSnapshot('dogs_summary', 'fido', version, function(err, snapshot) {
+          if (err) return done(err);
+          expect(snapshot.data).eql({age: 3, owner: {name: 'jim'}});
+          expect(snapshot.v).eql(1);
+          done();
+        });
+      });
+    });
+
+    it('snapshot fetchSnapshotByTimestamp', function(done) {
+      this.backend.connect().fetchSnapshotByTimestamp('dogs_summary', 'fido', null, function(err, snapshot) {
+        if (err) return done(err);
+        expect(snapshot.data).eql({age: 3, owner: {name: 'jim'}});
+        expect(snapshot.v).eql(1);
+        done();
+      });
+    });
+
     if (getQuery) {
       ['createFetchQuery', 'createSubscribeQuery'].forEach(function(method) {
         it('snapshot ' + method, function(done) {

package/test/client/snapshot-timestamp-request.js

@@ -411,6 +411,23 @@ describe('SnapshotTimestampRequest', function() {
           done();
         });
       });
+
+      describe('when the database projects snapshots', function() {
+        beforeEach(function() {
+          backend.db.projectsSnapshots = true;
+        });
+
+        [null, day2].forEach(function(timestamp) {
+          it('applies the projection to a snapshot at timestamp ' + timestamp, function(done) {
+            var connection = backend.connect();
+            connection.fetchSnapshotByTimestamp('bookTitles', 'time-machine', timestamp, function(error, snapshot) {
+              if (error) return done(error);
+              expect(snapshot.data).to.eql({title: 'The Time Machine'});
+              done();
+            });
+          });
+        });
+      });
     });
   });
 

package/test/client/snapshot-version-request.js

@@ -351,6 +351,22 @@ describe('SnapshotVersionRequest', function() {
           done();
         });
       });
+
+      describe('when the database projects snapshots', function() {
+        beforeEach(function() {
+          backend.db.projectsSnapshots = true;
+        });
+
+        [null, 2].forEach(function(version) {
+          it('applies the projection to a snapshot at version ' + version, function(done) {
+            backend.connect().fetchSnapshot('bookTitles', 'don-quixote', version, function(error, snapshot) {
+              if (error) return done(error);
+              expect(snapshot.data).to.eql({title: 'Don Quixote'});
+              done();
+            });
+          });
+        });
+      });
     });
   });