2060-io
diff --git a/‎packages/core/src/agent/AgentConfig.ts‎
Lines changed: 10 additions & 0 deletions b/‎packages/core/src/agent/AgentConfig.ts‎
Lines changed: 10 additions & 0 deletions
diff --git a/‎packages/core/src/agent/MessageSender.ts‎
Lines changed: 8 additions & 4 deletions b/‎packages/core/src/agent/MessageSender.ts‎
Lines changed: 8 additions & 4 deletions
diff --git a/‎packages/core/src/error/MessageSendingError.ts‎
Lines changed: 11 additions & 0 deletions b/‎packages/core/src/error/MessageSendingError.ts‎
Lines changed: 11 additions & 0 deletions
diff --git a/‎packages/core/src/error/index.ts‎
Lines changed: 1 addition & 0 deletions b/‎packages/core/src/error/index.ts‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎packages/core/src/index.ts‎
Lines changed: 1 addition & 1 deletion b/‎packages/core/src/index.ts‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎packages/core/src/modules/action-menu/services/ActionMenuService.ts‎
Lines changed: 5 additions & 0 deletions b/‎packages/core/src/modules/action-menu/services/ActionMenuService.ts‎
Lines changed: 5 additions & 0 deletions
diff --git a/‎packages/core/src/modules/basic-messages/BasicMessagesApi.ts‎
Lines changed: 48 additions & 3 deletions b/‎packages/core/src/modules/basic-messages/BasicMessagesApi.ts‎
Lines changed: 48 additions & 3 deletions
diff --git a/‎packages/core/src/modules/basic-messages/__tests__/BasicMessageService.test.ts‎
Lines changed: 1 addition & 1 deletion b/‎packages/core/src/modules/basic-messages/__tests__/BasicMessageService.test.ts‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎packages/core/src/modules/basic-messages/__tests__/basic-messages.e2e.test.ts‎
Lines changed: 110 additions & 0 deletions b/‎packages/core/src/modules/basic-messages/__tests__/basic-messages.e2e.test.ts‎
Lines changed: 110 additions & 0 deletions
diff --git a/‎packages/core/src/modules/basic-messages/services/BasicMessageService.ts‎
Lines changed: 12 additions & 3 deletions b/‎packages/core/src/modules/basic-messages/services/BasicMessageService.ts‎
Lines changed: 12 additions & 3 deletions
@@ -113,6 +113,16 @@ export class AgentConfig {
     return this.initConfig.maximumMediatorReconnectionIntervalMs ?? Number.POSITIVE_INFINITY
   }
 
+  /**
+   * Encode keys in did:key format instead of 'naked' keys, as stated in Aries RFC 0360.
+   *
+   * This setting will not be taken into account if the other party has previously used naked keys
+   * in a given protocol (i.e. it does not support Aries RFC 0360).
+   */
+  public get useDidKeyInProtocols() {
+    return this.initConfig.useDidKeyInProtocols ?? false
+  }
+
   public get endpoints(): [string, ...string[]] {
     // if endpoints is not set, return queue endpoint
     // https://github.com/hyperledger/aries-rfcs/issues/405#issuecomment-582612875
 
@@ -12,7 +12,7 @@ import type { AgentContext } from './context'
 
 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'
@@ -223,8 +223,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 }
       )
     }
 
@@ -291,7 +292,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(
 
@@ -0,0 +1,11 @@
+import type { OutboundMessage } from '../types'
+
+import { AriesFrameworkError } from './AriesFrameworkError'
+
+export class MessageSendingError extends AriesFrameworkError {
+  public outboundMessage: OutboundMessage
+  public constructor(message: string, { outboundMessage, cause }: { outboundMessage: OutboundMessage; cause?: Error }) {
+    super(message, { cause })
+    this.outboundMessage = outboundMessage
+  }
+}
@@ -3,3 +3,4 @@ export * from './RecordNotFoundError'
 export * from './RecordDuplicateError'
 export * from './IndySdkError'
 export * from './ClassValidationError'
+export * from './MessageSendingError'
@@ -30,7 +30,7 @@ export * from './storage/BaseRecord'
 export { InMemoryMessageRepository } from './storage/InMemoryMessageRepository'
 export { Repository } from './storage/Repository'
 export * from './storage/RepositoryEvents'
-export { StorageService } from './storage/StorageService'
+export { StorageService, Query } from './storage/StorageService'
 export { getDirFromFilePath } from './utils/path'
 export { InjectionSymbols } from './constants'
 export * from './wallet'
 
@@ -1,6 +1,7 @@
 import type { AgentContext } from '../../../agent'
 import type { InboundMessageContext } from '../../../agent/models/InboundMessageContext'
 import type { Logger } from '../../../logger'
+import type { Query } from '../../../storage/StorageService'
 import type { ActionMenuStateChangedEvent } from '../ActionMenuEvents'
 import type { ActionMenuProblemReportMessage } from '../messages'
 import type {
@@ -347,6 +348,10 @@ export class ActionMenuService {
     })
   }
 
