@nestjs/websockets 11.1.16 → 12.0.0-alpha.1

package/socket-module.js

@@ -1,48 +1,42 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SocketModule = void 0;
-const guards_consumer_1 = require("@nestjs/core/guards/guards-consumer");
-const guards_context_creator_1 = require("@nestjs/core/guards/guards-context-creator");
-const load_adapter_1 = require("@nestjs/core/helpers/load-adapter");
-const interceptors_consumer_1 = require("@nestjs/core/interceptors/interceptors-consumer");
-const interceptors_context_creator_1 = require("@nestjs/core/interceptors/interceptors-context-creator");
-const pipes_consumer_1 = require("@nestjs/core/pipes/pipes-consumer");
-const pipes_context_creator_1 = require("@nestjs/core/pipes/pipes-context-creator");
-const iterare_1 = require("iterare");
-const constants_1 = require("./constants");
-const exception_filters_context_1 = require("./context/exception-filters-context");
-const ws_context_creator_1 = require("./context/ws-context-creator");
-const ws_proxy_1 = require("./context/ws-proxy");
-const socket_server_provider_1 = require("./socket-server-provider");
-const sockets_container_1 = require("./sockets-container");
-const web_sockets_controller_1 = require("./web-sockets-controller");
-class SocketModule {
-    constructor() {
-        this.socketsContainer = new sockets_container_1.SocketsContainer();
-    }
+import { iterate } from 'iterare';
+import { GATEWAY_METADATA } from './constants.js';
+import { ExceptionFiltersContext } from './context/exception-filters-context.js';
+import { WsContextCreator } from './context/ws-context-creator.js';
+import { WsProxy } from './context/ws-proxy.js';
+import { SocketServerProvider } from './socket-server-provider.js';
+import { SocketsContainer } from './sockets-container.js';
+import { WebSocketsController } from './web-sockets-controller.js';
+import { GuardsConsumer, GuardsContextCreator, loadAdapter, InterceptorsConsumer, InterceptorsContextCreator, PipesConsumer, PipesContextCreator, } from '@nestjs/core/internal';
+export class SocketModule {
+    socketsContainer = new SocketsContainer();
+    applicationConfig;
+    webSocketsController;
+    isAdapterInitialized;
+    httpServer;
+    appOptions;
     register(container, applicationConfig, graphInspector, appOptions, httpServer) {
         this.applicationConfig = applicationConfig;
         this.appOptions = appOptions;
         this.httpServer = httpServer;
         const contextCreator = this.getContextCreator(container);
-        const serverProvider = new socket_server_provider_1.SocketServerProvider(this.socketsContainer, applicationConfig);
-        this.webSocketsController = new web_sockets_controller_1.WebSocketsController(serverProvider, applicationConfig, contextCreator, graphInspector, this.appOptions);
+        const serverProvider = new SocketServerProvider(this.socketsContainer, applicationConfig);
+        this.webSocketsController = new WebSocketsController(serverProvider, applicationConfig, contextCreator, graphInspector, this.appOptions);
         const modules = container.getModules();
         modules.forEach(({ providers }, moduleName) => this.connectAllGateways(providers, moduleName));
     }
     connectAllGateways(providers, moduleName) {
-        (0, iterare_1.iterate)(providers.values())
+        iterate(providers.values())
             .filter(wrapper => wrapper && !wrapper.isNotMetatype)
             .forEach(wrapper => this.connectGatewayToServer(wrapper, moduleName));
     }
-    connectGatewayToServer(wrapper, moduleName) {
+    async connectGatewayToServer(wrapper, moduleName) {
         const { instance, metatype } = wrapper;
         const metadataKeys = Reflect.getMetadataKeys(metatype);
-        if (!metadataKeys.includes(constants_1.GATEWAY_METADATA)) {
+        if (!metadataKeys.includes(GATEWAY_METADATA)) {
             return;
         }
         if (!this.isAdapterInitialized) {
-            this.initializeAdapter();
+            await this.initializeAdapter();
         }
         this.webSocketsController.connectGatewayToServer(instance, metatype, moduleName, wrapper.id);
     }
@@ -55,13 +49,13 @@ class SocketModule {
             return;
         }
         const servers = this.socketsContainer.getAll();
-        await Promise.all((0, iterare_1.iterate)(servers.values())
+        await Promise.all(iterate(servers.values())
             .filter(({ server }) => server)
             .map(async ({ server }) => adapter.close(server)));
         await adapter?.dispose();
         this.socketsContainer.clear();
     }
-    initializeAdapter() {
+    async initializeAdapter() {
         const forceCloseConnections = this.appOptions
             .forceCloseConnections;
         const adapter = this.applicationConfig.getIoAdapter();
@@ -71,14 +65,13 @@ class SocketModule {
             this.isAdapterInitialized = true;
             return;
         }
-        const { IoAdapter } = (0, load_adapter_1.loadAdapter)('@nestjs/platform-socket.io', 'WebSockets', () => require('@nestjs/platform-socket.io'));
+        const { IoAdapter } = await loadAdapter('@nestjs/platform-socket.io', 'WebSockets', () => import('@nestjs/platform-socket.io'));
         const ioAdapter = new IoAdapter(this.httpServer);
         ioAdapter.forceCloseConnections = forceCloseConnections;
         this.applicationConfig.setIoAdapter(ioAdapter);
         this.isAdapterInitialized = true;
     }
     getContextCreator(container) {
-        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());
+        return new WsContextCreator(new WsProxy(), new ExceptionFiltersContext(container), new PipesContextCreator(container), new PipesConsumer(), new GuardsContextCreator(container), new GuardsConsumer(), new InterceptorsContextCreator(container), new InterceptorsConsumer());
     }
 }
-exports.SocketModule = SocketModule;

package/socket-server-provider.d.ts

@@ -1,7 +1,7 @@
-import { ApplicationConfig } from '@nestjs/core/application-config';
-import { GatewayMetadata } from './interfaces/gateway-metadata.interface';
-import { ServerAndEventStreamsHost } from './interfaces/server-and-event-streams-host.interface';
-import { SocketsContainer } from './sockets-container';
+import { GatewayMetadata } from './interfaces/gateway-metadata.interface.js';
+import { ServerAndEventStreamsHost } from './interfaces/server-and-event-streams-host.interface.js';
+import { SocketsContainer } from './sockets-container.js';
+import type { ApplicationConfig } from '@nestjs/core';
 export declare class SocketServerProvider {
     private readonly socketsContainer;
     private readonly applicationConfig;

package/socket-server-provider.js

@@ -1,9 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SocketServerProvider = void 0;
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const server_and_event_streams_factory_1 = require("./factories/server-and-event-streams-factory");
-class SocketServerProvider {
+import { ServerAndEventStreamsFactory } from './factories/server-and-event-streams-factory.js';
+import { addLeadingSlash, isString } from '@nestjs/common/internal';
+export class SocketServerProvider {
+    socketsContainer;
+    applicationConfig;
     constructor(socketsContainer, applicationConfig) {
         this.socketsContainer = socketsContainer;
         this.applicationConfig = applicationConfig;
@@ -24,7 +23,7 @@ class SocketServerProvider {
         const adapter = this.applicationConfig.getIoAdapter();
         const { namespace, server, ...partialOptions } = options;
         const ioServer = adapter.create(port, partialOptions);
-        const serverAndEventStreamsHost = server_and_event_streams_factory_1.ServerAndEventStreamsFactory.create(ioServer);
+        const serverAndEventStreamsHost = ServerAndEventStreamsFactory.create(ioServer);
         this.socketsContainer.addOne({ port, path: options.path }, serverAndEventStreamsHost);
         if (!namespace) {
             return serverAndEventStreamsHost;
@@ -33,7 +32,7 @@ class SocketServerProvider {
     }
     decorateWithNamespace(options, port, targetServer) {
         const namespaceServer = this.getServerOfNamespace(options, port, targetServer);
-        const serverAndEventStreamsHost = server_and_event_streams_factory_1.ServerAndEventStreamsFactory.create(namespaceServer);
+        const serverAndEventStreamsHost = ServerAndEventStreamsFactory.create(namespaceServer);
         this.socketsContainer.addOne({ port, path: options.path, namespace: options.namespace }, serverAndEventStreamsHost);
         return serverAndEventStreamsHost;
     }
@@ -46,10 +45,9 @@ class SocketServerProvider {
         });
     }
     validateNamespace(namespace) {
-        if (!(0, shared_utils_1.isString)(namespace)) {
+        if (!isString(namespace)) {
             return namespace;
         }
-        return (0, shared_utils_1.addLeadingSlash)(namespace);
+        return addLeadingSlash(namespace);
     }
 }
-exports.SocketServerProvider = SocketServerProvider;

package/sockets-container.d.ts

@@ -1,4 +1,4 @@
-import { GatewayMetadata, ServerAndEventStreamsHost } from './interfaces';
+import { GatewayMetadata, ServerAndEventStreamsHost } from './interfaces/index.js';
 export declare class SocketsContainer {
     private readonly serverAndEventStreamsHosts;
     getAll(): Map<string | RegExp, ServerAndEventStreamsHost>;

package/sockets-container.js

@@ -1,11 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SocketsContainer = void 0;
-const hash = require("object-hash");
-class SocketsContainer {
-    constructor() {
-        this.serverAndEventStreamsHosts = new Map();
-    }
+import hash from 'object-hash';
+export class SocketsContainer {
+    serverAndEventStreamsHosts = new Map();
     getAll() {
         return this.serverAndEventStreamsHosts;
     }
@@ -24,4 +19,3 @@ class SocketsContainer {
         return hash(options, { ignoreUnknown: true });
     }
 }
-exports.SocketsContainer = SocketsContainer;

package/tsconfig.build.json

@@ -2,13 +2,7 @@
   "extends": "../tsconfig.build.json",
   "compilerOptions": {
     "outDir": ".",
-    "rootDir": ".",
-    "paths": {
-      "@nestjs/common": ["../common"],
-      "@nestjs/common/*": ["../common/*"],
-      "@nestjs/core": ["../core"],
-      "@nestjs/core/*": ["../core/*"]
-    }
+    "rootDir": "."
   },
   "exclude": ["node_modules", "dist", "test/**/*", "*.spec.ts"],
   "references": [

package/utils/compare-element.util.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compareElementAt = compareElementAt;
-function compareElementAt(prev, curr, index) {
+export function compareElementAt(prev, curr, index) {
     return prev && curr && prev[index] === curr[index];
 }

package/utils/index.d.ts

@@ -1 +1 @@
-export * from './param.utils';
+export * from './param.utils.js';

package/utils/index.js

@@ -1,4 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./param.utils"), exports);
+export * from './param.utils.js';

package/utils/param.utils.d.ts

@@ -1,5 +1,5 @@
-import { PipeTransform, Type } from '@nestjs/common';
+import type { ParameterDecoratorOptions, PipeTransform, Type } from '@nestjs/common';
 import 'reflect-metadata';
-import { WsParamtype } from '../enums/ws-paramtype.enum';
+import { WsParamtype } from '../enums/ws-paramtype.enum.js';
 export declare function createWsParamDecorator(paramtype: WsParamtype): (...pipes: (Type<PipeTransform> | PipeTransform)[]) => ParameterDecorator;
-export declare const createPipesWsParamDecorator: (paramtype: WsParamtype) => (data?: any, ...pipes: (Type<PipeTransform> | PipeTransform)[]) => ParameterDecorator;
+export declare const createPipesWsParamDecorator: (paramtype: WsParamtype) => (data?: any, optionsOrPipe?: ParameterDecoratorOptions | Type<PipeTransform> | PipeTransform, ...pipes: (Type<PipeTransform> | PipeTransform)[]) => ParameterDecorator;

package/utils/param.utils.js

@@ -1,23 +1,46 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPipesWsParamDecorator = void 0;
-exports.createWsParamDecorator = createWsParamDecorator;
-const route_params_decorator_1 = require("@nestjs/common/decorators/http/route-params.decorator");
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-require("reflect-metadata");
-const constants_1 = require("../constants");
-function createWsParamDecorator(paramtype) {
+import { assignMetadata } from '@nestjs/common';
+import { isNil, isString } from '@nestjs/common/internal';
+import 'reflect-metadata';
+import { PARAM_ARGS_METADATA } from '../constants.js';
+export function createWsParamDecorator(paramtype) {
     return (...pipes) => (target, key, index) => {
-        const args = Reflect.getMetadata(constants_1.PARAM_ARGS_METADATA, target.constructor, key) ||
+        const args = Reflect.getMetadata(PARAM_ARGS_METADATA, target.constructor, key) ||
             {};
-        Reflect.defineMetadata(constants_1.PARAM_ARGS_METADATA, (0, route_params_decorator_1.assignMetadata)(args, paramtype, index, undefined, ...pipes), target.constructor, key);
+        Reflect.defineMetadata(PARAM_ARGS_METADATA, assignMetadata(args, paramtype, index, { pipes }), target.constructor, key);
     };
 }
-const createPipesWsParamDecorator = (paramtype) => (data, ...pipes) => (target, key, index) => {
-    const args = Reflect.getMetadata(constants_1.PARAM_ARGS_METADATA, target.constructor, key) || {};
-    const hasParamData = (0, shared_utils_1.isNil)(data) || (0, shared_utils_1.isString)(data);
+export const createPipesWsParamDecorator = (paramtype) => (data, optionsOrPipe, ...pipes) => (target, key, index) => {
+    const args = Reflect.getMetadata(PARAM_ARGS_METADATA, target.constructor, key) || {};
+    const isDataOptions = data &&
+        typeof data === 'object' &&
+        !('transform' in data) &&
+        ('schema' in data || 'pipes' in data);
+    if (isDataOptions) {
+        const opts = data;
+        Reflect.defineMetadata(PARAM_ARGS_METADATA, assignMetadata(args, paramtype, index, {
+            pipes: opts.pipes ?? [],
+            schema: opts.schema,
+        }), target.constructor, key);
+        return;
+    }
+    const hasParamData = isNil(data) || isString(data);
     const paramData = hasParamData ? data : undefined;
-    const paramPipes = hasParamData ? pipes : [data, ...pipes];
-    Reflect.defineMetadata(constants_1.PARAM_ARGS_METADATA, (0, route_params_decorator_1.assignMetadata)(args, paramtype, index, paramData, ...paramPipes), target.constructor, key);
+    const isOptions = optionsOrPipe &&
+        typeof optionsOrPipe === 'object' &&
+        ('schema' in optionsOrPipe || 'pipes' in optionsOrPipe);
+    let paramPipes;
+    if (isOptions) {
+        paramPipes = optionsOrPipe.pipes ?? [];
+    }
+    else if (hasParamData) {
+        paramPipes = [optionsOrPipe, ...pipes].filter(Boolean);
+    }
+    else {
+        paramPipes = [data, optionsOrPipe, ...pipes].filter(Boolean);
+    }
+    Reflect.defineMetadata(PARAM_ARGS_METADATA, assignMetadata(args, paramtype, index, {
+        data: paramData,
+        pipes: paramPipes,
+        schema: isOptions ? optionsOrPipe.schema : undefined,
+    }), target.constructor, key);
 };
-exports.createPipesWsParamDecorator = createPipesWsParamDecorator;

package/web-sockets-controller.d.ts

@@ -1,14 +1,13 @@
-import { NestApplicationContextOptions } from '@nestjs/common/interfaces/nest-application-context-options.interface';
-import { Type } from '@nestjs/common/interfaces/type.interface';
-import { ApplicationConfig } from '@nestjs/core/application-config';
-import { GraphInspector } from '@nestjs/core/inspector/graph-inspector';
 import { Observable, Subject } from 'rxjs';
-import { WsContextCreator } from './context/ws-context-creator';
-import { MessageMappingProperties } from './gateway-metadata-explorer';
-import { GatewayMetadata } from './interfaces/gateway-metadata.interface';
-import { NestGateway } from './interfaces/nest-gateway.interface';
-import { ServerAndEventStreamsHost } from './interfaces/server-and-event-streams-host.interface';
-import { SocketServerProvider } from './socket-server-provider';
+import { WsContextCreator } from './context/ws-context-creator.js';
+import { MessageMappingProperties } from './gateway-metadata-explorer.js';
+import { GatewayMetadata } from './interfaces/gateway-metadata.interface.js';
+import { NestGateway } from './interfaces/nest-gateway.interface.js';
+import { ServerAndEventStreamsHost } from './interfaces/server-and-event-streams-host.interface.js';
+import { SocketServerProvider } from './socket-server-provider.js';
+import type { NestApplicationContextOptions } from '@nestjs/common/internal';
+import { type Type } from '@nestjs/common';
+import { type ApplicationConfig, type GraphInspector } from '@nestjs/core';
 export declare class WebSocketsController {
     private readonly socketServerProvider;
     private readonly config;

package/web-sockets-controller.js

@@ -1,31 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebSocketsController = void 0;
-const logger_service_1 = require("@nestjs/common/services/logger.service");
-const metadata_scanner_1 = require("@nestjs/core/metadata-scanner");
-const rxjs_1 = require("rxjs");
-const operators_1 = require("rxjs/operators");
-const constants_1 = require("./constants");
-const invalid_socket_port_exception_1 = require("./errors/invalid-socket-port.exception");
-const gateway_metadata_explorer_1 = require("./gateway-metadata-explorer");
-const compare_element_util_1 = require("./utils/compare-element.util");
-class WebSocketsController {
+import { from as fromPromise, isObservable, of, } from 'rxjs';
+import { distinctUntilChanged, mergeAll } from 'rxjs/operators';
+import { GATEWAY_OPTIONS, PORT_METADATA } from './constants.js';
+import { InvalidSocketPortException } from './errors/invalid-socket-port.exception.js';
+import { GatewayMetadataExplorer, } from './gateway-metadata-explorer.js';
+import { compareElementAt } from './utils/compare-element.util.js';
+import { Logger } from '@nestjs/common';
+import { MetadataScanner, } from '@nestjs/core';
+export class WebSocketsController {
+    socketServerProvider;
+    config;
+    contextCreator;
+    graphInspector;
+    appOptions;
+    logger = new Logger(WebSocketsController.name, {
+        timestamp: true,
+    });
+    metadataExplorer = new GatewayMetadataExplorer(new MetadataScanner());
     constructor(socketServerProvider, config, contextCreator, graphInspector, appOptions = {}) {
         this.socketServerProvider = socketServerProvider;
         this.config = config;
         this.contextCreator = contextCreator;
         this.graphInspector = graphInspector;
         this.appOptions = appOptions;
-        this.logger = new logger_service_1.Logger(WebSocketsController.name, {
-            timestamp: true,
-        });
-        this.metadataExplorer = new gateway_metadata_explorer_1.GatewayMetadataExplorer(new metadata_scanner_1.MetadataScanner());
     }
     connectGatewayToServer(instance, metatype, moduleKey, instanceWrapperId) {
-        const options = Reflect.getMetadata(constants_1.GATEWAY_OPTIONS, metatype) || {};
-        const port = Reflect.getMetadata(constants_1.PORT_METADATA, metatype) || 0;
+        const options = Reflect.getMetadata(GATEWAY_OPTIONS, metatype) || {};
+        const port = Reflect.getMetadata(PORT_METADATA, metatype) || 0;
         if (!Number.isInteger(port)) {
-            throw new invalid_socket_port_exception_1.InvalidSocketPortException(port, metatype);
+            throw new InvalidSocketPortException(port, metatype);
         }
         this.subscribeToServerEvents(instance, options, port, moduleKey, instanceWrapperId);
     }
@@ -63,7 +65,7 @@ class WebSocketsController {
             context.subscribeMessages(subscribersMap, client, instance);
             const disconnectHook = adapter.bindClientDisconnect;
             disconnectHook &&
-                disconnectHook.call(adapter, client, () => disconnect.next(client));
+                disconnectHook.call(adapter, client, (reason) => disconnect.next({ client, reason }));
         };
     }
     subscribeInitEvent(instance, event) {
@@ -74,15 +76,27 @@ class WebSocketsController {
     subscribeConnectionEvent(instance, event) {
         if (instance.handleConnection) {
             event
-                .pipe((0, operators_1.distinctUntilChanged)((prev, curr) => (0, compare_element_util_1.compareElementAt)(prev, curr, 0)))
+                .pipe(distinctUntilChanged((prev, curr) => compareElementAt(prev, curr, 0)))
                 .subscribe((args) => instance.handleConnection(...args));
         }
     }
     subscribeDisconnectEvent(instance, event) {
         if (instance.handleDisconnect) {
             event
-                .pipe((0, operators_1.distinctUntilChanged)())
-                .subscribe(instance.handleDisconnect.bind(instance));
+                .pipe(distinctUntilChanged((prev, curr) => {
+                const prevClient = prev?.client || prev;
+                const currClient = curr?.client || curr;
+                return prevClient === currClient;
+            }))
+                .subscribe((data) => {
+                if (data && typeof data === 'object' && 'client' in data) {
+                    instance.handleDisconnect(data.client, data.reason);
+                }
+                else {
+                    // Backward compatibility: if it's just the client
+                    instance.handleDisconnect(data);
+                }
+            });
         }
     }
     subscribeMessages(subscribersMap, client, instance) {
@@ -92,17 +106,17 @@ class WebSocketsController {
             callback: callback.bind(instance, client),
             isAckHandledManually,
         }));
-        adapter.bindMessageHandlers(client, handlers, data => (0, rxjs_1.from)(this.pickResult(data)).pipe((0, operators_1.mergeAll)()));
+        adapter.bindMessageHandlers(client, handlers, data => fromPromise(this.pickResult(data)).pipe(mergeAll()));
     }
     async pickResult(deferredResult) {
         const result = await deferredResult;
-        if ((0, rxjs_1.isObservable)(result)) {
+        if (isObservable(result)) {
             return result;
         }
         if (result instanceof Promise) {
-            return (0, rxjs_1.from)(result);
+            return fromPromise(result);
         }
-        return (0, rxjs_1.of)(result);
+        return of(result);
     }
     inspectEntrypointDefinitions(instance, port, messageHandlers, instanceWrapperId) {
         messageHandlers.forEach(handler => {
@@ -132,4 +146,3 @@ class WebSocketsController {
         subscribersMap.forEach(({ message }) => this.logger.log(`${gatewayClassName} subscribed to the "${message}" message`));
     }
 }
-exports.WebSocketsController = WebSocketsController;