Rename db to database to conform with other drivers

Author: ali-ince

src/driver.js

@@ -111,13 +111,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.
+   * @param {string} [database=''] the target database to verify connectivity for.
    * @returns {Promise<object>} promise resolved with server info or rejected with error.
    */
-  verifyConnectivity ({ db = '' } = {}) {
+  verifyConnectivity ({ database = '' } = {}) {
     const connectionProvider = this._getOrCreateConnectionProvider()
     const connectivityVerifier = new ConnectivityVerifier(connectionProvider)
-    return connectivityVerifier.verify({ db })
+    return connectivityVerifier.verify({ database })
   }
 
   /**
@@ -194,13 +194,13 @@ class Driver {
    * @param {string} [defaultAccessMode=WRITE] the access mode of this session, allowed values are {@link READ} and {@link WRITE}.
    * @param {string|string[]} [bookmarks=null] the initial reference or references to some previous
    * transactions. Value is optional and absence indicates that that the bookmarks do not exist or are unknown.
-   * @param {string} [db=''] the database this session will connect to.
+   * @param {string} [database=''] the database this session will connect to.
    * @return {Session} new session.
    */
   session ({
     defaultAccessMode = WRITE,
     bookmarks: bookmarkOrBookmarks,
-    db = ''
+    database = ''
   } = {}) {
     const sessionMode = Driver._validateSessionMode(defaultAccessMode)
     const connectionProvider = this._getOrCreateConnectionProvider()
@@ -209,7 +209,7 @@ class Driver {
       : Bookmark.empty()
     return new Session({
       mode: sessionMode,
-      db,
+      database,
       connectionProvider,
       bookmark,
       config: this._config

src/internal/bolt-protocol-util.js

@@ -39,12 +39,12 @@ function assertTxConfigIsEmpty (txConfig, connection, observer) {
 
 /**
  * Asserts that the passed-in database name is empty.
- * @param {string} db
+ * @param {string} database
  * @param {Connection} connection
  * @param {StreamObserver} observer
  */
-function assertDbIsEmpty (db, connection, observer) {
-  if (db) {
+function assertDatabaseIsEmpty (database, connection, observer) {
+  if (database) {
     const error = newError(
       'Driver is connected to the database that does not support multiple databases. ' +
         'Please upgrade to neo4j 4.0.0 or later in order to use this functionality'
@@ -57,4 +57,4 @@ function assertDbIsEmpty (db, connection, observer) {
   }
 }
 
-export { assertDbIsEmpty, assertTxConfigIsEmpty }
+export { assertDatabaseIsEmpty, assertTxConfigIsEmpty }

src/internal/bolt-protocol-v1.js

@@ -21,7 +21,10 @@ import * as v1 from './packstream-v1'
 import Bookmark from './bookmark'
 import TxConfig from './tx-config'
 import { ACCESS_MODE_WRITE } from './constants'
-import { assertDbIsEmpty, assertTxConfigIsEmpty } from './bolt-protocol-util'
+import {
+  assertDatabaseIsEmpty,
+  assertTxConfigIsEmpty
+} from './bolt-protocol-util'
 
 export default class BoltProtocol {
   /**
@@ -81,12 +84,12 @@ export default class BoltProtocol {
    * @param {StreamObserver} observer the response observer.
    * @param {Bookmark} bookmark the bookmark.
    * @param {TxConfig} txConfig the configuration.
-   * @param {string} db the target database name.
+   * @param {string} database the target database name.
    * @param {string} mode the access mode.
    */
-  beginTransaction (observer, { bookmark, txConfig, db, mode }) {
+  beginTransaction (observer, { bookmark, txConfig, database, mode }) {
     assertTxConfigIsEmpty(txConfig, this._connection, observer)
-    assertDbIsEmpty(db, this._connection, observer)
+    assertDatabaseIsEmpty(database, this._connection, observer)
 
     const runMessage = RequestMessage.run(
       'BEGIN',
@@ -133,14 +136,14 @@ export default class BoltProtocol {
    * @param {StreamObserver} observer the response observer.
    * @param {Bookmark} bookmark the bookmark.
    * @param {TxConfig} txConfig the auto-commit transaction configuration.
-   * @param {string} db the target database name.
+   * @param {string} database the target database name.
    * @param {string} mode the access mode.
    */
-  run (statement, parameters, observer, { bookmark, txConfig, db, mode }) {
+  run (statement, parameters, observer, { bookmark, txConfig, database, mode }) {
     // bookmark and mode are ignored in this version of the protocol
     assertTxConfigIsEmpty(txConfig, this._connection, observer)
-    // passing in a db name on this protocol version throws an error
-    assertDbIsEmpty(db, this._connection, observer)
+    // passing in a database name on this protocol version throws an error
+    assertDatabaseIsEmpty(database, this._connection, observer)
 
     const runMessage = RequestMessage.run(statement, parameters)
     const pullAllMessage = RequestMessage.pullAll()

src/internal/bolt-protocol-v3.js

@@ -18,7 +18,7 @@
  */
 import BoltProtocolV2 from './bolt-protocol-v2'
 import RequestMessage from './request-message'
-import { assertDbIsEmpty } from './bolt-protocol-util'
+import { assertDatabaseIsEmpty } from './bolt-protocol-util'
 
 export default class BoltProtocol extends BoltProtocolV2 {
   transformMetadata (metadata) {
@@ -48,8 +48,8 @@ export default class BoltProtocol extends BoltProtocolV2 {
     this._connection.write(message, observer, true)
   }
 
-  beginTransaction (observer, { bookmark, txConfig, db, mode }) {
-    assertDbIsEmpty(db, this._connection, observer)
+  beginTransaction (observer, { bookmark, txConfig, database, mode }) {
+    assertDatabaseIsEmpty(database, this._connection, observer)
     prepareToHandleSingleResponse(observer)
     const message = RequestMessage.begin({ bookmark, txConfig, mode })
     this._connection.write(message, observer, true)
@@ -67,9 +67,9 @@ export default class BoltProtocol extends BoltProtocolV2 {
     this._connection.write(message, observer, true)
   }
 
-  run (statement, parameters, observer, { bookmark, txConfig, db, mode }) {
-    // passing in a db name on this protocol version throws an error
-    assertDbIsEmpty(db, this._connection, observer)
+  run (statement, parameters, observer, { bookmark, txConfig, database, mode }) {
+    // passing in a database name on this protocol version throws an error
+    assertDatabaseIsEmpty(database, this._connection, observer)
 
     const runMessage = RequestMessage.runWithMetadata(statement, parameters, {
       bookmark,

src/internal/bolt-protocol-v4.js

@@ -20,16 +20,16 @@ import BoltProtocolV3 from './bolt-protocol-v3'
 import RequestMessage from './request-message'
 
 export default class BoltProtocol extends BoltProtocolV3 {
-  beginTransaction (observer, { bookmark, txConfig, db, mode }) {
-    const message = RequestMessage.begin({ bookmark, txConfig, db, mode })
+  beginTransaction (observer, { bookmark, txConfig, database, mode }) {
+    const message = RequestMessage.begin({ bookmark, txConfig, database, mode })
     this._connection.write(message, observer, true)
   }
 
-  run (statement, parameters, observer, { bookmark, txConfig, db, mode }) {
+  run (statement, parameters, observer, { bookmark, txConfig, database, mode }) {
     const runMessage = RequestMessage.runWithMetadata(statement, parameters, {
       bookmark,
       txConfig,
-      db,
+      database,
       mode
     })
     const pullMessage = RequestMessage.pull()

src/internal/connection-holder.js

@@ -28,12 +28,16 @@ export default class ConnectionHolder {
   /**
    * @constructor
    * @param {string} mode - the access mode for new connection holder.
-   * @param {string} db - the target database name.
+   * @param {string} database - the target database name.
    * @param {ConnectionProvider} connectionProvider - the connection provider to acquire connections from.
    */
-  constructor ({ mode = ACCESS_MODE_WRITE, db = '', connectionProvider } = {}) {
+  constructor ({
+    mode = ACCESS_MODE_WRITE,
+    database = '',
+    connectionProvider
+  } = {}) {
     this._mode = mode
-    this._db = db ? assertString(db, 'db') : ''
+    this._database = database ? assertString(database, 'database') : ''
     this._connectionProvider = connectionProvider
     this._referenceCount = 0
     this._connectionPromise = Promise.resolve(null)
@@ -49,10 +53,10 @@ export default class ConnectionHolder {
 
   /**
    * Returns the target database name
-   * @returns {string} db name
+   * @returns {string} the database name
    */
-  db () {
-    return this._db
+  database () {
+    return this._database
   }
 
   /**
@@ -63,7 +67,7 @@ export default class ConnectionHolder {
     if (this._referenceCount === 0) {
       this._connectionPromise = this._connectionProvider.acquireConnection(
         this._mode,
-        this._db
+        this._database
       )
     }
     this._referenceCount++

src/internal/connection-providers.js

@@ -28,7 +28,7 @@ import { HostNameResolver } from './node'
 const UNAUTHORIZED_ERROR_CODE = 'Neo.ClientError.Security.Unauthorized'
 
 class ConnectionProvider {
-  acquireConnection (accessMode, db) {
+  acquireConnection (accessMode, database) {
     throw new Error('Abstract function')
   }
 
@@ -51,7 +51,7 @@ export class DirectConnectionProvider extends ConnectionProvider {
     this._driverOnErrorCallback = driverOnErrorCallback
   }
 
-  acquireConnection (accessMode, db) {
+  acquireConnection (accessMode, database) {
     const connectionPromise = this._connectionPool.acquire(this._address)
     return this._withAdditionalOnErrorCallback(
       connectionPromise,
@@ -83,7 +83,7 @@ export class LoadBalancer extends ConnectionProvider {
     this._useSeedRouter = true
   }
 
-  acquireConnection (accessMode, db) {
+  acquireConnection (accessMode, database) {
     const connectionPromise = this._freshRoutingTable(accessMode).then(
       routingTable => {
         if (accessMode === READ) {
@@ -357,7 +357,7 @@ export class SingleConnectionProvider extends ConnectionProvider {
     this._connection = connection
   }
 
-  acquireConnection (mode, db) {
+  acquireConnection (mode, database) {
     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 ({ db = '' } = {}) {
-    return acquireAndReleaseDummyConnection(this._connectionProvider, db)
+  verify ({ database = '' } = {}) {
+    return acquireAndReleaseDummyConnection(this._connectionProvider, database)
   }
 }
 
@@ -47,10 +47,10 @@ 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, db) {
+function acquireAndReleaseDummyConnection (connectionProvider, database) {
   const connectionHolder = new ConnectionHolder({
     mode: READ,
-    db,
+    database,
     connectionProvider
   })
   connectionHolder.initializeConnection()

src/internal/http/http-session.js

@@ -26,8 +26,14 @@ import { EMPTY_CONNECTION_HOLDER } from '../connection-holder'
 import Result from '../../result'
 
 export default class HttpSession extends Session {
-  constructor ({ url, authToken, config, db = '', sessionTracker } = {}) {
-    super({ mode: WRITE, connectionProvider: null, bookmark: null, db, config })
+  constructor ({ url, authToken, config, database = '', sessionTracker } = {}) {
+    super({
+      mode: WRITE,
+      connectionProvider: null,
+      bookmark: null,
+      database,
+      config
+    })
     this._ongoingTransactionIds = []
     this._serverInfoSupplier = createServerInfoSupplier(url)
     this._requestRunner = new HttpRequestRunner(url, authToken)

src/internal/request-message.js

@@ -115,12 +115,12 @@ export default class RequestMessage {
    * Create a new BEGIN message.
    * @param {Bookmark} bookmark the bookmark.
    * @param {TxConfig} txConfig the configuration.
-   * @param {string} db the database name.
+   * @param {string} database the database name.
    * @param {string} mode the access mode.
    * @return {RequestMessage} new BEGIN message.
    */
-  static begin ({ bookmark, txConfig, db, mode } = {}) {
-    const metadata = buildTxMetadata(bookmark, txConfig, db, mode)
+  static begin ({ bookmark, txConfig, database, mode } = {}) {
+    const metadata = buildTxMetadata(bookmark, txConfig, database, mode)
     return new RequestMessage(
       BEGIN,
       [metadata],
@@ -150,16 +150,16 @@ export default class RequestMessage {
    * @param {object} parameters the statement parameters.
    * @param {Bookmark} bookmark the bookmark.
    * @param {TxConfig} txConfig the configuration.
-   * @param {string} db the database name.
+   * @param {string} database the database name.
    * @param {string} mode the access mode.
    * @return {RequestMessage} new RUN message with additional metadata.
    */
   static runWithMetadata (
     statement,
     parameters,
-    { bookmark, txConfig, db, mode } = {}
+    { bookmark, txConfig, database, mode } = {}
   ) {
-    const metadata = buildTxMetadata(bookmark, txConfig, db, mode)
+    const metadata = buildTxMetadata(bookmark, txConfig, database, mode)
     return new RequestMessage(
       RUN,
       [statement, parameters, metadata],
@@ -213,11 +213,11 @@ export default class RequestMessage {
  * Create an object that represent transaction metadata.
  * @param {Bookmark} bookmark the bookmark.
  * @param {TxConfig} txConfig the configuration.
- * @param {string} db the database name.
+ * @param {string} database the database name.
  * @param {string} mode the access mode.
  * @return {object} a metadata object.
  */
-function buildTxMetadata (bookmark, txConfig, db, mode) {
+function buildTxMetadata (bookmark, txConfig, database, mode) {
   const metadata = {}
   if (!bookmark.isEmpty()) {
     metadata['bookmarks'] = bookmark.values()
@@ -228,8 +228,8 @@ function buildTxMetadata (bookmark, txConfig, db, mode) {
   if (txConfig.metadata) {
     metadata['tx_metadata'] = txConfig.metadata
   }
-  if (db) {
-    metadata['db'] = assertString(db, 'db')
+  if (database) {
+    metadata['db'] = assertString(database, 'database')
   }
   if (mode === ACCESS_MODE_READ) {
     metadata['mode'] = READ_MODE