@directus/api 35.0.2 → 35.2.0

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

package/dist/websocket/collab/messenger.js

@@ -43,19 +43,13 @@ var Messenger = class {
 				}
 			} else if (message.type === "error") {
 				const client = this.clients[message.client];
-				if (client) {
-					client.send(JSON.stringify(message.message));
-				}
-			} else if (message.type === "terminate") {
-				this.clients[message.client]?.close();
-			} else if (message.type === "room") {
-				this.roomListeners[message.room]?.(message);
-			} else if (message.type === "ping" && message.instance === this.uid) {
-				this.messenger.publish(COLLAB_BUS, {
-					type: "pong",
-					instance: this.uid
-				});
-			}
+				if (client) client.send(JSON.stringify(message.message));
+			} else if (message.type === "terminate") this.clients[message.client]?.close();
+			else if (message.type === "room") this.roomListeners[message.room]?.(message);
+			else if (message.type === "ping" && message.instance === this.uid) this.messenger.publish(COLLAB_BUS, {
+				type: "pong",
+				instance: this.uid
+			});
 		});
 	}
 	hasClient(client) {
@@ -133,17 +127,13 @@ var Messenger = class {
 		const inactiveInstances = new Set(Object.keys(instances));
 		inactiveInstances.delete(this.uid);
 		const pongCollector = (message) => {
-			if (message.type === "pong") {
-				inactiveInstances.delete(message.instance);
-			}
+			if (message.type === "pong") inactiveInstances.delete(message.instance);
 		};
 		this.messenger.subscribe(COLLAB_BUS, pongCollector);
-		for (const instance of inactiveInstances) {
-			this.messenger.publish(COLLAB_BUS, {
-				type: "ping",
-				instance
-			});
-		}
+		for (const instance of inactiveInstances) this.messenger.publish(COLLAB_BUS, {
+			type: "ping",
+			instance
+		});
 		await new Promise((resolve) => {
 			setTimeout(resolve, INSTANCE_TIMEOUT);
 		});
@@ -152,26 +142,20 @@ var Messenger = class {
 			clients: [],
 			rooms: []
 		};
-		if (inactiveInstances.size === 0) {
-			return {
-				inactive: dead,
-				active: Object.values(instances).map((instance) => instance.clients).flat()
-			};
-		}
+		if (inactiveInstances.size === 0) return {
+			inactive: dead,
+			active: Object.values(instances).map((instance) => instance.clients).flat()
+		};
 		const current = await this.store(async (store) => {
 			const current$1 = await store.get("instances");
 			let changed = false;
-			for (const deadId of inactiveInstances) {
-				if (current$1[deadId]) {
-					dead.clients.push(...current$1[deadId].clients ?? []);
-					dead.rooms.push(...current$1[deadId].rooms ?? []);
-					delete current$1[deadId];
-					changed = true;
-				}
-			}
-			if (changed) {
-				await store.set("instances", current$1);
+			for (const deadId of inactiveInstances) if (current$1[deadId]) {
+				dead.clients.push(...current$1[deadId].clients ?? []);
+				dead.rooms.push(...current$1[deadId].rooms ?? []);
+				delete current$1[deadId];
+				changed = true;
 			}
+			if (changed) await store.set("instances", current$1);
 			return current$1;
 		});
 		return {
@@ -195,50 +179,41 @@ var Messenger = class {
 				...message,
 				order
 			}));
-		} else {
-			this.messenger.publish(COLLAB_BUS, {
-				type: "send",
-				client,
-				message
-			});
-		}
+		} else this.messenger.publish(COLLAB_BUS, {
+			type: "send",
+			client,
+			message
+		});
 	}
 	terminateClient(client) {
 		const localClient = this.clients[client];
-		if (localClient) {
-			setTimeout(() => {
-				localClient.close();
-			}, 250);
-		} else {
-			this.messenger.publish(COLLAB_BUS, {
-				type: "terminate",
-				client
-			});
-		}
+		if (localClient) setTimeout(() => {
+			localClient.close();
+		}, 250);
+		else this.messenger.publish(COLLAB_BUS, {
+			type: "terminate",
+			client
+		});
 	}
 	sendError(client, error) {
 		const localClient = this.clients[client];
-		if (localClient) {
-			localClient.send(JSON.stringify(error));
-		} else {
-			this.messenger.publish(COLLAB_BUS, {
-				type: "error",
-				client,
-				message: error
-			});
-		}
+		if (localClient) localClient.send(JSON.stringify(error));
+		else this.messenger.publish(COLLAB_BUS, {
+			type: "error",
+			client,
+			message: error
+		});
 	}
 	handleError(client, error, action) {
 		let message;
-		if (isDirectusError(error)) {
-			message = {
-				action: "error",
-				type: TYPE.COLLAB,
-				code: error.code,
-				trigger: action,
-				message: error.message
-			};
-		} else {
+		if (isDirectusError(error)) message = {
+			action: "error",
+			type: TYPE.COLLAB,
+			code: error.code,
+			trigger: action,
+			message: error.message
+		};
+		else {
 			useLogger().error(`WebSocket unhandled exception ${JSON.stringify({
 				type: TYPE.COLLAB,
 				error

package/dist/websocket/collab/payload-permissions.js

@@ -27,7 +27,7 @@ async function sanitizePayload(payload, collection, context) {
 */
 async function processPermissions(payload, collection, context) {
 	const { direction, accountability, schema, knex, itemId } = context;
-	const permissionsCache = new Map();
+	const permissionsCache = /* @__PURE__ */ new Map();
 	const getPermissions = (col, id, action) => {
 		const cacheKey = `${col}:${id}:${action}`;
 		let cached = permissionsCache.get(cacheKey);
@@ -43,68 +43,44 @@ async function processPermissions(payload, collection, context) {
 	return deepMapWithSchema(payload, async (entry, deepMapContext) => {
 		const [key, value] = entry;
 		if (direction === "outbound") {
-			if (deepMapContext.field?.special?.some((v) => v === "conceal" || v === "hash" || v === "encrypt")) {
-				return undefined;
-			}
-			if (deepMapContext.leaf && !deepMapContext.relation && !deepMapContext.field) {
-				return undefined;
-			}
+			if (deepMapContext.field?.special?.some((v) => v === "conceal" || v === "hash" || v === "encrypt")) return;
+			if (deepMapContext.leaf && !deepMapContext.relation && !deepMapContext.field) return;
 		}
-		if (value === undefined) return undefined;
+		if (value === void 0) return void 0;
 		const currentCollection = deepMapContext.collection.collection;
 		const pkField = deepMapContext.collection.primary;
 		const primaryKeyInObject = deepMapContext.object[pkField] ?? null;
 		let action = direction === "inbound" ? "update" : "read";
 		let effectiveItemId = primaryKeyInObject;
 		if (direction === "inbound") {
-			const isTopLevel = deepMapContext.object === payload;
-			if (isTopLevel) {
+			if (deepMapContext.object === payload) {
 				effectiveItemId = itemId ?? null;
 				action = itemId ? "update" : "create";
-			} else if (!primaryKeyInObject) {
-				action = "create";
-			}
-			if (deepMapContext.action) {
-				action = deepMapContext.action;
-			}
-		} else {
-			if (deepMapContext.object === payload) {
-				effectiveItemId = primaryKeyInObject ?? itemId ?? null;
-			}
-		}
+			} else if (!primaryKeyInObject) action = "create";
+			if (deepMapContext.action) action = deepMapContext.action;
+		} else if (deepMapContext.object === payload) effectiveItemId = primaryKeyInObject ?? itemId ?? null;
 		if (direction === "inbound" && action === "delete") {
-			if (key !== pkField) {
-				throw new InvalidPayloadError({ reason: `Unexpected field ${key} in delete payload` });
-			}
+			if (key !== pkField) throw new InvalidPayloadError({ reason: `Unexpected field ${key} in delete payload` });
 			const allowed = await getPermissions(currentCollection, primaryKeyInObject, "delete");
-			if (allowed === null || allowed.length === 0 && !accountability?.admin) {
-				throw new ForbiddenError({ reason: `No permission to delete item in collection ${currentCollection}` });
-			}
-			return;
-		}
-		if (direction === "inbound" && action === "update" && key === pkField) {
+			if (allowed === null || allowed.length === 0 && !accountability?.admin) throw new ForbiddenError({ reason: `No permission to delete item in collection ${currentCollection}` });
 			return;
 		}
+		if (direction === "inbound" && action === "update" && key === pkField) return;
 		let allowedFields = await getPermissions(currentCollection, effectiveItemId, action);
 		if (!allowedFields) {
 			if (direction === "inbound" && action === "update") {
 				action = "create";
 				allowedFields = await getPermissions(currentCollection, effectiveItemId, action);
-			} else if (direction === "outbound") {
-				allowedFields = await getPermissions(currentCollection, null, "read") ?? [];
-			}
+			} else if (direction === "outbound") allowedFields = await getPermissions(currentCollection, null, "read") ?? [];
 		}
-		const isAllowed = allowedFields && (accountability?.admin || allowedFields.includes("*") || allowedFields.includes(String(key)));
-		if (!isAllowed) {
-			if (direction === "inbound") {
-				throw new ForbiddenError({ reason: `No permission to ${action} field ${key} or field does not exist` });
-			}
-			return undefined;
+		if (!(allowedFields && (accountability?.admin || allowedFields.includes("*") || allowedFields.includes(String(key))))) {
+			if (direction === "inbound") throw new ForbiddenError({ reason: `No permission to ${action} field ${key} or field does not exist` });
+			return;
 		}
 		if (direction === "outbound" && deepMapContext.relationType) {
 			if (Array.isArray(value)) {
 				const items = value.filter(isVisible);
-				if (items.length === 0) return undefined;
+				if (items.length === 0) return void 0;
 				return [key, items];
 			} else if (isDetailedUpdateSyntax(value)) {
 				const filtered = {
@@ -113,13 +89,9 @@ async function processPermissions(payload, collection, context) {
 					update: value.update.filter(isVisible),
 					delete: value.delete.filter(isVisible)
 				};
-				if (filtered.create.length === 0 && filtered.update.length === 0 && filtered.delete.length === 0) {
-					return undefined;
-				}
+				if (filtered.create.length === 0 && filtered.update.length === 0 && filtered.delete.length === 0) return;
 				return [key, filtered];
-			} else if (!isVisible(value)) {
-				return undefined;
-			}
+			} else if (!isVisible(value)) return;
 		}
 		return [key, value];
 	}, {
@@ -134,15 +106,12 @@ async function processPermissions(payload, collection, context) {
 		onUnknownField: (entry) => {
 			const [key] = entry;
 			if (String(key).startsWith("$")) return entry;
-			if (direction === "inbound") {
-				throw new ForbiddenError({ reason: `No permission to update field ${key} or field does not exist` });
-			}
-			return undefined;
+			if (direction === "inbound") throw new ForbiddenError({ reason: `No permission to update field ${key} or field does not exist` });
 		}
 	});
 }
 function isVisible(item) {
-	return item !== undefined && !(typeof item === "object" && item !== null && Object.keys(item).length === 0);
+	return item !== void 0 && !(typeof item === "object" && item !== null && Object.keys(item).length === 0);
 }
 
 //#endregion