tapeworm 0.3.2 → 0.4.0

package/lib/event_store_partition.js

@@ -1,5 +1,6 @@
 var _ = require('lodash');
 var Promise = require('bluebird');
+var uuid = require('uuid').v4;
 
 var EventStream = require('./event_stream');
 
@@ -9,40 +10,47 @@ var EventStorePartition = function (partitionId, persistencePartition, dispatchS
   this._dispatchService = dispatchService;
 
   var self = this;
-  _.forEach(['storeSnapshot', 'loadSnapshot', 'queryStream', 'queryStreamWithSnapshot', 'removeSnapshot'], function (what) {
-    if (self._persistencePartition[what]) {
-      self[what] = function () {
-        return self._persistencePartition[what].apply(self._persistencePartition, arguments);
-      };
-    } else {
-      if (what === 'queryStreamWithSnapshot') {
-        // fallback function
+  _.forEach(
+    ['storeSnapshot', 'loadSnapshot', 'queryStream', 'queryStreamWithSnapshot', 'removeSnapshot', 'getLatestCommit', 'querySnapshotsByMaxDateTime'],
+    function (what) {
+      if (self._persistencePartition[what]) {
         self[what] = function () {
-          return self._queryStreamWithSnapshotFallback.apply(self._persistencePartition, arguments);
+          return self._persistencePartition[what].apply(self._persistencePartition, arguments);
         };
+      } else {
+        if (what === 'queryStreamWithSnapshot') {
+          // fallback function
+          self[what] = function () {
+            return self._queryStreamWithSnapshotFallback.apply(self._persistencePartition, arguments);
+          };
+        }
       }
     }
-  })
+  );
 };
 
-EventStorePartition.prototype.openStream = function(streamId, callback) {
-  var stream = new EventStream(this, streamId);
+EventStorePartition.prototype.openStream = function (streamId, writeOnly, callback) {
+  if (typeof writeOnly === 'function') {
+    callback = writeOnly;
+    writeOnly = false;
+  }
+  var stream = new EventStream(this, streamId, writeOnly);
   return stream._prepareStream(callback);
 };
 
-EventStorePartition.prototype.append = function(commits, callback) {
+EventStorePartition.prototype.append = function (commits, callback) {
   //pre hooks
   var self = this;
 
-  if(!_.isArray(commits)) {
+  if (!_.isArray(commits)) {
     commits = [commits];
   }
-  return Promise.each(commits, function(commit) {
-    return self._persistencePartition.append(commit, callback).then(function(r) {
-      var done = function() {
+  return Promise.each(commits, function (commit) {
+    return self._persistencePartition.append(commit, callback).then(function (r) {
+      var done = function () {
         self._persistencePartition.markAsDispatched(commit);
-      }
-      if(self._dispatchService) {
+      };
+      if (self._dispatchService) {
         self._dispatchService(commit, done);
       }
       return r;
@@ -50,46 +58,82 @@ EventStorePartition.prototype.append = function(commits, callback) {
   });
   //post hooks
 };
+/**
+ * Delete function in tapeworm,
+ * Delete should trigger a $stream.deleted.event,  including aggregateType of first event and publish it.
+ * 2. Implement in projector service to listen to this event and then do a delete of all related projections.,
+ * 3. Delete function should store the following new commit (deleted event) under the stream:
+ *   streamId,
+ *   aggregateType,
+ *   date of deletion,
+ *   date of creation,
+ *   principal
+ * 4. Then remove snapshot for this stream and all commits for this stream.
+ * @param {*} streamId
+ * @param {*} deleteEvent optional delete event
+ */
+EventStorePartition.prototype.delete = function (streamId, deleteEvent) {
+  var self = this;
+  var event = Object.assign({}, deleteEvent, {
+    type: '$stream.deleted.event',
+    payload: Object.assign({}, { dateOfDeletion: new Date() }, (deleteEvent && deleteEvent.payload) || {})
+  });
+  return this._truncateStreamFrom(streamId, -1)
+    .then(function (result) {
+      return self.openStream(streamId, false);
+    })
+    .then(function (stream) {
+      stream.append(event);
+      return stream.commit(uuid());
+    })
+    .then(function () {
+      // support legacy/unsupported approach
+      if (self._persistencePartition.removeSnapshot) {
+        return self._persistencePartition.removeSnapshot(streamId);
+      } else if (self._persistencePartition.removeSnapshots) {
+        return self._persistencePartition.removeSnapshots([streamId]);
+      }
+    });
+};
 
 /*** UNDOCUMENTED API ***/
 
-EventStorePartition.prototype._queryStream = function(streamId, callback) {
+EventStorePartition.prototype._queryStream = function (streamId, callback) {
   return this._persistencePartition.queryStream(streamId, callback);
 };
 
-EventStorePartition.prototype._queryAll = function(callback) {
+EventStorePartition.prototype._queryAll = function (callback) {
   return this._persistencePartition.queryAll(callback);
 };
 
-EventStorePartition.prototype._queryStreamWithSnapshotFallback = function(streamId, callback) {
+EventStorePartition.prototype._queryStreamWithSnapshotFallback = function (streamId, callback) {
   var self = this;
   return new Promise(function (resolve, reject) {
     self.loadSnapshot(streamId, function (err, snapshot) {
       if (err) {
-        reject(err)
+        reject(err);
       } else {
-        var snapshotVersion = snapshot && snapshot.version || -1;
+        var snapshotVersion = (snapshot && snapshot.version) || -1;
         self.queryStream(streamId, snapshotVersion, function (err, res) {
-          resolve({ snapshot: snapshot, commits: res })
-        })
+          resolve({ snapshot: snapshot, commits: res });
+        });
       }
-    })
+    });
   }).nodeify(callback);
 };
 
 /*** NEEDED FOR SYNCING ***/
 
-EventStorePartition.prototype._truncateStreamFrom = function(streamId, commitSequence, callback) {
+EventStorePartition.prototype._truncateStreamFrom = function (streamId, commitSequence, callback) {
   return this._persistencePartition.truncateStreamFrom(streamId, commitSequence, callback);
-}
+};
 
-EventStorePartition.prototype._applyCommitHeader = function(commit, header, callback) {
+EventStorePartition.prototype._applyCommitHeader = function (commit, header, callback) {
   return this._persistencePartition.applyCommitHeader(commit, header, callback);
-}
+};
 
 //EventStorePartition.prototype.loadEvents = function(streamId, callback)
 
-
 /*EventStorePartition.prototype.append = function(streamId, expectedVersion, events) {
 	var commit = new Commit(uuid(), this._partitionId, streamId, expectedVersion, events);
 	return this._persistencePartition.append(commit).then(function()
@@ -101,4 +145,4 @@ EventStorePartition.prototype._applyCommitHeader = function(commit, header, call
 };
 */
 
-module.exports = EventStorePartition;
+module.exports = EventStorePartition;

package/lib/event_stream.js

@@ -2,104 +2,146 @@ var Promise = require('bluebird');
 var Commit = require('./persistence/commit');
 var _ = require('lodash');
 
-var EventStream = function(eventPartition, streamId) {
-	if(streamId === undefined) {
-		throw new Error('StreamId must be defined!');
-	}
-	this._partition = eventPartition;
-	this._streamId = streamId;
-	
-	this._uncommittedEvents = [];
-	this._version = 0;
-//	this._prepareStream();
-}
-
-EventStream.prototype._prepareStream = function(callback) {
-	this._committedEvents = [];
-	this._commitSequence = -1;
-	var self = this;
-
-	return this._partition._queryStream(this._streamId, callback).then(function(commits) {
-		self._version = 0;
-
-		if(!commits || commits.length === 0) {
+// writeOnly - will never read entire stream from
+var EventStream = function (eventPartition, streamId, writeOnly) {
+  if (streamId === undefined) {
+    throw new Error('StreamId must be defined!');
+  }
+  this._partition = eventPartition;
+  this._streamId = streamId;
+  this._writeOnly = writeOnly;
+  this._uncommittedEvents = [];
+  this._committedEvents = [];
+  this._version = 0;
+  this._isDeleted = false;
+};
 
-			commits = [];
-			self._version = -1;
-		}
-        var version = 0
-		for(var i=0; i<commits.length; i++) {
-			//console.log('found commit'  + commit);
-			self._commitSequence++;
-			for(var j=0;j<commits[i].events.length;j++) {
-				self._version++;
-                commits[i].events[j].version = version++;
-				self._committedEvents.push(commits[i].events[j]);
-			}
-		}
-	}).then(function(){
-		return self;  
-	});
+EventStream.prototype._prepareStream = function (callback) {
+  this._committedEvents = [];
+  this._commitSequence = -1;
+  var self = this;
+  if (self._writeOnly === true && self._partition.getLatestCommit) {
+    // if stream should only be opened for appending commits, only really care about getting the correct commitSequence (from last commit)
+    return self._partition
+      .getLatestCommit(self._streamId)
+      .then(function (commit) {
+        if (commit) {
+          self._commitSequence = commit.commitSequence;
+          var lastEvent = commit.events[commit.events.length - 1];
+          if (lastEvent && lastEvent.type === '$stream.deleted.event') {
+            self._isDeleted = true;
+          }
+          self._version = lastEvent.version + 1;
+        }
+        // if no commit is found, assume its a new stream, and keep default versions
+      })
+      .then(function () {
+        return self;
+      });
+  } else {
+    return self._partition
+      ._queryStream(self._streamId, callback)
+      .then(function (commits) {
+        self._version = 0;
+
+        if (!commits || commits.length === 0) {
+          commits = [];
+          self._version = -1;
+        } else {
+          if (commits[0] && commits[0].events && commits[0].events[0] && commits[0].events[0].type === '$stream.deleted.event') {
+            throw new Error('Stream is deleted');
+          }
+        }
+        var version = 0;
+        for (var i = 0; i < commits.length; i++) {
+          self._commitSequence++;
+          for (var j = 0; j < commits[i].events.length; j++) {
+            self._version++;
+            commits[i].events[j].version = version++;
+            self._committedEvents.push(commits[i].events[j]);
+          }
+        }
+      })
+      .then(function () {
+        return self;
+      });
+  }
 };
 
-EventStream.prototype.getVersion = function() {
-	return this._version;
+EventStream.prototype.getVersion = function () {
+  return this._version;
 };
 
-EventStream.prototype.append = function(event) {
-	this._uncommittedEvents.push(event);
+EventStream.prototype.append = function (event) {
+  this._uncommittedEvents.push(event);
 };
 
-EventStream.prototype.hasChanges = function() {
-	return this._uncommittedEvents.length > 0;
+EventStream.prototype.hasChanges = function () {
+  return this._uncommittedEvents.length > 0;
 };
 
-EventStream.prototype.commit = function(commitId, callback) {
-	var self = this;
-	if(!this.hasChanges()) {
-		//nothing to commit
-		return Promise.resolve().nodeify(callback);
-	} else {
-		var commit = this._buildCommit(commitId, this._uncommittedEvents);
-        
-		return this._partition.append(commit, callback).then(function(commit) {
-			self._clearChanges();
-			//rebuild local state
-			return self._prepareStream(callback);
-		});
-	}
-}
+EventStream.prototype.commit = function (commitId, callback) {
+  var self = this;
+  
+  if(this._isDeleted) {
+    throw new Error('Stream is deleted, unable to commit: ' + this._uncommittedEvents.map(function(event) {return event.type}) );
+  }
+
+  if (!this.hasChanges()) {
+    //nothing to commit
+    return Promise.resolve().nodeify(callback);
+  } else {
+    var commit = this._buildCommit(commitId, this._uncommittedEvents);
+    return this._partition.append(commit, callback).then(function (commit) {
+      //rebuild local state
+      var events = self._uncommittedEvents;
+      self._version = events[events.length - 1].version + 1;
+      if (self._writeOnly === true) {
+        self._commitSequence++;
+        self._clearChanges();
+      } else {
+        for (var i = 0; i < events.length; i++) {
+          self._committedEvents.push(events[i]);
+        }
+        self._clearChanges();
+        self._commitSequence++;
+        return self;
+      }
+    });
+  }
+};
 
-EventStream.prototype._clearChanges = function() {
-	this._uncommittedEvents = [];
+EventStream.prototype._clearChanges = function () {
+  this._uncommittedEvents = [];
 };
 
-EventStream.prototype.revertChanges = function() {
-	//trunc the uncomitted events log
-	var arr = this._uncommittedEvents;
-	this._uncommittedEvents = [];
-	delete arr;
+EventStream.prototype.revertChanges = function () {
+  //trunc the uncomitted events log
+  var arr = this._uncommittedEvents;
+  this._uncommittedEvents = [];
+  delete arr;
 };
 
+EventStream.prototype._buildCommit = function (commitId, events) {
+  var commitSequence = this._commitSequence;
+  var commit = new Commit(commitId, this._partition._partitionId, this._streamId, ++commitSequence, events);
+  var version = this._version == -1 ? 0 : this._version;
 
-EventStream.prototype._buildCommit = function(commitId, events) {
-	var commitSequence = this._commitSequence;
-	var commit = new Commit(commitId, this._partition._partitionId, this._streamId, ++commitSequence, events);
-    var version = this._version == -1 ? 0 : this._version;
-  
-    _.forEach(events, function(evt) {
-        evt.version = version++;
-    })
-	return commit;
+  _.forEach(events, function (evt) {
+    evt.version = version++;
+  });
+  return commit;
 };
 
-EventStream.prototype.getCommittedEvents = function() {
-	return this._committedEvents.slice();
+EventStream.prototype.getCommittedEvents = function () {
+  if (this._writeOnly) {
+    throw new Error('Cannot access committed events when using writeOnly mode...');
+  }
+  return this._committedEvents.slice();
 };
 
-EventStream.prototype.getUncommittedEvents = function() {
-	return this._uncommittedEvents.slice();
+EventStream.prototype.getUncommittedEvents = function () {
+  return this._uncommittedEvents.slice();
 };
 
-
-module.exports = EventStream;
+module.exports = EventStream;

package/lib/persistence/inmemory/inmemory_partition.js

@@ -9,8 +9,7 @@ var InMemoryPartition = function () {
   this._commitIds = [];
   this._commitConcurrencyCheck = [];
   this._snapshots = {};
-}
-
+};
 
 function getConcurrencyKey(commit) {
   return commit.streamId + '-' + commit.commitSequence;
@@ -21,7 +20,7 @@ InMemoryPartition.prototype._promisify = function (value, callback) {
 
 InMemoryPartition.prototype.truncateStreamFrom = function (streamId, commitSequence, callback) {
   var self = this;
-  var commits = this._streamIndex[streamId];
+  var commits = Array.from(this._streamIndex[streamId]);
   for (var i = 0; i < commits.length; i++) {
     var commit = commits[i];
 
@@ -30,12 +29,17 @@ InMemoryPartition.prototype.truncateStreamFrom = function (streamId, commitSeque
       self._commitIds = _.without(self._commitIds, commit.id);
       self._commitConcurrencyCheck = _.without(self._commitConcurrencyCheck, getConcurrencyKey(commit));
       self._commits = _.without(self._commits, commit);
+      // i--;
     }
   }
-  commits = commits.slice(0, commitSequence);
+  commits = commits.slice(0, Math.max(commitSequence, 0));
   this._streamIndex[streamId] = commits;
   return this._promisify(this);
-}
+};
+
+// InMemoryPartition.prototype.delete = function (streamId, headers, callback) {
+
+// }
 
 InMemoryPartition.prototype.applyCommitHeader = function (commitId, header, callback) {
   var self = this;
@@ -43,17 +47,16 @@ InMemoryPartition.prototype.applyCommitHeader = function (commitId, header, call
   if (commit) {
     _.assign(commit, header);
   } else {
-    throw new Error("Trying to apply header to missing commit: " + commitId);
+    throw new Error('Trying to apply header to missing commit: ' + commitId);
   }
   return this._promisify(commit, callback);
-}
-
+};
 
 InMemoryPartition.prototype.append = function (commit, callback) {
   commit.isDispatched = false;
   //check for duplicates
   if (_.contains(this._commitIds, commit.id)) {
-    throw new DuplicateCommitError("Duplicate commit of " + commit.id);
+    throw new DuplicateCommitError('Duplicate commit of ' + commit.id);
   }
   var concurrencyKey = getConcurrencyKey(commit);
   if (_.contains(this._commitConcurrencyCheck, concurrencyKey)) {
@@ -72,7 +75,7 @@ InMemoryPartition.prototype.append = function (commit, callback) {
 };
 
 InMemoryPartition.prototype.storeSnapshot = function (streamId, snapshot, version, callback) {
-  return this._promisify(this._snapshots[streamId] = { id: streamId, version: version, snapshot: snapshot }, callback);
+  return this._promisify((this._snapshots[streamId] = { id: streamId, version: version, snapshot: snapshot }), callback);
 };
 
 // Loads the latest snapshot
@@ -100,6 +103,14 @@ InMemoryPartition.prototype.queryAll = function (callback) {
   return this._promisify(this._commits.slice(), callback);
 };
 
+InMemoryPartition.prototype.getLatestCommit = function (streamId, callback) {
+  var result = this._streamIndex[streamId];
+  if (result) {
+    result = result.slice().pop();
+  }
+  return this._promisify(result, callback);
+};
+
 InMemoryPartition.prototype.queryStream = function (streamId, fromEventSequence, callback) {
   if (_.isFunction(fromEventSequence)) {
     callback = fromEventSequence;
@@ -132,4 +143,4 @@ InMemoryPartition.prototype.queryStream = function (streamId, fromEventSequence,
   return this._promisify(result, callback);
 };
 
-module.exports = InMemoryPartition;
+module.exports = InMemoryPartition;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tapeworm",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "",
   "main": "index.js",
   "directories": {
@@ -24,6 +24,7 @@
     "event",
     "store"
   ],
+  "prettier": "prettier-config-surikaterna",
   "author": "",
   "license": "MIT",
   "devDependencies": {
@@ -33,11 +34,13 @@
     "eslint-plugin-react": "^3.3.1",
     "istanbul": "^0.3.2",
     "mocha": "^2.0.1",
-    "should": "^4.1.0"
+    "should": "^4.1.0",
+    "prettier": "^2.1.2",
+    "prettier-config-surikaterna": "^1.0.1"
   },
   "dependencies": {
     "bluebird": "^2.5.2",
-    "lodash": "^2.4.1",
-    "node-uuid": "^1.4.2"
+    "lodash": "^2.4.2",
+    "uuid": "^8.3.2"
   }
 }

package/test/event_partition.js

@@ -1,103 +1,115 @@
 var should = require('should');
 var Promise = require('bluebird');
-var uuid = require('node-uuid').v4;
+var uuid = require('uuid').v4;
 
 var EventStore = require('..');
 var Commit = EventStore.Commit;
 
-describe('Partition', function() {
-	describe('#append', function(done) {
-		it('should return commit if added', function(done) {
-			var es = new EventStore();
-			es.openPartition('location').then(function(partition) {
-				partition.append(new Commit('1', 'location', '1', 0, [])).then(function(c) {
-					c[0].events.length.should.equal(0);
-					done();
-				});
-			}).catch(function(err) {
-				done(err);
-			});
-		});
-		it('should return after all commits are persisted', function(done) {
-			var es = new EventStore();
-			es.openPartition('location').then(function(partition) {
-				return partition.append([new Commit('1', 'location', '1', 0, []), new Commit('2', 'location', '1', 1, [])]).then(function(c) {
-					c.length.should.equal(2);
-					done();
-				});
-			}).catch(function(err) {
-				done(err);
-			});
-		});
-	});
-	describe('#_truncateStreamFrom', function() {
-		it('should remove all commits ', function(done) {
-			var es = new EventStore();
-			es.openPartition('location').then(function(partition) {
-				return partition.append([new Commit('1', 'location', '1', 0, []), new Commit('2', 'location', '1', 1, [])]).then(function(c) {
-					return partition._truncateStreamFrom('1', 0).then(function() {
-						return partition.openStream('1').then(function(stream) {
-							stream.getVersion().should.equal(-1);
-							done();
-						});
-					});
-				});
-			}).catch(function(err) {
-				done(err);
-			});
-		});
-		it('should remove all commits after commitSequence', function(done) {
-			var es = new EventStore();
-			es.openPartition('location').then(function(partition) {
-				return partition.append([new Commit('1', 'location', '1', 0, [{}]), new Commit('2', 'location', '1', 1, [{}])]).then(function(c) {
-					return partition._truncateStreamFrom('1', 1).then(function() {
-						return partition.openStream('1').then(function(stream) {
-							stream.getVersion().should.equal(1);
-							done();
-						});
-					});
-				});
-			}).catch(function(err) {
-				done(err);
-			});
-		});
-	});
-	describe('#_applyCommitHeader', function() {
-		it('should add to commit ', function(done) {
-			var es = new EventStore();
-			es.openPartition('location').then(function(partition) {
-				var commit = new Commit('1', 'location', '1', 0, []);
-				return partition.append([commit, new Commit('2', 'location', '1', 1, [])]).then(function(c) {
-					return partition._applyCommitHeader(commit.id, {authorative:true}).then(function(commit) {
-						commit.authorative.should.be.ok;
-						done();
-					});
-				});
-			}).catch(function(err) {
-				done(err);
-			});
-		});
-		it('should throw if commit id is unknown', function(done) {
-			var es = new EventStore();
-			es.openPartition('location').then(function(partition) {
-				var commit = new Commit('1', 'location', '1', 0, []);
-				return partition.append([commit, new Commit('2', 'location', '1', 1, [])]).then(function(c) {
-					return partition._applyCommitHeader("ID MISSING", {authorative:true}).then(function(commit) {
-						done(new Error("Unreachable code"));
-
-					});
-				});
-			}).catch(function(err) {
-				done();
-			});
-		});
-	});
+describe('Partition', function () {
+  describe('#append', function (done) {
+    it('should return commit if added', function (done) {
+      var es = new EventStore();
+      es.openPartition('location')
+        .then(function (partition) {
+          partition.append(new Commit('1', 'location', '1', 0, [])).then(function (c) {
+            c[0].events.length.should.equal(0);
+            done();
+          });
+        })
+        .catch(function (err) {
+          done(err);
+        });
+    });
+    it('should return after all commits are persisted', function (done) {
+      var es = new EventStore();
+      es.openPartition('location')
+        .then(function (partition) {
+          return partition.append([new Commit('1', 'location', '1', 0, []), new Commit('2', 'location', '1', 1, [])]).then(function (c) {
+            c.length.should.equal(2);
+            done();
+          });
+        })
+        .catch(function (err) {
+          done(err);
+        });
+    });
+  });
+  describe('#_truncateStreamFrom', function () {
+    it('should remove all commits ', function (done) {
+      var es = new EventStore();
+      es.openPartition('location')
+        .then(function (partition) {
+          return partition.append([new Commit('1', 'location', '1', 0, []), new Commit('2', 'location', '1', 1, [])]).then(function (c) {
+            return partition._truncateStreamFrom('1', 0).then(function () {
+              return partition.openStream('1').then(function (stream) {
+                stream.getVersion().should.equal(-1);
+                done();
+              });
+            });
+          });
+        })
+        .catch(function (err) {
+          done(err);
+        });
+    });
+    it('should remove all commits after commitSequence', function (done) {
+      var es = new EventStore();
+      es.openPartition('location')
+        .then(function (partition) {
+          return partition.append([new Commit('1', 'location', '1', 0, [{}]), new Commit('2', 'location', '1', 1, [{}])]).then(function (c) {
+            return partition._truncateStreamFrom('1', 1).then(function () {
+              return partition.openStream('1').then(function (stream) {
+                stream.getVersion().should.equal(1);
+                done();
+              });
+            });
+          });
+        })
+        .catch(function (err) {
+          done(err);
+        });
+    });
+  });
+  describe('#_applyCommitHeader', function () {
+    it('should add to commit ', function (done) {
+      var es = new EventStore();
+      es.openPartition('location')
+        .then(function (partition) {
+          var commit = new Commit('1', 'location', '1', 0, []);
+          return partition.append([commit, new Commit('2', 'location', '1', 1, [])]).then(function (c) {
+            return partition._applyCommitHeader(commit.id, { authorative: true }).then(function (commit) {
+              commit.authorative.should.be.ok;
+              done();
+            });
+          });
+        })
+        .catch(function (err) {
+          done(err);
+        });
+    });
+    it('should throw if commit id is unknown', function (done) {
+      var es = new EventStore();
+      es.openPartition('location')
+        .then(function (partition) {
+          var commit = new Commit('1', 'location', '1', 0, []);
+          return partition.append([commit, new Commit('2', 'location', '1', 1, [])]).then(function (c) {
+            return partition._applyCommitHeader('ID MISSING', { authorative: true }).then(function (commit) {
+              done(new Error('Unreachable code'));
+            });
+          });
+        })
+        .catch(function (err) {
+          done();
+        });
+    });
+  });
   describe('#queryStreamWithSnapshot', function () {
     it('queryStreamWithSnapshot should return snapshot and missing commits', function (done) {
       var es = new EventStore();
       var streamId = '1';
       var stream;
-      es.openPartition('location').call('openStream', streamId)
+      es.openPartition('location')
+        .call('openStream', streamId)
         .then(function (stream1) {
           stream = stream1;
           stream.append({ event: '123' });
@@ -118,16 +130,18 @@ describe('Partition', function() {
               res.commits[0].events.length.should.eql(2);
               res.commits[0].events[0].version.should.eql(2);
               done();
-            })
-          })
-        }).catch(function (err) {
-        done(err);
-      });
+            });
+          });
+        })
+        .catch(function (err) {
+          done(err);
+        });
     });
     it('queryStreamWithSnapshot should return snapshot and no commit if up to date', function (done) {
       var es = new EventStore();
       var streamId = '1';
-      es.openPartition('location').call('openStream', streamId)
+      es.openPartition('location')
+        .call('openStream', streamId)
         .then(function (stream) {
           stream.append({ event: '123' });
           stream.append({ event: '999' });
@@ -140,12 +154,79 @@ describe('Partition', function() {
               res.snapshot.version.should.eql(2);
               res.commits.length.should.eql(0);
               done();
-            })
-          })
-        }).catch(function (err) {
-        done(err);
-      });
+            });
+          });
+        })
+        .catch(function (err) {
+          done(err);
+        });
     });
   });
+  describe('#delete', function () {
+    it('should delete stream and all commits', function (done) {
+      var didIGetaDeleteEvent = false;
+      var es = new EventStore(null, (commit) => {
+        if (commit.events[0].type === '$stream.deleted.event') {
+          didIGetaDeleteEvent = true;
+        }
+      });
+      es.openPartition('location')
+        .then(function (partition) {
+          return partition
+            .append([new Commit('1', 'location', '1', 0, [{ type: 'dummy.event' }]), new Commit('2', 'location', '1', 1, [{ type: 'dummy2.event' }])])
+            .then(function (c) {
+              return partition.delete('1', { some: 'header-value', payload: { test: true }, type: 'fail' }).then(function () {
+                return partition
+                  .openStream('1')
+                  .then(function (stream) {
+                    console.log(JSON.stringify(stream, null, 2));
+                    done(new Error('able to open deleted stream'));
+                  })
+                  .catch(function (error) {
+                    error.message.should.equal('Stream is deleted');
+                    didIGetaDeleteEvent.should.be.true;
+                    done();
+                  });
+              });
+            });
+        })
+        .catch(function (err) {
+          done(err);
+        });
+    });
 
+    it('should delete and placeholder commit should have an id', function (done) {
+      var didIGetaDeleteEvent = false;
+      var es = new EventStore(null, (commit) => {
+        console.log(commit.id);
+        if (commit.events[0].type === '$stream.deleted.event' && commit.id) {
+          didIGetaDeleteEvent = true;
+        }
+        should(commit.id).not.be.null;
+      });
+      es.openPartition('location')
+        .then(function (partition) {
+          return partition
+            .append([new Commit('1', 'location', '1', 0, [{ type: 'dummy.event' }]), new Commit('2', 'location', '1', 1, [{ type: 'dummy2.event' }])])
+            .then(function (c) {
+              return partition.delete('1', { some: 'header-value', payload: { test: true }, type: 'fail' }).then(function () {
+                return partition
+                  .openStream('1')
+                  .then(function (stream) {
+                    console.log(JSON.stringify(stream, null, 2));
+                    done(new Error('able to open deleted stream'));
+                  })
+                  .catch(function (error) {
+                    error.message.should.equal('Stream is deleted');
+                    didIGetaDeleteEvent.should.be.true;
+                    done();
+                  });
+              });
+            });
+        })
+        .catch(function (err) {
+          done(err);
+        });
+    });
+  });
 });

package/test/event_stream.js

@@ -1,6 +1,6 @@
 var should = require('should');
 var Promise = require('bluebird');
-var uuid = require('node-uuid').v4;
+var uuid = require('uuid').v4;
 
 var EventStore = require('..');
 var EventStream = require('../lib/event_stream');
@@ -111,6 +111,31 @@ describe('event_stream', function () {
           done(err);
         });
     });
+    it('event stream writeOnly', function (done) {
+      var es = new EventStore();
+      var stream;
+      es.openPartition('location').then(function (partition) {
+        partition.openStream('1', true)
+          .then(function (stream1) {
+            stream = stream1;
+            stream.append({ event: '123' });
+            return stream.commit(uuid());
+          })
+          .then(function () {
+            stream._commitSequence.should.equal(0);
+            stream.append({ event: '666' });
+            stream.append({ event: '777' });
+            return stream.commit(uuid());
+          })
+          .then(function () {
+            stream._commitSequence.should.equal(1);
+            done();
+          })
+          .catch(function (err) {
+            done(err);
+          });
+      });
+    });
     it('committed events should have increasing version', function (done) {
       var es = new EventStore();
       var stream;
@@ -127,11 +152,37 @@ describe('event_stream', function () {
         })
         .then(function () {
           stream.getCommittedEvents()[3].version.should.equal(3);
+          stream._version.should.equal(4);
           done();
         }).catch(function (err) {
           done(err);
         });
     });
+    it('committed events should have increasing version (writeOnly)', function (done) {
+      var es = new EventStore();
+      var stream;
+      es.openPartition('location').then(function (partition) {
+        partition.openStream('1', true)
+          .then(function (stream1) {
+            stream = stream1;
+            stream.append({ event: '123' });
+            stream.append({ event: '999' });
+            return stream.commit(uuid());
+          })
+          .then(function () {
+            stream.append({ event: '666' });
+            stream.append({ event: '777' });
+            return stream.commit(uuid());
+          })
+          .then(function () {
+            stream._version.should.equal(4);
+            done();
+          })
+          .catch(function (err) {
+            done(err);
+          });
+      });
+    });
     it('published events should have increasing version', function (done) {
       var commitCount = 0;
 
@@ -160,4 +211,4 @@ describe('event_stream', function () {
         });
     });
   });
-});
+});

package/test/persistence/inmemory.js

@@ -1,5 +1,5 @@
 var should = require('should');
-var uuid = require("node-uuid").v4;
+var uuid = require("uuid").v4;
 var Promise = require("bluebird");
 
 var Store = require('../../lib/persistence/inmemory/inmemory_persistence');