@nestjs/websockets - npm Package Compare versions

Comparing version 5.0.0-beta.2 to 5.0.0-beta.3

adapters/io-adapter.d.ts

@@ -9,5 +9,7 @@ /// <reference types="node" />
     constructor(httpServer?: Server | null);
-    create(port: number): any;
-    createWithNamespace(port: number, namespace: string, server?: any): any;
-    createIOServer(port: number): any;
+    create(port: number, options?: any & {
+        namespace?: string;
+        server?: any;
+    }): any;
+    createIOServer(port: number, options?: any): any;
     bindClientConnect(server: any, callback: (...args) => void): void;
@@ -17,2 +19,3 @@ bindClientDisconnect(client: any, callback: (...args) => void): void;
     bindMiddleware(server: any, middleware: (socket, next) => void): void;
+    close(server: any): void;
 }

adapters/io-adapter.js

 "use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
+            t[p[i]] = s[p[i]];
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -7,2 +16,3 @@ const io = require("socket.io");
 const fromEvent_1 = require("rxjs/observable/fromEvent");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 class IoAdapter {
@@ -12,15 +22,18 @@ constructor(httpServer = null) {
     }
-    create(port) {
-        return this.createIOServer(port);
-    }
-    createWithNamespace(port, namespace, server) {
-        return server
+    create(port, options) {
+        if (!options) {
+            return this.createIOServer(port);
+        }
+        const { namespace, server } = options, opt = __rest(options, ["namespace", "server"]);
+        return server && shared_utils_1.isFunction(server.of)
             ? server.of(namespace)
-            : this.createIOServer(port).of(namespace);
+            : namespace
+                ? this.createIOServer(port, opt).of(namespace)
+                : this.createIOServer(port, opt);
     }
-    createIOServer(port) {
+    createIOServer(port, options) {
         if (this.httpServer && port === 0) {
-            return io.listen(this.httpServer);
+            return io(this.httpServer, options);
         }
-        return io(port);
+        return io(port, options);
     }
@@ -35,3 +48,3 @@ bindClientConnect(server, callback) {
         handlers.forEach(({ message, callback }) => fromEvent_1.fromEvent(client, message)
-            .pipe(operators_1.switchMap(data => process(callback(data))), operators_1.filter(result => !!result && result.event))
+            .pipe(operators_1.mergeMap(data => process(callback(data))), operators_1.filter(result => !!result && result.event))
             .subscribe(({ event, data }) => client.emit(event, data)));
@@ -42,3 +55,6 @@ }
     }
+    close(server) {
+        shared_utils_1.isFunction(server.close) && server.close();
+    }
 }
 exports.IoAdapter = IoAdapter;

constants.d.ts

@@ -1,9 +0,12 @@
-export declare const MESSAGE_MAPPING_METADATA = '__isMessageMapping';
-export declare const MESSAGE_METADATA = 'message';
-export declare const GATEWAY_SERVER_METADATA = '__isSocketServer';
-export declare const GATEWAY_METADATA = '__isGateway';
-export declare const NAMESPACE_METADATA = 'namespace';
-export declare const PORT_METADATA = 'port';
-export declare const GATEWAY_MIDDLEWARES = '__gatewayMiddlewares';
-export declare const CONNECTION_EVENT = 'connection';
-export declare const DISCONNECT_EVENT = 'disconnect';
+export declare const MESSAGE_MAPPING_METADATA = "__isMessageMapping";
+export declare const MESSAGE_METADATA = "message";
+export declare const GATEWAY_SERVER_METADATA = "__isSocketServer";
+export declare const GATEWAY_METADATA = "__isGateway";
+export declare const NAMESPACE_METADATA = "namespace";
+export declare const PORT_METADATA = "port";
+export declare const GATEWAY_MIDDLEWARES = "__gatewayMiddlewares";
+export declare const GATEWAY_OPTIONS = "__gatewayOptions";
+export declare const CONNECTION_EVENT = "connection";
+export declare const DISCONNECT_EVENT = "disconnect";
+export declare const CLOSE_EVENT = "close";
+export declare const ERROR_EVENT = "error";

constants.js

@@ -10,3 +10,6 @@ "use strict";
 exports.GATEWAY_MIDDLEWARES = '__gatewayMiddlewares';
+exports.GATEWAY_OPTIONS = '__gatewayOptions';
 exports.CONNECTION_EVENT = 'connection';
 exports.DISCONNECT_EVENT = 'disconnect';
+exports.CLOSE_EVENT = 'close';
+exports.ERROR_EVENT = 'error';

container.d.ts

 import { ObservableSocketServer } from './interfaces';
 export declare class SocketsContainer {
-  private readonly observableServers;
-  getAllServers(): Map<string, ObservableSocketServer>;
-  getServerByPort(port: number): ObservableSocketServer;
-  addServer(
-    namespace: string,
-    port: number,
-    server: ObservableSocketServer,
-  ): void;
-  clear(): void;
+    private readonly observableServers;
+    getAllServers(): Map<string, ObservableSocketServer>;
+    getServerByPort(port: number): ObservableSocketServer;
+    addServer(namespace: string, port: number, server: ObservableSocketServer): void;
+    clear(): void;
 }

context/exception-filters-context.d.ts

@@ -5,5 +5,7 @@ import 'reflect-metadata';
 import { WsExceptionsHandler } from '../exceptions/ws-exceptions-handler';
+import { NestContainer } from '@nestjs/core/injector/container';
 export declare class ExceptionFiltersContext extends BaseExceptionFilterContext {
-    create(instance: Controller, callback: (client, data) => any): WsExceptionsHandler;
+    constructor(container: NestContainer);
+    create(instance: Controller, callback: (client, data) => any, module: string): WsExceptionsHandler;
     getGlobalMetadata<T extends any[]>(): T;
 }

context/exception-filters-context.js

@@ -9,3 +9,7 @@ "use strict";
 class ExceptionFiltersContext extends base_exception_filter_context_1.BaseExceptionFilterContext {
-    create(instance, callback) {
+    constructor(container) {
+        super(container);
+    }
+    create(instance, callback, module) {
+        this.moduleContext = module;
         const exceptionHandler = new ws_exceptions_handler_1.WsExceptionsHandler();
@@ -12,0 +16,0 @@ const filters = this.createContext(instance, callback, constants_1.EXCEPTION_FILTERS_METADATA);

context/ws-context-creator.d.ts

@@ -20,5 +20,5 @@ import { WsProxy } from './ws-proxy';
     constructor(wsProxy: WsProxy, exceptionFiltersContext: ExceptionFiltersContext, pipesCreator: PipesContextCreator, pipesConsumer: PipesConsumer, guardsContextCreator: GuardsContextCreator, guardsConsumer: GuardsConsumer, interceptorsContextCreator: InterceptorsContextCreator, interceptorsConsumer: InterceptorsConsumer);
-    create(instance: Controller, callback: (client, data) => void, module: any): (client, data) => Promise<void>;
+    create(instance: Controller, callback: (...args) => void, module: any): (...args) => Promise<void>;
     reflectCallbackParamtypes(instance: Controller, callback: (...args) => any): any[];
     getDataMetatype(instance: any, callback: any): any;
 }

context/ws-context-creator.js

@@ -26,9 +26,9 @@ "use strict";
     create(instance, callback, module) {
-        const exceptionHandler = this.exceptionFiltersContext.create(instance, callback);
-        const pipes = this.pipesCreator.create(instance, callback);
+        const exceptionHandler = this.exceptionFiltersContext.create(instance, callback, module);
+        const pipes = this.pipesCreator.create(instance, callback, module);
         const guards = this.guardsContextCreator.create(instance, callback, module);
         const metatype = this.getDataMetatype(instance, callback);
         const interceptors = this.interceptorsContextCreator.create(instance, callback, module);
-        return this.wsProxy.create((client, data) => __awaiter(this, void 0, void 0, function* () {
-            const canActivate = yield this.guardsConsumer.tryActivate(guards, data, instance, callback);
+        return this.wsProxy.create((...args) => __awaiter(this, void 0, void 0, function* () {
+            const canActivate = yield this.guardsConsumer.tryActivate(guards, args, instance, callback);
             if (!canActivate) {
@@ -38,6 +38,7 @@ throw new ws_exception_1.WsException(constants_2.FORBIDDEN_MESSAGE);
             const handler = () => __awaiter(this, void 0, void 0, function* () {
+                const [client, data, ...params] = args;
                 const result = yield this.pipesConsumer.applyPipes(data, { metatype }, pipes);
-                return callback.call(instance, client, result);
+                return callback.call(instance, client, result, ...params);
             });
-            return yield this.interceptorsConsumer.intercept(interceptors, data, instance, callback, handler);
+            return yield this.interceptorsConsumer.intercept(interceptors, args, instance, callback, handler);
         }), exceptionHandler);
@@ -44,0 +45,0 @@ }

context/ws-proxy.d.ts

 import { WsExceptionsHandler } from './../exceptions/ws-exceptions-handler';
 export declare class WsProxy {
-    create(targetCallback: (client, data) => Promise<void>, exceptionsHandler: WsExceptionsHandler): (client, data) => Promise<void>;
+    create(targetCallback: (...args) => Promise<void>, exceptionsHandler: WsExceptionsHandler): (...args) => Promise<void>;
 }

context/ws-proxy.js

@@ -11,10 +11,12 @@ "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const execution_context_host_1 = require("@nestjs/core/helpers/execution-context.host");
 class WsProxy {
     create(targetCallback, exceptionsHandler) {
-        return (client, data) => __awaiter(this, void 0, void 0, function* () {
+        return (...args) => __awaiter(this, void 0, void 0, function* () {
+            const host = new execution_context_host_1.ExecutionContextHost(args);
             try {
-                return yield targetCallback(client, data);
+                return yield targetCallback(...args);
             }
             catch (e) {
-                exceptionsHandler.handle(e, client);
+                exceptionsHandler.handle(e, host);
             }
@@ -21,0 +23,0 @@ });

exceptions/ws-exceptions-handler.d.ts

 import { ExceptionFilterMetadata } from '@nestjs/common/interfaces/exceptions/exception-filter-metadata.interface';
 import { WsException } from '../exceptions/ws-exception';
+import { ArgumentsHost } from '@nestjs/common';
 export declare class WsExceptionsHandler {
     private filters;
-    handle(exception: Error | WsException | any, client: any): any;
+    handle(exception: Error | WsException | any, args: ArgumentsHost): any;
     setCustomFilters(filters: ExceptionFilterMetadata[]): void;
-    invokeCustomFilters(exception: any, client: any): boolean;
+    invokeCustomFilters(exception: any, args: ArgumentsHost): boolean;
 }

exceptions/ws-exceptions-handler.js

@@ -11,9 +11,10 @@ "use strict";
     }
-    handle(exception, client) {
-        if (this.invokeCustomFilters(exception, client) || !client.emit)
+    handle(exception, args) {
+        const client = args.switchToWs().getClient();
+        if (this.invokeCustomFilters(exception, args) || !client.emit)
             return;
         const status = 'error';
         if (!(exception instanceof ws_exception_1.WsException)) {
-            const message = constants_1.messages.UNKNOWN_EXCEPTION_MESSAGE;
-            return client.emit('exception', { status, message });
+            const errorMessage = constants_1.messages.UNKNOWN_EXCEPTION_MESSAGE;
+            return client.emit('exception', { status, message: errorMessage });
         }
@@ -35,3 +36,3 @@ const result = exception.getError();
     }
-    invokeCustomFilters(exception, client) {
+    invokeCustomFilters(exception, args) {
         if (shared_utils_1.isEmpty(this.filters))
@@ -44,3 +45,3 @@ return false;
         });
-        filter && filter.func(exception, client);
+        filter && filter.func(exception, args);
         return !!filter;
@@ -47,0 +48,0 @@ }

gateway-metadata-explorer.d.ts

@@ -5,14 +5,11 @@ import { NestGateway } from './interfaces/nest-gateway.interface';
 export declare class GatewayMetadataExplorer {
-  private readonly metadataScanner;
-  constructor(metadataScanner: MetadataScanner);
-  explore(instance: NestGateway): MessageMappingProperties[];
-  exploreMethodMetadata(
-    instancePrototype: any,
-    methodName: string,
-  ): MessageMappingProperties;
-  scanForServerHooks(instance: NestGateway): IterableIterator<string>;
+    private readonly metadataScanner;
+    constructor(metadataScanner: MetadataScanner);
+    explore(instance: NestGateway): MessageMappingProperties[];
+    exploreMethodMetadata(instancePrototype: any, methodName: string): MessageMappingProperties;
+    scanForServerHooks(instance: NestGateway): IterableIterator<string>;
 }
 export interface MessageMappingProperties {
-  message: string;
-  callback: (...args) => Observable<any> | Promise<any> | void;
+    message: any;
+    callback: (...args) => Observable<any> | Promise<any> | any;
 }

index.d.ts

@@ -0,1 +1,2 @@
+export * from './adapters/ws-adapter';
 export * from './adapters/io-adapter';
@@ -2,0 +3,0 @@ export * from './interfaces';

index.js

@@ -12,4 +12,5 @@ "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./adapters/ws-adapter"));
 __export(require("./adapters/io-adapter"));
 __export(require("./exceptions/ws-exception"));
 __export(require("./utils"));

interfaces/gateway-metadata.interface.d.ts

@@ -1,7 +0,11 @@
-import { Type } from '@nestjs/common/interfaces/type.interface';
-import { GatewayMiddleware } from './gateway-middleware.interface';
 export interface GatewayMetadata {
-    port?: number;
     namespace?: string;
-    middlewares?: Type<GatewayMiddleware>[];
+    path?: string;
+    serveClient?: boolean;
+    adapter?: any;
+    origins?: string;
+    parser?: any;
+    pingTimeout?: number;
+    pingInterval?: number;
+    transports?: string[];
 }

interfaces/on-gateway-connection.interface.d.ts

@@ -1,3 +0,3 @@
-export interface OnGatewayConnection {
-    handleConnection(client: any): any;
+export interface OnGatewayConnection<T = any> {
+    handleConnection(client: T): any;
 }

interfaces/on-gateway-disconnect.interface.d.ts

@@ -1,3 +0,3 @@
-export interface OnGatewayDisconnect {
-    handleDisconnect(client: any): any;
+export interface OnGatewayDisconnect<T = any> {
+    handleDisconnect(client: T): any;
 }

interfaces/on-gateway-init.interface.d.ts

@@ -1,3 +0,3 @@
-export interface OnGatewayInit {
-    afterInit(server: any): any;
+export interface OnGatewayInit<T = any> {
+    afterInit(server: T): any;
 }

interfaces/ws-response.interface.d.ts

@@ -1,4 +0,4 @@
-export interface WsResponse<T> {
+export interface WsResponse<T = any> {
     event: string;
     data: T;
 }

middlewares-injector.d.ts

 import 'reflect-metadata';
-import {
-  NestContainer,
-  InstanceWrapper,
-} from '@nestjs/core/injector/container';
+import { NestContainer, InstanceWrapper } from '@nestjs/core/injector/container';
 import { NestGateway } from './index';
@@ -11,17 +8,10 @@ import { Injectable } from '@nestjs/common/interfaces/injectable.interface';
 export declare class MiddlewaresInjector {
-  private readonly container;
-  private readonly config;
-  constructor(container: NestContainer, config: ApplicationConfig);
-  inject(server: any, instance: NestGateway, module: string): void;
-  reflectMiddlewaresTokens(instance: NestGateway): any[];
-  applyMiddlewares(
-    server: any,
-    components: Map<string, InstanceWrapper<Injectable>>,
-    tokens: any[],
-  ): void;
-  bindMiddleware(
-    token: string,
-    components: Map<string, InstanceWrapper<Injectable>>,
-  ): any;
-  isGatewayMiddleware(middleware: object): middleware is GatewayMiddleware;
+    private readonly container;
+    private readonly config;
+    constructor(container: NestContainer, config: ApplicationConfig);
+    inject(server: any, instance: NestGateway, module: string): void;
+    reflectMiddlewaresTokens(instance: NestGateway): any[];
+    applyMiddlewares(server: any, components: Map<string, InstanceWrapper<Injectable>>, tokens: any[]): void;
+    bindMiddleware(token: string, components: Map<string, InstanceWrapper<Injectable>>): any;
+    isGatewayMiddleware(middleware: object): middleware is GatewayMiddleware;
 }

observable-socket.d.ts

 import { ObservableSocketServer } from './interfaces/observable-socket-server.interface';
 export declare class ObservableSocket {
-  static create(server: any): ObservableSocketServer;
+    static create(server: any): ObservableSocketServer;
 }

package.json

 {
   "name": "@nestjs/websockets",
-  "version": "5.0.0-beta.2",
-  "description":
-    "Nest - modern, fast, powerful node.js web framework (@websockets)",
+  "version": "5.0.0-beta.3",
+  "description": "Nest - modern, fast, powerful node.js web framework (@websockets)",
   "author": "Kamil Mysliwiec",
@@ -7,0 +6,0 @@ "license": "MIT",

socket-module.d.ts

@@ -5,15 +5,10 @@ import 'reflect-metadata';
 export declare class SocketModule {
-  private socketsContainer;
-  private webSocketsController;
-  register(container: any, config: any): void;
-  hookGatewaysIntoServers(
-    components: Map<string, InstanceWrapper<Injectable>>,
-    moduleName: string,
-  ): void;
-  hookGatewayIntoServer(
-    wrapper: InstanceWrapper<Injectable>,
-    moduleName: string,
-  ): void;
-  close(): void;
-  private getContextCreator(container);
+    private readonly socketsContainer;
+    private applicationConfig;
+    private webSocketsController;
+    register(container: any, config: any): void;
+    hookGatewaysIntoServers(components: Map<string, InstanceWrapper<Injectable>>, moduleName: string): void;
+    hookGatewayIntoServer(wrapper: InstanceWrapper<Injectable>, moduleName: string): void;
+    close(): Promise<any>;
+    private getContextCreator(container);
 }

socket-module.js

 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
+const iterare_1 = require("iterare");
 const container_1 = require("./container");
@@ -22,2 +31,3 @@ const web_sockets_controller_1 = require("./web-sockets-controller");
     register(container, config) {
+        this.applicationConfig = config;
         this.webSocketsController = new web_sockets_controller_1.WebSocketsController(new socket_server_provider_1.SocketServerProvider(this.socketsContainer, config), container, config, this.getContextCreator(container));
@@ -42,10 +52,16 @@ const modules = container.getModules();
     close() {
-        const servers = this.socketsContainer.getAllServers();
-        servers.forEach(({ server }) => server.close());
-        this.socketsContainer.clear();
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.applicationConfig) {
+                return void 0;
+            }
+            const adapter = this.applicationConfig.getIoAdapter();
+            const servers = this.socketsContainer.getAllServers();
+            yield Promise.all(iterare_1.default(servers.values()).map(({ server }) => __awaiter(this, void 0, void 0, function* () { return server && (yield adapter.close(server)); })));
+            this.socketsContainer.clear();
+        });
     }
     getContextCreator(container) {
-        return new ws_context_creator_1.WsContextCreator(new ws_proxy_1.WsProxy(), new exception_filters_context_1.ExceptionFiltersContext(), new pipes_context_creator_1.PipesContextCreator(), new pipes_consumer_1.PipesConsumer(), new guards_context_creator_1.GuardsContextCreator(container), new guards_consumer_1.GuardsConsumer(), new interceptors_context_creator_1.InterceptorsContextCreator(container), new interceptors_consumer_1.InterceptorsConsumer());
+        return new ws_context_creator_1.WsContextCreator(new ws_proxy_1.WsProxy(), new exception_filters_context_1.ExceptionFiltersContext(container), new pipes_context_creator_1.PipesContextCreator(container), new pipes_consumer_1.PipesConsumer(), new guards_context_creator_1.GuardsContextCreator(container), new guards_consumer_1.GuardsConsumer(), new interceptors_context_creator_1.InterceptorsContextCreator(container), new interceptors_consumer_1.InterceptorsConsumer());
     }
 }
 exports.SocketModule = SocketModule;

socket-server-provider.d.ts

@@ -5,13 +5,10 @@ import { SocketsContainer } from './container';
 export declare class SocketServerProvider {
-  private readonly socketsContainer;
-  private readonly applicationConfig;
-  constructor(
-    socketsContainer: SocketsContainer,
-    applicationConfig: ApplicationConfig,
-  );
-  scanForSocketServer(namespace: string, port: number): ObservableSocketServer;
-  private createSocketServer(namespace, port);
-  private createWithNamespace(namespace, port, observableSocket);
-  private getServerOfNamespace(namespace, port, server);
-  private validateNamespace(namespace);
+    private readonly socketsContainer;
+    private readonly applicationConfig;
+    constructor(socketsContainer: SocketsContainer, applicationConfig: ApplicationConfig);
+    scanForSocketServer(options: any, port: number): ObservableSocketServer;
+    private createSocketServer(options, port);
+    private createWithNamespace(options, port, observableSocket);
+    private getServerOfNamespace(options, port, server);
+    private validateNamespace(namespace);
 }

socket-server-provider.js

 "use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
+            t[p[i]] = s[p[i]];
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -10,21 +19,22 @@ const observable_socket_1 = require("./observable-socket");
     }
-    scanForSocketServer(namespace, port) {
+    scanForSocketServer(options, port) {
         const observableServer = this.socketsContainer.getServerByPort(port);
         return observableServer
-            ? this.createWithNamespace(namespace, port, observableServer)
-            : this.createSocketServer(namespace, port);
+            ? this.createWithNamespace(options, port, observableServer)
+            : this.createSocketServer(options, port);
     }
-    createSocketServer(namespace, port) {
+    createSocketServer(options, port) {
+        const { namespace, server } = options, opt = __rest(options, ["namespace", "server"]);
         const adapter = this.applicationConfig.getIoAdapter();
-        const server = adapter.create(port);
-        const observableSocket = observable_socket_1.ObservableSocket.create(server);
+        const ioServer = adapter.create(port, opt);
+        const observableSocket = observable_socket_1.ObservableSocket.create(ioServer);
         this.socketsContainer.addServer(null, port, observableSocket);
-        return this.createWithNamespace(namespace, port, observableSocket);
+        return this.createWithNamespace(options, port, observableSocket);
     }
-    createWithNamespace(namespace, port, observableSocket) {
-        const adapter = this.applicationConfig.getIoAdapter();
-        if (!namespace || !adapter.createWithNamespace) {
+    createWithNamespace(options, port, observableSocket) {
+        const { namespace } = options;
+        if (!namespace) {
             return observableSocket;
         }
-        const namespaceServer = this.getServerOfNamespace(namespace, port, observableSocket.server);
+        const namespaceServer = this.getServerOfNamespace(options, port, observableSocket.server);
         const observableNamespaceSocket = observable_socket_1.ObservableSocket.create(namespaceServer);
@@ -34,5 +44,5 @@ this.socketsContainer.addServer(namespace, port, observableNamespaceSocket);
     }
-    getServerOfNamespace(namespace, port, server) {
+    getServerOfNamespace(options, port, server) {
         const adapter = this.applicationConfig.getIoAdapter();
-        return adapter.createWithNamespace(port, this.validateNamespace(namespace), server);
+        return adapter.create(port, Object.assign({}, options, { namespace: this.validateNamespace(options.namespace || ''), server }));
     }
@@ -39,0 +49,0 @@ validateNamespace(namespace) {

utils/gateway-server.decorator.d.ts

 import 'reflect-metadata';
 /**
- * Attaches the native Web Socket Server to the given property.
+ * Attaches native Web Socket Server to a given property.
  */
 export declare const WebSocketServer: () => PropertyDecorator;

utils/gateway-server.decorator.js

@@ -6,3 +6,3 @@ "use strict";
 /**
- * Attaches the native Web Socket Server to the given property.
+ * Attaches native Web Socket Server to a given property.
  */
@@ -9,0 +9,0 @@ exports.WebSocketServer = () => {

utils/socket-gateway.decorator.d.ts

 import 'reflect-metadata';
 import { GatewayMetadata } from '../interfaces';
 /**
- * Defines the Gateway. The gateway can inject dependencies through constructor.
- * Those dependencies should belongs to the same module. Gateway is listening on the specified port.
+ * Defines the Gateway. The gateway is able to inject dependencies through constructor.
+ * Those dependencies should belong to the same module. Gateway is listening on the specified port.
  */
-export declare const WebSocketGateway: (metadataOrPort?: number | GatewayMetadata) => ClassDecorator;
+export declare function WebSocketGateway(port?: number): any;
+export declare function WebSocketGateway(options?: GatewayMetadata | any): any;
+export declare function WebSocketGateway(port?: number, options?: GatewayMetadata | any): any;

utils/socket-gateway.decorator.js

@@ -5,17 +5,16 @@ "use strict";
 const constants_1 = require("../constants");
-/**
- * Defines the Gateway. The gateway can inject dependencies through constructor.
- * Those dependencies should belongs to the same module. Gateway is listening on the specified port.
- */
-exports.WebSocketGateway = (metadataOrPort) => {
-    if (Number.isInteger(metadataOrPort)) {
-        metadataOrPort = { port: metadataOrPort };
-    }
-    const metadata = metadataOrPort || {};
+function WebSocketGateway(portOrOptions, options) {
+    const isPortInt = Number.isInteger(portOrOptions);
+    // tslint:disable-next-line:prefer-const
+    let [port, opt] = isPortInt
+        ? [portOrOptions, options]
+        : [0, portOrOptions];
+    opt = opt || {};
     return (target) => {
         Reflect.defineMetadata(constants_1.GATEWAY_METADATA, true, target);
-        Reflect.defineMetadata(constants_1.NAMESPACE_METADATA, metadata.namespace, target);
-        Reflect.defineMetadata(constants_1.PORT_METADATA, metadata.port, target);
-        Reflect.defineMetadata(constants_1.GATEWAY_MIDDLEWARES, metadata.middlewares, target);
+        Reflect.defineMetadata(constants_1.PORT_METADATA, port, target);
+        Reflect.defineMetadata(constants_1.GATEWAY_OPTIONS, opt, target);
+        Reflect.defineMetadata(constants_1.GATEWAY_MIDDLEWARES, opt.middlewares, target);
     };
-};
+}
+exports.WebSocketGateway = WebSocketGateway;

utils/subscribe-message.decorator.d.ts

 import 'reflect-metadata';
 /**
- * Subscribes to the messages, which fulfils chosen pattern.
+ * Subscribes to messages that fulfils chosen pattern.
  */
-export declare const SubscribeMessage: (message?: string | {
-    value: string;
-}) => MethodDecorator;
+export declare const SubscribeMessage: <T = string>(message: T) => MethodDecorator;

utils/subscribe-message.decorator.js

@@ -5,14 +5,11 @@ "use strict";
 const constants_1 = require("../constants");
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 /**
- * Subscribes to the messages, which fulfils chosen pattern.
+ * Subscribes to messages that fulfils chosen pattern.
  */
 exports.SubscribeMessage = (message) => {
-    let metadata = shared_utils_1.isObject(message) ? message.value : message;
-    metadata = shared_utils_1.isUndefined(metadata) ? '' : metadata;
     return (target, key, descriptor) => {
         Reflect.defineMetadata(constants_1.MESSAGE_MAPPING_METADATA, true, descriptor.value);
-        Reflect.defineMetadata(constants_1.MESSAGE_METADATA, metadata, descriptor.value);
+        Reflect.defineMetadata(constants_1.MESSAGE_METADATA, message, descriptor.value);
         return descriptor;
     };
 };

web-sockets-controller.d.ts

@@ -13,56 +13,22 @@ import 'reflect-metadata';
 export declare class WebSocketsController {
-  private readonly socketServerProvider;
-  private readonly container;
-  private readonly config;
-  private readonly contextCreator;
-  private readonly metadataExplorer;
-  private readonly middlewaresInjector;
-  constructor(
-    socketServerProvider: SocketServerProvider,
-    container: NestContainer,
-    config: ApplicationConfig,
-    contextCreator: WsContextCreator,
-  );
-  hookGatewayIntoServer(
-    instance: NestGateway,
-    metatype: Type<any>,
-    module: string,
-  ): void;
-  subscribeObservableServer(
-    instance: NestGateway,
-    namespace: string,
-    port: number,
-    module: string,
-  ): void;
-  injectMiddlewares(
-    {
-      server,
-    }: {
-      server: any;
-    },
-    instance: NestGateway,
-    module: string,
-  ): void;
-  subscribeEvents(
-    instance: NestGateway,
-    messageHandlers: MessageMappingProperties[],
-    observableServer: ObservableSocketServer,
-  ): void;
-  getConnectionHandler(
-    context: WebSocketsController,
-    instance: NestGateway,
-    messageHandlers: MessageMappingProperties[],
-    disconnect: Subject<any>,
-    connection: Subject<any>,
-  ): (client: any) => void;
-  subscribeInitEvent(instance: NestGateway, event: Subject<any>): void;
-  subscribeConnectionEvent(instance: NestGateway, event: Subject<any>): void;
-  subscribeDisconnectEvent(instance: NestGateway, event: Subject<any>): void;
-  subscribeMessages(
-    messageHandlers: MessageMappingProperties[],
-    client: any,
-    instance: NestGateway,
-  ): void;
-  pickResult(defferedResult: Promise<any>): Promise<Observable<any>>;
-  private hookServerToProperties(instance, server);
+    private readonly socketServerProvider;
+    private readonly container;
+    private readonly config;
+    private readonly contextCreator;
+    private readonly metadataExplorer;
+    private readonly middlewaresInjector;
+    constructor(socketServerProvider: SocketServerProvider, container: NestContainer, config: ApplicationConfig, contextCreator: WsContextCreator);
+    hookGatewayIntoServer(instance: NestGateway, metatype: Type<any>, module: string): void;
+    subscribeObservableServer(instance: NestGateway, options: any, port: number, module: string): void;
+    injectMiddlewares({server}: {
+        server: any;
+    }, instance: NestGateway, module: string): void;
+    subscribeEvents(instance: NestGateway, messageHandlers: MessageMappingProperties[], observableServer: ObservableSocketServer): void;
+    getConnectionHandler(context: WebSocketsController, instance: NestGateway, messageHandlers: MessageMappingProperties[], disconnect: Subject<any>, connection: Subject<any>): (client: any) => void;
+    subscribeInitEvent(instance: NestGateway, event: Subject<any>): void;
+    subscribeConnectionEvent(instance: NestGateway, event: Subject<any>): void;
+    subscribeDisconnectEvent(instance: NestGateway, event: Subject<any>): void;
+    subscribeMessages(messageHandlers: MessageMappingProperties[], client: any, instance: NestGateway): void;
+    pickResult(defferedResult: Promise<any>): Promise<Observable<any>>;
+    private hookServerToProperties(instance, server);
 }

web-sockets-controller.js

@@ -31,3 +31,3 @@ "use strict";
     hookGatewayIntoServer(instance, metatype, module) {
-        const namespace = Reflect.getMetadata(constants_1.NAMESPACE_METADATA, metatype) || '';
+        const options = Reflect.getMetadata(constants_1.GATEWAY_OPTIONS, metatype) || {};
         const port = Reflect.getMetadata(constants_1.PORT_METADATA, metatype) || 0;
@@ -37,5 +37,5 @@ if (!Number.isInteger(port)) {
         }
-        this.subscribeObservableServer(instance, namespace, port, module);
+        this.subscribeObservableServer(instance, options, port, module);
     }
-    subscribeObservableServer(instance, namespace, port, module) {
+    subscribeObservableServer(instance, options, port, module) {
         const plainMessageHandlers = this.metadataExplorer.explore(instance);
@@ -46,3 +46,3 @@ const messageHandlers = plainMessageHandlers.map(({ callback, message }) => ({
         }));
-        const observableServer = this.socketServerProvider.scanForSocketServer(namespace, port);
+        const observableServer = this.socketServerProvider.scanForSocketServer(options, port);
         this.injectMiddlewares(observableServer, instance, module);
@@ -96,3 +96,3 @@ this.hookServerToProperties(instance, observableServer.server);
         }));
-        adapter.bindMessageHandlers(client, handlers, data => fromPromise_1.fromPromise(this.pickResult(data)).pipe(operators_1.switchMap(stream => stream)));
+        adapter.bindMessageHandlers(client, handlers, data => fromPromise_1.fromPromise(this.pickResult(data)).pipe(operators_1.mergeMap(stream => stream)));
     }
@@ -99,0 +99,0 @@ pickResult(defferedResult) {

No alert changes

Improved metrics

Total package byte prevSize

61878

increased by12.89%

Number of package files

67

increased by6.35%

Lines of code

1050

increased by10.53%

No dependency changes