@directus/api 35.0.2 → 35.1.0

package/dist/utils/verify-session-jwt.js

@@ -8,15 +8,11 @@ import { InvalidCredentialsError } from "@directus/errors";
 * @throws If session not found.
 */
 async function verifySessionJWT(payload) {
-	const database = database_default();
-	const session = await database.select(1).from("directus_sessions").where({
+	if (!await database_default().select(1).from("directus_sessions").where({
 		token: payload["session"],
 		user: payload["id"] || null,
 		share: payload["share"] || null
-	}).andWhere("expires", ">=", new Date()).first();
-	if (!session) {
-		throw new InvalidCredentialsError();
-	}
+	}).andWhere("expires", ">=", /* @__PURE__ */ new Date()).first()) throw new InvalidCredentialsError();
 }
 
 //#endregion

package/dist/utils/versioning/handle-version.js

@@ -9,15 +9,12 @@ async function handleVersion(self, key, queryWithKey, opts) {
 	const { ItemsService } = await import("../../services/items.js");
 	if (queryWithKey.versionRaw) {
 		const originalData = await self.readByQuery(queryWithKey, opts);
-		if (originalData.length === 0) {
-			throw new ForbiddenError();
-		}
-		const versionsService$1 = new VersionsService({
+		if (originalData.length === 0) throw new ForbiddenError();
+		const version$1 = await new VersionsService({
 			schema: self.schema,
 			accountability: self.accountability,
 			knex: self.knex
-		});
-		const version$1 = await versionsService$1.getVersionSave(queryWithKey.version, self.collection, key);
+		}).getVersionSave(queryWithKey.version, self.collection, key);
 		return Object.assign(originalData[0], version$1?.delta);
 	}
 	let result;
@@ -28,9 +25,7 @@ async function handleVersion(self, key, queryWithKey, opts) {
 	});
 	const createdIDs = {};
 	const version = await versionsService.getVersionSave(queryWithKey.version, self.collection, key, false);
-	if (!version) {
-		throw new ForbiddenError();
-	}
+	if (!version) throw new ForbiddenError();
 	const { delta } = version;
 	await transaction(self.knex, async (trx) => {
 		const itemsServiceAdmin = new ItemsService(self.collection, {
@@ -51,40 +46,26 @@ async function handleVersion(self, key, queryWithKey, opts) {
 				}
 			});
 		}
-		const itemsServiceUser = new ItemsService(self.collection, {
+		result = (await new ItemsService(self.collection, {
 			schema: self.schema,
 			accountability: self.accountability,
 			knex: trx
-		});
-		result = (await itemsServiceUser.readByQuery(queryWithKey, opts))[0];
+		}).readByQuery(queryWithKey, opts))[0];
 		await trx.rollback();
 	});
