Merge pull request #101 from hyperledger/main

feat!: add AgentMessageSentEvent and associate records to outbound me…
NB-MikeRichardson · Nov 25, 2022 · 6c9d89c · 6c9d89c
2 parents 85320ae + c68145a
commit 6c9d89c
Show file tree

Hide file tree

Showing 57 changed files with 1,082 additions and 491 deletions.
diff --git a/packages/action-menu/src/ActionMenuApi.ts b/packages/action-menu/src/ActionMenuApi.ts
@@ -12,7 +12,7 @@ import {
   ConnectionService,
   Dispatcher,
   MessageSender,
-  createOutboundMessage,
+  OutboundMessageContext,
   injectable,
 } from '@aries-framework/core'
 
@@ -59,8 +59,13 @@ export class ActionMenuApi {
       connection,
     })
 
-    const outboundMessage = createOutboundMessage(connection, message)
-    await this.messageSender.sendMessage(this.agentContext, outboundMessage)
+    const outboundMessageContext = new OutboundMessageContext(message, {
+      agentContext: this.agentContext,
+      connection,
+      associatedRecord: record,
+    })
+
+    await this.messageSender.sendMessage(outboundMessageContext)
 
     return record
   }
@@ -80,8 +85,13 @@ export class ActionMenuApi {
       menu: options.menu,
     })
 
-    const outboundMessage = createOutboundMessage(connection, message)
-    await this.messageSender.sendMessage(this.agentContext, outboundMessage)
+    const outboundMessageContext = new OutboundMessageContext(message, {
+      agentContext: this.agentContext,
+      connection,
+      associatedRecord: record,
+    })
+
+    await this.messageSender.sendMessage(outboundMessageContext)
 
     return record
   }
@@ -109,8 +119,13 @@ export class ActionMenuApi {
       performedAction: options.performedAction,
     })
 
-    const outboundMessage = createOutboundMessage(connection, message)
-    await this.messageSender.sendMessage(this.agentContext, outboundMessage)
+    const outboundMessageContext = new OutboundMessageContext(message, {
+      agentContext: this.agentContext,
+      connection,
+      associatedRecord: record,
+    })
+
+    await this.messageSender.sendMessage(outboundMessageContext)
 
     return record
   }

diff --git a/packages/core/src/agent/Dispatcher.ts b/packages/core/src/agent/Dispatcher.ts
@@ -1,4 +1,3 @@
-import type { OutboundMessage, OutboundServiceMessage } from '../types'
 import type { AgentMessage } from './AgentMessage'
 import type { AgentMessageProcessedEvent } from './Events'
 import type { Handler } from './Handler'
@@ -14,7 +13,7 @@ import { ProblemReportMessage } from './../modules/problem-reports/messages/Prob
 import { EventEmitter } from './EventEmitter'
 import { AgentEventTypes } from './Events'
 import { MessageSender } from './MessageSender'
