Introduce Driver.getServerInfo method

This is part of the drivers unification initiative.

The `Driver.verifyConnectivity` method was implemented in different ways accross the drivers with
different returns value. For concistency and clarity about what the method does, the new behaviour
of the `Driver.verifyConnectivy` is check the connectivity with all the readers available and then
returns a resolve empty promise in case of success (the promise will be rejected, otherwise).

The Server Info information was moved to the method `Driver.getSeverInfo` which verifies the
connectivity and then returnt the `ServerInfo` of one of the read servers.

For keeping the backwards compatibility, the `Driver.verifyConnectivity` was depreacted in this version
and it should be replace with a version with `Promise<void>` as return value in the next major release.
`Driver.getServerInfo` should be used instead if the client code needs server information.

Author: bigmontz

packages/bolt-connection/src/connection-provider/connection-provider-direct.js

@@ -103,4 +103,8 @@ export default class DirectConnectionProvider extends PooledConnectionProvider {
       version => version >= BOLT_PROTOCOL_V4_4
     )
   }
+
+  async verifyConnectivityAndGetServerInfo () {
+    return await this._verifyConnectivityAndGetServerVersion({ address: this._address })
+  }
 }

packages/bolt-connection/src/connection-provider/connection-provider-pooled.js

@@ -19,7 +19,7 @@
 
 import { createChannelConnection, ConnectionErrorHandler } from '../connection'
 import Pool, { PoolConfig } from '../pool'
