chore: update extension module sample (openwallet-foundation#1083)

Signed-off-by: Ariel Gentile <[email protected]>

Author: genaris

Diff for: jest.config.ts

@@ -5,7 +5,11 @@ import base from './jest.config.base'
 const config: Config.InitialOptions = {
   ...base,
   roots: ['<rootDir>'],
-  projects: ['<rootDir>/packages/*', '<rootDir>/tests/jest.config.ts'],
+  projects: [
+    '<rootDir>/packages/*',
+    '<rootDir>/tests/jest.config.ts',
+    '<rootDir>/samples/extension-module/jest.config.ts',
+  ],
 }
 
 export default config

Diff for: packages/core/src/index.ts

@@ -38,6 +38,7 @@ export * from './wallet'
 export type { TransportSession } from './agent/TransportService'
 export { TransportService } from './agent/TransportService'
 export { Attachment } from './decorators/attachment/Attachment'
+export { ReturnRouteTypes } from './decorators/transport/TransportDecorator'
 
 export * from './plugins'
 export * from './transport'

Diff for: samples/extension-module/README.md

@@ -16,35 +16,42 @@ This example consists of a module that implements a very simple request-response
 - Define events (inherited from `BaseEvent`)
 - Create a singleton service class that manages records and repository, and also trigger events using Agent's `EventEmitter`
 - Create a singleton api class that registers handlers in Agent's `Dispatcher` and provides a simple API to do requests and responses, with the aid of service classes and Agent's `MessageSender`
-- Create a module class that registers all the above on the dependency manager so it can be be injected from the `Agent` instance.
+- Create a module class that registers all the above on the dependency manager so it can be be injected from the `Agent` instance, and also register the features (such as protocols) the module adds to the Agent.
 
 ## Usage
 
-In order to use this module, you first need to register `DummyModule` on the `Agent` instance. After that you need to resolve the `DummyApi` to interact with the public api of the module. Make sure to register and resolve the api **before** initializing the agent.
+In order to use this module, you first need to register `DummyModule` on the `Agent` instance. This can be done by adding an entry for it in `AgentOptions`'s modules property:
 
 ```ts
-import { DummyModule, DummyApi } from './dummy'
-
-const agent = new Agent(/** agent config... */)
+import { DummyModule } from './dummy'
 
 // Register the module with it's dependencies
-agent.dependencyManager.registerModules(new DummyModule())
-
-const dummyApi = agent.dependencyManager.resolve(DummyApi)
+const agent = new Agent({
+  config: {
+    /* config */
+  },
+  dependencies: agentDependencies,
+  modules: {
+    dummy: new DummyModule({
+      /* module config */
+    }),
+    /* other custom modules */
+  },
+})
 
 await agent.initialize()
 ```
 
-Then, Dummy module API methods can be called, and events listeners can be created:
+Then, Dummy module API methods can be called from `agent.modules.dummy` namespace, and events listeners can be created:
 
 ```ts
 agent.events.on(DummyEventTypes.StateChanged, async (event: DummyStateChangedEvent) => {
   if (event.payload.dummyRecord.state === DummyState.RequestReceived) {
-    await dummyApi.respond(event.payload.dummyRecord)
+    await agent.modules.dummy.respond(event.payload.dummyRecord)
   }
 })
 
-const record = await dummyApi.request(connection)
+const record = await agent.modules.dummy.request(connection)
 ```
 
 ## Run demo

Diff for: samples/extension-module/dummy/DummyModule.ts

@@ -1,18 +1,28 @@
+import type { DummyModuleConfigOptions } from './DummyModuleConfig'
 import type { DependencyManager, FeatureRegistry, Module } from '@aries-framework/core'
 
 import { Protocol } from '@aries-framework/core'
 
 import { DummyApi } from './DummyApi'
+import { DummyModuleConfig } from './DummyModuleConfig'
 import { DummyRepository } from './repository'
 import { DummyService } from './services'
 
 export class DummyModule implements Module {
-  public api = DummyApi
+  public readonly config: DummyModuleConfig
+  public readonly api = DummyApi
+
+  public constructor(config?: DummyModuleConfigOptions) {
+    this.config = new DummyModuleConfig(config)
+  }
 
   public register(dependencyManager: DependencyManager, featureRegistry: FeatureRegistry) {
     // Api
     dependencyManager.registerContextScoped(DummyApi)
 
+    // Config
+    dependencyManager.registerInstance(DummyModuleConfig, this.config)
+
     dependencyManager.registerSingleton(DummyRepository)
     dependencyManager.registerSingleton(DummyService)
 

Diff for: samples/extension-module/dummy/DummyModuleConfig.ts

@@ -0,0 +1,25 @@
+/**
+ * DummyModuleConfigOptions defines the interface for the options of the DummyModuleConfig class.
+ * This can contain optional parameters that have default values in the config class itself.
+ */
+export interface DummyModuleConfigOptions {
+  /**
+   * Whether to automatically accept request messages.
+   *
+   * @default false
+   */
+  autoAcceptRequests?: boolean
+}
+
+export class DummyModuleConfig {
+  private options: DummyModuleConfigOptions
+
+  public constructor(options?: DummyModuleConfigOptions) {
+    this.options = options ?? {}
+  }
+
+  /** See {@link DummyModuleConfigOptions.autoAcceptRequests} */
+  public get autoAcceptRequests() {
+    return this.options.autoAcceptRequests ?? false
+  }
+}

Diff for: samples/extension-module/dummy/handlers/DummyRequestHandler.ts

@@ -1,6 +1,8 @@
 import type { DummyService } from '../services'
 import type { Handler, HandlerInboundMessage } from '@aries-framework/core'
 
+import { createOutboundMessage } from '@aries-framework/core'
+
 import { DummyRequestMessage } from '../messages'
 
 export class DummyRequestHandler implements Handler {
@@ -12,8 +14,11 @@ export class DummyRequestHandler implements Handler {
   }
 
   public async handle(inboundMessage: HandlerInboundMessage<DummyRequestHandler>) {
-    inboundMessage.assertReadyConnection()
+    const connection = inboundMessage.assertReadyConnection()
+    const responseMessage = await this.dummyService.processRequest(inboundMessage)
 
-    await this.dummyService.processRequest(inboundMessage)
+    if (responseMessage) {
+      return createOutboundMessage(connection, responseMessage)
+    }
   }
 }

Diff for: samples/extension-module/dummy/index.ts

@@ -4,3 +4,4 @@ export * from './messages'
 export * from './services'
 export * from './repository'
 export * from './DummyModule'
+export * from './DummyModuleConfig'

Diff for: samples/extension-module/dummy/messages/DummyRequestMessage.ts

@@ -1,4 +1,4 @@
-import { AgentMessage, IsValidMessageType, parseMessageType } from '@aries-framework/core'
+import { AgentMessage, IsValidMessageType, parseMessageType, ReturnRouteTypes } from '@aries-framework/core'
 
 export interface DummyRequestMessageOptions {
   id?: string
@@ -11,6 +11,8 @@ export class DummyRequestMessage extends AgentMessage {
     if (options) {
       this.id = options.id ?? this.generateId()
     }
+
+    this.setReturnRouting(ReturnRouteTypes.all)
   }
 
   @IsValidMessageType(DummyRequestMessage.type)

Diff for: samples/extension-module/dummy/services/DummyService.ts

@@ -3,6 +3,7 @@ import type { Query, AgentContext, ConnectionRecord, InboundMessageContext } fro
 
 import { injectable, JsonTransformer, EventEmitter } from '@aries-framework/core'
 
+import { DummyModuleConfig } from '../DummyModuleConfig'
 import { DummyRequestMessage, DummyResponseMessage } from '../messages'
 import { DummyRecord } from '../repository/DummyRecord'
 import { DummyRepository } from '../repository/DummyRepository'
@@ -14,8 +15,14 @@ import { DummyEventTypes } from './DummyEvents'
 export class DummyService {
   private dummyRepository: DummyRepository
   private eventEmitter: EventEmitter
+  private dummyModuleConfig: DummyModuleConfig
 
-  public constructor(dummyRepository: DummyRepository, eventEmitter: EventEmitter) {
+  public constructor(
+    dummyModuleConfig: DummyModuleConfig,
+    dummyRepository: DummyRepository,
+    eventEmitter: EventEmitter
+  ) {
+    this.dummyModuleConfig = dummyModuleConfig
     this.dummyRepository = dummyRepository
     this.eventEmitter = eventEmitter
   }
@@ -80,7 +87,9 @@ export class DummyService {
 
     this.emitStateChangedEvent(messageContext.agentContext, record, null)
 
-    return record
+    if (this.dummyModuleConfig.autoAcceptRequests) {
+      return await this.createResponse(messageContext.agentContext, record)
+    }
   }
 
   /**

Diff for: samples/extension-module/jest.config.ts

@@ -0,0 +1,13 @@
+import type { Config } from '@jest/types'
+
+import base from '../../jest.config.base'
+
+import packageJson from './package.json'
+
+const config: Config.InitialOptions = {
+  ...base,
+  displayName: packageJson.name,
+  setupFilesAfterEnv: ['./tests/setup.ts'],
+}
+
+export default config

Diff for: samples/extension-module/requester.ts

@@ -1,6 +1,13 @@
 import type { DummyRecord, DummyStateChangedEvent } from './dummy'
 
-import { Agent, AriesFrameworkError, ConsoleLogger, LogLevel, WsOutboundTransport } from '@aries-framework/core'
+import {
+  HttpOutboundTransport,
+  Agent,
+  AriesFrameworkError,
+  ConsoleLogger,
+  LogLevel,
+  WsOutboundTransport,
+} from '@aries-framework/core'
 import { agentDependencies } from '@aries-framework/node'
 import { filter, first, firstValueFrom, map, ReplaySubject, timeout } from 'rxjs'
 
@@ -10,6 +17,7 @@ const run = async () => {
   // Create transports
   const port = process.env.RESPONDER_PORT ? Number(process.env.RESPONDER_PORT) : 3002
   const wsOutboundTransport = new WsOutboundTransport()
+  const httpOutboundTransport = new HttpOutboundTransport()
 
   // Setup the agent
   const agent = new Agent({
@@ -19,7 +27,7 @@ const run = async () => {
         id: 'requester',
         key: 'requester',
       },
-      logger: new ConsoleLogger(LogLevel.test),
+      logger: new ConsoleLogger(LogLevel.info),
       autoAcceptConnections: true,
     },
     modules: {
@@ -30,6 +38,7 @@ const run = async () => {
 
   // Register transports
   agent.registerOutboundTransport(wsOutboundTransport)
+  agent.registerOutboundTransport(httpOutboundTransport)
 
   // Now agent will handle messages and events from Dummy protocol
 
@@ -59,7 +68,7 @@ const run = async () => {
 
   // Send a dummy request and wait for response
   const record = await agent.modules.dummy.request(connectionRecord.id)
-  agent.config.logger.info(`Request received for Dummy Record: ${record.id}`)
+  agent.config.logger.info(`Request sent for Dummy Record: ${record.id}`)
 
   const dummyRecord = await firstValueFrom(subject)
   agent.config.logger.info(`Response received for Dummy Record: ${dummyRecord.id}`)

Diff for: samples/extension-module/responder.ts

@@ -1,7 +1,7 @@
 import type { DummyStateChangedEvent } from './dummy'
 import type { Socket } from 'net'
 
-import { Agent, ConsoleLogger, LogLevel, WsOutboundTransport } from '@aries-framework/core'
+import { Agent, ConsoleLogger, LogLevel } from '@aries-framework/core'
 import { agentDependencies, HttpInboundTransport, WsInboundTransport } from '@aries-framework/node'
 import express from 'express'
 import { Server } from 'ws'
@@ -11,35 +11,34 @@ import { DummyModule, DummyEventTypes, DummyState } from './dummy'
 const run = async () => {
   // Create transports
   const port = process.env.RESPONDER_PORT ? Number(process.env.RESPONDER_PORT) : 3002
+  const autoAcceptRequests = true
   const app = express()
   const socketServer = new Server({ noServer: true })
 
   const httpInboundTransport = new HttpInboundTransport({ app, port })
   const wsInboundTransport = new WsInboundTransport({ server: socketServer })
-  const wsOutboundTransport = new WsOutboundTransport()
 
   // Setup the agent
   const agent = new Agent({
     config: {
       label: 'Dummy-powered agent - responder',
-      endpoints: [`ws://localhost:${port}`],
+      endpoints: [`http://localhost:${port}`],
       walletConfig: {
         id: 'responder',
         key: 'responder',
       },
-      logger: new ConsoleLogger(LogLevel.test),
+      logger: new ConsoleLogger(LogLevel.debug),
       autoAcceptConnections: true,
     },
     modules: {
-      dummy: new DummyModule(),
+      dummy: new DummyModule({ autoAcceptRequests }),
     },
     dependencies: agentDependencies,
   })
 
   // Register transports
   agent.registerInboundTransport(httpInboundTransport)
   agent.registerInboundTransport(wsInboundTransport)
-  agent.registerInboundTransport(wsOutboundTransport)
 
   // Allow to create invitation, no other way to ask for invitation yet
   app.get('/invitation', async (req, res) => {
@@ -58,12 +57,15 @@ const run = async () => {
     })
   })
 
-  // Subscribe to dummy record events
-  agent.events.on(DummyEventTypes.StateChanged, async (event: DummyStateChangedEvent) => {
-    if (event.payload.dummyRecord.state === DummyState.RequestReceived) {
-      await agent.modules.dummy.respond(event.payload.dummyRecord.id)
-    }
-  })
+  // If autoAcceptRequests is enabled, the handler will automatically respond
+  // (no need to subscribe to event and manually accept)
+  if (!autoAcceptRequests) {
+    agent.events.on(DummyEventTypes.StateChanged, async (event: DummyStateChangedEvent) => {
+      if (event.payload.dummyRecord.state === DummyState.RequestReceived) {
+        await agent.modules.dummy.respond(event.payload.dummyRecord.id)
+      }
+    })
+  }
 
   agent.config.logger.info(`Responder listening to port ${port}`)
 }