@directus/api 35.0.2 → 35.1.0

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");
 		}
 	}
 };

package/dist/websocket/handlers/subscribe.js

@@ -51,12 +51,8 @@ var SubscribeHandler = class {
 	*/
 	subscribe(subscription) {
 		const { collection } = subscription;
-		if ("item" in subscription && ["directus_fields", "directus_relations"].includes(collection)) {
-			throw new InvalidPayloadError({ reason: `Cannot subscribe to a specific item in the ${collection} collection.` });
-		}
-		if (!this.subscriptions[collection]) {
-			this.subscriptions[collection] = new Set();
-		}
+		if ("item" in subscription && ["directus_fields", "directus_relations"].includes(collection)) throw new InvalidPayloadError({ reason: `Cannot subscribe to a specific item in the ${collection} collection.` });
+		if (!this.subscriptions[collection]) this.subscriptions[collection] = /* @__PURE__ */ new Set();
 		this.subscriptions[collection]?.add(subscription);
 	}
 	/**
@@ -64,21 +60,15 @@ var SubscribeHandler = class {
 	* @param subscription
 	*/
 	unsubscribe(client, uid) {
-		if (uid !== undefined) {
+		if (uid !== void 0) {
 			const subscription = this.getSubscription(client, String(uid));
-			if (subscription) {
-				this.subscriptions[subscription.collection]?.delete(subscription);
-			}
-		} else {
-			for (const key of Object.keys(this.subscriptions)) {
-				const subscriptions = Array.from(this.subscriptions[key] || []);
-				for (let i = subscriptions.length - 1; i >= 0; i--) {
-					const subscription = subscriptions[i];
-					if (!subscription) continue;
-					if (subscription.client === client && (!uid || subscription.uid === uid)) {
-						this.subscriptions[key]?.delete(subscription);
-					}
-				}
+			if (subscription) this.subscriptions[subscription.collection]?.delete(subscription);
+		} else for (const key of Object.keys(this.subscriptions)) {
+			const subscriptions = Array.from(this.subscriptions[key] || []);
+			for (let i = subscriptions.length - 1; i >= 0; i--) {
+				const subscription = subscriptions[i];
+				if (!subscription) continue;
+				if (subscription.client === client && (!uid || subscription.uid === uid)) this.subscriptions[key]?.delete(subscription);
 			}
 		}
 	}
@@ -91,9 +81,7 @@ var SubscribeHandler = class {
 		const schema = await getSchema();
 		for (const subscription of subscriptions) {
 			const { client } = subscription;
-			if (subscription.event !== undefined && event.action !== subscription.event) {
-				continue;
-			}
+			if (subscription.event !== void 0 && event.action !== subscription.event) continue;
 			if ("item" in subscription) {
 				if ("keys" in event && !event.keys.includes(subscription.item)) continue;
 				if ("key" in event && event.key !== subscription.item) continue;
@@ -111,54 +99,37 @@ var SubscribeHandler = class {
 	* Handle incoming (un)subscribe requests
 	*/
 	async onMessage(client, message) {
-		if (getMessageType(message) === "subscribe") {
-			try {
-				const collection = String(message.collection);
-				const accountability = client.accountability;
-				const schema = await getSchema();
-				if (!accountability?.admin && !schema.collections[collection]) {
-					throw new WebSocketError("subscribe", "INVALID_COLLECTION", "The provided collection does not exists or is not accessible.", message.uid);
-				}
-				const subscription = {
-					client,
-					collection
-				};
-				if ("event" in message) {
-					subscription.event = message.event;
-				}
-				if (message.query) {
-					subscription.query = await sanitizeQuery(message.query, schema, accountability);
-				}
-				if ("item" in message) subscription.item = String(message.item);
-				if ("uid" in message) {
-					subscription.uid = String(message.uid);
-					this.unsubscribe(client, subscription.uid);
-				}
-				const data = subscription.event === undefined ? await getPayload(subscription, accountability, schema) : { event: "init" };
-				this.subscribe(subscription);
-				client.send(fmtMessage("subscription", data, subscription.uid));
-			} catch (err) {
-				handleWebSocketError(client, err, "subscribe");
+		if (getMessageType(message) === "subscribe") try {
+			const collection = String(message.collection);
+			const accountability = client.accountability;
+			const schema = await getSchema();
+			if (!accountability?.admin && !schema.collections[collection]) throw new WebSocketError("subscribe", "INVALID_COLLECTION", "The provided collection does not exists or is not accessible.", message.uid);
+			const subscription = {
+				client,
+				collection
+			};
+			if ("event" in message) subscription.event = message.event;
+			if (message.query) subscription.query = await sanitizeQuery(message.query, schema, accountability);
+			if ("item" in message) subscription.item = String(message.item);
+			if ("uid" in message) {
+				subscription.uid = String(message.uid);
+				this.unsubscribe(client, subscription.uid);
 			}
+			const data = subscription.event === void 0 ? await getPayload(subscription, accountability, schema) : { event: "init" };
+			this.subscribe(subscription);
+			client.send(fmtMessage("subscription", data, subscription.uid));
+		} catch (err) {
+			handleWebSocketError(client, err, "subscribe");
 		}
-		if (getMessageType(message) === "unsubscribe") {
-			try {
-				this.unsubscribe(client, message.uid);
-				client.send(fmtMessage("subscription", { event: "unsubscribe" }, message.uid));
-			} catch (err) {
-				handleWebSocketError(client, err, "unsubscribe");
-			}
+		if (getMessageType(message) === "unsubscribe") try {
+			this.unsubscribe(client, message.uid);
+			client.send(fmtMessage("subscription", { event: "unsubscribe" }, message.uid));
+		} catch (err) {
+			handleWebSocketError(client, err, "unsubscribe");
 		}
 	}
 	getSubscription(client, uid) {
-		for (const userSubscriptions of Object.values(this.subscriptions)) {
-			for (const subscription of userSubscriptions) {
-				if (subscription.client === client && subscription.uid === uid) {
-					return subscription;
-				}
-			}
-		}
-		return undefined;
+		for (const userSubscriptions of Object.values(this.subscriptions)) for (const subscription of userSubscriptions) if (subscription.client === client && subscription.uid === uid) return subscription;
 	}
 };
 

package/dist/websocket/utils/get-expires-at-for-token.js

@@ -3,9 +3,7 @@ import jwt from "jsonwebtoken";
 //#region src/websocket/utils/get-expires-at-for-token.ts
 function getExpiresAtForToken(token) {
 	const decoded = jwt.decode(token);
-	if (decoded && typeof decoded === "object" && decoded.exp) {
-		return decoded.exp;
-	}
+	if (decoded && typeof decoded === "object" && decoded.exp) return decoded.exp;
 	return null;
 }
 

package/dist/websocket/utils/items.js

@@ -37,9 +37,7 @@ async function getPayload(subscription, accountability, schema, event) {
 			break;
 	}
 	const query = subscription.query ?? {};
-	if ("meta" in query) {
-		result["meta"] = await metaService.getMetaForQuery(subscription.collection, query);
-	}
+	if ("meta" in query) result["meta"] = await metaService.getMetaForQuery(subscription.collection, query);
 	return result;
 }
 /**
@@ -55,18 +53,13 @@ async function getCollectionPayload(subscription, accountability, schema, event)
 		schema,
 		accountability
 	});
-	if ("item" in subscription) {
-		if (event?.action === "delete") {
-			return subscription.item;
-		} else {
-			return await service.readOne(String(subscription.item));
-		}
-	}
+	if ("item" in subscription) if (event?.action === "delete") return subscription.item;
+	else return await service.readOne(String(subscription.item));
 	switch (event?.action) {
 		case "create": return await service.readMany([String(event.key)]);
 		case "update": return await service.readMany(event.keys.map((key) => String(key)));
 		case "delete": return event.keys;
-		case undefined:
+		case void 0:
 		default: return await service.readByQuery();
 	}
 }
@@ -83,15 +76,10 @@ async function getFieldsPayload(subscription, accountability, schema, event) {
 		schema,
 		accountability
 	});
-	if ("item" in subscription) {
-		if (event?.action === "delete") {
-			return subscription.item;
-		} else {
-			return await service.readOne(subscription.collection, String(subscription.item));
-		}
-	}
+	if ("item" in subscription) if (event?.action === "delete") return subscription.item;
+	else return await service.readOne(subscription.collection, String(subscription.item));
 	switch (event?.action) {
-		case undefined: return await service.readAll();
+		case void 0: return await service.readAll();
 		case "delete": return event.keys;
 		default: return await service.readOne(event?.payload?.["collection"], event?.payload?.["field"]);
 	}
@@ -111,18 +99,13 @@ async function getItemsPayload(subscription, accountability, schema, event) {
 		schema,
 		accountability
 	});
-	if ("item" in subscription) {
-		if (event?.action === "delete") {
-			return subscription.item;
-		} else {
-			return await service.readOne(subscription.item, query);
-		}
-	}
+	if ("item" in subscription) if (event?.action === "delete") return subscription.item;
+	else return await service.readOne(subscription.item, query);
 	switch (event?.action) {
 		case "create": return await service.readMany([event.key], query);
 		case "update": return await service.readMany(event.keys, query);
 		case "delete": return event.keys;
-		case undefined:
+		case void 0:
 		default: return await service.readByQuery(query);
 	}
 }

package/dist/websocket/utils/message.js

@@ -4,20 +4,16 @@ const fmtMessage = (type, data = {}, uid) => {
 		type,
 		...data
 	};
-	if (uid !== undefined) {
-		message["uid"] = uid;
-	}
+	if (uid !== void 0) message["uid"] = uid;
 	return JSON.stringify(message);
 };
 const safeSend = async (client, data, delay = 100) => {
 	if (client.readyState !== client.OPEN) return false;
-	if (client.bufferedAmount > 0) {
-		return new Promise((resolve) => {
-			setTimeout(() => {
-				safeSend(client, data, delay).then((success) => resolve(success));
-			}, delay);
-		});
-	}
+	if (client.bufferedAmount > 0) return new Promise((resolve) => {
+		setTimeout(() => {
+			safeSend(client, data, delay).then((success) => resolve(success));
+		}, delay);
+	});
 	client.send(data);
 	return true;
 };