Merge pull request nestjs#1161 from nestjs/refactor/microservices

refactor(microservices) refactor, improvements, use es6 map

Author: kamilmysliwiec

integration/microservices/e2e/sum-nats.spec.ts

@@ -73,6 +73,15 @@ describe('NATS transport', () => {
       .expect(200, 'true');
   });
 
+  it(`/GET (exception)`, () => {
+    return request(server)
+      .get('/exception')
+      .expect(200, {
+        message: 'test',
+        status: 'error',
+      });
+  });
+
   afterEach(async () => {
     await app.close();
   });

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

@@ -1,12 +1,13 @@
-import { Body, Controller, HttpCode, Post, Query } from '@nestjs/common';
+import { Body, Controller, Get, HttpCode, Post, Query } from '@nestjs/common';
 import {
   Client,
   ClientProxy,
   MessagePattern,
+  RpcException,
   Transport,
 } from '@nestjs/microservices';
-import { from, Observable, of } from 'rxjs';
-import { scan } from 'rxjs/operators';
+import { from, Observable, of, throwError } from 'rxjs';
+import { catchError, scan } from 'rxjs/operators';
 
 @Controller()
 export class NatsController {
@@ -71,4 +72,16 @@ export class NatsController {
   streaming(data: number[]): Observable<number> {
     return from(data);
   }
+
+  @Get('exception')
+  async getError() {
+    return await this.client
+      .send<number>('exception', {})
+      .pipe(catchError(err => of(err)));
+  }
+
+  @MessagePattern('exception')
+  throwError(): Observable<number> {
+    return throwError(new RpcException('test'));
+  }
 }

integration/websockets/e2e/error-gateway.spec.ts

@@ -0,0 +1,35 @@
+import { INestApplication } from '@nestjs/common';
+import { Test } from '@nestjs/testing';
+import { expect } from 'chai';
+import * as io from 'socket.io-client';
+import { ErrorGateway } from '../src/error.gateway';
+
+describe('ErrorGateway', () => {
+  let app: INestApplication;
+
+  beforeEach(async () => {
+    const testingModule = await Test.createTestingModule({
+      providers: [ErrorGateway],
+    }).compile();
+    app = await testingModule.createNestApplication();
+    await app.listenAsync(3000);
+  });
+
+  it(`should handle error`, async () => {
+    const ws = io.connect('http://localhost:8080');
+    ws.emit('push', {
+      test: 'test',
+    });
+    await new Promise(resolve =>
+      ws.on('exception', data => {
+        expect(data).to.be.eql({
+          status: 'error',
+          message: 'test',
+        });
+        resolve();
+      }),
+    );
+  });
+
+  afterEach(() => app.close());
+});

integration/websockets/src/error.gateway.ts

@@ -0,0 +1,14 @@
+import {
+  SubscribeMessage,
+  WebSocketGateway,
+  WsException,
+} from '@nestjs/websockets';
+import { throwError } from 'rxjs';
+
+@WebSocketGateway(8080)
+export class ErrorGateway {
+  @SubscribeMessage('push')
+  onPush(client, data) {
+    return throwError(new WsException('test'));
+  }
+}

lerna.json

@@ -3,5 +3,5 @@
   "packages": [
     "packages/*"
   ],
-  "version": "5.4.1"
+  "version": "5.5.0"
 }

packages/common/cache/cache.module.ts

@@ -24,7 +24,10 @@ export class CacheModule {
     return {
       module: CacheModule,
       imports: options.imports,
-      providers: this.createAsyncProviders(options),
+      providers: [
+        ...this.createAsyncProviders(options),
+        ...(options.extraProviders || []),
+      ],
     };
   }
 
@@ -55,7 +58,8 @@ export class CacheModule {
     }
     return {
       provide: CACHE_MODULE_OPTIONS,
-      useFactory: async (optionsFactory: CacheOptionsFactory) => optionsFactory.createCacheOptions(),
+      useFactory: async (optionsFactory: CacheOptionsFactory) =>
+        optionsFactory.createCacheOptions(),
       inject: [options.useExisting || options.useClass],
     };
   }

packages/common/cache/interfaces/cache-module.interface.ts

