feat: improve sending error handling

packages/core/src/agent/MessageSender.ts

@@ -10,7 +10,7 @@ import type { TransportSession } from './TransportService'
 
 import { DID_COMM_TRANSPORT_QUEUE, InjectionSymbols } from '../constants'
 import { ReturnRouteTypes } from '../decorators/transport/TransportDecorator'
-import { AriesFrameworkError } from '../error'
+import { AriesFrameworkError, MessageSendingError } from '../error'
 import { Logger } from '../logger'
 import { DidCommDocumentService } from '../modules/didcomm'
 import { getKeyDidMappingByVerificationMethod } from '../modules/dids/domain/key-type'
@@ -209,8 +209,9 @@ export class MessageSender {
 
     if (!connection.did) {
       this.logger.error(`Unable to send message using connection '${connection.id}' that doesn't have a did`)
-      throw new AriesFrameworkError(
-        `Unable to send message using connection '${connection.id}' that doesn't have a did`
+      throw new MessageSendingError(
+        `Unable to send message using connection '${connection.id}' that doesn't have a did`,
+        { outboundMessage }
       )
     }
 
@@ -277,7 +278,10 @@ export class MessageSender {
       errors,
       connection,
     })
-    throw new AriesFrameworkError(`Message is undeliverable to connection ${connection.id} (${connection.theirLabel})`)
+    throw new MessageSendingError(
+      `Message is undeliverable to connection ${connection.id} (${connection.theirLabel})`,
+      { outboundMessage }
+    )
   }
 
   public async sendMessageToService({

packages/core/src/error/MessageSendingError.ts

@@ -1,21 +1,14 @@
-import type { AgentMessage } from '../agent/AgentMessage'
-import type { BaseRecord } from '../storage/BaseRecord'
+import type { OutboundMessage } from '../types'
 
 import { AriesFrameworkError } from './AriesFrameworkError'
 
 export class MessageSendingError extends AriesFrameworkError {
-  public agentMessage: AgentMessage
-  public associatedRecord?: BaseRecord
+  public outboundMessage: OutboundMessage
   public constructor(
     message: string,
-    {
-      agentMessage,
-      associatedRecord,
-      cause,
-    }: { agentMessage: AgentMessage; associatedRecord?: BaseRecord; cause?: Error }
+    { outboundMessage, cause }: { outboundMessage: OutboundMessage; associatedRecordId?: string; cause?: Error }
   ) {
     super(message, { cause })
-    this.agentMessage = agentMessage
-    this.associatedRecord = associatedRecord
+    this.outboundMessage = outboundMessage
   }
 }

packages/core/src/modules/basic-messages/BasicMessagesModule.ts

@@ -4,7 +4,6 @@ import type { BasicMessageTags } from './repository/BasicMessageRecord'
 import { Dispatcher } from '../../agent/Dispatcher'
 import { MessageSender } from '../../agent/MessageSender'
 import { createOutboundMessage } from '../../agent/helpers'
-import { MessageSendingError } from '../../error/MessageSendingError'
 import { injectable, module } from '../../plugins'
 import { ConnectionService } from '../connections'
 
@@ -48,15 +47,9 @@ export class BasicMessagesModule {
       connection
     )
     const outboundMessage = createOutboundMessage(connection, basicMessage)
-    try {
-      await this.messageSender.sendMessage(outboundMessage)
-    } catch (error) {
-      throw new MessageSendingError(`Error sending basic message: ${error.message}`, {
-        agentMessage: basicMessage,
-        associatedRecord: basicMessageRecord,
-        cause: error,
-      })
-    }
+    outboundMessage.associatedRecordId = basicMessageRecord.id
+
+    await this.messageSender.sendMessage(outboundMessage)
     return basicMessageRecord
   }
 

packages/core/src/modules/basic-messages/__tests__/basic-messages.e2e.test.ts

@@ -10,6 +10,7 @@ import { getBaseConfig, makeConnection, waitForBasicMessage } from '../../../../
 import testLogger from '../../../../tests/logger'
 import { Agent } from '../../../agent/Agent'
 import { MessageSendingError, RecordNotFoundError } from '../../../error'
+import { BasicMessage } from '../messages'
 import { BasicMessageRecord } from '../repository'
 
 const faberConfig = getBaseConfig('Faber Basic Messages', {
@@ -87,20 +88,22 @@ describe('Basic Messages E2E', () => {
     } catch (error) {
       const thrownError = error as MessageSendingError
       expect(thrownError.message).toEqual(
-        `Error sending basic message: Message is undeliverable to connection ${aliceConnection.id} (${aliceConnection.theirLabel})`
+        `Message is undeliverable to connection ${aliceConnection.id} (${aliceConnection.theirLabel})`
       )
-      testLogger.test('Error thrown includes the message and recently created record')
-      expect(thrownError.associatedRecord).toBeInstanceOf(BasicMessageRecord)
-      expect((thrownError.associatedRecord as BasicMessageRecord).content).toBe('Hello undeliverable')
+      testLogger.test('Error thrown includes the outbound message and recently created record id')
+      expect(thrownError.outboundMessage.associatedRecordId).toBeDefined()
+      expect(thrownError.outboundMessage.payload).toBeInstanceOf(BasicMessage)
+      expect((thrownError.outboundMessage.payload as BasicMessage).content).toBe('Hello undeliverable')
 
       testLogger.test('Created record can be found and deleted by id')
-      const storedRecord = await aliceAgent.basicMessages.getById(thrownError.associatedRecord!.id)
-      expect(storedRecord).toMatchObject(thrownError.associatedRecord!)
+      const storedRecord = await aliceAgent.basicMessages.getById(thrownError.outboundMessage.associatedRecordId!)
+      expect(storedRecord).toBeInstanceOf(BasicMessageRecord)
+      expect(storedRecord.content).toBe('Hello undeliverable')
 
       await aliceAgent.basicMessages.deleteById(storedRecord.id)
-      await expect(aliceAgent.basicMessages.getById(thrownError.associatedRecord!.id)).rejects.toThrowError(
-        RecordNotFoundError
-      )
+      await expect(
+        aliceAgent.basicMessages.getById(thrownError.outboundMessage.associatedRecordId!)
+      ).rejects.toThrowError(RecordNotFoundError)
     }
     spy.mockClear()
   })

packages/core/src/types.ts

@@ -96,6 +96,7 @@ export interface OutboundMessage<T extends AgentMessage = AgentMessage> {
   connection: ConnectionRecord
   sessionId?: string
   outOfBand?: OutOfBandRecord
+  associatedRecordId?: string
 }
 
 export interface OutboundServiceMessage<T extends AgentMessage = AgentMessage> {