fix: ServiceManager and AbstractServiceController

packages/daf-core/src/action-handler.ts → packages/daf-core/src/action/action-handler.ts

@@ -1,5 +1,5 @@
-import { Action } from './types'
-import { Core } from './core'
+import { Action } from '../types'
+import { Core } from '../core'
 
 export interface ActionHandler {
   setNext(actionHandler: ActionHandler): ActionHandler

packages/daf-core/src/core.ts

@@ -1,12 +1,12 @@
 import { EventEmitter } from 'events'
 import { DIDDocument } from 'did-resolver'
-import { IdentityManager, IdentityController } from './identity-manager'
+import { IdentityManager, IdentityController } from './identity/identity-manager'
 import { ServiceManager, ServiceControllerWithConfig, LastMessageTimestamp } from './service-manager'
-import { MessageValidator } from './message-validator'
-import { ActionHandler } from './action-handler'
+import { MessageValidator } from './message/message-validator'
+import { ActionHandler } from './action/action-handler'
 import { Action } from './types'
 import { EncryptionKeyManager } from './encryption-manager'
-import { Message } from './message'
+import { Message } from './message/message'
 
 import Debug from 'debug'
 const debug = Debug('core')

packages/daf-core/src/graphql-core.ts → packages/daf-core/src/graphql/graphql-core.ts

@@ -1,5 +1,5 @@
-import { Core } from './core'
-import { Message } from './message'
+import { Core } from '../core'
+import { Message } from '../message/message'
 
 interface Context {
   core: Core

packages/daf-core/src/graphql-identity-manager.ts → packages/daf-core/src/graphql/graphql-identity-manager.ts

@@ -1,5 +1,5 @@
-import { Core } from './core'
-import { Issuer } from './identity-manager'
+import { Core } from '../core'
+import { Issuer } from '../identity/identity-manager'
 
 export interface Context {
   core: Core

packages/daf-core/src/index.ts

@@ -1,19 +1,19 @@
 export { Core, EventTypes, Resolver } from './core'
-export { AbstractActionHandler } from './action-handler'
+export { AbstractActionHandler } from './action/action-handler'
 export { EncryptionKeyManager, KeyPair } from './encryption-manager'
-export { IdentityController, IdentityManager, Issuer } from './identity-manager'
-export { AbstractMessageValidator } from './message-validator'
-export { Message } from './message'
+export { IdentityController, IdentityManager, Issuer } from './identity/identity-manager'
+export { AbstractMessageValidator } from './message/message-validator'
+export { Message } from './message/message'
 export {
   ServiceController,
   ServiceControllerOptions,
   ServiceControllerWithConfig,
   ServiceInstanceId,
 } from './service-manager'
 import * as Types from './types'
-import { baseTypeDefs } from './graphql-base-type-defs'
-import * as GqlCore from './graphql-core'
-import * as GqlIdentityManager from './graphql-identity-manager'
+import { baseTypeDefs } from './graphql/graphql-base-type-defs'
+import * as GqlCore from './graphql/graphql-core'
+import * as GqlIdentityManager from './graphql/graphql-identity-manager'
 
 const Gql = {
   baseTypeDefs,

packages/daf-core/src/message-validator.ts → packages/daf-core/src/message/message-validator.ts

@@ -1,5 +1,5 @@
 import { Message } from './message'
-import { Core } from './core'
+import { Core } from '../core'
 
 export interface MessageValidator {
   setNext(messageValidator: MessageValidator): MessageValidator

packages/daf-core/src/service-manager.ts

@@ -1,7 +1,7 @@
 import { DIDDocument } from 'did-resolver'
 import { Resolver } from './core'
-import { Issuer } from './identity-manager'
-import { Message } from './message'
+import { Issuer } from './identity/identity-manager'
+import { Message } from './message/message'
 
 export interface ServiceControllerOptions {
   config: any

packages/daf-core/src/service/__tests__/abstract-service-controller.test.ts

@@ -0,0 +1,71 @@
+import { AbstractServiceController, ServiceEventTypes } from '../abstract-service-controller'
+import { Issuer } from '../../identity/identity-manager'
+import { Resolver } from '../../core'
+import { Message } from '../../message/message'
+
+const msg1 = new Message({ raw: 'test1', meta: { type: 'test' } })
+const msg2 = new Message({ raw: 'test2', meta: { type: 'test' } })
+
+export class MockServiceController extends AbstractServiceController {
+  static defaultServiceEndpoint: string = 'https://default.host/path'
+  readonly type = 'mockService'
+  private endPointUrl: string
+
+  constructor(issuer: Issuer, didResolver: Resolver) {
+    super(issuer, didResolver)
+    this.endPointUrl = 'https://from-did-doc'
+  }
+
+  instanceId() {
+    return {
+      did: this.issuer.did,
+      type: this.type,
+      id: this.endPointUrl,
+    }
+  }
+
+  async getMessagesSince(timestamp: number) {
+    this.emit(ServiceEventTypes.NewMessages, [msg1, msg2])
+    return [msg1, msg2]
+  }
+
+  async listen() {
+    this.emit(ServiceEventTypes.NewMessages, [msg1])
+  }
+}
+
+const mockIssuer: Issuer = {
+  did: 'did:test:123',
+  signer: async (data: string) => data,
+  type: 'mock',
+}
+
+const mockResolver: Resolver = {
+  resolve: async (did: string) => null,
+}
+
+it('should be possible to set configuration as a static property', async () => {
+  expect(MockServiceController.defaultServiceEndpoint).toEqual('https://default.host/path')
+  MockServiceController.defaultServiceEndpoint = 'https://custom.host/path'
+  expect(MockServiceController.defaultServiceEndpoint).toEqual('https://custom.host/path')
+})
+
+it('returns and emits an event with the same message array ', async () => {
+  const controller = new MockServiceController(mockIssuer, mockResolver)
+  spyOn(controller, 'emit')
+  const messages = await controller.getMessagesSince(0)
+  expect(controller.emit).toHaveBeenCalledWith(ServiceEventTypes.NewMessages, messages)
+})
+
+it('emits events on listen', async () => {
+  const controller = new MockServiceController(mockIssuer, mockResolver)
+  spyOn(controller, 'emit')
+  await controller.listen()
+  expect(controller.emit).toHaveBeenCalledWith(ServiceEventTypes.NewMessages, [msg1])
+})
+
+it('instanceId is generated from state', async () => {
+  const controller = new MockServiceController(mockIssuer, mockResolver)
+  const instanceId = controller.instanceId()
+  expect(instanceId).toEqual({ did: 'did:test:123', type: controller.type, id: 'https://from-did-doc' })
+})

packages/daf-core/src/service/abstract-service-controller.ts

@@ -0,0 +1,20 @@
+import { EventEmitter } from 'events'
+import { Issuer } from '../identity/identity-manager'
+import { Resolver } from '../core'
+import { Message } from '../message/message'
+
+export enum ServiceEventTypes {
+  NewMessages = 'NewMessages',
+}
+
+export abstract class AbstractServiceController extends EventEmitter {
+  constructor(readonly issuer: Issuer, readonly didResolver: Resolver) {
+    super()
+  }
+  abstract instanceId(): { did: string; type: string; id: string }
+  abstract getMessagesSince(timestamp: number): Promise<Message[]>
+  abstract listen(): void
+}
+
+type AbstractServiceControllerClass = typeof AbstractServiceController
+export interface ServiceControllerDerived extends AbstractServiceControllerClass {}

packages/daf-core/src/service/service-manager.ts

@@ -0,0 +1,66 @@
+import { EventEmitter } from 'events'
+import { Resolver } from '../core'
+import {
+  AbstractServiceController,
+  ServiceControllerDerived,
+  ServiceEventTypes,
+} from './abstract-service-controller'
+import { Issuer } from '../identity/identity-manager'
+import { Message } from '../message/message'
+
+interface Options {
+  controllers: ServiceControllerDerived[]
+  didResolver: Resolver
+}
+
+export interface LastMessageTimestampForInstance {
+  timestamp: number
+  did: string
+  type: string
+  id: string
+}
+
+export class ServiceManager extends EventEmitter {
+  private controllerInstances: AbstractServiceController[]
+  private controllers: ServiceControllerDerived[]
+  private didResolver: Resolver
+
+  constructor(options: Options) {
+    super()
+    this.controllerInstances = []
+    this.controllers = options.controllers
+    this.didResolver = options.didResolver
+  }
+
+  async setupServices(issuers: Issuer[]) {
+    for (const issuer of issuers) {
+      for (const controller of this.controllers) {
+        const instance = new controller(issuer, this.didResolver)
+        instance.on(ServiceEventTypes.NewMessages, this.onNewMessages)
+        this.controllerInstances.push(instance)
+      }
+    }
+  }
+
+  private onNewMessages(messages: Message[]) {
+    this.emit(ServiceEventTypes.NewMessages, messages)
+  }
+
+  listen() {
+    for (const instance of this.controllerInstances) {
+      instance.listen()
+    }
+  }
+
+  async getMessagesSince(ts: LastMessageTimestampForInstance[]): Promise<Message[]> {
+    let result: Message[] = []
+    for (const instance of this.controllerInstances) {
+      const { id, type, did } = instance.instanceId()
+      const found = ts.find(i => i.did === did && i.id === id && i.type === type)
+      let since = found ? found.timestamp : 0
+      const messages = await instance.getMessagesSince(since)
+      result = result.concat(messages)
+    }
+    return result
+  }
+}