nestjs / nest / 829

pending completion

Build # 829

Build Type

Pull #821

travis-ci

Committed by

web-flow

Commit Message

Merge remote-tracking branch 'origin/813-ws-req-on-connection-fix' into 813-ws-req-on-connection-fix

Pull Request Pull Request #821: refactor(@nestjs/websocket) ws support for connection req

Run Details

777 of 873 branches covered (89.0%)

4 of 4 new or added lines in 1 file covered. (100.0%)

2584 of 2679 relevant lines covered (96.45%)

12.46 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.02

/packages/websockets/web-sockets-controller.ts

import { Type } from '@nestjs/common/interfaces/type.interface';
import { isFunction } from '@nestjs/common/utils/shared.utils';
import { ApplicationConfig } from '@nestjs/core/application-config';
import { NestContainer } from '@nestjs/core/injector/container';
import { MetadataScanner } from '@nestjs/core/metadata-scanner';
import 'reflect-metadata';
import { from as fromPromise, Observable, of, Subject } from 'rxjs';
import { distinctUntilChanged, mergeAll } from 'rxjs/operators';
import { GATEWAY_OPTIONS, PORT_METADATA } from './constants';
import { WsContextCreator } from './context/ws-context-creator';
import { InvalidSocketPortException } from './exceptions/invalid-socket-port.exception';
import {
  GatewayMetadataExplorer,
  MessageMappingProperties,
} from './gateway-metadata-explorer';
import { NestGateway } from './interfaces/nest-gateway.interface';
import { ObservableSocketServer } from './interfaces/observable-socket-server.interface';
import { MiddlewareInjector } from './middleware-injector';
import { SocketServerProvider } from './socket-server-provider';

export class WebSocketsController {
  private readonly metadataExplorer = new GatewayMetadataExplorer(
    new MetadataScanner(),
  );
  private readonly middlewareInjector: MiddlewareInjector;

  constructor(
    private readonly socketServerProvider: SocketServerProvider,
    private readonly container: NestContainer,
    private readonly config: ApplicationConfig,
    private readonly contextCreator: WsContextCreator,
  ) {
    this.middlewareInjector = new MiddlewareInjector(container, config);
  }

  public hookGatewayIntoServer(
    instance: NestGateway,
    metatype: Type<any>,
    module: string,
  ) {
    const options = Reflect.getMetadata(GATEWAY_OPTIONS, metatype) || {};
    const port = Reflect.getMetadata(PORT_METADATA, metatype) || 0;

    if (!Number.isInteger(port)) {
      throw new InvalidSocketPortException(port, metatype);
    }
    this.subscribeObservableServer(instance, options, port, module);
  }

  public subscribeObservableServer(
    instance: NestGateway,
    options: any,
    port: number,
    module: string,
  ) {
    const plainMessageHandlers = this.metadataExplorer.explore(instance);
    const messageHandlers = plainMessageHandlers.map(
      ({ callback, message }) => ({
        message,
        callback: this.contextCreator.create(instance, callback, module),
      }),
    );
    const observableServer = this.socketServerProvider.scanForSocketServer(
      options,
      port,
    );
    this.injectMiddleware(observableServer, instance, module);
    this.hookServerToProperties(instance, observableServer.server);
    this.subscribeEvents(instance, messageHandlers, observableServer);
  }

  public injectMiddleware({ server }, instance: NestGateway, module: string) {
    this.middlewareInjector.inject(server, instance, module);
  }

  public subscribeEvents(
    instance: NestGateway,
    messageHandlers: MessageMappingProperties[],
    observableServer: ObservableSocketServer,
  ) {
    const { init, disconnect, connection, server } = observableServer;
    const adapter = this.config.getIoAdapter();

    this.subscribeInitEvent(instance, init);
    this.subscribeConnectionEvent(instance, connection);
    this.subscribeDisconnectEvent(instance, disconnect);

    const handler = this.getConnectionHandler(
      this,
      instance,
      messageHandlers,
      disconnect,
      connection,
    );
    adapter.bindClientConnect(server, handler);
  }

  public getConnectionHandler(
    context: WebSocketsController,
    instance: NestGateway,
    messageHandlers: MessageMappingProperties[],
    disconnect: Subject<any>,
    connection: Subject<any>,
  ) {
    const adapter = this.config.getIoAdapter();
    return (client, ...rest) => {
      // here different websocket implements may have different args
      // `ws` will have two args applied to this callback
      connection.next([client, ...rest]);

      context.subscribeMessages(messageHandlers, client, instance);

      const disconnectHook = adapter.bindClientDisconnect;
      disconnectHook &&
        disconnectHook.call(adapter, client, _ => disconnect.next(client));
    };
  }

