feat(microservices): add extras param to pattern decorators

Add optional "extras" parameter for MessagePattern and EventPattern decorators. Allow embedding extra params into each message handler method and improve an experience of creating custom microservice transports
nestjs · Jan 16, 2022 · 26e9ed6 · 26e9ed6
1 parent b01afec
commit 26e9ed6
Show file tree

Hide file tree

Showing 11 changed files with 96 additions and 42 deletions.
diff --git a/packages/microservices/constants.ts b/packages/microservices/constants.ts
@@ -20,6 +20,7 @@ export const SUBSCRIBE = 'subscribe';
 export const CANCEL_EVENT = 'cancelled';
 
 export const PATTERN_METADATA = 'microservices:pattern';
+export const PATTERN_EXTRAS_METADATA = 'microservices:pattern_extras';
 export const TRANSPORT_METADATA = 'microservices:transport';
 export const CLIENT_CONFIGURATION_METADATA = 'microservices:client';
 export const PATTERN_HANDLER_METADATA = 'microservices:handler_type';

diff --git a/packages/microservices/decorators/event-pattern.decorator.ts b/packages/microservices/decorators/event-pattern.decorator.ts
@@ -2,6 +2,7 @@ import {
   PATTERN_HANDLER_METADATA,
   PATTERN_METADATA,
   TRANSPORT_METADATA,
+  PATTERN_EXTRAS_METADATA,
 } from '../constants';
 import { PatternHandler } from '../enums/pattern-handler.enum';
 import { Transport } from '../enums';
@@ -12,6 +13,7 @@ import { Transport } from '../enums';
 export const EventPattern = <T = string>(
   metadata?: T,
   transport?: Transport,
+  extras?: Record<string, any>,
 ): MethodDecorator => {
   return (
     target: object,
@@ -25,6 +27,7 @@ export const EventPattern = <T = string>(
       descriptor.value,
     );
     Reflect.defineMetadata(TRANSPORT_METADATA, transport, descriptor.value);
+    Reflect.defineMetadata(PATTERN_EXTRAS_METADATA, extras, descriptor.value);
     return descriptor;
   };
 };
diff --git a/packages/microservices/decorators/message-pattern.decorator.ts b/packages/microservices/decorators/message-pattern.decorator.ts
@@ -3,6 +3,7 @@ import {
   PATTERN_HANDLER_METADATA,
   PATTERN_METADATA,
   TRANSPORT_METADATA,
+  PATTERN_EXTRAS_METADATA,
 } from '../constants';
 import { PatternHandler } from '../enums/pattern-handler.enum';
 import { PatternMetadata } from '../interfaces/pattern-metadata.interface';
