Expose basic metadata through summarize method.

Author: oskarhane

examples/node.js

@@ -17,36 +17,42 @@ var params = {
 var driver = neo4j.driver("neo4j://localhost");
 
 var streamSession = driver.session();
-streamSession.run(statement.join(' '), params).subscribe({
+var streamResult = streamSession.run(statement.join(' '), params);
+streamResult.subscribe({
   onNext: function(record) {
     // On receipt of RECORD
     for(var i in record) {
       console.log(i);
       console.log(record[i]);
     }
-  }, onCompleted: function(metadata) {
-    // On receipt of header summary message
+  }, onCompleted: function() {
+    var summary = streamResult.summarize();
+    //Print number of nodes created
     console.log('');
-    console.log(metadata);
+    console.log(summary.updateStatistics().nodesCreated());
     streamSession.close();
   }, onError: function(error) {
     console.log(error);
   }
 });
 
 var promiseSession = driver.session();
-promiseSession.run(statement.join(' '), params)
-  .then(function(records){
-    records.forEach(function(record) {
-      for(var i in record) {
-        console.log(i);
-        console.log(record[i]);
-      }
-    })
-  })
-  .catch(function(error) {
-    console.log(error);
-  })
-  .then(function(){
-    promiseSession.close();
+var promiseResult = promiseSession.run(statement.join(' '), params);
+promiseResult.then(function(records) {
+  records.forEach(function(record) {
+    for(var i in record) {
+      console.log(i);
+      console.log(record[i]);
+    }
   });
+  var summary = promiseResult.summarize();
+  //Print number of nodes created
+  console.log('');
+  console.log(summary.updateStatistics().nodesCreated());
+})
+.catch(function(error) {
+  console.log(error);
+})
+.then(function(){
+  promiseSession.close();
+});

lib/result.js

@@ -17,25 +17,29 @@
  * limitations under the License.
  */
 
+import neo4j from './neo4j';
+
 /**
   * A Result instance is used for retrieving request response.
   * @access public
   */
-
 class Result {
   /**
    * Inject the observer to be used.
    * @constructor
    * @param {StreamObserver} streamObserver
    */
-  constructor(streamObserver) {
+  constructor(streamObserver, statement, parameters) {
     this._streamObserver = streamObserver;
     this._p = null;
+    this._statement = statement;
+    this._parameters = parameters;
+    this.summary = {}
   }
 
   /**
    * Create and return new Promise
-   * @return {Primise} new Promise.
+   * @return {Promise} new Promise.
    */
   _createPromise() {
     if(this._p) {
@@ -87,8 +91,185 @@ class Result {
    * @return
    */
   subscribe(observer) {
+    let onCompletedOriginal = observer.onCompleted;
+    let onCompletedWrapper = (metadata) => {
+      this.summary = new ResultSummary(this._statement, this._parameters, metadata.type, metadata.stats);
+      onCompletedOriginal(metadata);
+    }
+    observer.onCompleted = onCompletedWrapper;
     this._streamObserver.subscribe(observer);
   }
+
+  /**
+   * Get a metadata summary for the statement.
+   * @return {ResultSummary} - A ResultSummary class.
+   */
+  summarize() {
+    return this.summary;
+  }
+}
+
+/**
+  * A ResultSummary instance contains structured metadata for a {Result}.
+  * @access public
+  */
+class ResultSummary {
+  /**
+   * @constructor
+   * @param {string} statement - The statement this summary is for
+   * @param {Object} parameters - Parameters for the statement
+   * @param {string} statementType - How did the statement effect the database
+   * @param {Object} statistics - Result statistics
+   */
+  constructor(statement, parameters, statementType, statistics) {
+    this.statement = statement;
+    this._parameters = parameters;
+    this.statementType = statementType;
+    this._statistics = new StatementStatistics(statistics || {});
+  }
+
+  hasPlan() {
+
+  }
+
+  hasProfile() {
+
+  }
+
+  plan() {
+
+  }
+
+  profile() {
+
+  }
+
+  /**
+   * Get the statistics
+   * @return {StatementStatistics}
+   */
+  updateStatistics() {
+    return this._statistics;
+  }
+}    
+
+/**
+  * Get statistical information for a {Result}.
+  * @access public
+  */
+class StatementStatistics {
+  /**
+   * Structurize the statistics
+   * @constructor
+   * @param {Object} statistics - Result statistics
+   */
+  constructor(statistics) {
+    this._stats = {};
+    this._stats.nodesCreated = 0;
+    this._stats.nodesDeleted = 0;
+    this._stats.relationshipsCreated = 0;
+    this._stats.relationshipsDeleted = 0;
+    this._stats.propertiesSet = 0;
+    this._stats.labelsAdded = 0;
+    this._stats.labelsRemoved = 0;
+    this._stats.indexesAdded = 0;
+    this._stats.indexesRemoved = 0;
+    this._stats.constraintsAdded = 0;
+    this._stats.constraintsRemoved = 0;
+
+    Object.keys(statistics).forEach((index) => {
+      let val = neo4j.isInt(statistics[index]) ? statistics[index].toInt() : statistics[index];
+      //To camelCase
+      this._stats[index.replace(/(\-\w)/g, function(m){return m[1].toUpperCase();})] = val;
+    });
+  }
+
+  /**
+   * Did the database get updated?
+   * @return {boolean}
+   */
+  containsUpdates() {
+    return Object.keys(this._stats).reduce((last, current) => {
+      return last + this._stats[current];
+    }, 0) > 0;
+  }
+
+  /**
+   * @return {Number} - Number of nodes created.
+   */
+  nodesCreated() {
+    return this._stats.nodesCreated;
+  }
+
+  /**
+   * @return {Number} - Number of nodes deleted.
+   */
+  nodesDeleted() {
+    return this._stats.nodesDeleted;
+  }
+
+  /**
+   * @return {Number} - Number of relationships created.
+   */
+  relationshipsCreated() {
+    return this._stats.relationshipsCreated;
+  }
+
+  /**
+   * @return {Number} - Number of nodes deleted.
+   */
+  relationshipsDeleted() {
+    return this._stats.relationshipsDeleted;
+  }
+
+  /**
+   * @return {Number} - Number of properties set.
+   */
+  propertiesSet() {
+    return this._stats.propertiesSet;
+  }
+
+  /**
+   * @return {Number} - Number of labels added.
+   */
+  labelsAdded() {
+    return this._stats.labelsAdded;
+  }
+
+  /**
+   * @return {Number} - Number of labels removed.
+   */
+  labelsRemoved() {
+    return this._stats.labelsRemoved;
+  }
+
+  /**
+   * @return {Number} - Number of indexes added.
+   */
+  indexesAdded() {
+    return this._stats.indexesAdded;
+  }
+
+  /**
+   * @return {Number} - Number of indexes removed.
+   */
+  indexesRemoved() {
+    return this._stats.indexesRemoved;
+  }
+
+  /**
+   * @return {Number} - Number of contraints added.
+   */
+  constraintsAdded() {
+    return this._stats.constraintsAdded;
+  }
+
+  /**
+   * @return {Number} - Number of contraints removed.
+   */
+  constraintsRemoved() {
+    return this._stats.constraintsRemoved;
+  }
 }
 
 export default Result;

lib/session.js

@@ -48,7 +48,7 @@ class Session {
     this._conn.run( statement, params || {}, streamObserver );
     this._conn.pullAll( streamObserver );
     this._conn.sync();
-    return new Result( streamObserver );
+    return new Result( streamObserver, statement, params );
   }
 
   /**

test/session.test.js

@@ -51,4 +51,21 @@ describe('session', function() {
       }
     )
   });
-});
+
+  it('should expose summarize method ', function(done) {
+    // Given
+    var driver = neo4j.driver("neo4j://localhost");
+    var statement = "CREATE (n:Label) RETURN n";
+    // When & Then
+    var result = driver.session().run( statement );
+    result.then(function( records ) {
+      var sum = result.summarize();
+      expect(sum.statement).toBe( statement );
+      expect(sum.updateStatistics().containsUpdates()).toBe(true);
+      expect(sum.updateStatistics().nodesCreated()).toBe(1);
+      expect(sum.statementType).toBe('rw');
+      driver.close(); 
+      done();
+    });
+  });
+});