  public subscribeInitEvent(instance: NestGateway, event: Subject<any>) {
    if (instance.afterInit) {
      event.subscribe(instance.afterInit.bind(instance));
    }
  }

  public subscribeConnectionEvent(instance: NestGateway, event: Subject<any>) {
    if (instance.handleConnection) {
      event.pipe(distinctUntilChanged()).subscribe((args: any[]) => {
        instance.handleConnection.bind(instance)(...args);
      });
    }
  }

  public subscribeDisconnectEvent(instance: NestGateway, event: Subject<any>) {
    if (instance.handleDisconnect) {
      event
        .pipe(distinctUntilChanged())
        .subscribe(instance.handleDisconnect.bind(instance));
    }
  }

  public subscribeMessages(
    messageHandlers: MessageMappingProperties[],
    client,
    instance: NestGateway,
  ) {
    const adapter = this.config.getIoAdapter();
    const handlers = messageHandlers.map(({ callback, message }) => ({
      message,
      callback: callback.bind(instance, client),
    }));
    adapter.bindMessageHandlers(client, handlers, data =>
      fromPromise(this.pickResult(data)).pipe(mergeAll()),
    );
  }

  public async pickResult(
    defferedResult: Promise<any>,
  ): Promise<Observable<any>> {
    const result = await defferedResult;
    if (result && isFunction(result.subscribe)) {
      return result;
    }
    if (result instanceof Promise) {
      return fromPromise(result);
    }
    return of(result);
  }

  private hookServerToProperties(instance: NestGateway, server) {
    for (const propertyKey of this.metadataExplorer.scanForServerHooks(
      instance,
    )) {
      Reflect.set(instance, propertyKey, server);
    }
  }
}

