@nestjs/websockets 10.4.11 → 11.0.0-next.2

package/adapters/ws-adapter.d.ts

@@ -10,7 +10,7 @@ export declare abstract class AbstractWsAdapter<TServer extends BaseWsInstance =
     private _forceCloseConnections;
     set forceCloseConnections(value: boolean);
     get forceCloseConnections(): boolean;
-    constructor(appOrHttpServer?: INestApplicationContext | any);
+    constructor(appOrHttpServer?: INestApplicationContext | object);
     bindClientConnect(server: TServer, callback: Function): void;
     bindClientDisconnect(client: TClient, callback: Function): void;
     close(server: TServer): Promise<void>;

package/adapters/ws-adapter.js

@@ -29,7 +29,6 @@ class AbstractWsAdapter {
         const isCallable = server && (0, shared_utils_1.isFunction)(server.close);
         isCallable && (await new Promise(resolve => server.close(resolve)));
     }
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
     async dispose() { }
 }
 exports.AbstractWsAdapter = AbstractWsAdapter;

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

@@ -38,7 +38,7 @@ export declare class WsContextCreator {
     exchangeKeysForValues<TMetadata = any>(keys: string[], metadata: TMetadata, moduleContext: string, paramsFactory: WsParamsFactory, contextFactory: (args: unknown[]) => ExecutionContextHost): ParamProperties[];
     createPipesFn(pipes: PipeTransform[], paramsOptions: (ParamProperties & {
         metatype?: unknown;
-    })[]): (args: unknown[], ...params: unknown[]) => Promise<void>;
+    })[]): ((args: unknown[], ...params: unknown[]) => Promise<void>) | null;
     getParamValue<T>(value: T, { metatype, type, data }: {
         metatype: any;
         type: any;

package/context/ws-metadata-constants.d.ts

@@ -1,12 +1,12 @@
 export declare const DEFAULT_CALLBACK_METADATA: {
     "3:1": {
         index: number;
-        data: any;
-        pipes: any[];
+        data: undefined;
+        pipes: never[];
     };
     "0:0": {
         index: number;
-        data: any;
-        pipes: any[];
+        data: undefined;
+        pipes: never[];
     };
 };

package/exceptions/base-ws-exception-filter.d.ts

@@ -1,15 +1,50 @@
-import { ArgumentsHost, WsExceptionFilter } from '@nestjs/common';
+import { ArgumentsHost, Logger, WsExceptionFilter } from '@nestjs/common';
+export interface ErrorPayload<Cause = {
+    pattern: string;
+    data: unknown;
+}> {
+    /**
+     * Error message identifier.
+     */
+    status: 'error';
+    /**
+     * Error message.
+     */
+    message: string;
+    /**
+     * Message that caused the exception.
+     */
+    cause?: Cause;
+}
+interface BaseWsExceptionFilterOptions {
+    /**
+     * When true, the data that caused the exception will be included in the response.
+     * This is useful when you want to provide additional context to the client, or
+     * when you need to associate the error with a specific request.
+     * @default true
+     */
+    includeCause?: boolean;
+    /**
+     * A factory function that can be used to control the shape of the "cause" object.
+     * This is useful when you need a custom structure for the cause object.
+     * @default (pattern, data) => ({ pattern, data })
+     */
+    causeFactory?: (pattern: string, data: unknown) => Record<string, any>;
+}
 /**
  * @publicApi
  */
 export declare class BaseWsExceptionFilter<TError = any> implements WsExceptionFilter<TError> {
-    private static readonly logger;
+    protected readonly options: BaseWsExceptionFilterOptions;
+    protected static readonly logger: Logger;
+    constructor(options?: BaseWsExceptionFilterOptions);
     catch(exception: TError, host: ArgumentsHost): void;
     handleError<TClient extends {
         emit: Function;
-    }>(client: TClient, exception: TError): void;
+    }>(client: TClient, exception: TError, cause: ErrorPayload['cause']): any;
     handleUnknownError<TClient extends {
         emit: Function;
-    }>(exception: TError, client: TClient): void;
+    }>(exception: TError, client: TClient, data: ErrorPayload['cause']): void;
     isExceptionObject(err: any): err is Error;
 }
+export {};

package/exceptions/base-ws-exception-filter.js