@@ -20,6 +21,7 @@ export enum GrpcMethodStreamingType {
 export const MessagePattern = <T = PatternMetadata | string>(
   metadata?: T,
   transport?: Transport,
+  extras?: Record<string, any>,
 ): MethodDecorator => {
   return (
     target: object,
@@ -33,6 +35,7 @@ export const MessagePattern = <T = PatternMetadata | string>(
       descriptor.value,
     );
     Reflect.defineMetadata(TRANSPORT_METADATA, transport, descriptor.value);
+    Reflect.defineMetadata(PATTERN_EXTRAS_METADATA, extras, descriptor.value);
     return descriptor;
   };
 };

diff --git a/packages/microservices/interfaces/message-handler.interface.ts b/packages/microservices/interfaces/message-handler.interface.ts
@@ -4,4 +4,5 @@ export interface MessageHandler<TInput = any, TContext = any, TResult = any> {
   (data: TInput, ctx?: TContext): Promise<Observable<TResult>>;
   next?: (data: TInput, ctx?: TContext) => Promise<Observable<TResult>>;
   isEventHandler?: boolean;
+  extras?: Record<string, any>;
 }
diff --git a/packages/microservices/listener-metadata-explorer.ts b/packages/microservices/listener-metadata-explorer.ts
@@ -7,6 +7,7 @@ import {
   PATTERN_HANDLER_METADATA,
   PATTERN_METADATA,
   TRANSPORT_METADATA,
+  PATTERN_EXTRAS_METADATA,
 } from './constants';
 import { Transport } from './enums';
 import { PatternHandler } from './enums/pattern-handler.enum';
@@ -24,6 +25,7 @@ export interface EventOrMessageListenerDefinition {
   isEventHandler: boolean;
   targetCallback: (...args: any[]) => any;
   transport?: Transport;
+  extras?: Record<string, any>;
 }
 
 export interface MessageRequestProperties {
@@ -58,11 +60,13 @@ export class ListenerMetadataExplorer {
     }
     const pattern = Reflect.getMetadata(PATTERN_METADATA, targetCallback);
     const transport = Reflect.getMetadata(TRANSPORT_METADATA, targetCallback);
+    const extras = Reflect.getMetadata(PATTERN_EXTRAS_METADATA, targetCallback);
     return {
       methodKey,
       targetCallback,
       pattern,
       transport,
+      extras,
       isEventHandler: handlerType === PatternHandler.EVENT,
     };
   }

diff --git a/packages/microservices/listeners-controller.ts b/packages/microservices/listeners-controller.ts
@@ -71,48 +71,55 @@ export class ListenersController {
           isUndefined(server.transportId) ||
           transport === server.transportId,
       )
-      .forEach(({ pattern, targetCallback, methodKey, isEventHandler }) => {
-        if (isStatic) {
-          const proxy = this.contextCreator.create(
-            instance as object,
-            targetCallback,
+      .forEach(
+        ({ pattern, targetCallback, methodKey, extras, isEventHandler }) => {
+          if (isStatic) {
+            const proxy = this.contextCreator.create(
+              instance as object,
+              targetCallback,
+              moduleKey,
+              methodKey,
+              STATIC_CONTEXT,
+              undefined,
+              defaultCallMetadata,
+            );
+            if (isEventHandler) {
+              const eventHandler: MessageHandler = (...args: unknown[]) => {
+                const originalArgs = args;
+                const [dataOrContextHost] = originalArgs;
+                if (dataOrContextHost instanceof RequestContextHost) {
+                  args = args.slice(1, args.length);
+                }
+                const originalReturnValue = proxy(...args);
+                const returnedValueWrapper = eventHandler.next?.(
+                  ...(originalArgs as Parameters<MessageHandler>),
+                );
+                returnedValueWrapper?.then(returnedValue =>
+                  this.connectIfStream(returnedValue as Observable<unknown>),
+                );
+                return originalReturnValue;
+              };
+              return server.addHandler(
+                pattern,
+                eventHandler,
+                isEventHandler,
+                extras,
+              );
+            } else {
+              return server.addHandler(pattern, proxy, isEventHandler, extras);
+            }
+          }
+          const asyncHandler = this.createRequestScopedHandler(
+            instanceWrapper,
+            pattern,
+            moduleRef,
             moduleKey,
             methodKey,
-            STATIC_CONTEXT,
-            undefined,
             defaultCallMetadata,
           );
-          if (isEventHandler) {
-            const eventHandler: MessageHandler = (...args: unknown[]) => {
-              const originalArgs = args;
-              const [dataOrContextHost] = originalArgs;
-              if (dataOrContextHost instanceof RequestContextHost) {
-                args = args.slice(1, args.length);
-              }
-              const originalReturnValue = proxy(...args);
-              const returnedValueWrapper = eventHandler.next?.(
-                ...(originalArgs as Parameters<MessageHandler>),
-              );
-              returnedValueWrapper?.then(returnedValue =>
-                this.connectIfStream(returnedValue as Observable<unknown>),
-              );
-              return originalReturnValue;
-            };
-            return server.addHandler(pattern, eventHandler, isEventHandler);
-          } else {
-            return server.addHandler(pattern, proxy, isEventHandler);
-          }
-        }
-        const asyncHandler = this.createRequestScopedHandler(
-          instanceWrapper,
-          pattern,
-          moduleRef,
-          moduleKey,
-          methodKey,
-          defaultCallMetadata,
-        );
-        server.addHandler(pattern, asyncHandler, isEventHandler);
-      });
+          server.addHandler(pattern, asyncHandler, isEventHandler, extras);
+        },
+      );
   }
 
   public assignClientsToProperties(instance: Controller | Injectable) {

diff --git a/packages/microservices/server/server.ts b/packages/microservices/server/server.ts
@@ -44,9 +44,11 @@ export abstract class Server {
     pattern: any,
     callback: MessageHandler,
     isEventHandler = false,
+    extras: Record<string, any> = {},
   ) {
     const normalizedPattern = this.normalizePattern(pattern);
     callback.isEventHandler = isEventHandler;
+    callback.extras = extras;
 
     if (this.messageHandlers.has(normalizedPattern) && isEventHandler) {
       const headRef = this.messageHandlers.get(normalizedPattern);

diff --git a/packages/microservices/test/decorators/event-pattern.decorator.spec.ts b/packages/microservices/test/decorators/event-pattern.decorator.spec.ts
@@ -1,15 +1,23 @@
 import { expect } from 'chai';
-import { PATTERN_METADATA } from '../../constants';
+import { PATTERN_METADATA, PATTERN_EXTRAS_METADATA } from '../../constants';
 import { EventPattern } from '../../decorators/event-pattern.decorator';
 
 describe('@EventPattern', () => {
   const pattern = { role: 'test' };
+  const extras = { param: 'value' };
   class TestComponent {
-    @EventPattern(pattern)
+    @EventPattern(pattern, undefined, extras)
     public static test() {}
   }
   it(`should enhance method with ${PATTERN_METADATA} metadata`, () => {
     const metadata = Reflect.getMetadata(PATTERN_METADATA, TestComponent.test);
     expect(metadata).to.be.eql(pattern);
   });
+  it(`should enhance method with ${PATTERN_EXTRAS_METADATA} metadata`, () => {
+    const metadata = Reflect.getMetadata(
+      PATTERN_EXTRAS_METADATA,
+      TestComponent.test,
+    );
+    expect(metadata).to.be.deep.equal(extras);
+  });
 });
diff --git a/packages/microservices/test/decorators/message-pattern.decorator.spec.ts b/packages/microservices/test/decorators/message-pattern.decorator.spec.ts
@@ -1,5 +1,5 @@
 import { expect } from 'chai';
-import { PATTERN_METADATA } from '../../constants';
+import { PATTERN_METADATA, PATTERN_EXTRAS_METADATA } from '../../constants';
 import {
   GrpcMethod,
   GrpcMethodStreamingType,
@@ -10,14 +10,22 @@ import {
 
 describe('@MessagePattern', () => {
   const pattern = { role: 'test' };
+  const extras = { param: 'value' };
   class TestComponent {
-    @MessagePattern(pattern)
+    @MessagePattern(pattern, undefined, extras)
     public static test() {}
   }
   it(`should enhance method with ${PATTERN_METADATA} metadata`, () => {
     const metadata = Reflect.getMetadata(PATTERN_METADATA, TestComponent.test);
     expect(metadata).to.be.eql(pattern);
   });
+  it(`should enhance method with ${PATTERN_EXTRAS_METADATA} metadata`, () => {
+    const metadata = Reflect.getMetadata(
+      PATTERN_EXTRAS_METADATA,
+      TestComponent.test,
+    );
+    expect(metadata).to.be.deep.equal(extras);
+  });
 });
 
 describe('@GrpcMethod', () => {

diff --git a/packages/microservices/test/listeners-controller.spec.ts b/packages/microservices/test/listeners-controller.spec.ts
@@ -118,6 +118,22 @@ describe('ListenersController', () => {
       instance.registerPatternHandlers(new InstanceWrapper(), serverTCP, '');
       expect(addSpyTCP.calledTwice).to.be.true;
     });
+    it(`should call "addHandler" method of server with extras data`, () => {
+      const serverHandlers = [
+        { pattern: 'test', targetCallback: 'tt', extras: { param: 'value' } },
+      ];
+      explorer.expects('explore').returns(serverHandlers);
+      instance.registerPatternHandlers(new InstanceWrapper(), serverTCP, '');
+      expect(addSpyTCP.calledOnce).to.be.true;
+      expect(
+        addSpyTCP.calledWith(
+          sinon.match.any,
+          sinon.match.any,
+          sinon.match.any,
+          sinon.match({ param: 'value' }),
+        ),
+      ).to.be.true;
+    });
     describe('when request scoped', () => {
       it(`should call "addHandler" with deferred proxy`, () => {
         explorer.expects('explore').returns(handlers);

diff --git a/packages/microservices/test/listeners-metadata-explorer.spec.ts b/packages/microservices/test/listeners-metadata-explorer.spec.ts
@@ -77,6 +77,7 @@ describe('ListenerMetadataExplorer', () => {
         'targetCallback',
         'pattern',
         'transport',
+        'extras',
       ]);
       expect(metadata.pattern).to.eql(pattern);
     });