sharedb-mongo 1.0.0-beta.6 → 1.0.0

package/mongodb.js

@@ -0,0 +1,3 @@
+var version = process.env._SHAREDB_MONGODB_DRIVER || 'mongodb';
+var mongodb = require(version);
+module.exports = mongodb;

package/op-link-validator.js

@@ -0,0 +1,78 @@
+/**
+ * This is a class for determining an op with a unique version number
+ * when presented with an **ordered** series of ops.
+ *
+ * For example, consider the following chain of op versions:
+ * 1 -> 1 -> 2 -> 2 -> 3 -> 4
+ * If we want to find the first unique version, we must consider a
+ * window of three versions. For example, if we consider the first
+ * three versions:
+ * 1 -> 1 -> 2
+ * Then we know that 1 is not unique. We don't know if 2 is unique
+ * yet, because we don't know what comes next. Therefore we push
+ * one more version and check again:
+ * 1 -> 2 -> 2
+ * Again we now see that 2 is not unique, so we keep pushing ops
+ * until we reach the final window:
+ * 2 -> 3 -> 4
+ * From here, **assuming the ops are well ordered** we can safely
+ * see that v3 is unique. We cannot make the same assumption of
+ * v4, because we don't know what comes next.
+ *
+ * Note that we also assume that the chain starts with **all**
+ * of the copies of an op version. That is that if we are provided
+ * 1 -> 2
+ * Then v1 is unique (because there are no other v1s).
+ *
+ * Similarly, if a null op is pushed into the class, it is assumed
+ * to be the end of the chain, and hence a unique version can be
+ * inferred, eg with this chain:
+ * 5 -> 6 -> null
+ * We say that 6 is unique, because we've reached the end of the
+ * list
+ */
+function OpLinkValidator() {
+  this.currentOp = undefined;
+  this.previousOp = undefined;
+  this.oneBeforePreviousOp = undefined;
+}
+
+OpLinkValidator.prototype.push = function(op) {
+  this.oneBeforePreviousOp = this.previousOp;
+  this.previousOp = this.currentOp;
+  this.currentOp = op;
+};
+
+OpLinkValidator.prototype.opWithUniqueVersion = function() {
+  return this._previousVersionWasUnique() ? this.previousOp : null;
+};
+
+OpLinkValidator.prototype.isAtEndOfList = function() {
+  // We ascribe a special meaning to a current op of null
+  // being that we're at the end of the list, because this
+  // is the value that the Mongo cursor will return when
+  // the cursor is exhausted
+  return this.currentOp === null;
+};
+
+OpLinkValidator.prototype._previousVersionWasUnique = function() {
+  var previousVersion = this._previousVersion();
+
+  return typeof previousVersion === 'number'
+    && previousVersion !== this._currentVersion()
+    && previousVersion !== this._oneBeforePreviousVersion();
+};
+
+OpLinkValidator.prototype._currentVersion = function() {
+  return this.currentOp && this.currentOp.v;
+};
+
+OpLinkValidator.prototype._previousVersion = function() {
+  return this.previousOp && this.previousOp.v;
+};
+
+OpLinkValidator.prototype._oneBeforePreviousVersion = function() {
+  return this.oneBeforePreviousOp && this.oneBeforePreviousOp.v;
+};
+
+module.exports = OpLinkValidator;

package/package.json

