sharedb 3.1.0 → 3.2.1

package/lib/agent.js

@@ -447,6 +447,8 @@ Agent.prototype._handleMessage = function(request, callback) {
         return this._subscribePresence(request.ch, request.seq, callback);
       case ACTIONS.presenceUnsubscribe:
         return this._unsubscribePresence(request.ch, request.seq, callback);
+      case ACTIONS.pingPong:
+        return this._pingPong(callback);
       default:
         callback(new ShareDBError(ERROR_CODE.ERR_MESSAGE_BADLY_FORMED, 'Invalid or unknown message'));
     }
@@ -540,6 +542,14 @@ Agent.prototype._querySubscribe = function(queryId, collection, query, options,
   });
 };
 
+Agent.prototype._pingPong = function(callback) {
+  var error = null;
+  var message = {
+    a: ACTIONS.pingPong
+  };
+  callback(error, message);
+};
+
 function getResultsData(results) {
   var items = [];
   for (var i = 0; i < results.length; i++) {

package/lib/client/connection.js

@@ -253,6 +253,8 @@ Connection.prototype.handleMessage = function(message) {
       return this._handlePresenceUnsubscribe(err, message);
     case ACTIONS.presenceRequest:
       return this._handlePresenceRequest(err, message);
+    case ACTIONS.pingPong:
+      return this._handlePingPong(err);
 
     default:
       logger.warn('Ignoring unrecognized message', message);
@@ -476,6 +478,19 @@ Connection.prototype.send = function(message) {
   this.socket.send(JSON.stringify(message));
 };
 
+Connection.prototype.ping = function() {
+  if (!this.canSend) {
+    throw new ShareDBError(
+      ERROR_CODE.ERR_CANNOT_PING_OFFLINE,
+      'Socket must be CONNECTED to ping'
+    );
+  }
+
+  var message = {
+    a: ACTIONS.pingPong
+  };
+  this.send(message);
+};
 
 /**
  * Closes the socket and emits 'closed'
@@ -506,6 +521,7 @@ Connection.prototype.get = function(collection, id) {
     this.emit('doc', doc);
   }
 
+  doc._wantsDestroy = false;
   return doc;
 };
 
@@ -516,7 +532,9 @@ Connection.prototype.get = function(collection, id) {
  * @private
  */
 Connection.prototype._destroyDoc = function(doc) {
+  if (!doc._wantsDestroy) return;
   util.digAndRemove(this.collections, doc.collection, doc.id);
+  doc.emit('destroy');
 };
 
 Connection.prototype._addDoc = function(doc) {
@@ -725,6 +743,11 @@ Connection.prototype._handleHandshake = function(error, message) {
   this._initialize(message);
 };
 
+Connection.prototype._handlePingPong = function(error) {
+  if (error) return this.emit('error', error);
+  this.emit('pong');
+};
+
 Connection.prototype._initialize = function(message) {
   if (this.state !== 'connecting') return;
 
@@ -753,17 +776,21 @@ Connection.prototype._initialize = function(message) {
 
 Connection.prototype.getPresence = function(channel) {
   var connection = this;
-  return util.digOrCreate(this._presences, channel, function() {
+  var presence = util.digOrCreate(this._presences, channel, function() {
     return new Presence(connection, channel);
   });
+  presence._wantsDestroy = false;
+  return presence;
 };
 
 Connection.prototype.getDocPresence = function(collection, id) {
   var channel = DocPresence.channel(collection, id);
   var connection = this;
-  return util.digOrCreate(this._presences, channel, function() {
+  var presence = util.digOrCreate(this._presences, channel, function() {
     return new DocPresence(connection, collection, id);
   });
+  presence._wantsDestroy = false;
+  return presence;
 };
 
 Connection.prototype._sendPresenceAction = function(action, seq, presence) {

package/lib/client/doc.js

@@ -76,6 +76,8 @@ function Doc(connection, collection, id) {
   // Whether to re-establish the subscription on reconnect
   this.wantSubscribe = false;
 
+  this._wantsDestroy = false;
+
   // The op that is currently roundtripping to the server, or null.
   //
   // When the connection reconnects, the inflight op is resubmitted.
@@ -122,6 +124,7 @@ function Doc(connection, collection, id) {
 emitter.mixin(Doc);
 
 Doc.prototype.destroy = function(callback) {
+  this._wantsDestroy = true;
   var doc = this;
   doc.whenNothingPending(function() {
     if (doc.wantSubscribe) {
@@ -131,12 +134,10 @@ Doc.prototype.destroy = function(callback) {
           return doc.emit('error', err);
         }
         doc.connection._destroyDoc(doc);
-        doc.emit('destroy');
         if (callback) callback();
       });
     } else {
       doc.connection._destroyDoc(doc);
-      doc.emit('destroy');
       if (callback) callback();
     }
   });

package/lib/client/presence/presence.js

@@ -24,6 +24,7 @@ function Presence(connection, channel) {
 
   this._remotePresenceInstances = {};
   this._subscriptionCallbacksBySeq = {};
+  this._wantsDestroy = false;
 }
 emitter.mixin(Presence);
 
@@ -36,6 +37,9 @@ Presence.prototype.unsubscribe = function(callback) {
 };
 
 Presence.prototype.create = function(id) {
+  if (this._wantsDestroy) {
+    throw new Error('Presence is being destroyed');
+  }
   id = id || hat();
   var localPresence = this._createLocalPresence(id);
   this.localPresences[id] = localPresence;
@@ -43,10 +47,15 @@ Presence.prototype.create = function(id) {
 };
 
 Presence.prototype.destroy = function(callback) {
+  this._wantsDestroy = true;
   var presence = this;
+  // Store these at the time of destruction: any LocalPresence on this
+  // instance at this time will be destroyed, but if the destroy is
+  // cancelled, any future LocalPresence objects will be kept.
+  // See: https://github.com/share/sharedb/pull/579
+  var localIds = Object.keys(presence.localPresences);
   this.unsubscribe(function(error) {
     if (error) return presence._callbackOrEmit(error, callback);
-    var localIds = Object.keys(presence.localPresences);
     var remoteIds = Object.keys(presence._remotePresenceInstances);
     async.parallel(
       [
@@ -56,13 +65,18 @@ Presence.prototype.destroy = function(callback) {
           }, next);
         },
         function(next) {
+          // We don't bother stashing the RemotePresence instances because
+          // they're not really bound to our local state: if we want to
+          // destroy, we destroy them all, but if we cancel the destroy,
+          // we'll want to keep them all
+          if (!presence._wantsDestroy) return next();
           async.each(remoteIds, function(presenceId, next) {
             presence._remotePresenceInstances[presenceId].destroy(next);
           }, next);
         }
       ],
       function(error) {
-        delete presence.connection._presences[presence.channel];
+        if (presence._wantsDestroy) delete presence.connection._presences[presence.channel];
         presence._callbackOrEmit(error, callback);
       }
     );

package/lib/error.js

@@ -16,6 +16,7 @@ ShareDBError.CODES = {
   ERR_APPLY_OP_VERSION_DOES_NOT_MATCH_SNAPSHOT: 'ERR_APPLY_OP_VERSION_DOES_NOT_MATCH_SNAPSHOT',
   ERR_APPLY_SNAPSHOT_NOT_PROVIDED: 'ERR_APPLY_SNAPSHOT_NOT_PROVIDED',
   ERR_CLIENT_ID_BADLY_FORMED: 'ERR_CLIENT_ID_BADLY_FORMED',
+  ERR_CANNOT_PING_OFFLINE: 'ERR_CANNOT_PING_OFFLINE',
   ERR_CONNECTION_SEQ_INTEGER_OVERFLOW: 'ERR_CONNECTION_SEQ_INTEGER_OVERFLOW',
   ERR_CONNECTION_STATE_TRANSITION_INVALID: 'ERR_CONNECTION_STATE_TRANSITION_INVALID',
   ERR_DATABASE_ADAPTER_NOT_FOUND: 'ERR_DATABASE_ADAPTER_NOT_FOUND',

package/lib/message-actions.js

@@ -14,6 +14,7 @@ exports.ACTIONS = {
   op: 'op',
   snapshotFetch: 'nf',
   snapshotFetchByTimestamp: 'nt',
+  pingPong: 'pp',
   presence: 'p',
   presenceSubscribe: 'ps',
   presenceUnsubscribe: 'pu',

package/package.json

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

package/test/client/connection.js

@@ -124,6 +124,45 @@ describe('client connection', function() {
     });
   });
 
+  describe('ping/pong', function() {
+    it('pings the backend', function(done) {
+      var connection = this.backend.connect();
+
+      connection.on('pong', function() {
+        done();
+      });
+
+      connection.on('connected', function() {
+        connection.ping();
+      });
+    });
+
+    it('handles errors', function(done) {
+      this.backend.use('receive', function(request, next) {
+        var error = request.data.a === 'pp' && new Error('bad');
+        next(error);
+      });
+
+      var connection = this.backend.connect();
+
+      connection.on('error', function(error) {
+        expect(error.message).to.equal('bad');
+        done();
+      });
+
+      connection.on('connected', function() {
+        connection.ping();
+      });
+    });
+
+    it('throws if pinging offline', function() {
+      var connection = this.backend.connect();
+      expect(function() {
+        connection.ping();
+      }).to.throw('Socket must be CONNECTED to ping');
+    });
+  });
+
   describe('backend.agentsCount', function() {
     it('updates after connect and connection.close()', function(done) {
       var backend = this.backend;

package/test/client/doc.js

@@ -43,11 +43,31 @@ describe('Doc', function() {
       if (err) return done(err);
       var doc2 = connection.get('dogs', 'fido');
       expect(doc).not.equal(doc2);
-      expect(doc).eql(doc2);
       done();
     });
   });
 
+  it('destroying then getting synchronously does not destroy the new doc', function(done) {
+    var connection = this.connection;
+    var doc = connection.get('dogs', 'fido');
+    var doc2;
+
+    doc.create({name: 'fido'}, function(error) {
+      if (error) return done(error);
+
+      doc.destroy(function(error) {
+        if (error) return done(error);
+        var doc3 = connection.get('dogs', 'fido');
+        async.parallel([
+          doc2.submitOp.bind(doc2, [{p: ['snacks'], oi: true}]),
+          doc3.submitOp.bind(doc3, [{p: ['color'], oi: 'gray'}])
+        ], done);
+      });
+
+      doc2 = connection.get('dogs', 'fido');
+    });
+  });
+
   it('doc.destroy() works without a callback', function() {
     var doc = this.connection.get('dogs', 'fido');
     doc.destroy();

package/test/client/presence/presence.js

@@ -98,6 +98,118 @@ describe('Presence', function() {
     ], done);
   });
 
+  it('gets presence during a destroy', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    var presence2a;
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        presence2.destroy(errorHandler(done));
+        next();
+      },
+      function(next) {
+        presence2a = connection2.getPresence('test-channel');
+        presence2a.subscribe(function(error) {
+          next(error);
+        });
+      },
+      function(next) {
+        localPresence1.submit({index: 5}, errorHandler(done));
+        presence2a.once('receive', function() {
+          next();
+        });
+      }
+    ], done);
+  });
+
+  it('destroys old local presence but keeps new local presence when getting during destroy', function(done) {
+    presence2.create('presence-2');
+    var presence2a;
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        presence2.destroy(function() {
+          expect(presence2).to.equal(presence2a);
+          expect(Object.keys(presence2.localPresences)).to.eql(['presence-2a']);
+          done();
+        });
+        next();
+      },
+      function(next) {
+        presence2a = connection2.getPresence('test-channel');
+        presence2a.create('presence-2a');
+        presence2a.subscribe(function(error) {
+          next(error);
+        });
+      }
+    ], errorHandler(done));
+  });
+
+  it('destroys old local presence but keeps new local presence when getting during destroy', function(done) {
+    presence2.create('presence-2');
+    var presence2a;
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        presence2.destroy(function() {
+          expect(presence2).to.equal(presence2a);
+          expect(Object.keys(presence2.localPresences)).to.eql(['presence-2a']);
+          done();
+        });
+        next();
+      },
+      function(next) {
+        presence2a = connection2.getPresence('test-channel');
+        presence2a.create('presence-2a');
+        presence2a.subscribe(function(error) {
+          next(error);
+        });
+      }
+    ], errorHandler(done));
+  });
+
+  it('throws if trying to create local presence when wanting destroy', function(done) {
+    presence2.destroy(errorHandler(done));
+    expect(function() {
+      presence2.create('presence-2');
+    }).to.throw('Presence is being destroyed');
+    done();
+  });
+
+  it('gets presence after destroy unsubscribe', function(done) {
+    var localPresence2 = presence2.create('presence-2');
+    var presence2a;
+
+    var flushLocalPresence2Destroy;
+    sinon.stub(localPresence2, 'destroy').callsFake(function(callback) {
+      flushLocalPresence2Destroy = callback;
+    });
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        presence2.destroy(function() {
+          expect(connection2.getPresence('test-channel')).to.equal(presence2a);
+          done();
+        });
+        next();
+      },
+      // Wait for the destroy unsubscribe callback to start, where we check
+      // _wantsDestroy for the first time
+      presence2.unsubscribe.bind(presence2),
+      function(next) {
+        presence2a = connection2.getPresence('test-channel');
+        presence2a.subscribe(function(error) {
+          next(error);
+        });
+        flushLocalPresence2Destroy();
+      }
+    ], errorHandler(done));
+  });
+
   it('requests existing presence from other subscribed clients when subscribing', function(done) {
     var localPresence1 = presence1.create('presence-1');
     async.series([

package/CHANGELOG.md

@@ -1,44 +0,0 @@
-## v2.0
-
-### Breaking changes
-
-* Drop Node.js v10 support
-
-## v1.0-beta
-
-### Breaking changes
-
-* Add options argument to all public database adapter methods that read
-  or write from snapshots or ops.
-
-* DB methods that get snapshots or ops no longer return metadata unless
-  `{metadata: true}` option is passed.
-
-* Replace `source` argument with `options` in doc methods. Use `options.source`
-  instead.
-
-* Backend streams now write objects intead of strings.
-
-* MemoryDB.prototype._querySync now returns `{snapshots: ..., extra: ...}`
-  instead of just an array of snapshots.
-
-### Non-breaking changes
-
-* Add options argument to backend.submit.
-
-* Add error codes to all errors.
-
-* Add `'updated'` event on queries which fires on all query result changes.
-
-* In clients, wrap errors in Error objects to they get passed through event
-  emitters.
-
-* Sanitize stack traces when sending errors to client, but log them on the
-  server.
-
-## v0.11.37
-
-Beginning of changelog.
-
-If you're upgrading from ShareJS 0.7 or earlier,
-take a look at the [ShareJS upgrade guide](docs/upgrading-from-sharejs.md).