-import { error, ConnectionProvider } from 'neo4j-driver-core'
+import { error, ConnectionProvider, ServerInfo } from 'neo4j-driver-core'
 
 const { SERVICE_UNAVAILABLE } = error
 export default class PooledConnectionProvider extends ConnectionProvider {
@@ -109,6 +109,20 @@ export default class PooledConnectionProvider extends ConnectionProvider {
     return conn.close()
   }
 
+  /**
+   * Acquire a connection from the pool and return it ServerInfo
+   * @param {object} param
+   * @param {string} param.address the server address
+   * @return {Promise<ServerInfo>} the server info
+   */
+  async _verifyConnectivityAndGetServerVersion ({ address }) {
+    const connection = await this._connectionPool.acquire(address)
+    const serverInfo = new ServerInfo(connection.server, connection.protocol().version)
+    await connection.resetAndFlush().catch(() => {})
+    await connection._release()
+    return serverInfo
+  }
+
   async close () {
     // purge all idle connections in the connection pool
     await this._connectionPool.close()

packages/bolt-connection/src/connection-provider/connection-provider-routing.js

@@ -237,7 +237,24 @@ export default class RoutingConnectionProvider extends PooledConnectionProvider
     return await this._hasProtocolVersion(
       version => version >= BOLT_PROTOCOL_V4_4
     )
-  }  
+  }
+
+  async verifyConnectivityAndGetServerInfo ({ database, accessMode }) {
+    const context = { database: database || DEFAULT_DB_NAME }
+
+    const routingTable = await this._freshRoutingTable({
+      accessMode,
+      database: context.database,
+      onDatabaseNameResolved: (databaseName) => {
+        context.database = context.database || databaseName
+      }
+    })
+
+    const servers = accessMode === WRITE ? routingTable.writers : routingTable.readers
+
+    return Promise.all(servers.map(address => this._verifyConnectivityAndGetServerVersion({ address })))
+      .then(([serverInfo]) => serverInfo)
+  }
 
   forget (address, database) {
     this._routingTableRegistry.apply(database, {

packages/bolt-connection/src/pool/pool.js

@@ -71,7 +71,7 @@ class Pool {
   /**
    * Acquire and idle resource fom the pool or create a new one.
    * @param {ServerAddress} address the address for which we're acquiring.
-   * @return {Object} resource that is ready to use.
+   * @return {Promise<Object>} resource that is ready to use.
    */
   acquire (address) {
     const key = address.asKey()

packages/core/src/connection-provider.ts

@@ -19,6 +19,7 @@
 
 import Connection from './connection'
 import { bookmarks } from './internal'
+import { ServerInfo } from './result-summary'
 
 
 /**
@@ -83,6 +84,20 @@ class ConnectionProvider {
     throw Error('Not implemented')
   }
 
+  /**
+   * This method verifies the connectivity of the database by trying to acquire a connection
+   * for each server available in the cluster.
+   *
+   * @param {object} param - object parameter
+   * @property {string} param.database - the target database for the to-be-acquired connection
+   * @property {string} param.accessMode - the access mode for the to-be-acquired connection
+   *
+   * @returns {Promise<ServerInfo>} promise resolved with server info or rejected with error.
+   */
+  verifyConnectivityAndGetServerInfo(param? :{ database?: string, accessMode?: string }): Promise<ServerInfo> {
+    throw Error('Not implemented')
+  }
+
   /**
    * Closes this connection provider along with its internals (connections, pools, etc.)
    *

packages/core/src/driver.ts

@@ -157,6 +157,9 @@ class Driver {
   /**
    * Verifies connectivity of this driver by trying to open a connection with the provided driver options.
    *
+   * @deprecated This return of this method will change in 6.0.0 to not return the {@link Promise<ServerInfo>} and return a
+   * {@link Promise<void>} instead. If you need to use the server info, use {@link getServerInfo} instead.
+   *
    * @public
    * @param {Object} param - The object parameter
    * @param {string} param.database - The target database to verify connectivity for.
@@ -166,8 +169,19 @@ class Driver {
     ServerInfo
   > {
     const connectionProvider = this._getOrCreateConnectionProvider()
-    const connectivityVerifier = new ConnectivityVerifier(connectionProvider)
-    return connectivityVerifier.verify({ database })
+    return connectionProvider.verifyConnectivityAndGetServerInfo({ database, accessMode: READ })
+  }
+
+  /**
+   * Get ServerInfo for the giver database.
+   *
+   * @param {Object} param - The object parameter
+   * @param {string} param.database - The target database to verify connectivity for.
+   * @returns {Promise<void>} promise resolved with void or rejected with error.
+   */
+  getServerInfo({ database = ''}: { database?: string } = {}): Promise<ServerInfo> {
+    const connectionProvider = this._getOrCreateConnectionProvider()
+    return connectionProvider.verifyConnectivityAndGetServerInfo({ database, accessMode: READ })
   }
 
   /**

packages/neo4j-driver-lite/test/unit/index.test.ts

@@ -221,7 +221,8 @@ describe('index', () => {
         close: () => Promise.resolve(),
         supportsMultiDb: () => Promise.resolve(true),
         supportsTransactionConfig: () => Promise.resolve(true),
-        supportsUserImpersonation: () => Promise.resolve(true)
+        supportsUserImpersonation: () => Promise.resolve(true),
+        verifyConnectivityAndGetServerInfo: () => Promise.resolve(new ServerInfo({}))
       }
     })
     expect(session).toBeDefined()

packages/testkit-backend/src/request-handlers.js

@@ -381,6 +381,8 @@ export function GetFeatures (_context, _params, wire) {
       'Feature:Bolt:4.2',
       'Feature:Bolt:4.3',
       'Feature:Bolt:4.4',
+      'Feature:API:Driver:GetServerInfo',
+      'Feature:API:Driver.VerifyConnectivity',
       'Feature:API:Result.List',
       'Feature:API:Result.Peek',
       'Feature:Configuration:ConnectionAcquisitionTimeout',
@@ -410,6 +412,17 @@ export function VerifyConnectivity (context, { driverId }, wire) {
     .catch(error => wire.writeError(error))
 }
 
+export function GetServerInfo (context, { driverId }, wire) {
+  const driver = context.getDriver(driverId)
+  return driver
+    .getServerInfo()
+    .then(info => wire.writeResponse('ServerInfo', {
+      ...info,
+      protocolVersion: info.protocolVersion.toFixed(1)
+    }))
+    .catch(error => wire.writeError(error))
+}
+
 export function CheckMultiDBSupport (context, { driverId }, wire) {
   const driver = context.getDriver(driverId)
   return driver