@nestjs/websockets 12.0.0-alpha.4 → 12.0.0-alpha.5

package/Readme.md

@@ -129,6 +129,7 @@ Nest is an MIT-licensed open source project. It can grow thanks to the sponsors
 <tr>
 <td align="center" valign="middle"><a href="https://solcellsforetag.se/" target="_blank"><img src="https://nestjs.com/img/logos/solcellsforetag-logo.svg" width="140" valign="middle" /></a></td>
 <td align="center" valign="middle"><a href="https://www.route4me.com/" target="_blank"><img src="https://nestjs.com/img/logos/route4me-logo.svg" width="100" valign="middle" /></a></td>
+<td align="center" valign="middle"><a href="https://memory2.co/" target="_blank"><img src="https://images.opencollective.com/memory-squared/bbe37f5/avatar/256.png?height=50" width="50" valign="middle" /></a></td>
 </tr>
 </table>
 

package/adapters/ws-adapter.js

@@ -22,6 +22,10 @@ export class AbstractWsAdapter {
         server.on(CONNECTION_EVENT, callback);
     }
     bindClientDisconnect(client, callback) {
+        if (typeof client.once === 'function') {
+            client.once(DISCONNECT_EVENT, callback);
+            return;
+        }
         client.on(DISCONNECT_EVENT, callback);
     }
     async close(server) {

package/context/exception-filters-context.d.ts

@@ -6,6 +6,6 @@ import type { NestContainer } from '@nestjs/core';
  */
 export declare class ExceptionFiltersContext extends BaseExceptionFilterContext {
     constructor(container: NestContainer);
-    create(instance: object, callback: <TClient>(client: TClient, data: any) => any, moduleKey: string): WsExceptionsHandler;
+    create(instance: object, callback: <TClient>(client: TClient, data: any) => any, moduleKey: string, contextId?: import("@nestjs/core").ContextId, inquirerId?: string): WsExceptionsHandler;
     getGlobalMetadata<T extends any[]>(): T;
 }

package/context/exception-filters-context.js

@@ -1,6 +1,6 @@
 import { WsExceptionsHandler } from '../exceptions/ws-exceptions-handler.js';
 import { EXCEPTION_FILTERS_METADATA, isEmptyArray, } from '@nestjs/common/internal';
-import { BaseExceptionFilterContext } from '@nestjs/core/internal';
+import { BaseExceptionFilterContext, STATIC_CONTEXT, } from '@nestjs/core/internal';
 /**
  * @publicApi
  */
@@ -8,10 +8,10 @@ export class ExceptionFiltersContext extends BaseExceptionFilterContext {
     constructor(container) {
         super(container);
     }
-    create(instance, callback, moduleKey) {
+    create(instance, callback, moduleKey, contextId = STATIC_CONTEXT, inquirerId) {
         this.moduleContext = moduleKey;
         const exceptionHandler = new WsExceptionsHandler();
-        const filters = this.createContext(instance, callback, EXCEPTION_FILTERS_METADATA);
+        const filters = this.createContext(instance, callback, EXCEPTION_FILTERS_METADATA, contextId, inquirerId);
         if (isEmptyArray(filters)) {
             return exceptionHandler;
         }

package/context/ws-context-creator.d.ts

@@ -25,7 +25,7 @@ export declare class WsContextCreator {
     private readonly wsParamsFactory;
     private readonly handlerMetadataStorage;
     constructor(wsProxy: WsProxy, exceptionFiltersContext: ExceptionFiltersContext, pipesContextCreator: PipesContextCreator, pipesConsumer: PipesConsumer, guardsContextCreator: GuardsContextCreator, guardsConsumer: GuardsConsumer, interceptorsContextCreator: InterceptorsContextCreator, interceptorsConsumer: InterceptorsConsumer);
-    create<T extends ParamsMetadata = ParamsMetadata>(instance: Controller, callback: (...args: unknown[]) => void, moduleKey: string, methodName: string): (...args: any[]) => Promise<void>;
+    create<T extends ParamsMetadata = ParamsMetadata>(instance: Controller, callback: (...args: unknown[]) => void, moduleKey: string, methodName: string, contextId?: import("@nestjs/core").ContextId, inquirerId?: string): (...args: any[]) => Promise<void>;
     reflectCallbackParamtypes(instance: Controller, callback: (...args: any[]) => any): any[];
     reflectCallbackPattern(callback: (...args: any[]) => any): string;
     createGuardsFn<TContext extends string = ContextType>(guards: any[], instance: Controller, callback: (...args: unknown[]) => any, contextType?: TContext): Function | null;

package/context/ws-context-creator.js

@@ -1,5 +1,5 @@
 import { CUSTOM_ROUTE_ARGS_METADATA, isEmptyArray, PARAMTYPES_METADATA, } from '@nestjs/common/internal';
-import { ContextUtils, FORBIDDEN_MESSAGE, HandlerMetadataStorage, } from '@nestjs/core/internal';
+import { ContextUtils, FORBIDDEN_MESSAGE, HandlerMetadataStorage, STATIC_CONTEXT, } from '@nestjs/core/internal';
 import { MESSAGE_METADATA, PARAM_ARGS_METADATA } from '../constants.js';
 import { WsException } from '../errors/ws-exception.js';
 import { WsParamsFactory } from '../factories/ws-params-factory.js';
@@ -26,13 +26,13 @@ export class WsContextCreator {
         this.interceptorsContextCreator = interceptorsContextCreator;
         this.interceptorsConsumer = interceptorsConsumer;
     }
-    create(instance, callback, moduleKey, methodName) {
+    create(instance, callback, moduleKey, methodName, contextId = STATIC_CONTEXT, inquirerId) {
         const contextType = 'ws';
         const { argsLength, paramtypes, getParamsMetadata } = this.getMetadata(instance, methodName, contextType);
-        const exceptionHandler = this.exceptionFiltersContext.create(instance, callback, moduleKey);
-        const pipes = this.pipesContextCreator.create(instance, callback, moduleKey);
-        const guards = this.guardsContextCreator.create(instance, callback, moduleKey);
-        const interceptors = this.interceptorsContextCreator.create(instance, callback, moduleKey);
+        const exceptionHandler = this.exceptionFiltersContext.create(instance, callback, moduleKey, contextId, inquirerId);
+        const pipes = this.pipesContextCreator.create(instance, callback, moduleKey, contextId, inquirerId);
+        const guards = this.guardsContextCreator.create(instance, callback, moduleKey, contextId, inquirerId);
+        const interceptors = this.interceptorsContextCreator.create(instance, callback, moduleKey, contextId, inquirerId);
         const paramsMetadata = getParamsMetadata(moduleKey);
         const paramsOptions = paramsMetadata
             ? this.contextUtils.mergeParamsMetatypes(paramsMetadata, paramtypes)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/websockets",
-  "version": "12.0.0-alpha.4",
+  "version": "12.0.0-alpha.5",
   "description": "Nest - modern, fast, powerful node.js web framework (@websockets)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",
@@ -26,8 +26,8 @@
     "tslib": "2.8.1"
   },
   "devDependencies": {
-    "@nestjs/common": "^12.0.0-alpha.4",
-    "@nestjs/core": "^12.0.0-alpha.4"
+    "@nestjs/common": "^12.0.0-alpha.5",
+    "@nestjs/core": "^12.0.0-alpha.5"
   },
   "peerDependencies": {
     "@nestjs/common": "^11.0.0",
@@ -41,5 +41,5 @@
       "optional": true
     }
   },
-  "gitHead": "415e4d33707e74998d8456be7bd305cedb6508e3"
+  "gitHead": "d91b72cc9567e6a09e3ad6075b2fb801e71adfc8"
 }

package/socket-module.d.ts

@@ -9,6 +9,7 @@ export declare class SocketModule<THttpServer = any, TAppOptions extends NestApp
     private isAdapterInitialized;
     private httpServer;
     private appOptions;
+    private injector;
     register(container: NestContainer, applicationConfig: ApplicationConfig, graphInspector: GraphInspector, appOptions: TAppOptions, httpServer?: THttpServer): void;
     connectAllGateways(providers: Map<InjectionToken, InstanceWrapper<Injectable>>, moduleName: string): void;
     connectGatewayToServer(wrapper: InstanceWrapper<Injectable>, moduleName: string): Promise<void>;

package/socket-module.js

@@ -6,7 +6,7 @@ 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';
+import { Injector, GuardsConsumer, GuardsContextCreator, loadAdapter, InterceptorsConsumer, InterceptorsContextCreator, PipesConsumer, PipesContextCreator, } from '@nestjs/core/internal';
 export class SocketModule {
     socketsContainer = new SocketsContainer();
     applicationConfig;
@@ -14,13 +14,19 @@ export class SocketModule {
     isAdapterInitialized;
     httpServer;
     appOptions;
+    injector;
     register(container, applicationConfig, graphInspector, appOptions, httpServer) {
         this.applicationConfig = applicationConfig;
         this.appOptions = appOptions;
         this.httpServer = httpServer;
-        const contextCreator = this.getContextCreator(container);
+        this.injector = new Injector({
+            preview: container.contextOptions?.preview,
+            instanceDecorator: container.contextOptions?.instrument?.instanceDecorator,
+        });
+        const exceptionFiltersContext = new ExceptionFiltersContext(container);
+        const contextCreator = this.getContextCreator(container, applicationConfig, exceptionFiltersContext);
         const serverProvider = new SocketServerProvider(this.socketsContainer, applicationConfig);
-        this.webSocketsController = new WebSocketsController(serverProvider, applicationConfig, contextCreator, graphInspector, this.appOptions);
+        this.webSocketsController = new WebSocketsController(serverProvider, applicationConfig, contextCreator, container, this.injector, exceptionFiltersContext, graphInspector, this.appOptions);
         const modules = container.getModules();
         modules.forEach(({ providers }, moduleName) => this.connectAllGateways(providers, moduleName));
     }
@@ -38,7 +44,7 @@ export class SocketModule {
         if (!this.isAdapterInitialized) {
             await this.initializeAdapter();
         }
-        this.webSocketsController.connectGatewayToServer(instance, metatype, moduleName, wrapper.id);
+        this.webSocketsController.connectGatewayToServer(wrapper, moduleName);
     }
     async close() {
         if (!this.applicationConfig) {
@@ -71,7 +77,7 @@ export class SocketModule {
         this.applicationConfig.setIoAdapter(ioAdapter);
         this.isAdapterInitialized = true;
     }
-    getContextCreator(container) {
-        return new WsContextCreator(new WsProxy(), new ExceptionFiltersContext(container), new PipesContextCreator(container), new PipesConsumer(), new GuardsContextCreator(container), new GuardsConsumer(), new InterceptorsContextCreator(container), new InterceptorsConsumer());
+    getContextCreator(container, config, exceptionFiltersContext) {
+        return new WsContextCreator(new WsProxy(), exceptionFiltersContext, new PipesContextCreator(container, config), new PipesConsumer(), new GuardsContextCreator(container, config), new GuardsConsumer(), new InterceptorsContextCreator(container, config), new InterceptorsConsumer());
     }
 }

package/web-sockets-controller.d.ts

@@ -7,26 +7,38 @@ import { ServerAndEventStreamsHost } from './interfaces/server-and-event-streams
 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';
+import { type ApplicationConfig, type ContextId, type GraphInspector, type NestContainer } from '@nestjs/core';
+import { type Injector, type InstanceWrapper, type Module } from '@nestjs/core/internal';
+import { ExceptionFiltersContext } from './context/exception-filters-context.js';
 export declare class WebSocketsController {
     private readonly socketServerProvider;
     private readonly config;
     private readonly contextCreator;
+    private readonly container;
+    private readonly injector;
+    private readonly exceptionFiltersContext;
     private readonly graphInspector;
     private readonly appOptions;
     private readonly logger;
     private readonly metadataExplorer;
-    constructor(socketServerProvider: SocketServerProvider, config: ApplicationConfig, contextCreator: WsContextCreator, graphInspector: GraphInspector, appOptions?: NestApplicationContextOptions);
+    private readonly exceptionFiltersCache;
+    constructor(socketServerProvider: SocketServerProvider, config: ApplicationConfig, contextCreator: WsContextCreator, container: NestContainer, injector: Injector, exceptionFiltersContext: ExceptionFiltersContext, graphInspector: GraphInspector, appOptions?: NestApplicationContextOptions);
+    connectGatewayToServer(instanceWrapper: InstanceWrapper<NestGateway>, moduleKey: string): void;
     connectGatewayToServer(instance: NestGateway, metatype: Type<unknown> | Function, moduleKey: string, instanceWrapperId: string): void;
+    subscribeToServerEvents<T extends GatewayMetadata>(instanceWrapper: InstanceWrapper<NestGateway>, options: T, port: number, moduleKey: string, instanceWrapperId: string): void;
     subscribeToServerEvents<T extends GatewayMetadata>(instance: NestGateway, options: T, port: number, moduleKey: string, instanceWrapperId: string): void;
-    subscribeEvents(instance: NestGateway, subscribersMap: MessageMappingProperties[], observableServer: ServerAndEventStreamsHost): void;
+    subscribeEvents(instanceWrapper: InstanceWrapper<NestGateway>, subscribersMap: MessageMappingProperties[], observableServer: ServerAndEventStreamsHost, connectionHandler?: Function, disconnectHandler?: Function): void;
     getConnectionHandler(context: WebSocketsController, instance: NestGateway, subscribersMap: MessageMappingProperties[], disconnect: Subject<any>, connection: Subject<any>): (...args: unknown[]) => void;
     subscribeInitEvent(instance: NestGateway, event: Subject<any>): void;
-    subscribeConnectionEvent(instance: NestGateway, event: Subject<any>): void;
-    subscribeDisconnectEvent(instance: NestGateway, event: Subject<any>): void;
+    subscribeConnectionEvent(handlerOrGateway: Function | NestGateway | undefined, event: Subject<any>): void;
+    subscribeDisconnectEvent(handlerOrGateway: Function | NestGateway | undefined, event: Subject<any>): void;
     subscribeMessages<T = any>(subscribersMap: MessageMappingProperties[], client: T, instance: NestGateway): void;
     pickResult(deferredResult: Promise<any>): Promise<Observable<any>>;
     inspectEntrypointDefinitions(instance: NestGateway, port: number, messageHandlers: MessageMappingProperties[], instanceWrapperId: string): void;
+    createRequestScopedHandler(instanceWrapper: InstanceWrapper<NestGateway>, moduleRef: Module, moduleKey: string, methodName: string): (...args: unknown[]) => Promise<void>;
+    createRequestScopedEventHandler(instanceWrapper: InstanceWrapper<NestGateway>, moduleRef: Module, moduleKey: string, methodName: 'handleConnection' | 'handleDisconnect', server: object): (...args: unknown[]) => Promise<unknown>;
+    getContextId<T extends Record<any, unknown> = any>(request: T, isTreeDurable: boolean): ContextId;
+    private cleanupRequestScopedContext;
     private assignServerToProperties;
     private printSubscriptionLogs;
 }

package/web-sockets-controller.js

@@ -5,38 +5,84 @@ import { InvalidSocketPortException } from './errors/invalid-socket-port.excepti
 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';
+import { ContextIdFactory, MetadataScanner, } from '@nestjs/core';
+import { ExecutionContextHost, REQUEST_CONTEXT_ID, STATIC_CONTEXT, } from '@nestjs/core/internal';
 export class WebSocketsController {
     socketServerProvider;
     config;
     contextCreator;
+    container;
+    injector;
+    exceptionFiltersContext;
     graphInspector;
     appOptions;
     logger = new Logger(WebSocketsController.name, {
         timestamp: true,
     });
     metadataExplorer = new GatewayMetadataExplorer(new MetadataScanner());
-    constructor(socketServerProvider, config, contextCreator, graphInspector, appOptions = {}) {
+    exceptionFiltersCache = new WeakMap();
+    constructor(socketServerProvider, config, contextCreator, container, injector, exceptionFiltersContext, graphInspector, appOptions = {}) {
         this.socketServerProvider = socketServerProvider;
         this.config = config;
         this.contextCreator = contextCreator;
+        this.container = container;
+        this.injector = injector;
+        this.exceptionFiltersContext = exceptionFiltersContext;
         this.graphInspector = graphInspector;
         this.appOptions = appOptions;
     }
-    connectGatewayToServer(instance, metatype, moduleKey, instanceWrapperId) {
-        const options = Reflect.getMetadata(GATEWAY_OPTIONS, metatype) || {};
-        const port = Reflect.getMetadata(PORT_METADATA, metatype) || 0;
+    connectGatewayToServer(instanceOrWrapper, metatypeOrModuleKey, moduleKey, instanceWrapperId) {
+        const isInstanceWrapper = typeof metatypeOrModuleKey === 'string' &&
+            'instance' in instanceOrWrapper;
+        const instance = isInstanceWrapper
+            ? instanceOrWrapper.instance
+            : instanceOrWrapper;
+        const metatype = isInstanceWrapper
+            ? instanceOrWrapper.metatype
+            : metatypeOrModuleKey;
+        const targetModuleKey = isInstanceWrapper
+            ? metatypeOrModuleKey
+            : moduleKey;
+        const targetInstanceWrapperId = isInstanceWrapper
+            ? instanceOrWrapper.id
+            : instanceWrapperId;
+        const instanceWrapper = isInstanceWrapper
+            ? instanceOrWrapper
+            : {
+                instance,
+                metatype,
+                id: targetInstanceWrapperId,
+                isDependencyTreeStatic: () => true,
+                isDependencyTreeDurable: () => false,
+            };
+        const gatewayMetatype = metatype ?? instance.constructor;
+        const options = Reflect.getMetadata(GATEWAY_OPTIONS, gatewayMetatype) || {};
+        const port = Reflect.getMetadata(PORT_METADATA, gatewayMetatype) || 0;
         if (!Number.isInteger(port)) {
-            throw new InvalidSocketPortException(port, metatype);
+            throw new InvalidSocketPortException(port, gatewayMetatype);
         }
-        this.subscribeToServerEvents(instance, options, port, moduleKey, instanceWrapperId);
+        this.subscribeToServerEvents(instanceWrapper, options, port, targetModuleKey, targetInstanceWrapperId);
     }
-    subscribeToServerEvents(instance, options, port, moduleKey, instanceWrapperId) {
+    subscribeToServerEvents(instanceOrWrapper, options, port, moduleKey, instanceWrapperId) {
+        const instanceWrapper = 'instance' in instanceOrWrapper
+            ? instanceOrWrapper
+            : {
+                instance: instanceOrWrapper,
+                metatype: instanceOrWrapper.constructor,
+                id: instanceWrapperId,
+                isDependencyTreeStatic: () => true,
+                isDependencyTreeDurable: () => false,
+            };
+        const { instance } = instanceWrapper;
         const nativeMessageHandlers = this.metadataExplorer.explore(instance);
+        const isStatic = instanceWrapper.isDependencyTreeStatic();
+        const moduleRef = this.container.getModuleByKey(moduleKey);
         const messageHandlers = nativeMessageHandlers.map(({ callback, isAckHandledManually, message, methodName }) => ({
             message,
             methodName,
-            callback: this.contextCreator.create(instance, callback, moduleKey, methodName),
+            callback: isStatic
+                ? this.contextCreator.create(instance, callback, moduleKey, methodName, STATIC_CONTEXT)
+                : this.createRequestScopedHandler(instanceWrapper, moduleRef, moduleKey, methodName),
             isAckHandledManually,
         }));
         this.inspectEntrypointDefinitions(instance, port, messageHandlers, instanceWrapperId);
@@ -45,14 +91,19 @@ export class WebSocketsController {
         }
         const observableServer = this.socketServerProvider.scanForSocketServer(options, port);
         this.assignServerToProperties(instance, observableServer.server);
-        this.subscribeEvents(instance, messageHandlers, observableServer);
+        this.subscribeEvents(instanceWrapper, messageHandlers, observableServer, isStatic
+            ? instance.handleConnection?.bind(instance)
+            : this.createRequestScopedEventHandler(instanceWrapper, moduleRef, moduleKey, 'handleConnection', observableServer.server), isStatic
+            ? instance.handleDisconnect?.bind(instance)
+            : this.createRequestScopedEventHandler(instanceWrapper, moduleRef, moduleKey, 'handleDisconnect', observableServer.server));
     }
-    subscribeEvents(instance, subscribersMap, observableServer) {
+    subscribeEvents(instanceWrapper, subscribersMap, observableServer, connectionHandler, disconnectHandler) {
+        const { instance } = instanceWrapper;
         const { init, disconnect, connection, server } = observableServer;
         const adapter = this.config.getIoAdapter();
         this.subscribeInitEvent(instance, init);
-        this.subscribeConnectionEvent(instance, connection);
-        this.subscribeDisconnectEvent(instance, disconnect);
+        this.subscribeConnectionEvent(connectionHandler, connection);
+        this.subscribeDisconnectEvent(disconnectHandler, disconnect);
         const handler = this.getConnectionHandler(this, instance, subscribersMap, disconnect, connection);
         adapter.bindClientConnect(server, handler);
         this.printSubscriptionLogs(instance, subscribersMap);
@@ -73,15 +124,21 @@ export class WebSocketsController {
             event.subscribe(instance.afterInit.bind(instance));
         }
     }
-    subscribeConnectionEvent(instance, event) {
-        if (instance.handleConnection) {
+    subscribeConnectionEvent(handlerOrGateway, event) {
+        const handler = typeof handlerOrGateway === 'function'
+            ? handlerOrGateway
+            : handlerOrGateway?.handleConnection?.bind(handlerOrGateway);
+        if (handler) {
             event
                 .pipe(distinctUntilChanged((prev, curr) => compareElementAt(prev, curr, 0)))
-                .subscribe((args) => instance.handleConnection(...args));
+                .subscribe((args) => handler(...args));
         }
     }
-    subscribeDisconnectEvent(instance, event) {
-        if (instance.handleDisconnect) {
+    subscribeDisconnectEvent(handlerOrGateway, event) {
+        const handler = typeof handlerOrGateway === 'function'
+            ? handlerOrGateway
+            : handlerOrGateway?.handleDisconnect?.bind(handlerOrGateway);
+        if (handler) {
             event
                 .pipe(distinctUntilChanged((prev, curr) => {
                 const prevClient = prev?.client || prev;
@@ -90,11 +147,11 @@ export class WebSocketsController {
             }))
                 .subscribe((data) => {
                 if (data && typeof data === 'object' && 'client' in data) {
-                    instance.handleDisconnect(data.client, data.reason);
+                    handler(data.client, data.reason);
                 }
                 else {
                     // Backward compatibility: if it's just the client
-                    instance.handleDisconnect(data);
+                    handler(data);
                 }
             });
         }
@@ -133,6 +190,83 @@ export class WebSocketsController {
             }, instanceWrapperId);
         });
     }
+    createRequestScopedHandler(instanceWrapper, moduleRef, moduleKey, methodName) {
+        const { instance } = instanceWrapper;
+        const collection = moduleRef.providers;
+        const isTreeDurable = instanceWrapper.isDependencyTreeDurable();
+        return async (...args) => {
+            const [client] = args;
+            try {
+                const contextId = this.getContextId(client, isTreeDurable);
+                const contextInstance = await this.injector.loadPerContext(instance, moduleRef, collection, contextId);
+                return this.contextCreator.create(contextInstance, contextInstance[methodName], moduleKey, methodName, contextId, instanceWrapper.id)(...args);
+            }
+            catch (err) {
+                let exceptionFilter = this.exceptionFiltersCache.get(instance[methodName]);
+                if (!exceptionFilter) {
+                    exceptionFilter = this.exceptionFiltersContext.create(instance, instance[methodName], moduleKey);
+                    this.exceptionFiltersCache.set(instance[methodName], exceptionFilter);
+                }
+                const host = new ExecutionContextHost(args);
+                host.setType('ws');
+                exceptionFilter.handle(err, host);
+            }
+        };
+    }
+    createRequestScopedEventHandler(instanceWrapper, moduleRef, moduleKey, methodName, server) {
+        const { instance } = instanceWrapper;
+        const collection = moduleRef.providers;
+        const isTreeDurable = instanceWrapper.isDependencyTreeDurable();
+        const targetCallback = instance[methodName];
+        return async (...args) => {
+            const [client] = args;
+            let contextId;
+            try {
+                contextId = this.getContextId(client, isTreeDurable);
+                const contextInstance = await this.injector.loadPerContext(instance, moduleRef, collection, contextId);
+                this.assignServerToProperties(contextInstance, server);
+                const scopedMethod = contextInstance[methodName];
+                return scopedMethod?.apply(contextInstance, args);
+            }
+            catch (err) {
+                if (!targetCallback) {
+                    throw err;
+                }
+                let exceptionFilter = this.exceptionFiltersCache.get(targetCallback);
+                if (!exceptionFilter) {
+                    exceptionFilter = this.exceptionFiltersContext.create(instance, targetCallback, moduleKey);
+                    this.exceptionFiltersCache.set(targetCallback, exceptionFilter);
+                }
+                const host = new ExecutionContextHost(args);
+                host.setType('ws');
+                exceptionFilter.handle(err, host);
+            }
+            finally {
+                if (methodName === 'handleDisconnect' && contextId) {
+                    this.cleanupRequestScopedContext(instanceWrapper, contextId, client);
+                }
+            }
+        };
+    }
+    getContextId(request, isTreeDurable) {
+        const contextId = ContextIdFactory.getByRequest(request);
+        if (!request[REQUEST_CONTEXT_ID]) {
+            Object.defineProperty(request, REQUEST_CONTEXT_ID, {
+                value: contextId,
+                enumerable: false,
+                writable: false,
+                configurable: true,
+            });
+            const requestProviderValue = isTreeDurable
+                ? contextId.payload
+                : Object.assign(request, contextId.payload);
+            this.container.registerRequestProvider(requestProviderValue, contextId);
+        }
+        return contextId;
+    }
+    cleanupRequestScopedContext(_instanceWrapper, _contextId, request) {
+        Reflect.deleteProperty(request, REQUEST_CONTEXT_ID);
+    }
     assignServerToProperties(instance, server) {
         for (const propertyKey of this.metadataExplorer.scanForServerHooks(instance)) {
             Reflect.set(instance, propertyKey, server);