Merge branch 'master' into warn-about-deprecated-features

Author: nateps

.gitignore

@@ -30,4 +30,5 @@ coverage
 
 # Dependency directories
 node_modules
+package-lock.json
 jspm_packages

.travis.yml

@@ -3,6 +3,6 @@ node_js:
   - "10"
   - "8"
   - "6"
-script: "ln -s .. node_modules/sharedb; npm run jshint && npm run test-cover"
+script: "npm run jshint && npm run test-cover"
 # Send coverage data to Coveralls
 after_script: "cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js"

lib/client/doc.js

@@ -104,11 +104,19 @@ emitter.mixin(Doc);
 Doc.prototype.destroy = function(callback) {
   var doc = this;
   doc.whenNothingPending(function() {
-    doc.connection._destroyDoc(doc);
     if (doc.wantSubscribe) {
-      return doc.unsubscribe(callback);
+      doc.unsubscribe(function(err) {
+        if (err) {
+          if (callback) return callback(err);
+          return doc.emit('error', err);
+        }
+        doc.connection._destroyDoc(doc);
+        if (callback) callback();
+      });
+    } else {
+      doc.connection._destroyDoc(doc);
+      if (callback) callback();
     }
-    if (callback) callback();
   });
 };
 

lib/db/index.js

@@ -7,6 +7,7 @@ function DB(options) {
 }
 module.exports = DB;
 
+// When false, Backend will handle projections instead of DB
 DB.prototype.projectsSnapshots = false;
 DB.prototype.disableSubscribe = false;
 

lib/ot.js

