feat: generics in registry + handle multiple messages on the same handler (#23)

* feat: Generics in registry + handle multiple messages on the same handler via routing keys

* feat: Generics in registry + handle multiple messages on the same handler via routing keys

* feat: Generics in registry + handle multiple messages on the same handler via routing keys

Author: Sebastian-Iwanczyszyn

README.md

@@ -89,7 +89,7 @@ import { SendMessage } from './send-message';
 import { MessageResponse, MessageHandler, IMessageHandler } from '@nestjstools/messaging';
 import { Injectable } from '@nestjs/common';
 
-
+// You can define multiple routing messages on the same handler: @MessageHandler('your.message', 'your.message2')
 @Injectable()
 @MessageHandler('your.message')
 export class SendMessageHandler implements IMessageHandler<SendMessage> {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjstools/messaging",
-  "version": "2.14.0",
+  "version": "2.15.0",
   "description": "Simplifies asynchronous and synchronous message handling with support for buses, handlers, channels, and consumers. Build scalable, decoupled applications with ease and reliability.",
   "author": "Sebastian Iwanczyszyn",
   "license": "MIT",

src/dependency-injection/decorator.ts

@@ -9,7 +9,7 @@ export const MESSAGING_NORMALIZER_METADATA = 'MESSAGING_NORMALIZER_METADATA';
 export const MESSAGING_EXCEPTION_LISTENER_METADATA = 'MESSAGING_EXCEPTION_LISTENER_METADATA';
 export const MESSAGING_MESSAGE_METADATA = 'MESSAGING_MESSAGE_METADATA';
 
-export const MessageHandler = (routingKey: string): ClassDecorator => {
+export const MessageHandler = (...routingKey: string[]): ClassDecorator => {
   return (target: Function) => {
     Reflect.defineMetadata(MESSAGE_HANDLER_METADATA, routingKey, target);
   };

src/dependency-injection/register.ts

@@ -8,6 +8,9 @@ import {
 } from './decorator';
 import { DEFAULT_MIDDLEWARE, DEFAULT_NORMALIZER } from '../const';
 import { Registry } from '../shared/registry';
+import { MiddlewareRegistry } from '../middleware/middleware.registry';
+import { ExceptionListenerRegistry } from '../exception-listener/exception-listener.registry';
+import { NormalizerRegistry } from '../normalizer/normalizer.registry';
 
 export const registerHandlers = (
   moduleRef: ModuleRef,
@@ -38,32 +41,32 @@ export const registerMiddlewares = (
   moduleRef: ModuleRef,
   discoveryService: DiscoveryService,
 ) => {
-  register(moduleRef, discoveryService, Service.MIDDLEWARE_REGISTRY, MESSAGING_MIDDLEWARE_METADATA, 'Middleware');
+  register<MiddlewareRegistry>(moduleRef, discoveryService, Service.MIDDLEWARE_REGISTRY, MESSAGING_MIDDLEWARE_METADATA, 'Middleware');
 };
 
 export const registerMessageNormalizers = (
   moduleRef: ModuleRef,
   discoveryService: DiscoveryService,
 ) => {
-  register(moduleRef, discoveryService, Service.MESSAGE_NORMALIZERS_REGISTRY, MESSAGING_NORMALIZER_METADATA, 'MessageNormalizer');
+  register<NormalizerRegistry>(moduleRef, discoveryService, Service.MESSAGE_NORMALIZERS_REGISTRY, MESSAGING_NORMALIZER_METADATA, 'MessageNormalizer');
 };
 
 export const registerExceptionListener = (
   moduleRef: ModuleRef,
   discoveryService: DiscoveryService,
 ) => {
-  register(moduleRef, discoveryService, Service.EXCEPTION_LISTENER_REGISTRY, MESSAGING_EXCEPTION_LISTENER_METADATA, 'ExceptionListener');
+  register<ExceptionListenerRegistry>(moduleRef, discoveryService, Service.EXCEPTION_LISTENER_REGISTRY, MESSAGING_EXCEPTION_LISTENER_METADATA, 'ExceptionListener');
 };
 
-const register = (
+const register = <T extends Registry<object>>(
   moduleRef: ModuleRef,
   discoveryService: DiscoveryService,
   registryProvider: string,
   decoratorMetadata: string,
   name: string,
 ) => {
   const exceptions = [DEFAULT_NORMALIZER, DEFAULT_MIDDLEWARE];
-  const registry: Registry<any> = moduleRef.get(
+  const registry: Registry<T> = moduleRef.get(
     registryProvider,
   );
   const logger: MessagingLogger = moduleRef.get(Service.LOGGER);

src/handler/message-handler.registry.ts

@@ -4,7 +4,13 @@ import { HandlerForMessageNotFoundException } from '../exception/handler-for-mes
 export class MessageHandlerRegistry {
   private registry: Map<string, IMessageHandler<any>[]> = new Map();
 
-  register(name: string, handler: IMessageHandler<any>): void {
+  register(names: string[], handler: IMessageHandler<any>): void {
+    names.forEach((name) => {
+      this.registerSingle(name, handler);
+    });
+  }
+
+  private registerSingle(name: string, handler: IMessageHandler<any>): void {
     if (this.registry.has(name)) {
       const bucket = this.registry.get(name) as Array<IMessageHandler<any>>;
 

test/unit/bus/in-memory-message.bus.spec.ts

@@ -71,7 +71,7 @@ describe('InMemoryMessageBus', () => {
       handle: jest.fn(),
     } as unknown as IMessageHandler<any>
 
-    handlerRegistry.register('my_routing.key', handler)
+    handlerRegistry.register(['my_routing.key'], handler)
 
     const subjectUnderTest = new InMemoryMessageBus(
       handlerRegistry,

test/unit/handler/message-handler.registry.spec.ts

@@ -12,13 +12,13 @@ describe('MessageHandlerRegistry', () => {
   });
 
   test('should register a handler for a given name', () => {
-    registry.register('testEvent', mockHandler);
+    registry.register(['testEvent'], mockHandler);
     expect(registry.getByRoutingKey('testEvent')).toContain(mockHandler);
   });
 
   test('should not register the same handler twice for the same name', () => {
-    registry.register('testEvent', mockHandler);
-    registry.register('testEvent', mockHandler);
+    registry.register(['testEvent'], mockHandler);
+    registry.register(['testEvent'], mockHandler);
     expect(registry.getByRoutingKey('testEvent').length).toBe(1);
   });
 

test/unit/middleware/handler-middleware.spec.ts

@@ -10,7 +10,7 @@ describe('HandlerMiddleware', () => {
   beforeEach(() => {
     logger = SpyLogger.create();
     registry = new MessageHandlerRegistry();
-    registry.register('abc', { handle: jest.fn(() => null) } as IMessageHandler<any>);
+    registry.register(['abc'], { handle: jest.fn(() => null) } as IMessageHandler<any>);
   });
 
   test('should found a handler', () => {