Improve naming of variable and properties

To clarify that address being used for connection is not a URL but
a host-port string.

Author: lutovich

src/v1/driver.js

@@ -57,16 +57,16 @@ class Driver {
   /**
    * You should not be calling this directly, instead use {@link driver}.
    * @constructor
-   * @param {string} url
+   * @param {string} hostPort
    * @param {string} userAgent
    * @param {object} token
    * @param {object} config
    * @protected
    */
-  constructor(url, userAgent, token = {}, config = {}) {
+  constructor(hostPort, userAgent, token = {}, config = {}) {
     sanitizeConfig(config);
 
-    this._url = url;
+    this._hostPort = hostPort;
     this._userAgent = userAgent;
     this._openSessions = {};
     this._sessionIdGenerator = 0;
@@ -117,13 +117,13 @@ class Driver {
    * @return {Connection} new connector-api session instance, a low level session API.
    * @access private
    */
-  _createConnection(url, release) {
+  _createConnection(hostPort, release) {
     let sessionId = this._sessionIdGenerator++;
-    let conn = connect(url, this._config, this._connectionErrorCode());
+    let conn = connect(hostPort, this._config, this._connectionErrorCode());
     let streamObserver = new _ConnectionStreamObserver(this, conn);
     conn.initialize(this._userAgent, this._token, streamObserver);
     conn._id = sessionId;
-    conn._release = () => release(url, conn);
+    conn._release = () => release(hostPort, conn);
 
     this._openSessions[sessionId] = conn;
     return conn;
@@ -186,8 +186,8 @@ class Driver {
   }
 
   // Extension point
-  _createConnectionProvider(address, connectionPool, driverOnErrorCallback) {
-    return new DirectConnectionProvider(address, connectionPool, driverOnErrorCallback);
+  _createConnectionProvider(hostPort, connectionPool, driverOnErrorCallback) {
+    return new DirectConnectionProvider(hostPort, connectionPool, driverOnErrorCallback);
   }
 
   // Extension point
@@ -204,7 +204,7 @@ class Driver {
   _getOrCreateConnectionProvider() {
     if (!this._connectionProvider) {
       const driverOnErrorCallback = this._driverOnErrorCallback.bind(this);
-      this._connectionProvider = this._createConnectionProvider(this._url, this._pool, driverOnErrorCallback);
+      this._connectionProvider = this._createConnectionProvider(this._hostPort, this._pool, driverOnErrorCallback);
     }
     return this._connectionProvider;
   }

src/v1/internal/connection-providers.js

@@ -45,24 +45,24 @@ class ConnectionProvider {
 
 export class DirectConnectionProvider extends ConnectionProvider {
 
-  constructor(address, connectionPool, driverOnErrorCallback) {
+  constructor(hostPort, connectionPool, driverOnErrorCallback) {
     super();
-    this._address = address;
+    this._hostPort = hostPort;
     this._connectionPool = connectionPool;
     this._driverOnErrorCallback = driverOnErrorCallback;
   }
 
   acquireConnection(mode) {
-    const connectionPromise = this._connectionPool.acquire(this._address);
+    const connectionPromise = this._connectionPool.acquire(this._hostPort);
     return this._withAdditionalOnErrorCallback(connectionPromise, this._driverOnErrorCallback);
   }
 }
 
 export class LoadBalancer extends ConnectionProvider {
 
-  constructor(address, routingContext, connectionPool, loadBalancingStrategy, driverOnErrorCallback) {
+  constructor(hostPort, routingContext, connectionPool, loadBalancingStrategy, driverOnErrorCallback) {
     super();
-    this._seedRouter = address;
+    this._seedRouter = hostPort;
     this._routingTable = new RoutingTable([this._seedRouter]);
     this._rediscovery = new Rediscovery(new RoutingUtil(routingContext));
     this._connectionPool = connectionPool;

src/v1/internal/connector.js

@@ -97,17 +97,17 @@ class Connection {
   /**
    * @constructor
    * @param {NodeChannel|WebSocketChannel} channel - channel with a 'write' function and a 'onmessage' callback property.
-   * @param {string} url - the hostname and port to connect to.
+   * @param {string} hostPort - the hostname and port to connect to.
    * @param {boolean} disableLosslessIntegers if this connection should convert all received integers to native JS numbers.
    */
-  constructor(channel, url, disableLosslessIntegers = false) {
+  constructor(channel, hostPort, disableLosslessIntegers = false) {
     /**
      * An ordered queue of observers, each exchange response (zero or more
      * RECORD messages followed by a SUCCESS message) we receive will be routed
      * to the next pending observer.
      */
-    this.url = url;
-    this.server = {address: url};
+    this.hostPort = hostPort;
+    this.server = {address: hostPort};
     this.creationTimestamp = Date.now();
     this._disableLosslessIntegers = disableLosslessIntegers;
     this._pendingObservers = [];
@@ -517,18 +517,18 @@ class ConnectionState {
 }
 
 /**
- * Crete new connection to the provided url.
+ * Crete new connection to the provided address.
  * @access private
- * @param {string} url - 'neo4j'-prefixed URL to Neo4j Bolt endpoint
+ * @param {string} hostPort - the Bolt endpoint to connect to
  * @param {object} config - this driver configuration
  * @param {string=null} connectionErrorCode - error code for errors raised on connection errors
  * @return {Connection} - New connection
  */
-function connect(url, config = {}, connectionErrorCode = null) {
+function connect(hostPort, config = {}, connectionErrorCode = null) {
   const Ch = config.channel || Channel;
-  const parsedUrl = urlUtil.parseDatabaseUrl(url);
-  const channelConfig = new ChannelConfig(parsedUrl, config, connectionErrorCode);
-  return new Connection(new Ch(channelConfig), parsedUrl.hostAndPort, config.disableLosslessIntegers);
+  const parsedAddress = urlUtil.parseDatabaseUrl(hostPort);
+  const channelConfig = new ChannelConfig(parsedAddress, config, connectionErrorCode);
+  return new Connection(new Ch(channelConfig), parsedAddress.hostAndPort, config.disableLosslessIntegers);
 }
 
 export {

src/v1/internal/http/http-driver.js

@@ -23,13 +23,13 @@ import HttpSessionTracker from './http-session-tracker';
 
 export default class HttpDriver extends Driver {
 
-  constructor(url, userAgent, token, config) {
-    super(url, userAgent, token, config);
+  constructor(hostPort, userAgent, token, config) {
+    super(hostPort, userAgent, token, config);
     this._sessionTracker = new HttpSessionTracker();
   }
 
   session() {
-    return new HttpSession(this._url, this._token, this._config, this._sessionTracker);
+    return new HttpSession(this._hostPort, this._token, this._config, this._sessionTracker);
   }
 
   close() {

src/v1/routing-driver.js

@@ -25,19 +25,19 @@ import LeastConnectedLoadBalancingStrategy, {LEAST_CONNECTED_STRATEGY_NAME} from
 import RoundRobinLoadBalancingStrategy, {ROUND_ROBIN_STRATEGY_NAME} from './internal/round-robin-load-balancing-strategy';
 
 /**
- * A driver that supports routing in a core-edge cluster.
+ * A driver that supports routing in a causal cluster.
  * @private
  */
 class RoutingDriver extends Driver {
 
-  constructor(url, routingContext, userAgent, token = {}, config = {}) {
-    super(url, userAgent, token, validateConfig(config));
+  constructor(hostPort, routingContext, userAgent, token = {}, config = {}) {
+    super(hostPort, userAgent, token, validateConfig(config));
     this._routingContext = routingContext;
   }
 
-  _createConnectionProvider(address, connectionPool, driverOnErrorCallback) {
+  _createConnectionProvider(hostPort, connectionPool, driverOnErrorCallback) {
     const loadBalancingStrategy = RoutingDriver._createLoadBalancingStrategy(this._config, connectionPool);
-    return new LoadBalancer(address, this._routingContext, connectionPool, loadBalancingStrategy, driverOnErrorCallback);
+    return new LoadBalancer(hostPort, this._routingContext, connectionPool, loadBalancingStrategy, driverOnErrorCallback);
   }
 
   _createSession(mode, connectionProvider, bookmark, config) {
@@ -47,14 +47,14 @@ class RoutingDriver extends Driver {
         return error;
       }
 
-      const url = conn.url;
+      const hostPort = conn.hostPort;
 
       if (error.code === SESSION_EXPIRED || isDatabaseUnavailable(error)) {
-        this._connectionProvider.forget(url);
+        this._connectionProvider.forget(hostPort);
         return error;
       } else if (isFailureToWrite(error)) {
-        this._connectionProvider.forgetWriter(url);
-        return newError('No longer possible to write to server at ' + url, SESSION_EXPIRED);
+        this._connectionProvider.forgetWriter(hostPort);
+        return newError('No longer possible to write to server at ' + hostPort, SESSION_EXPIRED);
       } else {
         return error;
       }

test/v1/session.test.js

@@ -1124,7 +1124,7 @@ describe('session', () => {
 
   function idleConnectionCount(driver) {
     const connectionProvider = driver._connectionProvider;
-    const address = connectionProvider._address;
+    const address = connectionProvider._hostPort;
     const connectionPool = connectionProvider._connectionPool;
     const idleConnections = connectionPool._pools[address];
     return idleConnections.length;