sharedb-mongo 1.0.0-beta.8 → 2.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

@@ -37,17 +37,17 @@ function OpLinkValidator() {
   this.oneBeforePreviousOp = undefined;
 }
 
-OpLinkValidator.prototype.push = function (op) {
+OpLinkValidator.prototype.push = function(op) {
   this.oneBeforePreviousOp = this.previousOp;
   this.previousOp = this.currentOp;
   this.currentOp = op;
 };
 
-OpLinkValidator.prototype.opWithUniqueVersion = function () {
+OpLinkValidator.prototype.opWithUniqueVersion = function() {
   return this._previousVersionWasUnique() ? this.previousOp : null;
 };
 
-OpLinkValidator.prototype.isAtEndOfList = function () {
+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
@@ -55,23 +55,23 @@ OpLinkValidator.prototype.isAtEndOfList = function () {
   return this.currentOp === null;
 };
 
-OpLinkValidator.prototype._previousVersionWasUnique = function () {
-  const previousVersion = this._previousVersion();
+OpLinkValidator.prototype._previousVersionWasUnique = function() {
+  var previousVersion = this._previousVersion();
 
   return typeof previousVersion === 'number'
     && previousVersion !== this._currentVersion()
     && previousVersion !== this._oneBeforePreviousVersion();
 };
 
-OpLinkValidator.prototype._currentVersion = function () {
+OpLinkValidator.prototype._currentVersion = function() {
   return this.currentOp && this.currentOp.v;
 };
 
-OpLinkValidator.prototype._previousVersion = function () {
+OpLinkValidator.prototype._previousVersion = function() {
   return this.previousOp && this.previousOp.v;
 };
 
-OpLinkValidator.prototype._oneBeforePreviousVersion = function () {
+OpLinkValidator.prototype._oneBeforePreviousVersion = function() {
   return this.oneBeforePreviousOp && this.oneBeforePreviousOp.v;
 };
 

package/package.json

@@ -1,24 +1,37 @@
 {
   "name": "sharedb-mongo",
-  "version": "1.0.0-beta.8",
+  "version": "2.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.1.13 || ^4.0.0",
+    "sharedb": "^1.9.1 || ^2.0.0 || ^3.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",
-    "sinon": "^6.1.5"
+    "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

@@ -1,5 +1,4 @@
-var expect = require('expect.js');
-var mongodb = require('mongodb');
+var expect = require('chai').expect;
 var ShareDbMongo = require('..');
 var getQuery = require('sharedb-mingo-memory/get-query');
 var sinon = require('sinon');
@@ -7,27 +6,25 @@ var sinon = require('sinon');
 var mongoUrl = process.env.TEST_MONGO_URL || 'mongodb://localhost:27017/test';
 
 function create(callback) {
-  var db = ShareDbMongo({
-    mongo: function(shareDbCallback) {
-      mongodb.connect(mongoUrl, function(err, mongo) {
-        if (err) return callback(err);
-        mongo.dropDatabase(function(err) {
-          if (err) return callback(err);
-          shareDbCallback(null, mongo);
-          callback(null, db, mongo);
-        });
-      });
-    },
-    getOpsWithoutStrictLinking: true,
+  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) {
+describe('getOpsWithoutStrictLinking: true', function() {
+  beforeEach(function(done) {
     var self = this;
-    create(function (err, db, mongo) {
+    create(function(err, db, mongo) {
       if (err) return done(err);
       self.db = db;
       self.mongo = mongo;
@@ -35,17 +32,17 @@ describe('getOpsWithoutStrictLinking: true', function () {
     });
   });
 
-  afterEach(function (done) {
+  afterEach(function(done) {
     this.db.close(done);
   });
 
-  describe('a chain of ops', function () {
-    var db
+  describe('a chain of ops', function() {
+    var db;
     var mongo;
     var id;
     var collection;
 
-    beforeEach(function (done) {
+    beforeEach(function(done) {
       db = this.db;
       mongo = this.mongo;
       id = 'document1';
@@ -55,93 +52,93 @@ describe('getOpsWithoutStrictLinking: true', function () {
       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' }
+        {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) {
+    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.be(2);
-        expect(ops[0].v).to.be(0);
-        expect(ops[1].v).to.be(1);
-        expect(db._getSnapshotOpLink.notCalled).to.be(true);
-        expect(db._getOps.calledOnceWith(collection, id, 0, 2)).to.be(true);
+        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 };
+    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).insert(spuriousOp, next);
+        function(next) {
+          mongo.collection('o_' + collection).insertOne(spuriousOp, next);
         },
-        function (result, next) {
+        function(result, next) {
           db.getOps(collection, id, 0, 2, null, next);
         },
-        function (ops, next) {
-          expect(ops.length).to.be(2);
-          expect(ops[1].oi).to.be('bar');
-          expect(db._getSnapshotOpLink.notCalled).to.be(true);
-          expect(db._getOps.calledOnceWith(collection, id, 0, 2)).to.be(true);
+        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 };
+    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).insert(spuriousOp, next);
+        function(next) {
+          mongo.collection('o_' + collection).insertOne(spuriousOp, next);
         },
-        function (result, next) {
+        function(result, next) {
           db.getOps(collection, id, 0, 2, null, next);
         },
-        function (ops, next) {
-          expect(ops.length).to.be(2);
-          expect(ops[1].oi).to.be('bar');
-          expect(db._getSnapshotOpLink.notCalled).to.be(true);
-          expect(db._getOps.calledOnceWith(collection, id, 0, 3)).to.be(true);
+        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) {
+    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 },
+        {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) {
+        function(next) {
           mongo.collection('o_' + collection).insertMany(spuriousOps, next);
         },
-        function (result, next) {
+        function(result, next) {
           db.getOps(collection, id, 0, 2, null, next);
         },
-        function (ops, next) {
-          expect(ops.length).to.be(2);
+        function(ops, next) {
+          expect(ops.length).to.equal(2);
           expect(ops[0].create).to.eql({});
-          expect(ops[1].oi).to.be('bar');
-          expect(db._getSnapshotOpLink.calledOnce).to.be(true);
+          expect(ops[1].oi).to.equal('bar');
+          expect(db._getSnapshotOpLink.calledOnce).to.equal(true);
           next();
         },
-        done,
-      ])
+        done
+      ]);
     });
   });
 });
@@ -160,10 +157,10 @@ function commitOpChain(db, mongo, collection, id, ops, previousOpId, version, ca
     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) {
+  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) {
+    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);
     });
@@ -182,7 +179,7 @@ function callInSeries(callbacks, args) {
 
   var callback = callbacks.shift();
   if (callbacks.length) {
-    args.push(function () {
+    args.push(function() {
       var args = Array.from(arguments);
       callInSeries(callbacks, args);
     });