sharedb 4.1.5 → 5.0.1

package/lib/db/memory.js

@@ -84,10 +84,12 @@ MemoryDB.prototype.getOps = function(collection, id, from, to, options, callback
   if (typeof callback !== 'function') throw new Error('Callback required');
   util.nextTick(function() {
     var opLog = db._getOpLogSync(collection, id);
-    if (to == null) {
-      to = opLog.length;
+    if (!from) from = 0;
+    if (to == null) to = opLog.length;
+    var ops = clone(opLog.slice(from, to).filter(Boolean));
+    if (ops.length < to - from) {
+      return callback(new Error('Missing ops'));
     }
-    var ops = clone(opLog.slice(from, to));
     if (!includeMetadata) {
       for (var i = 0; i < ops.length; i++) {
         delete ops[i].m;
@@ -97,6 +99,18 @@ MemoryDB.prototype.getOps = function(collection, id, from, to, options, callback
   });
 };
 
+MemoryDB.prototype.deleteOps = function(collection, id, from, to, options, callback) {
+  if (typeof callback !== 'function') throw new Error('Callback required');
+  var db = this;
+  util.nextTick(function() {
+    var opLog = db._getOpLogSync(collection, id);
+    if (!from) from = 0;
+    if (to == null) to = opLog.length;
+    for (var i = from; i < to; i++) opLog[i] = null;
+    callback(null);
+  });
+};
+
 // The memory database query function returns all documents in a collection
 // regardless of query by default
 MemoryDB.prototype.query = function(collection, query, fields, options, callback) {

package/lib/submit-request.js

@@ -109,7 +109,7 @@ SubmitRequest.prototype.submit = function(callback) {
         // case, we should return a non-fatal 'Op already submitted' error. We
         // must get the past ops and check their src and seq values to
         // differentiate.
-        backend.db.getCommittedOpVersion(collection, id, snapshot, op, null, function(err, version) {
+        request._fetchCreateOpVersion(function(error, version) {
           if (err) return callback(err);
           if (version == null) {
             callback(request.alreadyCreatedError());
@@ -194,6 +194,15 @@ SubmitRequest.prototype.commit = function(callback) {
   backend.trigger(backend.MIDDLEWARE_ACTIONS.commit, this.agent, this, function(err) {
     if (err) return callback(err);
     if (request._fixupOps.length) request.op.m.fixup = request._fixupOps;
+    if (request.op.create) {
+      // When we create the snapshot, we store a pointer to the op that created
+      // it. This allows us to return OP_ALREADY_SUBMITTED errors when appropriate.
+      request.snapshot.m._create = {
+        src: request.op.src,
+        seq: request.op.seq,
+        v: request.op.v
+      };
+    }
 
     // Try committing the operation and snapshot to the database atomically
     backend.db.commit(
@@ -290,6 +299,20 @@ SubmitRequest.prototype._shouldSaveMilestoneSnapshot = function(snapshot) {
   return this.saveMilestoneSnapshot;
 };
 
+SubmitRequest.prototype._fetchCreateOpVersion = function(callback) {
+  var create = this.snapshot.m._create;
+  if (create) {
+    var version = (create.src === this.op.src && create.seq === this.op.seq) ? create.v : null;
+    return callback(null, version);
+  }
+
+  // We can only reach here if the snapshot is missing the create metadata.
+  // This can happen if a client tries to re-create or resubmit a create op to
+  // a "legacy" snapshot that existed before we started adding the meta (should
+  // be uncommon) or when using a driver that doesn't support metadata (eg Postgres).
+  this.backend.db.getCommittedOpVersion(this.collection, this.id, this.snapshot, this.op, null, callback);
+};
+
 // Non-fatal client errors:
 SubmitRequest.prototype.alreadySubmittedError = function() {
   return new ShareDBError(ERROR_CODE.ERR_OP_ALREADY_SUBMITTED, 'Op already submitted');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sharedb",
-  "version": "4.1.5",
+  "version": "5.0.1",
   "description": "JSON OT database backend",
   "main": "lib/index.js",
   "dependencies": {

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

@@ -145,7 +145,18 @@ describe('SnapshotVersionRequest', function() {
 
     it('errors if asking for a version that does not exist', function(done) {
       backend.connect().fetchSnapshot('books', 'don-quixote', 4, function(error, snapshot) {
-        expect(error.code).to.equal('ERR_OP_VERSION_NEWER_THAN_CURRENT_SNAPSHOT');
+        expect(error).to.be.ok;
+        expect(snapshot).to.equal(undefined);
+        done();
+      });
+    });
+
+    it('errors if asking for a version that does not exist if the DB adapter does not error', function(done) {
+      sinon.stub(MemoryDb.prototype, 'getOps').callsFake(function(collection, id, from, to, options, callback) {
+        callback(null, []);
+      });
+      backend.connect().fetchSnapshot('books', 'don-quixote', 4, function(error, snapshot) {
+        expect(error).to.be.ok;
         expect(snapshot).to.equal(undefined);
         done();
       });

package/test/client/submit.js

@@ -6,6 +6,7 @@ var deserializedType = require('./deserialized-type');
 var numberType = require('./number-type');
 var errorHandler = require('../util').errorHandler;
 var richText = require('rich-text');
+var MemoryDB = require('../../lib/db/memory');
 types.register(deserializedType.type);
 types.register(deserializedType.type2);
 types.register(numberType.type);
@@ -206,44 +207,124 @@ module.exports = function() {
       });
     });
 
-    it('can create a new doc then fetch', function(done) {
-      var doc = this.backend.connect().get('dogs', 'fido');
-      doc.create({age: 3}, function(err) {
-        if (err) return done(err);
-        doc.fetch(function(err) {
-          if (err) return done(err);
-          expect(doc.data).eql({age: 3});
-          expect(doc.version).eql(1);
-          done();
-        });
+
+    describe('create', function() {
+      describe('metadata enabled', function() {
+        runCreateTests();
       });
-    });
 
-    it('calling create on the same doc twice fails', function(done) {
-      var doc = this.backend.connect().get('dogs', 'fido');
-      doc.create({age: 3}, function(err) {
-        if (err) return done(err);
-        doc.create({age: 4}, function(err) {
-          expect(err).instanceOf(Error);
-          expect(doc.version).equal(1);
-          expect(doc.data).eql({age: 3});
-          done();
+      describe('no snapshot metadata available', function() {
+        beforeEach(function() {
+          var getSnapshot = MemoryDB.prototype.getSnapshot;
+          sinon.stub(MemoryDB.prototype, 'getSnapshot')
+            .callsFake(function() {
+              var args = Array.from(arguments);
+              var callback = args.pop();
+              args.push(function(error, snapshot) {
+                if (snapshot) delete snapshot.m;
+                callback(error, snapshot);
+              });
+              getSnapshot.apply(this, args);
+            });
         });
-      });
-    });
 
-    it('trying to create an already created doc without fetching fails and fetches', function(done) {
-      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.create({age: 4}, function(err) {
-          expect(err).instanceOf(Error);
-          expect(doc2.version).equal(1);
-          expect(doc2.data).eql({age: 3});
-          done();
+        afterEach(function() {
+          sinon.restore();
         });
+
+        runCreateTests();
       });
+
+      function runCreateTests() {
+        it('can create a new doc then fetch', function(done) {
+          var doc = this.backend.connect().get('dogs', 'fido');
+          doc.create({age: 3}, function(err) {
+            if (err) return done(err);
+            doc.fetch(function(err) {
+              if (err) return done(err);
+              expect(doc.data).eql({age: 3});
+              expect(doc.version).eql(1);
+              done();
+            });
+          });
+        });
+
+        it('calling create on the same doc twice fails', function(done) {
+          var doc = this.backend.connect().get('dogs', 'fido');
+          doc.create({age: 3}, function(err) {
+            if (err) return done(err);
+            doc.create({age: 4}, function(err) {
+              expect(err).instanceOf(Error);
+              expect(doc.version).equal(1);
+              expect(doc.data).eql({age: 3});
+              done();
+            });
+          });
+        });
+
+        it('trying to create an already created doc without fetching fails and fetches', function(done) {
+          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.create({age: 4}, function(err) {
+              expect(err).instanceOf(Error);
+              expect(doc2.version).equal(1);
+              expect(doc2.data).eql({age: 3});
+              done();
+            });
+          });
+        });
+
+        it('does not fail when resubmitting a create op', function(done) {
+          var backend = this.backend;
+          var connection = backend.connect();
+          var submitted = false;
+          backend.use('submit', function(request, next) {
+            if (!submitted) {
+              submitted = true;
+              connection.close();
+              backend.connect(connection);
+            }
+            next();
+          });
+
+          var doc = connection.get('dogs', 'fido');
+          doc.create({age: 3}, function(error) {
+            expect(doc.version).to.equal(1);
+            done(error);
+          });
+        });
+
+        it('does not fail when resubmitting a create op on a doc that was deleted', function(done) {
+          var backend = this.backend;
+          var connection1 = backend.connect();
+          var connection2 = backend.connect();
+          var doc1 = connection1.get('dogs', 'fido');
+          var doc2 = connection2.get('dogs', 'fido');
+
+          async.series([
+            doc1.create.bind(doc1, {age: 3}),
+            doc1.del.bind(doc1),
+            function(next) {
+              var submitted = false;
+              backend.use('submit', function(request, next) {
+                if (!submitted) {
+                  submitted = true;
+                  connection2.close();
+                  backend.connect(connection2);
+                }
+                next();
+              });
+
+              doc2.create({name: 'Fido'}, function(error) {
+                expect(doc2.version).to.equal(3);
+                next(error);
+              });
+            }
+          ], done);
+        });
+      }
     });
 
     it('server fetches and transforms by already committed op', function(done) {

package/test/db-memory.js

@@ -1,6 +1,8 @@
 var expect = require('chai').expect;
+var Backend = require('../lib/backend');
 var DB = require('../lib/db');
 var BasicQueryableMemoryDB = require('./BasicQueryableMemoryDB');
+var async = require('async');
 
 describe('DB base class', function() {
   it('can call db.close() without callback', function() {
@@ -54,17 +56,83 @@ describe('DB base class', function() {
   });
 });
 
-// Run all the DB-based tests against the BasicQueryableMemoryDB.
-require('./db')({
-  create: function(options, callback) {
-    if (typeof options === 'function') {
-      callback = options;
-      options = null;
+describe('MemoryDB', function() {
+  // Run all the DB-based tests against the BasicQueryableMemoryDB.
+  require('./db')({
+    create: function(options, callback) {
+      if (typeof options === 'function') {
+        callback = options;
+        options = null;
+      }
+      var db = new BasicQueryableMemoryDB(options);
+      callback(null, db);
+    },
+    getQuery: function(options) {
+      return {filter: options.query, sort: options.sort};
     }
-    var db = new BasicQueryableMemoryDB(options);
-    callback(null, db);
-  },
-  getQuery: function(options) {
-    return {filter: options.query, sort: options.sort};
-  }
+  });
+
+  describe('deleteOps', function() {
+    describe('with some ops', function() {
+      var backend;
+      var db;
+      var connection;
+      var doc;
+
+      beforeEach(function(done) {
+        backend = new Backend();
+        db = backend.db;
+        connection = backend.connect();
+        doc = connection.get('dogs', 'fido');
+
+        async.waterfall([
+          doc.create.bind(doc, {name: 'Fido'}),
+          doc.submitOp.bind(doc, [{p: ['tricks'], oi: ['fetch']}]),
+          db.getOps.bind(db, 'dogs', 'fido', null, null, null),
+          function(ops, next) {
+            expect(ops).to.have.length(2);
+            next();
+          }
+        ], done);
+      });
+
+      it('deletes all ops', function(done) {
+        async.waterfall([
+          db.deleteOps.bind(db, 'dogs', 'fido', null, null, null),
+          function(next) {
+            db.getOps('dogs', 'fido', null, null, null, function(error) {
+              expect(error.message).to.equal('Missing ops');
+              next();
+            });
+          }
+        ], done);
+      });
+
+      it('deletes some ops', function(done) {
+        async.waterfall([
+          db.deleteOps.bind(db, 'dogs', 'fido', 0, 1, null),
+          db.getOps.bind(db, 'dogs', 'fido', 1, 2, null),
+          function(ops, next) {
+            expect(ops).to.have.length(1);
+            expect(ops[0].op).to.eql([{p: ['tricks'], oi: ['fetch']}]);
+            db.getOps('dogs', 'fido', 0, 1, null, function(error) {
+              expect(error.message).to.equal('Missing ops');
+              next();
+            });
+          }
+        ], done);
+      });
+
+      it('submits more ops after deleting ops', function(done) {
+        async.series([
+          db.deleteOps.bind(db, 'dogs', 'fido', null, null, null),
+          doc.submitOp.bind(doc, [{p: ['tricks', 1], li: 'sit'}]),
+          function(next) {
+            expect(doc.data.tricks).to.eql(['fetch', 'sit']);
+            next();
+          }
+        ], done);
+      });
+    });
+  });
 });