sharedb 1.9.1 → 2.2.0

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.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
@@ -836,7 +854,7 @@ Backend.prototype._fetchSnapshotByTimestamp = function(collection, id, timestamp
 
 Backend.prototype._buildSnapshotFromOps = function(id, startingSnapshot, ops, callback) {
   var snapshot = startingSnapshot || new Snapshot(id, 0, null, undefined, null);
-  var error = ot.applyOps(snapshot, ops, {_normalizeJson0Paths: true});
+  var error = ot.applyOps(snapshot, ops, {_normalizeLegacyJson0Ops: true});
   callback(error, snapshot);
 };
 

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/error.js

@@ -38,6 +38,7 @@ ShareDBError.CODES = {
   ERR_OP_VERSION_MISMATCH_AFTER_TRANSFORM: 'ERR_OP_VERSION_MISMATCH_AFTER_TRANSFORM',
   ERR_OP_VERSION_MISMATCH_DURING_TRANSFORM: 'ERR_OP_VERSION_MISMATCH_DURING_TRANSFORM',
   ERR_OP_VERSION_NEWER_THAN_CURRENT_SNAPSHOT: 'ERR_OP_VERSION_NEWER_THAN_CURRENT_SNAPSHOT',
+  ERR_OT_LEGACY_JSON0_OP_CANNOT_BE_NORMALIZED: 'ERR_OT_LEGACY_JSON0_OP_CANNOT_BE_NORMALIZED',
   ERR_OT_OP_BADLY_FORMED: 'ERR_OT_OP_BADLY_FORMED',
   ERR_OT_OP_NOT_APPLIED: 'ERR_OT_OP_NOT_APPLIED',
   ERR_OT_OP_NOT_PROVIDED: 'ERR_OT_OP_NOT_PROVIDED',

package/lib/ot.js

@@ -164,7 +164,16 @@ exports.applyOps = function(snapshot, ops, options) {
   options = options || {};
   for (var index = 0; index < ops.length; index++) {
     var op = ops[index];
-    if (options._normalizeJson0Paths) normalizeJson0Paths(snapshot, op);
+    if (options._normalizeLegacyJson0Ops) {
+      try {
+        normalizeLegacyJson0Ops(snapshot, op);
+      } catch (error) {
+        return new ShareDBError(
+          ERROR_CODE.ERR_OT_LEGACY_JSON0_OP_CANNOT_BE_NORMALIZED,
+          'Cannot normalize legacy json0 op'
+        );
+      }
+    }
     snapshot.v = op.v;
     var error = exports.apply(snapshot, op);
     if (error) return error;
@@ -205,15 +214,17 @@ exports.transformPresence = function(presence, op, isOwnOp) {
  * json0 had a breaking change in https://github.com/ottypes/json0/pull/40
  * The change added stricter type checking, which breaks fetchSnapshot()
  * when trying to rebuild a snapshot from old, committed ops that didn't
- * have this stricter validation. This method fixes up the op paths to
+ * have this stricter validation. This method fixes up legacy ops to
  * pass the stricter validation
  */
-function normalizeJson0Paths(snapshot, json0Op) {
+function normalizeLegacyJson0Ops(snapshot, json0Op) {
   if (snapshot.type !== types.defaultType.uri) return;
   var components = json0Op.op;
   if (!components) return;
   for (var i = 0; i < components.length; i++) {
-    var path = components[i].p;
+    var component = components[i];
+    if (typeof component.lm === 'string') component.lm = +component.lm;
+    var path = component.p;
     var element = snapshot.data;
     for (var j = 0; j < path.length; j++) {
       var key = path[j];

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.1",
+  "version": "2.2.0",
   "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/client/projections.js

@@ -220,17 +220,16 @@ module.exports = function(options) {
             if (err) return done(err);
             expect(results).to.have.length(0);
 
+            query.once('changed', function() {
+              expect(query.results).to.have.length(1);
+              expect(query.results[0].id).to.equal('fido');
+              expect(query.results[0].data).to.eql({age: 3, owner: {name: 'jim'}});
+              done();
+            });
+
             // Submit an op on a field not in the projection, where the op should
             // cause the doc to be included in the query results
-            fido.submitOp({p: ['color'], od: 'gold', oi: 'black'}, null, function(err) {
-              if (err) return done(err);
-              setTimeout(function() {
-                expect(query.results).to.have.length(1);
-                expect(query.results[0].id).to.equal('fido');
-                expect(query.results[0].data).to.eql({age: 3, owner: {name: 'jim'}});
-                done();
-              }, 10);
-            });
+            fido.submitOp({p: ['color'], od: 'gold', oi: 'black'}, null, util.errorHandler(done));
           });
         });
       });

package/test/client/query-subscribe.js

@@ -216,19 +216,28 @@ module.exports = function(options) {
         }
       ], function(err) {
         if (err) return done(err);
-        var query = connection.createSubscribeQuery('dogs', matchAllDbQuery, null, function(err) {
-          if (err) return done(err);
+        var query = connection.createSubscribeQuery('dogs', matchAllDbQuery);
+        query.on('error', done);
+
+        query.once('ready', function() {
           connection.close();
+
           connection2.get('dogs', 'fido').fetch(function(err) {
             if (err) return done(err);
-            connection2.get('dogs', 'fido').del();
-            connection2.get('dogs', 'taco').on('error', done).create({age: 2});
-            process.nextTick(function() {
+            async.parallel([
+              function(cb) {
+                connection2.get('dogs', 'fido').del(cb);
+              },
+              function(cb) {
+                connection2.get('dogs', 'taco').create({age: 2}, cb);
+              }
+            ], function(error) {
+              if (error) return done(error);
               backend.connect(connection);
             });
           });
         });
-        query.on('error', done);
+
         var wait = 2;
         function finish() {
           if (--wait) return;
@@ -237,12 +246,12 @@ module.exports = function(options) {
           expect(util.pluck(results, 'data')).eql([{age: 5}, {age: 2}]);
           done();
         }
-        query.on('insert', function(docs) {
+        query.once('insert', function(docs) {
           expect(util.pluck(docs, 'id')).eql(['taco']);
           expect(util.pluck(docs, 'data')).eql([{age: 2}]);
           finish();
         });
-        query.on('remove', function(docs) {
+        query.once('remove', function(docs) {
           expect(util.pluck(docs, 'id')).eql(['fido']);
           // We don't assert the value of data, because the del op could be
           // applied by the client before or after the query result is removed.

package/test/client/snapshot-version-request.js

@@ -441,16 +441,15 @@ describe('SnapshotVersionRequest', function() {
     });
   });
 
-  describe('invalid json0 path', function() {
+  describe('invalid json0v2 path', function() {
     beforeEach(function(done) {
       var doc = backend.connect().get('series', 'his-dark-materials');
-      doc.create([{title: 'Golden Compass'}], function(error) {
-        if (error) return done(error);
-        doc.submitOp({p: ['0', 'title'], od: 'Golden Compass', oi: 'Northern Lights'}, function(error) {
-          if (error) return done(error);
-          doc.submitOp({p: ['1'], li: {title: 'Subtle Knife'}}, done);
-        });
-      });
+      async.series([
+        doc.create.bind(doc, [{title: 'Golden Compass'}]),
+        doc.submitOp.bind(doc, {p: ['0', 'title'], od: 'Golden Compass', oi: 'Northern Lights'}),
+        doc.submitOp.bind(doc, {p: ['1'], li: {title: 'Subtle Knife'}}),
+        doc.submitOp.bind(doc, {p: ['1'], lm: '0'})
+      ], done);
     });
 
     describe('json0v1', function() {
@@ -477,13 +476,24 @@ describe('SnapshotVersionRequest', function() {
         types.register(defaultType);
       });
 
-      it('fetches v2 with json0v2', function(done) {
+      it('fetches a string-indexed list insertion with json0v2', function(done) {
         backend.connect().fetchSnapshot('series', 'his-dark-materials', 2, function(error, snapshot) {
           if (error) return done(error);
           expect(snapshot.data).to.eql([{title: 'Northern Lights'}]);
           done();
         });
       });
+
+      it('fetches a list move using a string target', function(done) {
+        backend.connect().fetchSnapshot('series', 'his-dark-materials', 4, function(error, snapshot) {
+          if (error) return done(error);
+          expect(snapshot.data).to.eql([
+            {title: 'Subtle Knife'},
+            {title: 'Northern Lights'}
+          ]);
+          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));
-}