sharedb 3.2.4 → 3.3.1

package/lib/agent.js

@@ -718,9 +718,10 @@ Agent.prototype._unsubscribeBulk = function(collection, ids, callback) {
 
 Agent.prototype._submit = function(collection, id, op, callback) {
   var agent = this;
-  this.backend.submit(this, collection, id, op, null, function(err, ops) {
+  this.backend.submit(this, collection, id, op, null, function(err, ops, request) {
     // Message to acknowledge the op was successfully submitted
     var ack = {src: op.src, seq: op.seq, v: op.v};
+    if (request._fixupOps.length) ack[ACTIONS.fixup] = request._fixupOps;
     if (err) {
       // Occasional 'Op already submitted' errors are expected to happen as
       // part of normal operation, since inflight ops need to be resent after

package/lib/backend.js

@@ -229,7 +229,7 @@ Backend.prototype.submit = function(agent, index, id, op, options, originalCallb
 
   var callback = function(error, ops) {
     backend.emit('submitRequestEnd', error, request);
-    originalCallback(error, ops);
+    originalCallback(error, ops, request);
   };
 
   var err = ot.checkOp(op);
@@ -661,10 +661,32 @@ Backend.prototype.querySubscribe = function(agent, index, query, options, callba
         'DB does not support subscribe'
       ));
     }
-    backend.pubsub.subscribe(request.channel, function(err, stream) {
-      if (err) return callback(err);
+
+    var channels = request.channels;
+
+    if (request.channel) {
+      logger.warn(
+        '[DEPRECATED] "query" middleware\'s context.channel is deprecated, use context.channels instead. ' +
+        'Read more: https://share.github.io/sharedb/middleware/actions#query'
+      );
+      channels = [request.channel];
+    }
+
+    if (!channels || !channels.length) {
+      return callback(new ShareDBError(ERROR_CODE.ERR_QUERY_CHANNEL_MISSING, 'Required minimum one query channel.'));
+    }
+
+    var streams = [];
+
+    function destroyStreams() {
+      streams.forEach(function(stream) {
+        stream.destroy();
+      });
+    }
+
+    function createQueryEmitter() {
       if (options.ids) {
-        var queryEmitter = new QueryEmitter(request, stream, options.ids);
+        var queryEmitter = new QueryEmitter(request, streams, options.ids);
         backend.emit('timing', 'querySubscribe.reconnect', Date.now() - start, request);
         callback(null, queryEmitter);
         return;
@@ -672,14 +694,29 @@ Backend.prototype.querySubscribe = function(agent, index, query, options, callba
       // Issue query on db to get our initial results
       backend._query(agent, request, function(err, snapshots, extra) {
         if (err) {
-          stream.destroy();
+          destroyStreams();
           return callback(err);
         }
         var ids = pluckIds(snapshots);
-        var queryEmitter = new QueryEmitter(request, stream, ids, extra);
+        var queryEmitter = new QueryEmitter(request, streams, ids, extra);
         backend.emit('timing', 'querySubscribe.initial', Date.now() - start, request);
         callback(null, queryEmitter, snapshots, extra);
       });
+    }
+
+    channels.forEach(function(channel) {
+      backend.pubsub.subscribe(channel, function(err, stream) {
+        if (err) {
+          destroyStreams();
+          return callback(err);
+        }
+        streams.push(stream);
+
+        var subscribedToAllChannels = streams.length === channels.length;
+        if (subscribedToAllChannels) {
+          createQueryEmitter();
+        }
+      });
     });
   });
 };
@@ -693,7 +730,7 @@ Backend.prototype._triggerQuery = function(agent, index, query, options, callbac
     collection: collection,
     projection: projection,
     fields: fields,
-    channel: this.getCollectionChannel(collection),
+    channels: [this.getCollectionChannel(collection)],
     query: query,
     options: options,
     db: null,

package/lib/client/doc.js

@@ -5,6 +5,7 @@ var types = require('../types');
 var util = require('../util');
 var clone = util.clone;
 var deepEqual = require('fast-deep-equal');
+var ACTIONS = require('../message-actions').ACTIONS;
 
 var ERROR_CODE = ShareDBError.CODES;
 
@@ -960,6 +961,23 @@ Doc.prototype._opAcknowledged = function(message) {
     return this.fetch();
   }
 
+  if (message[ACTIONS.fixup]) {
+    for (var i = 0; i < message[ACTIONS.fixup].length; i++) {
+      var fixupOp = message[ACTIONS.fixup][i];
+
+      for (var j = 0; j < this.pendingOps.length; j++) {
+        var transformErr = transformX(this.pendingOps[i], fixupOp);
+        if (transformErr) return this._hardRollback(transformErr);
+      }
+
+      try {
+        this._otApply(fixupOp, false);
+      } catch (error) {
+        return this._hardRollback(error);
+      }
+    }
+  }
+
   // The op was committed successfully. Increment the version number
   this.version++;
 

package/lib/error.js

@@ -15,6 +15,8 @@ ShareDBError.prototype.name = 'ShareDBError';
 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_FIXUP_IS_ONLY_VALID_ON_APPLY: 'ERR_FIXUP_IS_ONLY_VALID_ON_APPLY',
+  ERR_CANNOT_FIXUP_DELETION: 'ERR_CANNOT_FIXUP_DELETION',
   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',
@@ -45,6 +47,7 @@ ShareDBError.CODES = {
   ERR_OT_OP_NOT_PROVIDED: 'ERR_OT_OP_NOT_PROVIDED',
   ERR_PRESENCE_TRANSFORM_FAILED: 'ERR_PRESENCE_TRANSFORM_FAILED',
   ERR_PROTOCOL_VERSION_NOT_SUPPORTED: 'ERR_PROTOCOL_VERSION_NOT_SUPPORTED',
+  ERR_QUERY_CHANNEL_MISSING: 'ERR_QUERY_CHANNEL_MISSING',
   ERR_QUERY_EMITTER_LISTENER_NOT_ASSIGNED: 'ERR_QUERY_EMITTER_LISTENER_NOT_ASSIGNED',
   /**
    * A special error that a "readSnapshots" middleware implementation can use to indicate that it
@@ -67,6 +70,7 @@ ShareDBError.CODES = {
   ERR_SNAPSHOT_READS_REJECTED: 'ERR_SNAPSHOT_READS_REJECTED',
   ERR_SUBMIT_TRANSFORM_OPS_NOT_FOUND: 'ERR_SUBMIT_TRANSFORM_OPS_NOT_FOUND',
   ERR_TYPE_CANNOT_BE_PROJECTED: 'ERR_TYPE_CANNOT_BE_PROJECTED',
+  ERR_TYPE_DOES_NOT_SUPPORT_COMPOSE: 'ERR_TYPE_DOES_NOT_SUPPORT_COMPOSE',
   ERR_TYPE_DOES_NOT_SUPPORT_PRESENCE: 'ERR_TYPE_DOES_NOT_SUPPORT_PRESENCE',
   ERR_UNKNOWN_ERROR: 'ERR_UNKNOWN_ERROR'
 };

package/lib/message-actions.js

@@ -9,6 +9,7 @@ exports.ACTIONS = {
   bulkSubscribe: 'bs',
   bulkUnsubscribe: 'bu',
   fetch: 'f',
+  fixup: 'fixup',
   subscribe: 's',
   unsubscribe: 'u',
   op: 'op',

package/lib/query-emitter.js

@@ -5,7 +5,7 @@ var util = require('./util');
 
 var ERROR_CODE = ShareDBError.CODES;
 
-function QueryEmitter(request, stream, ids, extra) {
+function QueryEmitter(request, streams, ids, extra) {
   this.backend = request.backend;
   this.agent = request.agent;
   this.db = request.db;
@@ -15,7 +15,7 @@ function QueryEmitter(request, stream, ids, extra) {
   this.fields = request.fields;
   this.options = request.options;
   this.snapshotProjection = request.snapshotProjection;
-  this.stream = stream;
+  this.streams = streams;
   this.ids = ids;
   this.extra = extra;
 
@@ -23,10 +23,12 @@ function QueryEmitter(request, stream, ids, extra) {
   this.canPollDoc = this.db.canPollDoc(this.collection, this.query);
   this.pollDebounce =
     (typeof this.options.pollDebounce === 'number') ? this.options.pollDebounce :
-      (typeof this.db.pollDebounce === 'number') ? this.db.pollDebounce : 0;
+      (typeof this.db.pollDebounce === 'number') ? this.db.pollDebounce :
+        streams.length > 1 ? 1000 : 0;
   this.pollInterval =
     (typeof this.options.pollInterval === 'number') ? this.options.pollInterval :
-      (typeof this.db.pollInterval === 'number') ? this.db.pollInterval : 0;
+      (typeof this.db.pollInterval === 'number') ? this.db.pollInterval :
+        streams.length > 1 ? 1000 : 0;
 
   this._polling = false;
   this._pendingPoll = null;
@@ -41,15 +43,19 @@ QueryEmitter.prototype._open = function() {
   this._defaultCallback = function(err) {
     if (err) emitter.onError(err);
   };
-  emitter.stream.on('data', function(data) {
-    if (data.error) {
-      return emitter.onError(data.error);
-    }
-    emitter._update(data);
-  });
-  emitter.stream.on('end', function() {
-    emitter.destroy();
+
+  emitter.streams.forEach(function(stream) {
+    stream.on('data', function(data) {
+      if (data.error) {
+        return emitter.onError(data.error);
+      }
+      emitter._update(data);
+    });
+    stream.on('end', function() {
+      emitter.destroy();
+    });
   });
+
   // Make sure we start polling if pollInterval is being used
   this._flushPoll();
 };
@@ -57,7 +63,12 @@ QueryEmitter.prototype._open = function() {
 QueryEmitter.prototype.destroy = function() {
   clearTimeout(this._pollDebounceId);
   clearTimeout(this._pollIntervalId);
-  this.stream.destroy();
+
+  var stream;
+
+  while (stream = this.streams.pop()) {
+    stream.destroy();
+  }
 };
 
 QueryEmitter.prototype._emitTiming = function(action, start) {
@@ -140,8 +151,8 @@ QueryEmitter.prototype._flushPoll = function() {
   if (this._pendingPoll) {
     this.queryPoll();
 
-  // If a pollInterval is specified, poll if the query doesn't get polled in
-  // the time of the interval
+    // If a pollInterval is specified, poll if the query doesn't get polled in
+    // the time of the interval
   } else if (this.pollInterval) {
     var emitter = this;
     this._pollIntervalId = setTimeout(function() {
@@ -301,14 +312,14 @@ QueryEmitter.prototype.queryPollDoc = function(id, callback) {
 // 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 =
-QueryEmitter.prototype.onOp = function() {
-  throw new ShareDBError(
-    ERROR_CODE.ERR_QUERY_EMITTER_LISTENER_NOT_ASSIGNED,
-    'Required QueryEmitter listener not assigned'
-  );
-};
+  QueryEmitter.prototype.onDiff =
+  QueryEmitter.prototype.onExtra =
+  QueryEmitter.prototype.onOp = function() {
+    throw new ShareDBError(
+      ERROR_CODE.ERR_QUERY_EMITTER_LISTENER_NOT_ASSIGNED,
+      'Required QueryEmitter listener not assigned'
+    );
+  };
 
 function getInserted(diff) {
   var inserted = [];

package/lib/submit-request.js

@@ -1,6 +1,7 @@
 var ot = require('./ot');
 var projections = require('./projections');
 var ShareDBError = require('./error');
+var types = require('./types');
 
 var ERROR_CODE = ShareDBError.CODES;
 
@@ -40,9 +41,47 @@ function SubmitRequest(backend, agent, index, id, op, options) {
   this.snapshot = null;
   this.ops = [];
   this.channels = null;
+  this._fixupOps = [];
 }
 module.exports = SubmitRequest;
 
+SubmitRequest.prototype.$fixup = function(op) {
+  if (this.action !== this.backend.MIDDLEWARE_ACTIONS.apply) {
+    throw new ShareDBError(
+      ERROR_CODE.ERR_FIXUP_IS_ONLY_VALID_ON_APPLY,
+      'fixup can only be called during the apply middleware'
+    );
+  }
+
+  if (this.op.del) {
+    throw new ShareDBError(
+      ERROR_CODE.ERR_CANNOT_FIXUP_DELETION,
+      'fixup cannot be applied on deletion ops'
+    );
+  }
+
+  var typeId = this.op.create ? this.op.create.type : this.snapshot.type;
+  var type = types.map[typeId];
+  if (typeof type.compose !== 'function') {
+    throw new ShareDBError(
+      ERROR_CODE.ERR_TYPE_DOES_NOT_SUPPORT_COMPOSE,
+      typeId + ' does not support compose'
+    );
+  }
+
+  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);
+
+  var fixupOp = {
+    src: this.op.src,
+    seq: this.op.seq,
+    v: this.op.v,
+    op: op
+  };
+
+  this._fixupOps.push(fixupOp);
+};
+
 SubmitRequest.prototype.submit = function(callback) {
   var request = this;
   var backend = this.backend;
@@ -103,7 +142,7 @@ SubmitRequest.prototype.submit = function(callback) {
 
     // Transform the op up to the current snapshot version, then apply
     var from = op.v;
-    backend.db.getOpsToSnapshot(collection, id, from, snapshot, null, function(err, ops) {
+    backend.db.getOpsToSnapshot(collection, id, from, snapshot, {metadata: true}, function(err, ops) {
       if (err) return callback(err);
 
       if (ops.length !== snapshot.v - from) {
@@ -134,6 +173,8 @@ 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) {
@@ -152,6 +193,7 @@ SubmitRequest.prototype.commit = function(callback) {
   var backend = this.backend;
   backend.trigger(backend.MIDDLEWARE_ACTIONS.commit, this.agent, this, function(err) {
     if (err) return callback(err);
+    if (request._fixupOps.length) request.op.m.fixup = request._fixupOps;
 
     // Try committing the operation and snapshot to the database atomically
     backend.db.commit(
@@ -204,6 +246,7 @@ SubmitRequest.prototype._transformOp = function(ops) {
       // can happen in normal operation, such as a client resending an
       // unacknowledged operation at reconnect. It's important we don't apply
       // the same op twice
+      if (op.m.fixup) this._fixupOps = op.m.fixup;
       return this.alreadySubmittedError();
     }
 
@@ -213,6 +256,7 @@ SubmitRequest.prototype._transformOp = function(ops) {
 
     var err = ot.transform(type, this.op, op);
     if (err) return err;
+    delete op.m;
     this.ops.push(op);
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sharedb",
-  "version": "3.2.4",
+  "version": "3.3.1",
   "description": "JSON OT database backend",
   "main": "lib/index.js",
   "dependencies": {
@@ -22,7 +22,7 @@
     "ot-json1": "^0.3.0",
     "rich-text": "^4.1.0",
     "sharedb-legacy": "npm:sharedb@=1.1.0",
-    "sinon": "^7.5.0"
+    "sinon": "^9.2.4"
   },
   "files": [
     "lib/",

package/test/client/presence/presence.js

@@ -38,7 +38,6 @@ describe('Presence', function() {
   });
 
   afterEach(function(done) {
-    sinon.restore();
     connection1.close();
     connection2.close();
     backend.close(done);
@@ -147,30 +146,6 @@ describe('Presence', function() {
     ], 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() {