@@ -1,4 +1,4 @@
-import { ModuleMetadata, Type } from '../../interfaces';
+import { ModuleMetadata, Provider, Type } from '../../interfaces';
 import { CacheManagerOptions } from './cache-manager.interface';
 
 export interface CacheModuleOptions extends CacheManagerOptions {
@@ -17,4 +17,5 @@ export interface CacheModuleAsyncOptions
     ...args: any[]
   ) => Promise<CacheModuleOptions> | CacheModuleOptions;
   inject?: any[];
+  extraProviders?: Provider[];
 }

packages/common/decorators/core/inject.decorator.ts

@@ -15,17 +15,17 @@ export function Inject<T = any>(token?: T) {
       token && isFunction(token) ? ((token as any) as Function).name : token;
 
     if (!isUndefined(index)) {
-      const dependencies =
+      let dependencies =
         Reflect.getMetadata(SELF_DECLARED_DEPS_METADATA, target) || [];
 
-      dependencies.push({ index, param: type });
+      dependencies = [...dependencies, { index, param: type }];
       Reflect.defineMetadata(SELF_DECLARED_DEPS_METADATA, dependencies, target);
       return;
     }
-    const properties =
+    let properties =
       Reflect.getMetadata(PROPERTY_DEPS_METADATA, target.constructor) || [];
 
-    properties.push({ key, type });
+    properties = [...properties, { key, type }];
     Reflect.defineMetadata(
       PROPERTY_DEPS_METADATA,
       properties,

packages/common/http/http.constants.ts

@@ -1,2 +1,3 @@
 export const AXIOS_INSTANCE_TOKEN = 'AXIOS_INSTANCE_TOKEN';
 export const HTTP_MODULE_ID = 'HTTP_MODULE_ID';
+export const HTTP_MODULE_OPTIONS = 'HTTP_MODULE_OPTIONS';

packages/common/http/http.module.ts

@@ -1,9 +1,18 @@
-import Axios, { AxiosRequestConfig } from 'axios';
+import Axios from 'axios';
 import { Module } from '../decorators/modules/module.decorator';
-import { DynamicModule } from '../interfaces';
+import { DynamicModule, Provider } from '../interfaces';
 import { randomStringGenerator } from '../utils/random-string-generator.util';
-import { AXIOS_INSTANCE_TOKEN, HTTP_MODULE_ID } from './http.constants';
+import {
+  AXIOS_INSTANCE_TOKEN,
+  HTTP_MODULE_ID,
+  HTTP_MODULE_OPTIONS,
+} from './http.constants';
 import { HttpService } from './http.service';
+import {
+  HttpModuleAsyncOptions,
+  HttpModuleOptions,
+  HttpModuleOptionsFactory,
+} from './interfaces';
 
 @Module({
   providers: [
@@ -16,7 +25,7 @@ import { HttpService } from './http.service';
   exports: [HttpService],
 })
 export class HttpModule {
-  static register(config: AxiosRequestConfig): DynamicModule {
+  static register(config: HttpModuleOptions): DynamicModule {
     return {
       module: HttpModule,
       providers: [
@@ -31,4 +40,52 @@ export class HttpModule {
       ],
     };
   }
+
+  static registerAsync(options: HttpModuleAsyncOptions): DynamicModule {
+    return {
+      module: HttpModule,
+      imports: options.imports,
+      providers: [
+        ...this.createAsyncProviders(options),
+        {
+          provide: HTTP_MODULE_ID,
+          useValue: randomStringGenerator(),
+        },
+        ...(options.extraProviders || []),
+      ],
+    };
+  }
+
+  private static createAsyncProviders(
+    options: HttpModuleAsyncOptions,
+  ): Provider[] {
+    if (options.useExisting || options.useFactory) {
+      return [this.createAsyncOptionsProvider(options)];
+    }
+    return [
+      this.createAsyncOptionsProvider(options),
+      {
+        provide: options.useClass,
+        useClass: options.useClass,
+      },
+    ];
+  }
+
+  private static createAsyncOptionsProvider(
+    options: HttpModuleAsyncOptions,
+  ): Provider {
+    if (options.useFactory) {
+      return {
+        provide: HTTP_MODULE_OPTIONS,
+        useFactory: options.useFactory,
+        inject: options.inject || [],
+      };
+    }
+    return {
+      provide: HTTP_MODULE_OPTIONS,
+      useFactory: async (optionsFactory: HttpModuleOptionsFactory) =>
+        optionsFactory.createHttpOptions(),
+      inject: [options.useExisting || options.useClass],
+    };
+  }
 }