@@ -102,7 +102,7 @@ exports.apply = function(snapshot, op) {
 function applyOpEdit(snapshot, edit) {
   if (!snapshot.type) return {code: 4015, message: 'Document does not exist'};
 
-  if (typeof edit !== 'object') return {code: 5004, message: 'Missing op'};
+  if (edit == null) return {code: 5004, message: 'Missing op'};
   var type = types[snapshot.type];
   if (!type) return {code: 4008, message: 'Unknown type'};
 

package.json

@@ -16,8 +16,7 @@
     "expect.js": "^0.3.1",
     "istanbul": "^0.4.2",
     "jshint": "^2.9.2",
-    "mocha": "^3.2.0",
-    "sharedb-mingo-memory": "^1.0.0-beta"
+    "mocha": "^5.2.0"
   },
   "scripts": {
     "test": "./node_modules/.bin/mocha && npm run jshint",

test/client/number-type.js

@@ -0,0 +1,23 @@
+// A simple number type, where:
+//
+// - snapshot is an integer
+// - operation is an integer
+exports.type = {
+  name: 'number-type',
+  uri: 'http://sharejs.org/types/number-type',
+  create: create,
+  apply: apply,
+  transform: transform
+};
+
+function create(data) {
+  return data | 0;
+}
+
+function apply(snapshot, op) {
+  return snapshot + op;
+}
+
+function transform(op1, op2, side) {
+  return op1;
+}

test/client/query-subscribe.js

@@ -413,14 +413,13 @@ describe('client query subscribe', function() {
 
   it('changing a sorted property moves in a subscribed query', function(done) {
     var connection = this.backend.connect();
-    var matchAllDbQuery = this.matchAllDbQuery;
 
     async.parallel([
       function(cb) { connection.get('dogs', 'fido').create({age: 3}, cb); },
       function(cb) { connection.get('dogs', 'spot').create({age: 5}, cb); }
     ], function(err) {
       if (err) return done(err);
-      var dbQuery = getQuery({query: matchAllDbQuery, sort: [['age', 1]]});
+      var dbQuery = getQuery({query: {}, sort: [['age', 1]]});
       var query = connection.createSubscribeQuery(
         'dogs',
         dbQuery,

test/client/submit.js

@@ -2,8 +2,10 @@ var async = require('async');
 var expect = require('expect.js');
 var types = require('../../lib/types');
 var deserializedType = require('./deserialized-type');
+var numberType = require('./number-type');
 types.register(deserializedType.type);
 types.register(deserializedType.type2);
+types.register(numberType.type);
 
 module.exports = function() {
 describe('client submit', function() {
@@ -509,25 +511,44 @@ describe('client submit', function() {
   });
 
   it('submits fail above the backend.maxSubmitRetries threshold', function(done) {
+    var backend = this.backend;
     this.backend.maxSubmitRetries = 0;
     var doc = this.backend.connect().get('dogs', 'fido');
     var doc2 = this.backend.connect().get('dogs', 'fido');
     doc.create({age: 3}, function(err) {
       if (err) return done(err);
       doc2.fetch(function(err) {
         if (err) return done(err);
-        var count = 0;
-        var cb = function(err) {
-          count++;
-          if (count === 1) {
-            if (err) return done(err);
-          } else {
-            expect(err).ok();
-            done();
+        var docCallback;
+        var doc2Callback;
+        // The submit retry happens just after an op is committed. This hook into the middleware
+        // catches both ops just before they're about to be committed. This ensures that both ops
+        // are certainly working on the same snapshot (ie one op hasn't been committed before the
+        // other fetches the snapshot to apply to). By storing the callbacks, we can then
+        // manually trigger the callbacks, first calling doc, and when we know that's been committed,
+        // we then commit doc2.
+        backend.use('commit', function (request, callback) {
+          if (request.op.op[0].na === 2) docCallback = callback;
+          if (request.op.op[0].na === 7) doc2Callback = callback;
+
+          // Wait until both ops have been applied to the same snapshot and are about to be committed
+          if (docCallback && doc2Callback) {
+            // Trigger the first op's commit and then the second one later, which will cause the
+            // second op to retry
+            docCallback();
           }
-        };
-        doc.submitOp({p: ['age'], na: 2}, cb);
-        doc2.submitOp({p: ['age'], na: 7}, cb);
+        });
+        doc.submitOp({p: ['age'], na: 2}, function (error) {
+          if (error) return done(error);
+          // When we know the first op has been committed, we try to commit the second op, which will
+          // fail because it's working on an out-of-date snapshot. It will retry, but exceed the
+          // maxSubmitRetries limit of 0
+          doc2Callback();
+        });
+        doc2.submitOp({p: ['age'], na: 7}, function (error) {
+          expect(error).ok();
+          done();
+        });
       });
     });
   });
@@ -608,11 +629,16 @@ describe('client submit', function() {
         doc2.del(function(err) {
           if (err) return done(err);
           doc.pause();
+          var calledBack = false;
+          doc.on('error', function() {
+            expect(calledBack).equal(true);
+            done();
+          });
           doc.submitOp({p: ['age'], na: 1}, function(err) {
             expect(err).ok();
             expect(doc.version).equal(2);
             expect(doc.data).eql(undefined);
-            done();
+            calledBack = true;
           });
           doc.fetch();
         });
@@ -632,11 +658,16 @@ describe('client submit', function() {
           doc2.create({age: 5}, function(err) {
             if (err) return done(err);
             doc.pause();
+            var calledBack = false;
+            doc.on('error', function() {
+              expect(calledBack).equal(true);
+              done();
+            });
             doc.create({age: 9}, function(err) {
               expect(err).ok();
               expect(doc.version).equal(3);
               expect(doc.data).eql({age: 5});
-              done();
+              calledBack = true;
             });
             doc.fetch();
           });
@@ -1044,6 +1075,19 @@ describe('client submit', function() {
     });
   });
 
+  it('allows snapshot and op to be a non-object', function(done) {
+    var doc = this.backend.connect().get('dogs', 'fido');
+    doc.create(5, numberType.type.uri, function (err) {
+      if (err) return done(err);
+      expect(doc.data).to.equal(5);
+      doc.submitOp(2, function(err) {
+        if (err) return done(err);
+        expect(doc.data).to.equal(7);
+        done();
+      });
+    });
+  });
+
   describe('type.deserialize', function() {
     it('can create a new doc', function(done) {
       var doc = this.backend.connect().get('dogs', 'fido');

test/client/subscribe.js

@@ -405,23 +405,37 @@ describe('client subscribe', function() {
   });
 
   it('doc destroy stops op updates', function(done) {
-    var doc = this.backend.connect().get('dogs', 'fido');
-    var doc2 = this.backend.connect().get('dogs', 'fido');
+    var connection1 = this.backend.connect();
+    var connection2 = this.backend.connect();
+    var doc = connection1.get('dogs', 'fido');
+    var doc2 = connection2.get('dogs', 'fido');
     doc.create({age: 3}, function(err) {
       if (err) return done(err);
       doc2.subscribe(function(err) {
         if (err) return done(err);
         doc2.on('op', function(op, context) {
-          done();
+          done(new Error('Should not get op event'));
         });
         doc2.destroy(function(err) {
           if (err) return done(err);
+          expect(connection2.getExisting('dogs', 'fido')).equal(undefined);
           doc.submitOp({p: ['age'], na: 1}, done);
         });
       });
     });
   });
 
+  it('doc destroy removes doc from connection when doc is not subscribed', function(done) {
+    var connection = this.backend.connect();
+    var doc = connection.get('dogs', 'fido');
+    expect(connection.getExisting('dogs', 'fido')).equal(doc);
+    doc.destroy(function(err) {
+      if (err) return done(err);
+      expect(connection.getExisting('dogs', 'fido')).equal(undefined);
+      done();
+    });
+  });
+
   it('bulk unsubscribe stops op updates', function(done) {
     var connection = this.backend.connect();
     var connection2 = this.backend.connect();

test/db-memory.js

@@ -2,11 +2,6 @@ var expect = require('expect.js');
 var DB = require('../lib/db');
 var MemoryDB = require('../lib/db/memory');
 
-// Extend from MemoryDB as defined in this package, not the one that
-// sharedb-mingo-memory depends on.
-var ShareDbMingo = require('sharedb-mingo-memory').extendMemoryDB(MemoryDB);
-var getQuery = require('sharedb-mingo-memory/get-query');
-
 describe('DB base class', function() {
   it('can call db.close() without callback', function() {
     var db = new DB();
@@ -59,10 +54,76 @@ describe('DB base class', function() {
   });
 });
 
+
+// Extension of MemoryDB that supports query filters and sorts on simple
+// top-level properties, which is enough for the core ShareDB tests on
+// query subscription updating.
+function BasicQueryableMemoryDB() {
+  MemoryDB.apply(this, arguments);
+}
+BasicQueryableMemoryDB.prototype = Object.create(MemoryDB.prototype);
+BasicQueryableMemoryDB.prototype.constructor = BasicQueryableMemoryDB;
+
+BasicQueryableMemoryDB.prototype._querySync = function(snapshots, query, options) {
+  if (query.filter) {
+    snapshots = snapshots.filter(function(snapshot) {
+      for (var queryKey in query.filter) {
+        // This fake only supports simple property equality filters, so
+        // throw an error on Mongo-like filter properties with dots.
+        if (queryKey.includes('.')) {
+          throw new Error('Only simple property filters are supported, got:', queryKey);
+        }
+        if (snapshot.data[queryKey] !== query.filter[queryKey]) {
+          return false;
+        }
+      }
+      return true;
+    });
+  }
+
+  if (query.sort) {
+    if (!Array.isArray(query.sort)) {
+      throw new Error('query.sort must be an array');
+    }
+    if (query.sort.length) {
+      snapshots.sort(snapshotComparator(query.sort));
+    }
+  }
+
+  return {snapshots: snapshots};
+};
+
+// sortProperties is an array whose items are each [propertyName, direction].
+function snapshotComparator(sortProperties) {
+  return function(snapshotA, snapshotB) {
+    for (var i = 0; i < sortProperties.length; i++) {
+      var sortProperty = sortProperties[i];
+      var sortKey = sortProperty[0];
+      var sortDirection = sortProperty[1];
+
+      var aPropVal = snapshotA.data[sortKey];
+      var bPropVal = snapshotB.data[sortKey];
+      if (aPropVal < bPropVal) {
+        return -1 * sortDirection;
+      } else if (aPropVal > bPropVal) {
+        return sortDirection;
+      } else if (aPropVal === bPropVal) {
+        continue;
+      } else {
+        throw new Error('Could not compare ' + aPropVal + ' and ' + bPropVal);
+      }
+    }
+    return 0;
+  };
+}
+
+// Run all the DB-based tests against the BasicQueryableMemoryDB.
 require('./db')({
   create: function(callback) {
-    var db = new ShareDbMingo();
+    var db = new BasicQueryableMemoryDB();
     callback(null, db);
   },
-  getQuery: getQuery
+  getQuery: function(options) {
+    return {filter: options.query, sort: options.sort};
+  }
 });