Expose server info in result summary from sessions and transactions

Exposed as a map in `result.summary.server`:

```
{
  address: 'localhost:7687',
  version: 'Neo4j/3.1.0'
}
```

Author: oskarhane

src/v1/driver.js

@@ -67,8 +67,8 @@ class Driver {
    */
   _createConnection(url, release) {
     let sessionId = this._sessionIdGenerator++;
-    let streamObserver = new _ConnectionStreamObserver(this);
     let conn = connect(url, this._config);
+    let streamObserver = new _ConnectionStreamObserver(this, conn);
     conn.initialize(this._userAgent, this._token, streamObserver);
     conn._id = sessionId;
     conn._release = () => release(url, conn);
@@ -172,9 +172,10 @@ class Driver {
 
 /** Internal stream observer used for connection state */
 class _ConnectionStreamObserver extends StreamObserver {
-  constructor(driver) {
+  constructor(driver, conn) {
     super();
     this._driver = driver;
+    this._conn = conn;
     this._hasFailed = false;
   }
 
@@ -192,6 +193,9 @@ class _ConnectionStreamObserver extends StreamObserver {
     if (this._driver.onCompleted) {
       this._driver.onCompleted(message);
     }
+    if (this._conn && message && message.server) {
+      this._conn.setServerVersion(message.server);
+    }
   }
 }
 

src/v1/internal/connector.js

@@ -196,6 +196,7 @@ class Connection {
      * to the next pending observer.
      */
     this.url = url;
+    this.server = {address: url};
     this._pendingObservers = [];
     this._currentObserver = undefined;
     this._ch = channel;
@@ -456,6 +457,10 @@ class Connection {
   _packable(value) {
       return this._packer.packable(value, (err) => this._handleFatalError(err));
   }
+
+  setServerVersion(version) {
+    this.server.version = version;
+  }
 }
 
 /**
@@ -467,16 +472,20 @@ class Connection {
  */
 function connect( url, config = {}) {
   let Ch = config.channel || Channel;
+  const host = parseHost(url);
+  const port = parsePort(url) || 7687;
+  const completeUrl = host + ':' + port;
+
   return new Connection( new Ch({
-    host: parseHost(url),
-    port: parsePort(url) || 7687,
+    host: host,
+    port: port,
     // Default to using ENCRYPTION_NON_LOCAL if trust-on-first-use is available
     encrypted : shouldEncrypt(config.encrypted, (hasFeature("trust_on_first_use") ? ENCRYPTION_NON_LOCAL : ENCRYPTION_OFF), parseHost(url)),
     // Default to using TRUST_ON_FIRST_USE if it is available
     trust : config.trust || (hasFeature("trust_on_first_use") ? "TRUST_ON_FIRST_USE" : "TRUST_CUSTOM_CA_SIGNED_CERTIFICATES"),
     trustedCertificates : config.trustedCertificates || [],
     knownHosts : config.knownHosts
-  }), url);
+  }), completeUrl);
 }
 
 export {

src/v1/result-summary.js

@@ -40,6 +40,7 @@ class ResultSummary {
     this.plan = metadata.plan || metadata.profile ? new Plan(metadata.plan || metadata.profile) : false;
     this.profile = metadata.profile ? new ProfiledPlan(metadata.profile) : false;
     this.notifications = this._buildNotifications(metadata.notifications);
+    this.server = new ServerInfo(metadata.server);
     this.resultConsumedAfter = metadata.result_consumed_after;
     this.resultAvailableAfter = metadata.result_available_after;
   }
@@ -254,6 +255,24 @@ class Notification {
   }
 }
 
+/**
+  * Class for exposing server info from a result.
+  * @access public
+  */
+class ServerInfo {
+  /**
+   * Create a ServerInfo instance
+   * @constructor
+   * @param {Object} serverMeta - Object with serverMeta data
+   */
+  constructor(serverMeta) {
+    if (serverMeta) {
+      this.address = serverMeta.address;
+      this.version = serverMeta.version;
+    }
+  }
+}
+
 const statementType = {
   READ_ONLY: 'r',
   READ_WRITE: 'rw',

src/v1/session.js

@@ -136,7 +136,8 @@ class _RunObserver extends StreamObserver {
   }
 
   meta() {
-    return this._meta;
+    const serverMeta = {server: this._conn.server};
+    return Object.assign({}, this._meta, serverMeta);
   }
 }
 

src/v1/transaction.js

@@ -128,6 +128,11 @@ class _TransactionStreamObserver extends StreamObserver {
       this._tx._onBookmark(bookmark);
     }
   }
+
+  serverMeta() {
+    const serverMeta = {server: this._conn.server};
+    return serverMeta;
+  }
 }
 
 /** internal state machine of the transaction*/
@@ -149,7 +154,7 @@ let _states = {
         conn.sync();
       }).catch(observer.onError);
 
-      return new Result( observer, statement, parameters );
+      return new Result( observer, statement, parameters, () => observer.serverMeta() );
     }
   },
 

test/v1/session.test.js

@@ -164,6 +164,29 @@ describe('session', function () {
       });
   });
 
+  it('should expose server info on successful query', function (done) {
+    //lazy way of checking the version number
+    //if server has been set we know it is at least
+    //3.1 (todo actually parse the version string)
+    if (!server) {
+      done();
+      return;
+    }
+
+    // Given
+    var statement = 'RETURN 1';
+
+    // When & Then
+    session.run(statement)
+      .then(function (result) {
+        var sum = result.summary;
+        expect(sum.server).toBeDefined();
+        expect(sum.server.address).toEqual('localhost:7687');
+        expect(sum.server.version).toBeDefined();
+        done();
+      });
+  });
+
   it('should expose execution time information when using 3.1 and onwards', function (done) {
 
     //lazy way of checking the version number

test/v1/transaction.test.js

@@ -236,4 +236,29 @@ describe('transaction', function() {
         done();
       });
   });
+
+  it('should expose server info on successful query', function (done) {
+    //lazy way of checking the version number
+    //if server has been set we know it is at least
+    //3.1 (todo actually parse the version string)
+    if (!server) {
+      done();
+      return;
+    }
+    // Given
+    var statement = 'RETURN 1';
+
+    // When & Then
+    var tx = session.beginTransaction();
+    tx.run(statement)
+      .then(function (result) {
+        var sum = result.summary;
+        expect(sum.server).toBeDefined();
+        expect(sum.server.address).toEqual('localhost:7687');
+        expect(sum.server.version).toBeDefined();
+      });
+    tx.commit().then(function() {
+      done();
+    })
+  });
 });