neo4j-driver 1.1.1 → 1.3.0

package/lib/v1/driver.js

@@ -1,68 +1,54 @@
-"use strict";
+'use strict';
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.WRITE = exports.READ = exports.Driver = undefined;
 
-var _getPrototypeOf = require("babel-runtime/core-js/object/get-prototype-of");
+var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');
 
 var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
 
-var _possibleConstructorReturn2 = require("babel-runtime/helpers/possibleConstructorReturn");
+var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');
 
 var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
 
-var _get2 = require("babel-runtime/helpers/get");
+var _get2 = require('babel-runtime/helpers/get');
 
 var _get3 = _interopRequireDefault(_get2);
 
-var _inherits2 = require("babel-runtime/helpers/inherits");
+var _inherits2 = require('babel-runtime/helpers/inherits');
 
 var _inherits3 = _interopRequireDefault(_inherits2);
 
-var _promise = require("babel-runtime/core-js/promise");
-
-var _promise2 = _interopRequireDefault(_promise);
-
-var _classCallCheck2 = require("babel-runtime/helpers/classCallCheck");
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
 
 var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
 
-var _createClass2 = require("babel-runtime/helpers/createClass");
+var _createClass2 = require('babel-runtime/helpers/createClass');
 
 var _createClass3 = _interopRequireDefault(_createClass2);
 
-var _session = require("./session");
+var _session = require('./session');
 
 var _session2 = _interopRequireDefault(_session);
 
-var _pool = require("./internal/pool");
+var _pool = require('./internal/pool');
 
 var _pool2 = _interopRequireDefault(_pool);
 
-var _connector = require("./internal/connector");
+var _connector = require('./internal/connector');
 
-var _streamObserver = require("./internal/stream-observer");
+var _streamObserver = require('./internal/stream-observer');
 
 var _streamObserver2 = _interopRequireDefault(_streamObserver);
 
-var _error = require("./error");
+var _error = require('./error');
+
+var _connectionProviders = require('./internal/connection-providers');
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var READ = 'READ',
-    WRITE = 'WRITE';
-/**
- * A driver maintains one or more {@link Session sessions} with a remote
- * Neo4j instance. Through the {@link Session sessions} you can send statements
- * and retrieve results from the database.
- *
- * Drivers are reasonably expensive to create - you should strive to keep one
- * driver instance around per Neo4j Instance you connect to.
- *
- * @access public
- */
 /**
  * Copyright (c) 2002-2017 "Neo Technology,","
  * Network Engine for Objects in Lund AB [http://neotechnology.com]
@@ -82,6 +68,19 @@ var READ = 'READ',
  * limitations under the License.
  */
 
