sharedb 7.0.0 → 7.0.2

package/lib/agent.js

@@ -1,3 +1,4 @@
+var async = require('async');
 var hat = require('hat');
 var ShareDBError = require('./error');
 var logger = require('./logger');
@@ -5,6 +6,7 @@ var ACTIONS = require('./message-actions').ACTIONS;
 var types = require('./types');
 var util = require('./util');
 var protocol = require('./protocol');
+var DocPresence = require('./client/presence/doc-presence');
 
 var ERROR_CODE = ShareDBError.CODES;
 
@@ -45,14 +47,26 @@ function Agent(backend, stream) {
   this.presenceSubscriptionSeq = Object.create(null);
   // Keep track of the last request that has been sent by each local presence
   // belonging to this agent. This is used to generate a new disconnection
-  // request if the client disconnects ungracefully. This is a
-  // map of channel -> id -> request
+  // request if the client disconnects ungracefully, and a presence that's
+  // been replaced here by the time it would be published isn't sent. This
+  // is a map of channel -> id -> request
   this.presenceRequests = Object.create(null);
   // Keep track of the latest known Doc version, so that we can avoid fetching
   // ops to transform presence if not needed
   this.latestDocVersionStreams = Object.create(null);
   this.latestDocVersions = Object.create(null);
 
+  // Every doc, doc version and presence stream this agent holds, so that
+  // _cleanup() destroys them even if they've gone missing from their own map.
+  // Map of key -> stream
+  this._streams = Object.create(null);
+  this._nextStreamKey = 1;
+  // Presence broadcasts still in their doc version lookup or receivePresence
+  // middleware. _retractPresences() flags them to go out as a leave, and a
+  // leave from the client that gets through middleware flags its own older
+  // ones to be dropped
+  this._pendingPresenceBroadcasts = [];
+
   // We need to track this manually to make sure we don't reply to messages
   // after the stream was closed.
   this.closed = false;
@@ -93,20 +107,16 @@ Agent.prototype._cleanup = function() {
   this.backend.agentsCount--;
   if (!this.stream.isServer) this.backend.remoteAgentsCount--;
 
-  // Clean up doc subscription streams
-  for (var collection in this.subscribedDocs) {
-    var docs = this.subscribedDocs[collection];
-    for (var id in docs) {
-      var stream = docs[id];
-      stream.destroy();
-    }
+  for (var channel in this.presenceRequests) {
+    this._retractPresences(channel);
   }
-  this.subscribedDocs = Object.create(null);
 
-  for (var channel in this.subscribedPresences) {
-    this.subscribedPresences[channel].destroy();
+  for (var key in this._streams) {
+    this._streams[key].destroy();
   }
+  this.subscribedDocs = Object.create(null);
   this.subscribedPresences = Object.create(null);
+  this.latestDocVersionStreams = Object.create(null);
 
   // Clean up query subscription streams
   for (var id in this.subscribedQueries) {
@@ -114,12 +124,16 @@ Agent.prototype._cleanup = function() {
     emitter.destroy();
   }
   this.subscribedQueries = Object.create(null);
+};
 
-  for (var collection in this.latestDocVersionStreams) {
-    var streams = this.latestDocVersionStreams[collection];
-    for (var id in streams) streams[id].destroy();
-  }
-  this.latestDocVersionStreams = Object.create(null);
+Agent.prototype._trackStream = function(stream) {
+  if (stream.open === false) return;
+  var streams = this._streams;
+  var key = this._nextStreamKey++;
+  streams[key] = stream;
+  stream.once('close', function() {
+    delete streams[key];
+  });
 };
 
 /**
@@ -142,6 +156,7 @@ Agent.prototype._subscribeToStream = function(collection, id, stream) {
 
 Agent.prototype._subscribeMapToStream = function(map, collection, id, stream, dataHandler) {
   if (this.closed) return stream.destroy();
+  this._trackStream(stream);
 
   var streams = map[collection] || (map[collection] = Object.create(null));
 
@@ -163,29 +178,57 @@ Agent.prototype._subscribeMapToStream = function(map, collection, id, stream, da
 
 Agent.prototype._subscribeToPresenceStream = function(channel, stream) {
   if (this.closed) return stream.destroy();
+  this._trackStream(stream);
   var agent = this;
 
+  var previous = this.subscribedPresences[channel];
+  if (previous) previous.destroy();
+  this.subscribedPresences[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);
   });
 
   stream.on('end', function() {
-    var requests = agent.presenceRequests[channel] || {};
-    for (var id in requests) {
-      var request = agent.presenceRequests[channel][id];
-      request.seq++;
-      request.p = null;
-      agent._broadcastPresence(request, function(error) {
-        if (error) logger.error('Error broadcasting disconnect presence', channel, error);
-      });
-    }
     if (agent.subscribedPresences[channel] === stream) {
       delete agent.subscribedPresences[channel];
     }
-    delete agent.presenceRequests[channel];
+  });
+};
+
+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++) {
+    if (pendingBroadcasts[i].channel === channel) pendingBroadcasts[i].retracted = true;
+  }
+
+  var requests = this.presenceRequests[channel];
+  for (var id in requests) {
+    var request = requests[id];
+    var alreadyLeft = request.p === null;
+    if (alreadyLeft) this._unsubscribeDocVersion(request.c, request.d, function() {});
+    else this._broadcastLeave(request);
+  }
+  delete this.presenceRequests[channel];
+};
+
+Agent.prototype._broadcastLeave = function(presence, callback) {
+  var agent = this;
+  presence.p = null;
+  this._broadcastPresence(presence, [], function(error, result) {
+    if (error) logger.error('Error broadcasting disconnect presence', presence.ch, presence.id, agent._src(), error);
+    if (callback) callback(error, result);
   });
 };
 
@@ -245,7 +288,7 @@ Agent.prototype._onOp = function(collection, id, op) {
   // before calling into projection and middleware code
   var agent = this;
   util.nextTick(function() {
-    var copy = shallowCopy(op);
+    var copy = util.shallowCopy(op);
     agent.backend.sanitizeOp(agent, collection, id, copy, function(err) {
       if (err) {
         logger.error('Error sanitizing op emitted from subscription', collection, id, copy, err);
@@ -451,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 ||
@@ -466,8 +510,19 @@ Agent.prototype._checkRequest = function(request) {
   if (request.c != null && isInvalidName(request.c)) return 'Invalid collection';
   if (request.ch != null && isInvalidName(request.ch)) return 'Invalid presence channel';
   if (request.seq != null && typeof request.seq !== 'number') return 'Invalid seq';
+  if (request.a === ACTIONS.presence && isDocPresence(request) && !matchesDocPresenceChannel(request)) {
+    return 'Presence collection and doc ID do not match channel';
+  }
 };
 
+function isDocPresence(request) {
+  return request.c != null || request.d != null;
+}
+
+function matchesDocPresenceChannel(request) {
+  return !!request.c && !!request.d && request.ch === DocPresence.channel(request.c, request.d);
+}
+
 // Handle an incoming message from the client
 Agent.prototype._handleMessage = function(request, callback) {
   try {
@@ -522,7 +577,8 @@ Agent.prototype._handleMessage = function(request, callback) {
             message: 'Type does not support presence: ' + presence.t
           });
         }
-        return this._broadcastPresence(presence, callback);
+        var olderBroadcasts = presence.p === null ? this._olderPendingPresenceBroadcasts(presence) : [];
+        return this._broadcastPresence(presence, olderBroadcasts, callback);
       case ACTIONS.presenceSubscribe:
         if (!this.backend.presenceEnabled) return;
         return this._subscribePresence(request.ch, request.seq, callback);
@@ -564,6 +620,7 @@ function getQueryOptions(request) {
     }
   }
   var options = request.o || {};
+  delete options.fields;
   delete options.pollInterval;
   delete options.pollDebounce;
   options.ids = ids;
@@ -588,42 +645,50 @@ Agent.prototype._querySubscribe = function(queryId, collection, query, options,
   // Subscribe to a query. The client is sent the query results and its
   // notified whenever there's a change
   var agent = this;
-  var wait = 1;
-  var message;
-  function finish(err) {
+  this.backend.querySubscribe(this, collection, query, options, function(err, emitter, results, extra) {
     if (err) return callback(err);
-    if (--wait) return;
-    callback(null, message);
-  }
-  if (options.fetch) {
-    wait++;
-    this.backend.fetchBulk(this, collection, options.fetch, function(err, snapshotMap) {
-      if (err) return finish(err);
-      message = getMapResult(snapshotMap);
-      finish();
+    agent._fetchKnownResults(collection, options, function(err, message) {
+      if (err) {
+        emitter.destroy();
+        return callback(err);
+      }
+      if (agent.closed) return emitter.destroy();
+
+      agent._subscribeToQuery(emitter, queryId, collection, query);
+      if (results) return callback(null, {data: getResultsData(results), extra: extra});
+      // No results are returned when ids are passed in as an option. Instead,
+      // want to re-poll the entire query once we've established listeners to
+      // emit any diff in results
+      emitter.queryPoll(function(err) {
+        if (err) {
+          emitter.destroy();
+          if (agent.subscribedQueries[queryId] === emitter) delete agent.subscribedQueries[queryId];
+        }
+        callback(err, message);
+      });
     });
-  }
-  if (options.fetchOps) {
-    wait++;
-    this._fetchBulkOps(collection, options.fetchOps, finish);
-  }
-  this.backend.querySubscribe(this, collection, query, options, function(err, emitter, results, extra) {
-    if (err) return finish(err);
-    if (agent.closed) return emitter.destroy();
-
-    agent._subscribeToQuery(emitter, queryId, collection, query);
-    // No results are returned when ids are passed in as an option. Instead,
-    // want to re-poll the entire query once we've established listeners to
-    // emit any diff in results
-    if (!results) {
-      emitter.queryPoll(finish);
-      return;
+  });
+};
+
+Agent.prototype._fetchKnownResults = function(collection, options, callback) {
+  var agent = this;
+  async.parallel({
+    snapshots: function(cb) {
+      if (!options.fetch) return cb();
+      agent.backend.fetchBulk(agent, collection, options.fetch, function(err, snapshotMap) {
+        if (err) return cb(err);
+        if (hasRejectedSnapshot(snapshotMap)) return cb(new ShareDBError(ERROR_CODE.ERR_SNAPSHOT_READS_REJECTED));
+        cb(null, getMapResult(snapshotMap));
+      });
+    },
+    ops: function(cb) {
+      if (!options.fetchOps) return cb();
+      agent.backend.getOpsBulk(agent, collection, options.fetchOps, null, cb);
     }
-    message = {
-      data: getResultsData(results),
-      extra: extra
-    };
-    finish();
+  }, function(err, results) {
+    if (err) return callback(err);
+    if (results.ops) agent._sendOpsBulk(collection, results.ops);
+    callback(null, results.snapshots);
   });
 };
 
@@ -662,6 +727,13 @@ function getMapResult(snapshotMap) {
   return {data: data};
 }
 
+function hasRejectedSnapshot(snapshotMap) {
+  for (var id in snapshotMap) {
+    if (snapshotMap[id].error) return true;
+  }
+  return false;
+}
+
 function getSnapshotData(snapshot) {
   var data = {
     v: snapshot.v,
@@ -843,53 +915,92 @@ Agent.prototype._src = function() {
   return this.src || this.clientId;
 };
 
-Agent.prototype._broadcastPresence = function(presence, callback) {
+Agent.prototype._broadcastPresence = function(presence, supersededBroadcasts, callback) {
   var agent = this;
   var backend = this.backend;
-  var presenceRequests = this.presenceRequests;
+  var leaving = presence.p === null;
+  var pendingBroadcast = this._addPendingPresenceBroadcast(presence);
   var context = {
     presence: presence,
     collection: presence.c
   };
   var start = Date.now();
 
-  var subscriptionUpdater = presence.p === null ?
+  var subscriptionUpdater = leaving ?
     this._unsubscribeDocVersion.bind(this) :
     this._subscribeDocVersion.bind(this);
 
   subscriptionUpdater(presence.c, presence.d, function(error) {
-    if (error) return callback(error);
+    if (error) {
+      agent._removePendingPresenceBroadcast(pendingBroadcast);
+      return callback(error);
+    }
     backend.trigger(backend.MIDDLEWARE_ACTIONS.receivePresence, agent, context, function(error) {
+      agent._removePendingPresenceBroadcast(pendingBroadcast);
       if (error) return callback(error);
-      var requests = presenceRequests[presence.ch] || (presenceRequests[presence.ch] = Object.create(null));
-      var previousRequest = requests[presence.id];
-      if (!previousRequest || previousRequest.pv < presence.pv) {
-        presenceRequests[presence.ch][presence.id] = presence;
+      for (var i = 0; i < supersededBroadcasts.length; i++) {
+        supersededBroadcasts[i].superseded = true;
       }
-
-      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);
+      if (pendingBroadcast.superseded && !leaving) {
+        return agent._unsubscribeDocVersion(presence.c, presence.d, function() {
+          callback(null, presence);
+        });
+      }
+      var clientHasLeft = agent.closed || pendingBroadcast.retracted;
+      if (clientHasLeft && !leaving) return agent._broadcastLeave(presence, callback);
+      var requests = agent.presenceRequests[presence.ch] || (agent.presenceRequests[presence.ch] = Object.create(null));
+      var previousRequest = requests[presence.id];
+      if (!previousRequest || previousRequest.p === null || previousRequest.pv < presence.pv) {
+        requests[presence.id] = presence;
       }
 
-      transformer(agent, presence, function(error, presence) {
-        if (error) return callback(error);
-        var channel = agent._getPresenceChannel(presence.ch);
-        agent.backend.pubsub.publish([channel], presence, function(error) {
+      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);
+        }
+        var replaced = util.dig(agent.presenceRequests, presence.ch, presence.id) !== presence;
+        if (replaced && !leaving) return callback(null, transformedPresence);
+        var channel = agent._getPresenceChannel(transformedPresence.ch);
+        agent.backend.pubsub.publish([channel], transformedPresence, function(error) {
           if (error) return callback(error);
           backend.emit('timing', 'presence.broadcast', Date.now() - start, context);
-          callback(null, presence);
+          callback(null, transformedPresence);
         });
       });
     });
   });
 };
 
+Agent.prototype._withdrawPresenceRequest = function(requests, presence, previousRequest) {
+  if (requests[presence.id] !== presence) return;
+  if (previousRequest) requests[presence.id] = previousRequest;
+  else presence.p = null;
+};
+
+Agent.prototype._addPendingPresenceBroadcast = function(presence) {
+  var broadcast = {channel: presence.ch, id: presence.id, pv: presence.pv, retracted: false, superseded: false};
+  this._pendingPresenceBroadcasts.push(broadcast);
+  return broadcast;
+};
+
+Agent.prototype._removePendingPresenceBroadcast = function(broadcast) {
+  var index = this._pendingPresenceBroadcasts.indexOf(broadcast);
+  if (index !== -1) this._pendingPresenceBroadcasts.splice(index, 1);
+};
+
+Agent.prototype._olderPendingPresenceBroadcasts = function(presence) {
+  var olderBroadcasts = [];
+  var pendingBroadcasts = this._pendingPresenceBroadcasts;
+  for (var i = 0; i < pendingBroadcasts.length; i++) {
+    var broadcast = pendingBroadcasts[i];
+    var isOlder = broadcast.channel === presence.ch && broadcast.id === presence.id && broadcast.pv < presence.pv;
+    if (isOlder) olderBroadcasts.push(broadcast);
+  }
+  return olderBroadcasts;
+};
+
 Agent.prototype._subscribeDocVersion = function(collection, id, callback) {
   if (!collection || !id) return callback();
 
@@ -905,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;
     });
@@ -957,11 +1069,6 @@ Agent.prototype._subscribePresence = function(channel, seq, cb) {
       return callback();
     }
     agent.presenceSubscriptionSeq[channel] = seq;
-    if (agent.subscribedPresences[channel]) {
-      stream.destroy();
-      return callback();
-    }
-    agent.subscribedPresences[channel] = stream;
     agent._subscribeToPresenceStream(channel, stream);
     agent._requestPresence(channel, function(error) {
       callback(error);
@@ -974,6 +1081,7 @@ Agent.prototype._unsubscribePresence = function(channel, seq, callback) {
   var stream = this.subscribedPresences[channel];
   if (stream) stream.destroy();
   delete this.subscribedPresences[channel];
+  this._retractPresences(channel);
   callback(null, {ch: channel, seq: seq});
 };
 
@@ -1037,16 +1145,6 @@ function createClientOp(request, clientId) {
         undefined;
 }
 
-function shallowCopy(object) {
-  var out = {};
-  for (var key in object) {
-    if (util.hasOwn(object, key)) {
-      out[key] = object[key];
-    }
-  }
-  return out;
-}
-
 function CreateOp(src, seq, v, create, x, c, d, m) {
   this.src = src;
   this.seq = seq;

package/lib/backend.js

@@ -89,6 +89,8 @@ Backend.prototype.MIDDLEWARE_ACTIONS = {
   receivePresence: 'receivePresence',
   // About to send presence information to a client
   sendPresence: 'sendPresence',
+  // An operation lost the race to commit and is about to be retried against a newer snapshot
+  retry: 'retry',
   // An operation is about to be submitted to the database
   submit: 'submit'
 };
@@ -936,18 +938,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/lib/client/presence/doc-presence.js

@@ -17,6 +17,12 @@ DocPresence.channel = function(collection, id) {
   return collection + '.' + id;
 };
 
+DocPresence.prototype._receiveUpdate = function(error, message) {
+  var isForThisDoc = message.c === this.collection && message.d === this.id;
+  if (!error && !isForThisDoc) return;
+  Presence.prototype._receiveUpdate.call(this, error, message);
+};
+
 DocPresence.prototype._createLocalPresence = function(id) {
   return new LocalDocPresence(this, id);
 };

package/lib/client/presence/presence.js

@@ -120,10 +120,13 @@ Presence.prototype._handleUnsubscribe = function(error, seq) {
 };
 
 Presence.prototype._receiveUpdate = function(error, message) {
+  var isErrorForOwnRequest = !!error && message.pv != null;
+  var isFromThisConnection = message.src === this.connection.id;
   var localPresence = util.dig(this.localPresences, message.id);
-  if (localPresence) return localPresence._ack(error, message.pv);
+  if (localPresence && (isErrorForOwnRequest || isFromThisConnection)) return localPresence._ack(error, message.pv);
 
   if (error) return this.emit('error', error);
+  if (localPresence) return;
   var presence = this;
   var remotePresence = util.digOrCreate(this._remotePresenceInstances, message.id, function() {
     return presence._createRemotePresence(message.id);

package/lib/pubsub/index.js

@@ -14,13 +14,12 @@ function PubSub(options) {
   this.streamsCount = 0;
   // Maps channel -> id -> stream
   this.streams = Object.create(null);
-  // State for tracking subscriptions. We track this.subscribed separately from
-  // the streams, since the stream gets added synchronously, and the subscribe
-  // isn't complete until the callback returns from Redis
   // Maps channel -> true
   this.subscribed = Object.create(null);
   // Maps channel -> callbacks waiting on _subscribe
   this._subscribing = Object.create(null);
+  // Maps channel -> true while _unsubscribe is in flight
+  this._unsubscribing = Object.create(null);
 
   var pubsub = this;
   this._defaultCallback = function(err) {
@@ -70,10 +69,9 @@ PubSub.prototype.subscribe = function(channel, callback) {
     channel = this.prefix + ' ' + channel;
   }
 
-  var pubsub = this;
   if (this.subscribed[channel]) {
+    var stream = this._createStream(channel);
     util.nextTick(function() {
-      var stream = pubsub._createStream(channel);
       callback(null, stream);
     });
     return;
@@ -82,7 +80,14 @@ PubSub.prototype.subscribe = function(channel, callback) {
     this._subscribing[channel].push(callback);
     return;
   }
-  var callbacks = this._subscribing[channel] = [callback];
+  this._subscribing[channel] = [callback];
+  if (this._unsubscribing[channel]) return;
+  this._startSubscribe(channel);
+};
+
+PubSub.prototype._startSubscribe = function(channel) {
+  var pubsub = this;
+  var callbacks = this._subscribing[channel];
   this._subscribe(channel, function(err) {
     delete pubsub._subscribing[channel];
     if (err) return util.callEach(callbacks, err);
@@ -142,9 +147,16 @@ PubSub.prototype._removeStream = function(channel, stream) {
   delete this.streams[channel];
   // Synchronously clear subscribed state. We won't actually be unsubscribed
   // until some unknown time in the future. If subscribe is called in this
-  // period, we want to send a subscription message and wait for it to
-  // complete before we can count on being subscribed again
+  // period, it waits for the unsubscribe to complete before calling
+  // _subscribe, since an adapter may drop a subscription made while an
+  // unsubscribe from the same channel is still pending
   delete this.subscribed[channel];
 
-  this._unsubscribe(channel, this._defaultCallback);
+  var pubsub = this;
+  this._unsubscribing[channel] = true;
+  this._unsubscribe(channel, function(err) {
+    delete pubsub._unsubscribing[channel];
+    if (pubsub._subscribing[channel]) pubsub._startSubscribe(channel);
+    pubsub._defaultCallback(err);
+  });
 };

package/lib/query-emitter.js

@@ -197,7 +197,9 @@ QueryEmitter.prototype.queryPoll = function(callback) {
   clearTimeout(this._pollIntervalId);
 
   var start = Date.now();
-  this.db.queryPoll(this.collection, this.query, this.options, function(err, ids, extra) {
+  var pollOptions = util.shallowCopy(this.options);
+  pollOptions.fields = this.fields;
+  this.db.queryPoll(this.collection, this.query, pollOptions, function(err, ids, extra) {
     if (err) return emitter._finishPoll(err, callback, pending);
     emitter._emitTiming('queryEmitter.poll', start);
 
@@ -306,11 +308,9 @@ QueryEmitter.prototype.queryPollDoc = function(id, callback) {
   });
 };
 
-// Clients must assign each of these functions synchronously after constructing
-// an instance of QueryEmitter. The instance is subscribed to an op stream at
-// construction time, and does not buffer emitted events. Diff events assume
-// all messages are received and applied in order, so it is critical that none
-// are dropped.
+// Clients must assign each of these functions before calling _open(). The op
+// streams buffer emitted events until then. Diff events assume all messages
+// are received and applied in order, so it is critical that none are dropped.
 QueryEmitter.prototype.onError =
   QueryEmitter.prototype.onDiff =
   QueryEmitter.prototype.onExtra =