sharedb 3.3.1 → 4.0.1

package/lib/agent.js

@@ -58,6 +58,11 @@ function Agent(backend, stream) {
   // active, and it is passed to each middleware call
   this.custom = {};
 
+  // The first message received over the connection. Stored to warn if messages
+  // are being sent before the handshake.
+  this._firstReceivedMessage = null;
+  this._handshakeReceived = false;
+
   // Send the legacy message to initialize old clients with the random agent Id
   this.send(this._initMessage(ACTIONS.initLegacy));
 }
@@ -394,6 +399,7 @@ Agent.prototype._handleMessage = function(request, callback) {
   try {
     var errMessage = this._checkRequest(request);
     if (errMessage) return callback(new ShareDBError(ERROR_CODE.ERR_MESSAGE_BADLY_FORMED, errMessage));
+    this._checkFirstMessage(request);
 
     switch (request.a) {
       case ACTIONS.handshake:
@@ -855,6 +861,20 @@ Agent.prototype._handlePresenceData = function(presence) {
   });
 };
 
+Agent.prototype._checkFirstMessage = function(request) {
+  if (this._handshakeReceived) return;
+  if (!this._firstReceivedMessage) this._firstReceivedMessage = request;
+
+  if (request.a === ACTIONS.handshake) {
+    this._handshakeReceived = true;
+    if (this._firstReceivedMessage.a !== ACTIONS.handshake) {
+      logger.warn('Unexpected message received before handshake', this._firstReceivedMessage);
+    }
+    // Release memory
+    this._firstReceivedMessage = null;
+  }
+};
+
 function createClientOp(request, clientId) {
   // src can be provided if it is not the same as the current agent,
   // such as a resubmission after a reconnect, but it usually isn't needed

package/lib/client/doc.js

@@ -425,12 +425,17 @@ Doc.prototype._resubscribe = function() {
 
 // Request the current document snapshot or ops that bring us up to date
 Doc.prototype.fetch = function(callback) {
-  if (this.connection.canSend) {
-    var isDuplicate = this.connection.sendFetch(this);
-    pushActionCallback(this.inflightFetch, isDuplicate, callback);
-    return;
-  }
+  this._fetch({}, callback);
+};
+
+Doc.prototype._fetch = function(options, callback) {
   this.pendingFetch.push(callback);
+  var shouldSend = this.connection.canSend && (
+    options.force || !this.inflightFetch.length
+  );
+  if (!shouldSend) return;
+  this.inflightFetch.push(this.pendingFetch.shift());
+  this.connection.sendFetch(this);
 };
 
 // Fetch the initial document and keep receiving updates
@@ -490,18 +495,6 @@ Doc.prototype._flushSubscribe = function() {
   }
 };
 
-function pushActionCallback(inflight, isDuplicate, callback) {
-  if (isDuplicate) {
-    var lastCallback = inflight.pop();
-    inflight.push(function(err) {
-      lastCallback && lastCallback(err);
-      callback && callback(err);
-    });
-  } else {
-    inflight.push(callback);
-  }
-}
-
 function combineCallbacks(callbacks) {
   callbacks = callbacks.filter(util.truthy);
   if (!callbacks.length) return null;
@@ -1043,7 +1036,7 @@ 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(function() {
+  this._fetch({force: true}, function() {
     // 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/package.json

@@ -1,28 +1,28 @@
 {
   "name": "sharedb",
-  "version": "3.3.1",
+  "version": "4.0.1",
   "description": "JSON OT database backend",
   "main": "lib/index.js",
   "dependencies": {
-    "arraydiff": "^0.1.1",
-    "async": "^2.6.3",
-    "fast-deep-equal": "^2.0.1",
+    "arraydiff": "^0.1.3",
+    "async": "^3.2.4",
+    "fast-deep-equal": "^3.1.3",
     "hat": "0.0.3",
-    "ot-json0": "^1.0.1"
+    "ot-json0": "^1.1.0"
   },
   "devDependencies": {
-    "chai": "^4.2.0",
-    "coveralls": "^3.0.7",
-    "eslint": "^7.32.0",
+    "chai": "^4.3.7",
+    "coveralls": "^3.1.1",
+    "eslint": "^8.47.0",
     "eslint-config-google": "^0.14.0",
-    "lolex": "^5.1.1",
-    "mocha": "^8.2.1",
-    "nyc": "^14.1.1",
+    "mocha": "^10.2.0",
+    "nyc": "^15.1.0",
     "ot-json0-v2": "https://github.com/ottypes/json0#90a3ae26364c4fa3b19b6df34dad46707a704421",
-    "ot-json1": "^0.3.0",
+    "ot-json1": "^1.0.2",
     "rich-text": "^4.1.0",
     "sharedb-legacy": "npm:sharedb@=1.1.0",
-    "sinon": "^9.2.4"
+    "sinon": "^15.2.0",
+    "sinon-chai": "^3.7.0"
   },
   "files": [
     "lib/",

package/test/agent.js

@@ -0,0 +1,74 @@
+var Backend = require('../lib/backend');
+var logger = require('../lib/logger');
+var sinon = require('sinon');
+var StreamSocket = require('../lib/stream-socket');
+var expect = require('chai').expect;
+var ACTIONS = require('../lib/message-actions').ACTIONS;
+var Connection = require('../lib/client/connection');
+var LegacyConnection = require('sharedb-legacy/lib/client').Connection;
+
+describe('Agent', function() {
+  var backend;
+
+  beforeEach(function() {
+    backend = new Backend();
+  });
+
+  afterEach(function(done) {
+    backend.close(done);
+  });
+
+  describe('handshake', function() {
+    it('warns when messages are sent before the handshake', function(done) {
+      var socket = new StreamSocket();
+      var stream = socket.stream;
+      backend.listen(stream);
+      sinon.spy(logger, 'warn');
+      socket.send(JSON.stringify({a: ACTIONS.subscribe, c: 'dogs', d: 'fido'}));
+      var connection = new Connection(socket);
+      socket._open();
+      connection.once('connected', function() {
+        expect(logger.warn).to.have.been.calledOnceWithExactly(
+          'Unexpected message received before handshake',
+          {a: ACTIONS.subscribe, c: 'dogs', d: 'fido'}
+        );
+        done();
+      });
+    });
+
+    it('does not warn when messages are sent after the handshake', function(done) {
+      var socket = new StreamSocket();
+      var stream = socket.stream;
+      var agent = backend.listen(stream);
+      sinon.spy(logger, 'warn');
+      var connection = new Connection(socket);
+      socket._open();
+      connection.once('connected', function() {
+        socket.send(JSON.stringify({a: ACTIONS.subscribe, c: 'dogs', d: 'fido'}));
+        expect(logger.warn).not.to.have.been.called;
+        expect(agent._firstReceivedMessage).to.be.null;
+        done();
+      });
+    });
+
+    it('does not warn for clients on protocol v1.0', function(done) {
+      backend.use('receive', function(request, next) {
+        var error = null;
+        if (request.data.a === ACTIONS.handshake) error = new Error('Unexpected handshake');
+        next(error);
+      });
+      var socket = new StreamSocket();
+      var stream = socket.stream;
+      backend.listen(stream);
+      sinon.spy(logger, 'warn');
+      socket.send(JSON.stringify({a: ACTIONS.subscribe, c: 'dogs', d: 'fido'}));
+      var connection = new LegacyConnection(socket);
+      socket._open();
+      connection.get('dogs', 'fido').fetch(function(error) {
+        if (error) return done(error);
+        expect(logger.warn).not.to.have.been.called;
+        done();
+      });
+    });
+  });
+});

package/test/client/doc.js

@@ -5,6 +5,7 @@ var json0 = require('ot-json0').type;
 var richText = require('rich-text').type;
 var ShareDBError = require('../../lib/error');
 var errorHandler = require('../util').errorHandler;
+var sinon = require('sinon');
 
 describe('Doc', function() {
   beforeEach(function() {
@@ -84,6 +85,23 @@ describe('Doc', function() {
     });
   });
 
+  describe('fetch', function() {
+    it('only fetches once when calling in quick succession', function(done) {
+      var connection = this.connection;
+      var doc = connection.get('dogs', 'fido');
+      sinon.spy(connection, 'sendFetch');
+      var count = 0;
+      var finish = function() {
+        count++;
+        expect(connection.sendFetch).to.have.been.calledOnce;
+        if (count === 3) done();
+      };
+      doc.fetch(finish);
+      doc.fetch(finish);
+      doc.fetch(finish);
+    });
+  });
+
   describe('when connection closed', function() {
     beforeEach(function(done) {
       this.op1 = [{p: ['snacks'], oi: true}];

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

@@ -1,6 +1,5 @@
 var Backend = require('../../lib/backend');
 var expect = require('chai').expect;
-var lolex = require('lolex');
 var MemoryDb = require('../../lib/db/memory');
 var MemoryMilestoneDb = require('../../lib/milestone-db/memory');
 var sinon = require('sinon');
@@ -18,7 +17,7 @@ describe('SnapshotTimestampRequest', function() {
   var ONE_DAY = 1000 * 60 * 60 * 24;
 
   beforeEach(function() {
-    clock = lolex.install({now: day1});
+    clock = sinon.useFakeTimers(day1);
     backend = new Backend();
   });
 

package/test/client/subscribe.js

@@ -838,46 +838,6 @@ module.exports = function() {
       });
     });
 
-    it('doc fetches ops to catch up if it receives multiple future ops', function(done) {
-      var backend = this.backend;
-      var doc = this.backend.connect().get('dogs', 'fido').on('error', done);
-      var doc2 = this.backend.connect().get('dogs', 'fido').on('error', done);
-      // Delaying op replies will cause multiple future ops to be received
-      // before the fetch to catch up completes
-      backend.use('op', function(request, next) {
-        setTimeout(next, 10 * Math.random());
-      });
-      doc.create({age: 3}, function(err) {
-        if (err) return done(err);
-        doc2.subscribe(function(err) {
-          if (err) return done(err);
-          var wait = 4;
-          doc2.on('op', function() {
-            if (--wait) return;
-            expect(doc2.version).eql(5);
-            expect(doc2.data).eql({age: 122});
-            // Wait for whenNothingPending, because the doc might have kicked
-            // off multiple fetches, and some could be pending still. We want to
-            // resolve all inflight requests of the database before closing and
-            // proceeding to the next test
-            doc2.whenNothingPending(done);
-          });
-          backend.suppressPublish = true;
-          doc.submitOp({p: ['age'], na: 1}, function(err) {
-            if (err) return done(err);
-            backend.suppressPublish = false;
-            doc.submitOp({p: ['age'], na: 5}, function(err) {
-              if (err) return done(err);
-              doc.submitOp({p: ['age'], na: 13}, function(err) {
-                if (err) return done(err);
-                doc.submitOp({p: ['age'], na: 100});
-              });
-            });
-          });
-        });
-      });
-    });
-
     describe('doc.subscribed', function() {
       it('is set to false initially', function(done) {
         var doc = this.backend.connect().get('dogs', 'fido').on('error', done);

package/test/middleware.js

@@ -734,11 +734,11 @@ describe('middleware', function() {
         next();
       });
 
-      sinon.spy(doc, 'fetch');
+      sinon.spy(doc, '_fetch');
 
       doc.submitOp([{p: ['fetch'], oi: true}], function(error) {
         expect(error).to.be.ok;
-        expect(doc.fetch.calledOnce).to.be.true;
+        expect(doc._fetch.calledOnce).to.be.true;
         done();
       });
     });

package/test/setup.js

@@ -1,5 +1,9 @@
 var logger = require('../lib/logger');
 var sinon = require('sinon');
+var sinonChai = require('sinon-chai');
+var chai = require('chai');
+
+chai.use(sinonChai);
 
 if (process.env.LOGGING !== 'true') {
   // Silence the logger for tests by setting all its methods to no-ops