sharedb 2.0.0 → 2.2.2

package/README.md

@@ -1,5 +1,3 @@
-_This README is for `sharedb@1.x`. For `sharedb@1.x-beta`, see [the 1.x-beta branch](https://github.com/share/sharedb/tree/1.x-beta). To upgrade, see [the upgrade guide](https://github.com/share/sharedb/wiki/Upgrading-to-sharedb@1.0.0-from-1.0.0-beta)._
-
 # ShareDB
 
   [![NPM Version](https://img.shields.io/npm/v/sharedb.svg)](https://npmjs.org/package/sharedb)

package/lib/agent.js

@@ -736,17 +736,25 @@ Agent.prototype._src = function() {
 
 Agent.prototype._broadcastPresence = function(presence, callback) {
   var agent = this;
+  var backend = this.backend;
   var requests = this.presenceRequests[presence.ch] || (this.presenceRequests[presence.ch] = {});
   var previousRequest = requests[presence.id];
   if (!previousRequest || previousRequest.pv < presence.pv) {
     this.presenceRequests[presence.ch][presence.id] = presence;
   }
-  this.backend.transformPresenceToLatestVersion(this, presence, function(error, presence) {
+  var context = {
+    presence: presence,
+    collection: presence.c
+  };
+  backend.trigger(backend.MIDDLEWARE_ACTIONS.receivePresence, this, context, function(error) {
     if (error) return callback(error);
-    var channel = agent._getPresenceChannel(presence.ch);
-    agent.backend.pubsub.publish([channel], presence, function(error) {
+    backend.transformPresenceToLatestVersion(agent, presence, function(error, presence) {
       if (error) return callback(error);
-      callback(null, presence);
+      var channel = agent._getPresenceChannel(presence.ch);
+      agent.backend.pubsub.publish([channel], presence, function(error) {
+        if (error) return callback(error);
+        callback(null, presence);
+      });
     });
   });
 };
@@ -815,7 +823,9 @@ Agent.prototype._handlePresenceData = function(presence) {
   var agent = this;
   backend.trigger(backend.MIDDLEWARE_ACTIONS.sendPresence, this, context, function(error) {
     if (error) {
-      return agent.send({a: 'p', ch: presence.ch, id: presence.id, error: getReplyErrorObject(error)});
+      if (backend.doNotForwardSendPresenceErrorsToClient) backend.errorHandler(error, {agent: agent});
+      else agent.send({a: 'p', ch: presence.ch, id: presence.id, error: getReplyErrorObject(error)});
+      return;
     }
     agent.send(presence);
   });

package/lib/backend.js

@@ -14,6 +14,7 @@ var StreamSocket = require('./stream-socket');
 var SubmitRequest = require('./submit-request');
 var ReadSnapshotsRequest = require('./read-snapshots-request');
 var util = require('./util');
+var logger = require('./logger');
 
 var ERROR_CODE = ShareDBError.CODES;
 
@@ -34,6 +35,14 @@ function Backend(options) {
   this.suppressPublish = !!options.suppressPublish;
   this.maxSubmitRetries = options.maxSubmitRetries || null;
   this.presenceEnabled = !!options.presence;
+  this.doNotForwardSendPresenceErrorsToClient = !!options.doNotForwardSendPresenceErrorsToClient;
+  if (this.presenceEnabled && !this.doNotForwardSendPresenceErrorsToClient) {
+    logger.warn(
+      'Broadcasting "sendPresence" middleware errors to clients is deprecated ' +
+      'and will be removed in a future release. Disable this behaviour with:\n\n' +
+      'new Backend({doNotForwardSendPresenceErrorsToClient: true})\n\n'
+    );
+  }
 
   // Map from event name to a list of middleware
   this.middleware = {};
@@ -41,6 +50,13 @@ function Backend(options) {
   // The number of open agents for monitoring and testing memory leaks
   this.agentsCount = 0;
   this.remoteAgentsCount = 0;
+
+  this.errorHandler = typeof options.errorHandler === 'function' ?
+    options.errorHandler :
+    // eslint-disable-next-line no-unused-vars
+    function(error, context) {
+      logger.error(error);
+    };
 }
 module.exports = Backend;
 emitter.mixin(Backend);
@@ -68,6 +84,8 @@ Backend.prototype.MIDDLEWARE_ACTIONS = {
   // by design, changing existing reply properties can cause weird bugs, since
   // the rest of ShareDB would be unaware of those changes.
   reply: 'reply',
+  // The server received presence information
+  receivePresence: 'receivePresence',
   // About to send presence information to a client
   sendPresence: 'sendPresence',
   // An operation is about to be submitted to the database

package/lib/client/doc.js

@@ -3,6 +3,7 @@ var logger = require('../logger');
 var ShareDBError = require('../error');
 var types = require('../types');
 var util = require('../util');
+var clone = util.clone;
 var deepEqual = require('fast-deep-equal');
 
 var ERROR_CODE = ShareDBError.CODES;
@@ -113,6 +114,10 @@ function Doc(connection, collection, id) {
   // ops are still received. Should be toggled through the pause() and
   // resume() methods to correctly flush on resume.
   this.paused = false;
+
+  // Internal counter that gets incremented every time doc.data is updated.
+  // Used as a cheap way to check if doc.data has changed.
+  this._dataStateVersion = 0;
 }
 emitter.mixin(Doc);
 
@@ -155,13 +160,18 @@ Doc.prototype._setType = function(newType) {
   } else if (newType === null) {
     this.type = newType;
     // If we removed the type from the object, also remove its data
-    this.data = undefined;
+    this._setData(undefined);
   } else {
     var err = new ShareDBError(ERROR_CODE.ERR_DOC_TYPE_NOT_RECOGNIZED, 'Missing type ' + newType);
     return this.emit('error', err);
   }
 };
 
+Doc.prototype._setData = function(data) {
+  this.data = data;
+  this._dataStateVersion++;
+};
+
 // Ingest snapshot data. This data must include a version, snapshot and type.
 // This is used both to ingest data that was exported with a webpage and data
 // that was received from the server during a fetch.
@@ -217,9 +227,11 @@ Doc.prototype.ingestSnapshot = function(snapshot, callback) {
   this.version = snapshot.v;
   var type = (snapshot.type === undefined) ? types.defaultType : snapshot.type;
   this._setType(type);
-  this.data = (this.type && this.type.deserialize) ?
-    this.type.deserialize(snapshot.data) :
-    snapshot.data;
+  this._setData(
+    (this.type && this.type.deserialize) ?
+      this.type.deserialize(snapshot.data) :
+      snapshot.data
+  );
   this.emit('load');
   callback && callback();
 };
@@ -621,7 +633,7 @@ Doc.prototype._otApply = function(op, source) {
         }
         // Apply the individual op component
         this.emit('before op', componentOp.op, source, op.src);
-        this.data = this.type.apply(this.data, componentOp.op);
+        this._setData(this.type.apply(this.data, componentOp.op));
         this.emit('op', componentOp.op, source, op.src);
       }
       this.emit('op batch', op.op, source);
@@ -634,7 +646,7 @@ Doc.prototype._otApply = function(op, source) {
     // the snapshot before it gets changed
     this.emit('before op', op.op, source, op.src);
     // Apply the operation to the local data, mutating it in place
-    this.data = this.type.apply(this.data, op.op);
+    this._setData(this.type.apply(this.data, op.op));
     // Emit an 'op' event once the local data includes the changes from the
     // op. For locally submitted ops, this will be synchronously with
     // submission and before the server or other clients have received the op.
@@ -647,11 +659,15 @@ Doc.prototype._otApply = function(op, source) {
 
   if (op.create) {
     this._setType(op.create.type);
-    this.data = (this.type.deserialize) ?
-      (this.type.createDeserialized) ?
-        this.type.createDeserialized(op.create.data) :
-        this.type.deserialize(this.type.create(op.create.data)) :
-      this.type.create(op.create.data);
+    if (this.type.deserialize) {
+      if (this.type.createDeserialized) {
+        this._setData(this.type.createDeserialized(op.create.data));
+      } else {
+        this._setData(this.type.deserialize(this.type.create(op.create.data)));
+      }
+    } else {
+      this._setData(this.type.create(op.create.data));
+    }
     this.emit('create', source);
     return;
   }
@@ -919,6 +935,15 @@ Doc.prototype.resume = function() {
   this.flush();
 };
 
+// Create a snapshot that can be serialized, deserialized, and passed into `Doc.ingestSnapshot`.
+Doc.prototype.toSnapshot = function() {
+  return {
+    v: this.version,
+    data: clone(this.data),
+    type: this.type.uri
+  };
+};
+
 // *** Receiving operations
 
 // This is called when the server acknowledges an operation from the client.
@@ -948,7 +973,13 @@ Doc.prototype._rollback = function(err) {
   var op = this.inflightOp;
 
   if ('op' in op && op.type.invert) {
-    op.op = op.type.invert(op.op);
+    try {
+      op.op = op.type.invert(op.op);
+    } catch (error) {
+      // If the op doesn't support `.invert()`, we just reload the doc
+      // instead of trying to locally revert it.
+      return this._hardRollback(err);
+    }
 
     // Transform the undo operation by any pending ops.
     for (var i = 0; i < this.pendingOps.length; i++) {

package/lib/client/presence/local-doc-presence.js

@@ -12,6 +12,7 @@ function LocalDocPresence(presence, presenceId) {
 
   this._doc = this.connection.get(this.collection, this.id);
   this._isSending = false;
+  this._docDataVersionByPresenceVersion = {};
 
   this._opHandler = this._transformAgainstOp.bind(this);
   this._createOrDelHandler = this._handleCreateOrDel.bind(this);
@@ -35,6 +36,9 @@ LocalDocPresence.prototype.submit = function(value, callback) {
     return this._callbackOrEmit(error, callback);
   };
 
+  // Record the current data state version to check if we need to transform
+  // the presence later
+  this._docDataVersionByPresenceVersion[this.presenceVersion] = this._doc._dataStateVersion;
   LocalPresence.prototype.submit.call(this, value, callback);
 };
 
@@ -63,6 +67,7 @@ LocalDocPresence.prototype._sendPending = function() {
     });
 
     presence._pendingMessages = [];
+    presence._docDataVersionByPresenceVersion = {};
   });
 };
 
@@ -76,9 +81,18 @@ LocalDocPresence.prototype._registerWithDoc = function() {
 
 LocalDocPresence.prototype._transformAgainstOp = function(op, source) {
   var presence = this;
+  var docDataVersion = this._doc._dataStateVersion;
+
   this._pendingMessages.forEach(function(message) {
+    // Check if the presence needs transforming against the op - this is to check against
+    // edge cases where presence is submitted from an 'op' event
+    var messageDocDataVersion = presence._docDataVersionByPresenceVersion[message.pv];
+    if (messageDocDataVersion >= docDataVersion) return;
     try {
       message.p = presence._transformPresence(message.p, op, source);
+      // Ensure the presence's data version is kept consistent to deal with "deep" op
+      // submissions
+      presence._docDataVersionByPresenceVersion[message.pv] = docDataVersion;
     } catch (error) {
       var callback = presence._getCallback(message.pv);
       presence._callbackOrEmit(error, callback);
@@ -103,6 +117,7 @@ LocalDocPresence.prototype._handleCreateOrDel = function() {
 LocalDocPresence.prototype._handleLoad = function() {
   this.value = null;
   this._pendingMessages = [];
+  this._docDataVersionByPresenceVersion = {};
 };
 
 LocalDocPresence.prototype._message = function() {

package/lib/db/memory.js

@@ -1,6 +1,7 @@
 var DB = require('./index');
 var Snapshot = require('../snapshot');
 var util = require('../util');
+var clone = util.clone;
 
 // In-memory ShareDB database
 //
@@ -172,7 +173,3 @@ MemoryDB.prototype._getVersionSync = function(collection, id) {
   var collectionOps = this.ops[collection];
   return (collectionOps && collectionOps[id] && collectionOps[id].length) || 0;
 };
-
-function clone(obj) {
-  return (obj === undefined) ? undefined : JSON.parse(JSON.stringify(obj));
-}

package/lib/util.js

@@ -96,3 +96,8 @@ exports.nextTick = function(callback) {
     callback.apply(null, args);
   });
 };
+
+exports.clone = function(obj) {
+  return (obj === undefined) ? undefined : JSON.parse(JSON.stringify(obj));
+};
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sharedb",
-  "version": "2.0.0",
+  "version": "2.2.2",
   "description": "JSON OT database backend",
   "main": "lib/index.js",
   "dependencies": {
@@ -20,6 +20,7 @@
     "nyc": "^14.1.1",
     "ot-json0-v2": "ottypes/json0",
     "ot-json1": "^0.3.0",
+    "rich-text": "^4.1.0",
     "sharedb-legacy": "npm:sharedb@=1.1.0",
     "sinon": "^7.5.0"
   },

package/test/backend.js

@@ -1,29 +1,51 @@
 var Backend = require('../lib/backend');
 var expect = require('chai').expect;
 var sinon = require('sinon');
+var logger = require('../lib/logger');
 
 describe('Backend', function() {
   var backend;
-  var agent = {
-    custom: {
-      foo: 'bar'
-    }
-  };
-  var fetchOptions = {
-    snapshotOptions: {
-      fizz: 'buzz'
-    }
-  };
-
-  beforeEach(function() {
-    backend = new Backend();
-  });
 
   afterEach(function(done) {
     backend.close(done);
   });
 
+  describe('options', function() {
+    describe('errorHandler', function() {
+      it('logs by default', function() {
+        backend = new Backend();
+        var error = new Error('foo');
+        sinon.spy(logger, 'error');
+        backend.errorHandler(error);
+        expect(logger.error.callCount).to.equal(1);
+      });
+
+      it('overrides with another function', function() {
+        var handler = sinon.spy();
+        backend = new Backend({errorHandler: handler});
+        var error = new Error('foo');
+        backend.errorHandler(error);
+        expect(handler.callCount).to.equal(1);
+      });
+    });
+  });
+
   describe('a simple document', function() {
+    var agent = {
+      custom: {
+        foo: 'bar'
+      }
+    };
+    var fetchOptions = {
+      snapshotOptions: {
+        fizz: 'buzz'
+      }
+    };
+
+    beforeEach(function() {
+      backend = new Backend();
+    });
+
     beforeEach(function(done) {
       var doc = backend.connect().get('books', '1984');
       doc.create({title: '1984'}, function(error) {

package/test/client/doc.js

@@ -1,6 +1,9 @@
 var Backend = require('../../lib/backend');
 var expect = require('chai').expect;
 var async = require('async');
+var json0 = require('ot-json0').type;
+var richText = require('rich-text').type;
+var ShareDBError = require('../../lib/error');
 var errorHandler = require('../util').errorHandler;
 
 describe('Doc', function() {
@@ -407,6 +410,43 @@ describe('Doc', function() {
       ], done);
     });
 
+    it('rolls the doc back even if the op is not invertible', function(done) {
+      var backend = this.backend;
+
+      async.series([
+        function(next) {
+          // Register the rich text type, which can't be inverted
+          json0.registerSubtype(richText);
+
+          var validOp = {p: ['richName'], oi: {ops: [{insert: 'Scooby\n'}]}};
+          doc.submitOp(validOp, function(error) {
+            expect(error).to.not.exist;
+            next();
+          });
+        },
+        function(next) {
+          // Make the server reject this insertion
+          backend.use('submit', function(_context, backendNext) {
+            backendNext(new ShareDBError(ShareDBError.CODES.ERR_UNKNOWN_ERROR, 'Custom unknown error'));
+          });
+          var nonInvertibleOp = {p: ['richName'], t: 'rich-text', o: [{insert: 'e'}]};
+
+          // The server error should get all the way back to our handler
+          doc.submitOp(nonInvertibleOp, function(error) {
+            expect(error.message).to.eql('Custom unknown error');
+            next();
+          });
+        },
+        doc.whenNothingPending.bind(doc),
+        function(next) {
+          // The doc should have been reverted successfully
+          expect(doc.data).to.eql({name: 'Scooby', richName: {ops: [{insert: 'Scooby\n'}]}});
+          next();
+        }
+      ], done);
+    });
+
+
     it('rescues an irreversible op collision', function(done) {
       // This test case attempts to reconstruct the following corner case, with
       // two independent references to the same document. We submit two simultaneous, but
@@ -475,4 +515,30 @@ describe('Doc', function() {
       ], done);
     });
   });
+
+  describe('toSnapshot', function() {
+    var doc;
+    beforeEach(function(done) {
+      doc = this.connection.get('dogs', 'scooby');
+      doc.create({name: 'Scooby'}, done);
+    });
+
+    it('generates a snapshot', function() {
+      expect(doc.toSnapshot()).to.eql({
+        v: 1,
+        data: {name: 'Scooby'},
+        type: 'http://sharejs.org/types/JSONv0'
+      });
+    });
+
+    it('clones snapshot data to guard against mutation', function() {
+      var snapshot = doc.toSnapshot();
+      doc.data.name = 'Shaggy';
+      expect(snapshot).to.eql({
+        v: 1,
+        data: {name: 'Scooby'},
+        type: 'http://sharejs.org/types/JSONv0'
+      });
+    });
+  });
 });

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

@@ -979,4 +979,50 @@ describe('DocPresence', function() {
       }
     ], done);
   });
+
+  it('does not transform presence submitted in an op event when the presence was created late', function(done) {
+    var localPresence1;
+
+    doc1.on('op', function() {
+      localPresence1.submit({index: 7});
+    });
+
+    localPresence1 = presence1.create('presence-1');
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        doc1.submitOp({index: 5, value: 'ern'});
+        presence2.on('receive', function(id, value) {
+          expect(value).to.eql({index: 7});
+          next();
+        });
+      }
+    ], done);
+  });
+
+  it('does transform late-created presence submitted in an op event by a deep second op', function(done) {
+    var localPresence1;
+
+    var submitted = false;
+    doc1.on('op', function() {
+      if (submitted) return;
+      submitted = true;
+      localPresence1.submit({index: 7});
+      doc1.submitOp({index: 5, value: 'akg'});
+    });
+
+    localPresence1 = presence1.create('presence-1');
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        doc1.submitOp({index: 5, value: 'ern'});
+        presence2.on('receive', function(id, value) {
+          expect(value).to.eql({index: 10});
+          next();
+        });
+      }
+    ], done);
+  });
 });

package/test/client/presence/presence.js

@@ -487,4 +487,102 @@ describe('Presence', function() {
       }
     ], done);
   });
+
+  describe('middleware', function() {
+    describe('receivePresence', function() {
+      it('provides the presence in the middleware', function(done) {
+        backend.use(backend.MIDDLEWARE_ACTIONS.receivePresence, function(context) {
+          expect(context.presence.p).to.eql({index: 5});
+          done();
+        });
+
+        var localPresence1 = presence1.create('presence-1');
+        localPresence1.submit({index: 5}, errorHandler(done));
+      });
+
+      it('can mutate the presence in the middleware', function(done) {
+        backend.use(backend.MIDDLEWARE_ACTIONS.receivePresence, function(context, next) {
+          context.presence.p.index++;
+          next();
+        });
+
+        var localPresence1 = presence1.create('presence-1');
+
+        async.series([
+          presence2.subscribe.bind(presence2),
+          function(next) {
+            presence2.on('receive', function(id, value) {
+              expect(value).to.eql({index: 6});
+              next();
+            });
+            localPresence1.submit({index: 5}, errorHandler(done));
+          }
+        ], done);
+      });
+
+      it('can cancel a presence broadcast by erroring', function(done) {
+        backend.use(backend.MIDDLEWARE_ACTIONS.receivePresence, function(context, next) {
+          next(new Error('bad!'));
+        });
+
+        var localPresence1 = presence1.create('presence-1');
+
+        async.series([
+          presence2.subscribe.bind(presence2),
+          function(next) {
+            presence2.on('receive', function() {
+              done(new Error('should not have received presence'));
+            });
+            localPresence1.submit({index: 5}, function(error) {
+              expect(error.message).to.contain('bad!');
+              next();
+            });
+          }
+        ], done);
+      });
+    });
+
+    describe('sendPresence', function() {
+      // TODO: This functionality is deprecated
+      it('sends an error to a subscribed client', function(done) {
+        var localPresence1 = presence1.create('presence-1');
+
+        backend.use(backend.MIDDLEWARE_ACTIONS.sendPresence, function(context, next) {
+          next(new Error('uh-oh!'));
+        });
+
+        async.series([
+          presence2.subscribe.bind(presence2),
+          function(next) {
+            localPresence1.submit({index: 3}, errorHandler(done));
+            presence2.once('error', function(error) {
+              expect(error.message).to.equal('uh-oh!');
+              next();
+            });
+          }
+        ], done);
+      });
+
+      it('emits errors on the server instead of sending to the client', function(done) {
+        var localPresence1 = presence1.create('presence-1');
+
+        backend.doNotForwardSendPresenceErrorsToClient = true;
+        backend.use(backend.MIDDLEWARE_ACTIONS.sendPresence, function(context, next) {
+          next(new Error('uh-oh!'));
+        });
+
+        async.series([
+          presence2.subscribe.bind(presence2),
+          function(next) {
+            localPresence1.submit({index: 3}, errorHandler(done));
+            presence2.on('error', errorHandler(done));
+            backend.errorHandler = function(error) {
+              expect(error.message).to.equal('uh-oh!');
+              next();
+            };
+          }
+        ], done);
+      });
+    });
+  });
 });

package/test/projections.js

@@ -1,6 +1,7 @@
 var expect = require('chai').expect;
 var projections = require('../lib/projections');
 var type = require('../lib/types').defaultType.uri;
+var clone = require('../lib/util').clone;
 
 describe('projection utility methods', function() {
   describe('projectSnapshot', function() {
@@ -385,7 +386,3 @@ describe('projection utility methods', function() {
     });
   });
 });
-
-function clone(obj) {
-  return (obj === undefined) ? undefined : JSON.parse(JSON.stringify(obj));
-}