Customer resolvers for message handler mappings (#49)

* remove name based mappings

* handler tests

* rebuild int tests

* overload handler registration

* transport fixes

* test updates

* mem test fixes

* duplicate handler tests

* more test updates

* increase int test timeouts

* sqs test updates

* sqs tests

* int test changes

* hidden console.log

* rabbit-mq tests

* test blocks

Author: adenhertog

packages/bus-core/src/application-bootstrap/application-bootstrap.spec.ts

@@ -6,6 +6,7 @@ import { Logger } from '@node-ts/logger-core'
 import { Container } from 'inversify'
 import { TestCommandHandler, TestCommand } from '../test'
 import { Transport } from '../transport'
+import { Message } from '@node-ts/bus-messages'
 
 describe('ApplicationBootstrap', () => {
   let sut: ApplicationBootstrap
@@ -57,7 +58,7 @@ describe('ApplicationBootstrap', () => {
     it('should add the handler to the registry', () => {
       handlerRegistry.verify(
         h => h.register(
-          TestCommand.NAME,
+          It.isAny(),
           It.isAny(),
           TestCommandHandler,
           TestCommand

packages/bus-core/src/application-bootstrap/application-bootstrap.ts

@@ -2,7 +2,7 @@ import { Message } from '@node-ts/bus-messages'
 import { LOGGER_SYMBOLS, Logger } from '@node-ts/logger-core'
 import { Container, inject, injectable } from 'inversify'
 import { BUS_SYMBOLS } from '../bus-symbols'
-import { Handler, HandlerPrototype } from '../handler/handler'
+import { Handler, HandlerPrototype, MessageType } from '../handler/handler'
 import { HandlerRegistry } from '../handler'
 import { Bus } from '../service-bus'
 import { ClassConstructor } from '../util'
@@ -51,28 +51,21 @@ export class ApplicationBootstrap {
     this.logger.info('Bus application disposed')
   }
 
-  registerHandler (handler: ClassConstructor<Handler<Message>>): void {
+  registerHandler (handler: ClassConstructor<Handler<MessageType>>): void {
     if (this.isInitialized) {
       throw new Error('Cannot call registerHandler() after initialize() has been called')
     }
 
-    const prototype = handler.prototype as HandlerPrototype
+    const prototype = handler.prototype as HandlerPrototype<MessageType>
     if (!prototype.$symbol) {
       throw new Error(
         `Missing symbol on ${prototype.constructor}.`
         + 'This could mean the handler class is missing the @Handles() decorator.'
       )
     }
 
-    if (!prototype.$messageName) {
-      throw new Error(
-        `Missing message type on ${prototype.constructor}.`
-        + 'This could mean the handler class is missing the @Handles() decorator.'
-      )
-    }
-
     this.handlerRegistry.register(
-      prototype.$messageName,
+      prototype.$resolver,
       prototype.$symbol,
       handler,
       prototype.$message

packages/bus-core/src/handler/handler-registry.spec.ts

@@ -1,15 +1,16 @@
 import { HandlerRegistry } from './handler-registry'
 import { Mock, IMock, Times, It } from 'typemoq'
 import { Logger } from '@node-ts/logger-core'
-import { TestEvent, TestEventHandler, TestCommandHandler } from '../test'
+import { TestEvent, TestEventHandler, TestCommandHandler, TestCommand } from '../test'
 import { Container, interfaces } from 'inversify'
+import { Message } from '@node-ts/bus-messages'
 
 describe('HandlerRegistry', () => {
   let sut: HandlerRegistry
 
   let logger: IMock<Logger>
 
-  const messageName = TestEvent.name
+  const messageName = TestEvent.NAME
   const symbol = Symbol()
   const handler = TestEventHandler
   const messageType = TestEvent
@@ -21,16 +22,21 @@ describe('HandlerRegistry', () => {
     )
   })
 
-  describe('when registring a handler', () => {
+  describe('when registering a handler for a bus message', () => {
     beforeEach(() => {
-      sut.register(messageName, symbol, handler, messageType)
+      sut.register((m: Message) => m.$name === messageName, symbol, handler, messageType)
     })
 
     it('should register the handler', () => {
-      const handlers = sut.get(messageName)
+      const handlers = sut.get(new TestEvent())
       expect(handlers).toHaveLength(1)
     })
 
+    it('should add it to the subscribed bus messages list', () => {
+      const subscription = sut.subscribedBusMessages.find(s => new s().$name === messageType.NAME)
+      expect(subscription).toBeDefined()
+    })
+
     describe('when binding handlers to the container', () => {
       let container: IMock<Container>
       let bindingTo: IMock<interfaces.BindingToSyntax<{}>>
@@ -66,10 +72,21 @@ describe('HandlerRegistry', () => {
     })
   })
 
-  describe('when registrying a handler twice', () => {
+  describe('when registering a handler for an external message', () => {
     beforeEach(() => {
-      sut.register(messageName, symbol, handler, messageType)
-      sut.register(messageName, symbol, handler, messageType)
+      sut.register((m: Message) => m.$name === messageName, symbol, handler)
+    })
+
+    it('should not include the message in the subscribed bus messages list', () => {
+      const messageSubscription = sut.subscribedBusMessages.find(m => new m().$name === messageName)
+      expect(messageSubscription).toBeUndefined()
+    })
+  })
+
+  describe('when registering a handler twice', () => {
+    beforeEach(() => {
+      sut.register((m: Message) => m.$name === messageName, symbol, handler, messageType)
+      sut.register((m: Message) => m.$name === messageName, symbol, handler, messageType)
     })
 
     it('should warn that the handler is already registered', () => {
@@ -80,32 +97,25 @@ describe('HandlerRegistry', () => {
     })
 
     it('should register a single instance of the handler', () => {
-      const handlers = sut.get(messageName)
+      const handlers = sut.get(new TestEvent())
       expect(handlers).toHaveLength(1)
     })
   })
 
-  describe('when adding two handlers of the same name', () => {
-    it('should throw an error', () => {
-      sut.register(messageName, symbol, handler, messageType)
-      expect(() => sut.register('random', symbol, handler, messageType)).toThrowError()
-    })
-  })
-
   describe('when getting a handler', () => {
-    it('should return an empty array for an unregisterd handler', () => {
-      expect(sut.get('')).toHaveLength(0)
+    it('should return an empty array for an unregistered handler', () => {
+      expect(sut.get(new TestCommand())).toHaveLength(0)
     })
 
     it('should return a single handler for a single registration', () => {
-      sut.register(messageName, symbol, handler, messageType)
-      expect(sut.get(messageName)).toHaveLength(1)
+      sut.register((m: Message) => m.$name === messageName, symbol, handler, messageType)
+      expect(sut.get(new TestEvent())).toHaveLength(1)
     })
 
     it('should return a multiple handlers for multiple registrations', () => {
-      sut.register(messageName, symbol, handler, messageType)
-      sut.register(messageName, Symbol(), TestCommandHandler, messageType)
-      expect(sut.get(messageName)).toHaveLength(2)
+      sut.register((m: Message) => m.$name === messageName, symbol, handler, messageType)
+      sut.register((m: Message) => m.$name === messageName, Symbol(), TestCommandHandler, messageType)
+      expect(sut.get(new TestEvent())).toHaveLength(2)
     })
   })