Release version 0.1.11 of npm package

fix noopLogger typo fix #49

.gitignore

@@ -33,4 +33,13 @@ node_modules
 .node_repl_history
 
 # InteliJ
-.idea
+.idea/workspace.xml
+.vscode
+
+lib/
+.eslintrc.json
+jsconfig.json
+docs/
+
+# Vagrant
+.vagrant

.idea/.name

@@ -0,0 +1 @@
+eventstore-node

.idea/codeStyleSettings.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectCodeStyleSettingsManager">
+    <option name="PER_PROJECT_SETTINGS">
+      <value>
+        <codeStyleSettings language="JavaScript">
+          <indentOptions>
+            <option name="INDENT_SIZE" value="2" />
+            <option name="CONTINUATION_INDENT_SIZE" value="2" />
+            <option name="TAB_SIZE" value="2" />
+          </indentOptions>
+        </codeStyleSettings>
+      </value>
+    </option>
+    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
+  </component>
+</project>

.idea/copyright/profiles_settings.xml

@@ -0,0 +1,3 @@
+<component name="CopyrightManager">
+  <settings default="" />
+</component>

.idea/encodings.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Encoding">
+    <file url="PROJECT" charset="UTF-8" />
+  </component>
+</project>

.idea/eventstore-node.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/test" isTestSource="true" />
+      <excludeFolder url="file://$MODULE_DIR$/docs" />
+      <excludeFolder url="file://$MODULE_DIR$/lib" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/jsLibraryMappings.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="JavaScriptLibraryMappings">
+    <includedPredefinedLibrary name="Node.js Core" />
+  </component>
+</project>

.idea/misc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="JavaScriptSettings">
+    <option name="languageLevel" value="ES5" />
+  </component>
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/eventstore-node.iml" filepath="$PROJECT_DIR$/.idea/eventstore-node.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

README.md

@@ -1,65 +1,130 @@
-# eventstore-node
+# node-eventstore-client
 A port of the EventStore .Net ClientAPI to Node.js
 
