sharedb 1.9.2 → 2.2.1

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## v2.0
+
+### Breaking changes
+
+* Drop Node.js v10 support
+
 ## v1.0-beta
 
 ### Breaking changes

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;
@@ -919,6 +920,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 +958,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/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": "1.9.2",
+  "version": "2.2.1",
   "description": "JSON OT database backend",
   "main": "lib/index.js",
   "dependencies": {
@@ -13,13 +13,14 @@
   "devDependencies": {
     "chai": "^4.2.0",
     "coveralls": "^3.0.7",
-    "eslint": "^6.5.1",
+    "eslint": "^7.32.0",
     "eslint-config-google": "^0.14.0",
-    "ot-json0-v2": "ottypes/json0",
     "lolex": "^5.1.1",
     "mocha": "^8.2.1",
     "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/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));
-}