Add support for error cause in Neo4jError and Routing errors

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

@@ -121,7 +121,8 @@ export default class RoutingConnectionProvider extends PooledConnectionProvider
     this.forgetWriter(address, database || DEFAULT_DB_NAME)
     return newError(
       'No longer possible to write to server at ' + address,
-      SESSION_EXPIRED
+      SESSION_EXPIRED,
+      error
     )
   }
 
@@ -338,7 +339,7 @@ export default class RoutingConnectionProvider extends PooledConnectionProvider
   ) {
     // we start with seed router, no routers were probed before
     const seenRouters = []
-    let newRoutingTable = await this._fetchRoutingTableUsingSeedRouter(
+    let [newRoutingTable, error] = await this._fetchRoutingTableUsingSeedRouter(
       seenRouters,
       this._seedRouter,
       currentRoutingTable,
@@ -350,18 +351,21 @@ export default class RoutingConnectionProvider extends PooledConnectionProvider
       this._useSeedRouter = false
     } else {
       // seed router did not return a valid routing table - try to use other known routers
-      newRoutingTable = await this._fetchRoutingTableUsingKnownRouters(
+      const [newRoutingTable2, error2] = await this._fetchRoutingTableUsingKnownRouters(
         knownRouters,
         currentRoutingTable,
         bookmarks,
         impersonatedUser
       )
+      newRoutingTable = newRoutingTable2
+      error = error2 || error
     }
 
     return await this._applyRoutingTableIfPossible(
       currentRoutingTable,
       newRoutingTable,
-      onDatabaseNameResolved
+      onDatabaseNameResolved,
+      error
     )
   }
 
@@ -372,7 +376,7 @@ export default class RoutingConnectionProvider extends PooledConnectionProvider
     impersonatedUser,
     onDatabaseNameResolved
   ) {
-    let newRoutingTable = await this._fetchRoutingTableUsingKnownRouters(
+    let [newRoutingTable, error] = await this._fetchRoutingTableUsingKnownRouters(
       knownRouters,
       currentRoutingTable,
       bookmarks,
@@ -381,7 +385,7 @@ export default class RoutingConnectionProvider extends PooledConnectionProvider
 
     if (!newRoutingTable) {
       // none of the known routers returned a valid routing table - try to use seed router address for rediscovery
-      newRoutingTable = await this._fetchRoutingTableUsingSeedRouter(
+      [newRoutingTable, error] = await this._fetchRoutingTableUsingSeedRouter(
         knownRouters,
         this._seedRouter,
         currentRoutingTable,
@@ -393,7 +397,8 @@ export default class RoutingConnectionProvider extends PooledConnectionProvider
     return await this._applyRoutingTableIfPossible(
       currentRoutingTable,
       newRoutingTable,
-      onDatabaseNameResolved
+      onDatabaseNameResolved,
+      error
     )
   }
 
@@ -403,7 +408,7 @@ export default class RoutingConnectionProvider extends PooledConnectionProvider
     bookmarks,
     impersonatedUser
   ) {
-    const newRoutingTable = await this._fetchRoutingTable(
+    const [newRoutingTable, error] = await this._fetchRoutingTable(
       knownRouters,
       currentRoutingTable,
       bookmarks,
@@ -412,7 +417,7 @@ export default class RoutingConnectionProvider extends PooledConnectionProvider
 
     if (newRoutingTable) {
       // one of the known routers returned a valid routing table - use it
-      return newRoutingTable
+      return [newRoutingTable, null]
     }
 
     // returned routing table was undefined, this means a connection error happened and the last known
@@ -424,7 +429,7 @@ export default class RoutingConnectionProvider extends PooledConnectionProvider
       lastRouterIndex
     )
 
-    return null
+    return [null, error]
   }
 
   async _fetchRoutingTableUsingSeedRouter (
@@ -453,14 +458,14 @@ export default class RoutingConnectionProvider extends PooledConnectionProvider
     return [].concat.apply([], dnsResolvedAddresses)
   }
 
-  _fetchRoutingTable (routerAddresses, routingTable, bookmarks, impersonatedUser) {
+  async _fetchRoutingTable (routerAddresses, routingTable, bookmarks, impersonatedUser) {
     return routerAddresses.reduce(
       async (refreshedTablePromise, currentRouter, currentIndex) => {
-        const newRoutingTable = await refreshedTablePromise
+        const [newRoutingTable] = await refreshedTablePromise
 
         if (newRoutingTable) {
           // valid routing table was fetched - just return it, try next router otherwise
-          return newRoutingTable
+          return [newRoutingTable, null]
         } else {
           // returned routing table was undefined, this means a connection error happened and we need to forget the
           // previous router and try the next one
@@ -473,19 +478,19 @@ export default class RoutingConnectionProvider extends PooledConnectionProvider
         }
 
         // try next router
-        const session = await this._createSessionForRediscovery(
+        const [session, error] = await this._createSessionForRediscovery(
           currentRouter,
           bookmarks,
           impersonatedUser
         )
         if (session) {
           try {
-            return await this._rediscovery.lookupRoutingTableOnRouter(
+            return [await this._rediscovery.lookupRoutingTableOnRouter(
               session,
               routingTable.database,
               currentRouter,
               impersonatedUser
-            )
+            ), null]
           } catch (error) {
             return this._handleRediscoveryError(error, currentRouter)
           } finally {
@@ -494,10 +499,10 @@ export default class RoutingConnectionProvider extends PooledConnectionProvider
         } else {
           // unable to acquire connection and create session towards the current router
           // return null to signal that the next router should be tried
-          return null
+          return [null, error]
         }
       },
-      Promise.resolve(null)
+      Promise.resolve([null, null])
     )
   }
 
@@ -522,13 +527,13 @@ export default class RoutingConnectionProvider extends PooledConnectionProvider
         })
       }
 
-      return new Session({
+      return [new Session({
         mode: READ,
         database: SYSTEM_DB_NAME,
         bookmarks,
         connectionProvider,
         impersonatedUser
-      })
+      }), null]
     } catch (error) {
       return this._handleRediscoveryError(error, routerAddress)
     }
@@ -541,21 +546,23 @@ export default class RoutingConnectionProvider extends PooledConnectionProvider
       // throw when getServers procedure not found because this is clearly a configuration issue
       throw newError(
         `Server at ${routerAddress.asHostPort()} can't perform routing. Make sure you are connecting to a causal cluster`,
-        SERVICE_UNAVAILABLE
+        SERVICE_UNAVAILABLE,
+        error
       )
     }
     this._log.warn(
       `unable to fetch routing table because of an error ${error}`
     )
-    return null
+    return [null, error]
   }
 
-  async _applyRoutingTableIfPossible (currentRoutingTable, newRoutingTable, onDatabaseNameResolved) {
+  async _applyRoutingTableIfPossible (currentRoutingTable, newRoutingTable, onDatabaseNameResolved, error) {
     if (!newRoutingTable) {
       // none of routing servers returned valid routing table, throw exception
       throw newError(
         `Could not perform discovery. No routing servers available. Known routing table: ${currentRoutingTable}`,
-        SERVICE_UNAVAILABLE
+        SERVICE_UNAVAILABLE,
+        error
       )
     }
 

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

@@ -1701,6 +1701,8 @@ describe('#unit RoutingConnectionProvider', () => {
             'Server at server-non-existing-seed-router:7687 can\'t ' +
              'perform routing. Make sure you are connecting to a causal cluster'
           )
+          // Error should be the cause of the given capturedError
+          expect(capturedError).toEqual(newError(capturedError.message, capturedError.code, error))
         }
 
         expect(completed).toBe(false)
@@ -1728,6 +1730,9 @@ describe('#unit RoutingConnectionProvider', () => {
             'Could not perform discovery. ' +
             'No routing servers available. Known routing table: '
           ))
+
+          // Error should be the cause of the given capturedError
+          expect(capturedError).toEqual(newError(capturedError.message, capturedError.code, error))
         }
 
         expect(completed).toBe(false)

packages/core/src/error.ts

@@ -70,8 +70,9 @@ class Neo4jError extends Error {
    * @param {string} message - the error message
    * @param {string} code - Optional error code. Will be populated when error originates in the database.
    */
-  constructor (message: string, code: Neo4jErrorCode) {
-    super(message)
+  constructor (message: string, code: Neo4jErrorCode, cause?: Error) {
+    // @ts-expect-error
+    super(message, cause != null ? { cause } : undefined)
     this.constructor = Neo4jError
     // eslint-disable-next-line no-proto
     this.__proto__ = Neo4jError.prototype
@@ -105,8 +106,8 @@ class Neo4jError extends Error {
  * @return {Neo4jError} an {@link Neo4jError}
  * @private
  */
-function newError (message: string, code?: Neo4jErrorCode): Neo4jError {
-  return new Neo4jError(message, code ?? NOT_AVAILABLE)
+function newError (message: string, code?: Neo4jErrorCode, cause?: Error): Neo4jError {
+  return new Neo4jError(message, code ?? NOT_AVAILABLE, cause)
 }
 
 /**

packages/core/test/error.test.ts

@@ -26,6 +26,14 @@ import {
 } from '../src/error'
 
 describe('newError', () => {
+  let supportsCause = false
+  beforeAll(() => {
+    // @ts-expect-error
+    const error = new Error('a', { cause: new Error('a') })
+    // @ts-expect-error
+    supportsCause = error.cause != null
+  })
+
   ;[PROTOCOL_ERROR, SERVICE_UNAVAILABLE, SESSION_EXPIRED].forEach(
     expectedCode => {
       test(`should create Neo4jError for code ${expectedCode}`, () => {
@@ -43,6 +51,31 @@ describe('newError', () => {
     expect(error.message).toEqual('some error')
     expect(error.code).toEqual('N/A')
   })
+
+  test('should create Neo4jErro with cause', () => {
+    const cause = new Error('cause')
+    const error: Neo4jError = newError('some error', undefined, cause)
+
+    expect(error.message).toEqual('some error')
+    expect(error.code).toEqual('N/A')
+    if (supportsCause) {
+      // @ts-expect-error
+      expect(error.cause).toBe(cause)
+    } else {
+      // @ts-expect-error
+      expect(error.cause).toBeUndefined()
+    }
+  })
+
+  test.each([null, undefined])('should create Neo4jErro without cause (%s)', (cause) => {
+    // @ts-expect-error
+    const error: Neo4jError = newError('some error', undefined, cause)
+
+    expect(error.message).toEqual('some error')
+    expect(error.code).toEqual('N/A')
+    // @ts-expect-error
+    expect(error.cause).toBeUndefined()
+  })
 })
 
 describe('isRetriableError()', () => {