+  public async findAllByQuery(agentContext: AgentContext, options: Query<ActionMenuRecord>) {
+    return await this.actionMenuRepository.findByQuery(agentContext, options)
+  }
+
   private emitStateChangedEvent(
     agentContext: AgentContext,
     actionMenuRecord: ActionMenuRecord,
 
@@ -1,4 +1,5 @@
-import type { BasicMessageTags } from './repository/BasicMessageRecord'
+import type { Query } from '../../storage/StorageService'
+import type { BasicMessageRecord } from './repository/BasicMessageRecord'
 
 import { AgentContext } from '../../agent'
 import { Dispatcher } from '../../agent/Dispatcher'
@@ -31,18 +32,62 @@ export class BasicMessagesApi {
     this.registerHandlers(dispatcher)
   }
 
+  /**
+   * Send a message to an active connection
+   *
+   * @param connectionId Connection Id
+   * @param message Message contents
+   * @throws {RecordNotFoundError} If connection is not found
+   * @throws {MessageSendingError} If message is undeliverable
+   * @returns the created record
+   */
   public async sendMessage(connectionId: string, message: string) {
     const connection = await this.connectionService.getById(this.agentContext, connectionId)
 
-    const basicMessage = await this.basicMessageService.createMessage(this.agentContext, message, connection)
+    const { message: basicMessage, record: basicMessageRecord } = await this.basicMessageService.createMessage(
+      this.agentContext,
+      message,
+      connection
+    )
     const outboundMessage = createOutboundMessage(connection, basicMessage)
+    outboundMessage.associatedRecord = basicMessageRecord
+
     await this.messageSender.sendMessage(this.agentContext, outboundMessage)
+    return basicMessageRecord
   }
 
-  public async findAllByQuery(query: Partial<BasicMessageTags>) {
+  /**
+   * Retrieve all basic messages matching a given query
+   *
+   * @param query The query
+   * @returns array containing all matching records
+   */
+  public async findAllByQuery(query: Query<BasicMessageRecord>) {
     return this.basicMessageService.findAllByQuery(this.agentContext, query)
   }
 
+  /**
+   * Retrieve a basic message record by id
+   *
+   * @param basicMessageRecordId The basic message record id
+   * @throws {RecordNotFoundError} If no record is found
+   * @return The basic message record
+   *
+   */
+  public async getById(basicMessageRecordId: string) {
+    return this.basicMessageService.getById(this.agentContext, basicMessageRecordId)
+  }
+
+  /**
+   * Delete a basic message record by id
+   *
+   * @param connectionId the basic message record id
+   * @throws {RecordNotFoundError} If no record is found
+   */
+  public async deleteById(basicMessageRecordId: string) {
+    await this.basicMessageService.deleteById(this.agentContext, basicMessageRecordId)
+  }
+
   private registerHandlers(dispatcher: Dispatcher) {
     dispatcher.registerHandler(new BasicMessageHandler(this.basicMessageService))
   }
 
@@ -30,7 +30,7 @@ describe('BasicMessageService', () => {
 
   describe('createMessage', () => {
     it(`creates message and record, and emits message and basic message record`, async () => {
-      const message = await basicMessageService.createMessage(agentContext, 'hello', mockConnectionRecord)
+      const { message } = await basicMessageService.createMessage(agentContext, 'hello', mockConnectionRecord)
 
       expect(message.content).toBe('hello')
 
 
@@ -0,0 +1,110 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import type { SubjectMessage } from '../../../../../../tests/transport/SubjectInboundTransport'
+import type { ConnectionRecord } from '../../../modules/connections'
+
+import { Subject } from 'rxjs'
+
+import { SubjectInboundTransport } from '../../../../../../tests/transport/SubjectInboundTransport'
+import { SubjectOutboundTransport } from '../../../../../../tests/transport/SubjectOutboundTransport'
+import { getAgentOptions, makeConnection, waitForBasicMessage } from '../../../../tests/helpers'
+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 = getAgentOptions('Faber Basic Messages', {
+  endpoints: ['rxjs:faber'],
+})
+
+const aliceConfig = getAgentOptions('Alice Basic Messages', {
+  endpoints: ['rxjs:alice'],
+})
+
+describe('Basic Messages E2E', () => {
+  let faberAgent: Agent
+  let aliceAgent: Agent
+  let faberConnection: ConnectionRecord
+  let aliceConnection: ConnectionRecord
+
+  beforeEach(async () => {
+    const faberMessages = new Subject<SubjectMessage>()
+    const aliceMessages = new Subject<SubjectMessage>()
+    const subjectMap = {
+      'rxjs:faber': faberMessages,
+      'rxjs:alice': aliceMessages,
+    }
+
+    faberAgent = new Agent(faberConfig)
+    faberAgent.registerInboundTransport(new SubjectInboundTransport(faberMessages))
+    faberAgent.registerOutboundTransport(new SubjectOutboundTransport(subjectMap))
+    await faberAgent.initialize()
+
+    aliceAgent = new Agent(aliceConfig)
+    aliceAgent.registerInboundTransport(new SubjectInboundTransport(aliceMessages))
+    aliceAgent.registerOutboundTransport(new SubjectOutboundTransport(subjectMap))
+    await aliceAgent.initialize()
+    ;[aliceConnection, faberConnection] = await makeConnection(aliceAgent, faberAgent)
+  })
+
+  afterEach(async () => {
+    await faberAgent.shutdown()
+    await faberAgent.wallet.delete()
+    await aliceAgent.shutdown()
+    await aliceAgent.wallet.delete()
+  })
+
+  test('Alice and Faber exchange messages', async () => {
+    testLogger.test('Alice sends message to Faber')
+    const helloRecord = await aliceAgent.basicMessages.sendMessage(aliceConnection.id, 'Hello')
+
+    expect(helloRecord.content).toBe('Hello')
+
+    testLogger.test('Faber waits for message from Alice')
+    await waitForBasicMessage(faberAgent, {
+      content: 'Hello',
+    })
+
+    testLogger.test('Faber sends message to Alice')
+    const replyRecord = await faberAgent.basicMessages.sendMessage(faberConnection.id, 'How are you?')
+    expect(replyRecord.content).toBe('How are you?')
+
+    testLogger.test('Alice waits until she receives message from faber')
+    await waitForBasicMessage(aliceAgent, {
+      content: 'How are you?',
+    })
+  })
+
+  test('Alice is unable to send a message', async () => {
+    testLogger.test('Alice sends message to Faber that is undeliverable')
+
+    const spy = jest.spyOn(aliceAgent.outboundTransports[0], 'sendMessage').mockRejectedValue(new Error('any error'))
+
+    await expect(aliceAgent.basicMessages.sendMessage(aliceConnection.id, 'Hello')).rejects.toThrowError(
+      MessageSendingError
+    )
+    try {
+      await aliceAgent.basicMessages.sendMessage(aliceConnection.id, 'Hello undeliverable')
+    } catch (error) {
+      const thrownError = error as MessageSendingError
+      expect(thrownError.message).toEqual(
+        `Message is undeliverable to connection ${aliceConnection.id} (${aliceConnection.theirLabel})`
+      )
+      testLogger.test('Error thrown includes the outbound message and recently created record id')
+      expect(thrownError.outboundMessage.associatedRecord).toBeInstanceOf(BasicMessageRecord)
+      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.outboundMessage.associatedRecord!.id)
+      expect(storedRecord).toBeInstanceOf(BasicMessageRecord)
+      expect(storedRecord.content).toBe('Hello undeliverable')
+
+      await aliceAgent.basicMessages.deleteById(storedRecord.id)
+      await expect(
+        aliceAgent.basicMessages.getById(thrownError.outboundMessage.associatedRecord!.id)
+      ).rejects.toThrowError(RecordNotFoundError)
+    }
+    spy.mockClear()
+  })
+})
@@ -1,8 +1,8 @@
 import type { AgentContext } from '../../../agent'
 import type { InboundMessageContext } from '../../../agent/models/InboundMessageContext'
+import type { Query } from '../../../storage/StorageService'
 import type { ConnectionRecord } from '../../connections/repository/ConnectionRecord'
 import type { BasicMessageStateChangedEvent } from '../BasicMessageEvents'
-import type { BasicMessageTags } from '../repository'
 
 import { EventEmitter } from '../../../agent/EventEmitter'
 import { injectable } from '../../../plugins'
@@ -35,7 +35,7 @@ export class BasicMessageService {
     await this.basicMessageRepository.save(agentContext, basicMessageRecord)
     this.emitStateChangedEvent(agentContext, basicMessageRecord, basicMessage)
 
-    return basicMessage
+    return { message: basicMessage, record: basicMessageRecord }
   }
 
   /**
@@ -65,7 +65,16 @@ export class BasicMessageService {
     })
   }
 
-  public async findAllByQuery(agentContext: AgentContext, query: Partial<BasicMessageTags>) {
+  public async findAllByQuery(agentContext: AgentContext, query: Query<BasicMessageRecord>) {
     return this.basicMessageRepository.findByQuery(agentContext, query)
   }
+
+  public async getById(agentContext: AgentContext, basicMessageRecordId: string) {
+    return this.basicMessageRepository.getById(agentContext, basicMessageRecordId)
+  }
+
+  public async deleteById(agentContext: AgentContext, basicMessageRecordId: string) {
+    const basicMessageRecord = await this.getById(agentContext, basicMessageRecordId)
+    return this.basicMessageRepository.delete(agentContext, basicMessageRecord)
+  }
 }