@@ -1,23 +1,37 @@
 {
   "name": "sharedb-mongo",
-  "version": "1.0.0-beta.6",
+  "version": "1.0.0",
   "description": "MongoDB database adapter for ShareDB",
   "main": "index.js",
   "dependencies": {
-    "async": "^1.4.2",
-    "mongodb": "^2.1.2",
-    "sharedb": "^1.0.0-beta"
+    "async": "^2.6.3",
+    "mongodb": "^2.1.2 || ^3.0.0 || ^4.0.0",
+    "sharedb": "^1.9.1 || ^2.0.0"
   },
   "devDependencies": {
-    "coveralls": "^2.11.8",
-    "expect.js": "^0.3.1",
-    "istanbul": "^0.4.2",
-    "mocha": "^2.3.3",
-    "sharedb-mingo-memory": "^1.0.2"
+    "chai": "^4.2.0",
+    "coveralls": "^3.0.7",
+    "eslint": "^5.16.0",
+    "eslint-config-google": "^0.13.0",
+    "mocha": "^6.2.2",
+    "mongodb2": "npm:mongodb@^2.1.2",
+    "mongodb3": "npm:mongodb@^3.0.0",
+    "mongodb4": "npm:mongodb@^4.0.0",
+    "nyc": "^14.1.1",
+    "ot-json1": "^1.0.1",
+    "sharedb-mingo-memory": "^1.1.1",
+    "sinon": "^6.1.5",
+    "sinon-chai": "^3.7.0"
   },
   "scripts": {
-    "test": "node_modules/.bin/mocha",
-    "test-cover": "node_modules/istanbul/lib/cli.js cover node_modules/mocha/bin/_mocha"
+    "lint": "./node_modules/.bin/eslint --ignore-path .gitignore '**/*.js'",
+    "lint:fix": "npm run lint -- --fix",
+    "test": "mocha",
+    "test:mongodb2": "_SHAREDB_MONGODB_DRIVER=mongodb2 npm test",
+    "test:mongodb3": "_SHAREDB_MONGODB_DRIVER=mongodb3 npm test",
+    "test:mongodb4": "_SHAREDB_MONGODB_DRIVER=mongodb4 npm test",
+    "test:all": "npm run test:mongodb2 && npm run test:mongodb3 && npm run test:mongodb4",
+    "test-cover": "nyc --temp-dir=coverage -r text -r lcov npm run test:all"
   },
   "repository": "git://github.com/share/sharedb-mongo.git",
   "author": "Nate Smith and Joseph Gentle",

package/src/middleware/actions.js

@@ -0,0 +1,9 @@
+module.exports = {
+  // Triggers before the call to write a new document is made
+  beforeCreate: 'beforeCreate',
+  // Triggers before the call to replace a document is made
+  beforeOverwrite: 'beforeOverwrite',
+  // Triggers directly before the call to issue a query for snapshots
+  // Applies for both a single lookup by ID and bulk lookups by a list of IDs
+  beforeSnapshotLookup: 'beforeSnapshotLookup'
+};

package/src/middleware/middlewareHandler.js

@@ -0,0 +1,66 @@
+var MIDDLEWARE_ACTIONS = require('./actions');
+
+function MiddlewareHandler() {
+  this._middleware = {};
+}
+
+/**
+* Add middleware to an action or array of actions
+*
+* @param action The action to use from MIDDLEWARE_ACTIONS (e.g. 'beforeOverwrite')
+* @param fn The function to call when this middleware is triggered
+* The fn receives a request object with information on the triggered action (e.g. the snapshot to write)
+* and a next function to call once the middleware is complete
+*
+* NOTE: It is recommended not to add async or long running tasks to the sharedb-mongo middleware as it will
+* be called very frequently during sensitive operations. It may have a significant performance impact.
+*/
+MiddlewareHandler.prototype.use = function(action, fn) {
+  if (Array.isArray(action)) {
+    for (var i = 0; i < action.length; i++) {
+      this.use(action[i], fn);
+    }
+    return this;
+  }
+  if (!action) throw new Error('Expected action to be defined');
+  if (!fn) throw new Error('Expected fn to be defined');
+  if (!Object.values(MIDDLEWARE_ACTIONS).includes(action)) {
+    throw new Error('Unrecognized action name ' + action);
+  }
+
+  var fns = this._middleware[action] || (this._middleware[action] = []);
+  fns.push(fn);
+  return this;
+};
+
+/**
+ * Passes request through the middleware stack
+ *
+ * Middleware may modify the request object. After all middleware have been
+ * invoked we call `callback` with `null` and the modified request. If one of
+ * the middleware resturns an error the callback is called with that error.
+ *
+ * @param action The action to trigger from MIDDLEWARE_ACTIONS (e.g. 'beforeOverwrite')
+ * @param request Request details such as the snapshot to write, depends on the triggered action
+ * @param callback Function to call once the middleware has been processed.
+ */
+MiddlewareHandler.prototype.trigger = function(action, request, callback) {
+  request.action = action;
+
+  var fns = this._middleware[action];
+  if (!fns) return callback();
+
+  // Copying the triggers we'll fire so they don't get edited while we iterate.
+  fns = fns.slice();
+  var next = function(err) {
+    if (err) return callback(err);
+    var fn = fns.shift();
+    if (!fn) return callback();
+    fn(request, next);
+  };
+  next();
+};
+
+MiddlewareHandler.Actions = MIDDLEWARE_ACTIONS;
+
+module.exports = MiddlewareHandler;

package/test/mocha.opts

@@ -2,3 +2,4 @@
 --check-leaks
 --globals Promise
 --timeout 18000
+--file test/setup.js

package/test/setup.js

@@ -0,0 +1,10 @@
+var logger = require('sharedb/lib/logger');
+
+if (process.env.LOGGING !== 'true') {
+  // Silence the logger for tests by setting all its methods to no-ops
+  logger.setMethods({
+    info: function() {},
+    warn: function() {},
+    error: function() {}
+  });
+}

package/test/test_get_ops.js

@@ -0,0 +1,135 @@
+var expect = require('chai').expect;
+var ShareDbMongo = require('..');
+var sinon = require('sinon');
+
+var mongoUrl = process.env.TEST_MONGO_URL || 'mongodb://localhost:27017/test';
+
+function create(options, callback) {
+  var opts = Object.assign({
+    mongoOptions: {},
+    getOpsWithoutStrictLinking: true
+  }, options);
+  var db = new ShareDbMongo(mongoUrl, opts);
+  db.getDbs(function(err, mongo) {
+    if (err) return callback(err);
+    mongo.dropDatabase(function(err) {
+      if (err) return callback(err);
+      callback(null, db, mongo);
+    });
+  });
+};
+
+// loop thru strict linking options
+[true, false].forEach(function(strictLinkingOption) {
+  describe('getOps with strict linking ' + strictLinkingOption, function() {
+    beforeEach(function(done) {
+      var self = this;
+      create(
+        {getOpsWithoutStrictLinking: strictLinkingOption},
+        function(err, db, mongo) {
+          if (err) return done(err);
+          self.db = db;
+          self.mongo = mongo;
+          done();
+        });
+    });
+
+    afterEach(function(done) {
+      this.db.close(done);
+    });
+
+    describe('a chain of ops', function() {
+      var db;
+      var mongo;
+      var id;
+      var collection;
+
+      beforeEach(function(done) {
+        db = this.db;
+        mongo = this.mongo;
+        id = 'document1';
+        collection = 'testcollection';
+
+        sinon.spy(db, '_getOps');
+        sinon.spy(db, '_getSnapshotOpLink');
+
+        var ops = [
+          {v: 0, create: {}},
+          {v: 1, p: ['foo'], oi: 'bar'},
+          {v: 2, p: ['foo'], oi: 'baz'},
+          {v: 3, p: ['foo'], oi: 'qux'}
+        ];
+
+        commitOpChain(db, mongo, collection, id, ops, function(error) {
+          if (error) done(error);
+          mongo.collection('o_' + collection).deleteOne({v: 1}, done);
+        });
+      });
+
+      it('fetches ops 2-3 without fetching all ops', function(done) {
+        db.getOps(collection, id, 2, 4, null, function(error, ops) {
+          if (error) return done(error);
+          expect(ops.length).to.equal(2);
+          expect(ops[0].v).to.equal(2);
+          expect(ops[1].v).to.equal(3);
+          done();
+        });
+      });
+
+      it('default option errors when missing ops', function(done) {
+        db.getOps(collection, id, 0, 4, null, function(error) {
+          expect(error.code).to.equal(5103);
+          expect(error.message).to.equal('Missing ops from requested version testcollection.document1 0');
+          done();
+        });
+      });
+
+      it('ignoreMissingOps option returns ops up to the first missing op', function(done) {
+        db.getOps(collection, id, 0, 4, {ignoreMissingOps: true}, function(error, ops) {
+          if (error) return done(error);
+          expect(ops.length).to.equal(2);
+          expect(ops[0].v).to.equal(2);
+          expect(ops[1].v).to.equal(3);
+          done();
+        });
+      });
+
+      it('getOpsToSnapshot ignoreMissingOps option returns ops up to the first missing op', function(done) {
+        db.getSnapshot(collection, id, {$submit: true}, null, function(error, snapshot) {
+          if (error) done(error);
+          db.getOpsToSnapshot(collection, id, 0, snapshot, {ignoreMissingOps: true}, function(error, ops) {
+            if (error) return done(error);
+            expect(ops.length).to.equal(2);
+            expect(ops[0].v).to.equal(2);
+            expect(ops[1].v).to.equal(3);
+            done();
+          });
+        });
+      });
+    });
+  });
+});
+
+function commitOpChain(db, mongo, collection, id, ops, previousOpId, version, callback) {
+  if (typeof previousOpId === 'function') {
+    callback = previousOpId;
+    previousOpId = undefined;
+    version = 0;
+  }
+
+  ops = ops.slice();
+  var op = ops.shift();
+
+  if (!op) {
+    return callback();
+  }
+
+  var snapshot = {id: id, v: version + 1, type: 'json0', data: {}, m: null, _opLink: previousOpId};
+  db.commit(collection, id, op, snapshot, null, function(error) {
+    if (error) return callback(error);
+    mongo.collection('o_' + collection).find({d: id, v: version}).next(function(error, op) {
+      if (error) return callback(error);
+      commitOpChain(db, mongo, collection, id, ops, (op ? op._id : null), ++version, callback);
+    });
+  });
+}

package/test/test_get_ops_without_strict_linking.js

@@ -0,0 +1,189 @@
+var expect = require('chai').expect;
+var ShareDbMongo = require('..');
+var getQuery = require('sharedb-mingo-memory/get-query');
+var sinon = require('sinon');
+
+var mongoUrl = process.env.TEST_MONGO_URL || 'mongodb://localhost:27017/test';
+
+function create(callback) {
+  var db = new ShareDbMongo(mongoUrl, {
+    mongoOptions: {},
+    getOpsWithoutStrictLinking: true
+  });
+  db.getDbs(function(err, mongo) {
+    if (err) return callback(err);
+    mongo.dropDatabase(function(err) {
+      if (err) return callback(err);
+      callback(null, db, mongo);
+    });
+  });
+};
+
+require('sharedb/test/db')({create: create, getQuery: getQuery});
+
+describe('getOpsWithoutStrictLinking: true', function() {
+  beforeEach(function(done) {
+    var self = this;
+    create(function(err, db, mongo) {
+      if (err) return done(err);
+      self.db = db;
+      self.mongo = mongo;
+      done();
+    });
+  });
+
+  afterEach(function(done) {
+    this.db.close(done);
+  });
+
+  describe('a chain of ops', function() {
+    var db;
+    var mongo;
+    var id;
+    var collection;
+
+    beforeEach(function(done) {
+      db = this.db;
+      mongo = this.mongo;
+      id = 'document1';
+      collection = 'testcollection';
+
+      sinon.spy(db, '_getOps');
+      sinon.spy(db, '_getSnapshotOpLink');
+
+      var ops = [
+        {v: 0, create: {}},
+        {v: 1, p: ['foo'], oi: 'bar'},
+        {v: 2, p: ['foo'], oi: 'baz'},
+        {v: 3, p: ['foo'], oi: 'qux'}
+      ];
+
+      commitOpChain(db, mongo, collection, id, ops, done);
+    });
+
+    it('fetches ops 0-1 without fetching all ops', function(done) {
+      db.getOps(collection, id, 0, 2, null, function(error, ops) {
+        if (error) return done(error);
+        expect(ops.length).to.equal(2);
+        expect(ops[0].v).to.equal(0);
+        expect(ops[1].v).to.equal(1);
+        expect(db._getSnapshotOpLink.notCalled).to.equal(true);
+        expect(db._getOps.calledOnceWith(collection, id, 0, 2)).to.equal(true);
+        done();
+      });
+    });
+
+    it('fetches ops 0-1 when v1 has a spurious duplicate', function(done) {
+      var spuriousOp = {v: 1, d: id, p: ['foo'], oi: 'corrupt', o: null};
+
+      callInSeries([
+        function(next) {
+          mongo.collection('o_' + collection).insertOne(spuriousOp, next);
+        },
+        function(result, next) {
+          db.getOps(collection, id, 0, 2, null, next);
+        },
+        function(ops, next) {
+          expect(ops.length).to.equal(2);
+          expect(ops[1].oi).to.equal('bar');
+          expect(db._getSnapshotOpLink.notCalled).to.equal(true);
+          expect(db._getOps.calledOnceWith(collection, id, 0, 2)).to.equal(true);
+          next();
+        },
+        done
+      ]);
+    });
+
+    it('fetches ops 0-1 when the next op v2 has a spurious duplicate', function(done) {
+      var spuriousOp = {v: 2, d: id, p: ['foo'], oi: 'corrupt', o: null};
+
+      callInSeries([
+        function(next) {
+          mongo.collection('o_' + collection).insertOne(spuriousOp, next);
+        },
+        function(result, next) {
+          db.getOps(collection, id, 0, 2, null, next);
+        },
+        function(ops, next) {
+          expect(ops.length).to.equal(2);
+          expect(ops[1].oi).to.equal('bar');
+          expect(db._getSnapshotOpLink.notCalled).to.equal(true);
+          expect(db._getOps.calledOnceWith(collection, id, 0, 3)).to.equal(true);
+          next();
+        },
+        done
+      ]);
+    });
+
+    it('fetches ops 0-1 when all the ops have spurious duplicates', function(done) {
+      var spuriousOps = [
+        {v: 0, d: id, p: ['foo'], oi: 'corrupt', o: null},
+        {v: 1, d: id, p: ['foo'], oi: 'corrupt', o: null},
+        {v: 2, d: id, p: ['foo'], oi: 'corrupt', o: null},
+        {v: 3, d: id, p: ['foo'], oi: 'corrupt', o: null}
+      ];
+
+      callInSeries([
+        function(next) {
+          mongo.collection('o_' + collection).insertMany(spuriousOps, next);
+        },
+        function(result, next) {
+          db.getOps(collection, id, 0, 2, null, next);
+        },
+        function(ops, next) {
+          expect(ops.length).to.equal(2);
+          expect(ops[0].create).to.eql({});
+          expect(ops[1].oi).to.equal('bar');
+          expect(db._getSnapshotOpLink.calledOnce).to.equal(true);
+          next();
+        },
+        done
+      ]);
+    });
+  });
+});
+
+function commitOpChain(db, mongo, collection, id, ops, previousOpId, version, callback) {
+  if (typeof previousOpId === 'function') {
+    callback = previousOpId;
+    previousOpId = undefined;
+    version = 0;
+  }
+
+  ops = ops.slice();
+  var op = ops.shift();
+
+  if (!op) {
+    return callback();
+  }
+
+  var snapshot = {id: id, v: version + 1, type: 'json0', data: {}, m: null, _opLink: previousOpId};
+  db.commit(collection, id, op, snapshot, null, function(error) {
+    if (error) return callback(error);
+    mongo.collection('o_' + collection).find({d: id, v: version}).next(function(error, op) {
+      if (error) return callback(error);
+      commitOpChain(db, mongo, collection, id, ops, op._id, ++version, callback);
+    });
+  });
+}
+
+function callInSeries(callbacks, args) {
+  if (!callbacks.length) return;
+  args = args || [];
+  var error = args.shift();
+
+  if (error) {
+    var finalCallback = callbacks[callbacks.length - 1];
+    return finalCallback(error);
+  }
+
+  var callback = callbacks.shift();
+  if (callbacks.length) {
+    args.push(function() {
+      var args = Array.from(arguments);
+      callInSeries(callbacks, args);
+    });
+  }
+
+  callback.apply(callback, args);
+}