-## Dependencies
-
-- Node.js >= 0.12
-- Modules: [long](https://www.npmjs.org/package/long), [protobufjs](https://www.npmjs.org/package/protobufjs), [uuid](https://www.npmjs.org/package/uuid) (installed via `npm install`)
-
 ## Status
 
-Unstable
-
 ### Missing features:
 
 - Ssl connection
-- Cluster connection
 - Set system settings
 
-### Incomplete
+### Areas to improve
 
-- Typed errors: currently most errors are direct instance of Error, which is not practical for error handling
-- Performance: there's still some while loop in the code that could be problematic with node.js
-- Tests: tests are only covering happy path scenarios for now
+- Errors
+  - Use codes or types to differentiate between errors
+- Performance
+  - Performance hasn't been tested yet
+- Tests
+  - Can always do with more tests
 
 ## Getting started
 
-Install the client using npm
+Install using `npm install node-eventstore-client`
 
-    npm install eventstore-node
+### Dependencies
 
-Examples
+- Node.js >= 4.0
+- Modules: [long](https://www.npmjs.org/package/long), [protobufjs](https://www.npmjs.org/package/protobufjs), [uuid](https://www.npmjs.org/package/uuid) (installed via `npm install`)
 
-    TODO
+### API Documentation
 
+#### Offline
 
-## Porting .Net Task to Node.js
+The offline documentation can be found in the module folder `./node_modules/node-eventstore-client/docs`.
 
-I used Promise to replace .Net Task, so when executing an async command, i.e. appendToStream you'll have to wait for result/error like this:
+#### Online
 
-    connection
-      .appendToStream('myStream', client.expectedVersion.any, events, userCredentials)
+The online documentation can be found at [https://dev.nicdex.com/node-eventstore-client/docs/](https://dev.nicdex.com/node-eventstore-client/docs/)
+
+### Install & run an Eventstore on localhost
+
+See http://docs.geteventstore.com/introduction/3.9.0/ . 
+   
+### Example: Storing an event
+
+Save to ```app.js:```
+
+```javascript
+var esClient = require('node-eventstore-client');
+var uuid = require('uuid');
+
+var streamName = "testStream";
+/* 
+  Connecting to a single node using "tcp://localhost:1113"
+  - to connect to a cluster via dns discovery use "discover://my.host:2113"
+  - to connect to a cluster via gossip seeds use 
+  [
+    new esClient.GossipSeed({host: '192.168.1.10', port: 2113}), 
+    new esClient.GossipSeed({host: '192.168.1.11', port: 2113}), 
+    new esClient.GossipSeed({host: '192.168.1.12', port: 2113})
+  ]
+*/
+var connSettings = {};  // Use defaults
+var esConnection = esClient.createConnection(connSettings, "tcp://localhost:1113");
+esConnection.connect();
+esConnection.once('connected', function (tcpEndPoint) {
+    console.log('Connected to eventstore at ' + tcpEndPoint.host + ":" + tcpEndPoint.port);
+});
+
+var eventId = uuid.v4();
+var eventData = {
+    a : Math.random(), 
+    b: uuid.v4()
+};
+var event = esClient.createJsonEventData(eventId, eventData, null, 'testEvent');
+console.log("Appending...");
+esConnection.appendToStream(streamName, esClient.expectedVersion.any, event)
     .then(function(result) {
-        //Do something with the WriteResult here
+        console.log("Stored event:", eventId);
+        console.log("Look for it at: http://localhost:2113/web/index.html#/streams/testStream");
+        esConnection.close();
     })
     .catch(function(err) {
-        //Handle error here
+        console.log(err);
     });
+```
+
+Run:
+
+```json
+npm install uuid
+npm install node-eventstore-client
+node app.js
+```
+
+### Example: Subscribing to events
+
+```cd samples```
+
+To subscribe to all events from now on (includes example of a filter which ignores events which we aren't interested in):
+
+```node subscribe-all-events.js```
+
+To catch up on all events ever and subscribe to all new ones from now on:
+
+```node subscribe-catchup-all-events.js```
+
+To generate a test event, open a separate console and run:
+
+```node store-event.js```
 
 ## Running the tests
 
-To run the tests you will need
+To run the tests it is recommended that you use an in-memory instance of the eventstore so you don't pollute your dev instance.
 
-- To install the dependencies (`npm install`)
-- To install nodeunit (`npm install -g nodeunit`)
-- Run an instance of EventStore >= 3.3.0 (competing consumers are required for test) on localhost:1113 (Download [here](https://geteventstore.com/downloads/))
+    EventStore.ClusterNode.exe --run-projections=all --memdb
 
-To execute the tests suites simply run test with npm
+To execute the tests suites simply run
 
     npm test
 
+## Porting .Net Task to Node.js
+
+Any async commands returns a [Promise](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Promise) object in replacement of .Net Task.  
+
+
 ## License
 
-Ported code is released under the MIT license, see [LICENSE](https://github.com/nicdex/eventstore-node/blob/master/LICENSE). 
+Ported code is released under the MIT license, see [LICENSE](https://github.com/nicdex/node-eventstore-client/blob/master/LICENSE). 
  
 Original code is released under the EventStore license and can be found at https://github.com/eventstore/eventstore.

Vagrantfile

@@ -0,0 +1,87 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# All Vagrant configuration is done below. The "2" in Vagrant.configure
+# configures the configuration version (we support older styles for
+# backwards compatibility). Please don't change it unless you know what
+# you're doing.
+Vagrant.configure("2") do |config|
+  # The most common configuration options are documented and commented below.
+  # For a complete reference, please see the online documentation at
+  # https://docs.vagrantup.com.
+
+  config.vm.define "es_cluster_1" do |es_cluster_1|
+      es_cluster_1.vm.box = "ubuntu/trusty64"
+
+      es_cluster_1.vm.box_check_update = false
+
+      es_cluster_1.vm.network "private_network", ip: "192.168.33.10"
+
+      es_cluster_1.vm.provider "virtualbox" do |vb|
+        vb.memory = "512"
+      end
+
+      es_cluster_1.vm.provision "shell", inline: <<-SHELL
+        curl -s https://packagecloud.io/install/repositories/EventStore/EventStore-OSS/script.deb.sh | sudo bash
+        sudo apt install EventStore-OSS
+        sudo echo "---" > /etc/eventstore/eventstore.conf
+        sudo echo "RunProjections: None" >> /etc/eventstore/eventstore.conf
+        sudo echo "IntIp: 192.168.33.10" >> /etc/eventstore/eventstore.conf
+        sudo echo "ExtIp: 192.168.33.10" >> /etc/eventstore/eventstore.conf
+        sudo echo "ClusterSize: 3" >> /etc/eventstore/eventstore.conf
+        sudo echo "DiscoverViaDns: False" >> /etc/eventstore/eventstore.conf
+        sudo echo "GossipSeed: ['192.168.33.11:2112','192.168.33.12:2112']" >> /etc/eventstore/eventstore.conf
+        sudo service eventstore start
+      SHELL
+  end
+
+  config.vm.define "es_cluster_2" do |es_cluster_2|
+    es_cluster_2.vm.box = "ubuntu/trusty64"
+
+    es_cluster_2.vm.box_check_update = false
+
+    es_cluster_2.vm.network "private_network", ip: "192.168.33.11"
+
+    es_cluster_2.vm.provider "virtualbox" do |vb|
+      vb.memory = "512"
+    end
+
+    es_cluster_2.vm.provision "shell", inline: <<-SHELL
+      curl -s https://packagecloud.io/install/repositories/EventStore/EventStore-OSS/script.deb.sh | sudo bash
+      sudo apt install EventStore-OSS
+      sudo echo "---" > /etc/eventstore/eventstore.conf
+      sudo echo "RunProjections: None" >> /etc/eventstore/eventstore.conf
+      sudo echo "IntIp: 192.168.33.11" >> /etc/eventstore/eventstore.conf
+      sudo echo "ExtIp: 192.168.33.11" >> /etc/eventstore/eventstore.conf
+      sudo echo "ClusterSize: 3" >> /etc/eventstore/eventstore.conf
+      sudo echo "DiscoverViaDns: False" >> /etc/eventstore/eventstore.conf
+      sudo echo "GossipSeed: ['192.168.33.10:2112','192.168.33.12:2112']" >> /etc/eventstore/eventstore.conf
+      sudo service eventstore start
+    SHELL
+  end
+
+  config.vm.define "es_cluster_3" do |es_cluster_3|
+    es_cluster_3.vm.box = "ubuntu/trusty64"
+
+    es_cluster_3.vm.box_check_update = false
+
+    es_cluster_3.vm.network "private_network", ip: "192.168.33.12"
+
+    es_cluster_3.vm.provider "virtualbox" do |vb|
+      vb.memory = "512"
+    end
+
+    es_cluster_3.vm.provision "shell", inline: <<-SHELL
+      curl -s https://packagecloud.io/install/repositories/EventStore/EventStore-OSS/script.deb.sh | sudo bash
+      sudo apt install EventStore-OSS
+      sudo echo "---" > /etc/eventstore/eventstore.conf
+      sudo echo "RunProjections: None" >> /etc/eventstore/eventstore.conf
+      sudo echo "IntIp: 192.168.33.12" >> /etc/eventstore/eventstore.conf
+      sudo echo "ExtIp: 192.168.33.12" >> /etc/eventstore/eventstore.conf
+      sudo echo "ClusterSize: 3" >> /etc/eventstore/eventstore.conf
+      sudo echo "DiscoverViaDns: False" >> /etc/eventstore/eventstore.conf
+      sudo echo "GossipSeed: ['192.168.33.10:2112','192.168.33.11:2112']" >> /etc/eventstore/eventstore.conf
+      sudo service eventstore start
+    SHELL
+  end
+end

index.d.ts

@@ -0,0 +1,368 @@
+/// <reference types="node" />
+/// <reference types="Long" />
+
+export class Position {
+    constructor(commitPosition: number|Long, preparePosition: number|Long);
+    readonly commitPosition: Long;
+    readonly preparePosition: Long;
+}
+
+// Expose classes
+
+export class UserCredentials {
+    constructor(username: string, password: string);
+    readonly username: string;
+    readonly password: string;
+}
+
+export class PersistentSubscriptionSettings {
+    constructor(resolveLinkTos: boolean, startFrom: number, extraStatistics: boolean, messageTimeout: number,
+                maxRetryCount: number, liveBufferSize: number, readBatchSize: number, historyBufferSize: number,
+                checkPointAfter: number, minCheckPointCount: number, maxCheckPointCount: number,
+                maxSubscriberCount: number, namedConsumerStrategy: string)
+    static create(): PersistentSubscriptionSettings;
+}
+
+export namespace SystemConsumerStrategies {
+    const DispatchToSingle: string;
+    const RoundRobin: string;
+    const Pinned: string;
+}
+
+export class GossipSeed {
+    constructor(endPoint: TcpEndPoint, hostHeader: string);
+    readonly endPoint: TcpEndPoint;
+    readonly hostHeader: string;
+}
+
+// Expose errors
+export class WrongExpectedVersionError {
+    readonly name: string;
+    readonly action: string;
+    readonly message: string;
+    readonly stream?: string;
+    readonly expectedVersion?: number;
+    readonly transactionId?: Long;
+}
+
+export class StreamDeletedError {
+    readonly message: string;
+    readonly stream?: string;
+    readonly transactionId?: Long;
+}
+
+export class AccessDeniedError {
+    readonly name: string;
+    readonly action: string;
+    readonly message: string;
+    readonly stream?: string;
+    readonly transactionId?: Long;
+}
+
+// Expose enums/constants
+
+export namespace expectedVersion {
+    const any: number;
+    const noStream: number;
+    const emptyStream: number;
+}
+
+export namespace positions {
+    const start: Position;
+    const end: Position;
+}
+
+// systemMetadata
+// eventReadStatus
+// sliceReadStatus
+
+// Expose loggers
+
+export interface Logger {
+    debug(fmt: string, ...args: any[]): void;
+    info(fmt: string, ...args: any[]): void;
+    error(fmt: string, ...args: any[]): void;
+}
+
+export class NoopLogger implements Logger {
+    constructor()
+    debug(fmt: string, ...args: any[]): void;
+    info(fmt: string, ...args: any[]): void;
+    error(fmt: string, ...args: any[]): void;
+}
+
+export class FileLogger implements Logger {
+    constructor(filePath: string, append: boolean);
+    debug(fmt: string, ...args: any[]): void;
+    info(fmt: string, ...args: any[]): void;
+    error(fmt: string, ...args: any[]): void;
+}
+
+//
+
+export interface WriteResult {
+    readonly nextExpectedVersion: number;
+    readonly logPosition: Position;
+}
+
+export interface RecordedEvent {
+    readonly eventStreamId: string;
+    readonly eventId: string;
+    readonly eventNumber: number;
+    readonly eventType: string;
+    readonly createdEpoch: number;
+    readonly data?: Buffer;
+    readonly metadata?: Buffer;
+    readonly isJson: boolean;
+}
+
+export interface ResolvedEvent {
+    readonly event?: RecordedEvent;
+    readonly link?: RecordedEvent;
+    readonly originalEvent?: RecordedEvent;
+    readonly isResolved: boolean;
+    readonly originalPosition?: Position;
+    readonly originalStreamId: string;
+    readonly originalEventNumber: number;
+}
+
+export interface StreamEventsSlice {
+    readonly status: string;        // TODO: enum
+    readonly stream: string;
+    readonly fromEventNumber: number;
+    readonly readDirection: string; // TODO: enum
+    readonly events: ResolvedEvent[];
+    readonly nextEventNumber: number;
+    readonly lastEventNumber: number;
+    readonly isEndOfStream: boolean;
+}
+
+export interface AllEventsSlice {
+    readonly readDirection: string; // TODO enum
+    readonly fromPosition: Position;
+    readonly nextPosition: Position;
+    readonly events: ResolvedEvent[];
+    readonly isEndOfStream: boolean;
+}
+
+export interface DeleteResult {
+    readonly logPosition: Position;
+}
+
+export interface EventStoreTransaction {
+    readonly transactionId: number;
+    commit(): Promise<WriteResult>;
+    write(eventOrEvents: EventData | EventData[]): Promise<void>;
+    rollback(): void;
+}
+
+export interface EventReadResult {
+    readonly status: string;
+    readonly stream: string;
+    readonly eventNumber: number;
+    readonly event: ResolvedEvent | null;
+}
+
+export interface EventStoreSubscription {
+    readonly isSubscribedToAll: boolean;
+    readonly streamId: string;
+    readonly lastCommitPosition: Position;
+    readonly lastEventNumber: number;
+
+    close(): void;
+    unsubscribe(): void;
+}
+
+export interface EventStoreCatchUpSubscription {
+    stop(): void;
+}
+
+export enum PersistentSubscriptionNakEventAction {
+    Unknown = 0,
+    Park = 1,
+    Retry = 2,
+    Skip = 3,
+    Stop = 4
+}
+
+export interface EventStorePersistentSubscription {
+    acknowledge(events: ResolvedEvent | ResolvedEvent[]): void;
+    fail(events: ResolvedEvent | ResolvedEvent[], action: PersistentSubscriptionNakEventAction, reason: string): void;
+    stop(): void;
+}
+
+export interface RawStreamMetadataResult {
+    readonly stream: string;
+    readonly isStreamDeleted: boolean;
+    readonly metastreamVersion: number;
+    readonly streamMetadata: any;
+}
+
+export interface PersistentSubscriptionCreateResult {
+    readonly status: string;
+}
+
+export interface PersistentSubscriptionUpdateResult {
+    readonly status: string;
+}
+
+export interface PersistentSubscriptionDeleteResult {
+    readonly status: string;
+}
+
+// Callbacks
+export interface EventAppearedCallback<TSubscription> {
+    (subscription: TSubscription, event: ResolvedEvent): void | Promise<void>;
+}
+
+export interface LiveProcessingStartedCallback {
+    (subscription: EventStoreCatchUpSubscription): void;
+}
+
+export interface SubscriptionDroppedCallback<TSubscription> {
+    (subscription: TSubscription, reason: string, error?: Error): void;
+}
+
+export interface TcpEndPoint {
+    port: number;
+    host: string;
+}
+
+export interface HeartbeatInfo {
+    connectionId: string;
+    remoteEndPoint: TcpEndPoint;
+    requestSentAt: number;
+    requestPkgNumber: number;
+    responseReceivedAt: number;
+    responsePkgNumber: number;
+}
+
+export interface EventData {
+    readonly eventId: string;
+    readonly type: string;
+    readonly isJson: boolean;
+    readonly data: Buffer;
+    readonly metadata: Buffer;
+}
+
+export interface EventStoreNodeConnection {
+    connect(): Promise<void>;
+    close(): void;
+    // write actions
+    deleteStream(stream: string, expectedVersion: number, hardDelete?: boolean, userCredentials?: UserCredentials): Promise<DeleteResult>;
+    appendToStream(stream: string, expectedVersion: number, eventOrEvents: EventData | EventData[], userCredentials?: UserCredentials): Promise<WriteResult>;
+    startTransaction(stream: string, expectedVersion: number, userCredentials?: UserCredentials): Promise<EventStoreTransaction>;
+    continueTransaction(transactionId: number, userCredentials?: UserCredentials): EventStoreTransaction;
+    // read actions
+    readEvent(stream: string, eventNumber: number, resolveLinkTos?: boolean, userCredentials?: UserCredentials): Promise<EventReadResult>;
+    readStreamEventsForward(stream: string, start: number, count: number, resolveLinkTos?: boolean, userCredentials?: UserCredentials): Promise<StreamEventsSlice>;
+    readStreamEventsBackward(stream: string, start: number, count: number, resolveLinkTos?: boolean, userCredentials?: UserCredentials): Promise<StreamEventsSlice>;
+    readAllEventsForward(position: Position, maxCount: number, resolveLinkTos?: boolean, userCredentials?: UserCredentials): Promise<AllEventsSlice>;
+    readAllEventsBackward(position: Position, maxCount: number, resolveLinkTos?: boolean, userCredentials?: UserCredentials): Promise<AllEventsSlice>;
+    // subscription actions
+    subscribeToStream(stream: string, resolveLinkTos: boolean, eventAppeared: EventAppearedCallback<EventStoreSubscription>, subscriptionDropped?: SubscriptionDroppedCallback<EventStoreSubscription>, userCredentials?: UserCredentials): Promise<EventStoreSubscription>;
+    subscribeToStreamFrom(stream: string, lastCheckpoint: number | null, resolveLinkTos: boolean, eventAppeared: EventAppearedCallback<EventStoreCatchUpSubscription>, liveProcessingStarted?: LiveProcessingStartedCallback, subscriptionDropped?: SubscriptionDroppedCallback<EventStoreCatchUpSubscription>, userCredentials?: UserCredentials, readBatchSize?: number): EventStoreCatchUpSubscription;
+    subscribeToAll(resolveLinkTos: boolean, eventAppeared: EventAppearedCallback<EventStoreSubscription>, subscriptionDropped?: SubscriptionDroppedCallback<EventStoreSubscription>, userCredentials?: UserCredentials): Promise<EventStoreSubscription>;
+    subscribeToAllFrom(lastCheckpoint: Position | null, resolveLinkTos: boolean, eventAppeared: EventAppearedCallback<EventStoreCatchUpSubscription>, liveProcessingStarted?: LiveProcessingStartedCallback, subscriptionDropped?: SubscriptionDroppedCallback<EventStoreCatchUpSubscription>, userCredentials?: UserCredentials, readBatchSize?: number): EventStoreCatchUpSubscription;
+    // persistent subscriptions
+    createPersistentSubscription(stream: string, groupName: string, settings: PersistentSubscriptionSettings, userCredentials?: PersistentSubscriptionSettings): Promise<PersistentSubscriptionCreateResult>;
+    updatePersistentSubscription(stream: string, groupName: string, settings: PersistentSubscriptionSettings, userCredentials?: PersistentSubscriptionSettings): Promise<PersistentSubscriptionUpdateResult>;
+    deletePersistentSubscription(stream: string, groupName: string, userCredentials?: PersistentSubscriptionSettings): Promise<PersistentSubscriptionDeleteResult>
+    connectToPersistentSubscription(stream: string, groupName: string, eventAppeared: EventAppearedCallback<EventStorePersistentSubscription>, subscriptionDropped?: SubscriptionDroppedCallback<EventStorePersistentSubscription>, userCredentials?: UserCredentials, bufferSize?: number, autoAck?: boolean): Promise<EventStorePersistentSubscription>;
+    // metadata actions
+    setStreamMetadataRaw(stream: string, expectedMetastreamVersion: number, metadata: any, userCredentials?: UserCredentials): Promise<WriteResult>;
+    getStreamMetadataRaw(stream: string, userCredentials?: UserCredentials): Promise<RawStreamMetadataResult>;
+
+    on(event: "connected" | "disconnected" | "reconnecting" | "closed" | "error" | "heartbeatInfo", listener: (arg: Error | string | TcpEndPoint | HeartbeatInfo) => void): this;
+    once(event: "connected" | "disconnected" | "reconnecting" | "closed" | "error" | "heartbeatInfo", listener: (arg: Error | string | TcpEndPoint | HeartbeatInfo) => void): this;
+}
+
+// Expose helper functions
+
+export interface ConnectionSettings {
+    log?: Logger,
+    verboseLogging?: boolean,
+
+    maxQueueSize?: number,
+    maxConcurrentItems?: number,
+    maxRetries?: number,
+    maxReconnections?: number,
+
+    requireMaster?: boolean,
+
+    reconnectionDelay?: number,
+    operationTimeout?: number,
+    operationTimeoutCheckPeriod?: number,
+
+    defaultUserCredentials?: UserCredentials,
+    useSslConnection?: boolean,
+    targetHost?: TcpEndPoint,
+    validateServer?: boolean,
+
+    failOnNoServerResponse?: boolean,
+    heartbeatInterval?: number,
+    heartbeatTimeout?: number,
+    clientConnectionTimeout?: number,
+
+    // Cluster Settings
+    clusterDns?: string,
+    maxDiscoverAttempts?: number,
+    externalGossipPort?: number,
+    gossipTimeout?: number
+}
+
+export function createConnection(settings: ConnectionSettings, endPointOrGossipSeed: string | TcpEndPoint | GossipSeed[], connectionName?: string): EventStoreNodeConnection;
+export function createJsonEventData(eventId: string, event: any, metadata?: any, type?: string): EventData;
+export function createEventData(eventId: string, type: string, isJson: boolean, data: Buffer, metadata?: Buffer): EventData;
+
+// Projections
+export interface ProjectionDetails {
+    coreProcessingTime: number,
+    version: number,
+    epoch: number,
+    effectiveName: string,
+    writesInProgress: number,
+    readsInProgress: number,
+    partitionsCached: number,
+    status: string,
+    stateReason: string,
+    name: string,
+    mode: string,
+    position: string,
+    progress: number,
+    lastCheckpoint: string,
+    eventsProcessedAfterRestart: number,
+    statusUrl: string,
+    stateUrl: string,
+    resultUrl: string,
+    queryUrl: string,
+    enableCommandUrl: string,
+    disableCommandUrl: string,
+    checkpointStatus: string,
+    bufferedEvents: number,
+    writePendingEventsBeforeCheckpoint: number,
+    writePendingEventsAfterCheckpoint: number
+}
+
+export class ProjectionsManager {
+    constructor(log: Logger, httpEndPoint: string, operationTimeout: number);
+    enable(name: string, userCredentials: UserCredentials): Promise<void>;
+    disable(name: string, userCredentials: UserCredentials): Promise<void>;
+    abort(name: string, userCredentials: UserCredentials): Promise<void>;
+    createOneTime(query: string, userCredentials: UserCredentials): Promise<void>;
+    createTransient(name: string, query: string, userCredentials: UserCredentials): Promise<void>;
+    createContinuous(name: string, query: string, trackEmittedStreams: boolean, userCredentials: UserCredentials): Promise<void>;
+    listAll(userCredentials: UserCredentials): Promise<ProjectionDetails[]>;
+    listOneTime(userCredentials: UserCredentials): Promise<ProjectionDetails[]>;
+    listContinuous(userCredentials: UserCredentials): Promise<ProjectionDetails[]>;
+    getStatus(name: string, userCredentials: UserCredentials): Promise<string>;
+    getState(name: string, userCredentials: UserCredentials): Promise<string>;
+    getPartitionState(name: string, partitionId: string, userCredentials: UserCredentials): Promise<string>;
+    getResult(name: string, userCredentials: UserCredentials): Promise<string>;
+    getPartitionResult(name: string, partitionId: string, userCredentials: UserCredentials): Promise<string>;
+    getStatistics(name: string, userCredentials: UserCredentials): Promise<string>;
+    getQuery(name: string, userCredentials: UserCredentials): Promise<string>;
+    getState(name: string, userCredentials: UserCredentials): Promise<string>;
+    updateQuery(name: string, query: string, userCredentials: UserCredentials): Promise<void>;
+    deleteQuery(name: string, deleteEmittedStreams: boolean, userCredentials: UserCredentials): Promise<void>;
+}

index.js

@@ -1,11 +1,6 @@
 /**
- * eventstore-node A port of EventStore .Net ClientAPI to Node.js
+ * node-eventstore-client A port of EventStore .Net ClientAPI to Node.js
  * see README.md for more details
  * see LICENSE for license info
  */
-/**
- * TODO:
- * library is heavy on number of files so it could have negative impact on load time
- * we need a compiled (single file) version of the library
- */
 module.exports = require('./lib/dist.js');

package.json

@@ -1,14 +1,37 @@
 {
-  "name": "eventstore-node",
-  "version": "0.0.2",
+  "name": "node-eventstore-client",
+  "version": "0.1.11",
   "description": "A port of the EventStore .Net ClientAPI to Node.js",
   "main": "index.js",
+  "types": "index.d.ts",
+  "engines": {
+    "node": ">=4.0"
+  },
+  "engineStrict": true,
   "scripts": {
-    "test": "nodeunit"
+    "clean": "rm lib/dist.js",
+    "build": "webpack",
+    "pretest": "npm run build",
+    "test": "nodeunit",
+    "test-debug": "TESTS_VERBOSE_LOGGING=1 nodeunit",
+    "prepublish": "npm run build && npm run gendocs",
+    "gendocs": "rm -rf docs && jsdoc src -r -d docs"
+  },
+  "files": [
+    "lib",
+    "docs",
+    "src",
+    "index.js",
+    "index.d.ts"
+  ],
+  "directories": {
+    "lib": "lib",
+    "doc": "docs",
+    "example": "samples"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/nicdex/eventstore-node.git"
+    "url": "git+https://github.com/nicdex/node-eventstore-client.git"
   },
   "keywords": [
     "eventstore",
@@ -18,16 +41,19 @@
   "author": "Nicolas Dextraze",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/nicdex/eventstore-node/issues"
+    "url": "https://github.com/nicdex/node-eventstore-client/issues"
   },
-  "homepage": "https://github.com/nicdex/eventstore-node#readme",
+  "homepage": "https://github.com/nicdex/node-eventstore-client#readme",
   "dependencies": {
-    "long": "^3.0.3",
-    "protobufjs": "^5.0.1",
-    "uuid": "^2.0.1"
+    "@types/long": "^3.0.31",
+    "@types/node": "^6.0.47",
+    "long": "^3.2",
+    "protobufjs": "^6.7.3",
+    "uuid": "^3.0.1"
   },
-  "engines": {
-    "node": ">=0.12"
-  },
-  "engineStrict": true
+  "devDependencies": {
+    "jsdoc": "^3.5.3",
+    "nodeunit": "^0.11.1",
+    "webpack": "^3.3.0"
+  }
 }

samples/simple.js

@@ -0,0 +1,55 @@
+const client = require('../src/client')
+// const client = require("node-eventstore-client")
+const uuid = require("uuid")
+
+const settings = {
+  verboseLogging: true,
+  log: new client.FileLogger("./simple-verbose.log")
+}
+/*
+// connecting to Cluster using hard-coded gossip seeds
+const gossipSeeds = [
+  new client.GossipSeed({host: "192.168.33.10", port: 2113}),
+  new client.GossipSeed({host: "192.168.33.11", port: 2113}),
+  new client.GossipSeed({host: "192.168.33.12", port: 2113})
+]
+const connection = client.createConnection(settings, gossipSeeds)
+*/
+/*
+// connecting to Cluster using dns discovery, note that cluster gossip over external http port not tcp port
+const connection = client.createConnection(settings, 'discover://my.dns:2113')
+*/
+const connection = client.createConnection(settings, 'tcp://localhost:1113')
+
+connection.connect().catch(err => console.log(err))
+
+connection.on("connected", tcpEndPoint => {
+  console.log(`connected to endPoint ${tcpEndPoint.host}:${tcpEndPoint.port}`)
+
+  setInterval(() => {
+    connection.appendToStream(
+      `test-${uuid.v4()}`,
+      client.expectedVersion.noStream,
+      [
+        client.createJsonEventData(
+          uuid.v4(),
+          { abc: 123 },
+          null,
+          "MyEvent"
+        )
+      ]
+    ).then(writeResult => console.log(writeResult))
+  }, 1000)
+})
+
+connection.on("error", error =>
+  console.log(`Error occurred on connection: ${error}`)
+)
+
+connection.on("closed", reason =>
+  console.log(`Connection closed, reason: ${reason}`)
+)
+
+process.stdin.setRawMode(true)
+process.stdin.resume()
+process.stdin.on("data", process.exit.bind(process, 0))

samples/speed-tests.js

@@ -0,0 +1,108 @@
+//NOTE: this script require node.js v8+ to run (native async/await)
+var uuid = require('uuid');
+var client = require('../src/client');
+var conn = client.createConnection({}, 'tcp://localhost:1113');
+conn.on('connected', onConnected);
+
+var batchSize = parseInt(process.argv[2], 10) || 500;
+const MB = 1024*1024;
+const adminCreds = new client.UserCredentials("admin", "changeit");
+const nbEvents = 50000;
+const events = [];
+const streams = [];
+const writeOneStream = 'testWrite-' + uuid.v4();
+for(var i = 0; i < nbEvents; i++) {
+  streams.push('testWrite-' + uuid.v4());
+  events.push(client.createJsonEventData(uuid.v4(), {a:i, b:i+1, c:i+2}, null, 'myEvent'))
+}
+conn.connect();
+
+function rssMB() {
+  return (process.memoryUsage().rss / MB).toFixed(2);
+}
+
+function reportResult(action, nbEvents, elapsedMs) {
+  console.log(action, nbEvents, 'events took', elapsedMs, 'ms, avg', (nbEvents/(elapsedMs/1000)).toFixed(2), '/s');
+  console.log('Memory usage:', rssMB(), 'MB\n');
+}
+
+async function testWriteOneStreamAnyVersion(batchSize) {
+  console.log(`Test Write One Stream Any Version (batchSize = ${batchSize})...`);
+  const start = Date.now();
+  const promises = [];
+  for(let i = 0; i < nbEvents; i += batchSize) {
+    promises.push(conn.appendToStream(writeOneStream, client.expectedVersion.any, events.slice(i, i + batchSize)))
+  }
+  await Promise.all(promises);
+  var diff = Date.now() - start;
+  reportResult("Writing", nbEvents, diff)
+}
+
+async function testWriteOneStreamWithVersion(batchSize) {
+  console.log(`Test Write One Stream With Version (batchSize = ${batchSize})...`);
+  const writeStream = 'testWrite-' + uuid.v4();
+  const start = Date.now();
+  const promises = [];
+  for(let i = 0; i < nbEvents; i += batchSize) {
+    promises.push(conn.appendToStream(writeStream, i-1, events.slice(i, i + batchSize)))
+  }
+  await Promise.all(promises);
+  var diff = Date.now() - start;
+  reportResult("Writing", nbEvents, diff)
+}
+
+async function testWriteMultipleStream() {
+  console.log('Test Write Multiple Streams...');
+  var start = Date.now();
+  var promises = [];
+  for(var i = 0; i < nbEvents; i++) {
+    promises.push(conn.appendToStream(streams[i], client.expectedVersion.emptyStream, events[i]))
+  }
+  await Promise.all(promises);
+  const diff = Date.now() - start;
+  reportResult("Writing", nbEvents, diff)
+}
+
+async function testRead(batchSize) {
+  console.log(`Test Read One Stream (batchSize = ${batchSize})...`);
+  const start = Date.now();
+  const promises = [];
+  for(let i = 0; i < nbEvents; i += batchSize) {
+    promises.push(conn.readStreamEventsForward(writeOneStream, i, batchSize, false));
+  }
+  const results = await Promise.all(promises);
+  const diff = Date.now() - start;
+  const readEvents = results.reduce((x,y) => x + y.events.length, 0);
+  reportResult("Reading", readEvents, diff)
+}
+
+async function testReadAll(batchSize) {
+  console.log(`Test Read from $all (batchSize = ${batchSize})...`);
+  const start = Date.now();
+  let pos = client.positions.start;
+  let eventsCount = 0;
+  for(;;) {
+    var result = await conn.readAllEventsForward(pos, batchSize, false, adminCreds);
+    pos = result.nextPosition;
+    eventsCount += result.events.length;
+    if (result.isEndOfStream) break;
+  }
+  const diff = Date.now() - start;
+  reportResult("Reading", eventsCount, diff)
+}
+
+async function onConnected() {
+  try {
+    await testWriteOneStreamAnyVersion(1);
+    await testWriteOneStreamAnyVersion(batchSize);
+    await testWriteOneStreamWithVersion(1);
+    await testWriteOneStreamWithVersion(batchSize);
+    await testWriteMultipleStream();
+    await testRead(1);
+    await testRead(batchSize);
+    await testReadAll(batchSize);
+    conn.close();
+  } catch (e) {
+    console.log('ERROR', e);
+  }
+}

samples/store-event.js

@@ -0,0 +1,53 @@
+const client = require('../src/client')
+// const client = require("node-eventstore-client")
+const uuid = require("uuid")
+
+const settings = {}
+const endpoint = "tcp://localhost:1113"
+const connection = client.createConnection(settings, endpoint)
+
+connection.connect().catch(err => console.log(err))
+
+connection.once("connected", tcpEndPoint => {
+  const userId = uuid.v4()
+
+  const userCreatedEvent = {
+    id: userId,
+    username: `user${uuid.v4().substring(0,6)}`,
+    password: Math.random().toString()
+  }
+
+  const eventId = uuid.v4();
+  const event = client.createJsonEventData(
+    eventId,
+    userCreatedEvent,
+    null,
+    "UserCreated"
+  )
+
+  // Every user has their own stream of events:
+  const streamName = `user-${userId}`
+
+  console.log(`Connected to eventstore at ${tcpEndPoint.host}:${tcpEndPoint.port}`)
+  console.log(`Storing event ${eventId}. Look for it at http://localhost:2113/web/index.html#/streams/user-${userId}`)
+
+  connection.appendToStream(streamName, client.expectedVersion.any, event)
+    .then(result => {
+      console.log("Event stored.")
+      process.exit(0)
+    })
+    .catch(error => {
+      console.log(error)
+      process.exit(-1)
+    })
+})
+
+connection.on("error", error => {
+  console.log(`Error occurred on connection: ${error}`)
+  process.exit(-1)
+})
+
+connection.on("closed", reason => {
+  console.log(`Connection closed, reason: ${reason}`)
+  process.exit(-1)
+})

samples/subscribe-all-events.js

@@ -0,0 +1,56 @@
+// Subscribe to all new events on the $all stream. Filter out any which aren"t about "user" aggregates.
+
+const client = require('../src/client')
+// const client = require("node-eventstore-client")
+
+const resolveLinkTos = false
+
+const belongsToAUserAggregate = event =>
+  event.originalEvent.eventStreamId.startsWith("user-")
+
+const eventAppeared = (subscription, event) => {
+  if (belongsToAUserAggregate(event)) {
+    const aggregateId = event.originalEvent.eventStreamId
+    const eventId = event.originalEvent.eventId
+    const eventType = event.originalEvent.eventType
+    console.log(aggregateId, eventType, eventId)
+    console.log(event.originalEvent.data.toString())
+  }
+}
+
+const subscriptionDropped = (subscription, reason, error) =>
+  console.log(error ? error : "Subscription dropped.")
+
+const credentials = new client.UserCredentials("admin", "changeit")
+
+const settings = {}
+const endpoint = "tcp://localhost:1113"
+const connection = client.createConnection(settings, endpoint)
+
+connection.connect().catch(err => console.log(err))
+
+connection.on('heartbeatInfo', heartbeatInfo => {
+  console.log('Connected to endpoint', heartbeatInfo.remoteEndPoint)
+  console.log('Heartbeat latency', heartbeatInfo.responseReceivedAt - heartbeatInfo.requestSentAt)
+})
+
+connection.once("connected", tcpEndPoint => {
+  console.log(`Connected to eventstore at ${tcpEndPoint.host}:${tcpEndPoint.port}`)
+  connection.subscribeToAll(
+    resolveLinkTos,
+    eventAppeared,
+    subscriptionDropped,
+    credentials
+  ).then(subscription => {
+    console.log(`subscription.isSubscribedToAll: ${subscription.isSubscribedToAll}`),
+    console.log("(To generate a test event, try running 'node store-event.js' in a separate console.)")
+  })
+})
+
+connection.on("error", error =>
+  console.log(`Error occurred on connection: ${error}`)
+)
+
+connection.on("closed", reason =>
+  console.log(`Connection closed, reason: ${reason}`)
+)

samples/subscribe-catchup-all-events.js

@@ -0,0 +1,49 @@
+// Subscribe to all events on the $all stream. Catch up from the beginning, then listen for any new events as they occur.
+// This could be used for subscribers which populate read models.
+
+const client = require('../src/client')
+// const client = require("node-eventstore-client")
+
+const eventAppeared = (stream, event) =>
+  console.log(
+    event.originalEvent.eventStreamId,
+    event.originalEvent.eventId,
+    event.originalEvent.eventType
+  )
+
+const liveProcessingStarted = () => {
+  console.log("Caught up with previously stored events. Listening for new events.")
+  console.log("(To generate a test event, try running 'node store-event.js' in a separate console.)")
+}
+
+const subscriptionDropped = (subscription, reason, error) =>
+  console.log(error ? error : "Subscription dropped.")
+
+const credentials = new client.UserCredentials("admin", "changeit")
+
+const settings = {}
+const endpoint = "tcp://localhost:1113"
+const connection = client.createConnection(settings, endpoint)
+
+connection.connect().catch(err => console.log(err))
+
+connection.once("connected", tcpEndPoint => {
+  const subscription = connection.subscribeToAllFrom(
+    null,
+    true,
+    eventAppeared,
+    liveProcessingStarted,
+    subscriptionDropped,
+    credentials
+  )
+  console.log(`Connected to eventstore at ${tcpEndPoint.host}:${tcpEndPoint.port}`)
+  console.log(`subscription.isSubscribedToAll: ${subscription.isSubscribedToAll}`)
+})
+
+connection.on("error", err =>
+  console.log(`Error occurred on connection: ${err}`)
+)
+
+connection.on("closed", reason =>
+  console.log(`Connection closed, reason: ${reason}`)
+)

src/client.js

@@ -6,19 +6,23 @@ const expectedVersion = {
   noStream: -1,
   emptyStream: -1
 };
+Object.freeze(expectedVersion);
 const positions = {
   start: new results.Position(0, 0),
   end: new results.Position(-1, -1)
 };
+Object.freeze(positions);
 
 /**
- * @param {string} eventId
- * @param {object} event
- * @param {object} [metadata]
- * @param {string} [type]
+ * Create an EventData object from JavaScript event/metadata that will be serialized as json
+ * @public
+ * @param {string} eventId    Event UUID
+ * @param {object} event      Event object
+ * @param {object} [metadata] Event metadata
+ * @param {string} [type]     Event type
  * @returns {EventData}
  */
-function jsonEventDataFactory(eventId, event, metadata, type) {
+function createJsonEventData(eventId, event, metadata, type) {
   if (!event || typeof event !== 'object') throw new TypeError("data must be an object.");
 
   var eventBuf = new Buffer(JSON.stringify(event));
@@ -27,34 +31,42 @@ function jsonEventDataFactory(eventId, event, metadata, type) {
 }
 
 /**
- * @param {string} eventId
- * @param {string} type
- * @param {boolean} isJson
- * @param {Buffer} data
- * @param {Buffer} [metadata]
+ * Create an EventData object from event/metadata buffer(s)
+ * @public
+ * @param {string} eventId    Event UUID
+ * @param {string} type       Event type
+ * @param {boolean} isJson    is buffer(s) content json
+ * @param {Buffer} data       Data buffer
+ * @param {Buffer} [metadata] Metadata buffer
  * @returns {EventData}
  */
-function eventDataFactory(eventId, type, isJson, data, metadata) {
+function createEventData(eventId, type, isJson, data, metadata) {
   return new EventData(eventId, type, isJson, data, metadata);
 }
 
-// Exporting classes
-module.exports.EventStoreConnection = require('./eventStoreConnection');
+// Expose classes
+module.exports.Position = results.Position;
 module.exports.UserCredentials = require('./systemData/userCredentials');
-module.exports.EventData = EventData;
 module.exports.PersistentSubscriptionSettings = require('./persistentSubscriptionSettings');
 module.exports.SystemConsumerStrategies = require('./systemConsumerStrategies');
-// Exporting errors
+module.exports.GossipSeed = require('./gossipSeed');
+module.exports.EventStoreConnection = require('./eventStoreConnection');
+module.exports.ProjectionsManager = require('./projections/projectionsManager');
+// Expose errors
 module.exports.WrongExpectedVersionError = require('./errors/wrongExpectedVersionError');
 module.exports.StreamDeletedError = require('./errors/streamDeletedError');
 module.exports.AccessDeniedError = require('./errors/accessDeniedError');
-// Exporting enums/constants
+module.exports.ProjectionCommandFailedError = require('./errors/projectionCommandFailedError');
+// Expose enums/constants
 module.exports.expectedVersion = expectedVersion;
 module.exports.positions = positions;
 module.exports.systemMetadata = require('./common/systemMetadata');
 module.exports.eventReadStatus = results.EventReadStatus;
 module.exports.sliceReadStatus = require('./sliceReadStatus');
-// Helper functions
-module.exports.createConnection = module.exports.EventStoreConnection.create;
-module.exports.createEventData = eventDataFactory;
-module.exports.createJsonEventData = jsonEventDataFactory;
+// Expose loggers
+module.exports.NoopLogger = require('./common/log/noopLogger');
+module.exports.FileLogger = require('./common/log/fileLogger');
+// Expose Helper functions
+module.exports.createConnection = require('./eventStoreConnection').create;
+module.exports.createJsonEventData = createJsonEventData;
+module.exports.createEventData = createEventData;

src/clientOperations/appendToStreamOperation.js

@@ -1,5 +1,5 @@
 var util = require('util');
-var uuid = require('uuid');
+var guidParse = require('../common/guid-parse');
 
 var TcpCommand = require('../systemData/tcpCommand');
 var InspectionDecision = require('../systemData/inspectionDecision');
@@ -26,17 +26,18 @@ util.inherits(AppendToStreamOperation, OperationBase);
 
 AppendToStreamOperation.prototype._createRequestDto = function() {
   var dtos = this._events.map(function(ev) {
-    var eventId = new Buffer(uuid.parse(ev.eventId));
-    return new ClientMessage.NewEvent({
-      event_id: eventId, event_type: ev.type,
-      data_content_type: ev.isJson ? 1 : 0, metadata_content_type: 0,
-      data: ev.data, metadata: ev.metadata});
+    var eventId = guidParse.parse(ev.eventId);
+    return {
+      eventId: eventId, eventType: ev.type,
+      dataContentType: ev.isJson ? 1 : 0, metadataContentType: 0,
+      data: ev.data, metadata: ev.metadata
+    };
   });
   return new ClientMessage.WriteEvents({
-    event_stream_id: this._stream,
-    expected_version: this._expectedVersion,
+    eventStreamId: this._stream,
+    expectedVersion: this._expectedVersion,
     events: dtos,
-    require_master: this._requireMaster});
+    requireMaster: this._requireMaster});
 };
 
 AppendToStreamOperation.prototype._inspectResponse = function(response) {
@@ -72,7 +73,7 @@ AppendToStreamOperation.prototype._inspectResponse = function(response) {
 };
 
 AppendToStreamOperation.prototype._transformResponse = function(response) {
-  return new WriteResult(response.last_event_number, new Position(response.prepare_position || -1, response.commit_position || -1));
+  return new WriteResult(response.lastEventNumber, new Position(response.preparePosition || -1, response.commitPosition || -1));
 };
 
 AppendToStreamOperation.prototype.toString = function() {

src/clientOperations/commitTransactionOperation.js

@@ -6,6 +6,9 @@ var InspectionDecision = require('../systemData/inspectionDecision');
 var InspectionResult = require('./../systemData/inspectionResult');
 var ClientMessage = require('../messages/clientMessage');
 var results = require('../results');
+var WrongExpectedVersionError = require('../errors/wrongExpectedVersionError');
+var StreamDeletedError = require('../errors/streamDeletedError');
+var AccessDeniedError = require('../errors/accessDeniedError');
 
 var OperationBase = require('../clientOperations/operationBase');
 
@@ -20,7 +23,10 @@ function CommitTransactionOperation(log, cb, requireMaster, transactionId, userC
 util.inherits(CommitTransactionOperation, OperationBase);
 
 CommitTransactionOperation.prototype._createRequestDto = function() {
-  return new ClientMessage.TransactionCommit(this._transactionId, this._requireMaster);
+  return new ClientMessage.TransactionCommit({
+    transactionId: this._transactionId,
+    requireMaster: this._requireMaster
+  });
 };
 
 CommitTransactionOperation.prototype._inspectResponse = function(response) {
@@ -36,17 +42,16 @@ CommitTransactionOperation.prototype._inspectResponse = function(response) {
     case ClientMessage.OperationResult.ForwardTimeout:
       return new InspectionResult(InspectionDecision.Retry, "ForwardTimeout");
     case ClientMessage.OperationResult.WrongExpectedVersion:
-      var err = util.format("Commit transaction failed due to WrongExpectedVersion. TransactionID: %d.", this._transactionId);
-      this.fail(new Error(err));
+      this.fail(new WrongExpectedVersionError("Commit", this._transactionId));
       return new InspectionResult(InspectionDecision.EndOperation, "WrongExpectedVersion");
     case ClientMessage.OperationResult.StreamDeleted:
-      this.fail(new Error("Stream deleted."));
+      this.fail(new StreamDeletedError(this._transactionId));
       return new InspectionResult(InspectionDecision.EndOperation, "StreamDeleted");
     case ClientMessage.OperationResult.InvalidTransaction:
       this.fail(new Error("Invalid transaction."));
       return new InspectionResult(InspectionDecision.EndOperation, "InvalidTransaction");
     case ClientMessage.OperationResult.AccessDenied:
-      this.fail(new Error("Write access denied."));
+      this.fail(new AccessDeniedError("Write", this._transactionId));
       return new InspectionResult(InspectionDecision.EndOperation, "AccessDenied");
     default:
       throw new Error(util.format("Unexpected OperationResult: %s.", response.result));
@@ -54,8 +59,8 @@ CommitTransactionOperation.prototype._inspectResponse = function(response) {
 };
 
 CommitTransactionOperation.prototype._transformResponse = function(response) {
-  var logPosition = new results.Position(response.prepare_position || -1, response.commit_position || -1);
-  return new results.WriteResult(response.last_event_number, logPosition);
+  var logPosition = new results.Position(response.preparePosition || -1, response.commitPosition || -1);
+  return new results.WriteResult(response.lastEventNumber, logPosition);
 };
 
 CommitTransactionOperation.prototype.toString = function() {

src/clientOperations/connectToPersistentSubscriptionOperation.js

@@ -1,5 +1,5 @@
 var util = require('util');
-var uuid = require('uuid');
+var guidParse = require('../common/guid-parse');
 
 var SubscriptionOperation = require('./subscriptionOperation');
 var ClientMessage = require('../messages/clientMessage');
@@ -27,48 +27,52 @@ function ConnectToPersistentSubscriptionOperation(
 util.inherits(ConnectToPersistentSubscriptionOperation, SubscriptionOperation);
 
 ConnectToPersistentSubscriptionOperation.prototype._createSubscriptionPackage = function() {
-  var dto = new ClientMessage.ConnectToPersistentSubscription(this._groupName, this._streamId, this._bufferSize);
+  var dto = new ClientMessage.ConnectToPersistentSubscription({
+    subscriptionId: this._groupName,
+    eventStreamId: this._streamId,
+    allowedInFlightMessages: this._bufferSize
+  });
   return new TcpPackage(TcpCommand.ConnectToPersistentSubscription,
       this._userCredentials !== null ? TcpFlags.Authenticated : TcpFlags.None,
       this._correlationId,
       this._userCredentials !== null ? this._userCredentials.username : null,
       this._userCredentials !== null ? this._userCredentials.password : null,
-      createBufferSegment(dto.toBuffer()));
+      createBufferSegment(ClientMessage.ConnectToPersistentSubscription.encode(dto).finish()));
 };
 
 ConnectToPersistentSubscriptionOperation.prototype._inspectPackage = function(pkg) {
-  if (pkg.command == TcpCommand.PersistentSubscriptionConfirmation)
+  if (pkg.command === TcpCommand.PersistentSubscriptionConfirmation)
   {
     var dto = ClientMessage.PersistentSubscriptionConfirmation.decode(pkg.data.toBuffer());
-    this._confirmSubscription(dto.last_commit_position, dto.last_event_number);
-    this._subscriptionId = dto.subscription_id;
+    this._confirmSubscription(dto.lastCommitPosition, dto.lastEventNumber);
+    this._subscriptionId = dto.subscriptionId;
     return new InspectionResult(InspectionDecision.Subscribed, "SubscriptionConfirmation");
   }
-  if (pkg.command == TcpCommand.PersistentSubscriptionStreamEventAppeared)
+  if (pkg.command === TcpCommand.PersistentSubscriptionStreamEventAppeared)
   {
     var dto = ClientMessage.PersistentSubscriptionStreamEventAppeared.decode(pkg.data.toBuffer());
     this._onEventAppeared(new results.ResolvedEvent(dto.event));
     return new InspectionResult(InspectionDecision.DoNothing, "StreamEventAppeared");
   }
-  if (pkg.command == TcpCommand.SubscriptionDropped)
+  if (pkg.command === TcpCommand.SubscriptionDropped)
   {
     var dto = ClientMessage.SubscriptionDropped.decode(pkg.data.toBuffer());
-    if (dto.reason == ClientMessage.SubscriptionDropped.SubscriptionDropReason.AccessDenied)
+    if (dto.reason === ClientMessage.SubscriptionDropped.SubscriptionDropReason.AccessDenied)
     {
       this.dropSubscription(SubscriptionDropReason.AccessDenied, new Error("You do not have access to the stream."));
       return new InspectionResult(InspectionDecision.EndOperation, "SubscriptionDropped");
     }
-    if (dto.reason == ClientMessage.SubscriptionDropped.SubscriptionDropReason.NotFound)
+    if (dto.reason === ClientMessage.SubscriptionDropped.SubscriptionDropReason.NotFound)
     {
       this.dropSubscription(SubscriptionDropReason.NotFound, new Error("Subscription not found"));
       return new InspectionResult(InspectionDecision.EndOperation, "SubscriptionDropped");
     }
-    if (dto.reason == ClientMessage.SubscriptionDropped.SubscriptionDropReason.PersistentSubscriptionDeleted)
+    if (dto.reason === ClientMessage.SubscriptionDropped.SubscriptionDropReason.PersistentSubscriptionDeleted)
     {
       this.dropSubscription(SubscriptionDropReason.PersistentSubscriptionDeleted, new Error("Persistent subscription deleted."));
       return new InspectionResult(InspectionDecision.EndOperation, "SubscriptionDropped");
     }
-    if (dto.reason == ClientMessage.SubscriptionDropped.SubscriptionDropReason.SubscriberMaxCountReached)
+    if (dto.reason === ClientMessage.SubscriptionDropped.SubscriptionDropReason.SubscriberMaxCountReached)
     {
       this.dropSubscription(SubscriptionDropReason.MaxSubscribersReached, new Error("Maximum subscribers reached."));
       return new InspectionResult(InspectionDecision.EndOperation, "SubscriptionDropped");
@@ -86,9 +90,9 @@ ConnectToPersistentSubscriptionOperation.prototype._createSubscriptionObject = f
 ConnectToPersistentSubscriptionOperation.prototype.notifyEventsProcessed = function(processedEvents) {
   ensure.notNull(processedEvents, "processedEvents");
   var dto = new ClientMessage.PersistentSubscriptionAckEvents({
-    subscription_id: this._subscriptionId,
-    processed_event_ids: processedEvents.map(function (x) {
-      return new Buffer(uuid.parse(x));
+    subscriptionId: this._subscriptionId,
+    processedEventIds: processedEvents.map(function (x) {
+      return guidParse.parse(x);
     })
   });
 
@@ -97,25 +101,26 @@ ConnectToPersistentSubscriptionOperation.prototype.notifyEventsProcessed = funct
       this._correlationId,
       this._userCredentials !== null ? this._userCredentials.username : null,
       this._userCredentials !== null ? this._userCredentials.password : null,
-      createBufferSegment(dto.encode().toBuffer()));
+      createBufferSegment(ClientMessage.PersistentSubscriptionAckEvents.encode(dto).finish()));
   this._enqueueSend(pkg);
 };
 
 ConnectToPersistentSubscriptionOperation.prototype.notifyEventsFailed = function(processedEvents, action, reason) {
   ensure.notNull(processedEvents, "processedEvents");
   ensure.notNull(reason, "reason");
-  var dto = new ClientMessage.PersistentSubscriptionNakEvents(
-      this._subscriptionId,
-      processedEvents.map(function(x) { return new Buffer(uuid.parse(x)); }),
-      reason,
-      action);
+  var dto = new ClientMessage.PersistentSubscriptionNakEvents({
+    subscriptionId: this._subscriptionId,
+    processedEventIds: processedEvents.map(function(x) { return guidParse.parse(x); }),
+    message: reason,
+    action: action
+  });
 
   var pkg = new TcpPackage(TcpCommand.PersistentSubscriptionNakEvents,
-      this._userCredentials != null ? TcpFlags.Authenticated : TcpFlags.None,
+      this._userCredentials !== null ? TcpFlags.Authenticated : TcpFlags.None,
       this._correlationId,
-      this._userCredentials != null ? this._userCredentials.username : null,
-      this._userCredentials != null ? this._userCredentials.password : null,
-      createBufferSegment(dto.toBuffer()));
+      this._userCredentials !== null ? this._userCredentials.username : null,
+      this._userCredentials !== null ? this._userCredentials.password : null,
+      createBufferSegment(ClientMessage.PersistentSubscriptionNakEvents.encode(dto).finish()));
   this._enqueueSend(pkg);
 };
 

src/clientOperations/createPersistentSubscriptionOperation.js

@@ -36,11 +36,24 @@ function CreatePersistentSubscriptionOperation(log, cb, stream, groupName, setti
 util.inherits(CreatePersistentSubscriptionOperation, OperationBase);
 
 CreatePersistentSubscriptionOperation.prototype._createRequestDto = function() {
-  return new ClientMessage.CreatePersistentSubscription(this._groupName, this._stream, this._resolveLinkTos,
-      this._startFromBeginning, this._messageTimeoutMilliseconds, this._recordStatistics, this._liveBufferSize,
-      this._readBatchSize, this._bufferSize, this._maxRetryCount,
-      this._namedConsumerStrategy == SystemConsumerStrategies.RoundRobin, this._checkPointAfter,
-      this._maxCheckPointCount, this._minCheckPointCount, this._maxSubscriberCount, this._namedConsumerStrategy);
+  return new ClientMessage.CreatePersistentSubscription({
+      subscriptionGroupName: this._groupName,
+      eventStreamId: this._stream,
+      resolveLinkTos: this._resolveLinkTos,
+      startFrom: this._startFromBeginning,
+      messageTimeoutMilliseconds: this._messageTimeoutMilliseconds,
+      recordStatistics: this._recordStatistics,
+      liveBufferSize: this._liveBufferSize,
+      readBatchSize: this._readBatchSize,
+      bufferSize: this._bufferSize,
+      maxRetryCount: this._maxRetryCount,
+      preferRoundRobin: this._namedConsumerStrategy === SystemConsumerStrategies.RoundRobin,
+      checkpointAfterTime: this._checkPointAfter,
+      checkpointMaxCount: this._maxCheckPointCount,
+      checkpointMinCount: this._minCheckPointCount,
+      subscriberMaxCount: this._maxSubscriberCount,
+      namedConsumerStrategy: this._namedConsumerStrategy
+  });
 };
 
 CreatePersistentSubscriptionOperation.prototype._inspectResponse = function(response) {

src/clientOperations/deletePersistentSubscriptionOperation.js

@@ -21,7 +21,10 @@ function DeletePersistentSubscriptionOperation(log, cb, stream, groupName, userC
 util.inherits(DeletePersistentSubscriptionOperation, OperationBase);
 
 DeletePersistentSubscriptionOperation.prototype._createRequestDto = function() {
-  return new ClientMessage.DeletePersistentSubscription(this._groupName, this._stream);
+  return new ClientMessage.DeletePersistentSubscription({
+      subscriptionGroupName: this._groupName,
+      eventStreamId: this._stream
+  });
 };
 
 DeletePersistentSubscriptionOperation.prototype._inspectResponse = function(response) {

src/clientOperations/deleteStreamOperation.js

@@ -25,7 +25,12 @@ function DeleteStreamOperation(log, cb, requireMaster, stream, expectedVersion,
 util.inherits(DeleteStreamOperation, OperationBase);
 
 DeleteStreamOperation.prototype._createRequestDto = function() {
-  return new ClientMessage.DeleteStream(this._stream, this._expectedVersion, this._requireMaster, this._hardDelete);
+  return new ClientMessage.DeleteStream({
+    eventStreamId: this._stream,
+    expectedVersion: this._expectedVersion,
+    requireMaster: this._requireMaster,
+    hardDelete: this._hardDelete
+  });
 };
 
 DeleteStreamOperation.prototype._inspectResponse = function(response) {
@@ -58,7 +63,7 @@ DeleteStreamOperation.prototype._inspectResponse = function(response) {
 };
 
 DeleteStreamOperation.prototype._transformResponse = function(response) {
-  return new results.DeleteResult(new results.Position(response.prepare_position || -1, response.commit_position || -1));
+  return new results.DeleteResult(new results.Position(response.preparePosition || -1, response.commitPosition || -1));
 };
 
 DeleteStreamOperation.prototype.toString = function() {

src/clientOperations/operationBase.js

@@ -42,7 +42,7 @@ OperationBase.prototype._succeed = function() {
   if (!this._completed) {
     this._completed = true;
 
-    if (this._response != null)
+    if (this._response)
       this._cb(null, this._transformResponse(this._response));
     else
       this._cb(new Error("No result."))
@@ -51,7 +51,7 @@ OperationBase.prototype._succeed = function() {
 
 OperationBase.prototype.createNetworkPackage = function(correlationId) {
   var dto = this._createRequestDto();
-  var buf = dto.toBuffer();
+  var buf = dto.constructor.encode(dto).finish();
   return new TcpPackage(
       this._requestCommand,
       this.userCredentials ? TcpFlags.Authenticated : TcpFlags.None,
@@ -75,7 +75,7 @@ OperationBase.prototype.inspectPackage = function(pkg) {
       case TcpCommand.NotHandled:
         return this._inspectNotHandled(pkg);
       default:
-        return this._inspectUnexpectedCommand(package, this._responseCommand);
+        return this._inspectUnexpectedCommand(pkg, this._responseCommand);
     }
   } catch(e) {
     this.fail(e);
@@ -117,10 +117,10 @@ OperationBase.prototype._inspectNotHandled = function(pkg)
       return new InspectionResult(InspectionDecision.Retry, "NotHandled - TooBusy");
 
     case ClientMessage.NotHandled.NotHandledReason.NotMaster:
-      var masterInfo = ClientMessage.NotHandled.MasterInfo.decode(message.additional_info);
-      return new new InspectionResult(InspectionDecision.Reconnect, "NotHandled - NotMaster",
-          {host: masterInfo.external_tcp_address, port: masterInfo.external_tcp_port},
-          {host: masterInfo.external_secure_tcp_address, port: masterInfo.external_secure_tcp_port});
+      var masterInfo = ClientMessage.NotHandled.MasterInfo.decode(message.additionalInfo);
+      return new InspectionResult(InspectionDecision.Reconnect, "NotHandled - NotMaster",
+          {host: masterInfo.externalTcpAddress, port: masterInfo.externalTcpPort},
+          {host: masterInfo.externalSecureTcpAddress, port: masterInfo.externalSecureTcpPort});
 
     default:
       this.log.error("Unknown NotHandledReason: %s.", message.reason);
@@ -130,7 +130,7 @@ OperationBase.prototype._inspectNotHandled = function(pkg)
 
 OperationBase.prototype._inspectUnexpectedCommand = function(pkg, expectedCommand)
 {
-  if (pkg.command == expectedCommand)
+  if (pkg.command === expectedCommand)
     throw new Error("Command shouldn't be " + TcpCommand.getName(pkg.command));
 
   this.log.error("Unexpected TcpCommand received.\n"

src/clientOperations/readAllEventsBackwardOperation.js

@@ -25,7 +25,13 @@ function ReadAllEventsBackwardOperation(
 util.inherits(ReadAllEventsBackwardOperation, OperationBase);
 
 ReadAllEventsBackwardOperation.prototype._createRequestDto = function() {
-  return new ClientMessage.ReadAllEvents(this._position.commitPosition, this._position.preparePosition, this._maxCount, this._resolveLinkTos, this._requireMaster);
+  return new ClientMessage.ReadAllEvents({
+    commitPosition: this._position.commitPosition,
+    preparePosition: this._position.preparePosition,
+    maxCount: this._maxCount,
+    resolveLinkTos: this._resolveLinkTos,
+    requireMaster: this._requireMaster
+  });
 };
 
 ReadAllEventsBackwardOperation.prototype._inspectResponse = function(response) {
@@ -48,8 +54,8 @@ ReadAllEventsBackwardOperation.prototype._inspectResponse = function(response) {
 ReadAllEventsBackwardOperation.prototype._transformResponse = function(response) {
   return new results.AllEventsSlice(
       ReadDirection.Backward,
-      new results.Position(response.commit_position, response.prepare_position),
-      new results.Position(response.next_commit_position, response.next_prepare_position),
+      new results.Position(response.commitPosition, response.preparePosition),
+      new results.Position(response.nextCommitPosition, response.nextPreparePosition),
       response.events
   )
 };

src/clientOperations/readAllEventsForwardOperation.js

@@ -25,7 +25,13 @@ function ReadAllEventsForwardOperation(
 util.inherits(ReadAllEventsForwardOperation, OperationBase);
 
 ReadAllEventsForwardOperation.prototype._createRequestDto = function() {
-  return new ClientMessage.ReadAllEvents(this._position.commitPosition, this._position.preparePosition, this._maxCount, this._resolveLinkTos, this._requireMaster);
+  return new ClientMessage.ReadAllEvents({
+      commitPosition: this._position.commitPosition,
+      preparePosition: this._position.preparePosition,
+      maxCount: this._maxCount,
+      resolveLinkTos: this._resolveLinkTos,
+      requireMaster: this._requireMaster
+  });
 };
 
 ReadAllEventsForwardOperation.prototype._inspectResponse = function(response) {
@@ -48,8 +54,8 @@ ReadAllEventsForwardOperation.prototype._inspectResponse = function(response) {
 ReadAllEventsForwardOperation.prototype._transformResponse = function(response) {
   return new results.AllEventsSlice(
       ReadDirection.Forward,
-      new results.Position(response.commit_position, response.prepare_position),
-      new results.Position(response.next_commit_position, response.next_prepare_position),
+      new results.Position(response.commitPosition, response.preparePosition),
+      new results.Position(response.nextCommitPosition, response.nextPreparePosition),
       response.events
   )
 };

src/clientOperations/readEventOperation.js

@@ -21,7 +21,12 @@ function ReadEventOperation(log, cb, stream, eventNumber, resolveLinkTos, requir
 util.inherits(ReadEventOperation, OperationBase);
 
 ReadEventOperation.prototype._createRequestDto = function() {
-  return new ClientMessage.ReadEvent(this._stream, this._eventNumber, this._resolveLinkTos, this._requireMaster);
+  return new ClientMessage.ReadEvent({
+      eventStreamId: this._stream,
+      eventNumber: this._eventNumber,
+      resolveLinkTos: this._resolveLinkTos,
+      requireMaster: this._requireMaster
+  });
 };
 
 ReadEventOperation.prototype._inspectResponse = function(response) {

src/clientOperations/readStreamEventsBackwardOperation.js

@@ -27,7 +27,13 @@ function ReadStreamEventsBackwardOperation(
 util.inherits(ReadStreamEventsBackwardOperation, OperationBase);
 
 ReadStreamEventsBackwardOperation.prototype._createRequestDto = function() {
-  return new ClientMessage.ReadStreamEvents(this._stream, this._fromEventNumber, this._maxCount, this._resolveLinkTos, this._requireMaster);
+  return new ClientMessage.ReadStreamEvents({
+      eventStreamId: this._stream,
+      fromEventNumber: this._fromEventNumber,
+      maxCount: this._maxCount,
+      resolveLinkTos: this._resolveLinkTos,
+      requireMaster: this._requireMaster
+  });
 };
 
 ReadStreamEventsBackwardOperation.prototype._inspectResponse = function(response) {
@@ -60,9 +66,9 @@ ReadStreamEventsBackwardOperation.prototype._transformResponse = function(respon
       this._fromEventNumber,
       ReadDirection.Backward,
       response.events,
-      response.next_event_number,
-      response.last_event_number,
-      response.is_end_of_stream
+      response.nextEventNumber,
+      response.lastEventNumber,
+      response.isEndOfStream
   )
 };
 

src/clientOperations/readStreamEventsForwardOperation.js

@@ -27,7 +27,13 @@ function ReadStreamEventsForwardOperation(
 util.inherits(ReadStreamEventsForwardOperation, OperationBase);
 
 ReadStreamEventsForwardOperation.prototype._createRequestDto = function() {
-  return new ClientMessage.ReadStreamEvents(this._stream, this._fromEventNumber, this._maxCount, this._resolveLinkTos, this._requireMaster);
+  return new ClientMessage.ReadStreamEvents({
+      eventStreamId: this._stream,
+      fromEventNumber: this._fromEventNumber,
+      maxCount: this._maxCount,
+      resolveLinkTos: this._resolveLinkTos,
+      requireMaster: this._requireMaster
+  });
 };
 
 ReadStreamEventsForwardOperation.prototype._inspectResponse = function(response) {
@@ -60,9 +66,9 @@ ReadStreamEventsForwardOperation.prototype._transformResponse = function(respons
       this._fromEventNumber,
       ReadDirection.Forward,
       response.events,
-      response.next_event_number,
-      response.last_event_number,
-      response.is_end_of_stream
+      response.nextEventNumber,
+      response.lastEventNumber,
+      response.isEndOfStream
   )
 };
 

src/clientOperations/startTransactionOperation.js

@@ -7,7 +7,9 @@ var InspectionResult = require('./../systemData/inspectionResult');
 var ClientMessage = require('../messages/clientMessage');
 var EventStoreTransaction = require('../eventStoreTransaction');
 var results = require('../results');
-
+var AccessDeniedError = require('../errors/accessDeniedError');
+var WrongExpectedVersionError = require('../errors/wrongExpectedVersionError');
+var StreamDeletedError = require('../errors/streamDeletedError');
 var OperationBase = require('../clientOperations/operationBase');
 
 function StartTransactionOperation(log, cb, requireMaster, stream, expectedVersion, parentConnection, userCredentials) {
@@ -22,7 +24,11 @@ function StartTransactionOperation(log, cb, requireMaster, stream, expectedVersi
 util.inherits(StartTransactionOperation, OperationBase);
 
 StartTransactionOperation.prototype._createRequestDto = function() {
-  return new ClientMessage.TransactionStart(this._stream, this._expectedVersion, this._requireMaster);
+  return new ClientMessage.TransactionStart({
+      eventStreamId: this._stream,
+      expectedVersion: this._expectedVersion,
+      requireMaster: this._requireMaster
+  });
 };
 
 StartTransactionOperation.prototype._inspectResponse = function(response) {
@@ -38,17 +44,16 @@ StartTransactionOperation.prototype._inspectResponse = function(response) {
     case ClientMessage.OperationResult.ForwardTimeout:
       return new InspectionResult(InspectionDecision.Retry, "ForwardTimeout");
     case ClientMessage.OperationResult.WrongExpectedVersion:
-      var err = util.format("Start transaction failed due to WrongExpectedVersion. Stream: %s, Expected version: %d.", this._stream, this._expectedVersion);
-      this.fail(new Error(err));
+      this.fail(new WrongExpectedVersionError("Start transaction", this._stream, this._expectedVersion));
       return new InspectionResult(InspectionDecision.EndOperation, "WrongExpectedVersion");
     case ClientMessage.OperationResult.StreamDeleted:
-      this.fail(new Error("Stream deleted: " + this._stream));
+      this.fail(new StreamDeletedError(this._stream));
       return new InspectionResult(InspectionDecision.EndOperation, "StreamDeleted");
     case ClientMessage.OperationResult.InvalidTransaction:
       this.fail(new Error("Invalid transaction."));
       return new InspectionResult(InspectionDecision.EndOperation, "InvalidTransaction");
     case ClientMessage.OperationResult.AccessDenied:
-      this.fail(new Error(util.format("Write access denied for stream '%s'.", this._stream)));
+      this.fail(new AccessDeniedError("Write", this._stream));
       return new InspectionResult(InspectionDecision.EndOperation, "AccessDenied");
     default:
       throw new Error(util.format("Unexpected OperationResult: %s.", response.result));
@@ -56,7 +61,7 @@ StartTransactionOperation.prototype._inspectResponse = function(response) {
 };
 
 StartTransactionOperation.prototype._transformResponse = function(response) {
-  return new EventStoreTransaction(response.transaction_id, this.userCredentials, this._parentConnection);
+  return new EventStoreTransaction(response.transactionId, this.userCredentials, this._parentConnection);
 };
 
 StartTransactionOperation.prototype.toString = function() {

src/clientOperations/subscriptionOperation.js

@@ -46,7 +46,7 @@ SubscriptionOperation.prototype._enqueueSend = function(pkg) {
 SubscriptionOperation.prototype.subscribe = function(correlationId, connection) {
   if (connection === null) throw new TypeError("connection is null.");
 
-  if (this._subscription != null || this._unsubscribed != 0)
+  if (this._subscription !== null || this._unsubscribed)
     return false;
 
   this._correlationId = correlationId;
@@ -64,7 +64,7 @@ SubscriptionOperation.prototype.unsubscribe = function() {
 
 SubscriptionOperation.prototype._createUnsubscriptionPackage = function() {
   var msg = new ClientMessage.UnsubscribeFromStream();
-  var data = new BufferSegment(msg.toBuffer());
+  var data = new BufferSegment(ClientMessage.UnsubscribeFromStream.encode(msg).finish());
   return new TcpPackage(TcpCommand.UnsubscribeFromStream, TcpFlags.None, this._correlationId, null, null, data);
 };
 
@@ -128,7 +128,7 @@ SubscriptionOperation.prototype.inspectPackage = function(pkg) {
 
       case TcpCommand.NotHandled:
       {
-        if (this._subscription != null)
+        if (this._subscription !== null)
           throw new Error("NotHandled command appeared while we already subscribed.");
 
         var message = ClientMessage.NotHandled.decode(pkg.data.toBuffer());
@@ -141,10 +141,10 @@ SubscriptionOperation.prototype.inspectPackage = function(pkg) {
             return new InspectionResult(InspectionDecision.Retry, "NotHandled - TooBusy");
 
           case ClientMessage.NotHandled.NotHandledReason.NotMaster:
-            var masterInfo = ClientMessage.NotHandled.MasterInfo.decode(message.additional_info);
+            var masterInfo = ClientMessage.NotHandled.MasterInfo.decode(message.additionalInfo);
             return new InspectionResult(InspectionDecision.Reconnect, "NotHandled - NotMaster",
-                {host: masterInfo.external_tcp_address, port: masterInfo.external_tcp_port},
-                {host: masterInfo.external_secure_tcp_address, port: masterInfo.external_secure_tcp_port});
+                {host: masterInfo.externalTcpAddress, port: masterInfo.externalTcpPort},
+                {host: masterInfo.externalSecureTcpAddress, port: masterInfo.externalSecureTcpPort});
 
           default:
             this._log.error("Unknown NotHandledReason: %s.", message.reason);
@@ -189,7 +189,6 @@ SubscriptionOperation.prototype.dropSubscription = function(reason, err, connect
     if (reason !== SubscriptionDropReason.UserInitiated && this._subscription === null)
     {
       if (err === null) throw new Error(util.format("No exception provided for subscription drop reason '%s", reason));
-      //TODO: this should be last thing to execute
       this._cb(err);
       return;
     }
@@ -233,7 +232,7 @@ SubscriptionOperation.prototype._onEventAppeared = function(e) {
         e.originalStreamId, e.originalEventNumber, e.originalEvent.eventType, e.originalPosition);
 
   var self = this;
-  this._executeAction(function() { self._eventAppeared(self._subscription, e); });
+  this._executeAction(function() { return self._eventAppeared(self._subscription, e); });
 };
 
 SubscriptionOperation.prototype._executeAction = function(action) {
@@ -245,21 +244,30 @@ SubscriptionOperation.prototype._executeAction = function(action) {
 };
 
 SubscriptionOperation.prototype._executeActions = function() {
-  //TODO: possible blocking loop for node.js
   var action = this._actionQueue.shift();
-  while (action)
-  {
+  if (!action) {
+    this._actionExecuting = false;
+    return;
+  }
+  var promise;
   try
   {
-      action();
+    promise = action();
   }
   catch (err)
   {
     this._log.error(err, "Exception during executing user callback: %s.", err.message);
   }
-    action = this._actionQueue.shift();
+  if (promise && promise.then) {
+    var self = this;
+    promise
+      .catch(function (err) {
+        self._log.error(err, "Exception during executing user callback: %s.", err.message);
+      })
+      .then(this._executeActions.bind(this));
+  } else {
+    setImmediate(this._executeActions.bind(this));
   }
-  this._actionExecuting = false;
 };
 
 SubscriptionOperation.prototype.toString = function() {

src/clientOperations/transactionalWriteOperation.js

@@ -1,10 +1,11 @@
 var util = require('util');
-var uuid = require('uuid');
+var guidParse = require('../common/guid-parse');
 
 var TcpCommand = require('../systemData/tcpCommand');
 var InspectionDecision = require('../systemData/inspectionDecision');
 var InspectionResult = require('./../systemData/inspectionResult');
 var ClientMessage = require('../messages/clientMessage');
+var AccessDeniedError = require('../errors/accessDeniedError');
 
 var OperationBase = require('../clientOperations/operationBase');
 
@@ -21,13 +22,18 @@ util.inherits(TransactionalWriteOperation, OperationBase);
 
 TransactionalWriteOperation.prototype._createRequestDto = function() {
   var dtos = this._events.map(function(ev) {
-    var eventId = new Buffer(uuid.parse(ev.eventId));
-    return new ClientMessage.NewEvent({
-      event_id: eventId, event_type: ev.type,
-      data_content_type: ev.isJson ? 1 : 0, metadata_content_type: 0,
-      data: ev.data, metadata: ev.metadata});
+    var eventId = guidParse.parse(ev.eventId);
+    return {
+      eventId: eventId, eventType: ev.type,
+      dataContentType: ev.isJson ? 1 : 0, metadataContentType: 0,
+      data: ev.data, metadata: ev.metadata
+    };
+  });
+  return new ClientMessage.TransactionWrite({
+    transactionId: this._transactionId,
+    events: dtos,
+    requireMaster: this._requireMaster
   });
-  return new ClientMessage.TransactionWrite(this._transactionId, dtos, this._requireMaster);
 };
 
 TransactionalWriteOperation.prototype._inspectResponse = function(response) {
@@ -43,7 +49,7 @@ TransactionalWriteOperation.prototype._inspectResponse = function(response) {
     case ClientMessage.OperationResult.ForwardTimeout:
       return new InspectionResult(InspectionDecision.Retry, "ForwardTimeout");
     case ClientMessage.OperationResult.AccessDenied:
-      this.fail(new Error("Write access denied."));
+      this.fail(new AccessDeniedError("Write", "trx:" + this._transactionId));
       return new InspectionResult(InspectionDecision.EndOperation, "AccessDenied");
     default:
       throw new Error(util.format("Unexpected OperationResult: %s.", response.result));

src/clientOperations/updatePersistentSubscriptionOperation.js

@@ -36,11 +36,24 @@ function UpdatePersistentSubscriptionOperation(log, cb, stream, groupName, setti
 util.inherits(UpdatePersistentSubscriptionOperation, OperationBase);
 
 UpdatePersistentSubscriptionOperation.prototype._createRequestDto = function() {
-  return new ClientMessage.UpdatePersistentSubscription(this._groupName, this._stream, this._resolveLinkTos,
-      this._startFromBeginning, this._messageTimeoutMilliseconds, this._recordStatistics, this._liveBufferSize,
-      this._readBatchSize, this._bufferSize, this._maxRetryCount,
-      this._namedConsumerStrategy == SystemConsumerStrategies.RoundRobin, this._checkPointAfter,
-      this._maxCheckPointCount, this._minCheckPointCount, this._maxSubscriberCount, this._namedConsumerStrategy);
+  return new ClientMessage.UpdatePersistentSubscription({
+      subscriptionGroupName: this._groupName,
+      eventStreamId: this._stream,
+      resolveLinkTos: this._resolveLinkTos,
+      startFrom: this._startFromBeginning,
+      messageTimeoutMilliseconds: this._messageTimeoutMilliseconds,
+      recordStatistics: this._recordStatistics,
+      liveBufferSize: this._liveBufferSize,
+      readBatchSize: this._readBatchSize,
+      bufferSize: this._bufferSize,
+      maxRetryCount: this._maxRetryCount,
+      preferRoundRobin: this._namedConsumerStrategy === SystemConsumerStrategies.RoundRobin,
+      checkpointAfterTime: this._checkPointAfter,
+      checkpointMaxCount: this._maxCheckPointCount,
+      checkpointMinCount: this._minCheckPointCount,
+      subscriberMaxCount: this._maxSubscriberCount,
+      namedConsumerStrategy: this._namedConsumerStrategy
+  });
 };
 
 UpdatePersistentSubscriptionOperation.prototype._inspectResponse = function(response) {

src/clientOperations/volatileSubscriptionOperation.js

@@ -9,7 +9,7 @@ var BufferSegment = require('../common/bufferSegment');
 var InspectionDecision = require('../systemData/inspectionDecision');
 var InspectionResult = require('./../systemData/inspectionResult');
 var results = require('../results');
-var VolatileEventStoreSubscription = require('../volatileEventStoreConnection');
+var VolatileEventStoreSubscription = require('../volatileEventStoreSubscription');
 
 function VolatileSubscriptionOperation(
     log, cb, streamId, resolveLinkTos, userCredentials, eventAppeared,
@@ -20,23 +20,26 @@ function VolatileSubscriptionOperation(
 util.inherits(VolatileSubscriptionOperation, SubscriptionOperation);
 
 VolatileSubscriptionOperation.prototype._createSubscriptionPackage = function() {
-  var dto = new ClientMessage.SubscribeToStream(this._streamId, this._resolveLinkTos);
+  var dto = new ClientMessage.SubscribeToStream({
+      eventStreamId: this._streamId,
+      resolveLinkTos: this._resolveLinkTos
+  });
   return new TcpPackage(TcpCommand.SubscribeToStream,
-      this._userCredentials != null ? TcpFlags.Authenticated : TcpFlags.None,
+      this._userCredentials !== null ? TcpFlags.Authenticated : TcpFlags.None,
       this._correlationId,
-      this._userCredentials != null ? this._userCredentials.username : null,
-      this._userCredentials != null ? this._userCredentials.password : null,
-      new BufferSegment(dto.toBuffer()));
+      this._userCredentials !== null ? this._userCredentials.username : null,
+      this._userCredentials !== null ? this._userCredentials.password : null,
+      new BufferSegment(ClientMessage.SubscribeToStream.encode(dto).finish()));
 };
 
 VolatileSubscriptionOperation.prototype._inspectPackage = function(pkg) {
   try {
-    if (pkg.command == TcpCommand.SubscriptionConfirmation) {
+    if (pkg.command === TcpCommand.SubscriptionConfirmation) {
       var dto = ClientMessage.SubscriptionConfirmation.decode(pkg.data.toBuffer());
-      this._confirmSubscription(dto.last_commit_position, dto.last_event_number);
+      this._confirmSubscription(dto.lastCommitPosition, dto.lastEventNumber);
       return new InspectionResult(InspectionDecision.Subscribed, "SubscriptionConfirmation");
     }
-    if (pkg.command == TcpCommand.StreamEventAppeared) {
+    if (pkg.command === TcpCommand.StreamEventAppeared) {
       var dto = ClientMessage.StreamEventAppeared.decode(pkg.data.toBuffer());
       this._onEventAppeared(new results.ResolvedEvent(dto.event));
       return new InspectionResult(InspectionDecision.DoNothing, "StreamEventAppeared");

src/common/bufferSegment.js

@@ -1,5 +1,6 @@
 /**
  * Create a buffer segment
+ * @private
  * @param {Buffer} buf
  * @param {number} [offset]
  * @param {number} [count]

src/common/guid-parse.js

@@ -0,0 +1,47 @@
+'use strict';
+
+// Maps for number <-> hex string conversion
+var _byteToHex = [];
+var _hexToByte = {};
+for (var i = 0; i < 256; i++) {
+  _byteToHex[i] = (i + 0x100).toString(16).substr(1);
+  _hexToByte[_byteToHex[i]] = i;
+}
+
+// **`parse()` - Parse a UUID into it's component bytes**
+function parse(s, buf, offset) {
+  const i = (buf && offset) || 0;
+  var ii = 0;
+
+  if (buf) buf.fill(0, i, i + 16);
+  buf = buf || new Buffer(16);
+  s.toLowerCase().replace(/[0-9a-f]{2}/g, function(oct) {
+    if (ii < 16) { // Don't overflow!
+      buf[i + ii++] = _hexToByte[oct];
+    }
+  });
+
+  var buf2 = new Buffer(buf.slice(i, i + 16));
+  buf[i + 0] = buf2[3];
+  buf[i + 1] = buf2[2];
+  buf[i + 2] = buf2[1];
+  buf[i + 3] = buf2[0];
+  buf[i + 4] = buf2[5];
+  buf[i + 5] = buf2[4];
+  buf[i + 6] = buf2[7];
+  buf[i + 7] = buf2[6];
+
+  return buf;
+}
+
+// **`unparse()` - Convert UUID byte array (ala parse()) into a string**
+function unparse(buf, offset) {
+  var i = offset || 0;
+  return '03020100-0504-0706-0809-101112131415'.replace(/\d{2}/g, function (num) {
+    var j = parseInt(num, 10);
+    return _byteToHex[buf[i+j]];
+  })
+}
+
+exports.parse = parse;
+exports.unparse = unparse;

src/common/hash.js

@@ -1,4 +1,5 @@
 /**
+ * @private
  * @constructor
  * @property {number} length
  */

src/common/log/fileLogger.js

@@ -6,7 +6,7 @@ function FileLogger(filePath, append) {
   this._filePath = filePath;
   if (!append) {
     try {
-      fs.unlink(filePath);
+      fs.unlinkSync(filePath);
     } catch(e) {}
   }
 }

src/common/systemMetadata.js

@@ -12,5 +12,6 @@ const SystemMetadata = {
   userStreamAcl: '$userStreamAcl',
   systemStreamAcl: '$systemStreamAcl'
 };
+Object.freeze(SystemMetadata);
 
 module.exports = SystemMetadata;

src/common/utils/ensure.js

@@ -19,12 +19,13 @@ module.exports.isArrayOf = function(expectedType, value, name) {
   if (!Array.isArray(value))
     throw new TypeError(name + " should be an array.");
   if (!value.every(function(x) { return x instanceof expectedType; }))
-    throw new TypeError([name, " should be an array of ", expectedType, "."].join(""));
+    throw new TypeError([name, " should be an array of ", expectedType.name, "."].join(""));
 };
 
-module.exports.isTypeOf = function(expectedType, value, name) {
+module.exports.isTypeOf = function(expectedType, value, name, nullAllowed) {
+  if (nullAllowed && value === null) return;
   if (!(value instanceof expectedType))
-    throw new TypeError([name, " should be of type '", expectedType, "'."].join(""));
+    throw new TypeError([name, " should be of type '", expectedType.name, "'", nullAllowed ? " or null": "", "."].join(""));
 };
 
 module.exports.positive = function(value, name) {

src/core/clusterDnsEndPointDiscoverer.js

@@ -0,0 +1,254 @@
+var http = require('http');
+var util = require('util');
+var dns = require('dns');
+var GossipSeed = require('../gossipSeed');
+
+function NodeEndPoints(tcpEndPoint, secureTcpEndPoint) {
+  if (tcpEndPoint === null && secureTcpEndPoint === null) throw new Error('Both endpoints are null.');
+  Object.defineProperties(this, {
+    tcpEndPoint: {
+      enumerable: true,
+      value: tcpEndPoint
+    },
+    secureTcpEndPoint: {
+      enumerable: true,
+      value: secureTcpEndPoint
+    }
+  });
+}
+
+function ClusterDnsEndPointDiscoverer(log, clusterDns, maxDiscoverAttempts, managerExternalHttpPort, gossipSeeds, gossipTimeout) {
+  if (!clusterDns && (!gossipSeeds || gossipSeeds.length === 0)) throw new Error('Both clusterDns and gossipSeeds are null/empty.');
+  this._log = log;
+  this._clusterDns = clusterDns;
+  this._maxDiscoverAttempts = maxDiscoverAttempts;
+  this._managerExternalHttpPort = managerExternalHttpPort;
+  this._gossipSeeds = gossipSeeds;
+  this._gossipTimeout = gossipTimeout;
+  this._oldGossip = null;
+}
+
+ClusterDnsEndPointDiscoverer.prototype.discover = function(failedTcpEndPoint) {
+  var attempt = 1;
+  var self = this;
+  function discover(resolve, reject) {
+    self._discoverEndPoint(failedTcpEndPoint)
+      .then(function (endPoints) {
+        if (!endPoints)
+          self._log.info(util.format("Discovering attempt %d/%d failed: no candidate found.", attempt, self._maxDiscoverAttempts));
+        return endPoints;
+      })
+      .catch(function (exc) {
+        self._log.info(util.format("Discovering attempt %d/%d failed with error: %s.\n%s", attempt, self._maxDiscoverAttempts, exc, exc.stack));
+      })
+      .then(function (endPoints) {
+        if (endPoints)
+          return resolve(endPoints);
+        if (attempt++ === self._maxDiscoverAttempts)
+          return reject(new Error('Failed to discover candidate in ' + self._maxDiscoverAttempts + ' attempts.'));
+        setTimeout(discover, 500, resolve, reject);
+      });
+  }
+  return new Promise(function (resolve, reject) {
+    discover(resolve, reject);
+  });
+};
+
+/**
+ * Discover Cluster endpoints
+ * @param {Object} failedTcpEndPoint
+ * @returns {Promise.<NodeEndPoints>}
+ * @private
+ */
+ClusterDnsEndPointDiscoverer.prototype._discoverEndPoint = function (failedTcpEndPoint) {
+  try {
+    var mainPromise = this._oldGossip
+      ? Promise.resolve(this._getGossipCandidatesFromOldGossip(this._oldGossip, failedTcpEndPoint))
+      : this._getGossipCandidatesFromDns();
+    var self = this;
+    var j = 0;
+    return mainPromise.then(function (gossipCandidates) {
+      var loopPromise = Promise.resolve();
+      for (var i = 0; i < gossipCandidates.length; i++) {
+        loopPromise = loopPromise.then(function (endPoints) {
+          if (endPoints) return endPoints;
+          return self._tryGetGossipFrom(gossipCandidates[j++])
+            .then(function (gossip) {
+              if (!gossip || !gossip.members || gossip.members.length === 0)
+                return;
+              var bestNode = self._tryDetermineBestNode(gossip.members);
+              if (bestNode) {
+                self._oldGossip = gossip.members;
+                return bestNode;
+              }
+            });
+        });
+      }
+      return loopPromise;
+    });
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+
+ClusterDnsEndPointDiscoverer.prototype._getGossipCandidatesFromOldGossip = function (oldGossip, failedTcpEndPoint) {
+  if (!failedTcpEndPoint) return this._arrangeGossipCandidates(oldGossip);
+  var gossipCandidates = oldGossip.filter(function(x) {
+    return !(x.externalTcpPort === failedTcpEndPoint.port && x.externalTcpIp === failedTcpEndPoint.host);
+  });
+  return this._arrangeGossipCandidates(gossipCandidates);
+};
+
+ClusterDnsEndPointDiscoverer.prototype._arrangeGossipCandidates = function (members) {
+  var result = new Array(members.length);
+  var i = -1;
+  var j = members.length;
+  for (var k = 0; k < members.length; ++k)
+  {
+    if (members[k].state === 'Manager')
+      result[--j] = new GossipSeed({host: members[k].externalHttpIp, port: members[k].externalHttpPort});
+    else
+      result[++i] = new GossipSeed({host: members[k].externalHttpIp, port: members[k].externalHttpPort});
+  }
+  this._randomShuffle(result, 0, i); // shuffle nodes
+  this._randomShuffle(result, j, members.length - 1); // shuffle managers
+  return result;
+};
+
+ClusterDnsEndPointDiscoverer.prototype._getGossipCandidatesFromDns = function () {
+  var self = this;
+  return new Promise(function (resolve, reject) {
+    if (self._gossipSeeds && self._gossipSeeds.length > 0) {
+      var endpoints = self._gossipSeeds;
+      self._randomShuffle(endpoints, 0, endpoints.length - 1);
+      resolve(endpoints);
+    }
+    else {
+      const dnsOptions = {
+        family: 4,
+        hints: dns.ADDRCONFIG | dns.V4MAPPED,
+        all: true
+      };
+      dns.lookup(self._clusterDns, dnsOptions, function (err, addresses) {
+        if (err) {
+          return reject(err);
+        }
+        if (!addresses || addresses.length === 0) {
+          return reject(new Error('No result from dns lookup for ' + self._clusterDns));
+        }
+        var endpoints = addresses.map(function (x) {
+          return new GossipSeed({host: x.address, port: self._managerExternalHttpPort});
+        });
+        resolve(endpoints);
+      });
+    }
+  });
+};
+
+ClusterDnsEndPointDiscoverer.prototype._tryGetGossipFrom = function (endPoint) {
+  var options = {
+    host: endPoint.endPoint.host,
+    port: endPoint.endPoint.port,
+    path: '/gossip?format=json'
+  };
+  if (endPoint.hostHeader) {
+    options.headers = {'Host': endPoint.hostHeader};
+  }
+  this._log.info('Try get gossip from', endPoint);
+  var self = this;
+  return new Promise(function (resolve, reject) {
+    var timedout = false;
+    http.request(options, function (res) {
+          if (timedout) return;
+          var result = '';
+          if (res.statusCode !== 200) {
+            self._log.info('Trying to get gossip from', endPoint, 'failed with status code:', res.statusCode);
+            resolve();
+            return;
+          }
+          res.on('data', function (chunk) {
+            result += chunk.toString();
+          });
+          res.on('end', function () {
+            try {
+              result = JSON.parse(result);
+            } catch (e) {
+              return resolve();
+            }
+            resolve(result);
+          });
+        })
+        .setTimeout(self._gossipTimeout, function () {
+          self._log.info('Trying to get gossip from', endPoint, 'timed out.');
+          timedout = true;
+          resolve();
+        })
+        .on('error', function (e) {
+          if (timedout) return;
+          self._log.info('Trying to get gossip from', endPoint, 'failed with error:', e);
+          resolve();
+        })
+        .end();
+  });
+};
+
+const VNodeStates = {
+  'Initializing': 0,
+  'Unknown': 1,
+  'PreReplica': 2,
+  'CatchingUp': 3,
+  'Clone': 4,
+  'Slave': 5,
+  'PreMaster': 6,
+  'Master': 7,
+  'Manager': 8,
+  'ShuttingDown': 9,
+  'Shutdown': 10
+};
+
+ClusterDnsEndPointDiscoverer.prototype._tryDetermineBestNode = function (members) {
+  var notAllowedStates = [
+    'Manager',
+    'ShuttingDown',
+    'Shutdown'
+  ];
+  var node = members
+    .filter(function (x) {
+      return (x.isAlive && notAllowedStates.indexOf(x.state) === -1);
+    })
+    .sort(function (a, b) {
+      return VNodeStates[b.state] - VNodeStates[a.state];
+    })[0];
+  if (!node)
+  {
+    //_log.Info("Unable to locate suitable node. Gossip info:\n{0}.", string.Join("\n", members.Select(x => x.ToString())));
+    return null;
+  }
+
+  var normTcp = {host: node.externalTcpIp, port: node.externalTcpPort};
+  var secTcp = node.externalSecureTcpPort > 0
+    ? {host: externalTcpIp, port: node.externalSecureTcpPort}
+    : null;
+  this._log.info(util.format("Discovering: found best choice [%j,%j] (%s).", normTcp, secTcp === null ? "n/a" : secTcp, node.state));
+  return new NodeEndPoints(normTcp, secTcp);
+};
+
+function rndNext(min, max) {
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  return Math.floor(Math.random() * (max - min)) + min;
+}
+
+ClusterDnsEndPointDiscoverer.prototype._randomShuffle = function (arr, i, j) {
+  if (i >= j)
+    return;
+  for (var k = i; k <= j; ++k)
+  {
+    var index = rndNext(k, j + 1);
+    var tmp = arr[index];
+    arr[index] = arr[k];
+    arr[k] = tmp;
+  }
+};
+
+module.exports = ClusterDnsEndPointDiscoverer;

src/core/eventStoreConnectionLogicHandler.js

@@ -36,12 +36,14 @@ const TimerTickMessage = new messages.TimerTickMessage();
 const EmptyGuid = '00000000-0000-0000-0000-000000000000';
 
 /**
+ * @private
  * @param {EventStoreNodeConnection} esConnection
  * @param {Object} settings
  * @constructor
  * @property {Number} totalOperationCount
  */
 function EventStoreConnectionLogicHandler(esConnection, settings) {
+  EventEmitter.call(this);
   this._esConnection = esConnection;
   this._settings = settings;
   this._queue = new SimpleQueuedHandler();
@@ -165,7 +167,7 @@ EventStoreConnectionLogicHandler.prototype._startConnection = function(cb, endpo
  * @private
  */
 EventStoreConnectionLogicHandler.prototype._closeConnection = function(reason, error) {
-  if (this._state == ConnectionState.Closed) {
+  if (this._state === ConnectionState.Closed) {
     this._logDebug("CloseConnection IGNORED because is ESConnection is CLOSED, reason %s, error %s.", reason, error ? error.stack : '');
     return;
   }
@@ -189,7 +191,7 @@ EventStoreConnectionLogicHandler.prototype._closeConnection = function(reason, e
 
 EventStoreConnectionLogicHandler.prototype._closeTcpConnection = function(reason) {
   if (!this._connection) {
-    this._logDebug("CloseTcpConnection IGNORED because _connection == null");
+    this._logDebug("CloseTcpConnection IGNORED because _connection === null");
     return;
   }
 
@@ -320,7 +322,7 @@ EventStoreConnectionLogicHandler.prototype._startPersistentSubscription = functi
 
 EventStoreConnectionLogicHandler.prototype._establishTcpConnection = function(endPoints) {
   var endPoint = this._settings.useSslConnection ? endPoints.secureTcpEndPoint : endPoints.tcpEndPoint;
-  if (endPoint == null)
+  if (endPoint === null)
   {
     this._closeConnection("No end point to node specified.");
     return;
@@ -328,8 +330,8 @@ EventStoreConnectionLogicHandler.prototype._establishTcpConnection = function(en
 
   this._logDebug("EstablishTcpConnection to [%j]", endPoint);
 
-  if (this._state != ConnectionState.Connecting) return;
-  if (this._connectingPhase != ConnectingPhase.EndPointDiscovery) return;
+  if (this._state !== ConnectionState.Connecting) return;
+  if (this._connectingPhase !== ConnectingPhase.EndPointDiscovery) return;
 
   var self = this;
   this._connectingPhase = ConnectingPhase.ConnectionEstablishing;
@@ -358,10 +360,10 @@ EventStoreConnectionLogicHandler.prototype._establishTcpConnection = function(en
 };
 
 EventStoreConnectionLogicHandler.prototype._tcpConnectionEstablished = function(connection) {
-  if (this._state != ConnectionState.Connecting || !this._connection.equals(connection) || connection.isClosed)
+  if (this._state !== ConnectionState.Connecting || !this._connection || !this._connection.equals(connection) || connection.isClosed)
   {
     this._logDebug("IGNORED (_state %s, _conn.Id %s, conn.Id %s, conn.closed %s): TCP connection to [%j, L%j] established.",
-        this._state, this._connection == null ? EmptyGuid : this._connection.connectionId, connection.connectionId,
+        this._state, this._connection === null ? EmptyGuid : this._connection.connectionId, connection.connectionId,
         connection.isClosed, connection.remoteEndPoint, connection.localEndPoint);
     return;
   }
@@ -373,7 +375,7 @@ EventStoreConnectionLogicHandler.prototype._tcpConnectionEstablished = function(
     timeStamp: Date.now()
   };
 
-  if (this._settings.defaultUserCredentials != null)
+  if (this._settings.defaultUserCredentials !== null)
   {
     this._connectingPhase = ConnectingPhase.Authentication;
 
@@ -402,7 +404,7 @@ EventStoreConnectionLogicHandler.prototype._goToConnectedState = function() {
 
   this.emit('connected', this._connection.remoteEndPoint);
 
-  if (Date.now() - this._lastTimeoutsTimeStamp >= this._settings.operationTimeoutCheckPeriod)
+  if ((Date.now() - this._lastTimeoutsTimeStamp) >= this._settings.operationTimeoutCheckPeriod)
   {
     this._operations.checkTimeoutsAndRetry(this._connection);
     this._subscriptions.checkTimeoutsAndRetry(this._connection);
@@ -411,19 +413,19 @@ EventStoreConnectionLogicHandler.prototype._goToConnectedState = function() {
 };
 
 EventStoreConnectionLogicHandler.prototype._tcpConnectionError = function(connection, error) {
-  if (this._connection != connection) return;
-  if (this._state == ConnectionState.Closed) return;
+  if (!this._connection || !this._connection.equals(connection)) return;
+  if (this._state === ConnectionState.Closed) return;
 
   this._logDebug("TcpConnectionError connId %s, exc %s.", connection.connectionId, error);
   this._closeConnection("TCP connection error occurred.", error);
 };
 
 EventStoreConnectionLogicHandler.prototype._tcpConnectionClosed = function(connection, error) {
-  if (this._state == ConnectionState.Init) throw new Error();
-  if (this._state == ConnectionState.Closed || !this._connection.equals(connection))
+  if (this._state === ConnectionState.Init) throw new Error();
+  if (this._state === ConnectionState.Closed || !this._connection || !this._connection.equals(connection))
   {
     this._logDebug("IGNORED (_state: %s, _conn.ID: %s, conn.ID: %s): TCP connection to [%j, L%j] closed.",
-        this._state, this._connection == null ? EmptyGuid : this._connection.connectionId,  connection.connectionId,
+        this._state, this._connection === null ? EmptyGuid : this._connection.connectionId,  connection.connectionId,
         connection.remoteEndPoint, connection.localEndPoint);
     return;
   }
@@ -447,7 +449,7 @@ EventStoreConnectionLogicHandler.prototype._tcpConnectionClosed = function(conne
 };
 
 EventStoreConnectionLogicHandler.prototype._handleTcpPackage = function(connection, pkg) {
-  if (!connection.equals(this._connection) || this._state == ConnectionState.Closed || this._state == ConnectionState.Init)
+  if (!connection.equals(this._connection) || this._state === ConnectionState.Closed || this._state === ConnectionState.Init)
   {
     this._logDebug("IGNORED: HandleTcpPackage connId %s, package %s, %s.",
                    connection.connectionId, TcpCommand.getName(pkg.command), pkg.correlationId);
@@ -458,9 +460,28 @@ EventStoreConnectionLogicHandler.prototype._handleTcpPackage = function(connecti
                  this._connection.connectionId, TcpCommand.getName(pkg.command), pkg.correlationId);
   this._packageNumber += 1;
 
-  if (pkg.command == TcpCommand.HeartbeatResponseCommand)
+  if (pkg.command === TcpCommand.HeartbeatResponseCommand)
+  {
+    if (pkg.correlationId === this._heartbeatInfo.correlationId)
+    {
+      var now = Date.now();
+      var heartbeatEvent = {
+        connectionId: this._connection.connectionId,
+        remoteEndPoint: this._connection.remoteEndPoint,
+        requestSentAt: this._heartbeatInfo.timeStamp,
+        requestPkgNumber: this._heartbeatInfo.lastPackageNumber,
+        responseReceivedAt: now,
+        responsePkgNumber: this._packageNumber
+      };
+      try {
+        this.emit('heartbeatInfo', heartbeatEvent);
+      } catch(e) {
+        this._logDebug("IGNORED: emit heartbeat event failed.\n%s", e.stack);
+      }
+    }
     return;
-  if (pkg.command == TcpCommand.HeartbeatRequestCommand)
+  }
+  if (pkg.command === TcpCommand.HeartbeatRequestCommand)
   {
     this._connection.enqueueSend(new TcpPackage(
       TcpCommand.HeartbeatResponseCommand,
@@ -469,13 +490,13 @@ EventStoreConnectionLogicHandler.prototype._handleTcpPackage = function(connecti
     return;
   }
 
-  if (pkg.command == TcpCommand.Authenticated || pkg.command == TcpCommand.NotAuthenticated)
+  if (pkg.command === TcpCommand.Authenticated || pkg.command === TcpCommand.NotAuthenticated)
   {
-    if (this._state == ConnectionState.Connecting
-        && this._connectingPhase == ConnectingPhase.Authentication
-        && this._authInfo.correlationId == pkg.correlationId)
+    if (this._state === ConnectionState.Connecting
+        && this._connectingPhase === ConnectingPhase.Authentication
+        && this._authInfo.correlationId === pkg.correlationId)
     {
-      if (pkg.command == TcpCommand.NotAuthenticated)
+      if (pkg.command === TcpCommand.NotAuthenticated)
         this.emit('authenticationFailed', "Not authenticated");
 
       this._goToConnectedState();
@@ -483,7 +504,7 @@ EventStoreConnectionLogicHandler.prototype._handleTcpPackage = function(connecti
     }
   }
 
-  if (pkg.command == TcpCommand.BadRequest && pkg.correlationId == EmptyGuid)
+  if (pkg.command === TcpCommand.BadRequest && pkg.correlationId === EmptyGuid)
   {
     var message = "<no message>";
     try {
@@ -515,7 +536,7 @@ EventStoreConnectionLogicHandler.prototype._handleTcpPackage = function(connecti
       default:
         throw new Error("Unknown InspectionDecision: " + result.decision);
     }
-    if (this._state == ConnectionState.Connected)
+    if (this._state === ConnectionState.Connected)
       this._operations.scheduleWaitingOperations(connection);
 
     return;
@@ -557,13 +578,13 @@ EventStoreConnectionLogicHandler.prototype._reconnectTo = function(endPoints) {
   var endPoint = this._settings.useSslConnection
       ? endPoints.secureTcpEndPoint
       : endPoints.tcpEndPoint;
-  if (endPoint == null)
+  if (endPoint === null)
   {
     this._closeConnection("No end point is specified while trying to reconnect.");
     return;
   }
 
-  if (this._state != ConnectionState.Connected || this._connection.remoteEndPoint == endPoint)
+  if (this._state !== ConnectionState.Connected || this._connection.remoteEndPoint === endPoint)
     return;
 
   var msg = util.format("EventStoreConnection '%s': going to reconnect to [%j]. Current endpoint: [%j, L%j].",
@@ -581,7 +602,7 @@ EventStoreConnectionLogicHandler.prototype._timerTick = function() {
   {
     case ConnectionState.Init: break;
     case ConnectionState.Connecting:
-      if (this._connectingPhase == ConnectingPhase.Reconnecting && Date.now() - this._reconnInfo.timeStamp >= this._settings.reconnectionDelay)
+      if (this._connectingPhase === ConnectingPhase.Reconnecting && (Date.now() - this._reconnInfo.timeStamp) >= this._settings.reconnectionDelay)
       {
         this._logDebug("TimerTick checking reconnection...");
 
@@ -594,17 +615,17 @@ EventStoreConnectionLogicHandler.prototype._timerTick = function() {
           this._discoverEndpoint(null);
         }
       }
-      else if (this._connectingPhase == ConnectingPhase.Authentication && Date.now() - this._authInfo.timeStamp >= this._settings.operationTimeout)
+      else if (this._connectingPhase === ConnectingPhase.Authentication && (Date.now() - this._authInfo.timeStamp) >= this._settings.operationTimeout)
       {
         this.emit('authenticationFailed', "Authentication timed out.");
         this._goToConnectedState();
       }
-      else if (this._connectingPhase > ConnectingPhase.ConnectionEstablishing)
+      else if (this._connectingPhase === ConnectingPhase.Authentication || this._connectingPhase === ConnectingPhase.Connected)
         this._manageHeartbeats();
       break;
     case ConnectionState.Connected:
       // operations timeouts are checked only if connection is established and check period time passed
-      if (Date.now() - this._lastTimeoutsTimeStamp >= this._settings.operationTimeoutCheckPeriod)
+      if ((Date.now() - this._lastTimeoutsTimeStamp) >= this._settings.operationTimeoutCheckPeriod)
       {
         // On mono even impossible connection first says that it is established
         // so clearing of reconnection count on ConnectionEstablished event causes infinite reconnections.
@@ -624,14 +645,14 @@ EventStoreConnectionLogicHandler.prototype._timerTick = function() {
 };
 
 EventStoreConnectionLogicHandler.prototype._manageHeartbeats = function() {
-  if (this._connection == null) throw new Error();
+  if (this._connection === null) return;
 
   var timeout = this._heartbeatInfo.isIntervalStage ? this._settings.heartbeatInterval : this._settings.heartbeatTimeout;
-  if (Date.now() - this._heartbeatInfo.timeStamp < timeout)
+  if ((Date.now() - this._heartbeatInfo.timeStamp) < timeout)
     return;
 
   var packageNumber = this._packageNumber;
-  if (this._heartbeatInfo.lastPackageNumber != packageNumber)
+  if (this._heartbeatInfo.lastPackageNumber !== packageNumber)
   {
     this._heartbeatInfo = {lastPackageNumber: packageNumber, isIntervalStage: true, timeStamp: Date.now()};
     return;
@@ -639,12 +660,13 @@ EventStoreConnectionLogicHandler.prototype._manageHeartbeats = function() {
 
   if (this._heartbeatInfo.isIntervalStage)
   {
+    var correlationId = uuid.v4();
     // TcpMessage.Heartbeat analog
     this._connection.enqueueSend(new TcpPackage(
       TcpCommand.HeartbeatRequestCommand,
       TcpFlags.None,
-      uuid.v4()));
-    this._heartbeatInfo = {lastPackageNumber: this._heartbeatInfo.lastPackageNumber, isIntervalStage: false, timeStamp: Date.now()};
+      correlationId));
+    this._heartbeatInfo = {correlationId: correlationId, lastPackageNumber: this._heartbeatInfo.lastPackageNumber, isIntervalStage: false, timeStamp: Date.now()};
   }
   else
   {

src/core/messages.js

@@ -41,6 +41,7 @@ function StartSubscriptionMessage(
 util.inherits(StartSubscriptionMessage, Message);
 
 /**
+ * @private
  * @constructor
  * @property {object} endPoints
  * @property {object} endPoints.secureTcpEndPoint

src/core/operationsManager.js

@@ -5,6 +5,7 @@ var Hash = require('../common/hash');
 var TcpCommand = require('../systemData/tcpCommand');
 
 /**
+ * @private
  * @param {string} connectionName
  * @param {object} settings
  * @constructor
@@ -29,17 +30,20 @@ OperationsManager.prototype.getActiveOperation = function(correlationId) {
   return this._activeOperations.get(correlationId);
 };
 
-OperationsManager.prototype.cleanUp = function() {
-  var connectionClosedError = new Error(util.format("Connection '%s' was closed.", this._connectionName));
+function cleanUpError(connName, state, operation) {
+    return new Error(util.format("Connection '%s' was closed. %s %s.", connName, state, operation.toString()));
+}
 
+OperationsManager.prototype.cleanUp = function() {
+  var self = this;
   this._activeOperations.forEach(function(correlationId, operation){
-    operation.operation.fail(connectionClosedError);
+    operation.operation.fail(cleanUpError(self._connectionName, 'Active', operation));
   });
   this._waitingOperations.forEach(function(operation) {
-    operation.operation.fail(connectionClosedError);
+    operation.operation.fail(cleanUpError(self._connectionName, 'Waiting', operation));
   });
   this._retryPendingOperations.forEach(function(operation) {
-    operation.operation.fail(connectionClosedError);
+    operation.operation.fail(cleanUpError(self._connectionName, 'Pending', operation));
   });
 
   this._activeOperations.clear();
@@ -55,7 +59,7 @@ OperationsManager.prototype.checkTimeoutsAndRetry = function(connection) {
   var removeOperations = [];
   var self = this;
   this._activeOperations.forEach(function(correlationId, operation) {
-    if (operation.connectionId != connection.connectionId)
+    if (operation.connectionId !== connection.connectionId)
     {
       retryOperations.push(operation);
     }
@@ -120,7 +124,7 @@ OperationsManager.prototype.scheduleOperationRetry = function(operation) {
 };
 
 OperationsManager.prototype.removeOperation = function(operation) {
-  this._activeOperations.remove(operation.connectionId);
+  this._activeOperations.remove(operation.correlationId);
   this._logDebug("RemoveOperation SUCCEEDED for %s.", operation);
   this._totalOperationCount = this._activeOperations.length + this._waitingOperations.length;
   return true;

src/core/simpleQueuedHandler.js

@@ -13,8 +13,14 @@ function SimpleQueuedHandler() {
 }
 
 SimpleQueuedHandler.prototype.registerHandler = function(type, handler) {
-  type = typeName(type);
-  this._handlers[type] = handler;
+  var typeId = typeName(type);
+  this._handlers[typeId] = function (msg) {
+    try {
+      handler(msg);
+    } catch(e) {
+      console.log('ERROR: ', e.stack);
+    }
+  };
 };
 
 SimpleQueuedHandler.prototype.enqueueMessage = function(msg) {
@@ -28,10 +34,10 @@ SimpleQueuedHandler.prototype.enqueueMessage = function(msg) {
 SimpleQueuedHandler.prototype._processQueue = function() {
   var message = this._messages.shift();
   while(message) {
-    var type = typeName(message);
-    var handler = this._handlers[type];
+    var typeId = typeName(message);
+    var handler = this._handlers[typeId];
     if (!handler)
-        throw new Error("No handler registered for message " + type);
+        throw new Error("No handler registered for message " + typeId);
     setImmediate(handler, message);
     message = this._messages.shift();
   }

src/core/subscriptionsManager.js

@@ -38,11 +38,11 @@ SubscriptionsManager.prototype.cleanUp = function() {
   this._retryPendingSubscriptions = [];
 };
 
-SubscriptionsManager.prototype.purgeSubscribedAndDroppedSubscriptions = function() {
+SubscriptionsManager.prototype.purgeSubscribedAndDroppedSubscriptions = function(connectionId) {
   var self = this;
   var subscriptionsToRemove = [];
   this._activeSubscriptions.forEach(function(_, subscription) {
-    if (subscription.isSubscribed && subscription.connectionId == connectionId) {
+    if (subscription.isSubscribed && subscription.connectionId === connectionId) {
       subscription.operation.connectionClosed();
       subscriptionsToRemove.push(subscription);
     }
@@ -60,7 +60,7 @@ SubscriptionsManager.prototype.checkTimeoutsAndRetry = function(connection) {
   var removeSubscriptions = [];
   this._activeSubscriptions.forEach(function(_, subscription) {
     if (subscription.isSubscribed) return;
-    if (subscription.connectionId != connection.connectionId)
+    if (subscription.connectionId !== connection.connectionId)
     {
       retrySubscriptions.push(subscription);
     }
@@ -165,7 +165,7 @@ SubscriptionsManager.prototype._logDebug = function(message) {
   if (!this._settings.verboseLogging) return;
 
   var parameters = Array.prototype.slice.call(arguments, 1);
-  this._settings.log.debug("EventStoreConnection '%s': %s.", this._connectionName, parameters.length == 0 ? message : util.format(message, parameters));
+  this._settings.log.debug("EventStoreConnection '%s': %s.", this._connectionName, parameters.length === 0 ? message : util.format(message, parameters));
 };
 
 module.exports = SubscriptionsManager;

src/errors/accessDeniedError.js

@@ -1,11 +1,23 @@
 var util = require('util');
+var Long = require('long');
 
-function AccessDeniedError(action, stream) {
+function AccessDeniedError(action, streamOrTransactionId) {
   Error.captureStackTrace(this, this.constructor);
   this.name = this.constructor.name;
-  this.message = util.format("%s access denied for stream '%s'.", action, stream);
   this.action = action;
-  this.stream = stream;
+  if (typeof streamOrTransactionId === 'string') {
+    this.message = util.format("%s access denied for stream '%s'.", action, streamOrTransactionId);
+    this.stream = streamOrTransactionId;
+    Object.freeze(this);
+    return;
+  }
+  if (Long.isLong(streamOrTransactionId)) {
+    this.message = util.format("%s access denied for transaction %s.", action, streamOrTransactionId);
+    this.transactionId = streamOrTransactionId;
+    Object.freeze(this);
+    return;
+  }
+  throw new TypeError("second argument must be a stream name or transaction Id.");
 }
 util.inherits(AccessDeniedError, Error);
 

src/errors/projectionCommandFailedError.js

@@ -0,0 +1,10 @@
+const util = require('util');
+
+function ProjectionCommandFailedError(httpStatusCode, message) {
+  Error.captureStackTrace(this, this.constructor);
+  this.httpStatusCode = httpStatusCode;
+  this.message = message;
+}
+util.inherits(ProjectionCommandFailedError, Error);
+
+module.exports = ProjectionCommandFailedError;

src/errors/streamDeletedError.js

@@ -1,10 +1,22 @@
 var util = require('util');
+var Long = require('long');
 
-function StreamDeletedError(stream) {
+function StreamDeletedError(streamOrTransactionId) {
   Error.captureStackTrace(this, this.constructor);
   this.name = this.constructor.name;
-  this.message = util.format("Event stream '%s' is deleted.", stream);
-  this.stream = stream;
+  if (typeof streamOrTransactionId === 'string') {
+    this.message = util.format("Event stream '%s' is deleted.", streamOrTransactionId);
+    this.stream = streamOrTransactionId;
+    Object.freeze(this);
+    return;
+  }
+  if (Long.isLong(streamOrTransactionId)) {
+    this.message = util.format("Stream is deleted for transaction %s.", streamOrTransactionId);
+    this.transactionId = streamOrTransactionId;
+    Object.freeze(this);
+    return;
+  }
+  throw new TypeError("second argument must be a stream name or transaction Id.");
 }
 util.inherits(StreamDeletedError, Error);
 

src/errors/wrongExpectedVersionError.js

@@ -1,12 +1,24 @@
 var util = require('util');
+var Long = require('long');
 
-function WrongExpectedVersionError(action, stream, expectedVersion) {
+function WrongExpectedVersionError(action, streamOrTransactionId, expectedVersion) {
   Error.captureStackTrace(this, this.constructor);
   this.name = this.constructor.name;
-  this.message = util.format("%s failed due to WrongExpectedVersion. Stream: %s Expected version: %d.", action, stream, expectedVersion);
   this.action = action;
-  this.stream = stream;
+  if (typeof streamOrTransactionId === 'string') {
+    this.message = util.format("%s failed due to WrongExpectedVersion. Stream: %s Expected version: %d.", action, streamOrTransactionId, expectedVersion);
+    this.stream = streamOrTransactionId;
     this.expectedVersion = expectedVersion;
+    Object.freeze(this);
+    return;
+  }
+  if (Long.isLong(streamOrTransactionId)) {
+    this.message = util.format("%s transaction failed due to WrongExpectedVersion. Transaction Id: %s.", action, streamOrTransactionId);
+    this.transactionId = streamOrTransactionId;
+    Object.freeze(this);
+    return;
+  }
+  throw new TypeError("second argument must be a stream name or a transaction Id.");
 }
 util.inherits(WrongExpectedVersionError, Error);
 

src/eventData.js

@@ -1,17 +1,14 @@
 var uuid = require('uuid');
 
+const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function isValidId(id) {
   if (typeof id !== 'string') return false;
-  var buf = uuid.parse(id);
-  var valid = false;
-  for(var i=0;i<buf.length;i++)
-    if (buf[i] !== 0)
-      valid = true;
-  return valid;
+  return uuidRegex.test(id);
 }
 
 /**
  * Create an EventData
+ * @private
  * @param {string} eventId
  * @param {string} type
  * @param {boolean} [isJson]
@@ -31,6 +28,7 @@ function EventData(eventId, type, isJson, data, metadata) {
   this.isJson = isJson || false;
   this.data = data || new Buffer(0);
   this.metadata = metadata || new Buffer(0);
+  Object.freeze(this);
 }
 
 module.exports = EventData;

src/eventStoreAllCatchUpSubscription.js

@@ -24,14 +24,10 @@ EventStoreAllCatchUpSubscription.prototype._readEventsTill = function(
   var self = this;
 
   function processEvents(events, index) {
-    index = index || 0;
     if (index >= events.length) return Promise.resolve();
     if (events[index].originalPosition === null) throw new Error("Subscription event came up with no OriginalPosition.");
 
-    return new Promise(function(resolve, reject) {
-          self._tryProcess(events[index]);
-          resolve();
-        })
+    return self._tryProcess(events[index])
         .then(function() {
           return processEvents(events, index + 1);
         });
@@ -40,15 +36,12 @@ EventStoreAllCatchUpSubscription.prototype._readEventsTill = function(
   function readNext() {
     return connection.readAllEventsForward(self._nextReadPosition, self.readBatchSize, resolveLinkTos, userCredentials)
         .then(function(slice) {
-          return processEvents(slice.events)
+          return processEvents(slice.events, 0)
               .then(function() {
                 self._nextReadPosition = slice.nextPosition;
-                var done = lastCommitPosition === null
+                return (lastCommitPosition === null)
                     ? slice.isEndOfStream
                     : slice.nextPosition.compareTo(new results.Position(lastCommitPosition, lastCommitPosition)) >= 0;
-                if (!done && slice.isEndOfStream)
-                    return Promise.resolve(done).delay(10);
-                return Promise.resolve(done);
               });
         })
         .then(function(done) {
@@ -69,9 +62,10 @@ EventStoreAllCatchUpSubscription.prototype._readEventsTill = function(
 
 EventStoreAllCatchUpSubscription.prototype._tryProcess = function(e) {
   var processed = false;
+  var promise;
   if (e.originalPosition.compareTo(this._lastProcessedPosition) > 0)
   {
-    this._eventAppeared(this, e);
+    promise = this._eventAppeared(this, e);
     this._lastProcessedPosition = e.originalPosition;
     processed = true;
   }
@@ -79,6 +73,7 @@ EventStoreAllCatchUpSubscription.prototype._tryProcess = function(e) {
     this._log.debug("Catch-up Subscription to %s: %s event (%s, %d, %s @ %s).",
         this.streamId || '<all>', processed ? "processed" : "skipping",
         e.originalEvent.eventStreamId, e.originalEvent.eventNumber, e.originalEvent.eventType, e.originalPosition);
+  return (promise && promise.then) ? promise : Promise.resolve();
 };
 
 module.exports = EventStoreAllCatchUpSubscription;

src/eventStoreCatchUpSubscription.js

@@ -209,26 +209,35 @@ EventStoreCatchUpSubscription.prototype._ensureProcessingPushQueue = function()
 
 EventStoreCatchUpSubscription.prototype._processLiveQueue = function() {
   var ev = this._liveQueue.shift();
-  //TODO: possible blocking while, use when
-  while(ev) {
+  if (!ev) {
+    this._isProcessing = false;
+    return;
+  }
   if (ev instanceof DropSubscriptionEvent) {
     if (!this._dropData) this._dropData = {reason: SubscriptionDropReason.Unknown, error: new Error("Drop reason not specified.")};
     this._dropSubscription(this._dropData.reason, this._dropData.error);
     this._isProcessing = false;
     return;
   }
-
+  var promise;
   try {
-      this._tryProcess(ev);
+    promise = this._tryProcess(ev);
   }
   catch(err) {
     this._dropSubscription(SubscriptionDropReason.EventHandlerException, err);
+    this._isProcessing = false;
     return;
   }
-    ev = this._liveQueue.shift();
+  if (promise && promise.then) {
+    var self = this;
+    promise
+      .then(this._processLiveQueue.bind(this), function(err) {
+        self._dropSubscription(SubscriptionDropReason.EventHandlerException, err);
+        self._isProcessing = false;
+      });
+  } else {
+    setImmediate(this._processLiveQueue.bind(this));
   }
-
-  this._isProcessing = false;
 };
 
 EventStoreCatchUpSubscription.prototype._dropSubscription = function(reason, error) {

src/eventStoreConnection.js

@@ -1,6 +1,8 @@
 var EventStoreNodeConnection = require('./eventStoreNodeConnection');
 var StaticEndpointDiscoverer = require('./core/staticEndpointDiscoverer');
+var ClusterDnsEndPointDiscoverer = require('./core/clusterDnsEndPointDiscoverer');
 var NoopLogger = require('./common/log/noopLogger');
+var ensure = require('./common/utils/ensure');
 
 var defaultConnectionSettings = {
   log: new NoopLogger(),
@@ -25,7 +27,13 @@ var defaultConnectionSettings = {
   failOnNoServerResponse: false,
   heartbeatInterval: 750,
   heartbeatTimeout: 1500,
-  clientConnectionTimeout: 1000
+  clientConnectionTimeout: 1000,
+
+  // Cluster Settings
+  clusterDns: '',
+  maxDiscoverAttempts: 10,
+  externalGossipPort: 0,
+  gossipTimeout: 1000
 };
 
 
@@ -40,16 +48,86 @@ function merge(a,b) {
   return c;
 }
 
+function createFromTcpEndpoint(settings, tcpEndpoint, connectionName) {
+  if (!tcpEndpoint.port || !tcpEndpoint.host) throw new TypeError('endPoint object must have host and port properties.');
+  var mergedSettings = merge(defaultConnectionSettings, settings || {});
+  var endpointDiscoverer = new StaticEndpointDiscoverer(tcpEndpoint, settings.useSslConnection);
+  return new EventStoreNodeConnection(mergedSettings, null, endpointDiscoverer, connectionName || null);
+}
+
+function createFromStringEndpoint(settings, endPoint, connectionName) {
+  var m = endPoint.match(/^(tcp|discover):\/\/([^:]+):?(\d+)?$/);
+  if (!m) throw new Error('endPoint string must be tcp://hostname[:port] or discover://dns[:port]');
+  var scheme = m[1];
+  var host = m[2] || null;
+  var port = m[3] ? parseInt(m[3]) : null;
+  if (scheme === 'tcp') {
+    var tcpEndpoint = {
+      host: host,
+      port: port || 1113
+    };
+    return createFromTcpEndpoint(settings, tcpEndpoint, connectionName);
+  }
+  if (scheme === 'discover') {
+    return createFromClusterDns(settings, host, port || 2113, connectionName);
+  }
+  throw new Error('Invalid scheme for endPoint: ' + scheme);
+}
+
+function createFromClusterDns(connectionSettings, clusterDns, externalGossipPort, connectionName) {
+  ensure.notNull(connectionSettings, "connectionSettings");
+  ensure.notNull(clusterDns, "clusterDns");
+  var mergedSettings = merge(defaultConnectionSettings, connectionSettings || {});
+  var clusterSettings = {
+    clusterDns: clusterDns,
+    gossipSeeds: null,
+    externalGossipPort: externalGossipPort,
+    maxDiscoverAttempts: mergedSettings.maxDiscoverAttempts,
+    gossipTimeout: mergedSettings.gossipTimeout
+  };
+  var endPointDiscoverer = new ClusterDnsEndPointDiscoverer(mergedSettings.log,
+    clusterSettings.clusterDns,
+    clusterSettings.maxDiscoverAttempts,
+    clusterSettings.externalGossipPort,
+    clusterSettings.gossipSeeds,
+    clusterSettings.gossipTimeout
+  );
+  return new EventStoreNodeConnection(mergedSettings, clusterSettings, endPointDiscoverer, connectionName);
+}
+
+function createFromGossipSeeds(connectionSettings, gossipSeeds, connectionName) {
+  ensure.notNull(connectionSettings, "connectionSettings");
+  ensure.notNull(gossipSeeds, "gossipSeeds");
+  var mergedSettings = merge(defaultConnectionSettings, connectionSettings || {});
+  var clusterSettings = {
+    clusterDns: '',
+    gossipSeeds: gossipSeeds,
+    externalGossipPort: 0,
+    maxDiscoverAttempts: mergedSettings.maxDiscoverAttempts,
+    gossipTimeout: mergedSettings.gossipTimeout
+  };
+  var endPointDiscoverer = new ClusterDnsEndPointDiscoverer(mergedSettings.log,
+    clusterSettings.clusterDns,
+    clusterSettings.maxDiscoverAttempts,
+    clusterSettings.externalGossipPort,
+    clusterSettings.gossipSeeds,
+    clusterSettings.gossipTimeout
+  );
+  return new EventStoreNodeConnection(mergedSettings, clusterSettings, endPointDiscoverer, connectionName);
+}
+
 /**
  * Create an EventStore connection
+ * @public
+ * @alias createConnection
  * @param {object} settings
- * @param {object} tcpEndPoint
+ * @param {string|object|array} endPointOrGossipSeeds
  * @param {string} [connectionName]
  * @returns {EventStoreNodeConnection}
  */
-module.exports.create = function(settings, tcpEndPoint, connectionName) {
-  //TODO: cluster connection
-  var mergedSettings = merge(defaultConnectionSettings, settings || {});
-  var endpointDiscoverer = new StaticEndpointDiscoverer(tcpEndPoint, settings.useSslConnection);
-  return new EventStoreNodeConnection(mergedSettings, endpointDiscoverer, connectionName || null);
+module.exports.create = function(settings, endPointOrGossipSeeds, connectionName) {
+  if (Array.isArray(endPointOrGossipSeeds)) return createFromGossipSeeds(settings, endPointOrGossipSeeds, connectionName);
+  if (typeof endPointOrGossipSeeds === 'object') return createFromTcpEndpoint(settings, endPointOrGossipSeeds, connectionName);
+  if (typeof endPointOrGossipSeeds === 'string') return createFromStringEndpoint(settings, endPointOrGossipSeeds, connectionName);
+  throw new TypeError('endPointOrGossipSeeds must be an object, a string or an array.');
 };

src/eventStoreNodeConnection.js

@@ -33,15 +33,14 @@ var EventData = require('./eventData');
 const MaxReadSize = 4096;
 
 /**
- * @param settings
- * @param endpointDiscoverer
- * @param connectionName
+ * @protected
  * @constructor
- * @property {string} connectionName
  */
-function EventStoreNodeConnection(settings, endpointDiscoverer, connectionName) {
+function EventStoreNodeConnection(settings, clusterSettings, endpointDiscoverer, connectionName) {
+  EventEmitter.call(this);
   this._connectionName = connectionName || ['ES-', uuid.v4()].join('');
   this._settings = settings;
+  this._clusterSettings = clusterSettings;
   this._endpointDiscoverer = endpointDiscoverer;
   this._handler = new EventStoreConnectionLogicHandler(this, settings);
 
@@ -61,6 +60,9 @@ function EventStoreNodeConnection(settings, endpointDiscoverer, connectionName)
   this._handler.on('error', function(e) {
     self.emit('error', e);
   });
+  this._handler.on('heartbeatInfo', function(e) {
+    self.emit('heartbeatInfo', e);
+  });
 }
 util.inherits(EventStoreNodeConnection, EventEmitter);
 
@@ -71,6 +73,8 @@ Object.defineProperty(EventStoreNodeConnection.prototype, 'connectionName', {
 });
 
 /**
+ * Start connection task
+ * @public
  * @returns {Promise}
  */
 EventStoreNodeConnection.prototype.connect = function() {
@@ -85,12 +89,17 @@ EventStoreNodeConnection.prototype.connect = function() {
   });
 };
 
+/**
+ * Close connection
+ * @public
+ */
 EventStoreNodeConnection.prototype.close = function() {
   this._handler.enqueueMessage(new messages.CloseConnectionMessage("Connection close requested by client.", null));
 };
 
 /**
  * Delete a stream (async)
+ * @public
  * @param {string} stream
  * @param {number} expectedVersion
  * @param {boolean} [hardDelete]
@@ -118,6 +127,7 @@ EventStoreNodeConnection.prototype.deleteStream = function(stream, expectedVersi
 
 /**
  * Append events to a stream (async)
+ * @public
  * @param {string} stream The name of the stream to which to append.
  * @param {number} expectedVersion The version at which we currently expect the stream to be in order that an optimistic concurrency check can be performed.
  * @param {EventData[]|EventData} events The event(s) to append.
@@ -146,13 +156,17 @@ EventStoreNodeConnection.prototype.appendToStream = function(stream, expectedVer
 
 /**
  * Start a transaction (async)
+ * @public
  * @param {string} stream
  * @param {number} expectedVersion
  * @param {UserCredentials} [userCredentials]
  * @returns {Promise.<EventStoreTransaction>}
  */
 EventStoreNodeConnection.prototype.startTransaction = function(stream, expectedVersion, userCredentials) {
-  //TODO validations
+  ensure.notNullOrEmpty(stream, "stream");
+  ensure.isInteger(expectedVersion, "expectedVersion");
+  userCredentials = userCredentials || null;
+
   var self = this;
   return new Promise(function(resolve, reject) {
     function cb(err, result) {
@@ -160,23 +174,29 @@ EventStoreNodeConnection.prototype.startTransaction = function(stream, expectedV
       resolve(result);
     }
     var operation = new StartTransactionOperation(self._settings.log, cb, self._settings.requireMaster, stream,
-        expectedVersion, self, userCredentials || null);
+        expectedVersion, self, userCredentials);
     self._enqueueOperation(operation);
   });
 };
 
 /**
  * Continue a transaction
+ * @public
  * @param {number} transactionId
  * @param {UserCredentials} userCredentials
  * @returns {EventStoreTransaction}
  */
 EventStoreNodeConnection.prototype.continueTransaction = function(transactionId, userCredentials) {
-  //TODO validations
+  ensure.nonNegative(transactionId, "transactionId");
+
   return new EventStoreTransaction(transactionId, userCredentials, this);
 };
 
 EventStoreNodeConnection.prototype.transactionalWrite = function(transaction, events, userCredentials) {
+  ensure.isTypeOf(EventStoreTransaction, transaction, "transaction");
+  ensure.isArrayOf(EventData, events, "events");
+  userCredentials = userCredentials || null;
+
   var self = this;
   return new Promise(function(resolve, reject) {
     function cb(err) {
@@ -189,7 +209,16 @@ EventStoreNodeConnection.prototype.transactionalWrite = function(transaction, ev
   });
 };
 
+/**
+ * Commit a transaction
+ * @public
+ * @param transaction
+ * @param userCredentials
+ * @returns {Promise.<WriteResult>}
+ */
 EventStoreNodeConnection.prototype.commitTransaction = function(transaction, userCredentials) {
+  ensure.isTypeOf(EventStoreTransaction, transaction, "transaction");
+
   var self = this;
   return new Promise(function(resolve, reject) {
     function cb(err, result) {
@@ -204,6 +233,7 @@ EventStoreNodeConnection.prototype.commitTransaction = function(transaction, use
 
 /**
  * Read a single event (async)
+ * @public
  * @param {string} stream
  * @param {number} eventNumber
  * @param {boolean} [resolveLinkTos]
@@ -236,6 +266,7 @@ EventStoreNodeConnection.prototype.readEvent = function(stream, eventNumber, res
 
 /**
  * Reading a specific stream forwards (async)
+ * @public
  * @param {string} stream
  * @param {number} start
  * @param {number} count
@@ -269,6 +300,7 @@ EventStoreNodeConnection.prototype.readStreamEventsForward = function(
 
 /**
  * Reading a specific stream backwards (async)
+ * @public
  * @param {string} stream
  * @param {number} start
  * @param {number} count
@@ -301,6 +333,7 @@ EventStoreNodeConnection.prototype.readStreamEventsBackward = function(
 
 /**
  * Reading all events forwards (async)
+ * @public
  * @param {Position} position
  * @param {number} maxCount
  * @param {boolean} [resolveLinkTos]
@@ -331,6 +364,7 @@ EventStoreNodeConnection.prototype.readAllEventsForward = function(
 
 /**
  * Reading all events backwards (async)
+ * @public
  * @param {Position} position
  * @param {number} maxCount
  * @param {boolean} [resolveLinkTos]
@@ -361,6 +395,7 @@ EventStoreNodeConnection.prototype.readAllEventsBackward = function(
 
 /**
  * Subscribe to a stream (async)
+ * @public
  * @param {!string} stream
  * @param {!boolean} resolveLinkTos
  * @param {function} eventAppeared
@@ -371,8 +406,10 @@ EventStoreNodeConnection.prototype.readAllEventsBackward = function(
 EventStoreNodeConnection.prototype.subscribeToStream = function(
     stream, resolveLinkTos, eventAppeared, subscriptionDropped, userCredentials
 ) {
-  if (typeof stream !== 'string' || stream === '') throw new TypeError("stream must be a non-empty string.");
-  if (typeof eventAppeared !== 'function') throw new TypeError("eventAppeared must be a function.");
+  ensure.notNullOrEmpty(stream, "stream");
+  ensure.isTypeOf(Function, eventAppeared, "eventAppeared");
+  if (subscriptionDropped)
+    ensure.isTypeOf(Function, subscriptionDropped, "subscriptionDropped");
 
   var self = this;
   return new Promise(function(resolve,reject) {
@@ -388,6 +425,8 @@ EventStoreNodeConnection.prototype.subscribeToStream = function(
 };
 
 /**
+ * Subscribe to a stream from position
+ * @public
  * @param {!string} stream
  * @param {?number} lastCheckpoint
  * @param {!boolean} resolveLinkTos
@@ -403,6 +442,7 @@ EventStoreNodeConnection.prototype.subscribeToStreamFrom = function(
     userCredentials, readBatchSize
 ) {
   if (typeof stream !== 'string' || stream === '') throw new TypeError("stream must be a non-empty string.");
+  if (lastCheckpoint !== null && typeof lastCheckpoint !== 'number') throw new TypeError("lastCheckpoint must be a number or null.");
   if (typeof eventAppeared !== 'function') throw new TypeError("eventAppeared must be a function.");
 
   var catchUpSubscription =
@@ -416,6 +456,7 @@ EventStoreNodeConnection.prototype.subscribeToStreamFrom = function(
 
 /**
  * Subscribe to all (async)
+ * @public
  * @param {!boolean} resolveLinkTos
  * @param {!function} eventAppeared
  * @param {function} [subscriptionDropped]
@@ -442,6 +483,7 @@ EventStoreNodeConnection.prototype.subscribeToAll = function(
 
 /**
  * Subscribe to all from
+ * @public
  * @param {?Position} lastCheckpoint
  * @param {!boolean} resolveLinkTos
  * @param {!function} eventAppeared
@@ -455,7 +497,10 @@ EventStoreNodeConnection.prototype.subscribeToAllFrom = function(
     lastCheckpoint, resolveLinkTos, eventAppeared, liveProcessingStarted, subscriptionDropped,
     userCredentials, readBatchSize
 ) {
-  if (typeof eventAppeared !== 'function') throw new TypeError("eventAppeared must be a function.");
+  ensure.isTypeOf(results.Position, lastCheckpoint, "lastCheckpoint", true);
+  ensure.isTypeOf(Function, eventAppeared, "eventAppeared", false);
+  if (liveProcessingStarted) ensure.isTypeOf(Function, liveProcessingStarted, "liveProcessingStarted", false);
+  if (subscriptionDropped) ensure.isTypeOf(Function, subscriptionDropped, "subscriptionDropped", false);
 
   var catchUpSubscription =
       new EventStoreAllCatchUpSubscription(this, this._settings.log, lastCheckpoint, resolveLinkTos,
@@ -467,6 +512,7 @@ EventStoreNodeConnection.prototype.subscribeToAllFrom = function(
 
 /**
  * Subscribe to a persistent subscription
+ * @public
  * @param {string} stream
  * @param {string} groupName
  * @param {function} eventAppeared
@@ -474,6 +520,7 @@ EventStoreNodeConnection.prototype.subscribeToAllFrom = function(
  * @param {UserCredentials} [userCredentials]
  * @param {number} [bufferSize]
  * @param {boolean} [autoAck]
+ * @return {Promise<EventStorePersistentSubscription>}
  */
 EventStoreNodeConnection.prototype.connectToPersistentSubscription = function(
     stream, groupName, eventAppeared, subscriptionDropped, userCredentials, bufferSize, autoAck
@@ -490,12 +537,12 @@ EventStoreNodeConnection.prototype.connectToPersistentSubscription = function(
   var subscription = new EventStorePersistentSubscription(
       groupName, stream, eventAppeared, subscriptionDropped, userCredentials, this._settings.log,
       this._settings.verboseLogging, this._settings, this._handler, bufferSize, autoAck);
-  subscription.start();
-
-  return subscription;
+  return subscription.start();
 };
 
 /**
+ * Create a persistent subscription
+ * @public
  * @param {string} stream
  * @param {string} groupName
  * @param {PersistentSubscriptionSettings} settings
@@ -519,9 +566,11 @@ EventStoreNodeConnection.prototype.createPersistentSubscription = function(strea
 };
 
 /**
+ * Update a persistent subscription
+ * @public
  * @param {string} stream
  * @param {string} groupName
- * @param {string} settings
+ * @param {PersistentSubscriptionSettings} settings
  * @param {UserCredentials} [userCredentials]
  * @returns {Promise.<PersistentSubscriptionUpdateResult>}
  */
@@ -541,6 +590,8 @@ EventStoreNodeConnection.prototype.updatePersistentSubscription = function(strea
 };
 
 /**
+ * Delete a persistent subscription
+ * @public
  * @param {string} stream
  * @param {string} groupName
  * @param {UserCredentials} [userCredentials]
@@ -560,6 +611,10 @@ EventStoreNodeConnection.prototype.deletePersistentSubscription = function(strea
   });
 };
 
+/**
+ * Set stream metadata
+ * @private
+ */
 EventStoreNodeConnection.prototype.setStreamMetadata = function() {
   //TODO: set stream metadata (non-raw)
   throw new Error("Not implemented.");
@@ -567,6 +622,7 @@ EventStoreNodeConnection.prototype.setStreamMetadata = function() {
 
 /**
  * Set stream metadata with raw object (async)
+ * @public
  * @param {string} stream
  * @param {number} expectedMetastreamVersion
  * @param {object} metadata
@@ -594,6 +650,12 @@ EventStoreNodeConnection.prototype.setStreamMetadataRaw = function(
   });
 };
 
+/**
+ * Get stream metadata
+ * @private
+ * @param stream
+ * @param userCredentials
+ */
 EventStoreNodeConnection.prototype.getStreamMetadata = function(stream, userCredentials) {
   //TODO: get stream metadata (non-raw)
   throw new Error("Not implemented.");
@@ -601,6 +663,7 @@ EventStoreNodeConnection.prototype.getStreamMetadata = function(stream, userCred
 
 /**
  * Get stream metadata as raw object (async)
+ * @public
  * @param {string} stream
  * @param {UserCredentials} [userCredentials]
  * @returns {Promise.<RawStreamMetadataResult>}
@@ -626,6 +689,10 @@ EventStoreNodeConnection.prototype.getStreamMetadataRaw = function(stream, userC
       });
 };
 
+/**
+ * Set system settings
+ * @private
+ */
 EventStoreNodeConnection.prototype.setSystemSettings = function() {
   //TODO: set system settings
   throw new Error("Not implemented.");

src/eventStorePersistentSubscriptionBase.js

@@ -35,10 +35,12 @@ EventStorePersistentSubscriptionBase.prototype.start = function() {
   this._stopped = false;
 
   var self = this;
-  this._startSubscription(this._subscriptionId, this._streamId, this._bufferSize, this._userCredentials,
+  return this._startSubscription(this._subscriptionId, this._streamId, this._bufferSize, this._userCredentials,
                           this._onEventAppeared.bind(this), this._onSubscriptionDropped.bind(this), this._settings)
       .then(function(subscription) {
+        console.log('Subscription started.');
         self._subscription = subscription;
+        return self;
       });
 };
 
@@ -77,6 +79,7 @@ EventStorePersistentSubscriptionBase.prototype.fail = function(events, action, r
   this._subscription.notifyEventsFailed(ids, action, reason);
 };
 
+//TODO: this should return a promise
 EventStorePersistentSubscriptionBase.prototype.stop = function() {
   if (this._verbose) this._log.debug("Persistent Subscription to %s: requesting stop...", this._streamId);
   this._enqueueSubscriptionDropNotification(SubscriptionDropReason.UserInitiated, null);
@@ -109,43 +112,56 @@ EventStorePersistentSubscriptionBase.prototype._enqueue = function(resolvedEvent
   }
 };
 
+function runAsync(fn) {
+  try {
+    return Promise.resolve(fn());
+  } catch(e) {
+    return Promise.reject(e);
+  }
+}
+
 EventStorePersistentSubscriptionBase.prototype._processQueue = function() {
-  //do
-  //{
-    var e = this._queue.shift();
-    while (e)
-    {
-      if (e instanceof DropSubscriptionEvent) // drop subscription artificial ResolvedEvent
+  var ev = this._queue.shift();
+  if (!ev) {
+    this._isProcessing = false;
+    return;
+  }
+
+  if (ev instanceof DropSubscriptionEvent) // drop subscription artificial ResolvedEvent
   {
     if (this._dropData === null) throw new Error("Drop reason not specified.");
     this._dropSubscription(this._dropData.reason, this._dropData.error);
+    this._isProcessing = false;
     return;
   }
   if (this._dropData !== null)
   {
     this._dropSubscription(this._dropData.reason, this._dropData.error);
-        return;
-      }
-      try
-      {
-        this._eventAppeared(this, e);
-        if(this._autoAck)
-          this._subscription.notifyEventsProcessed([e.originalEvent.eventId]);
-        if (this._verbose)
-          this._log.debug("Persistent Subscription to %s: processed event (%s, %d, %s @ %d).",
-              this._streamId, e.originalEvent.eventStreamId, e.originalEvent.eventNumber, e.originalEvent.eventType,
-              e.originalEventNumber);
-      }
-      catch (err)
-      {
-        //TODO GFY should we autonak here?
-        this._dropSubscription(SubscriptionDropReason.EventHandlerException, err);
-        return;
-      }
-      e = this._queue.shift();
-    }
     this._isProcessing = false;
-  //} while (_queue.Count > 0 && Interlocked.CompareExchange(ref _isProcessing, 1, 0) == 0);
+    return;
+  }
+  var self = this;
+  runAsync(function() {
+    return self._eventAppeared(self, ev);
+  })
+    .then(function() {
+      if(self._autoAck)
+        self._subscription.notifyEventsProcessed([ev.originalEvent.eventId]);
+      if (self._verbose)
+        self._log.debug("Persistent Subscription to %s: processed event (%s, %d, %s @ %d).",
+          self._streamId, ev.originalEvent.eventStreamId, ev.originalEvent.eventNumber, ev.originalEvent.eventType,
+          ev.originalEventNumber);
+      return false;
+    }, function(err) {
+      //TODO GFY should we autonak here?
+      self._dropSubscription(SubscriptionDropReason.EventHandlerException, err);
+      self._isProcessing = false;
+      return true;
+    })
+    .then(function (faulted) {
+      if (faulted) return;
+      self._processQueue();
+    });
 };
 
 EventStorePersistentSubscriptionBase.prototype._dropSubscription = function(reason, error) {
@@ -158,8 +174,13 @@ EventStorePersistentSubscriptionBase.prototype._dropSubscription = function(reas
 
     if (this._subscription !== null)
       this._subscription.unsubscribe();
-    if (this._subscriptionDropped !== null)
+    if (this._subscriptionDropped !== null) {
+      try {
         this._subscriptionDropped(this, reason, error);
+      } catch (e) {
+        this._log.error(e, "Persistent Subscription to %s: subscriptionDropped callback failed.", this._streamId);
+      }
+    }
     this._stopped = true;
   }
 };

src/eventStoreStreamCatchUpSubscription.js

@@ -14,24 +14,26 @@ function EventStoreStreamCatchUpSubscription(
 
   //Ensure.NotNullOrEmpty(streamId, "streamId");
 
-  this._lastProcessedEventNumber = fromEventNumberExclusive || -1;
-  this._nextReadEventNumber = fromEventNumberExclusive || 0;
+  this._lastProcessedEventNumber = fromEventNumberExclusive === null ? -1 : fromEventNumberExclusive;
+  this._nextReadEventNumber = fromEventNumberExclusive === null ? 0 : fromEventNumberExclusive + 1;
 }
 util.inherits(EventStoreStreamCatchUpSubscription, EventStoreCatchUpSubscription);
 
+function delay(ms, result) {
+  return new Promise(function (resolve, reject) {
+    setTimeout(resolve, ms, result);
+  })
+}
+
 EventStoreStreamCatchUpSubscription.prototype._readEventsTill = function(
     connection, resolveLinkTos, userCredentials, lastCommitPosition, lastEventNumber
 ) {
   var self = this;
 
   function processEvents(events, index) {
-    index = index || 0;
     if (index >= events.length) return Promise.resolve();
 
-    return new Promise(function(resolve, reject) {
-          self._tryProcess(events[index]);
-          resolve();
-        })
+    return self._tryProcess(events[index])
         .then(function() {
           return processEvents(events, index + 1);
         });
@@ -42,12 +44,12 @@ EventStoreStreamCatchUpSubscription.prototype._readEventsTill = function(
         .then(function(slice) {
           switch(slice.status) {
             case SliceReadStatus.Success:
-              return processEvents(slice.events)
+              return processEvents(slice.events, 0)
                   .then(function() {
                     self._nextReadEventNumber = slice.nextEventNumber;
                     var done = Promise.resolve(lastEventNumber === null ? slice.isEndOfStream : slice.nextEventNumber > lastEventNumber);
                     if (!done && slice.isEndOfStream)
-                        return done.delay(10);
+                        return delay(100, false);
                     return done;
                   });
               break;
@@ -77,8 +79,9 @@ EventStoreStreamCatchUpSubscription.prototype._readEventsTill = function(
 
 EventStoreStreamCatchUpSubscription.prototype._tryProcess = function(e) {
   var processed = false;
+  var promise;
   if (e.originalEventNumber > this._lastProcessedEventNumber) {
-    this._eventAppeared(this, e);
+    promise = this._eventAppeared(this, e);
     this._lastProcessedEventNumber = e.originalEventNumber;
     processed = true;
   }
@@ -86,6 +89,7 @@ EventStoreStreamCatchUpSubscription.prototype._tryProcess = function(e) {
     this._log.debug("Catch-up Subscription to %s: %s event (%s, %d, %s @ %d).",
         this.isSubscribedToAll ? '<all>' : this.streamId, processed ? "processed" : "skipping",
         e.originalEvent.eventStreamId, e.originalEvent.eventNumber, e.originalEvent.eventType, e.originalEventNumber)
+  return (promise && promise.then) ? promise : Promise.resolve();
 };
 
 

src/eventStoreTransaction.js

@@ -33,13 +33,13 @@ EventStoreTransaction.prototype.commit = function() {
 
 /**
  * Write events (async)
- * @param {Array.<EventData>} events
+ * @param {EventData|EventData[]} eventOrEvents
  * @returns {Promise}
  */
-EventStoreTransaction.prototype.write = function(events) {
+EventStoreTransaction.prototype.write = function(eventOrEvents) {
   if (this._isRolledBack) throw new Error("can't write to a rolledback transaction");
   if (this._isCommitted) throw new Error("Transaction is already committed");
-  if (!Array.isArray(events)) throw new Error("events must be an array.");
+  var events = Array.isArray(eventOrEvents) ? eventOrEvents : [eventOrEvents];
   return this._connection.transactionalWrite(this, events);
 };
 

src/gossipSeed.js

@@ -0,0 +1,6 @@
+module.exports = function GossipSeed(endPoint, hostName) {
+  if (typeof endPoint !== 'object' || !endPoint.host || !endPoint.port) throw new TypeError('endPoint must be have host and port properties.');
+  this.endPoint = endPoint;
+  this.hostName = hostName;
+  Object.freeze(this);
+};

src/persistentSubscriptionSettings.js

@@ -21,6 +21,8 @@ function PersistentSubscriptionSettings(
   this.namedConsumerStrategy = namedConsumerStrategy;
 }
 
-module.exports.create = function() {
+PersistentSubscriptionSettings.create = function() {
   return new PersistentSubscriptionSettings(false, -1, false, 30000, 500, 500, 10, 20, 2000, 10, 1000, 0, SystemConsumerStrategies.RoundRobin);
 };
+
+module.exports = PersistentSubscriptionSettings;

src/projections/projectionDetails.js

@@ -0,0 +1,56 @@
+function ProjectionDetails(
+  coreProcessingTime,
+  version,
+  epoch,
+  effectiveName,
+  writesInProgress,
+  readsInProgress,
+  partitionsCached,
+  status,
+  stateReason,
+  name,
+  mode,
+  position,
+  progress,
+  lastCheckpoint,
+  eventsProcessedAfterRestart,
+  statusUrl,
+  stateUrl,
+  resultUrl,
+  queryUrl,
+  enableCommandUrl,
+  disableCommandUrl,
+  checkpointStatus,
+  bufferedEvents,
+  writePendingEventsBeforeCheckpoint,
+  writePendingEventsAfterCheckpoint
+) {
+  this.coreProcessingTime = coreProcessingTime;
+  this.version = version;
+  this.epoch = epoch;
+  this.effectiveName = effectiveName;
+  this.writesInProgress = writesInProgress;
+  this.readsInProgress = readsInProgress;
+  this.partitionsCached = partitionsCached;
+  this.status = status;
+  this.stateReason = stateReason;
+  this.name = name;
+  this.mode = mode;
+  this.position = position;
+  this.progress = progress;
+  this.lastCheckpoint = lastCheckpoint;
+  this.eventsProcessedAfterRestart = eventsProcessedAfterRestart;
+  this.statusUrl = statusUrl;
+  this.stateUrl = stateUrl;
+  this.resultUrl = resultUrl;
+  this.queryUrl = queryUrl;
+  this.enableCommandUrl = enableCommandUrl;
+  this.disableCommandUrl = disableCommandUrl;
+  this.checkpointStatus = checkpointStatus;
+  this.bufferedEvents = bufferedEvents;
+  this.writePendingEventsBeforeCheckpoint = writePendingEventsBeforeCheckpoint;
+  this.writePendingEventsAfterCheckpoint = writePendingEventsAfterCheckpoint;
+  Object.freeze(this);
+}
+
+module.exports = ProjectionDetails;

src/projections/projectionsClient.js

@@ -0,0 +1,170 @@
+const http = require('http');
+const url = require('url');
+const util = require('util');
+const ProjectionCommandFailedError = require('../errors/projectionCommandFailedError');
+
+const HTTP_OK = 200;
+const HTTP_CREATED = 201;
+
+function safeParseJson(json) {
+  try {
+    return JSON.parse(json);
+  } catch(e) {
+    return null;
+  }
+}
+
+function ProjectionsClient(log, operationTimeout) {
+  this._log = log;
+  this._operationTimeout = operationTimeout;
+}
+
+ProjectionsClient.prototype.enable = function(httpEndPoint, name, userCredentials) {
+  return this.sendPost(httpEndPoint + '/projection/' + name + '/command/enable', '', userCredentials, HTTP_OK);
+};
+
+ProjectionsClient.prototype.disable = function(httpEndPoint, name, userCredentials) {
+  return this.sendPost(httpEndPoint + '/projection/' + name + '/command/disable', '', userCredentials, HTTP_OK);
+};
+
+ProjectionsClient.prototype.abort = function(httpEndPoint, name, userCredentials) {
+  return this.sendPost(httpEndPoint + '/projection/' + name + '/command/abort', '', userCredentials, HTTP_OK);
+};
+
+ProjectionsClient.prototype.createOneTime = function(httpEndPoint, query, userCredentials) {
+  return this.sendPost(httpEndPoint + '/projections/onetime?type=JS', query, userCredentials, HTTP_CREATED);
+};
+
+ProjectionsClient.prototype.createTransient = function(httpEndPoint, name, query, userCredentials) {
+  return this.sendPost(httpEndPoint + '/projections/transient?name=' + name + '&type=JS', query, userCredentials, HTTP_CREATED);
+};
+
+ProjectionsClient.prototype.createContinuous = function(httpEndPoint, name, query, trackEmittedStreams, userCredentials) {
+  return this.sendPost(httpEndPoint + '/projections/continuous?name=' + name + '&type=JS&emit=1&trackEmittedStreams=' + trackEmittedStreams, query, userCredentials, HTTP_CREATED);
+};
+
+ProjectionsClient.prototype.listAll = function(httpEndPoint, userCredentials) {
+  return this.sendGet(httpEndPoint + '/projections/any', userCredentials, HTTP_OK)
+    .then(function (json) {
+      var r = safeParseJson(json);
+      if (r && r.projections) return r.projections;
+      return null;
+    });
+};
+
+ProjectionsClient.prototype.listOneTime = function(httpEndPoint, userCredentials) {
+  return this.sendGet(httpEndPoint + '/projections/onetime', userCredentials, HTTP_OK)
+    .then(function (json) {
+      var r = safeParseJson(json);
+      if (r && r.projections) return r.projections;
+      return null;
+    });
+};
+
+ProjectionsClient.prototype.listContinuous = function(httpEndPoint, userCredentials) {
+  return this.sendGet(httpEndPoint + '/projections/continuous', userCredentials, HTTP_OK)
+    .then(function (json) {
+      var r = safeParseJson(json);
+      if (r && r.projections) return r.projections;
+      return null;
+    });
+};
+
+ProjectionsClient.prototype.getStatus = function(httpEndPoint, name, userCredentials) {
+  return this.sendGet(httpEndPoint + '/projection/' + name, userCredentials, HTTP_OK);
+};
+
+ProjectionsClient.prototype.getState = function(httpEndPoint, name, userCredentials) {
+  return this.sendGet(httpEndPoint + '/projection/' + name + '/state', userCredentials, HTTP_OK);
+};
+
+ProjectionsClient.prototype.getPartitionState = function(httpEndPoint, name, partitionId, userCredentials) {
+  return this.sendGet(httpEndPoint + '/projection/' + name + '/state?partition=' + partitionId, userCredentials, HTTP_OK);
+};
+
+ProjectionsClient.prototype.getResult = function(httpEndPoint, name, userCredentials) {
+  return this.sendGet(httpEndPoint + '/projection/' + name + '/result', userCredentials, HTTP_OK);
+};
+
+ProjectionsClient.prototype.getPartitionResult = function(httpEndPoint, name, partitionId, userCredentials) {
+  return this.sendGet(httpEndPoint + '/projection/' + name + '/result?partition=' + partitionId, userCredentials, HTTP_OK);
+};
+
+ProjectionsClient.prototype.getStatistics = function(httpEndPoint, name, userCredentials) {
+  return this.sendGet(httpEndPoint + '/projection/' + name + '/statistics', userCredentials, HTTP_OK);
+};
+
+ProjectionsClient.prototype.getQuery = function(httpEndPoint, name, userCredentials) {
+  return this.sendGet(httpEndPoint + '/projection/' + name + '/query', userCredentials, HTTP_OK);
+};
+
+ProjectionsClient.prototype.updateQuery = function(httpEndPoint, name, query, userCredentials) {
+  return this.sendPut(httpEndPoint + '/projection/' + name + '/query?type=JS', query, userCredentials, HTTP_OK);
+};
+
+ProjectionsClient.prototype.delete = function(httpEndPoint, name, deleteEmittedStreams, userCredentials) {
+  return this.sendDelete(httpEndPoint + '/projection/' + name + '?deleteEmittedStreams=' + deleteEmittedStreams, userCredentials, HTTP_OK);
+};
+
+ProjectionsClient.prototype.request = function(method, _url, data, userCredentials, expectedCode) {
+  const options = url.parse(_url);
+  options.method = method;
+  if (userCredentials) {
+    options.auth = [userCredentials.username, userCredentials.password].join(':');
+  }
+  var self = this;
+  return new Promise(function (resolve, reject) {
+    const timeout = setTimeout(function () {
+      reject(new Error(util.format('Request timed out for %s on %s', method, _url)))
+    }, self._operationTimeout);
+    const req = http.request(options, function (res) {
+      const hasExpectedCode = res.statusCode === expectedCode;
+      var result = '';
+      res.setEncoding('utf8');
+      res.on('data', function (chunk) {
+        result += chunk;
+      });
+      res.on('end', function () {
+        if (hasExpectedCode) {
+          clearTimeout(timeout);
+          resolve(result);
+        } else {
+          clearTimeout(timeout);
+          reject(new ProjectionCommandFailedError(
+            res.statusCode,
+            util.format('Server returned %d (%s) for %s on %s', res.statusCode, res.statusMessage, method, _url)
+          ));
+        }
+      });
+    });
+    req.on('error', reject);
+    if (data) {
+      req.setHeader('Content-Type', 'application/json');
+      req.write(data);
+    }
+    req.end();
+  });
+};
+
+function voidResult() {}
+
+ProjectionsClient.prototype.sendGet = function(_url, userCredentials, expectedCode) {
+  return this.request('GET', _url, null, userCredentials, expectedCode);
+};
+
+ProjectionsClient.prototype.sendPost = function(_url, data, userCredentials, expectedCode) {
+  return this.request('POST', _url, data, userCredentials, expectedCode)
+    .then(voidResult);
+};
+
+ProjectionsClient.prototype.sendPut = function(_url, data, userCredentials, expectedCode) {
+  return this.request('PUT', _url, data, userCredentials, expectedCode)
+    .then(voidResult);
+};
+
+ProjectionsClient.prototype.sendDelete = function(_url, data, userCredentials, expectedCode) {
+  return this.request('DELETE', _url, data, userCredentials, expectedCode)
+    .then(voidResult);
+};
+
+module.exports = ProjectionsClient;

src/projections/projectionsManager.js

@@ -0,0 +1,202 @@
+const ensure = require('../common/utils/ensure');
+const ProjectionsClient = require('./projectionsClient');
+
+/**
+ * Creates a new instance of ProjectionsManager.
+ * @param {Logger} log              Instance of Logger to use for logging.
+ * @param {string} httpEndPoint     HTTP endpoint of an Event Store server.
+ * @param {number} operationTimeout Operation timeout in milliseconds.
+ * @constructor
+ */
+function ProjectionsManager(log, httpEndPoint, operationTimeout) {
+  ensure.notNull(log, "log");
+  ensure.notNull(httpEndPoint, "httpEndPoint");
+  this._client = new ProjectionsClient(log, operationTimeout);
+  this._httpEndPoint = httpEndPoint;
+}
+
+/**
+ * Enables a projection.
+ * @param name            The name of the projection.
+ * @param userCredentials Credentials for a user with permission to enable a projection.
+ * @returns {Promise<void>}
+ */
+ProjectionsManager.prototype.enable = function(name, userCredentials) {
+  return this._client.enable(this._httpEndPoint, name, userCredentials);
+};
+
+/**
+ * Aborts and disables a projection without writing a checkpoint.
+ * @param name            The name of the projection.
+ * @param userCredentials Credentials for a user with permission to disable a projection.
+ * @returns {Promise<void>}
+ */
+ProjectionsManager.prototype.disable = function(name, userCredentials) {
+  return this._client.disable(this._httpEndPoint, name, userCredentials);
+};
+
+/**
+ * Disables a projection.
+ * @param name            The name of the projection.
+ * @param userCredentials Credentials for a user with permission to disable a projection.
+ * @returns {Promise<void>}
+ */
+ProjectionsManager.prototype.abort = function(name, userCredentials) {
+  return this._client.abort(this._httpEndPoint, name, userCredentials);
+};
+
+/**
+ * Creates a one-time query.
+ * @param query           The JavaScript source code for the query.
+ * @param userCredentials Credentials for a user with permission to create a query.
+ * @returns {Promise<void>}
+ */
+ProjectionsManager.prototype.createOneTime = function(query, userCredentials) {
+  return this._client.createOneTime(this._httpEndPoint, query, userCredentials);
+};
+
+/**
+ * Creates a one-time query.
+ * @param name            A name for the query.
+ * @param query           The JavaScript source code for the query.
+ * @param userCredentials Credentials for a user with permission to create a query.
+ * @returns {Promise<void>}
+ */
+ProjectionsManager.prototype.createTransient = function(name, query, userCredentials) {
+  return this._client.createTransient(this._httpEndPoint, query, userCredentials);
+};
+
+/**
+ * Creates a one-time query.
+ * @param name                The name of the projection.
+ * @param query               The JavaScript source code for the query.
+ * @param trackEmittedStreams Whether the streams emitted by this projection should be tracked.
+ * @param userCredentials     Credentials for a user with permission to create a query.
+ * @returns {Promise<void>}
+ */
+ProjectionsManager.prototype.createContinuous = function(name, query, trackEmittedStreams, userCredentials) {
+  return this._client.createContinuous(this._httpEndPoint, name, query, trackEmittedStreams, userCredentials);
+};
+
+/**
+ * Lists the status of all projections.
+ * @param userCredentials Credentials for the operation.
+ * @returns {Promise<ProjectionDetails[]>}
+ */
+ProjectionsManager.prototype.listAll = function(userCredentials) {
+  return this._client.listAll(this._httpEndPoint, userCredentials);
+};
+
+/**
+ * Lists the status of all one-time projections.
+ * @param userCredentials Credentials for the operation.
+ * @returns {Promise<ProjectionDetails[]>}
+ */
+ProjectionsManager.prototype.listOneTime = function(userCredentials) {
+  return this._client.listOneTime(this._httpEndPoint, userCredentials);
+};
+
+/**
+ * Lists the status of all continuous projections.
+ * @param userCredentials Credentials for the operation.
+ * @returns {Promise<ProjectionDetails[]>}
+ */
+ProjectionsManager.prototype.listContinuous = function(userCredentials) {
+  return this._client.listContinuous(this._httpEndPoint, userCredentials);
+};
+
+/**
+ * Gets the status of a projection.
+ * @param name            The name of the projection.
+ * @param userCredentials Credentials for the operation.
+ * @returns {Promise<string>} String of JSON containing projection status.
+ */
+ProjectionsManager.prototype.getStatus = function(name, userCredentials) {
+  return this._client.getStatus(this._httpEndPoint, name, userCredentials);
+};
+
+/**
+ * Gets the state of a projection.
+ * @param name            The name of the projection.
+ * @param userCredentials Credentials for the operation.
+ * @returns {Promise<string>} String of JSON containing projection state.
+ */
+ProjectionsManager.prototype.getState = function(name, userCredentials) {
+  return this._client.getState(this._httpEndPoint, name, userCredentials);
+};
+
+/**
+ * Gets the state of a projection for a specified partition.
+ * @param name            The name of the projection.
+ * @param partitionId     The id of the partition.
+ * @param userCredentials Credentials for the operation.
+ * @returns {Promise<string>} String of JSON containing projection state.
+ */
+ProjectionsManager.prototype.getPartitionState = function(name, partitionId, userCredentials) {
+  return this._client.getPartitionState(this._httpEndPoint, name, partitionId, userCredentials);
+};
+
+/**
+ * Gets the state of a projection.
+ * @param name            The name of the projection.
+ * @param userCredentials Credentials for the operation.
+ * @returns {Promise<string>} String of JSON containing projection state.
+ */
+ProjectionsManager.prototype.getResult = function(name, userCredentials) {
+  return this._client.getResult(this._httpEndPoint, name, userCredentials);
+};
+
+/**
+ * Gets the state of a projection for a specified partition.
+ * @param name            The name of the projection.
+ * @param partitionId     The id of the partition.
+ * @param userCredentials Credentials for the operation.
+ * @returns {Promise<string>} String of JSON containing projection state.
+ */
+ProjectionsManager.prototype.getPartitionResult = function(name, partitionId, userCredentials) {
+  return this._client.getPartitionResult(this._httpEndPoint, name, partitionId, userCredentials);
+};
+
+/**
+ * Gets the statistics of a projection.
+ * @param name            The name of the projection.
+ * @param userCredentials Credentials for the operation.
+ * @returns {Promise<string>} String of JSON containing projection statistics.
+ */
+ProjectionsManager.prototype.getStatistics = function(name, userCredentials) {
+  return this._client.getStatistics(this._httpEndPoint, name, userCredentials);
+};
+
+/**
+ * Gets the status of a query.
+ * @param name            The name of the query.
+ * @param userCredentials Credentials for the operation.
+ * @returns {Promise<string>} String of JSON containing query status.
+ */
+ProjectionsManager.prototype.getQuery = function(name, userCredentials) {
+  return this._client.getQuery(this._httpEndPoint, name, userCredentials);
+};
+
+/**
+ * Updates the definition of a query.
+ * @param name            The name of the query.
+ * @param query           The JavaScript source code for the query.
+ * @param userCredentials Credentials for the operation.
+ * @returns {Promise<void>}
+ */
+ProjectionsManager.prototype.updateQuery = function(name, query, userCredentials) {
+  return this._client.updateQuery(this._httpEndPoint, name, query, userCredentials);
+};
+
+/**
+ * Updates the definition of a query.
+ * @param name                  The name of the projection.
+ * @param deleteEmittedStreams  Whether to delete the streams that were emitted by this projection.
+ * @param userCredentials       Credentials for a user with permission to delete a projection.
+ * @returns {Promise<void>}
+ */
+ProjectionsManager.prototype.delete = function(name, deleteEmittedStreams, userCredentials) {
+  return this._client.delete(this._httpEndPoint, name, deleteEmittedStreams, userCredentials);
+};
+
+module.exports = ProjectionsManager;

src/results.js

@@ -1,9 +1,9 @@
-var util = require('util');
-var uuid = require('uuid');
+var guidParse = require('./common/guid-parse');
 var Long = require('long');
 var ensure = require('./common/utils/ensure');
 
 /**
+ * @public
  * @param {!number|!Long} commitPosition
  * @param {!number|!Long} preparePosition
  * @constructor
@@ -13,17 +13,9 @@ var ensure = require('./common/utils/ensure');
 function Position(commitPosition, preparePosition) {
   ensure.notNull(commitPosition, "commitPosition");
   ensure.notNull(preparePosition, "preparePosition");
-  commitPosition = Long.fromValue(commitPosition);
-  preparePosition = Long.fromValue(preparePosition);
-
-  Object.defineProperties(this, {
-    commitPosition: {
-      enumerable: true, value: commitPosition
-    },
-    preparePosition: {
-      enumerable: true, value: preparePosition
-    }
-  });
+  this.commitPosition = Long.fromValue(commitPosition);
+  this.preparePosition = Long.fromValue(preparePosition);
+  Object.freeze(this);
 }
 
 Position.prototype.compareTo = function(other) {
@@ -45,6 +37,7 @@ const EventReadStatus = {
   NoStream: 'noStream',
   StreamDeleted: 'streamDeleted'
 };
+Object.freeze(EventReadStatus);
 
 /**
  * @param {object} ev
@@ -59,18 +52,16 @@ const EventReadStatus = {
  * @property {boolean} isJson
  */
 function RecordedEvent(ev) {
-  Object.defineProperties(this, {
-    eventStreamId: {enumerable: true, value: ev.event_stream_id},
-    eventId: {enumerable: true, value: uuid.unparse(ev.event_id.buffer, ev.event_id.offset)},
-    eventNumber: {enumerable: true, value: ev.event_number},
-    eventType: {enumerable: true, value: ev.event_type},
-    //Javascript doesn't have .Net precision for time, so we use created_epoch for created
-    created: {enumerable: true, value: new Date(ev.created_epoch ? ev.created_epoch.toInt() : 0)},
-    createdEpoch: {enumerable: true, value: ev.created_epoch ? ev.created_epoch.toInt() : 0},
-    data: {enumerable: true, value: ev.data ? ev.data.toBuffer() : new Buffer(0)},
-    metadata: {enumerable: true, value: ev.metadata ? ev.metadata.toBuffer() : new Buffer(0)},
-    isJson: {enumerable: true, value: ev.data_content_type == 1}
-  });
+  this.eventStreamId = ev.eventStreamId;
+  this.eventId = guidParse.unparse(ev.eventId);
+  this.eventNumber = ev.eventNumber;
+  this.eventType = ev.eventType;
+  this.created = new Date(ev.createdEpoch ? ev.createdEpoch.toNumber() : 0);
+  this.createdEpoch = ev.createdEpoch ? ev.createdEpoch.toNumber() : 0;
+  this.data = ev.data ? ev.data : new Buffer(0);
+  this.metadata = ev.metadata ? ev.metadata : new Buffer(0);
+  this.isJson = ev.dataContentType === 1;
+  Object.freeze(this);
 }
 
 /**
@@ -85,44 +76,14 @@ function RecordedEvent(ev) {
  * @property {number} originalEventNumber
  */
 function ResolvedEvent(ev) {
-  Object.defineProperties(this, {
-    event: {
-      enumerable: true,
-      value: ev.event === null ? null : new RecordedEvent(ev.event)
-    },
-    link: {
-      enumerable: true,
-      value: ev.link === null ? null : new RecordedEvent(ev.link)
-    },
-    originalEvent: {
-      enumerable: true,
-      get: function() {
-        return this.link || this.event;
-      }
-    },
-    isResolved: {
-      enumerable: true,
-      get: function() {
-        return this.link !== null && this.event !== null;
-      }
-    },
-    originalPosition: {
-      enumerable: true,
-      value: (ev.commit_position && ev.prepare_position) ? new Position(ev.commit_position, ev.prepare_position) : null
-    },
-    originalStreamId: {
-      enumerable: true,
-      get: function() {
-        return this.originalEvent.eventStreamId;
-      }
-    },
-    originalEventNumber: {
-      enumerable: true,
-      get: function() {
-        return this.originalEvent.eventNumber;
-      }
-    }
-  });
+  this.event = ev.event === null ? null : new RecordedEvent(ev.event);
+  this.link = ev.link === null ? null : new RecordedEvent(ev.link);
+  this.originalEvent = this.link || this.event;
+  this.isResolved = this.link !== null && this.event !== null;
+  this.originalPosition = (ev.commitPosition && ev.preparePosition) ? new Position(ev.commitPosition, ev.preparePosition) : null;
+  this.originalStreamId = this.originalEvent && this.originalEvent.eventStreamId;
+  this.originalEventNumber = this.originalEvent && this.originalEvent.eventNumber;
+  Object.freeze(this);
 }
 
 /**
@@ -138,14 +99,11 @@ function ResolvedEvent(ev) {
  * @property {ResolvedEvent} event
  */
 function EventReadResult(status, stream, eventNumber, event) {
-  Object.defineProperties(this, {
-    status: {enumerable: true, value: status},
-    stream: {enumerable: true, value: stream},
-    eventNumber: {enumerable: true, value: eventNumber},
-    event: {
-      enumerable: true, value: status === EventReadStatus.Success ? new ResolvedEvent(event) : null
-    }
-  });
+  this.status = status;
+  this.stream = stream;
+  this.eventNumber = eventNumber;
+  this.event = status === EventReadStatus.Success ? new ResolvedEvent(event) : null;
+  Object.freeze(this);
 }
 
 /**
@@ -156,14 +114,9 @@ function EventReadResult(status, stream, eventNumber, event) {
  * @property {Position} logPosition
  */
 function WriteResult(nextExpectedVersion, logPosition) {
-  Object.defineProperties(this, {
-    nextExpectedVersion: {
-      enumerable: true, value: nextExpectedVersion
-    },
-    logPosition: {
-      enumerable: true, value: logPosition
-    }
-  });
+  this.nextExpectedVersion = nextExpectedVersion;
+  this.logPosition = logPosition;
+  Object.freeze(this);
 }
 
 /**
@@ -188,32 +141,15 @@ function WriteResult(nextExpectedVersion, logPosition) {
 function StreamEventsSlice(
     status, stream, fromEventNumber, readDirection, events, nextEventNumber, lastEventNumber, isEndOfStream
 ) {
-  Object.defineProperties(this, {
-    status: {
-      enumerable: true, value: status
-    },
-    stream: {
-      enumerable: true, value: stream
-    },
-    fromEventNumber: {
-      enumerable: true, value: fromEventNumber
-    },
-    readDirection: {
-      enumerable: true, value: readDirection
-    },
-    events: {
-      enumerable: true, value: events ? events.map(function(ev) { return new ResolvedEvent(ev); }) : []
-    },
-    nextEventNumber: {
-      enumerable: true, value: nextEventNumber
-    },
-    lastEventNumber: {
-      enumerable: true, value: lastEventNumber
-    },
-    isEndOfStream: {
-      enumerable: true, value: isEndOfStream
-    }
-  })
+  this.status = status;
+  this.stream = stream;
+  this.fromEventNumber = fromEventNumber;
+  this.readDirection = readDirection;
+  this.events = events ? events.map(function(ev) { return new ResolvedEvent(ev); }) : [];
+  this.nextEventNumber = nextEventNumber;
+  this.lastEventNumber = lastEventNumber;
+  this.isEndOfStream = isEndOfStream;
+  Object.freeze(this);
 }
 
 /**
@@ -228,23 +164,12 @@ function StreamEventsSlice(
  * @property {ResolvedEvent[]} events
  */
 function AllEventsSlice(readDirection, fromPosition, nextPosition, events) {
-  Object.defineProperties(this, {
-    readDirection: {
-      enumerable: true, value: readDirection
-    },
-    fromPosition: {
-      enumerable: true, value: fromPosition
-    },
-    nextPosition: {
-      enumerable: true, value: nextPosition
-    },
-    events: {
-      enumerable: true, value: events ? events.map(function(ev){ return new ResolvedEvent(ev); }) : []
-    },
-    isEndOfStream: {
-      enumerable: true, value: events === null || events.length === 0
-    }
-  });
+  this.readDirection = readDirection;
+  this.fromPosition = fromPosition;
+  this.nextPosition = nextPosition;
+  this.events = events ? events.map(function(ev){ return new ResolvedEvent(ev); }) : [];
+  this.isEndOfStream = events === null || events.length === 0;
+  Object.freeze(this);
 }
 
 /**
@@ -253,11 +178,8 @@ function AllEventsSlice(readDirection, fromPosition, nextPosition, events) {
  * @property {Position} logPosition
  */
 function DeleteResult(logPosition) {
-  Object.defineProperties(this, {
-    logPosition: {
-      enumerable: true, value: logPosition
-    }
-  });
+  this.logPosition = logPosition;
+  Object.freeze(this);
 }
 
 /**
@@ -273,12 +195,11 @@ function DeleteResult(logPosition) {
  */
 function RawStreamMetadataResult(stream, isStreamDeleted, metastreamVersion, streamMetadata) {
   ensure.notNullOrEmpty(stream);
-  Object.defineProperties(this, {
-    stream: {enumerable: true, value: stream},
-    isStreamDeleted: {enumerable: true, value: isStreamDeleted},
-    metastreamVersion: {enumerable: true, value: metastreamVersion},
-    streamMetadata: {enumerable: true, value: streamMetadata}
-  });
+  this.stream = stream;
+  this.isStreamDeleted = isStreamDeleted;
+  this.metastreamVersion = metastreamVersion;
+  this.streamMetadata = streamMetadata;
+  Object.freeze(this);
 }
 
 const PersistentSubscriptionCreateStatus = {
@@ -286,6 +207,7 @@ const PersistentSubscriptionCreateStatus = {
   NotFound: 'notFound',
   Failure: 'failure'
 };
+Object.freeze(PersistentSubscriptionCreateStatus);
 
 /**
  * @param {string} status
@@ -293,9 +215,8 @@ const PersistentSubscriptionCreateStatus = {
  * @property {string} status
  */
 function PersistentSubscriptionCreateResult(status) {
-  Object.defineProperties(this, {
-    status: {enumerable: true, value: status}
-  });
+  this.status = status;
+  Object.freeze(this);
 }
 
 const PersistentSubscriptionUpdateStatus = {
@@ -304,6 +225,7 @@ const PersistentSubscriptionUpdateStatus = {
   Failure: 'failure',
   AccessDenied: 'accessDenied'
 };
+Object.freeze(PersistentSubscriptionUpdateStatus);
 
 /**
  * @param {string} status
@@ -311,15 +233,15 @@ const PersistentSubscriptionUpdateStatus = {
  * @property {string} status
  */
 function PersistentSubscriptionUpdateResult(status) {
-  Object.defineProperties(this, {
-    status: {enumerable: true, value: status}
-  });
+  this.status = status;
+  Object.freeze(this);
 }
 
 const PersistentSubscriptionDeleteStatus = {
   Success: 'success',
   Failure: 'failure'
 };
+Object.freeze(PersistentSubscriptionDeleteStatus);
 
 /**
  * @param {string} status
@@ -327,9 +249,8 @@ const PersistentSubscriptionDeleteStatus = {
  * @property {string} status
  */
 function PersistentSubscriptionDeleteResult(status) {
-  Object.defineProperties(this, {
-    status: {enumerable: true, value: status}
-  });
+  this.status = status;
+  Object.freeze(this);
 }
 
 // Exports Constructors

src/sliceReadStatus.js

@@ -3,5 +3,6 @@ const SliceReadStatus = {
   StreamNotFound: 'streamNotFound',
   StreamDeleted: 'streamDeleted'
 };
+Object.freeze(SliceReadStatus);
 
 module.exports = SliceReadStatus;

src/systemConsumerStrategies.js

@@ -3,5 +3,6 @@ const SystemConsumerStrategies = {
   RoundRobin: 'RoundRobin',
   Pinned: 'Pinned'
 };
+Object.freeze(SystemConsumerStrategies);
 
 module.exports = SystemConsumerStrategies;

src/systemData/tcpPackage.js

@@ -1,4 +1,4 @@
-var uuid = require('uuid');
+var guidParse = require('../common/guid-parse');
 
 var createBufferSegment = require('../common/bufferSegment');
 var TcpFlags = require('./tcpFlags');
@@ -25,11 +25,11 @@ TcpPackage.fromBufferSegment = function(data) {
   var command = data.buffer[data.offset + CommandOffset];
   var flags = data.buffer[data.offset + FlagsOffset];
 
-  var correlationId = uuid.unparse(data.buffer, data.offset + CorrelationOffset);
+  var correlationId = guidParse.unparse(data.buffer, data.offset + CorrelationOffset);
 
   var headerSize = MandatorySize;
   var login = null, pass = null;
-  if ((flags & TcpFlags.Authenticated) != 0)
+  if ((flags & TcpFlags.Authenticated) !== 0)
   {
     var loginLen = data.buffer[data.offset + AuthOffset];
     if (AuthOffset + 1 + loginLen + 1 >= data.count)
@@ -48,7 +48,7 @@ TcpPackage.fromBufferSegment = function(data) {
 };
 
 TcpPackage.prototype.asBuffer = function() {
-  if ((this.flags & TcpFlags.Authenticated) != 0) {
+  if ((this.flags & TcpFlags.Authenticated) !== 0) {
     var loginBytes = new Buffer(this.login);
     if (loginBytes.length > 255) throw new Error("Login serialized length should be less than 256 bytes.");
     var passwordBytes = new Buffer(this.password);
@@ -57,7 +57,7 @@ TcpPackage.prototype.asBuffer = function() {
     var res = new Buffer(MandatorySize + 2 + loginBytes.length + passwordBytes.length + (this.data ? this.data.count : 0));
     res[CommandOffset] = this.command;
     res[FlagsOffset] = this.flags;
-    uuid.parse(this.correlationId, res, CorrelationOffset);
+    guidParse.parse(this.correlationId, res, CorrelationOffset);
 
     res[AuthOffset] = loginBytes.length;
     loginBytes.copy(res, AuthOffset + 1);
@@ -72,7 +72,7 @@ TcpPackage.prototype.asBuffer = function() {
     var res = new Buffer(MandatorySize + (this.data ? this.data.count : 0));
     res[CommandOffset] = this.command;
     res[FlagsOffset] = this.flags;
-    uuid.parse(this.correlationId, res, CorrelationOffset);
+    guidParse.parse(this.correlationId, res, CorrelationOffset);
     if (this.data)
       this.data.copyTo(res, AuthOffset);
     return res;

src/systemData/userCredentials.js

@@ -10,11 +10,9 @@ var ensure = require('../common/utils/ensure');
 function UserCredentials(username, password) {
   ensure.notNullOrEmpty(username, 'username');
   ensure.notNullOrEmpty(password, 'password');
-
-  Object.defineProperties(this, {
-    username: {enumerable: true, value: username},
-    password: {enumerable: true, value: password}
-  });
+  this.username = username;
+  this.password = password;
+  Object.freeze(this);
 }
 
 module.exports = UserCredentials;

src/transport/tcp/lengthPrefixMessageFramer.js

@@ -29,7 +29,7 @@ LengthPrefixMessageFramer.prototype._parse = function(bytes) {
     {
       this._packageLength |= (buffer[i] << (this._headerBytes * 8)); // little-endian order
       ++this._headerBytes;
-      if (this._headerBytes == HeaderLength)
+      if (this._headerBytes === HeaderLength)
       {
         if (this._packageLength <= 0 || this._packageLength > this._maxPackageSize)
           throw new Error(["Package size is out of bounds: ", this._packageLength, "(max: ", this._maxPackageSize, "."].join(''));
@@ -44,9 +44,9 @@ LengthPrefixMessageFramer.prototype._parse = function(bytes) {
       this._bufferIndex += copyCnt;
       i += copyCnt - 1;
 
-      if (this._bufferIndex == this._packageLength)
+      if (this._bufferIndex === this._packageLength)
       {
-        if (this._receivedHandler != null)
+        if (this._receivedHandler !== null)
           this._receivedHandler(createBufferSegment(this._messageBuffer, 0, this._bufferIndex));
         this.reset();
       }

src/transport/tcp/tcpConnection.js

@@ -1,7 +1,7 @@
 var net = require('net');
 var createBufferSegment = require('../../common/bufferSegment');
 
-const MaxSendPacketSize = 64 * 1000;
+const MaxSendPacketSize = 64 * 1024;
 
 function TcpConnection(log, connectionId, remoteEndPoint, onConnectionClosed) {
   this._socket = null;
@@ -32,9 +32,13 @@ function TcpConnection(log, connectionId, remoteEndPoint, onConnectionClosed) {
 TcpConnection.prototype._initSocket = function(socket) {
   this._socket = socket;
   this._localEndPoint = {host: socket.localAddress, port: socket.localPort};
+  this._remoteEndPoint.host = socket.remoteAddress;
 
+  this._socket.on('drain', this._trySend.bind(this));
   this._socket.on('error', this._processError.bind(this));
   this._socket.on('data', this._processReceive.bind(this));
+
+  this._trySend();
 };
 
 TcpConnection.prototype.enqueueSend = function(bufSegmentArray) {
@@ -53,19 +57,20 @@ TcpConnection.prototype._trySend = function() {
 
   var buffers = [];
   var bytes = 0;
-  var sendPiece = this._sendQueue.shift();
-  while(sendPiece) {
-    if (bytes + sendPiece.length > MaxSendPacketSize)
-        break;
-
+  var sendPiece;
+  while(sendPiece = this._sendQueue.shift()) {
     buffers.push(sendPiece);
     bytes += sendPiece.length;
-
-    sendPiece = this._sendQueue.shift();
+    if (bytes > MaxSendPacketSize)
+        break;
   }
 
   var joinedBuffers = Buffer.concat(buffers, bytes);
-  this._socket.write(joinedBuffers);
+  if (!this._socket.write(joinedBuffers)) {
+    return;
+  }
+
+  setImmediate(this._trySend.bind(this));
 };
 
 TcpConnection.prototype._processError = function(err) {
@@ -120,13 +125,13 @@ TcpConnection.prototype._closeInternal = function(err, reason) {
   if (this._closed) return;
   this._closed = true;
 
-  if (this._socket != null) {
+  if (this._socket !== null) {
     this._socket.end();
     this._socket.unref();
     this._socket = null;
   }
 
-  if (this._onConnectionClosed != null)
+  if (this._onConnectionClosed !== null)
       this._onConnectionClosed(this, err);
 };
 
@@ -135,7 +140,7 @@ TcpConnection.createConnectingConnection = function(
     onConnectionEstablished, onConnectionFailed, onConnectionClosed
 ) {
   var connection = new TcpConnection(log, connectionId, remoteEndPoint, onConnectionClosed);
-  var socket = net.connect(remoteEndPoint);
+  var socket = net.connect(remoteEndPoint.port, remoteEndPoint.host);
   function onError(err) {
     if (onConnectionFailed)
       onConnectionFailed(connection, err);

src/transport/tcp/tcpPackageConnection.js

@@ -7,6 +7,7 @@ var TcpPackage = require('../../systemData/tcpPackage');
 var TcpCommand = require('../../systemData/tcpCommand');
 
 /**
+ * @private
  * @param log
  * @param remoteEndPoint
  * @param connectionId
@@ -120,26 +121,26 @@ TcpPackageConnection.prototype._incomingMessageArrived = function(data) {
     var message = util.format("TcpPackageConnection: [%j, L%j, %s] ERROR for %s. Connection will be closed.",
         this.remoteEndPoint, this.localEndPoint, this._connectionId,
         valid ? TcpCommand.getName(pkg.command) : "<invalid package>");
-    if (this._onError != null)
+    if (this._onError !== null)
       this._onError(this, e);
     this._log.debug(e, message);
   }
 };
 
 TcpPackageConnection.prototype.startReceiving = function() {
-  if (this._connection == null)
+  if (this._connection === null)
     throw new Error("Failed connection.");
   this._connection.receive(this._onRawDataReceived.bind(this));
 };
 
 TcpPackageConnection.prototype.enqueueSend = function(pkg) {
-  if (this._connection == null)
+  if (this._connection === null)
     throw new Error("Failed connection.");
   this._connection.enqueueSend(this._framer.frameData(pkg.asBufferSegment()));
 };
 
 TcpPackageConnection.prototype.close = function(reason) {
-  if (this._connection == null)
+  if (this._connection === null)
     throw new Error("Failed connection.");
   this._connection.close(reason);
 };

src/volatileEventStoreSubscription.js

@@ -3,6 +3,7 @@ var util = require('util');
 var EventStoreSubsription = require('./eventStoreSubscription');
 
 /**
+ * @private
  * @param {SubscriptionOperation} subscriptionOperation
  * @param {string} streamId
  * @param {Position} lastCommitPosition
@@ -10,15 +11,15 @@ var EventStoreSubsription = require('./eventStoreSubscription');
  * @constructor
  * @augments {EventStoreSubscription}
  */
-function VolatileEventStoreConnection(subscriptionOperation, streamId, lastCommitPosition, lastEventNumber) {
+function VolatileEventStoreSubscription(subscriptionOperation, streamId, lastCommitPosition, lastEventNumber) {
   EventStoreSubsription.call(this, streamId, lastCommitPosition, lastEventNumber);
 
   this._subscriptionOperation = subscriptionOperation;
 }
-util.inherits(VolatileEventStoreConnection, EventStoreSubsription);
+util.inherits(VolatileEventStoreSubscription, EventStoreSubsription);
 
-VolatileEventStoreConnection.prototype.unsubscribe = function() {
+VolatileEventStoreSubscription.prototype.unsubscribe = function() {
   this._subscriptionOperation.unsubscribe();
 };
 
-module.exports = VolatileEventStoreConnection;
+module.exports = VolatileEventStoreSubscription;

test/appendToStream_test.js

@@ -3,6 +3,7 @@ var client = require('../src/client');
 
 module.exports = {
   'Append One Event To Stream Happy Path': function(test) {
+    test.expect(2);
     var event = client.createJsonEventData(uuid.v4(), {a: Math.random(), b: uuid.v4()}, null, 'testEvent');
     this.conn.appendToStream(this.testStreamName, client.expectedVersion.any, event)
         .then(function(result) {
@@ -15,6 +16,7 @@ module.exports = {
         });
   },
   'Append Multiple Events To Stream Happy Path': function(test) {
+    test.expect(2);
     const expectedVersion = 25;
     var events = [];
     for(var i = 0; i <= expectedVersion; i++) {
@@ -33,7 +35,43 @@ module.exports = {
           test.done(err);
         });
   },
+  'Append Multiple Events To Stream Happy Path Stress Test': function(test) {
+    test.expect(2);
+    const expectedVersion = 1000;
+    var events = [];
+    for(var i = 0; i <= expectedVersion; i++) {
+      if (i % 2 === 0)
+        events.push(client.createJsonEventData(uuid.v4(), {a: Math.random(), b: uuid.v4()}, null, 'testEvent'));
+      else
+        events.push(client.createJsonEventData(uuid.v4(), {b: Math.random(), a: uuid.v4()}, null, 'otherEvent'));
+    }
+    this.conn.appendToStream(this.testStreamName, client.expectedVersion.any, events)
+        .then(function(result) {
+          test.areEqual("result.nextExpectedVersion", result.nextExpectedVersion, expectedVersion);
+          test.ok(result.logPosition, "No log position in result.");
+          test.done();
+        })
+        .catch(function(err) {
+          test.done(err);
+        });
+  },
+  'Append Large event': function(test) {
+    test.expect(2);
+    const largeData = Buffer.alloc(3 * 1024 *1024, " ");
+    const event = client.createJsonEventData(uuid.v4(), {a: largeData.toString()}, null, 'largePayloadEvent');
+    
+    this.conn.appendToStream(this.testStreamName, client.expectedVersion.any, event)
+        .then(function(result) {
+          test.areEqual("result.nextExpectedVersion", result.nextExpectedVersion, 0);
+          test.ok(result.logPosition, "No log position in result.");
+          test.done();
+        })
+        .catch(function(err) {
+          test.done(err);
+        });
+  },
   'Append To Stream Wrong Expected Version': function(test) {
+    test.expect(1);
     var event = client.createJsonEventData(uuid.v4(), {a: Math.random(), b: uuid.v4()}, null, 'testEvent');
     this.conn.appendToStream(this.testStreamName, 10, event)
         .then(function(result) {
@@ -48,6 +86,7 @@ module.exports = {
         });
   },
   'Append To Stream Deleted': function(test) {
+    test.expect(1);
     var self = this;
     this.conn.deleteStream(this.testStreamName, client.expectedVersion.noStream, true)
         .then(function() {
@@ -66,6 +105,7 @@ module.exports = {
         });
   },
   'Append To Stream Access Denied': function(test) {
+    test.expect(1);
     var self = this;
     var metadata = {$acl: {$w: "$admins"}};
     this.conn.setStreamMetadataRaw(this.testStreamName, client.expectedVersion.noStream, metadata)

test/client_test.js

@@ -1,326 +0,0 @@
-var util = require('util');
-var uuid = require('uuid');
-var client = require('../src/client');
-var NoopLogger = require('../src/common/log/noopLogger');
-
-var consoleLogger = {
-  debug: function() {
-    var msg = util.format.apply(util, Array.prototype.slice.call(arguments));
-    util.log(msg);
-  },
-  info: function() {},
-  error: function() {}
-};
-
-function createRandomEvent() {
-  return client.createJsonEventData(uuid.v4(), {a: uuid.v4(), b: Math.random()}, {createdAt: Date.now()}, 'testEvent');
-}
-
-var testStreamName = 'test-' + uuid.v4();
-var userCredentialsForAll = new client.UserCredentials("admin", "changeit");
-
-function testEvent(test, event, expectedVersion) {
-  if (!event) return;
-  test.ok(event.event, "Event has no 'event'.");
-  if (!event.event) return;
-  test.ok(event.event.eventNumber === expectedVersion, util.format("Wrong expected version. Expected: %d Got: %d", event.event.eventNumber, expectedVersion));
-}
-
-module.exports = {
-  setUp: function(cb) {
-    var tcpEndPoint = {host: 'localhost', port: 1113};
-    var settings = {verboseLogging: false, log: new NoopLogger()};
-    //var settings = {verboseLogging: true, log: consoleLogger};
-    this.conn = client.EventStoreConnection.create(settings, tcpEndPoint);
-    this.connError = null;
-    var self = this;
-    this.conn.connect()
-        .catch(function(e) {
-          self.connError = e;
-          cb(e);
-        });
-    this.conn.on('connected', function() {
-      cb();
-    });
-  },
-  tearDown: function(cb) {
-    this.conn.close();
-    this.conn.on('closed', function() {
-      cb();
-    });
-    this.conn = null;
-  },
-/*
-  'Test Connection': function(test) {
-    test.ok(this.connError === null, "Connection error: " + this.connError);
-    test.done();
-  },
-  'Test Append To Stream': function(test) {
-    var events = [
-      createRandomEvent()
-    ];
-    this.conn.appendToStream(testStreamName, client.expectedVersion.any, events)
-        .then(function(result) {
-          test.ok(result, "No result.");
-          test.done();
-        })
-        .catch(function (err) {
-          test.done(err);
-        });
-  },*/
-  'Test Commit Two Events Using Transaction': function(test) {
-    this.conn.startTransaction(testStreamName, client.expectedVersion.any)
-        .then(function(trx) {
-          test.ok(trx, "No transaction.");
-          return Promise.all([trx, trx.write([createRandomEvent()])]);
-        })
-        .then(function(args) {
-          var trx = args[0];
-          return Promise.all([trx, trx.write([createRandomEvent()])]);
-        })
-        .then(function(args) {
-          var trx = args[0];
-          return trx.commit();
-        })
-        .then(function(result) {
-          test.ok(result, "No result.");
-          test.done();
-        })
-        .catch(function(err) {
-          test.done(err);
-        });
-  },
-  /*
-  'Test Read One Event': function(test) {
-    this.conn.readEvent(testStreamName, 0)
-        .then(function(result) {
-          test.ok(result, "No result.");
-          if (result)
-            test.ok(result.event, "No event. " + result.status);
-          test.done();
-        })
-        .catch(function(err) {
-          test.done(err);
-        });
-  },
-  'Test Read Stream Forward': function(test) {
-    this.conn.readStreamEventsForward(testStreamName, 0, 100)
-        .then(function(result) {
-          test.ok(result, "No result.");
-          if (result)
-            test.ok(result.events.length === 3, "Expecting 3 events, got " + result.events.length);
-          for(var i = 0; i < 3; i++)
-            testEvent(test, result.events[i], i);
-          test.done();
-        })
-        .catch(function(err) {
-          test.done(err);
-        });
-  },
-  'Test Read Stream Backward': function(test) {
-    this.conn.readStreamEventsBackward(testStreamName, 2, 100)
-        .then(function(result) {
-          test.ok(result, "No result.");
-          if (result)
-            test.ok(result.events.length === 3, "Expecting 3 events, got " + result.events.length);
-          for(var i = 0; i < 3; i++)
-            testEvent(test, result.events[i], 2-i);
-          test.done();
-        })
-        .catch(function(err) {
-          test.done(err);
-        });
-  },
-  'Test Read All Forward': function(test) {
-    this.conn.readAllEventsForward(client.positions.start, 100, false, userCredentialsForAll)
-        .then(function(result) {
-          test.ok(result, "No result.");
-          if (result)
-            test.ok(result.events.length >= 3, "Expecting at least 3 events, got " + result.events.length);
-          for(var i = 1; i < result.events.length; i++)
-            test.ok(result.events[i].originalPosition.compareTo(result.events[i-1].originalPosition) > 0,
-                    util.format("event[%d] position is not > event[%d] position.",
-                                result.events[i].originalPosition,
-                                result.events[i-1].originalPosition));
-          test.done();
-        })
-        .catch(function(err) {
-          test.done(err);
-        });
-  },
-  'Test Read All Backward': function(test) {
-    this.conn.readAllEventsBackward(client.positions.end, 100, false, userCredentialsForAll)
-        .then(function(result) {
-          test.ok(result, "No result.");
-          if (result)
-            test.ok(result.events.length >= 3, "Expecting at least 3 events, got " + result.events.length);
-          for(var i = 1; i < result.events.length; i++)
-            test.ok(result.events[i].originalPosition.compareTo(result.events[i-1].originalPosition) < 0,
-                util.format("event[%d] position is not < event[%d] position.",
-                    result.events[i].originalPosition,
-                    result.events[i-1].originalPosition));
-          test.done();
-        })
-        .catch(function(err) {
-          test.done(err);
-        });
-  },*/
-  'Test Subscribe to Stream': function(test) {
-    var done = false;
-    function eventAppeared() {
-      if (!done) {
-        done = true;
-        test.done();
-      }
-    }
-    function subscriptionDropped() {
-      if (!done) {
-        done = true;
-        test.done();
-      }
-    }
-    var conn = this.conn;
-    this.conn.subscribeToStream(testStreamName, false, eventAppeared, subscriptionDropped)
-        .then(function(subscription) {
-          var events = [createRandomEvent()];
-          return conn.appendToStream(testStreamName, client.expectedVersion.any, events);
-        })
-        .catch(function(err) {
-          done = true;
-          test.done(err);
-        })
-  },
-  'Test Subscribe to All': function(test) {
-    var done = false;
-    function eventAppeared() {
-      if (!done) {
-        done = true;
-        test.done();
-      }
-    }
-    function subscriptionDropped() {
-      if (!done) {
-        done = true;
-        test.done();
-      }
-    }
-    var conn = this.conn;
-    this.conn.subscribeToAll(false, eventAppeared, subscriptionDropped, userCredentialsForAll)
-        .then(function(subscription) {
-          var events = [createRandomEvent()];
-          return conn.appendToStream(testStreamName, client.expectedVersion.any, events);
-        })
-        .catch(function(err) {
-          done = true;
-          test.done(err);
-        });
-  },
-  'Test Subscribe to Stream From': function(test) {
-    var self = this;
-    var liveProcessing = false;
-    var catchUpEvents = [];
-    var liveEvents = [];
-    function eventAppeared(s, e) {
-      if (liveProcessing) {
-        liveEvents.push(e);
-        s.stop();
-      } else {
-        catchUpEvents.push(e);
-      }
-    }
-    function liveProcessingStarted() {
-      liveProcessing = true;
-      var events = [createRandomEvent()];
-      self.conn.appendToStream('test', client.expectedVersion.any, events);
-    }
-    function subscriptionDropped(connection, reason, error) {
-      test.ok(liveEvents.length === 1, "Expecting 1 live event, got " + liveEvents.length);
-      test.ok(catchUpEvents.length > 1, "Expecting at least 1 catchUp event, got " + catchUpEvents.length);
-      test.done(error);
-    }
-    var subscription = this.conn.subscribeToStreamFrom('test', null, false, eventAppeared, liveProcessingStarted, subscriptionDropped);
-  },
-  'Test Subscribe to All From': function(test) {
-    var self = this;
-    var liveProcessing = false;
-    var catchUpEvents = [];
-    var liveEvents = [];
-    function eventAppeared(s, e) {
-      if (liveProcessing) {
-        liveEvents.push(e);
-        s.stop();
-      } else {
-        catchUpEvents.push(e);
-      }
-    }
-    function liveProcessingStarted() {
-      liveProcessing = true;
-      var events = [createRandomEvent()];
-      self.conn.appendToStream(testStreamName, client.expectedVersion.any, events);
-    }
-    function subscriptionDropped(connection, reason, error) {
-      test.ok(liveEvents.length === 1, "Expecting 1 live event, got " + liveEvents.length);
-      test.ok(catchUpEvents.length > 1, "Expecting at least 1 catchUp event, got " + catchUpEvents.length);
-      test.done(error);
-    }
-    var subscription = this.conn.subscribeToAllFrom(null, false, eventAppeared, liveProcessingStarted, subscriptionDropped, userCredentialsForAll);
-  },
-  'Test Set Stream Metadata Raw': function(test) {
-    this.conn.setStreamMetadataRaw(testStreamName, client.expectedVersion.emptyStream, {$maxCount: 100})
-        .then(function(result) {
-          test.done();
-        })
-        .catch(function(err) {
-          test.done(err);
-        });
-  },
-  'Test Get Stream Metadata Raw': function(test) {
-    this.conn.getStreamMetadataRaw(testStreamName)
-        .then(function(result) {
-          test.done();
-        })
-        .catch(function(err) {
-          test.done(err);
-        });
-  },
-  'Test Create Persistent Subscription': function(test) {
-    var settings = client.PersistentSubscriptionSettings.create();
-    this.conn.createPersistentSubscription(testStreamName, 'consumer-1', settings, userCredentialsForAll)
-        .then(function(result) {
-          test.done();
-        })
-        .catch(function(err) {
-          test.done(err);
-        });
-  },
-  //TODO: Update Persistent Subscription
-  'Test ConnectTo Persistent Subscription': function(test) {
-    function eventAppeared(s, e) {
-      s.stop();
-    }
-    function subscriptionDropped(connection, reason, error) {
-      test.done(error);
-    }
-    var subscription = this.conn.connectToPersistentSubscription(testStreamName, 'consumer-1', eventAppeared, subscriptionDropped);
-    this.conn.appendToStream(testStreamName, client.expectedVersion.any, [createRandomEvent()]);
-  },
-  'Test Delete Persistent Subscription': function(test) {
-    this.conn.deletePersistentSubscription(testStreamName, 'consumer-1', userCredentialsForAll)
-        .then(function(result) {
-          test.done();
-        })
-        .catch(function(err) {
-          test.done(err);
-        });
-  }/*,
-  'Test Delete Stream': function(test) {
-    this.conn.deleteStream(testStreamName, client.expectedVersion.any)
-        .then(function(result) {
-          test.ok(result, "No result.");
-          test.done();
-        })
-        .catch(function(err) {
-          test.done(err);
-        });
-  }*/
-};

test/cluster/dns_test.js

@@ -0,0 +1,32 @@
+var client = require('../../src/client');
+var uuid = require('uuid');
+
+var settings = {
+  log: {
+    info: console.log,
+    error: console.log,
+    debug: console.log
+  }
+};
+var conn = client.createConnection(settings, "discover://es.nicdex.com:2113");
+console.log('Connecting...');
+conn.on('connected', function (tcpEndPoint) {
+  console.log('Connected to', tcpEndPoint);
+  setTimeout(function () {
+    conn.appendToStream('test-' + uuid.v4(), client.expectedVersion.noStream, [
+      client.createJsonEventData(uuid.v4(), {abc: 123}, {}, 'myEvent')
+    ]);
+  }, 5000);
+});
+conn.on('error', function (err) {
+  console.log(err.stack);
+});
+conn.on('closed', function (reason) {
+  console.log('Connection closed:', reason);
+  process.exit(-1);
+});
+conn.connect()
+  .catch(function (err) {
+    console.log(err.stack);
+    process.exit(-1);
+  });

test/cluster/gossipSeeds_test.js

@@ -0,0 +1,37 @@
+var client = require('../../src/client');
+var uuid = require('uuid');
+
+var settings = {
+  log: {
+    info: console.log,
+    error: console.log,
+    debug: console.log
+  }
+};
+var gossipSeeds = [
+  new client.GossipSeed({host: '192.168.33.10', port: 2113}),
+  new client.GossipSeed({host: '192.168.33.11', port: 2113}),
+  new client.GossipSeed({host: '192.168.33.12', port: 2113})
+];
+var conn = client.createConnection(settings, gossipSeeds);
+console.log('Connecting...');
+conn.on('connected', function (tcpEndPoint) {
+  console.log('Connected to', tcpEndPoint);
+  setTimeout(function () {
+    conn.appendToStream('test-' + uuid.v4(), client.expectedVersion.noStream, [
+      client.createJsonEventData(uuid.v4(), {abc: 123}, {}, 'myEvent')
+    ]);
+  }, 5000);
+});
+conn.on('error', function (err) {
+  console.log(err.stack);
+});
+conn.on('closed', function (reason) {
+  console.log('Connection closed:', reason);
+  process.exit(-1);
+});
+conn.connect()
+  .catch(function (err) {
+    console.log(err.stack);
+    process.exit(-1);
+  });

test/common/base_test.js

@@ -34,7 +34,8 @@ function setUp(cb) {
     settings.log.error(error, "Connection to %j failed.", tcpEndPoint);
     cb(error);
   });
-  this.conn.on('connected', function () {
+  this.conn.on('connected', function (tcpEndPoint) {
+    if (connected) return;
     settings.log.debug("Connected to %j.", tcpEndPoint);
     connected = true;
     cb();
@@ -70,6 +71,32 @@ function eventEqualEventData(name, resolvedEvent, eventData) {
   this.ok(Buffer.compare(ev.metadata, eventData.metadata) === 0, name + ".originalEvent.metadata is not equal to original metadata.");
 }
 
+function testLiveEvent(name, event, evNumber) {
+  this.ok(event.event, name + ".event not defined (or null)");
+  this.ok(event.originalEvent, name + ".originalEvent not defined (or null)");
+  this.ok(event.isResolved === false, name + ".isResolved should be true");
+  this.ok(event.originalPosition instanceof client.Position, name + ".originalPosition is not an instance of Position");
+  this.ok(event.originalStreamId, name + ".originalStreamId not defined (or null)");
+  if (typeof evNumber === 'number') {
+    this.ok(event.originalEventNumber === evNumber, name + '.originalEventNumber expected ' + evNumber + ' got ' + event.originalEventNumber);
+  } else {
+    this.ok(typeof event.originalEventNumber === 'number', name + ".originalEventNumber is not a number");
+  }
+}
+
+function testReadEvent(name, event, evNumber) {
+  this.ok(event.event, name + ".event not defined (or null)");
+  this.ok(event.originalEvent, name + ".originalEvent not defined (or null)");
+  this.ok(event.isResolved === false, name + ".isResolved should be true");
+  this.ok(event.originalPosition === null, name + ".originalPosition is not null");
+  this.ok(event.originalStreamId, name + ".originalStreamId not defined (or null)");
+  if (typeof evNumber === 'number') {
+    this.ok(event.originalEventNumber === evNumber, name + '.originalEventNumber expected ' + evNumber + ' got ' + event.originalEventNumber);
+  } else {
+    this.ok(typeof event.originalEventNumber === 'number', name + ".originalEventNumber is not a number");
+  }
+}
+
 var _ = {
   'setUp': setUp,
   'tearDown': tearDown
@@ -83,6 +110,8 @@ function wrap(name, testFunc) {
       test.areEqual = areEqual.bind(test);
       test.fail = fail.bind(test);
       test.eventEqualEventData = eventEqualEventData.bind(test);
+      test.testLiveEvent = testLiveEvent.bind(test);
+      test.testReadEvent = testReadEvent.bind(test);
       return testFunc.call(this, test);
     }
   }

test/connection_test.js

@@ -1,10 +1,12 @@
 var client = require('../src/client.js');
+var GossipSeed = require('../src/gossipSeed');
 
 var testBase = require('./common/base_test');
 
 module.exports = {
   'Connect To Endpoint Happy Path': function(test) {
-    var tcpEndpoint = {hostname: 'localhost', port: 1113};
+    test.expect(1);
+    var tcpEndpoint = {host: 'localhost', port: 1113};
     var conn = client.EventStoreConnection.create(testBase.settings(), tcpEndpoint);
     conn.connect()
         .catch(function(err) {
@@ -22,15 +24,16 @@ module.exports = {
       test.done();
     }
   },
-  'Connect To Endpoint That Don\'t Exist': function(test) {
-    var tcpEndpoint = {hostname: 'localhost', port: 1114};
+  'Connect To Endpoint That Doesn\'t Exist': function(test) {
+    test.expect(1);
+    var tcpEndpoint = {host: 'localhost', port: 11112};
     var conn = client.EventStoreConnection.create(testBase.settings({maxReconnections:1}), tcpEndpoint);
     conn.connect()
         .catch(function (err) {
           test.done(err);
         });
     conn.on('connected', function () {
-      test.fail("Should not be able to connect.");
+      test.ok(false, "Should not be able to connect.");
       test.done();
     });
     conn.on('error', function (err) {
@@ -40,7 +43,36 @@ module.exports = {
       test.ok(reason.indexOf("Reconnection limit reached") === 0, "Wrong expected reason.");
       test.done();
     });
+  },
+  'Create a connection with tcp://host:port string': function(test) {
+    var conn = client.createConnection({}, 'tcp://localhost:1113');
+    conn.close();
+    test.done();
+  }/*,
+  'Connect to Cluster using gossip seeds': function (test) {
+    test.expect(1);
+    var gossipSeeds = [
+      new GossipSeed({host: 'localhost', port: 1113}),
+      new GossipSeed({host: 'localhost', port: 2113}),
+      new GossipSeed({host: 'localhost', port: 3113})
+    ];
+    var conn = client.EventStoreConnection.create(testBase.settings(), gossipSeeds);
+    conn.connect()
+      .catch(function(err) {
+        test.done(err);
+      });
+    conn.on('connected', function(endPoint){
+      test.ok(endPoint, "no endpoint");
+      done();
+    });
+    conn.on('error', done);
+
+    function done(err) {
+      conn.close();
+      if (err) return test.done(err);
+      test.done();
     }
+  }*/
 };
 
 testBase.init(module.exports, false);

test/deleteStream_test.js

@@ -14,6 +14,7 @@ module.exports = {
         .catch(cb);
   },
   'Test Delete Stream Soft Happy Path': function(test) {
+    test.expect(4);
     var self = this;
     this.conn.deleteStream(this.testStreamName, 1, false)
         .then(function(result) {
@@ -31,6 +32,7 @@ module.exports = {
         });
   },
   'Test Delete Stream Hard Happy Path': function(test) {
+    test.expect(4);
     var self = this;
     this.conn.deleteStream(this.testStreamName, 1, true)
         .then(function(result) {
@@ -48,6 +50,7 @@ module.exports = {
         });
   },
   'Test Delete Stream With Wrong Expected Version': function(test) {
+    test.expect(1);
     this.conn.deleteStream(this.testStreamName, 10)
         .then(function(result) {
           test.fail("Delete succeeded but should have failed.");
@@ -61,6 +64,7 @@ module.exports = {
         });
   },
   'Test Delete Stream With No Access': function(test) {
+    test.expect(1);
     var self = this;
     this.conn.setStreamMetadataRaw(this.testStreamName, client.expectedVersion.any, {$acl: {$d: "$admins"}})
         .then(function() {
@@ -78,6 +82,7 @@ module.exports = {
         });
   },
   'Test Delete Stream Hard When Already Deleted': function(test) {
+    test.expect(1);
     var self = this;
     this.conn.deleteStream(this.testStreamName, 1, true)
         .then(function() {

test/metadata_test.js

@@ -0,0 +1,26 @@
+var util = require('util');
+var uuid = require('uuid');
+var client = require('../src/client');
+
+module.exports = {
+  'Test Set Stream Metadata Raw': function(test) {
+    this.conn.setStreamMetadataRaw(this.testStreamName, client.expectedVersion.emptyStream, {$maxCount: 100})
+      .then(function(result) {
+        test.done();
+      })
+      .catch(function(err) {
+        test.done(err);
+      });
+  },
+  'Test Get Stream Metadata Raw': function(test) {
+    this.conn.getStreamMetadataRaw(this.testStreamName)
+      .then(function(result) {
+        test.done();
+      })
+      .catch(function(err) {
+        test.done(err);
+      });
+  }
+};
+
+require('./common/base_test').init(module.exports);

test/persistentSubscription_test.js

@@ -0,0 +1,81 @@
+var util = require('util');
+var uuid = require('uuid');
+var client = require('../src/client');
+const adminCredentials = new client.UserCredentials("admin", "changeit");
+
+function createRandomEvent() {
+  return client.createJsonEventData(uuid.v4(), {a: uuid.v4(), b: Math.random()}, {createdAt: Date.now()}, 'testEvent');
+}
+
+var testStreamName = 'test-' + uuid.v4();
+
+function delay(ms) {
+  return new Promise(function (resolve, reject) {
+    setTimeout(resolve, ms);
+  })
+}
+
+function delayOnlyFirst(count, action) {
+  if (count === 0) return action();
+  return delay(200)
+    .then(function () {
+      action();
+    })
+}
+
+module.exports = {
+  'Test Create Persistent Subscription': function(test) {
+    var settings = client.PersistentSubscriptionSettings.create();
+    this.conn.createPersistentSubscription(testStreamName, 'consumer-1', settings, adminCredentials)
+      .then(function(result) {
+        test.done();
+      })
+      .catch(function(err) {
+        test.done(err);
+      });
+  },
+  //TODO: Update Persistent Subscription
+  'Test ConnectTo Persistent Subscription': function(test) {
+    test.expect(4);
+    var receivedEvents = [];
+    var _doneCount = 0;
+    function done(err) {
+      test.ok(!err, err ? err.stack : '');
+      _doneCount++;
+      if (_doneCount < 2) return;
+      test.done();
+    }
+    function eventAppeared(s, e) {
+      return delayOnlyFirst(receivedEvents.length, function () {
+        receivedEvents.push(e);
+        if (receivedEvents.length === 2) s.stop();
+      });
+    }
+    function subscriptionDropped(connection, reason, error) {
+      if (error) return done(error);
+      test.ok(receivedEvents[1].originalEventNumber > receivedEvents[0].originalEventNumber, "Received events are out of order.");
+      done();
+    }
+    var self = this;
+    this.conn.connectToPersistentSubscription(testStreamName, 'consumer-1', eventAppeared, subscriptionDropped)
+      .then(function(subscription) {
+        test.ok(subscription, "Subscription is null.");
+        return self.conn.appendToStream(testStreamName, client.expectedVersion.any, [createRandomEvent(), createRandomEvent()]);
+      })
+      .then(function () {
+        done();
+      })
+      .catch(done);
+  },
+  'Test Delete Persistent Subscription': function(test) {
+    this.conn.deletePersistentSubscription(testStreamName, 'consumer-1', adminCredentials)
+      .then(function(result) {
+        test.done();
+      })
+      .catch(function(err) {
+        test.done(err);
+      });
+  }
+};
+
+require('./common/base_test').init(module.exports);

test/projections_test.js

@@ -0,0 +1,47 @@
+const client = require('../src/client');
+const userCredentials = new client.UserCredentials('admin', 'changeit');
+
+const log = new client.NoopLogger();
+const httpEndpoint = 'http://127.0.0.1:2113';
+const operationTimeout = 5000;
+
+const simpleProjection = "\
+fromStream('$stats-127.0.0.1:2113')\
+  .when({\
+    $init: function(){\
+      return {\
+        count: 0\
+      }\
+    },\
+    $any: function(s,e){\
+      s.count += 1;\
+    }\
+  })\
+";
+
+module.exports = {
+  setUp: function(cb) {
+    this.projectionsManager = new client.ProjectionsManager(log, httpEndpoint, operationTimeout);
+    cb();
+  },
+  'Create One Time Projection Happy Path': function(test) {
+    test.expect(1);
+
+    this.projectionsManager.createOneTime(simpleProjection, userCredentials)
+      .then(function (result) {
+        test.equal(result, undefined);
+        test.done();
+      })
+      .catch(test.done);
+  },
+  'List All Happy Path': function(test) {
+    test.expect(1);
+    this.projectionsManager.listAll(userCredentials)
+      .then(function (projections) {
+        test.ok(projections.length > 0, "no projections");
+        test.done();
+      })
+      .catch(test.done);
+  }
+  //TODO: other tests
+};

test/readAllEventsBackward_test.js

@@ -37,6 +37,7 @@ module.exports = {
         })
   },
   'Read All Events Backward Happy Path': function(test) {
+    test.expect(4 + maxCount);
     var self = this;
     this.conn.readAllEventsBackward(client.positions.end, maxCount, false, allCredentials)
         .then(function(slice) {
@@ -56,6 +57,7 @@ module.exports = {
         })
   },
   'Read All Events Backward With No Access': function(test) {
+    test.expect(1);
     this.conn.readAllEventsBackward(client.positions.end, maxCount)
         .then(function(slice) {
           test.fail("readAllEventsBackward succeeded but should have failed.");

test/readAllEventsForward_test.js

@@ -37,6 +37,7 @@ module.exports = {
         })
   },
   'Read All Events Forward Happy Path': function(test) {
+    test.expect(5 + maxCount);
     this.conn.readAllEventsForward(client.positions.start, maxCount, false, allCredentials)
         .then(function(slice) {
           test.areEqual('slice.readDirection', slice.readDirection, 'forward');
@@ -57,6 +58,7 @@ module.exports = {
         })
   },
   'Read All Events Forward With No Access': function(test) {
+    test.expect(1);
     this.conn.readAllEventsForward(client.positions.start, maxCount)
         .then(function(slice) {
           test.fail("readAllEventsForward succeeded but should have failed.");

test/readEvent_test.js

@@ -5,7 +5,10 @@ var client = require('../src/client');
 
 module.exports = {
   setUp: function(cb) {
-    this.expectedEvent = {a: uuid.v4(), b: Math.random()};
+    this.expectedEvent = {
+      a: uuid.v4(),
+      b: Math.random()
+    };
     this.expectedEventType = 'anEvent';
     this.expectedEventId = uuid.v4();
     var event = client.createJsonEventData(this.expectedEventId, this.expectedEvent, null, this.expectedEventType);
@@ -16,6 +19,7 @@ module.exports = {
       .catch(cb);
   },
   'Read Event Happy Path': function(test) {
+    test.expect(8);
     var self = this;
     this.conn.readEvent(this.testStreamName, 0)
       .then(function(result) {
@@ -35,6 +39,7 @@ module.exports = {
       })
   },
   'Read Event From Non-Existing Stream': function(test) {
+    test.expect(4);
     var anotherStream = 'test' + uuid.v4();
     this.conn.readEvent(anotherStream, 0)
       .then(function(result) {
@@ -49,6 +54,7 @@ module.exports = {
       });
   },
   'Read Event From Deleted Stream': function(test) {
+    test.expect(4);
     var self = this;
     this.conn.deleteStream(this.testStreamName, 0, true)
       .then(function() {
@@ -66,6 +72,7 @@ module.exports = {
       });
   },
   'Read Event With Inexisting Version': function(test) {
+    test.expect(4);
     var self = this;
     return self.conn.readEvent(self.testStreamName, 1)
       .then(function(result) {
@@ -80,8 +87,13 @@ module.exports = {
       });
   },
   'Read Event With No Access': function(test) {
+    test.expect(1);
     var self = this;
-    var metadata = {$acl: {$r: '$admins'}};
+    var metadata = {
+      $acl: {
+        $r: '$admins'
+      }
+    };
     this.conn.setStreamMetadataRaw(self.testStreamName, client.expectedVersion.noStream, metadata)
       .then(function() {
         return self.conn.readEvent(self.testStreamName, 0);
@@ -96,7 +108,36 @@ module.exports = {
         if (isAccessDenied) return test.done();
         test.done(err);
       });
-  }
+  },
+  'Read a Large Event': function(test) {
+    test.expect(8);
+    var self = this;
+    const largeData = Buffer.alloc(3 * 1024 * 1024, " ");
+
+    const largeEvent = client.createJsonEventData(uuid.v4(), {
+      a: largeData.toString()
+    }, null, 'largePayloadEvent');
+
+    this.conn.appendToStream(this.testStreamName, client.expectedVersion.any, largeEvent)
+      .then(function(result) {
+        self.conn.readEvent(self.testStreamName, 1)
+          .then(function(result) {
+            test.areEqual('status', result.status, client.eventReadStatus.Success);
+            test.areEqual('stream', result.stream, self.testStreamName);
+            test.areEqual('eventNumber', result.eventNumber, 1);
+            test.ok(result.event !== null, "event is null.");
+            test.ok(result.event.originalEvent !== null, "event.originalEvent is null.");
+            var event = JSON.parse(result.event.originalEvent.data.toString());
+            test.areEqual('event.eventId', result.event.originalEvent.eventId, largeEvent.eventId);
+            test.areEqual('event.eventType', result.event.originalEvent.eventType, 'largePayloadEvent');
+            test.areEqual('decoded event.data', event, JSON.parse(largeEvent.data.toString()));
+            test.done();
+          });
+      })
+      .catch(function(err) {
+        test.done(err);
+      });
+  },
 };
 
 require('./common/base_test').init(module.exports);

test/readStreamEventsBackward_test.js

@@ -16,6 +16,7 @@ module.exports = {
         .catch(cb);
   },
   'Read Stream Events Backward Happy Path': function(test) {
+    test.expect(7 + (streamSize * 6));
     var self = this;
     this.conn.readStreamEventsBackward(this.testStreamName, streamSize-1, streamSize)
         .then(function(slice) {
@@ -38,6 +39,7 @@ module.exports = {
         })
   },
   'Read Stream Events Backward With Non-Existing Stream': function(test) {
+    test.expect(4);
     var anotherStream = 'test' + uuid.v4();
     this.conn.readStreamEventsBackward(anotherStream, streamSize-1, streamSize)
         .then(function(slice) {
@@ -52,6 +54,7 @@ module.exports = {
         });
   },
   'Read Stream Events Backward With Deleted Stream': function(test) {
+    test.expect(4);
     var self = this;
     this.conn.deleteStream(this.testStreamName, streamSize-1, true)
         .then(function() {
@@ -69,6 +72,7 @@ module.exports = {
         });
   },
   'Read Stream Events Backward With Inexisting Version': function(test) {
+    test.expect(4);
     var self = this;
     return self.conn.readStreamEventsBackward(self.testStreamName, streamSize * 2, streamSize)
         .then(function(slice) {
@@ -83,6 +87,7 @@ module.exports = {
         });
   },
   'Read Stream Events Backward With No Access': function(test) {
+    test.expect(1);
     var self = this;
     var metadata = {$acl: {$r: '$admins'}};
     this.conn.setStreamMetadataRaw(self.testStreamName, client.expectedVersion.noStream, metadata)

test/readStreamEventsForward_test.js

@@ -16,6 +16,7 @@ module.exports = {
         .catch(cb);
   },
   'Read Stream Events Forward Happy Path': function(test) {
+    test.expect(7 + (streamSize * 11));
     var self = this;
     this.conn.readStreamEventsForward(this.testStreamName, 0, streamSize)
         .then(function(slice) {
@@ -28,7 +29,7 @@ module.exports = {
           test.areEqual('slice.isEndOfStream', slice.isEndOfStream, true);
           for(var i = 0; i < streamSize; i++) {
             test.eventEqualEventData('slice.events[' + i + ']', slice.events[i], self.eventsData[i]);
-            test.areEqual('slice.events[' + i + '].originalEventNumber', slice.events[i].originalEventNumber, i);
+            test.testReadEvent('slice.events[' + i + ']', slice.events[i], i);
           }
           test.done();
         })
@@ -37,6 +38,7 @@ module.exports = {
         })
   },
   'Read Stream Events Forward With Non-Existing Stream': function(test) {
+    test.expect(4);
     var anotherStream = 'test' + uuid.v4();
     this.conn.readStreamEventsForward(anotherStream, 0, streamSize)
         .then(function(slice) {
@@ -51,6 +53,7 @@ module.exports = {
         });
   },
   'Read Stream Events Forward With Deleted Stream': function(test) {
+    test.expect(4);
     var self = this;
     this.conn.deleteStream(this.testStreamName, streamSize-1, true)
         .then(function() {
@@ -68,6 +71,7 @@ module.exports = {
         });
   },
   'Read Stream Events Forward With Inexisting Version': function(test) {
+    test.expect(4);
     var self = this;
     return self.conn.readStreamEventsForward(self.testStreamName, streamSize * 2, streamSize)
         .then(function(slice) {
@@ -82,6 +86,7 @@ module.exports = {
         });
   },
   'Read Stream Events Forward With No Access': function(test) {
+    test.expect(1);
     var self = this;
     var metadata = {$acl: {$r: '$admins'}};
     this.conn.setStreamMetadataRaw(self.testStreamName, client.expectedVersion.noStream, metadata)

test/subscribeToAllFrom_test.js

@@ -0,0 +1,183 @@
+var util = require('util');
+var uuid = require('uuid');
+var client = require('../src/client');
+const allCredentials = new client.UserCredentials("admin", "changeit");
+
+function createRandomEvent() {
+  return client.createJsonEventData(uuid.v4(), {a: uuid.v4(), b: Math.random()}, {createdAt: Date.now()}, 'testEvent');
+}
+
+function delay(ms) {
+  return new Promise(function (resolve, reject) {
+    setTimeout(resolve, ms);
+  })
+}
+
+function delayOnlyFirst(count, action) {
+  if (count === 0) return action();
+  return delay(200)
+    .then(function () {
+      action();
+    })
+}
+
+module.exports = {
+  'Test Subscribe to All From (Start)': function(test) {
+    test.expect(6);
+    var self = this;
+    var liveProcessing = false;
+    var catchUpEvents = [];
+    var liveEvents = [];
+    var _doneCount = 0;
+    function done(err) {
+      test.ok(!err, err ? err.stack : '');
+      _doneCount++;
+      if (_doneCount < 2) return;
+
+      var catchUpInOrder = true;
+      for(var i = 1; i < catchUpEvents.length; i++)
+        catchUpInOrder = catchUpInOrder && (catchUpEvents[i].originalPosition.compareTo(catchUpEvents[i-1].originalPosition) > 0);
+      test.ok(catchUpInOrder, "Catch-up events are out of order.");
+
+      var liveInOrder = true;
+      for(var j = 1; j < liveEvents.length; j++)
+        liveInOrder = liveInOrder && (liveEvents[j].originalPosition.compareTo(liveEvents[j-1].originalPosition) > 0);
+      test.ok(liveInOrder, "Live events are out of order.");
+
+      test.done();
+    }
+    function eventAppeared(s, e) {
+      var isLive = liveProcessing;
+      delayOnlyFirst(isLive ? liveEvents.length : catchUpEvents.length, function() {
+        if (isLive) {
+          liveEvents.push(e);
+        } else {
+          catchUpEvents.push(e);
+        }
+        if (isLive && liveEvents.length === 2) s.stop();
+      });
+    }
+    function liveProcessingStarted() {
+      liveProcessing = true;
+      var events = [createRandomEvent(), createRandomEvent()];
+      self.conn.appendToStream(self.testStreamName, client.expectedVersion.any, events)
+          .then(function () {
+            done();
+          })
+          .catch(done);
+    }
+    function subscriptionDropped(connection, reason, error) {
+      test.ok(liveEvents.length === 2, "Expecting 2 live event, got " + liveEvents.length);
+      test.ok(catchUpEvents.length > 1, "Expecting at least 1 catchUp event, got " + catchUpEvents.length);
+      done(error);
+    }
+    var subscription = this.conn.subscribeToAllFrom(null, false, eventAppeared, liveProcessingStarted, subscriptionDropped, allCredentials);
+  },
+  'Test Subscribe to All From (Position)': function(test) {
+    test.expect(7);
+    var self = this;
+    var liveProcessing = false;
+    var catchUpEvents = [];
+    var liveEvents = [];
+    var _doneCount = 0;
+    function done(err) {
+      test.ok(!err, err ? err.stack : '');
+      _doneCount++;
+      if (_doneCount < 2) return;
+
+      var catchUpInOrder = true;
+      for(var i = 1; i < catchUpEvents.length; i++)
+        catchUpInOrder = catchUpInOrder && (catchUpEvents[i].originalPosition.compareTo(catchUpEvents[i-1].originalPosition) > 0);
+      test.ok(catchUpInOrder, "Catch-up events are out of order.");
+
+      var liveInOrder = true;
+      for(var j = 1; j < liveEvents.length; j++)
+        liveInOrder = liveInOrder && (liveEvents[j].originalPosition.compareTo(liveEvents[j-1].originalPosition) > 0);
+      test.ok(liveInOrder, "Live events are out of order.");
+
+      test.done();
+    }
+    function eventAppeared(s, e) {
+      var isLive = liveProcessing;
+      delayOnlyFirst(isLive ? liveEvents.length : catchUpEvents.length, function() {
+        if (isLive) {
+          liveEvents.push(e);
+        } else {
+          catchUpEvents.push(e);
+        }
+        if (isLive && liveEvents.length === 2) s.stop();
+      });
+    }
+    function liveProcessingStarted() {
+      liveProcessing = true;
+      var events = [createRandomEvent(), createRandomEvent()];
+      self.conn.appendToStream(self.testStreamName, client.expectedVersion.any, events)
+        .then(function () {
+          done();
+        })
+        .catch(done);
+    }
+    function subscriptionDropped(connection, reason, error) {
+      test.ok(liveEvents.length === 2, "Expecting 2 live event, got " + liveEvents.length);
+      test.ok(catchUpEvents.length > 1, "Expecting at least 1 catchUp event, got " + catchUpEvents.length);
+      done(error);
+    }
+    this.conn.readAllEventsForward(client.positions.start, 512, true, allCredentials)
+      .then(function (slice) {
+        var subscription = self.conn.subscribeToAllFrom(slice.nextPosition, false, eventAppeared, liveProcessingStarted, subscriptionDropped, allCredentials);
+        test.ok(subscription, "Subscription is null/undefined.");
+      });
+  },
+  'Test Subscribe to All From (End)': function(test) {
+    test.expect(6);
+    var self = this;
+    var liveProcessing = false;
+    var catchUpEvents = [];
+    var liveEvents = [];
+    var _doneCount = 0;
+    function done(err) {
+      test.ok(!err, err ? err.stack : '');
+      _doneCount++;
+      if (_doneCount < 2) return;
+
+      var liveInOrder = true;
+      for(var j = 1; j < liveEvents.length; j++)
+        liveInOrder = liveInOrder && (liveEvents[j].originalPosition.compareTo(liveEvents[j-1].originalPosition) > 0);
+      test.ok(liveInOrder, "Live events are out of order.");
+
+      test.done();
+    }
+    function eventAppeared(s, e) {
+      var isLive = liveProcessing;
+      delayOnlyFirst(isLive ? liveEvents.length : catchUpEvents.length, function() {
+        if (isLive) {
+          liveEvents.push(e);
+        } else {
+          catchUpEvents.push(e);
+        }
+        if (isLive && liveEvents.length === 2) s.stop();
+      });
+    }
+    function liveProcessingStarted() {
+      liveProcessing = true;
+      var events = [createRandomEvent(), createRandomEvent()];
+      self.conn.appendToStream(self.testStreamName, client.expectedVersion.any, events)
+        .then(function () {
+          done();
+        })
+        .catch(done);
+    }
+    function subscriptionDropped(connection, reason, error) {
+      test.ok(liveEvents.length === 2, "Expecting 2 live event, got " + liveEvents.length);
+      test.ok(catchUpEvents.length === 0, "Expecting 0 catchUp event, got " + catchUpEvents.length);
+      done(error);
+    }
+    this.conn.readAllEventsForward(client.positions.end, 512, true, allCredentials)
+      .then(function (slice) {
+        var subscription = self.conn.subscribeToAllFrom(slice.nextPosition, false, eventAppeared, liveProcessingStarted, subscriptionDropped, allCredentials);
+        test.ok(subscription, "Subscription is null/undefined.");
+      });
+  }
+};
+
+require('./common/base_test').init(module.exports);

test/subscribeToAll_test.js

@@ -0,0 +1,72 @@
+const uuid = require('uuid');
+const client = require('../src/client');
+const allCredentials = new client.UserCredentials("admin", "changeit");
+
+function delay(ms) {
+  return new Promise(function (resolve, reject) {
+    setTimeout(resolve, ms);
+  })
+}
+
+function delayOnlyFirst(count, action) {
+  if (count === 0) return action();
+  return delay(200)
+    .then(function () {
+      action();
+    })
+}
+
+module.exports = {
+  'Test Subscribe To All Happy Path': function(test) {
+    const resolveLinkTos = false;
+    const numberOfPublishedEvents = 5;
+    test.expect(numberOfPublishedEvents + 4);
+
+    var _doneCount = 0;
+    function done(err) {
+      test.ok(!err, err ? err.stack : '');
+      if (++_doneCount < 2) return;
+      test.done();
+    }
+
+    var publishedEvents = [];
+    for(var i=0;i<numberOfPublishedEvents;i++)
+      publishedEvents.push(client.createJsonEventData(uuid.v4(), {a: Math.random(), b: uuid.v4()}, null, 'anEvent'));
+
+    function testAllPublishedEventsAppeared() {
+      test.areEqual("receivedEvents.length", receivedEvents.length, numberOfPublishedEvents);
+    }
+    function testEventsAppearedInCorrectOrder() {
+      for (var j = 0; j < numberOfPublishedEvents; j++)
+        test.ok(receivedEvents[j].originalEvent.eventId === publishedEvents[j].eventId,
+          "receivedEvents[" + j + "] != publishedEvents[" + j + "]");
+    }
+
+    var receivedEvents = [];
+    function eventAppeared(subscription, event) {
+      delayOnlyFirst(receivedEvents.length, function() {
+        receivedEvents.push(event);
+        if (receivedEvents.length === numberOfPublishedEvents) subscription.close();
+      });
+    }
+    function subscriptionDropped(subscription, reason, error) {
+      if (error) return done(error);
+      testAllPublishedEventsAppeared();
+      testEventsAppearedInCorrectOrder();
+      done();
+    }
+    var self = this;
+    this.conn.subscribeToAll(resolveLinkTos, eventAppeared, subscriptionDropped, allCredentials)
+      .then(function(subscription) {
+        test.areEqual("subscription.isSubscribedToAll", subscription.isSubscribedToAll, true);
+
+        return self.conn.appendToStream(self.testStreamName, client.expectedVersion.emptyStream, publishedEvents);
+      })
+      .then(function () {
+        done();
+      })
+      .catch(test.done)
+  }
+};
+
+require('./common/base_test').init(module.exports);

test/subscribeToStreamFrom_test.js

@@ -0,0 +1,144 @@
+var util = require('util');
+var uuid = require('uuid');
+var client = require('../src/client');
+
+function createRandomEvent() {
+  return client.createJsonEventData(uuid.v4(), {a: uuid.v4(), b: Math.random()}, {createdAt: Date.now()}, 'testEvent');
+}
+
+function delay(ms) {
+  return new Promise(function (resolve, reject) {
+    setTimeout(resolve, ms);
+  })
+}
+
+function delayOnlyFirst(count, action) {
+  if (count === 0) return action();
+  return delay(200)
+    .then(function () {
+      action();
+    })
+}
+
+module.exports = {
+  'Test Subscribe to Stream From Beginning (null)': function(test) {
+    test.expect(36);
+    var self = this;
+    var liveProcessing = false;
+    var catchUpEvents = [];
+    var liveEvents = [];
+    var _doneCount = 0;
+
+    function done(err) {
+      test.ok(!err, err ? err.stack : '');
+      if (++_doneCount < 2) return;
+      test.done();
+    }
+
+    function eventAppeared(s, e) {
+      var isLive = liveProcessing;
+      delayOnlyFirst(isLive ? liveEvents.length : catchUpEvents.length, function() {
+        if (isLive) {
+          liveEvents.push(e);
+        } else {
+          catchUpEvents.push(e);
+        }
+        if (isLive && liveEvents.length === 2) s.stop();
+      });
+    }
+    function liveProcessingStarted() {
+      liveProcessing = true;
+      var events = [createRandomEvent(), createRandomEvent()];
+      self.conn.appendToStream(self.testStreamName, client.expectedVersion.any, events)
+          .then(function () {
+            done();
+          })
+          .catch(done);
+    }
+    function subscriptionDropped(connection, reason, error) {
+      test.ok(liveEvents.length === 2, "Expecting 2 live event, got " + liveEvents.length);
+      test.testLiveEvent('liveEvents[0]', liveEvents[0]);
+      test.testLiveEvent('liveEvents[1]', liveEvents[1]);
+      test.ok(liveEvents[0].originalEventNumber, 2);
+      test.ok(liveEvents[1].originalEventNumber, 3);
+      test.ok(catchUpEvents.length === 2, "Expecting 2 catchUp event, got " + catchUpEvents.length);
+      test.testReadEvent('catchUpEvents[0]', catchUpEvents[0]);
+      test.testReadEvent('catchUpEvents[1]', catchUpEvents[1]);
+      test.ok(liveEvents[0].originalEventNumber, 0);
+      test.ok(liveEvents[1].originalEventNumber, 1);
+      done(error);
+    }
+
+    var events = [createRandomEvent(), createRandomEvent()];
+    this.conn.appendToStream(self.testStreamName, client.expectedVersion.noStream, events)
+      .then(function() {
+        var subscription = self.conn.subscribeToStreamFrom(self.testStreamName, null, false, eventAppeared, liveProcessingStarted, subscriptionDropped);
+
+        test.areEqual("subscription.streamId", subscription.streamId, self.testStreamName);
+        test.areEqual("subscription.isSubscribedToAll", subscription.isSubscribedToAll, false);
+        test.areEqual("subscription.readBatchSize", subscription.readBatchSize, 500);
+        test.areEqual("subscription.maxPushQueueSize", subscription.maxPushQueueSize, 10000);
+      })
+      .catch(test.done);
+  },
+  'Test Subscribe to Stream From 0': function(test) {
+    test.expect(29);
+    var self = this;
+    var liveProcessing = false;
+    var catchUpEvents = [];
+    var liveEvents = [];
+    var _doneCount = 0;
+
+    function done(err) {
+      test.ok(!err, err ? err.stack : '');
+      if (++_doneCount < 2) return;
+      test.done();
+    }
+
+    function eventAppeared(s, e) {
+      var isLive = liveProcessing;
+      delayOnlyFirst(isLive ? liveEvents.length : catchUpEvents.length, function() {
+        if (isLive) {
+          liveEvents.push(e);
+        } else {
+          catchUpEvents.push(e);
+        }
+        if (isLive && liveEvents.length === 2) s.stop();
+      });
+    }
+    function liveProcessingStarted() {
+      liveProcessing = true;
+      var events = [createRandomEvent(), createRandomEvent()];
+      self.conn.appendToStream(self.testStreamName, client.expectedVersion.any, events)
+        .then(function () {
+          done();
+        })
+        .catch(done);
+    }
+    function subscriptionDropped(connection, reason, error) {
+      test.ok(liveEvents.length === 2, "Expecting 2 live event, got " + liveEvents.length);
+      test.testLiveEvent('liveEvents[0]', liveEvents[0]);
+      test.testLiveEvent('liveEvents[1]', liveEvents[1]);
+      test.ok(liveEvents[0].originalEventNumber, 2);
+      test.ok(liveEvents[1].originalEventNumber, 3);
+      test.ok(catchUpEvents.length === 1, "Expecting 1 catchUp event, got " + catchUpEvents.length);
+      test.testReadEvent('catchUpEvents[0]', catchUpEvents[0]);
+      test.ok(liveEvents[0].originalEventNumber, 1);
+      done(error);
+    }
+
+    var events = [createRandomEvent(), createRandomEvent()];
+    this.conn.appendToStream(self.testStreamName, client.expectedVersion.noStream, events)
+      .then(function() {
+        var subscription = self.conn.subscribeToStreamFrom(self.testStreamName, 0, false, eventAppeared, liveProcessingStarted, subscriptionDropped);
+
+        test.areEqual("subscription.streamId", subscription.streamId, self.testStreamName);
+        test.areEqual("subscription.isSubscribedToAll", subscription.isSubscribedToAll, false);
+        test.areEqual("subscription.readBatchSize", subscription.readBatchSize, 500);
+        test.areEqual("subscription.maxPushQueueSize", subscription.maxPushQueueSize, 10000);
+      })
+      .catch(test.done);
+  }
+};
+
+require('./common/base_test').init(module.exports);

test/subscribeToStream_test.js

@@ -0,0 +1,72 @@
+const uuid = require('uuid');
+const client = require('../src/client');
+
+function delay(ms) {
+  return new Promise(function (resolve, reject) {
+    setTimeout(resolve, ms);
+  })
+}
+
+function delayOnlyFirst(count, action) {
+  if (count === 0) return action();
+  return delay(200)
+    .then(function () {
+      action();
+    })
+}
+
+module.exports = {
+  'Test Subscribe To Stream Happy Path': function(test) {
+    const resolveLinkTos = false;
+    const numberOfPublishedEvents = 5;
+    test.expect(numberOfPublishedEvents + 6);
+    var publishedEvents = [];
+    for(var i=0;i<numberOfPublishedEvents;i++)
+      publishedEvents.push(client.createJsonEventData(uuid.v4(), {a: Math.random(), b: uuid.v4()}, null, 'anEvent'));
+
+    var _doneCount = 0;
+    function done(err) {
+      test.ok(!err, err ? err.stack : '');
+      if (++_doneCount < 2) return;
+      test.done();
+    }
+
+    function testAllPublishedEventsAppeared() {
+      test.areEqual("receivedEvents.length", receivedEvents.length, numberOfPublishedEvents);
+    }
+    function testEventsAppearedInCorrectOrder() {
+      for (var j = 0; j < numberOfPublishedEvents; j++)
+        test.ok(receivedEvents[j].originalEvent.eventId === publishedEvents[j].eventId,
+            "receivedEvents[" + j + "] != publishedEvents[" + j + "]");
+    }
+
+    var receivedEvents = [];
+    function eventAppeared(subscription, event) {
+      delayOnlyFirst(receivedEvents.length, function () {
+        receivedEvents.push(event);
+        if (receivedEvents.length === numberOfPublishedEvents) subscription.close();
+      });
+    }
+    function subscriptionDropped(subscription, reason, error) {
+      if (error) return done(error);
+      testAllPublishedEventsAppeared();
+      testEventsAppearedInCorrectOrder();
+      done();
+    }
+    var self = this;
+    this.conn.subscribeToStream(this.testStreamName, resolveLinkTos, eventAppeared, subscriptionDropped)
+        .then(function(subscription) {
+          test.areEqual("subscription.streamId", subscription.streamId, self.testStreamName);
+          test.areEqual("subscription.isSubscribedToAll", subscription.isSubscribedToAll, false);
+          test.areEqual("subscription.lastEventNumber", subscription.lastEventNumber, client.expectedVersion.emptyStream);
+
+          return self.conn.appendToStream(self.testStreamName, client.expectedVersion.emptyStream, publishedEvents);
+        })
+        .then(function () {
+          done();
+        })
+        .catch(test.done)
+  }
+};
+
+require('./common/base_test').init(module.exports);

test/transactions_test.js

@@ -0,0 +1,191 @@
+var uuid = require('uuid');
+var Long = require('long');
+var client = require('../src/client');
+
+module.exports = {
+  setUp: function(cb) {
+    cb();
+  },
+  'Start A Transaction Happy Path': function(test) {
+    test.expect(1);
+    this.conn.startTransaction(this.testStreamName, client.expectedVersion.noStream)
+        .then(function(trx) {
+          test.ok(Long.isLong(trx.transactionId), "trx.transactionId should be a Long.");
+          test.done();
+        })
+        .catch(test.done);
+  },
+  /*
+  'Start A Transaction With Wrong Expected Version': function(test) {
+    this.conn.startTransaction(this.testStreamName, 10)
+        .then(function(trx) {
+          test.fail("Start Transaction with wrong expected version succeeded.");
+          test.done();
+        })
+        .catch(function(err) {
+          var isWrongExpectedVersion = err instanceof client.WrongExpectedVersionError;
+          if (isWrongExpectedVersion) return test.done();
+          test.done(err);
+        });
+  },
+  'Start A Transaction With Deleted Stream': function(test) {
+    var self = this;
+    this.conn.deleteStream(this.testStreamName, client.expectedVersion.emptyStream)
+        .then(function() {
+          return self.conn.startTransaction(self.testStreamName, client.expectedVersion.any);
+        })
+        .then(function(trx) {
+          test.fail("Start Transaction with deleted stream succeeded.");
+          test.done();
+        })
+        .catch(function(err) {
+          var isStreamDeleted = err instanceof client.StreamDeletedError;
+          test.ok(isStreamDeleted, "Expected StreamDeletedError got " + err.constructor.name);
+          if (isStreamDeleted) return test.done();
+          test.done(err);
+        });
+  },
+  */
+  'Start A Transaction With No Access': function(test) {
+    test.expect(1);
+    var self = this;
+    var metadata = {$acl: {$w: "$admins"}};
+    this.conn.setStreamMetadataRaw(this.testStreamName, -1, metadata)
+        .then(function() {
+          return self.conn.startTransaction(self.testStreamName, client.expectedVersion.any);
+        })
+        .then(function(trx) {
+          test.fail("Start Transaction with no access succeeded.");
+          test.done();
+        })
+        .catch(function(err) {
+          var isAccessDenied = err instanceof client.AccessDeniedError;
+          test.ok(isAccessDenied, "Expected AccessDeniedError got " + err.constructor.name);
+          if (isAccessDenied) return test.done();
+          test.done(err);
+        });
+  },
+  'Continue A Transaction Happy Path': function(test) {
+    var self = this;
+    this.conn.startTransaction(this.testStreamName, client.expectedVersion.emptyStream)
+        .then(function(trx) {
+          return trx.write(client.createJsonEventData(uuid.v4(), {a: Math.random()}, null, 'anEvent'))
+              .then(function () {
+                return self.conn.continueTransaction(trx.transactionId);
+              });
+        })
+        .then(function(trx) {
+          return trx.write(client.createJsonEventData(uuid.v4(), {a: Math.random()}, null, 'anEvent'))
+              .then(function() {
+                return trx.commit();
+              })
+              .then(function() {
+                test.done();
+              });
+        })
+        .catch(test.done);
+  },
+  'Write/Commit Transaction Happy Path': function(test) {
+    test.expect(2);
+    var self = this;
+    this.conn.startTransaction(this.testStreamName, client.expectedVersion.emptyStream)
+        .then(function(trx) {
+          self.events = [];
+          for(var i = 0; i < 15; i++) {
+            var event = {a: uuid.v4(), b: Math.random()};
+            self.events.push(client.createJsonEventData(uuid.v4(), event, null, 'anEvent'));
+          }
+          return trx.write(self.events)
+              .then(function() {
+                var events = [];
+                for(var j = 0; j < 9; j++) {
+                  var event = {a: Math.random(), b: uuid.v4()};
+                  events.push(client.createJsonEventData(uuid.v4(), event, null, 'anotherEvent'));
+                }
+                Array.prototype.push.apply(self.events, events);
+                trx.write(events);
+              })
+              .then(function() {
+                return trx.commit();
+              });
+        })
+        .then(function(result) {
+          test.ok(result.logPosition, "Missing result.logPosition");
+          test.areEqual("result.nextExpectedVersion", result.nextExpectedVersion, self.events.length-1);
+          test.done();
+        })
+        .catch(test.done);
+  },
+  'Write/Commit Transaction With Wrong Expected Version': function(test) {
+    test.expect(1);
+    this.conn.startTransaction(this.testStreamName, 10)
+        .then(function(trx) {
+          return trx.write(client.createJsonEventData(uuid.v4(), {a: Math.random(), b: uuid.v4()}, null, 'anEvent'))
+              .then(function() {
+                return trx.commit();
+              });
+        })
+        .then(function() {
+          test.fail("Commit on transaction with wrong expected version succeeded.");
+          test.done();
+        })
+        .catch(function(err) {
+          var isWrongExpectedVersion = err instanceof client.WrongExpectedVersionError;
+          test.ok(isWrongExpectedVersion, "Expected WrongExpectedVersionError, but got " + err.constructor.name);
+          if (isWrongExpectedVersion) return test.done();
+          test.done(err);
+        });
+  },
+  'Write/Commit Transaction With Deleted Stream': function(test) {
+    test.expect(1);
+    var self = this;
+    this.conn.deleteStream(this.testStreamName, client.expectedVersion.emptyStream, true)
+        .then(function() {
+          return self.conn.startTransaction(self.testStreamName, client.expectedVersion.any);
+        })
+        .then(function(trx) {
+          return trx.write(client.createJsonEventData(uuid.v4(), {a: Math.random(), b: uuid.v4()}, null, 'anEvent'))
+              .then(function() {
+                return trx.commit();
+              });
+        })
+        .then(function() {
+          test.fail("Commit on transaction on deleted stream succeeded.");
+          test.done();
+        })
+        .catch(function(err) {
+          var isStreamDeleted = err instanceof client.StreamDeletedError;
+          test.ok(isStreamDeleted, "Expected StreamDeletedError, but got " + err.constructor.name);
+          if (isStreamDeleted) return test.done();
+          test.done(err);
+        });
+  },
+  'Write/Commit Transaction With No Write Access': function(test) {
+    test.expect(1);
+    var self = this;
+    this.conn.startTransaction(this.testStreamName, client.expectedVersion.any)
+        .then(function(trx) {
+          var metadata = {$acl: {$w: "$admins"}};
+          return self.conn.setStreamMetadataRaw(self.testStreamName, -1, metadata)
+              .then(function () {
+                return trx.write(client.createJsonEventData(uuid.v4(), {a: Math.random(), b: uuid.v4()}, null, 'anEvent'))
+                    .then(function () {
+                      return trx.commit();
+                    });
+              })
+        })
+        .then(function() {
+          test.fail("Commit on transaction on deleted stream succeeded.");
+          test.done();
+        })
+        .catch(function(err) {
+          var isAccessDenied = err instanceof client.AccessDeniedError;
+          test.ok(isAccessDenied, "Expected AccessDeniedError, but got " + err.constructor.name);
+          if (isAccessDenied) return test.done();
+          test.done(err);
+        });
+  }
+};
+
+require('./common/base_test').init(module.exports);
+