Add multi database support

Author: ali-ince

src/driver.js

@@ -109,12 +109,13 @@ class Driver {
 
   /**
    * Verifies connectivity of this driver by trying to open a connection with the provided driver options.
+   * @param {string} [db=''] the target database to verify connectivity for.
    * @returns {Promise<object>} promise resolved with server info or rejected with error.
    */
-  verifyConnectivity () {
+  verifyConnectivity ({ db = '' } = {}) {
     const connectionProvider = this._getOrCreateConnectionProvider()
     const connectivityVerifier = new ConnectivityVerifier(connectionProvider)
-    return connectivityVerifier.verify()
+    return connectivityVerifier.verify({ db })
   }
 
   /**
@@ -194,7 +195,13 @@ class Driver {
     const bookmark = bookmarkOrBookmarks
       ? new Bookmark(bookmarkOrBookmarks)
       : Bookmark.empty()
-    return new Session(sessionMode, connectionProvider, bookmark, this._config)
+    return new Session({
+      mode: sessionMode,
+      db,
+      connectionProvider,
+      bookmark,
+      config: this._config
+    })
   }
 
   static _validateSessionMode (rawMode) {

src/internal/connection-holder.js

@@ -18,6 +18,8 @@
  */
 
 import { newError } from '../error'
+import { assertString } from './util'
+import { ACCESS_MODE_WRITE } from './constants'
 
 /**
  * Utility to lazily initialize connections and return them back to the pool when unused.
@@ -26,10 +28,12 @@ export default class ConnectionHolder {
   /**
    * @constructor
    * @param {string} mode - the access mode for new connection holder.
+   * @param {string} db - the target database name.
    * @param {ConnectionProvider} connectionProvider - the connection provider to acquire connections from.
    */
-  constructor (mode, connectionProvider) {
+  constructor ({ mode = ACCESS_MODE_WRITE, db = '', connectionProvider } = {}) {
     this._mode = mode
+    this._db = db ? assertString(db, 'db') : ''
     this._connectionProvider = connectionProvider
     this._referenceCount = 0
     this._connectionPromise = Promise.resolve(null)
@@ -43,14 +47,23 @@ export default class ConnectionHolder {
     return this._mode
   }
 
+  /**
+   * Returns the target database name
+   * @returns {string} db name
+   */
+  db () {
+    return this._db
+  }
+
   /**
    * Make this holder initialize new connection if none exists already.
    * @return {undefined}
    */
   initializeConnection () {
     if (this._referenceCount === 0) {
       this._connectionPromise = this._connectionProvider.acquireConnection(
-        this._mode
+        this._mode,
+        this._db
       )
     }
     this._referenceCount++

src/internal/connection-providers.js

@@ -27,7 +27,7 @@ import RoutingUtil from './routing-util'
 const UNAUTHORIZED_ERROR_CODE = 'Neo.ClientError.Security.Unauthorized'
 
 class ConnectionProvider {
-  acquireConnection (mode) {
+  acquireConnection (accessMode, db) {
     throw new Error('Abstract function')
   }
 
@@ -50,7 +50,7 @@ export class DirectConnectionProvider extends ConnectionProvider {
     this._driverOnErrorCallback = driverOnErrorCallback
   }
 
-  acquireConnection (mode) {
+  acquireConnection (accessMode, db) {
     const connectionPromise = this._connectionPool.acquire(this._hostPort)
     return this._withAdditionalOnErrorCallback(
       connectionPromise,
@@ -81,7 +81,7 @@ export class LoadBalancer extends ConnectionProvider {
     this._useSeedRouter = false
   }
 
-  acquireConnection (accessMode) {
+  acquireConnection (accessMode, db) {
     const connectionPromise = this._freshRoutingTable(accessMode).then(
       routingTable => {
         if (accessMode === READ) {
@@ -282,7 +282,7 @@ export class LoadBalancer extends ConnectionProvider {
       .acquire(routerAddress)
       .then(connection => {
         const connectionProvider = new SingleConnectionProvider(connection)
-        return new Session(READ, connectionProvider)
+        return new Session({ mode: READ, connectionProvider })
       })
       .catch(error => {
         // unable to acquire connection towards the given router
@@ -340,7 +340,7 @@ export class SingleConnectionProvider extends ConnectionProvider {
     this._connection = connection
   }
 
-  acquireConnection (mode) {
+  acquireConnection (mode, db) {
     const connection = this._connection
     this._connection = null
     return Promise.resolve(connection)

src/internal/connectivity-verifier.js

@@ -37,8 +37,8 @@ export default class ConnectivityVerifier {
    * Try to obtain a working connection from the connection provider.
    * @returns {Promise<object>} promise resolved with server info or rejected with error.
    */
-  verify () {
-    return acquireAndReleaseDummyConnection(this._connectionProvider)
+  verify ({ db = '' } = {}) {
+    return acquireAndReleaseDummyConnection(this._connectionProvider, db)
   }
 }
 
@@ -47,8 +47,12 @@ export default class ConnectivityVerifier {
  * @param {ConnectionProvider} connectionProvider the provider to obtain connections from.
  * @return {Promise<object>} promise resolved with server info or rejected with error.
  */
-function acquireAndReleaseDummyConnection (connectionProvider) {
-  const connectionHolder = new ConnectionHolder(READ, connectionProvider)
+function acquireAndReleaseDummyConnection (connectionProvider, db) {
+  const connectionHolder = new ConnectionHolder({
+    mode: READ,
+    db,
+    connectionProvider
+  })
   connectionHolder.initializeConnection()
   const dummyObserver = new StreamObserver()
   const connectionPromise = connectionHolder.getConnection(dummyObserver)

src/internal/http/http-driver.js

@@ -28,12 +28,12 @@ export default class HttpDriver extends Driver {
   }
 
   session () {
-    return new HttpSession(
-      this._hostPort,
-      this._authToken,
-      this._config,
-      this._sessionTracker
-    )
+    return new HttpSession({
+      url: this._hostPort,
+      authToken: this._authToken,
+      config: this._config,
+      sessionTracker: this._sessionTracker
+    })
   }
 
   close () {

src/internal/http/http-session.js

@@ -26,16 +26,16 @@ import { EMPTY_CONNECTION_HOLDER } from '../connection-holder'
 import Result from '../../result'
 
 export default class HttpSession extends Session {
-  constructor (url, authToken, config, sessionTracker) {
-    super(WRITE, null, null, config)
+  constructor ({ url, authToken, config, db = '', sessionTracker } = {}) {
+    super({ mode: WRITE, connectionProvider: null, bookmark: null, db, config })
     this._ongoingTransactionIds = []
     this._serverInfoSupplier = createServerInfoSupplier(url)
     this._requestRunner = new HttpRequestRunner(url, authToken)
     this._sessionTracker = sessionTracker
     this._sessionTracker.sessionOpened(this)
   }
 
-  run (statement, parameters = {}) {
+  run (statement, parameters = {}, transactionConfig) {
     const { query, params } = validateStatementAndParameters(
       statement,
       parameters

src/session.js

@@ -62,16 +62,19 @@ class Session {
    * @param {Bookmark} bookmark - the initial bookmark for this session.
    * @param {Object} [config={}] - this driver configuration.
    */
-  constructor (mode, connectionProvider, bookmark, config) {
+  constructor ({ mode, connectionProvider, bookmark, db, config }) {
     this._mode = mode
-    this._readConnectionHolder = new ConnectionHolder(
-      ACCESS_MODE_READ,
+    this._db = db
+    this._readConnectionHolder = new ConnectionHolder({
+      mode: ACCESS_MODE_READ,
+      db,
       connectionProvider
-    )
-    this._writeConnectionHolder = new ConnectionHolder(
-      ACCESS_MODE_WRITE,
+    })
+    this._writeConnectionHolder = new ConnectionHolder({
+      mode: ACCESS_MODE_WRITE,
+      db,
       connectionProvider
-    )
+    })
     this._open = true
     this._hasTx = false
     this._lastBookmark = bookmark
@@ -100,7 +103,8 @@ class Session {
       connection.protocol().run(query, params, streamObserver, {
         bookmark: this._lastBookmark,
         txConfig: autoCommitTxConfig,
-        mode: this._mode
+        mode: this._mode,
+        db: this._db
       })
     )
   }

src/transaction.js

@@ -51,7 +51,8 @@ class Transaction {
         conn.protocol().beginTransaction(streamObserver, {
           bookmark: bookmark,
           txConfig: txConfig,
-          mode: this._connectionHolder.mode()
+          mode: this._connectionHolder.mode(),
+          db: this._connectionHolder.db()
         })
       )
       .catch(error => streamObserver.onError(error))
@@ -184,7 +185,8 @@ let _states = {
           conn.protocol().run(statement, parameters, observer, {
             bookmark: bookmark,
             txConfig: txConfig,
-            mode: connectionHolder.mode()
+            mode: connectionHolder.mode(),
+            db: connectionHolder.db()
           })
         )
         .catch(error => observer.onError(error))