-	if (!result) {
-		throw new ForbiddenError();
-	}
+	if (!result) throw new ForbiddenError();
 	return deepMapWithSchema(result, ([key$1, value], context) => {
 		if (context.relationType === "m2o" || context.relationType === "a2o") {
-			const ids = createdIDs[context.relation.related_collection];
-			const match = ids?.find((id) => String(id) === String(value));
-			if (match) {
-				return [key$1, null];
-			}
+			if (createdIDs[context.relation.related_collection]?.find((id) => String(id) === String(value))) return [key$1, null];
 		} else if (context.relationType === "o2m" && Array.isArray(value)) {
 			const ids = createdIDs[context.relation.collection];
 			return [key$1, value.map((val) => {
-				const match = ids?.find((id) => String(id) === String(val));
-				if (match) {
-					return null;
-				}
+				if (ids?.find((id) => String(id) === String(val))) return null;
 				return val;
 			})];
 		}
 		if (context.field.field === context.collection.primary) {
-			const ids = createdIDs[context.collection.collection];
-			const match = ids?.find((id) => String(id) === String(value));
-			if (match) {
-				return [key$1, null];
-			}
+			if (createdIDs[context.collection.collection]?.find((id) => String(id) === String(value))) return [key$1, null];
 		}
 		return [key$1, value];
 	}, {

package/dist/utils/versioning/merge-version-data.js

@@ -3,11 +3,7 @@ import { cloneDeep } from "lodash-es";
 //#region src/utils/versioning/merge-version-data.ts
 function mergeVersionsRaw(item, versionData) {
 	const result = cloneDeep(item);
-	for (const versionRecord of versionData) {
-		for (const key of Object.keys(versionRecord)) {
-			result[key] = versionRecord[key];
-		}
-	}
+	for (const versionRecord of versionData) for (const key of Object.keys(versionRecord)) result[key] = versionRecord[key];
 	return result;
 }
 

package/dist/utils/versioning/split-recursive.js

@@ -12,6 +12,10 @@ function splitRecursive(object) {
 			const { rawDelta, defaultOverwrites: innerDefaultOverwrites } = splitRecursive(rest[key]);
 			rest[key] = rawDelta;
 			if (innerDefaultOverwrites) defaultOverwrites[key] = innerDefaultOverwrites;
+			else if (Array.isArray(rest[key]) && _user !== void 0 && _date !== void 0) defaultOverwrites[key] = {
+				_user,
+				_date
+			};
 		}
 		return {
 			rawDelta: rest,
@@ -25,15 +29,14 @@ function splitRecursive(object) {
 			rest[key] = rawDelta;
 			if (innerDefaultOverwrites) defaultOverwrites[key] = innerDefaultOverwrites;
 		}
-		object.map((value) => splitRecursive(value));
 		return {
 			rawDelta: rest,
-			defaultOverwrites
+			defaultOverwrites: defaultOverwrites.length > 0 ? defaultOverwrites : void 0
 		};
 	}
 	return {
 		rawDelta: object,
-		defaultOverwrites: undefined
+		defaultOverwrites: void 0
 	};
 }
 

package/dist/websocket/authenticate.js

@@ -15,20 +15,16 @@ async function authenticateConnection(message, accountabilityOverrides) {
 	let access_token, refresh_token;
 	try {
 		if ("email" in message && "password" in message) {
-			const authenticationService = new AuthenticationService({ schema: await getSchema() });
-			const { accessToken, refreshToken } = await authenticationService.login(DEFAULT_AUTH_PROVIDER, message);
+			const { accessToken, refreshToken } = await new AuthenticationService({ schema: await getSchema() }).login(DEFAULT_AUTH_PROVIDER, message);
 			access_token = accessToken;
 			refresh_token = refreshToken;
 		}
 		if ("refresh_token" in message) {
-			const authenticationService = new AuthenticationService({ schema: await getSchema() });
-			const { accessToken, refreshToken } = await authenticationService.refresh(message.refresh_token);
+			const { accessToken, refreshToken } = await new AuthenticationService({ schema: await getSchema() }).refresh(message.refresh_token);
 			access_token = accessToken;
 			refresh_token = refreshToken;
 		}
-		if ("access_token" in message) {
-			access_token = message.access_token;
-		}
+		if ("access_token" in message) access_token = message.access_token;
 		if (!access_token) throw new Error();
 		const defaultAccountability = createDefaultAccountability(accountabilityOverrides);
 		const authenticationState = {
@@ -41,11 +37,8 @@ async function authenticateConnection(message, accountabilityOverrides) {
 			schema: null,
 			accountability: null
 		});
-		if (customAccountability && isEqual(customAccountability, defaultAccountability) === false) {
-			authenticationState.accountability = customAccountability;
-		} else {
-			authenticationState.accountability = await getAccountabilityForToken(access_token, defaultAccountability);
-		}
+		if (customAccountability && isEqual(customAccountability, defaultAccountability) === false) authenticationState.accountability = customAccountability;
+		else authenticationState.accountability = await getAccountabilityForToken(access_token, defaultAccountability);
 		return authenticationState;
 	} catch {
 		throw new WebSocketError("auth", "AUTH_FAILED", "Authentication failed.", message["uid"]);
@@ -56,12 +49,8 @@ function authenticationSuccess(uid, refresh_token) {
 		type: "auth",
 		status: "ok"
 	};
-	if (uid !== undefined) {
-		message.uid = uid;
-	}
-	if (refresh_token !== undefined) {
-		message["refresh_token"] = refresh_token;
-	}
+	if (uid !== void 0) message.uid = uid;
+	if (refresh_token !== void 0) message["refresh_token"] = refresh_token;
 	return JSON.stringify(message);
 }
 

package/dist/websocket/collab/calculate-cache-metadata.js

@@ -13,51 +13,41 @@ const DYNAMIC_VARIABLE_MAP = {
 */
 function calculateCacheMetadata(collection, itemData, rawPermissions, schema, accountability) {
 	let ttlMs;
-	const dependencies = new Set();
+	const dependencies = /* @__PURE__ */ new Set();
 	if (itemData) {
 		const now = Date.now();
 		let closestExpiry = Infinity;
 		const scan = (val, fieldKey, currentCollection = collection) => {
 			if (!val || typeof val !== "object") return;
 			for (const [key, value] of Object.entries(val)) {
-				if (typeof value === "string" && value.startsWith("$")) {
-					if (value.startsWith("$NOW")) {
-						const field$1 = fieldKey || key;
-						const dateValue = itemData[field$1];
-						if (dateValue) {
-							let ruleDate = new Date();
-							if (value.includes("(")) {
-								const adjustment = value.match(REGEX_BETWEEN_PARENS)?.[1];
-								if (adjustment) ruleDate = adjustDate(ruleDate, adjustment) || ruleDate;
-							}
-							const adjustmentMs = ruleDate.getTime() - now;
-							const expiry = new Date(dateValue).getTime() - adjustmentMs;
-							if (expiry > now && expiry < closestExpiry) {
-								closestExpiry = expiry;
-							}
+				if (typeof value === "string" && value.startsWith("$")) if (value.startsWith("$NOW")) {
+					const dateValue = itemData[fieldKey || key];
+					if (dateValue) {
+						let ruleDate = /* @__PURE__ */ new Date();
+						if (value.includes("(")) {
+							const adjustment = value.match(REGEX_BETWEEN_PARENS)?.[1];
+							if (adjustment) ruleDate = adjustDate(ruleDate, adjustment) || ruleDate;
 						}
-					} else {
-						const parts = value.split(".");
-						const dynamicVariable = parts[0];
-						const rootCollection = DYNAMIC_VARIABLE_MAP[dynamicVariable];
-						if (rootCollection) {
-							if (dynamicVariable === "$CURRENT_USER" && accountability.user) {
-								dependencies.add(`${rootCollection}:${accountability.user}`);
-							} else {
-								dependencies.add(rootCollection);
-							}
-							if (parts.length > 1) {
-								let currentCollection$1 = rootCollection;
-								for (const segment of parts.slice(1, -1)) {
-									if (!currentCollection$1) break;
-									const relation = schema.relations.find((r) => r.collection === currentCollection$1 && r.field === segment || r.related_collection === currentCollection$1 && r.meta?.one_field === segment);
-									if (relation) {
-										currentCollection$1 = relation.collection === currentCollection$1 ? relation.related_collection : relation.collection;
-										if (currentCollection$1) dependencies.add(currentCollection$1);
-									} else {
-										currentCollection$1 = null;
-									}
-								}
+						const adjustmentMs = ruleDate.getTime() - now;
+						const expiry = new Date(dateValue).getTime() - adjustmentMs;
+						if (expiry > now && expiry < closestExpiry) closestExpiry = expiry;
+					}
+				} else {
+					const parts = value.split(".");
+					const dynamicVariable = parts[0];
+					const rootCollection = DYNAMIC_VARIABLE_MAP[dynamicVariable];
+					if (rootCollection) {
+						if (dynamicVariable === "$CURRENT_USER" && accountability.user) dependencies.add(`${rootCollection}:${accountability.user}`);
+						else dependencies.add(rootCollection);
+						if (parts.length > 1) {
+							let currentCollection$1 = rootCollection;
+							for (const segment of parts.slice(1, -1)) {
+								if (!currentCollection$1) break;
+								const relation = schema.relations.find((r) => r.collection === currentCollection$1 && r.field === segment || r.related_collection === currentCollection$1 && r.meta?.one_field === segment);
+								if (relation) {
+									currentCollection$1 = relation.collection === currentCollection$1 ? relation.related_collection : relation.collection;
+									if (currentCollection$1) dependencies.add(currentCollection$1);
+								} else currentCollection$1 = null;
 							}
 						}
 					}
@@ -70,23 +60,15 @@ function calculateCacheMetadata(collection, itemData, rawPermissions, schema, ac
 				if (!field.startsWith("_")) {
 					const relation = schema.relations.find((r) => r.collection === currentCollection && r.field === field || r.related_collection === currentCollection && r.meta?.one_field === field);
 					let targetCol = null;
-					if (relation) {
-						targetCol = relation.collection === currentCollection ? relation.related_collection : relation.collection;
-					}
+					if (relation) targetCol = relation.collection === currentCollection ? relation.related_collection : relation.collection;
 					if (targetCol) {
 						dependencies.add(targetCol);
-						scan(value, undefined, targetCol);
-					} else {
-						scan(value, field.startsWith("_") ? fieldKey : field, currentCollection);
-					}
-				} else {
-					scan(value, fieldKey, currentCollection);
-				}
+						scan(value, void 0, targetCol);
+					} else scan(value, field.startsWith("_") ? fieldKey : field, currentCollection);
+				} else scan(value, fieldKey, currentCollection);
 			}
 		};
-		for (const permission of rawPermissions) {
-			scan(permission.permissions);
-		}
+		for (const permission of rawPermissions) scan(permission.permissions);
 		if (closestExpiry !== Infinity) {
 			ttlMs = closestExpiry - now;
 			ttlMs = Math.max(1e3, Math.min(ttlMs, 36e5));

package/dist/websocket/collab/collab.js

@@ -50,21 +50,15 @@ var CollabHandler = class {
 		if (this.initializePromise) return this.initializePromise;
 		this.initializePromise = (async () => {
 			try {
-				if (!this.settingsService) {
-					const schema = await getSchema();
-					this.settingsService = new SettingsService({ schema });
-				}
-				const settings = await this.settingsService.readSingleton({ fields: ["collaborative_editing_enabled"] });
-				this.enabled = settings?.["collaborative_editing_enabled"] ?? false;
+				if (!this.settingsService) this.settingsService = new SettingsService({ schema: await getSchema() });
+				this.enabled = (await this.settingsService.readSingleton({ fields: ["collaborative_editing_enabled"] }))?.["collaborative_editing_enabled"] ?? false;
 			} catch (err) {
 				useLogger().error(err, "[Collab] Failed to initialize collaborative editing settings");
 			} finally {
-				this.initializePromise = undefined;
+				this.initializePromise = void 0;
 			}
 		})();
-		if (!this.initialized) {
-			this.initialized = this.initializePromise;
-		}
+		if (!this.initialized) this.initialized = this.initializePromise;
 		return this.initializePromise;
 	}
 	bindWebSocket() {
@@ -82,36 +76,26 @@ var CollabHandler = class {
 				if (event.collection === "directus_settings" && event.action === "update" && "collaborative_editing_enabled" in event.payload) {
 					useLogger().debug(`[Collab] [Node ${this.messenger.uid}] Settings update via bus, triggering handler`);
 					this.initialize(true).then(() => {
-						if (!this.enabled) {
-							try {
-								useLogger().debug(`[Collab] [Node ${this.messenger.uid}] Collaborative editing disabled, terminating all rooms`);
-								this.roomManager.terminateAll();
-							} catch (err) {
-								useLogger().error(err, "[Collab] Collaborative editing disabling terminateAll failed");
-							}
+						if (!this.enabled) try {
+							useLogger().debug(`[Collab] [Node ${this.messenger.uid}] Collaborative editing disabled, terminating all rooms`);
+							this.roomManager.terminateAll();
+						} catch (err) {
+							useLogger().error(err, "[Collab] Collaborative editing disabling terminateAll failed");
 						}
 					}).catch((err) => {
 						useLogger().error(err, "[Collab] Collaborative editing re-initialization failed");
 					});
 					return;
 				}
-				if (event.action === "create" || IRRELEVANT_COLLECTIONS.includes(event.collection)) {
-					return;
-				}
+				if (event.action === "create" || IRRELEVANT_COLLECTIONS.includes(event.collection)) return;
 				if (event.action === "update" || event.action === "delete") {
 					let keys = [];
-					if (Array.isArray(event.keys)) {
-						keys = event.keys;
-					} else if (event.key) {
-						keys = [event.key];
-					} else if (event.payload && event.action === "delete") {
-						keys = toArray(event.payload);
-					}
+					if (Array.isArray(event.keys)) keys = event.keys;
+					else if (event.key) keys = [event.key];
+					else if (event.payload && event.action === "delete") keys = toArray(event.payload);
 					event.keys = keys;
 					const roomsToUpdate = Object.values(this.roomManager.rooms).filter((room) => {
-						if (room.version) {
-							return event.collection === "directus_versions" && keys.some((key) => String(key) === room.version);
-						}
+						if (room.version) return event.collection === "directus_versions" && keys.some((key) => String(key) === room.version);
 						if (room.collection !== event.collection || event.collection === "directus_versions") return false;
 						if (room.item === null) return true;
 						return keys.some((key) => String(key) === String(room.item));
@@ -119,22 +103,15 @@ var CollabHandler = class {
 					if (roomsToUpdate.length === 0) return;
 					await Promise.all(roomsToUpdate.map(async (room) => {
 						let relevantKeys;
-						if (room.version) {
-							relevantKeys = [room.version];
-						} else if (room.item) {
-							relevantKeys = [room.item];
-						} else {
-							relevantKeys = keys;
-						}
+						if (room.version) relevantKeys = [room.version];
+						else if (room.item) relevantKeys = [room.item];
+						else relevantKeys = keys;
 						const singleKeyedEvent = {
 							...event,
 							keys: relevantKeys
 						};
-						if (event.action === "delete") {
-							await room.onDeleteHandler(singleKeyedEvent);
-						} else {
-							await room.onUpdateHandler(singleKeyedEvent);
-						}
+						if (event.action === "delete") await room.onDeleteHandler(singleKeyedEvent);
+						else await room.onUpdateHandler(singleKeyedEvent);
 					}));
 				}
 			}).catch((err) => {
@@ -177,23 +154,18 @@ var CollabHandler = class {
 			for (const roomUid of inactive.rooms) {
 				const room = await this.roomManager.getRoom(roomUid);
 				if (room) {
-					for (const client of inactive.clients) {
-						if (await room.hasClient(client)) {
-							useLogger().debug(`[Collab] Removing dead client ${client} from room ${roomUid}`);
-							await room.leave(client);
-						}
-					}
-					if (await room.close()) {
-						this.roomManager.removeRoom(room.uid);
+					for (const client of inactive.clients) if (await room.hasClient(client)) {
+						useLogger().debug(`[Collab] Removing dead client ${client} from room ${roomUid}`);
+						await room.leave(client);
 					}
+					if (await room.close()) this.roomManager.removeRoom(room.uid);
 				}
 			}
 		});
 		this.cleanupInterval = setInterval(async () => {
 			try {
 				const globalClients = await this.messenger.getGlobalClients();
-				const localClients = (await this.roomManager.getLocalRoomClients()).map((client) => client.uid);
-				const invalidClients = difference(localClients, globalClients);
+				const invalidClients = difference((await this.roomManager.getLocalRoomClients()).map((client) => client.uid), globalClients);
 				for (const client of invalidClients) {
 					const rooms = await this.roomManager.getClientRooms(client);
 					for (const room of rooms) {
@@ -212,32 +184,24 @@ var CollabHandler = class {
 	*/
 	async terminate() {
 		await this.cleanupJob?.stop();
-		if (this.cleanupInterval) {
-			clearInterval(this.cleanupInterval);
-		}
-		if (this.busHandler) {
-			await this.messenger.messenger.unsubscribe("websocket.event", this.busHandler);
-		}
+		if (this.cleanupInterval) clearInterval(this.cleanupInterval);
+		if (this.busHandler) await this.messenger.messenger.unsubscribe("websocket.event", this.busHandler);
 	}
 	/**
 	* Ensure collaborative editing is enabled and initialized
 	*/
 	async ensureEnabled() {
 		await this.initialized;
-		if (!this.enabled) {
-			throw new ServiceUnavailableError({
-				reason: "Collaborative editing is disabled",
-				service: "collab"
-			});
-		}
+		if (!this.enabled) throw new ServiceUnavailableError({
+			reason: "Collaborative editing is disabled",
+			service: "collab"
+		});
 	}
 	/**
 	* Join a collaborative editing room
 	*/
 	async onJoin(client, message) {
-		if (client.accountability?.share) {
-			throw new ForbiddenError({ reason: "Collaborative editing is not supported for shares" });
-		}
+		if (client.accountability?.share) throw new ForbiddenError({ reason: "Collaborative editing is not supported for shares" });
 		const schema = await getSchema();
 		const db = database_default();
 		try {
@@ -266,15 +230,12 @@ var CollabHandler = class {
 		} catch {
 			throw new ForbiddenError({ reason: `No permission to access item or it does not exist` });
 		}
-		if (message.initialChanges) {
-			await validateChanges(message.initialChanges, message.collection, message.item, {
-				knex: db,
-				schema,
-				accountability: client.accountability
-			});
-		}
-		const room = await this.roomManager.createRoom(message.collection, message.item, message.version ?? null, message.initialChanges);
-		await room.join(client, message.color);
+		if (message.initialChanges) await validateChanges(message.initialChanges, message.collection, message.item, {
+			knex: db,
+			schema,
+			accountability: client.accountability
+		});
+		await (await this.roomManager.createRoom(message.collection, message.item, message.version ?? null, message.initialChanges)).join(client, message.color);
 	}
 	/**
 	* Leave a collaborative editing room
@@ -282,15 +243,11 @@ var CollabHandler = class {
 	async onLeave(client, message) {
 		if (message?.room) {
 			const room = await this.roomManager.getRoom(message.room);
-			if (!room || !await room.hasClient(client.uid)) {
-				throw new ForbiddenError({ reason: `No access to room "${message.room}" or it does not exist` });
-			}
+			if (!room || !await room.hasClient(client.uid)) throw new ForbiddenError({ reason: `No access to room "${message.room}" or it does not exist` });
 			await room.leave(client.uid);
 		} else {
 			const rooms = await this.roomManager.getClientRooms(client.uid);
-			for (const room of rooms) {
-				await room.leave(client.uid);
-			}
+			for (const room of rooms) await room.leave(client.uid);
 		}
 	}
 	/**
@@ -300,22 +257,18 @@ var CollabHandler = class {
 		const knex = database_default();
 		const schema = await getSchema();
 		const room = await this.roomManager.getRoom(message.room);
-		if (!room || !await room.hasClient(client.uid)) {
-			throw new ForbiddenError({ reason: `No access to room ${message.room} or room does not exist` });
-		}
+		if (!room || !await room.hasClient(client.uid)) throw new ForbiddenError({ reason: `No access to room ${message.room} or room does not exist` });
 		await this.checkFieldsAccess(client, room, message.field, "update", {
 			knex,
 			schema
 		});
 		let focus = await room.getFocusByUser(client.uid);
-		if (message.changes !== undefined) {
+		if (message.changes !== void 0) {
 			if (focus !== message.field) {
 				await room.focus(client, message.field);
 				focus = await room.getFocusByUser(client.uid);
 			}
-			if (!focus || focus !== message.field) {
-				throw new ForbiddenError({ reason: `Cannot update field ${message.field} without focusing on it first` });
-			}
+			if (!focus || focus !== message.field) throw new ForbiddenError({ reason: `Cannot update field ${message.field} without focusing on it first` });
 			await validateChanges({ [message.field]: message.changes }, room.collection, room.item, {
 				knex,
 				schema,
@@ -324,9 +277,7 @@ var CollabHandler = class {
 			await room.update(client, { [message.field]: message.changes });
 		} else {
 			const currentFocuser = await room.getFocusByField(message.field);
-			if (currentFocuser && currentFocuser !== client.uid) {
-				throw new ForbiddenError({ reason: `Field ${message.field} is already focused by another user` });
-			}
+			if (currentFocuser && currentFocuser !== client.uid) throw new ForbiddenError({ reason: `Field ${message.field} is already focused by another user` });
 			await room.unset(client, message.field);
 		}
 	}
@@ -343,9 +294,7 @@ var CollabHandler = class {
 		const fields = Object.keys(message.changes ?? {});
 		for (const key of fields) {
 			const focus = await room.getFocusByField(key);
-			if (focus && focus !== client.uid) {
-				delete message.changes?.[key];
-			}
+			if (focus && focus !== client.uid) delete message.changes?.[key];
 		}
 		if (!isEmpty(message.changes)) {
 			await validateChanges(message.changes, collection, room.item, {
@@ -362,27 +311,19 @@ var CollabHandler = class {
 	async onFocus(client, message) {
 		const room = await this.roomManager.getRoom(message.room);
 		if (!room || !await room.hasClient(client.uid)) throw new ForbiddenError({ reason: `No access to room ${message.room} or room does not exist` });
-		if (message.field) {
-			await this.checkFieldsAccess(client, room, message.field, "focus on");
-		}
-		if (!await room.focus(client, message.field ?? null)) {
-			throw new ForbiddenError({ reason: `Field ${message.field} is already focused by another user` });
-		}
+		if (message.field) await this.checkFieldsAccess(client, room, message.field, "focus on");
+		if (!await room.focus(client, message.field ?? null)) throw new ForbiddenError({ reason: `Field ${message.field} is already focused by another user` });
 	}
 	/**
 	* Discard specified changes in the room
 	*/
 	async onDiscard(client, message) {
 		const room = await this.roomManager.getRoom(message.room);
-		if (!room || !await room.hasClient(client.uid)) {
-			throw new ForbiddenError({ reason: `No access to room ${message.room} or room does not exist` });
-		}
+		if (!room || !await room.hasClient(client.uid)) throw new ForbiddenError({ reason: `No access to room ${message.room} or room does not exist` });
 		const knex = database_default();
 		const schema = await getSchema();
 		const allowedFields = await this.getAllowedFields(client, room, knex, schema);
-		if (!allowedFields || allowedFields.length === 0) {
-			throw new ForbiddenError({ reason: `No permission to discard fields or item does not exist` });
-		}
+		if (!allowedFields || allowedFields.length === 0) throw new ForbiddenError({ reason: `No permission to discard fields or item does not exist` });
 		await room.discard(allowedFields);
 	}
 	/**
@@ -393,12 +334,7 @@ var CollabHandler = class {
 		const schema = options.schema ?? await getSchema();
 		const allowedFields = await this.getAllowedFields(client, room, knex, schema);
 		const fieldsArray = Array.isArray(fields) ? fields : [fields];
-		for (const field of fieldsArray) {
-			const fieldExists = !!schema.collections[room.collection]?.fields[field];
-			if (!fieldExists || allowedFields && !isFieldAllowed(allowedFields, field)) {
-				throw new ForbiddenError({ reason: `No permission to ${errorAction} field ${field} or field does not exist` });
-			}
-		}
+		for (const field of fieldsArray) if (!!!schema.collections[room.collection]?.fields[field] || allowedFields && !isFieldAllowed(allowedFields, field)) throw new ForbiddenError({ reason: `No permission to ${errorAction} field ${field} or field does not exist` });
 	}
 	async getAllowedFields(client, room, knex, schema) {
 		const [read, update] = await Promise.all([verifyPermissions(client.accountability, room.collection, room.item, "read", {

package/dist/websocket/collab/filter-to-fields.js

@@ -2,12 +2,9 @@ import { deepMapFilter } from "@directus/utils";
 
 //#region src/websocket/collab/filter-to-fields.ts
 function filterToFields(filter, collection, schema) {
-	const fields = new Set();
+	const fields = /* @__PURE__ */ new Set();
 	deepMapFilter(filter, ([key, _value], context) => {
-		if (context.leaf && context.field) {
-			fields.add([...context.path, key].join("."));
-		}
-		return undefined;
+		if (context.leaf && context.field) fields.add([...context.path, key].join("."));
 	}, {
 		collection,
 		schema