Merge pull request nestjs#3039 from nestjs/feat/rpc-ws-decorators

feat() add rpc & ws decorators, add rpc context

Author: kamilmysliwiec

integration/microservices/src/nats/nats.controller.ts

@@ -2,8 +2,11 @@ import { Body, Controller, Get, HttpCode, Post, Query } from '@nestjs/common';
 import {
   Client,
   ClientProxy,
+  Ctx,
   EventPattern,
   MessagePattern,
+  NatsContext,
+  Payload,
   RpcException,
   Transport,
 } from '@nestjs/microservices';
@@ -57,7 +60,7 @@ export class NatsController {
   }
 
   @MessagePattern('math.*')
-  sum(data: number[]): number {
+  sum(@Payload() data: number[], @Ctx() context: NatsContext): number {
     return (data || []).reduce((a, b) => a + b);
   }
 
@@ -94,7 +97,7 @@ export class NatsController {
   }
 
   @EventPattern('notification')
-  eventHandler(data: boolean) {
+  eventHandler(@Payload() data: boolean) {
     NatsController.IS_NOTIFIED = data;
   }
 }

integration/websockets/src/app.gateway.ts

@@ -1,9 +1,13 @@
-import { WebSocketGateway, SubscribeMessage } from '@nestjs/websockets';
+import {
+  MessageBody,
+  SubscribeMessage,
+  WebSocketGateway,
+} from '@nestjs/websockets';
 
 @WebSocketGateway(8080)
 export class ApplicationGateway {
   @SubscribeMessage('push')
-  onPush(client, data) {
+  onPush(@MessageBody() data) {
     return {
       event: 'pop',
       data,

integration/websockets/src/core.gateway.ts

@@ -1,9 +1,14 @@
-import { SubscribeMessage, WebSocketGateway } from '@nestjs/websockets';
+import {
+  ConnectedSocket,
+  MessageBody,
+  SubscribeMessage,
+  WebSocketGateway,
+} from '@nestjs/websockets';
 
 @WebSocketGateway(8090)
 export class CoreGateway {
   @SubscribeMessage('push')
-  onPush(client, data) {
+  onPush(@ConnectedSocket() client, @MessageBody() data) {
     return {
       event: 'pop',
       data,

integration/websockets/src/server.gateway.ts

@@ -1,4 +1,4 @@
-import { WebSocketGateway, SubscribeMessage } from '@nestjs/websockets';
+import { SubscribeMessage, WebSocketGateway } from '@nestjs/websockets';
 
 @WebSocketGateway()
 export class ServerGateway {

packages/common/decorators/http/create-route-param-metadata.decorator.ts

@@ -7,10 +7,10 @@ import { PipeTransform } from '../../index';
 import { Type } from '../../interfaces';
 import { CustomParamFactory } from '../../interfaces/features/custom-route-param-factory.interface';
 import { isFunction, isNil } from '../../utils/shared.utils';
-import { ParamData, RouteParamsMetadata } from './route-params.decorator';
+import { ParamData, RouteParamMetadata } from './route-params.decorator';
 
 const assignCustomMetadata = (
-  args: RouteParamsMetadata,
+  args: Record<number, RouteParamMetadata>,
   paramtype: number | string,
   index: number,
   factory: CustomParamFactory,

packages/common/decorators/http/route-params.decorator.ts

@@ -5,35 +5,40 @@ import { Type } from '../../interfaces';
 import { isNil, isString } from '../../utils/shared.utils';
 
 export type ParamData = object | string | number;
-export interface RouteParamsMetadata {
-  [prop: number]: {
-    index: number;
-    data?: ParamData;
-  };
+export interface RouteParamMetadata {
+  index: number;
+  data?: ParamData;
 }
 
-const assignMetadata = (
-  args: RouteParamsMetadata,
-  paramtype: RouteParamtypes,
+export function assignMetadata<TParamtype = any, TArgs = any>(
+  args: TArgs,
+  paramtype: TParamtype,
   index: number,
   data?: ParamData,
   ...pipes: (Type<PipeTransform> | PipeTransform)[]
-) => ({
-  ...args,
-  [`${paramtype}:${index}`]: {
-    index,
-    data,
-    pipes,
-  },
-});
+) {
+  return {
+    ...args,
+    [`${paramtype}:${index}`]: {
+      index,
+      data,
+      pipes,
+    },
+  };
+}
 
 const createRouteParamDecorator = (paramtype: RouteParamtypes) => {
   return (data?: ParamData): ParameterDecorator => (target, key, index) => {
     const args =
       Reflect.getMetadata(ROUTE_ARGS_METADATA, target.constructor, key) || {};
     Reflect.defineMetadata(
       ROUTE_ARGS_METADATA,
-      assignMetadata(args, paramtype, index, data),
+      assignMetadata<RouteParamtypes, Record<number, RouteParamMetadata>>(
+        args,
+        paramtype,
+        index,
+        data,
+      ),
       target.constructor,
       key,
     );

packages/common/interfaces/features/custom-route-param-factory.interface.ts

@@ -1,4 +1,4 @@
-export type CustomParamFactory<TData = any, TRequest = any, TResult = any> = (
+export type CustomParamFactory<TData = any, TInput = any, TOutput = any> = (
   data: TData,
-  req: TRequest,
-) => TResult;
+  input: TInput,
+) => TOutput;

packages/common/test/decorators/global.decorator.spec.ts

@@ -2,7 +2,7 @@ import { expect } from 'chai';
 import { GLOBAL_MODULE_METADATA } from '../../constants';
 import { Global } from '../../index';
 
-describe('Global', () => {
+describe('@Global', () => {
   @Global()
   class Test {}
 

packages/core/helpers/context-utils.ts

@@ -1,6 +1,7 @@
 import { ParamData } from '@nestjs/common';
 import { PARAMTYPES_METADATA } from '@nestjs/common/constants';
 import { Controller, PipeTransform } from '@nestjs/common/interfaces';
+import { isFunction } from '@nestjs/common/utils/shared.utils';
 
 export interface ParamProperties<T = any, IExtractor extends Function = any> {
   index: number;
@@ -51,4 +52,13 @@ export class ContextUtils {
       metatype: paramtypes[param.index],
     }));
   }
+
+  public getCustomFactory(
+    factory: (...args: unknown[]) => void,
+    data: unknown,
+  ): (...args: unknown[]) => unknown {
+    return isFunction(factory)
+      ? (...args: unknown[]) => factory(data, args)
+      : () => null;
+  }
 }

packages/core/helpers/external-context-creator.ts

@@ -14,32 +14,16 @@ import { PipesConsumer } from '../pipes/pipes-consumer';
 import { PipesContextCreator } from '../pipes/pipes-context-creator';
 import { ExternalExceptionFilterContext } from './../exceptions/external-exception-filter-context';
 import { STATIC_CONTEXT } from './../injector/constants';
-import { ContextId } from './../injector/instance-wrapper';
 import { ContextUtils, ParamProperties } from './context-utils';
 import { ExternalErrorProxy } from './external-proxy';
 import { HandlerMetadataStorage } from './handler-metadata-storage';
-
-export interface ParamsMetadata {
-  [prop: number]: {
-    index: number;
-    data?: ParamData;
-  };
-}
+import { ExternalHandlerMetadata } from './interfaces/external-handler-metadata.interface';
+import { ParamsMetadata } from './interfaces/params-metadata.interface';
 
 export interface ParamsFactory {
   exchangeKeyForValue(type: number, data: ParamData, args: any): any;
 }
 
-export interface ExternalHandlerMetadata {
-  argsLength: number;
-  paramtypes: any[];
-  getParamsMetadata: (
-    moduleKey: string,
-    contextId?: ContextId,
-    inquirerId?: string,
-  ) => (ParamProperties & { metatype?: any })[];
-}
-
 export interface ExternalContextOptions {
   guards?: boolean;
   interceptors?: boolean;
@@ -110,7 +94,7 @@ export class ExternalContextCreator {
       filters: true,
     },
   ) {
-    const module = this.findContextModuleName(instance.constructor);
+    const module = this.getContextModuleName(instance.constructor);
     const { argsLength, paramtypes, getParamsMetadata } = this.getMetadata<T>(
       instance,
       methodName,
@@ -230,20 +214,21 @@ export class ExternalContextCreator {
     return handlerMetadata;
   }
 
-  public findContextModuleName(constructor: Function): string {
+  public getContextModuleName(constructor: Function): string {
+    const defaultModuleName = '';
     const className = constructor.name;
     if (!className) {
-      return '';
+      return defaultModuleName;
     }
     for (const [key, module] of [...this.modulesContainer.entries()]) {
-      if (this.findProviderByClassName(module, className)) {
+      if (this.getProviderByClassName(module, className)) {
         return key;
       }
     }
-    return '';
+    return defaultModuleName;
   }
 
-  public findProviderByClassName(module: Module, className: string): boolean {
+  public getProviderByClassName(module: Module, className: string): boolean {
     const { providers } = module;
     const hasProvider = [...providers.keys()].some(
       provider => provider === className,
@@ -271,50 +256,45 @@ export class ExternalContextCreator {
 
       if (key.includes(CUSTOM_ROUTE_AGRS_METADATA)) {
         const { factory } = metadata[key];
-        const customExtractValue = this.getCustomFactory(factory, data);
+        const customExtractValue = this.contextUtils.getCustomFactory(
+          factory,
+          data,
+        );
         return { index, extractValue: customExtractValue, type, data, pipes };
       }
       const numericType = Number(type);
-      const extractValue = (...args: any[]) =>
+      const extractValue = (...args: unknown[]) =>
         paramsFactory.exchangeKeyForValue(numericType, data, args);
 
       return { index, extractValue, type: numericType, data, pipes };
     });
   }
 
-  public getCustomFactory(
-    factory: (...args: any[]) => void,
-    data: any,
-  ): (...args: any[]) => any {
-    return isFunction(factory)
-      ? (...args: any[]) => factory(data, args)
-      : () => null;
-  }
-
   public createPipesFn(
     pipes: PipeTransform[],
-    paramsOptions: (ParamProperties & { metatype?: any })[],
+    paramsOptions: (ParamProperties & { metatype?: unknown })[],
   ) {
-    const pipesFn = async (args: any[], ...params: any[]) => {
-      await Promise.all(
-        paramsOptions.map(async param => {
-          const {
-            index,
-            extractValue,
-            type,
-            data,
-            metatype,
-            pipes: paramPipes,
-          } = param;
-          const value = extractValue(...params);
+    const pipesFn = async (args: unknown[], ...params: unknown[]) => {
+      const resolveParamValue = async (
+        param: ParamProperties & { metatype?: unknown },
+      ) => {
+        const {
+          index,
+          extractValue,
+          type,
+          data,
+          metatype,
+          pipes: paramPipes,
+        } = param;
+        const value = extractValue(...params);
 
-          args[index] = await this.getParamValue(
-            value,
-            { metatype, type, data },
-            pipes.concat(paramPipes),
-          );
-        }),
-      );
+        args[index] = await this.getParamValue(
+          value,
+          { metatype, type, data },
+          pipes.concat(paramPipes),
+        );
+      };
+      await Promise.all(paramsOptions.map(resolveParamValue));
     };
     return paramsOptions.length ? pipesFn : null;
   }