+var READ = 'READ',
+    WRITE = 'WRITE';
+/**
+ * A driver maintains one or more {@link Session}s with a remote
+ * Neo4j instance. Through the {@link Session}s you can send statements
+ * and retrieve results from the database.
+ *
+ * Drivers are reasonably expensive to create - you should strive to keep one
+ * driver instance around per Neo4j Instance you connect to.
+ *
+ * @access public
+ */
+
 var Driver = function () {
   /**
    * You should not be calling this directly, instead use {@link driver}.
@@ -104,6 +103,13 @@ var Driver = function () {
     this._token = token;
     this._config = config;
     this._pool = new _pool2.default(this._createConnection.bind(this), this._destroyConnection.bind(this), Driver._validateConnection.bind(this), config.connectionPoolSize);
+
+    /**
+     * Reference to the connection provider. Initialized lazily by {@link _getOrCreateConnectionProvider}.
+     * @type {ConnectionProvider}
+     * @private
+     */
+    this._connectionProvider = null;
   }
 
   /**
@@ -114,10 +120,10 @@ var Driver = function () {
 
 
   (0, _createClass3.default)(Driver, [{
-    key: "_createConnection",
+    key: '_createConnection',
     value: function _createConnection(url, release) {
       var sessionId = this._sessionIdGenerator++;
-      var conn = (0, _connector.connect)(url, this._config);
+      var conn = (0, _connector.connect)(url, this._config, this._connectionErrorCode());
       var streamObserver = new _ConnectionStreamObserver(this, conn);
       conn.initialize(this._userAgent, this._token, streamObserver);
       conn._id = sessionId;
@@ -136,7 +142,7 @@ var Driver = function () {
      **/
 
   }, {
-    key: "_destroyConnection",
+    key: '_destroyConnection',
 
 
     /**
@@ -155,74 +161,67 @@ var Driver = function () {
      * will be pulling a session out of the common pool.
      *
      * This comes with some responsibility - make sure you always call
-     * {@link Session#close()} when you are done using a session, and likewise,
+     * {@link close} when you are done using a session, and likewise,
      * make sure you don't close your session before you are done using it. Once
      * it is returned to the pool, the session will be reset to a clean state and
      * made available for others to use.
      *
-     * @param {String} mode of session - optional
+     * @param {string} [mode=WRITE] the access mode of this session, allowed values are {@link READ} and {@link WRITE}.
+     * @param {string} [bookmark=null] the initial reference to some previous transaction. Value is optional and
+     * absence indicates that that the bookmark does not exist or is unknown.
      * @return {Session} new session.
      */
 
   }, {
-    key: "session",
-    value: function session(mode) {
-      var _this = this;
-
+    key: 'session',
+    value: function session(mode, bookmark) {
       var sessionMode = Driver._validateSessionMode(mode);
-      var connectionPromise = this._acquireConnection(sessionMode);
-      connectionPromise.catch(function (err) {
-        if (_this.onError && err.code === _error.SERVICE_UNAVAILABLE) {
-          _this.onError(err);
-        } else {
-          //we don't need to tell the driver about this error
-        }
-      });
-      return this._createSession(connectionPromise, this._releaseConnection(connectionPromise));
+      var connectionProvider = this._getOrCreateConnectionProvider();
+      return this._createSession(sessionMode, connectionProvider, bookmark, this._config);
     }
+  }, {
+    key: '_createConnectionProvider',
 
-    /**
-     * The returned function gets called on Session#close(), and is where we return the pooled 'connection' instance.
-     * We don't pool Session instances, to avoid users using the Session after they've called close.
-     * The `Session` object is just a thin wrapper around Connection anyway, so it makes little difference.
-     * @param {Promise} connectionPromise - promise resolved with the connection.
-     * @return {function(callback: function)} - function that releases the connection and then executes an optional callback.
-     * @protected
-     */
 
-  }, {
-    key: "_releaseConnection",
-    value: function _releaseConnection(connectionPromise) {
-      return function (userDefinedCallback) {
-        connectionPromise.then(function (conn) {
-          // Queue up a 'reset', to ensure the next user gets a clean session to work with.
-          conn.reset();
-          conn.sync();
-
-          // Return connection to the pool
-          conn._release();
-        }).catch(function (ignoredError) {});
-
-        if (userDefinedCallback) {
-          userDefinedCallback();
-        }
-      };
+    // Extension point
+    value: function _createConnectionProvider(address, connectionPool, driverOnErrorCallback) {
+      return new _connectionProviders.DirectConnectionProvider(address, connectionPool, driverOnErrorCallback);
     }
-  }, {
-    key: "_acquireConnection",
 
+    // Extension point
 
-    //Extension point
-    value: function _acquireConnection(mode) {
-      return _promise2.default.resolve(this._pool.acquire(this._url));
+  }, {
+    key: '_createSession',
+    value: function _createSession(mode, connectionProvider, bookmark, config) {
+      return new _session2.default(mode, connectionProvider, bookmark, config);
     }
 
-    //Extension point
+    // Extension point
 
   }, {
-    key: "_createSession",
-    value: function _createSession(connectionPromise, cb) {
-      return new _session2.default(connectionPromise, cb);
+    key: '_connectionErrorCode',
+    value: function _connectionErrorCode() {
+      // connection errors might result in different error codes depending on the driver
+      return _error.SERVICE_UNAVAILABLE;
+    }
+  }, {
+    key: '_getOrCreateConnectionProvider',
+    value: function _getOrCreateConnectionProvider() {
+      if (!this._connectionProvider) {
+        var driverOnErrorCallback = this._driverOnErrorCallback.bind(this);
+        this._connectionProvider = this._createConnectionProvider(this._url, this._pool, driverOnErrorCallback);
+      }
+      return this._connectionProvider;
+    }
+  }, {
+    key: '_driverOnErrorCallback',
+    value: function _driverOnErrorCallback(error) {
+      var userDefinedOnErrorCallback = this.onError;
+      if (userDefinedOnErrorCallback && error.code === _error.SERVICE_UNAVAILABLE) {
+        userDefinedOnErrorCallback(error);
+      } else {
+        // we don't need to tell the driver about this error
+      }
     }
 
     /**
@@ -232,7 +231,7 @@ var Driver = function () {
      */
 
   }, {
-    key: "close",
+    key: 'close',
     value: function close() {
       for (var sessionId in this._openSessions) {
         if (this._openSessions.hasOwnProperty(sessionId)) {
@@ -242,12 +241,12 @@ var Driver = function () {
       }
     }
   }], [{
-    key: "_validateConnection",
+    key: '_validateConnection',
     value: function _validateConnection(conn) {
       return conn.isOpen();
     }
   }, {
-    key: "_validateSessionMode",
+    key: '_validateSessionMode',
     value: function _validateSessionMode(rawMode) {
       var mode = rawMode || WRITE;
       if (mode !== READ && mode !== WRITE) {
@@ -268,19 +267,19 @@ var _ConnectionStreamObserver = function (_StreamObserver) {
   function _ConnectionStreamObserver(driver, conn) {
     (0, _classCallCheck3.default)(this, _ConnectionStreamObserver);
 
-    var _this2 = (0, _possibleConstructorReturn3.default)(this, (_ConnectionStreamObserver.__proto__ || (0, _getPrototypeOf2.default)(_ConnectionStreamObserver)).call(this));
+    var _this = (0, _possibleConstructorReturn3.default)(this, (_ConnectionStreamObserver.__proto__ || (0, _getPrototypeOf2.default)(_ConnectionStreamObserver)).call(this));
 
-    _this2._driver = driver;
-    _this2._conn = conn;
-    _this2._hasFailed = false;
-    return _this2;
+    _this._driver = driver;
+    _this._conn = conn;
+    _this._hasFailed = false;
+    return _this;
   }
 
   (0, _createClass3.default)(_ConnectionStreamObserver, [{
-    key: "onError",
+    key: 'onError',
     value: function onError(error) {
       if (!this._hasFailed) {
-        (0, _get3.default)(_ConnectionStreamObserver.prototype.__proto__ || (0, _getPrototypeOf2.default)(_ConnectionStreamObserver.prototype), "onError", this).call(this, error);
+        (0, _get3.default)(_ConnectionStreamObserver.prototype.__proto__ || (0, _getPrototypeOf2.default)(_ConnectionStreamObserver.prototype), 'onError', this).call(this, error);
         if (this._driver.onError) {
           this._driver.onError(error);
         }
@@ -288,13 +287,14 @@ var _ConnectionStreamObserver = function (_StreamObserver) {
       }
     }
   }, {
-    key: "onCompleted",
+    key: 'onCompleted',
     value: function onCompleted(message) {
       if (this._driver.onCompleted) {
         this._driver.onCompleted(message);
       }
-      if (this._conn && message && message.server) {
-        this._conn.setServerVersion(message.server);
+
+      if (this._observer && this._observer.onComplete) {
+        this._observer.onCompleted(message);
       }
     }
   }]);

package/lib/v1/error.js

@@ -45,8 +45,17 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 // A common place for constructing error objects, to keep them
 // uniform across the driver surface.
 
+/**
+ * @type {string}
+ */
 var SERVICE_UNAVAILABLE = 'ServiceUnavailable';
+/**
+ * @type {string}
+ */
 var SESSION_EXPIRED = 'SessionExpired';
+/**
+ * @type {string}
+ */
 var PROTOCOL_ERROR = 'ProtocolError';
 
 function newError(message) {

package/lib/v1/graph-types.js

@@ -48,8 +48,8 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 var Node = function () {
   /**
    * @constructor
-   * @param {string} identity - Unique identity
-   * @param {Array} labels - Array for all labels
+   * @param {Integer} identity - Unique identity
+   * @param {Array<string>} labels - Array for all labels
    * @param {Object} properties - Map with node properties
    */
   function Node(identity, labels, properties) {
@@ -91,9 +91,9 @@ var Node = function () {
 var Relationship = function () {
   /**
    * @constructor
-   * @param {string} identity - Unique identity
-   * @param {string} start - Identity of start Node
-   * @param {string} end - Identity of end Node
+   * @param {Integer} identity - Unique identity
+   * @param {Integer} start - Identity of start Node
+   * @param {Integer} end - Identity of end Node
    * @param {string} type - Relationship type
    * @param {Object} properties - Map with relationship properties
    */
@@ -136,7 +136,7 @@ var Relationship = function () {
 var UnboundRelationship = function () {
   /**
    * @constructor
-   * @param {string} identity - Unique identity
+   * @param {Integer} identity - Unique identity
    * @param {string} type - Relationship type
    * @param {Object} properties - Map with relationship properties
    */
@@ -150,8 +150,8 @@ var UnboundRelationship = function () {
 
   /**
    * Bind relationship
-   * @param {string} start - Indentity of start node
-   * @param {string} end - Indentity of end node
+   * @param {Integer} start - Identity of start node
+   * @param {Integer} end - Identity of end node
    * @return {Relationship} - Created relationship
    */
 
@@ -189,9 +189,9 @@ var UnboundRelationship = function () {
 var PathSegment =
 /**
  * @constructor
- * @param {string} start - Identity of start Node
- * @param {Relationship} rel - Relationship segment
- * @param {string} end - Identity of end Node
+ * @param {Node} start - start node
+ * @param {Relationship} rel - relationship that connects start and end node
+ * @param {Node} end - end node
  */
 function PathSegment(start, rel, end) {
   (0, _classCallCheck3.default)(this, PathSegment);
@@ -211,7 +211,7 @@ var Path =
  * @constructor
  * @param {Node} start  - start node
  * @param {Node} end - end node
- * @param {Array} segments - Array of Segments
+ * @param {Array<PathSegment>} segments - Array of Segments
  */
 function Path(start, end, segments) {
   (0, _classCallCheck3.default)(this, Path);

package/lib/v1/index.js

@@ -33,51 +33,59 @@ var _version = require('../version');
 
 var _version2 = _interopRequireDefault(_version);
 
-var _connector = require('./internal/connector');
-
 var _util = require('./internal/util');
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+/**
+ * Copyright (c) 2002-2017 "Neo Technology,","
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 var auth = {
   basic: function basic(username, password) {
     var realm = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
 
     if (realm) {
-      return { scheme: "basic", principal: username, credentials: password, realm: realm };
+      return { scheme: 'basic', principal: username, credentials: password, realm: realm };
     } else {
-      return { scheme: "basic", principal: username, credentials: password };
+      return { scheme: 'basic', principal: username, credentials: password };
     }
   },
+  kerberos: function kerberos(base64EncodedTicket) {
+    return {
+      scheme: 'kerberos',
+      principal: '', // This empty string is required for backwards compatibility.
+      credentials: base64EncodedTicket
+    };
+  },
   custom: function custom(principal, credentials, realm, scheme) {
     var parameters = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : undefined;
 
     if (parameters) {
-      return { scheme: scheme, principal: principal, credentials: credentials, realm: realm,
-        parameters: parameters };
+      return {
+        scheme: scheme, principal: principal, credentials: credentials, realm: realm,
+        parameters: parameters
+      };
     } else {
       return { scheme: scheme, principal: principal, credentials: credentials, realm: realm };
     }
   }
-}; /**
-    * Copyright (c) 2002-2017 "Neo Technology,","
-    * Network Engine for Objects in Lund AB [http://neotechnology.com]
-    *
-    * This file is part of Neo4j.
-    *
-    * Licensed under the Apache License, Version 2.0 (the "License");
-    * you may not use this file except in compliance with the License.
-    * You may obtain a copy of the License at
-    *
-    *     http://www.apache.org/licenses/LICENSE-2.0
-    *
-    * Unless required by applicable law or agreed to in writing, software
-    * distributed under the License is distributed on an "AS IS" BASIS,
-    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    * See the License for the specific language governing permissions and
-    * limitations under the License.
-    */
-
+};
 var USER_AGENT = "neo4j-javascript/" + _version2.default;
 
 /**
@@ -131,6 +139,16 @@ var USER_AGENT = "neo4j-javascript/" + _version2.default;
  *       // port, and this is then used to verify the host certificate does not change.
  *       // This setting has no effect unless TRUST_ON_FIRST_USE is enabled.
  *       knownHosts:"~/.neo4j/known_hosts",
+ *
+ *       // The max number of connections that are allowed idle in the pool at any time.
+ *       // Connection will be destroyed if this threshold is exceeded.
+ *       connectionPoolSize: 50,
+ *
+ *       // Specify the maximum time in milliseconds transactions are allowed to retry via
+ *       // {@link Session#readTransaction()} and {@link Session#writeTransaction()} functions. These functions
+ *       // will retry the given unit of work on `ServiceUnavailable`, `SessionExpired` and transient errors with
+ *       // exponential backoff using initial delay of 1 second. Default value is 30000 which is 30 seconds.
+ *       maxTransactionRetryTime: 30000,
  *     }
  *
  * @param {string} url The URL for the Neo4j database, for instance "bolt://localhost"
@@ -142,13 +160,17 @@ function driver(url, authToken) {
   var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
 
   (0, _util.assertString)(url, 'Bolt URL');
-  var scheme = (0, _connector.parseScheme)(url);
-  if (scheme === "bolt+routing://") {
-    return new _routingDriver2.default((0, _connector.parseUrl)(url), USER_AGENT, authToken, config);
-  } else if (scheme === "bolt://") {
-    return new _driver.Driver((0, _connector.parseUrl)(url), USER_AGENT, authToken, config);
+  var scheme = (0, _util.parseScheme)(url);
+  var routingContext = (0, _util.parseRoutingContext)(url);
+  if (scheme === 'bolt+routing://') {
+    return new _routingDriver2.default((0, _util.parseUrl)(url), routingContext, USER_AGENT, authToken, config);
+  } else if (scheme === 'bolt://') {
+    if (!(0, _util.isEmptyObjectOrNull)(routingContext)) {
+      throw new Error('Parameters are not supported with scheme \'bolt\'. Given URL: \'' + url + '\'');
+    }
+    return new _driver.Driver((0, _util.parseUrl)(url), USER_AGENT, authToken, config);
   } else {
-    throw new Error("Unknown scheme: " + scheme);
+    throw new Error('Unknown scheme: ' + scheme);
   }
 }
 

package/lib/v1/internal/ch-config.js

@@ -0,0 +1,87 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _features = require('./features');
+
+var _features2 = _interopRequireDefault(_features);
+
+var _error = require('../error');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Copyright (c) 2002-2017 "Neo Technology,","
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var ChannelConfig = function () {
+  function ChannelConfig(host, port, driverConfig, connectionErrorCode) {
+    (0, _classCallCheck3.default)(this, ChannelConfig);
+
+    this.host = host;
+    this.port = port;
+    this.encrypted = ChannelConfig._extractEncrypted(driverConfig);
+    this.trust = ChannelConfig._extractTrust(driverConfig);
+    this.trustedCertificates = ChannelConfig._extractTrustedCertificates(driverConfig);
+    this.knownHostsPath = ChannelConfig._extractKnownHostsPath(driverConfig);
+    this.connectionErrorCode = connectionErrorCode || _error.SERVICE_UNAVAILABLE;
+  }
+
+  (0, _createClass3.default)(ChannelConfig, null, [{
+    key: '_extractEncrypted',
+    value: function _extractEncrypted(driverConfig) {
+      // check if encryption was configured by the user, use explicit null check because we permit boolean value
+      var encryptionConfigured = driverConfig.encrypted == null;
+      // default to using encryption if trust-all-certificates is available
+      return encryptionConfigured ? (0, _features2.default)('trust_all_certificates') : driverConfig.encrypted;
+    }
+  }, {
+    key: '_extractTrust',
+    value: function _extractTrust(driverConfig) {
+      if (driverConfig.trust) {
+        return driverConfig.trust;
+      }
+      // default to using TRUST_ALL_CERTIFICATES if it is available
+      return (0, _features2.default)('trust_all_certificates') ? 'TRUST_ALL_CERTIFICATES' : 'TRUST_CUSTOM_CA_SIGNED_CERTIFICATES';
+    }
+  }, {
+    key: '_extractTrustedCertificates',
+    value: function _extractTrustedCertificates(driverConfig) {
+      return driverConfig.trustedCertificates || [];
+    }
+  }, {
+    key: '_extractKnownHostsPath',
+    value: function _extractKnownHostsPath(driverConfig) {
+      return driverConfig.knownHosts || null;
+    }
+  }]);
+  return ChannelConfig;
+}();
+
+exports.default = ChannelConfig;
+;

package/lib/v1/internal/ch-dummy.js

@@ -42,7 +42,12 @@ var observer = {
     */
 
 var DummyChannel = function () {
-  function DummyChannel(opts) {
+
+  /**
+   * @constructor
+   * @param {ChannelConfig} config - configuration for the new channel.
+   */
+  function DummyChannel(config) {
     (0, _classCallCheck3.default)(this, DummyChannel);
 
     this.written = [];