-import { isOutboundServiceMessage } from './helpers'
+import { OutboundMessageContext } from './models'
 
 @injectable()
 class Dispatcher {
@@ -38,14 +37,14 @@ class Dispatcher {
   }
 
   public async dispatch(messageContext: InboundMessageContext): Promise<void> {
-    const message = messageContext.message
+    const { agentContext, connection, senderKey, recipientKey, message } = messageContext
     const handler = this.getHandlerForType(message.type)
 
     if (!handler) {
       throw new AriesFrameworkError(`No handler for message type "${message.type}" found`)
     }
 
-    let outboundMessage: OutboundMessage<AgentMessage> | OutboundServiceMessage<AgentMessage> | void
+    let outboundMessage: OutboundMessageContext<AgentMessage> | void
 
     try {
       outboundMessage = await handler.handle(messageContext)
@@ -54,43 +53,39 @@ class Dispatcher {
 
       if (problemReportMessage instanceof ProblemReportMessage && messageContext.connection) {
         problemReportMessage.setThread({
-          threadId: messageContext.message.threadId,
+          threadId: message.threadId,
         })
-        outboundMessage = {
-          payload: problemReportMessage,
+        outboundMessage = new OutboundMessageContext(problemReportMessage, {
+          agentContext,
           connection: messageContext.connection,
-        }
+        })
       } else {
         this.logger.error(`Error handling message with type ${message.type}`, {
           message: message.toJSON(),
           error,
-          senderKey: messageContext.senderKey?.fingerprint,
-          recipientKey: messageContext.recipientKey?.fingerprint,
-          connectionId: messageContext.connection?.id,
+          senderKey: senderKey?.fingerprint,
+          recipientKey: recipientKey?.fingerprint,
+          connectionId: connection?.id,
         })
 
         throw error
       }
     }
 
-    if (outboundMessage && isOutboundServiceMessage(outboundMessage)) {
-      await this.messageSender.sendMessageToService(messageContext.agentContext, {
-        message: outboundMessage.payload,
-        service: outboundMessage.service,
-        senderKey: outboundMessage.senderKey,
-        returnRoute: true,
-      })
-    } else if (outboundMessage) {
-      outboundMessage.sessionId = messageContext.sessionId
-      await this.messageSender.sendMessage(messageContext.agentContext, outboundMessage)
+    if (outboundMessage) {
+      if (outboundMessage.isOutboundServiceMessage()) {
+        await this.messageSender.sendMessageToService(outboundMessage)
+      } else {
+        outboundMessage.sessionId = messageContext.sessionId
+        await this.messageSender.sendMessage(outboundMessage)
+      }
     }
-
     // Emit event that allows to hook into received messages
-    this.eventEmitter.emit<AgentMessageProcessedEvent>(messageContext.agentContext, {
+    this.eventEmitter.emit<AgentMessageProcessedEvent>(agentContext, {
       type: AgentEventTypes.AgentMessageProcessed,
       payload: {
-        message: messageContext.message,
-        connection: messageContext.connection,
+        message,
+        connection,
       },
     })
   }

diff --git a/packages/core/src/agent/Events.ts b/packages/core/src/agent/Events.ts
@@ -1,5 +1,6 @@
 import type { ConnectionRecord } from '../modules/connections'
 import type { AgentMessage } from './AgentMessage'
+import type { OutboundMessageContext, OutboundMessageSendStatus } from './models'
 import type { Observable } from 'rxjs'
 
 import { filter } from 'rxjs'
@@ -13,6 +14,7 @@ export function filterContextCorrelationId(contextCorrelationId: string) {
 export enum AgentEventTypes {
   AgentMessageReceived = 'AgentMessageReceived',
   AgentMessageProcessed = 'AgentMessageProcessed',
+  AgentMessageSent = 'AgentMessageSent',
 }
 
 export interface EventMetadata {
@@ -41,3 +43,11 @@ export interface AgentMessageProcessedEvent extends BaseEvent {
     connection?: ConnectionRecord
   }
 }
+
+export interface AgentMessageSentEvent extends BaseEvent {
+  type: typeof AgentEventTypes.AgentMessageSent
+  payload: {
+    message: OutboundMessageContext
+    status: OutboundMessageSendStatus
+  }
+}
diff --git a/packages/core/src/agent/Handler.ts b/packages/core/src/agent/Handler.ts
@@ -1,11 +1,10 @@
-import type { OutboundMessage, OutboundServiceMessage } from '../types'
 import type { ConstructableAgentMessage } from './AgentMessage'
-import type { InboundMessageContext } from './models/InboundMessageContext'
+import type { InboundMessageContext, OutboundMessageContext } from './models'
 
 export interface Handler {
   readonly supportedMessages: readonly ConstructableAgentMessage[]
 
-  handle(messageContext: InboundMessageContext): Promise<OutboundMessage | OutboundServiceMessage | void>
+  handle(messageContext: InboundMessageContext): Promise<OutboundMessageContext | void>
 }
 
 /**

diff --git a/packages/core/src/agent/MessageReceiver.ts b/packages/core/src/agent/MessageReceiver.ts
@@ -21,8 +21,7 @@ import { EnvelopeService } from './EnvelopeService'
 import { MessageSender } from './MessageSender'
 import { TransportService } from './TransportService'
 import { AgentContextProvider } from './context'
-import { createOutboundMessage } from './helpers'
-import { InboundMessageContext } from './models/InboundMessageContext'
+import { InboundMessageContext, OutboundMessageContext } from './models'
 
 @injectable()
 export class MessageReceiver {
@@ -277,9 +276,9 @@ export class MessageReceiver {
     problemReportMessage.setThread({
       threadId: plaintextMessage['@id'],
     })
-    const outboundMessage = createOutboundMessage(connection, problemReportMessage)
-    if (outboundMessage) {
-      await this.messageSender.sendMessage(agentContext, outboundMessage)
+    const outboundMessageContext = new OutboundMessageContext(problemReportMessage, { agentContext, connection })
+    if (outboundMessageContext) {
+      await this.messageSender.sendMessage(outboundMessageContext)
     }
   }
 }