@directus/api 35.0.2 → 35.2.0

package/dist/websocket/controllers/base.js

@@ -19,7 +19,7 @@ import cookie from "cookie";
 import { WebSocketServer } from "ws";
 
 //#region src/websocket/controllers/base.ts
-const TOKEN_CHECK_INTERVAL = 15 * 60 * 1e3;
+const TOKEN_CHECK_INTERVAL = 900 * 1e3;
 const logger = useLogger();
 var SocketController = class {
 	server;
@@ -34,7 +34,7 @@ var SocketController = class {
 			noServer: true,
 			autoPong: false
 		});
-		this.clients = new Set();
+		this.clients = /* @__PURE__ */ new Set();
 		this.authInterval = null;
 		const { endpoint, authentication, maxConnections } = this.getEnvironmentConfig(configPrefix);
 		this.endpoint = endpoint;
@@ -50,12 +50,10 @@ var SocketController = class {
 		const authMode = AuthMode.safeParse(String(env[`${configPrefix}_AUTH`]).toLowerCase());
 		const authTimeout = Number(env[`${configPrefix}_AUTH_TIMEOUT`]) * 1e3;
 		const maxConnections = `${configPrefix}_CONN_LIMIT` in env ? Number(env[`${configPrefix}_CONN_LIMIT`]) : Number.POSITIVE_INFINITY;
-		if (!authMode.success) {
-			throw new InvalidProviderConfigError({
-				provider: "ws",
-				reason: fromZodError(authMode.error, { prefix: `${configPrefix}_AUTH` }).message
-			});
-		}
+		if (!authMode.success) throw new InvalidProviderConfigError({
+			provider: "ws",
+			reason: fromZodError(authMode.error, { prefix: `${configPrefix}_AUTH` }).message
+		});
 		return {
 			endpoint,
 			maxConnections,
@@ -66,10 +64,7 @@ var SocketController = class {
 		};
 	}
 	getRateLimiter() {
-		const env = useEnv();
-		if (toBoolean(env["RATE_LIMITER_ENABLED"]) === true) {
-			return createRateLimiter("RATE_LIMITER", { keyPrefix: "websocket" });
-		}
+		if (toBoolean(useEnv()["RATE_LIMITER_ENABLED"]) === true) return createRateLimiter("RATE_LIMITER", { keyPrefix: "websocket" });
 		return null;
 	}
 	catchInvalidMessages(ws) {
@@ -108,11 +103,8 @@ var SocketController = class {
 		};
 		if (this.authentication.mode === "strict" || query["access_token"] || cookies[sessionCookieName]) {
 			let token = null;
-			if (typeof query["access_token"] === "string") {
-				token = query["access_token"];
-			} else if (typeof cookies[sessionCookieName] === "string") {
-				token = cookies[sessionCookieName] ?? null;
-			}
+			if (typeof query["access_token"] === "string") token = query["access_token"];
+			else if (typeof cookies[sessionCookieName] === "string") token = cookies[sessionCookieName] ?? null;
 			await this.handleTokenUpgrade(context, token);
 			return;
 		}
@@ -132,15 +124,13 @@ var SocketController = class {
 	async handleTokenUpgrade({ request, socket, head, accountabilityOverrides }, token) {
 		let accountability = null;
 		let expires_at = null;
-		if (token) {
-			try {
-				const state = await authenticateConnection({ access_token: token }, accountabilityOverrides);
-				accountability = state.accountability;
-				expires_at = state.expires_at;
-			} catch {
-				accountability = null;
-				expires_at = null;
-			}
+		if (token) try {
+			const state = await authenticateConnection({ access_token: token }, accountabilityOverrides);
+			accountability = state.accountability;
+			expires_at = state.expires_at;
+		} catch {
+			accountability = null;
+			expires_at = null;
 		}
 		if (!token || !accountability || !accountability.user) {
 			logger.debug("WebSocket upgrade denied - " + JSON.stringify(accountability || "invalid"));
@@ -177,8 +167,7 @@ var SocketController = class {
 				this.server.emit("connection", ws, state);
 			} catch {
 				logger.debug("WebSocket authentication handshake failed");
-				const error = new WebSocketError("auth", "AUTH_FAILED", "Authentication handshake failed.");
-				handleWebSocketError(ws, error, "auth");
+				handleWebSocketError(ws, new WebSocketError("auth", "AUTH_FAILED", "Authentication handshake failed."), "auth");
 				ws.close();
 			}
 		});
@@ -190,16 +179,12 @@ var SocketController = class {
 		client.uid = randomUUID();
 		client.auth_timer = null;
 		ws.on("message", async (data) => {
-			if (this.rateLimiter !== null) {
-				try {
-					await this.rateLimiter.consume(client.uid);
-				} catch (limit) {
-					const timeout = limit?.msBeforeNext ?? this.rateLimiter.msDuration;
-					const error = new WebSocketError("server", "REQUESTS_EXCEEDED", `Too many messages, retry after ${timeout}ms.`);
-					handleWebSocketError(client, error, "server");
-					logger.debug(`WebSocket#${client.uid} is rate limited`);
-					return;
-				}
+			if (this.rateLimiter !== null) try {
+				await this.rateLimiter.consume(client.uid);
+			} catch (limit) {
+				handleWebSocketError(client, new WebSocketError("server", "REQUESTS_EXCEEDED", `Too many messages, retry after ${limit?.msBeforeNext ?? this.rateLimiter.msDuration}ms.`), "server");
+				logger.debug(`WebSocket#${client.uid} is rate limited`);
+				return;
 			}
 			let message;
 			try {
@@ -234,9 +219,7 @@ var SocketController = class {
 			this.clients.delete(client);
 		});
 		logger.debug(`WebSocket#${client.uid} connected`);
-		if (accountability) {
-			logger.trace(`WebSocket#${client.uid} authenticated as ${JSON.stringify(accountability)}`);
-		}
+		if (accountability) logger.trace(`WebSocket#${client.uid} authenticated as ${JSON.stringify(accountability)}`);
 		this.setTokenExpireTimer(client);
 		this.clients.add(client);
 		return client;
@@ -257,13 +240,11 @@ var SocketController = class {
 			* Re-use the existing ip, userAgent and origin accountability properties.
 			* They are only sent in the original connection request
 			*/
-			if (client.accountability) {
-				accountabilityOverrides = {
-					ip: client.accountability.ip,
-					userAgent: client.accountability.userAgent,
-					origin: client.accountability.origin
-				};
-			}
+			if (client.accountability) accountabilityOverrides = {
+				ip: client.accountability.ip,
+				userAgent: client.accountability.userAgent,
+				origin: client.accountability.origin
+			};
 			const { accountability, expires_at, refresh_token } = await authenticateConnection(message, accountabilityOverrides);
 			this.checkUserRequirements(accountability);
 			client.accountability = accountability;
@@ -277,16 +258,11 @@ var SocketController = class {
 			emitter_default.emitAction("websocket.auth.failure", { client });
 			client.accountability = null;
 			client.expires_at = null;
-			const _error = error instanceof WebSocketError ? error : new WebSocketError("auth", "AUTH_FAILED", "Authentication failed.", message.uid);
-			handleWebSocketError(client, _error, "auth");
-			if (this.authentication.mode !== "public") {
-				client.close();
-			}
+			handleWebSocketError(client, error instanceof WebSocketError ? error : new WebSocketError("auth", "AUTH_FAILED", "Authentication failed.", message.uid), "auth");
+			if (this.authentication.mode !== "public") client.close();
 		}
 	}
-	checkUserRequirements(_accountability) {
-		return;
-	}
+	checkUserRequirements(_accountability) {}
 	setTokenExpireTimer(client) {
 		if (client.auth_timer !== null) {
 			clearTimeout(client.auth_timer);
@@ -300,11 +276,8 @@ var SocketController = class {
 			client.expires_at = null;
 			handleWebSocketError(client, new TokenExpiredError(), "auth");
 			waitForMessageType(client, "auth", this.authentication.timeout).catch((msg) => {
-				const error = new WebSocketError("auth", "AUTH_TIMEOUT", "Authentication timed out.", msg?.uid);
-				handleWebSocketError(client, error, "auth");
-				if (this.authentication.mode !== "public") {
-					client.close();
-				}
+				handleWebSocketError(client, new WebSocketError("auth", "AUTH_TIMEOUT", "Authentication timed out.", msg?.uid), "auth");
+				if (this.authentication.mode !== "public") client.close();
 			});
 		}, expiresIn);
 	}

package/dist/websocket/controllers/graphql.js

@@ -25,12 +25,11 @@ var GraphQLSubscriptionController = class extends SocketController {
 		});
 		this.gql = makeServer({ schema: async (ctx) => {
 			const accountability = ctx.extra.client.accountability;
-			const service = new GraphQLService({
+			return new GraphQLService({
 				schema: await getSchema(),
 				scope: "items",
 				accountability
-			});
-			return service.getSchema();
+			}).getSchema();
 		} });
 		bindPubSub();
 		logger.info(`GraphQL Subscriptions started at ${getAddress(httpServer)}${this.endpoint}`);
@@ -47,15 +46,13 @@ var GraphQLSubscriptionController = class extends SocketController {
 					try {
 						if (getMessageType(message) === "connection_init" && this.authentication.mode !== "strict") {
 							const params = ConnectionParams.parse(message["payload"] ?? {});
-							if (this.authentication.mode === "handshake") {
-								if (typeof params.access_token === "string") {
-									const { accountability, expires_at } = await authenticateConnection({ access_token: params.access_token }, { ip: client.accountability?.ip ?? null });
-									client.accountability = accountability;
-									client.expires_at = expires_at;
-								} else {
-									client.close(CloseCode.Forbidden, "Forbidden");
-									return;
-								}
+							if (this.authentication.mode === "handshake") if (typeof params.access_token === "string") {
+								const { accountability, expires_at } = await authenticateConnection({ access_token: params.access_token }, { ip: client.accountability?.ip ?? null });
+								client.accountability = accountability;
+								client.expires_at = expires_at;
+							} else {
+								client.close(CloseCode.Forbidden, "Forbidden");
+								return;
 							}
 						} else if (this.authentication.mode === "handshake" && !client.accountability?.user) {
 							client.close(CloseCode.Forbidden, "Forbidden");
@@ -69,9 +66,7 @@ var GraphQLSubscriptionController = class extends SocketController {
 			}
 		}, { client });
 		client.once("close", (code, reason) => closedHandler(code, reason.toString()));
-		if (this.authentication.mode === "strict" && !client.accountability?.user) {
-			client.close(CloseCode.Forbidden, "Forbidden");
-		}
+		if (this.authentication.mode === "strict" && !client.accountability?.user) client.close(CloseCode.Forbidden, "Forbidden");
 	}
 	setTokenExpireTimer(client) {
 		if (client.auth_timer !== null) {
@@ -80,9 +75,7 @@ var GraphQLSubscriptionController = class extends SocketController {
 		}
 		if (this.authentication.mode !== "handshake") return;
 		client.auth_timer = setTimeout(() => {
-			if (!client.accountability?.user) {
-				client.close(CloseCode.Forbidden, "Forbidden");
-			}
+			if (!client.accountability?.user) client.close(CloseCode.Forbidden, "Forbidden");
 		}, this.authentication.timeout);
 	}
 	async handleHandshakeUpgrade({ request, socket, head }) {

package/dist/websocket/controllers/index.js

@@ -9,28 +9,19 @@ let websocketController;
 let subscriptionController;
 let logsController;
 function createWebSocketController(server) {
-	const env = useEnv();
-	if (toBoolean(env["WEBSOCKETS_REST_ENABLED"])) {
-		websocketController = new WebSocketController(server);
-	}
+	if (toBoolean(useEnv()["WEBSOCKETS_REST_ENABLED"])) websocketController = new WebSocketController(server);
 }
 function getWebSocketController() {
 	return websocketController;
 }
 function createSubscriptionController(server) {
-	const env = useEnv();
-	if (toBoolean(env["WEBSOCKETS_GRAPHQL_ENABLED"])) {
-		subscriptionController = new GraphQLSubscriptionController(server);
-	}
+	if (toBoolean(useEnv()["WEBSOCKETS_GRAPHQL_ENABLED"])) subscriptionController = new GraphQLSubscriptionController(server);
 }
 function getSubscriptionController() {
 	return subscriptionController;
 }
 function createLogsController(server) {
-	const env = useEnv();
-	if (toBoolean(env["WEBSOCKETS_LOGS_ENABLED"])) {
-		logsController = new LogsController(server);
-	}
+	if (toBoolean(useEnv()["WEBSOCKETS_LOGS_ENABLED"])) logsController = new LogsController(server);
 }
 function getLogsController() {
 	return logsController;

package/dist/websocket/controllers/logs.js

@@ -18,11 +18,9 @@ var LogsController = class extends SocketController {
 	}
 	getEnvironmentConfig(configPrefix) {
 		const env = useEnv();
-		const endpoint = String(env[`${configPrefix}_PATH`]);
-		const maxConnections = `${configPrefix}_CONN_LIMIT` in env ? Number(env[`${configPrefix}_CONN_LIMIT`]) : Number.POSITIVE_INFINITY;
 		return {
-			endpoint,
-			maxConnections,
+			endpoint: String(env[`${configPrefix}_PATH`]),
+			maxConnections: `${configPrefix}_CONN_LIMIT` in env ? Number(env[`${configPrefix}_CONN_LIMIT`]) : Number.POSITIVE_INFINITY,
 			authentication: {
 				mode: "strict",
 				timeout: 0
@@ -56,9 +54,7 @@ var LogsController = class extends SocketController {
 		emitter_default.emitAction("websocket.connect", { client });
 	}
 	checkUserRequirements(accountability) {
-		if (!accountability?.admin) {
-			throw new WebSocketError("auth", "AUTH_FAILED", "Unauthorized access.");
-		}
+		if (!accountability?.admin) throw new WebSocketError("auth", "AUTH_FAILED", "Unauthorized access.");
 	}
 };
 

package/dist/websocket/errors.js

@@ -23,9 +23,7 @@ var WebSocketError = class WebSocketError extends Error {
 				message: this.message
 			}
 		};
-		if (this.uid !== undefined) {
-			message.uid = this.uid;
-		}
+		if (this.uid !== void 0) message.uid = this.uid;
 		return message;
 	}
 	toMessage() {
@@ -35,8 +33,7 @@ var WebSocketError = class WebSocketError extends Error {
 		return new WebSocketError(type, error.code, error.message);
 	}
 	static fromZodError(error, type = "unknown") {
-		const zError = fromZodError(error);
-		return new WebSocketError(type, "INVALID_PAYLOAD", zError.message);
+		return new WebSocketError(type, "INVALID_PAYLOAD", fromZodError(error).message);
 	}
 };
 function handleWebSocketError(client, error, type) {

package/dist/websocket/handlers/heartbeat.js

@@ -14,12 +14,10 @@ var HeartbeatHandler = class {
 	controller;
 	constructor(controller) {
 		controller = controller ?? getWebSocketController();
-		if (!controller) {
-			throw new ServiceUnavailableError({
-				service: "ws",
-				reason: "WebSocket server is not initialized"
-			});
-		}
+		if (!controller) throw new ServiceUnavailableError({
+			service: "ws",
+			reason: "WebSocket server is not initialized"
+		});
 		this.controller = controller;
 		emitter_default.onAction("websocket.message", ({ client, message }) => {
 			try {
@@ -34,14 +32,12 @@ var HeartbeatHandler = class {
 	}
 	checkClients() {
 		const hasClients = this.controller.clients.size > 0;
-		if (hasClients && !this.pulse) {
-			this.pulse = setInterval(() => {
-				this.pingClients();
-			}, HEARTBEAT_FREQUENCY);
-		}
+		if (hasClients && !this.pulse) this.pulse = setInterval(() => {
+			this.pingClients();
+		}, HEARTBEAT_FREQUENCY);
 		if (!hasClients && this.pulse) {
 			clearInterval(this.pulse);
-			this.pulse = undefined;
+			this.pulse = void 0;
 		}
 	}
 	onMessage(client, message) {
@@ -51,11 +47,9 @@ var HeartbeatHandler = class {
 	}
 	pingClients() {
 		const pendingClients = new Set(this.controller.clients);
-		const activeClients = new Set();
+		const activeClients = /* @__PURE__ */ new Set();
 		const timeout = setTimeout(() => {
-			for (const client of pendingClients) {
-				client.close();
-			}
+			for (const client of pendingClients) client.close();
 		}, HEARTBEAT_FREQUENCY);
 		const messageWatcher = ({ client }) => {
 			if (!activeClients.has(client)) {
@@ -68,9 +62,7 @@ var HeartbeatHandler = class {
 			}
 		};
 		emitter_default.onAction("websocket.message", messageWatcher);
-		for (const client of pendingClients) {
-			client.send(fmtMessage("ping"));
-		}
+		for (const client of pendingClients) client.send(fmtMessage("ping"));
 	}
 };
 

package/dist/websocket/handlers/index.js

@@ -15,21 +15,11 @@ function startWebSocketHandlers() {
 	const graphqlEnabled = toBoolean(env["WEBSOCKETS_GRAPHQL_ENABLED"]);
 	const logsEnabled = toBoolean(env["WEBSOCKETS_LOGS_ENABLED"]);
 	const collabEnabled = toBoolean(env["WEBSOCKETS_COLLAB_ENABLED"]);
-	if (restEnabled && heartbeatEnabled) {
-		new HeartbeatHandler();
-	}
-	if (restEnabled || graphqlEnabled) {
-		new ItemsHandler();
-	}
-	if (restEnabled) {
-		new SubscribeHandler();
-	}
-	if (logsEnabled) {
-		new LogsHandler();
-	}
-	if (collabEnabled) {
-		collabHandler = new CollabHandler();
-	}
+	if (restEnabled && heartbeatEnabled) new HeartbeatHandler();
+	if (restEnabled || graphqlEnabled) new ItemsHandler();
+	if (restEnabled) new SubscribeHandler();
+	if (logsEnabled) new LogsHandler();
+	if (collabEnabled) collabHandler = new CollabHandler();
 }
 function getCollabHandler() {
 	return collabHandler;

package/dist/websocket/handlers/items.js

@@ -28,9 +28,7 @@ var ItemsHandler = class {
 		const uid = message.uid;
 		const accountability = client.accountability;
 		const schema = await getSchema();
-		if (!schema.collections[message.collection] || isSystemCollection(message.collection)) {
-			throw new WebSocketError("items", "INVALID_COLLECTION", "The provided collection does not exists or is not accessible.", uid);
-		}
+		if (!schema.collections[message.collection] || isSystemCollection(message.collection)) throw new WebSocketError("items", "INVALID_COLLECTION", "The provided collection does not exists or is not accessible.", uid);
 		const isSingleton = !!schema.collections[message.collection]?.singleton;
 		const service = new ItemsService(message.collection, {
 			schema,
@@ -53,15 +51,10 @@ var ItemsHandler = class {
 		}
 		if (message.action === "read") {
 			const query = await sanitizeQuery(message.query ?? {}, schema, accountability);
-			if (message.id) {
-				result = await service.readOne(message.id, query);
-			} else if (message.ids) {
-				result = await service.readMany(message.ids, query);
-			} else if (isSingleton) {
-				result = await service.readSingleton(query);
-			} else {
-				result = await service.readByQuery(query);
-			}
+			if (message.id) result = await service.readOne(message.id, query);
+			else if (message.ids) result = await service.readMany(message.ids, query);
+			else if (isSingleton) result = await service.readSingleton(query);
+			else result = await service.readByQuery(query);
 			meta = await metaService.getMetaForQuery(message.collection, query);
 		}
 		if (message.action === "update") {
@@ -86,20 +79,16 @@ var ItemsHandler = class {
 				result = await service.readMany(keys, query);
 			}
 		}
-		if (message.action === "delete") {
-			if (message.id) {
-				await service.deleteOne(message.id);
-				result = message.id;
-			} else if (message.ids) {
-				await service.deleteMany(message.ids);
-				result = message.ids;
-			} else if (message.query) {
-				const query = await sanitizeQuery(message.query, schema, accountability);
-				result = await service.deleteByQuery(query);
-			} else {
-				throw new WebSocketError("items", "INVALID_PAYLOAD", "Either 'ids', 'id' or 'query' is required for a DELETE request.", uid);
-			}
-		}
+		if (message.action === "delete") if (message.id) {
+			await service.deleteOne(message.id);
+			result = message.id;
+		} else if (message.ids) {
+			await service.deleteMany(message.ids);
+			result = message.ids;
+		} else if (message.query) {
+			const query = await sanitizeQuery(message.query, schema, accountability);
+			result = await service.deleteByQuery(query);
+		} else throw new WebSocketError("items", "INVALID_PAYLOAD", "Either 'ids', 'id' or 'query' is required for a DELETE request.", uid);
 		client.send(fmtMessage("items", {
 			data: result,
 			...meta ? { meta } : {}

package/dist/websocket/handlers/logs.js

@@ -19,27 +19,23 @@ var LogsHandler = class {
 	subscriptions;
 	constructor(controller) {
 		controller = controller ?? getLogsController();
-		if (!controller) {
-			throw new ServiceUnavailableError({
-				service: "ws",
-				reason: "WebSocket server is not initialized"
-			});
-		}
+		if (!controller) throw new ServiceUnavailableError({
+			service: "ws",
+			reason: "WebSocket server is not initialized"
+		});
 		this.controller = controller;
 		this.messenger = useBus();
 		this.availableLogLevels = Object.keys(logger.levels.values);
 		this.logLevelValueMap = Object.fromEntries(Object.entries(logger.levels.values).map(([key, value]) => [value, key]));
 		this.subscriptions = this.availableLogLevels.reduce((acc, logLevel) => {
-			acc[logLevel] = new Set();
+			acc[logLevel] = /* @__PURE__ */ new Set();
 			return acc;
 		}, {});
 		this.bindWebSocket();
 		this.messenger.subscribe("logs", (message) => {
 			const { log, nodeId } = JSON.parse(message);
 			const logLevel = this.logLevelValueMap[log["level"]];
-			if (logLevel) {
-				this.subscriptions[logLevel]?.forEach((subscription) => subscription.send(fmtMessage("logs", { data: log }, nodeId)));
-			}
+			if (logLevel) this.subscriptions[logLevel]?.forEach((subscription) => subscription.send(fmtMessage("logs", { data: log }, nodeId)));
 		});
 	}
 	/**
@@ -72,49 +68,36 @@ var LogsHandler = class {
 		} catch (error) {
 			throw new WebSocketError("logs", ErrorCode.InvalidPayload, error.message);
 		}
-		for (const availableLogLevel of this.availableLogLevels) {
-			if (allowedLogLevelNames.includes(availableLogLevel)) {
-				this.subscriptions[availableLogLevel]?.add(client);
-			} else {
-				this.subscriptions[availableLogLevel]?.delete(client);
-			}
-		}
+		for (const availableLogLevel of this.availableLogLevels) if (allowedLogLevelNames.includes(availableLogLevel)) this.subscriptions[availableLogLevel]?.add(client);
+		else this.subscriptions[availableLogLevel]?.delete(client);
 	}
 	/**
 	* Remove a logs subscription
 	* @param client WebSocketClient
 	*/
 	unsubscribe(client) {
-		for (const availableLogLevel of this.availableLogLevels) {
-			this.subscriptions[availableLogLevel]?.delete(client);
-		}
+		for (const availableLogLevel of this.availableLogLevels) this.subscriptions[availableLogLevel]?.delete(client);
 	}
 	/**
 	* Handle incoming (un)subscribe requests
 	*/
 	async onMessage(client, message) {
-		const accountability = client.accountability;
-		if (!accountability?.admin) {
-			throw new WebSocketError("logs", ErrorCode.Forbidden, `You don't have permission to access this.`);
+		if (!client.accountability?.admin) throw new WebSocketError("logs", ErrorCode.Forbidden, `You don't have permission to access this.`);
+		if (message.type === "subscribe") try {
+			const logLevel = message.log_level;
+			this.subscribe(logLevel, client);
+			client.send(fmtMessage("logs", {
+				event: "subscribe",
+				log_level: logLevel
+			}));
+		} catch (err) {
+			handleWebSocketError(client, err, "subscribe");
 		}
-		if (message.type === "subscribe") {
-			try {
-				const logLevel = message.log_level;
-				this.subscribe(logLevel, client);
-				client.send(fmtMessage("logs", {
-					event: "subscribe",
-					log_level: logLevel
-				}));
-			} catch (err) {
-				handleWebSocketError(client, err, "subscribe");
-			}
-		} else if (message.type === "unsubscribe") {
-			try {
-				this.unsubscribe(client);
-				client.send(fmtMessage("logs", { event: "unsubscribe" }));
-			} catch (err) {
-				handleWebSocketError(client, err, "unsubscribe");
-			}
+		else if (message.type === "unsubscribe") try {
+			this.unsubscribe(client);
+			client.send(fmtMessage("logs", { event: "unsubscribe" }));
+		} catch (err) {
+			handleWebSocketError(client, err, "unsubscribe");
 		}
 	}
 };