✨ Add Metadata (#33)

src/core/mediator.test.ts

@@ -5,7 +5,7 @@ import { MessageHandler } from './messageHandler';
 import { clear, mediator } from './mediator';
 import { UnknownMessageError } from './errors/unknownMessage.error';
 import { MultipleHandlersError } from './errors/multipleHandlers.error';
-import { should } from 'chai';
+import { expect, should } from 'chai';
 import { Middleware } from './middlewares';
 
 should();
@@ -70,6 +70,46 @@ describe('mediator.send', () => {
     actual.should.be.deep.equal(expected);
   });
 
+  it('should return registered metadata when getting metadata from mediator', async () => {
+    // Arrange
+    const type1 = 'TYPE_1';
+    const type2 = 'TYPE_2';
+    mediator.register(type2, async () => {}, { meta1Prop: 'meta1value' });
+    mediator.register(type2, async () => {}, { meta2Prop: 'meta2value' });
+    mediator.register(type1, async () => {}, { meta3Prop: 'meta3value' });
+
+    // Act
+    const actualMessageMetadata = mediator.getMetadata(type2);
+
+    const expectedMessageMetadata = {
+      meta1Prop: 'meta1value',
+      meta2Prop: 'meta2value',
+    };
+
+    // Assert
+    expect(actualMessageMetadata).to.be.deep.equal(expectedMessageMetadata);
+
+    const actualAllMetadata = mediator.getAllMetadata();
+
+    const expectedAllMetadata = [
+      {
+        type: type2,
+        metadata: {
+          meta1Prop: 'meta1value',
+          meta2Prop: 'meta2value',
+        },
+      },
+      {
+        type: type1,
+        metadata: {
+          meta3Prop: 'meta3value',
+        },
+      },
+    ];
+
+    actualAllMetadata.should.deep.equal(expectedAllMetadata);
+  });
+
   it('should throw error when sending an unknown message through the mediator', async () => {
     // Arrange
     const type = 'CREATE_PERSON';

src/core/mediator.ts

@@ -3,16 +3,24 @@ import { MessageHandler } from './messageHandler';
 import { MessageResult } from './messageResult';
 import { MultipleHandlersError } from './errors/multipleHandlers.error';
 import { UnknownMessageError } from './errors/unknownMessage.error';
-import { AddOptions, Middleware, middlewares } from './middlewares';
+import { AddOptions, middlewares } from './middlewares';
+import { Metadata } from './metadata';
 
 const registry = new Map<string, Array<MessageHandler>>();
+const metadatas = new Map<string, Metadata>();
 
 const register = <TKey extends string, TMessage extends Message<TKey>>(
   messageType: TKey,
   messageHandler: MessageHandler<TMessage>,
+  metadata: Metadata = {},
 ) => {
   const handlers = registry.get(messageType) ?? [];
   registry.set(messageType, [...handlers, messageHandler as MessageHandler]);
+  const meta = metadatas.get(messageType);
+  metadatas.set(messageType, {
+    ...meta,
+    ...metadata,
+  });
 };
 
 const getHandlers = <TKey extends string, TMessage extends Message<TKey>>(
@@ -23,7 +31,7 @@ const getHandlers = <TKey extends string, TMessage extends Message<TKey>>(
   }
 
   const handlers = registry.get(messageType) as Array<MessageHandler<TMessage>>;
-  return handlers.map((h) => middlewares.apply(messageType, h));
+  return handlers.map((handler) => middlewares.apply(messageType, handler));
 };
 
 const send = async <TMessage extends Message>({
@@ -51,18 +59,24 @@ const use = <TMessage extends Message>(options: UseOptions<TMessage>) => {
   middlewares.add(options);
 };
 
-const getMessageTypes = () => [...registry.keys()].sort();
+const getMessageTypes = () => Array.from(registry.keys()).sort();
+const getMetadata = (type: string) => metadatas.get(type);
+const getAllMetadata = () =>
+  Array.from(metadatas.entries(), ([key, value]) => ({ type: key, metadata: value }));
 
 const mediator = {
   register,
   send,
   publish,
   use,
   getMessageTypes,
+  getMetadata,
+  getAllMetadata,
 } as const;
 
 const clear = () => {
   registry.clear();
+  metadatas.clear();
   middlewares.clear();
 };
 

src/core/metadata.ts

@@ -0,0 +1 @@
+export type Metadata = Record<string, unknown>;

src/core/middlewares.ts

@@ -21,7 +21,7 @@ const createChain = <TMessage extends Message>(
   const middlewares = [
     ...globalMiddlewares,
     ...(messageMiddlewares.get(messageType) ?? []),
-    ...(handlerMiddlewares.get(handler) ?? []),
+    ...(handlerMiddlewares.get(handler as MessageHandler) ?? []),
   ];
 
   const chain = (): MessageHandler<TMessage> => {
@@ -54,8 +54,9 @@ const hasMiddlewares = <TMessage extends Message>(
   const hasGlobalMiddlewares = !!globalMiddlewares.size;
   const hasMessageMiddlewares = !!(messageMiddlewares.get(messageType) || [])
     .length;
-  const hasHandlerMiddlewares = !!(handlerMiddlewares.get(handler) || [])
-    .length;
+  const hasHandlerMiddlewares = !!(
+    handlerMiddlewares.get(handler as MessageHandler) || []
+  ).length;
 
   return hasGlobalMiddlewares || hasMessageMiddlewares || hasHandlerMiddlewares;
 };
@@ -105,9 +106,10 @@ const add = <TMessage extends Message>(options: AddOptions<TMessage>) => {
       ]);
     }
   } else if (isAddHandlerMiddlewaresOptions(options)) {
-    const middlewares = handlerMiddlewares.get(options.handler) ?? [];
+    const middlewares =
+      handlerMiddlewares.get(options.handler as MessageHandler) ?? [];
 
-    handlerMiddlewares.set(options.handler, [
+    handlerMiddlewares.set(options.handler as MessageHandler, [
       ...middlewares,
       ...(options.middlewares as ReadonlyArray<Middleware>),
     ]);