@@ -9,34 +9,53 @@ const ws_exception_1 = require("../errors/ws-exception");
  * @publicApi
  */
 class BaseWsExceptionFilter {
+    constructor(options = {}) {
+        this.options = options;
+        this.options.includeCause = this.options.includeCause ?? true;
+        this.options.causeFactory =
+            this.options.causeFactory ?? ((pattern, data) => ({ pattern, data }));
+    }
     catch(exception, host) {
         const client = host.switchToWs().getClient();
-        this.handleError(client, exception);
+        const pattern = host.switchToWs().getPattern();
+        const data = host.switchToWs().getData();
+        this.handleError(client, exception, {
+            pattern,
+            data,
+        });
     }
-    handleError(client, exception) {
+    handleError(client, exception, cause) {
         if (!(exception instanceof ws_exception_1.WsException)) {
-            return this.handleUnknownError(exception, client);
+            return this.handleUnknownError(exception, client, cause);
         }
         const status = 'error';
         const result = exception.getError();
-        const message = (0, shared_utils_1.isObject)(result)
-            ? result
-            : {
-                status,
-                message: result,
-            };
-        client.emit('exception', message);
+        if ((0, shared_utils_1.isObject)(result)) {
+            return client.emit('exception', result);
+        }
+        const payload = {
+            status,
+            message: result,
+        };
+        if (this.options?.includeCause && cause) {
+            payload.cause = this.options.causeFactory(cause.pattern, cause.data);
+        }
+        client.emit('exception', payload);
     }
-    handleUnknownError(exception, client) {
+    handleUnknownError(exception, client, data) {
         const status = 'error';
-        client.emit('exception', {
+        const payload = {
             status,
             message: constants_1.MESSAGES.UNKNOWN_EXCEPTION_MESSAGE,
-        });
-        if (this.isExceptionObject(exception)) {
-            return BaseWsExceptionFilter.logger.error(exception.message, exception.stack);
+        };
+        if (this.options?.includeCause && data) {
+            payload.cause = this.options.causeFactory(data.pattern, data.data);
+        }
+        client.emit('exception', payload);
+        if (!(exception instanceof common_1.IntrinsicException)) {
+            const logger = BaseWsExceptionFilter.logger;
+            logger.error(exception);
         }
-        return BaseWsExceptionFilter.logger.error(exception);
     }
     isExceptionObject(err) {
         return (0, shared_utils_1.isObject)(err) && !!err.message;

package/exceptions/ws-exceptions-handler.d.ts

@@ -7,7 +7,7 @@ import { BaseWsExceptionFilter } from './base-ws-exception-filter';
  */
 export declare class WsExceptionsHandler extends BaseWsExceptionFilter {
     private filters;
-    handle(exception: Error | WsException | any, host: ArgumentsHost): void;
+    handle(exception: Error | WsException, host: ArgumentsHost): void;
     setCustomFilters(filters: ExceptionFilterMetadata[]): void;
     invokeCustomFilters<T = any>(exception: T, args: ArgumentsHost): boolean;
 }

package/exceptions/ws-exceptions-handler.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WsExceptionsHandler = void 0;
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const select_exception_filter_metadata_util_1 = require("@nestjs/common/utils/select-exception-filter-metadata.util");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const invalid_exception_filter_exception_1 = require("@nestjs/core/errors/exceptions/invalid-exception-filter.exception");
 const base_ws_exception_filter_1 = require("./base-ws-exception-filter");
 /**

package/gateway-metadata-explorer.d.ts

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

package/interfaces/gateway-metadata.interface.d.ts

@@ -96,7 +96,7 @@ export interface GatewayMetadata {
      * might be used for sticky-session. Defaults to not sending any cookie.
      * @default false
      */
-    cookie?: any | boolean;
+    cookie?: any;
     /**
      * The options that will be forwarded to the cors module
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/websockets",
-  "version": "10.4.11",
+  "version": "11.0.0-next.2",
   "description": "Nest - modern, fast, powerful node.js web framework (@websockets)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",
@@ -18,8 +18,8 @@
     "tslib": "2.7.0"
   },
   "devDependencies": {
-    "@nestjs/common": "10.4.11",
-    "@nestjs/core": "10.4.11"
+    "@nestjs/common": "^11.0.0-next.2",
+    "@nestjs/core": "^11.0.0-next.2"
   },
   "peerDependencies": {
     "@nestjs/common": "^10.0.0",

package/utils/param.utils.js

@@ -8,7 +8,8 @@ require("reflect-metadata");
 const constants_1 = require("../constants");
 function createWsParamDecorator(paramtype) {
     return (...pipes) => (target, key, index) => {
-        const args = Reflect.getMetadata(constants_1.PARAM_ARGS_METADATA, target.constructor, key) || {};
+        const args = Reflect.getMetadata(constants_1.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);
     };
 }