1	import { Type } from '@nestjs/common/interfaces/type.interface';
2	import { isFunction } from '@nestjs/common/utils/shared.utils';	2✔
3	import { ApplicationConfig } from '@nestjs/core/application-config';
4	import { NestContainer } from '@nestjs/core/injector/container';
5	import { MetadataScanner } from '@nestjs/core/metadata-scanner';	2✔
6	import 'reflect-metadata';	2✔
7	import { from as fromPromise, Observable, of, Subject } from 'rxjs';	2✔
8	import { distinctUntilChanged, mergeAll } from 'rxjs/operators';	2✔
9	import { GATEWAY_OPTIONS, PORT_METADATA } from './constants';	2✔
10	import { WsContextCreator } from './context/ws-context-creator';
11	import { InvalidSocketPortException } from './exceptions/invalid-socket-port.exception';	2✔
12	import {	2✔
13	GatewayMetadataExplorer,
14	MessageMappingProperties,
15	} from './gateway-metadata-explorer';
16	import { NestGateway } from './interfaces/nest-gateway.interface';
17	import { ObservableSocketServer } from './interfaces/observable-socket-server.interface';
18	import { MiddlewareInjector } from './middleware-injector';	2✔
19	import { SocketServerProvider } from './socket-server-provider';
20
21	export class WebSocketsController {	2✔
22	private readonly metadataExplorer = new GatewayMetadataExplorer(	48✔
23	new MetadataScanner(),
24	);
25	private readonly middlewareInjector: MiddlewareInjector;
26
27	constructor(
28	private readonly socketServerProvider: SocketServerProvider,	48✔
29	private readonly container: NestContainer,	48✔
30	private readonly config: ApplicationConfig,	48✔
31	private readonly contextCreator: WsContextCreator,	48✔
32	) {
33	this.middlewareInjector = new MiddlewareInjector(container, config);	48✔
34	}
35
36	public hookGatewayIntoServer(
37	instance: NestGateway,
38	metatype: Type<any>,
39	module: string,
40	) {
41	const options = Reflect.getMetadata(GATEWAY_OPTIONS, metatype) \|\| {};	6!
42	const port = Reflect.getMetadata(PORT_METADATA, metatype) \|\| 0;	6✔
43
44	if (!Number.isInteger(port)) {	6✔
45	throw new InvalidSocketPortException(port, metatype);	2✔
46	}
47	this.subscribeObservableServer(instance, options, port, module);	4✔
48	}
49
50	public subscribeObservableServer(
51	instance: NestGateway,
52	options: any,
53	port: number,
54	module: string,
55	) {
56	const plainMessageHandlers = this.metadataExplorer.explore(instance);	4✔
57	const messageHandlers = plainMessageHandlers.map(	4✔
58	({ callback, message }) => ({	4✔
59	message,
60	callback: this.contextCreator.create(instance, callback, module),
61	}),
62	);
63	const observableServer = this.socketServerProvider.scanForSocketServer(	4✔
64	options,
65	port,
66	);
67	this.injectMiddleware(observableServer, instance, module);	4✔
68	this.hookServerToProperties(instance, observableServer.server);	4✔
69	this.subscribeEvents(instance, messageHandlers, observableServer);	4✔
70	}
71
72	public injectMiddleware({ server }, instance: NestGateway, module: string) {
73	this.middlewareInjector.inject(server, instance, module);	×
74	}
75
76	public subscribeEvents(
77	instance: NestGateway,
78	messageHandlers: MessageMappingProperties[],
79	observableServer: ObservableSocketServer,
80	) {
81	const { init, disconnect, connection, server } = observableServer;	10✔
82	const adapter = this.config.getIoAdapter();	10✔
83
84	this.subscribeInitEvent(instance, init);	10✔
85	this.subscribeConnectionEvent(instance, connection);	10✔
86	this.subscribeDisconnectEvent(instance, disconnect);	10✔
87
88	const handler = this.getConnectionHandler(	10✔
89	this,
90	instance,
91	messageHandlers,
92	disconnect,
93	connection,
94	);
95	adapter.bindClientConnect(server, handler);	10✔
96	}
97
98	public getConnectionHandler(
99	context: WebSocketsController,
100	instance: NestGateway,
101	messageHandlers: MessageMappingProperties[],
102	disconnect: Subject<any>,
103	connection: Subject<any>,
104	) {
105	const adapter = this.config.getIoAdapter();	10✔
106	return (client, ...rest) => {	10✔
107	// here different websocket implements may have different args
108	// `ws` will have two args applied to this callback
109	connection.next([client, ...rest]);	8✔
110
111	context.subscribeMessages(messageHandlers, client, instance);	8✔
112
113	const disconnectHook = adapter.bindClientDisconnect;	8✔
114	disconnectHook &&	8✔
115	disconnectHook.call(adapter, client, _ => disconnect.next(client));	×
116	};
117	}
118
119	public subscribeInitEvent(instance: NestGateway, event: Subject<any>) {
120	if (instance.afterInit) {	4✔
121	event.subscribe(instance.afterInit.bind(instance));	2✔
122	}
123	}
124
125	public subscribeConnectionEvent(instance: NestGateway, event: Subject<any>) {
126	if (instance.handleConnection) {	4✔
127	event.pipe(distinctUntilChanged()).subscribe((args: any[]) => {	2✔
128	instance.handleConnection.bind(instance)(...args);	×
129	});
130	}
131	}
132
133	public subscribeDisconnectEvent(instance: NestGateway, event: Subject<any>) {
134	if (instance.handleDisconnect) {	4✔
135	event	2✔
136	.pipe(distinctUntilChanged())
137	.subscribe(instance.handleDisconnect.bind(instance));
138	}
139	}
140
141	public subscribeMessages(
142	messageHandlers: MessageMappingProperties[],
143	client,
144	instance: NestGateway,
145	) {
146	const adapter = this.config.getIoAdapter();	2✔
147	const handlers = messageHandlers.map(({ callback, message }) => ({	4✔
148	message,
149	callback: callback.bind(instance, client),
150	}));
151	adapter.bindMessageHandlers(client, handlers, data =>	2✔
152	fromPromise(this.pickResult(data)).pipe(mergeAll()),	×
153	);
154	}
155
156	public async pickResult(
157	defferedResult: Promise<any>,
158	): Promise<Observable<any>> {
159	const result = await defferedResult;	6✔
160	if (result && isFunction(result.subscribe)) {	6✔
161	return result;	2✔
162	}
163	if (result instanceof Promise) {	4!
164	return fromPromise(result);	×
165	}
166	return of(result);	4✔
167	}
168
169	private hookServerToProperties(instance: NestGateway, server) {
170	for (const propertyKey of this.metadataExplorer.scanForServerHooks(	×
171	instance,
172	)) {
173	Reflect.set(instance, propertyKey, server);	×
174	}
175	}
176	}

nestjs / nest / 829

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous