sharedb 6.0.3 → 6.0.4

package/README.md

@@ -1,8 +1,8 @@
 # ShareDB
 
   [![NPM Version](https://img.shields.io/npm/v/sharedb.svg)](https://npmjs.org/package/sharedb)
-  ![Test](https://github.com/share/sharedb/workflows/Test/badge.svg)
-  [![Coverage Status](https://coveralls.io/repos/github/share/sharedb/badge.svg?branch=master)](https://coveralls.io/github/share/sharedb?branch=master)
+  ![Test](https://github.com/share/sharedb/actions/workflows/test.yml/badge.svg?branch=main)
+  [![Coverage Status](https://coveralls.io/repos/github/share/sharedb/badge.svg?branch=main)](https://coveralls.io/github/share/sharedb?branch=main)
 
 ShareDB is a realtime database backend based on [Operational Transformation
 (OT)](https://en.wikipedia.org/wiki/Operational_transformation) of JSON

package/lib/agent.js

@@ -388,6 +388,8 @@ Agent.prototype._checkRequest = function(request) {
       request.a === ACTIONS.fetch ||
       request.a === ACTIONS.subscribe ||
       request.a === ACTIONS.unsubscribe ||
+      request.a === ACTIONS.snapshotFetch ||
+      request.a === ACTIONS.snapshotFetchByTimestamp ||
       request.a === ACTIONS.presence) {
     // Doc-based request.
     if (request.c != null) {
@@ -401,6 +403,11 @@ Agent.prototype._checkRequest = function(request) {
       }
     }
 
+    if (request.a === ACTIONS.snapshotFetch || request.a === ACTIONS.snapshotFetchByTimestamp) {
+      if (request.c == null) return 'Invalid collection';
+      if (request.d == null) return 'Invalid id';
+    }
+
     if (request.a === ACTIONS.op || request.a === ACTIONS.presence) {
       if (request.v != null && (typeof request.v !== 'number' || request.v < 0)) return 'Invalid version';
     }

package/lib/backend.js

@@ -106,10 +106,7 @@ Backend.prototype.close = function(callback) {
   var wait = 4;
   var backend = this;
   function finish(err) {
-    if (err) {
-      if (callback) return callback(err);
-      return backend.emit('error', err);
-    }
+    if (err) return util.callbackOrEmit(backend, err, callback);
     if (--wait) return;
     if (callback) callback();
   }

package/lib/client/doc.js

@@ -131,10 +131,7 @@ Doc.prototype.destroy = function(callback) {
   doc.whenNothingPending(function() {
     if (doc.wantSubscribe) {
       doc.unsubscribe(function(err) {
-        if (err) {
-          if (callback) return callback(err);
-          return doc.emit('error', err);
-        }
+        if (err) return util.callbackOrEmit(doc, err, callback);
         doc.connection._destroyDoc(doc);
         if (callback) callback();
       });
@@ -191,8 +188,7 @@ Doc.prototype.ingestSnapshot = function(snapshot, callback) {
       ERROR_CODE.ERR_INGESTED_SNAPSHOT_HAS_NO_VERSION,
       'Missing version in ingested snapshot. ' + this.collection + '.' + this.id
     );
-    if (callback) return callback(err);
-    return this.emit('error', err);
+    return util.callbackOrEmit(this, err, callback);
   }
 
   // If the doc is already created or there are ops pending, we cannot use the
@@ -214,8 +210,7 @@ Doc.prototype.ingestSnapshot = function(snapshot, callback) {
         ERROR_CODE.ERR_DOC_MISSING_VERSION,
         'Cannot ingest snapshot in doc with null version. ' + this.collection + '.' + this.id
       );
-      if (callback) return callback(err);
-      return this.emit('error', err);
+      return util.callbackOrEmit(this, err, callback);
     }
     // If we got a snapshot for a version further along than the document is
     // currently, issue a fetch to get the latest ops and catch us up
@@ -764,8 +759,7 @@ Doc.prototype._submit = function(op, source, callback) {
         );
       }
 
-      if (callback) return callback(err);
-      return this.emit('error', err);
+      return util.callbackOrEmit(this, err, callback);
     }
     // Try to normalize the op. This removes trailing skip:0's and things like that.
     if (this.type.normalize) op.op = this.type.normalize(op.op);
@@ -773,10 +767,7 @@ Doc.prototype._submit = function(op, source, callback) {
     // This has to happen before _pushOp(), because _tryCompose() applies the op
     // to a pending create, well before _otApply() gets a chance to check it
     var pathError = ot.checkOpPathsForType(this.type, op);
-    if (pathError) {
-      if (callback) return callback(pathError);
-      return this.emit('error', pathError);
-    }
+    if (pathError) return util.callbackOrEmit(this, pathError, callback);
   }
 
   try {
@@ -913,8 +904,7 @@ Doc.prototype.create = function(data, type, options, callback) {
   }
   if (this.type) {
     var err = new ShareDBError(ERROR_CODE.ERR_DOC_ALREADY_CREATED, 'Document already exists');
-    if (callback) return callback(err);
-    return this.emit('error', err);
+    return util.callbackOrEmit(this, err, callback);
   }
   var op = {create: {type: type, data: data}};
   var source = options && options.source;
@@ -935,8 +925,7 @@ Doc.prototype.del = function(options, callback) {
   }
   if (!this.type) {
     var err = new ShareDBError(ERROR_CODE.ERR_DOC_DOES_NOT_EXIST, 'Document does not exist');
-    if (callback) return callback(err);
-    return this.emit('error', err);
+    return util.callbackOrEmit(this, err, callback);
   }
   var op = {del: true};
   var source = options && options.source;

package/lib/client/query.js

@@ -149,8 +149,7 @@ Query.prototype._finishResponse = function(err, callback) {
   this.ready = true;
   if (err) {
     this.connection._destroyQuery(this);
-    if (callback) return callback(err);
-    return this.emit('error', err);
+    return util.callbackOrEmit(this, err, callback);
   }
   if (callback) callback(null, this.results, this.extra);
 };

package/lib/util.js

@@ -84,6 +84,11 @@ exports.callEach = function(callbacks, error) {
   return called;
 };
 
+exports.callbackOrEmit = function(emitter, error, callback) {
+  if (callback) return callback(error);
+  if (error) emitter.emit('error', error);
+};
+
 exports.truthy = function(arg) {
   return !!arg;
 };

package/package.json

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

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

@@ -208,6 +208,26 @@ describe('SnapshotTimestampRequest', function() {
       expect(fetch).to.throw(Error);
     });
 
+    [{}, null, '__proto__'].forEach(function(badValue) {
+      it('errors without reading the database if the collection is ' + JSON.stringify(badValue), function(done) {
+        var getSnapshot = sinon.spy(MemoryDb.prototype, 'getSnapshot');
+        backend.connect().fetchSnapshotByTimestamp(badValue, 'time-machine', null, function(error) {
+          expect(error).to.include({code: 'ERR_MESSAGE_BADLY_FORMED', message: 'Invalid collection'});
+          expect(getSnapshot).not.to.have.been.called;
+          done();
+        });
+      });
+
+      it('errors without reading the database if the id is ' + JSON.stringify(badValue), function(done) {
+        var getSnapshot = sinon.spy(MemoryDb.prototype, 'getSnapshot');
+        backend.connect().fetchSnapshotByTimestamp('books', badValue, null, function(error) {
+          expect(error).to.include({code: 'ERR_MESSAGE_BADLY_FORMED', message: 'Invalid id'});
+          expect(getSnapshot).not.to.have.been.called;
+          done();
+        });
+      });
+    });
+
     it('returns an empty snapshot if trying to fetch a non-existent document', function(done) {
       backend.connect().fetchSnapshotByTimestamp('books', 'does-not-exist', day1, function(error, snapshot) {
         if (error) return done(error);

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

@@ -143,6 +143,26 @@ describe('SnapshotVersionRequest', function() {
       expect(fetch).to.throw(Error);
     });
 
+    [{}, null, '__proto__'].forEach(function(badValue) {
+      it('errors without reading the database if the collection is ' + JSON.stringify(badValue), function(done) {
+        var getSnapshot = sinon.spy(MemoryDb.prototype, 'getSnapshot');
+        backend.connect().fetchSnapshot(badValue, 'don-quixote', null, function(error) {
+          expect(error).to.include({code: 'ERR_MESSAGE_BADLY_FORMED', message: 'Invalid collection'});
+          expect(getSnapshot).not.to.have.been.called;
+          done();
+        });
+      });
+
+      it('errors without reading the database if the id is ' + JSON.stringify(badValue), function(done) {
+        var getSnapshot = sinon.spy(MemoryDb.prototype, 'getSnapshot');
+        backend.connect().fetchSnapshot('books', badValue, null, function(error) {
+          expect(error).to.include({code: 'ERR_MESSAGE_BADLY_FORMED', message: 'Invalid id'});
+          expect(getSnapshot).not.to.have.been.called;
+          done();
+        });
+      });
+    });
+
     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).to.be.ok;

package/test/lib-util.js

@@ -0,0 +1,56 @@
+var EventEmitter = require('../lib/emitter').EventEmitter;
+var util = require('../lib/util');
+var expect = require('chai').expect;
+
+describe('util.callbackOrEmit', function() {
+  var emitter;
+  var error;
+
+  beforeEach(function() {
+    emitter = new EventEmitter();
+    error = new Error('some error');
+  });
+
+  it('calls back synchronously with the error', function() {
+    var calledWith = 'not called';
+    util.callbackOrEmit(emitter, error, function(err) {
+      calledWith = err;
+    });
+    expect(calledWith).to.equal(error);
+  });
+
+  it('calls back synchronously when there is no error', function() {
+    var calledWith = 'not called';
+    util.callbackOrEmit(emitter, null, function(err) {
+      calledWith = err;
+    });
+    expect(calledWith).to.equal(null);
+  });
+
+  it('does not emit when a callback is provided', function() {
+    var emitted = false;
+    emitter.on('error', function() {
+      emitted = true;
+    });
+    util.callbackOrEmit(emitter, error, function() {});
+    expect(emitted).to.equal(false);
+  });
+
+  it('emits the error when there is no callback', function() {
+    var emittedWith = 'not emitted';
+    emitter.on('error', function(err) {
+      emittedWith = err;
+    });
+    util.callbackOrEmit(emitter, error);
+    expect(emittedWith).to.equal(error);
+  });
+
+  it('does nothing when there is no error and no callback', function() {
+    var emitted = false;
+    emitter.on('error', function() {
+      emitted = true;
+    });
+    util.callbackOrEmit(emitter, null);
+    expect(emitted).to.equal(false);
+  });
+});