@directus/api 35.0.2 → 35.1.0

package/dist/ai/telemetry/index.js

@@ -9,14 +9,11 @@ async function doTelemetryInit() {
 	if (env["AI_TELEMETRY_ENABLED"] !== true) return;
 	const logger = useLogger();
 	const provider = env["AI_TELEMETRY_PROVIDER"] || "langfuse";
-	const requiredKeys = {
+	const missing = ({
 		langfuse: ["LANGFUSE_SECRET_KEY", "LANGFUSE_PUBLIC_KEY"],
 		braintrust: ["BRAINTRUST_API_KEY"]
-	};
-	const missing = (requiredKeys[provider] ?? []).filter((key) => !(typeof env[key] === "string" && env[key].length > 0));
-	if (missing.length > 0) {
-		logger.warn(`AI telemetry provider "${provider}" is missing required config: ${missing.join(", ")}`);
-	}
+	}[provider] ?? []).filter((key) => !(typeof env[key] === "string" && env[key].length > 0));
+	if (missing.length > 0) logger.warn(`AI telemetry provider "${provider}" is missing required config: ${missing.join(", ")}`);
 	try {
 		let state;
 		switch (provider) {
@@ -49,21 +46,25 @@ const initAITelemetry = async () => {
 	telemetryInitPromise = initPromise;
 	return initPromise;
 };
-const getAITelemetryConfig = (metadata) => {
-	if (!telemetryState) return undefined;
+const getAITelemetryConfig = (metadata, functionId = "directus-ai-chat") => {
+	if (!telemetryState) return void 0;
+	const telemetryMetadata = {
+		provider: metadata.provider,
+		model: metadata.model,
+		...metadata.userId != null ? { userId: metadata.userId } : {},
+		...metadata.role != null ? { role: metadata.role } : {}
+	};
 	return {
 		isEnabled: true,
 		tracer: telemetryState.tracerProvider.getTracer("directus-ai"),
-		functionId: "directus-ai-chat",
+		functionId,
 		recordInputs: telemetryState.recordIO,
 		recordOutputs: telemetryState.recordIO,
-		metadata
+		metadata: telemetryMetadata
 	};
 };
 const shutdownAITelemetry = async () => {
-	if (telemetryInitPromise) {
-		await telemetryInitPromise;
-	}
+	if (telemetryInitPromise) await telemetryInitPromise;
 	if (!telemetryState) return;
 	const logger = useLogger();
 	const { tracerProvider } = telemetryState;

package/dist/ai/telemetry/langfuse.js

@@ -1,7 +1,7 @@
 //#region src/ai/telemetry/langfuse.ts
 const getStringAttribute = (attributes, key) => {
 	const value = attributes[key];
-	return typeof value === "string" && value.length > 0 ? value : undefined;
+	return typeof value === "string" && value.length > 0 ? value : void 0;
 };
 /**
 * Langfuse's OTel integration doesn't automatically pick up AI SDK span attributes for input/output display.
@@ -22,18 +22,10 @@ const createLangfuseInputOutputCompatSpanProcessor = () => {
 			const traceOutput = getStringAttribute(attributes, "langfuse.trace.output");
 			const fallbackOutput = getStringAttribute(attributes, "ai.response.text") ?? getStringAttribute(attributes, "ai.response.object");
 			const output = observationOutput ?? traceOutput ?? fallbackOutput;
-			if (!observationInput && input) {
-				attributes["langfuse.observation.input"] = input;
-			}
-			if (!traceInput && input) {
-				attributes["langfuse.trace.input"] = input;
-			}
-			if (!observationOutput && output) {
-				attributes["langfuse.observation.output"] = output;
-			}
-			if (!traceOutput && output) {
-				attributes["langfuse.trace.output"] = output;
-			}
+			if (!observationInput && input) attributes["langfuse.observation.input"] = input;
+			if (!traceInput && input) attributes["langfuse.trace.input"] = input;
+			if (!observationOutput && output) attributes["langfuse.observation.output"] = output;
+			if (!traceOutput && output) attributes["langfuse.trace.output"] = output;
 		},
 		forceFlush: async () => {},
 		shutdown: async () => {}
@@ -43,15 +35,9 @@ const applyLangfuseEnv = (env) => {
 	const secretKey = env["LANGFUSE_SECRET_KEY"];
 	const publicKey = env["LANGFUSE_PUBLIC_KEY"];
 	const baseUrl = env["LANGFUSE_BASE_URL"];
-	if (typeof secretKey === "string" && secretKey.length > 0) {
-		process.env["LANGFUSE_SECRET_KEY"] = secretKey;
-	}
-	if (typeof publicKey === "string" && publicKey.length > 0) {
-		process.env["LANGFUSE_PUBLIC_KEY"] = publicKey;
-	}
-	if (typeof baseUrl === "string" && baseUrl.length > 0) {
-		process.env["LANGFUSE_BASE_URL"] = baseUrl;
-	}
+	if (typeof secretKey === "string" && secretKey.length > 0) process.env["LANGFUSE_SECRET_KEY"] = secretKey;
+	if (typeof publicKey === "string" && publicKey.length > 0) process.env["LANGFUSE_PUBLIC_KEY"] = publicKey;
+	if (typeof baseUrl === "string" && baseUrl.length > 0) process.env["LANGFUSE_BASE_URL"] = baseUrl;
 };
 const initLangfuse = async (env) => {
 	applyLangfuseEnv(env);

package/dist/ai/tools/assets/index.js

@@ -22,30 +22,22 @@ const assets = defineTool({
 			accountability,
 			schema
 		};
-		const filesService = new FilesService(serviceOptions);
-		const file = await filesService.readOne(args.id, { limit: 1 });
-		if (!file.type || !["image", "audio"].some((t) => file.type?.startsWith(t))) {
-			throw new UnsupportedMediaTypeError({
-				mediaType: file.type ?? "unknown",
-				where: "asset tool"
-			});
-		}
-		let transformation = undefined;
-		if (file.type.startsWith("image") && file.width && file.height && (file.width > 1200 || file.height > 1200)) {
-			transformation = { transformationParams: { transforms: file.width > file.height ? [["resize", {
-				width: 800,
-				fit: "contain"
-			}]] : [["resize", {
-				height: 800,
-				fit: "contain"
-			}]] } };
-		}
-		const assetsService = new AssetsService(serviceOptions);
-		const asset = await assetsService.getAsset(args.id, transformation);
+		const file = await new FilesService(serviceOptions).readOne(args.id, { limit: 1 });
+		if (!file.type || !["image", "audio"].some((t) => file.type?.startsWith(t))) throw new UnsupportedMediaTypeError({
+			mediaType: file.type ?? "unknown",
+			where: "asset tool"
+		});
+		let transformation = void 0;
+		if (file.type.startsWith("image") && file.width && file.height && (file.width > 1200 || file.height > 1200)) transformation = { transformationParams: { transforms: file.width > file.height ? [["resize", {
+			width: 800,
+			fit: "contain"
+		}]] : [["resize", {
+			height: 800,
+			fit: "contain"
+		}]] } };
+		const asset = await new AssetsService(serviceOptions).getAsset(args.id, transformation);
 		const chunks = [];
-		for await (const chunk of asset.stream) {
-			chunks.push(Buffer.from(chunk));
-		}
+		for await (const chunk of asset.stream) chunks.push(Buffer.from(chunk));
 		return {
 			type: file.type.startsWith("image") ? "image" : "audio",
 			data: Buffer.concat(chunks).toString("base64"),

package/dist/ai/tools/collections/index.js

@@ -46,9 +46,7 @@ const collections = defineTool({
 	inputSchema: CollectionsInputSchema,
 	validateSchema: CollectionsValidateSchema,
 	endpoint({ data }) {
-		if (!isObject(data) || !("collection" in data)) {
-			return;
-		}
+		if (!isObject(data) || !("collection" in data)) return;
 		return ["content", data["collection"]];
 	},
 	async handler({ args, schema, accountability }) {
@@ -59,19 +57,15 @@ const collections = defineTool({
 		if (args.action === "create") {
 			const data = toArray(args.data);
 			const savedKeys = await service.createMany(data);
-			const result = await service.readMany(savedKeys);
 			return {
 				type: "text",
-				data: result || null
+				data: await service.readMany(savedKeys) || null
 			};
 		}
 		if (args.action === "read") {
 			let result = null;
-			if (args.keys) {
-				result = await service.readMany(args.keys);
-			} else {
-				result = await service.readByQuery();
-			}
+			if (args.keys) result = await service.readMany(args.keys);
+			else result = await service.readByQuery();
 			return {
 				type: "text",
 				data: result || null
@@ -79,19 +73,15 @@ const collections = defineTool({
 		}
 		if (args.action === "update") {
 			const updatedKeys = await service.updateBatch(toArray(args.data));
-			const result = await service.readMany(updatedKeys);
-			return {
-				type: "text",
-				data: result || null
-			};
-		}
-		if (args.action === "delete") {
-			const deletedKeys = await service.deleteMany(args.keys);
 			return {
 				type: "text",
-				data: deletedKeys
+				data: await service.readMany(updatedKeys) || null
 			};
 		}
+		if (args.action === "delete") return {
+			type: "text",
+			data: await service.deleteMany(args.keys)
+		};
 		throw new InvalidPayloadError({ reason: "Invalid action" });
 	}
 });

package/dist/ai/tools/fields/index.js

@@ -68,16 +68,12 @@ const fields = defineTool({
 					accountability,
 					knex: trx
 				});
-				for (const field of fields$1) {
-					await service.createField(args.collection, field, undefined, {
-						autoPurgeCache: false,
-						autoPurgeSystemCache: false
-					});
-				}
+				for (const field of fields$1) await service.createField(args.collection, field, void 0, {
+					autoPurgeCache: false,
+					autoPurgeSystemCache: false
+				});
 			});
-			if (shouldClearCache(service.cache)) {
-				await service.cache.clear();
-			}
+			if (shouldClearCache(service.cache)) await service.cache.clear();
 			await clearSystemCache();
 			service = new FieldsService({
 				schema: await getSchema(),
@@ -94,15 +90,9 @@ const fields = defineTool({
 		}
 		if (args.action === "read") {
 			let result = null;
-			if (args.collection) {
-				if (args.field) {
-					result = await service.readOne(args.collection, args.field);
-				} else {
-					result = await service.readAll(args.collection);
-				}
-			} else {
-				result = await service.readAll();
-			}
+			if (args.collection) if (args.field) result = await service.readOne(args.collection, args.field);
+			else result = await service.readAll(args.collection);
+			else result = await service.readAll();
 			return {
 				type: "text",
 				data: result || null
@@ -118,16 +108,12 @@ const fields = defineTool({
 					accountability,
 					knex: trx
 				});
-				for (const field of fields$1) {
-					await service.updateField(args.collection, field, {
-						autoPurgeCache: false,
-						autoPurgeSystemCache: false
-					});
-				}
+				for (const field of fields$1) await service.updateField(args.collection, field, {
+					autoPurgeCache: false,
+					autoPurgeSystemCache: false
+				});
 			});
-			if (shouldClearCache(service.cache)) {
-				await service.cache.clear();
-			}
+			if (shouldClearCache(service.cache)) await service.cache.clear();
 			await clearSystemCache();
 			service = new FieldsService({
 				schema: await getSchema(),

package/dist/ai/tools/files/index.js

@@ -49,9 +49,7 @@ const files = defineTool({
 	inputSchema: FilesInputSchema,
 	validateSchema: FilesValidateSchema,
 	endpoint({ data }) {
-		if (!isObject(data) || !("id" in data)) {
-			return;
-		}
+		if (!isObject(data) || !("id" in data)) return;
 		return ["files", data["id"]];
 	},
 	async handler({ args, schema, accountability }) {
@@ -62,11 +60,8 @@ const files = defineTool({
 		if (args.action === "read") {
 			const sanitizedQuery = await buildSanitizedQueryFromArgs(args, schema, accountability);
 			let result = null;
-			if (args.keys) {
-				result = await service.readMany(args.keys, sanitizedQuery);
-			} else {
-				result = await service.readByQuery(sanitizedQuery);
-			}
+			if (args.keys) result = await service.readMany(args.keys, sanitizedQuery);
+			else result = await service.readByQuery(sanitizedQuery);
 			return {
 				type: "text",
 				data: result
@@ -75,26 +70,18 @@ const files = defineTool({
 		if (args.action === "update") {
 			const sanitizedQuery = await buildSanitizedQueryFromArgs(args, schema, accountability);
 			let updatedKeys = [];
-			if (Array.isArray(args.data)) {
-				updatedKeys = await service.updateBatch(args.data);
-			} else if (args.keys) {
-				updatedKeys = await service.updateMany(args.keys, args.data);
-			} else {
-				updatedKeys = await service.updateByQuery(sanitizedQuery, args.data);
-			}
-			const result = await service.readMany(updatedKeys, sanitizedQuery);
-			return {
-				type: "text",
-				data: result
-			};
-		}
-		if (args.action === "delete") {
-			const deletedKeys = await service.deleteMany(args.keys);
+			if (Array.isArray(args.data)) updatedKeys = await service.updateBatch(args.data);
+			else if (args.keys) updatedKeys = await service.updateMany(args.keys, args.data);
+			else updatedKeys = await service.updateByQuery(sanitizedQuery, args.data);
 			return {
 				type: "text",
-				data: deletedKeys
+				data: await service.readMany(updatedKeys, sanitizedQuery)
 			};
 		}
+		if (args.action === "delete") return {
+			type: "text",
+			data: await service.deleteMany(args.keys)
+		};
 		if (args.action === "import") {
 			const savedKeys = [];
 			for (const file of args.data) {

package/dist/ai/tools/flows/index.js

@@ -49,9 +49,7 @@ const flows = defineTool({
 	inputSchema: FlowsInputSchema,
 	validateSchema: FlowsValidateSchema,
 	endpoint({ data }) {
-		if (!isObject(data) || !("id" in data)) {
-			return;
-		}
+		if (!isObject(data) || !("id" in data)) return;
 		return [
 			"settings",
 			"flows",
@@ -65,36 +63,30 @@ const flows = defineTool({
 		});
 		if (args.action === "create") {
 			const savedKey = await flowsService.createOne(args.data);
-			const result = await flowsService.readOne(savedKey);
 			return {
 				type: "text",
-				data: result || null
+				data: await flowsService.readOne(savedKey) || null
 			};
 		}
 		if (args.action === "read") {
 			const sanitizedQuery = await buildSanitizedQueryFromArgs(args, schema, accountability);
-			const result = await flowsService.readByQuery(sanitizedQuery);
 			return {
 				type: "text",
-				data: result || null
+				data: await flowsService.readByQuery(sanitizedQuery) || null
 			};
 		}
 		if (args.action === "update") {
 			const sanitizedQuery = await buildSanitizedQueryFromArgs(args, schema, accountability);
 			const updatedKey = await flowsService.updateOne(args.key, args.data);
-			const result = await flowsService.readOne(updatedKey, sanitizedQuery);
-			return {
-				type: "text",
-				data: result || null
-			};
-		}
-		if (args.action === "delete") {
-			const deletedKey = await flowsService.deleteOne(args.key);
 			return {
 				type: "text",
-				data: deletedKey
+				data: await flowsService.readOne(updatedKey, sanitizedQuery) || null
 			};
 		}
+		if (args.action === "delete") return {
+			type: "text",
+			data: await flowsService.deleteOne(args.key)
+		};
 		throw new Error("Invalid action.");
 	}
 });

package/dist/ai/tools/folders/index.js

@@ -58,20 +58,16 @@ const folders = defineTool({
 			const sanitizedQuery = await buildSanitizedQueryFromArgs(args, schema, accountability);
 			const data = toArray(args.data);
 			const savedKeys = await service.createMany(data);
-			const result = await service.readMany(savedKeys, sanitizedQuery);
 			return {
 				type: "text",
-				data: result || null
+				data: await service.readMany(savedKeys, sanitizedQuery) || null
 			};
 		}
 		if (args.action === "read") {
 			const sanitizedQuery = await buildSanitizedQueryFromArgs(args, schema, accountability);
 			let result = null;
-			if (args.keys) {
-				result = await service.readMany(args.keys, sanitizedQuery);
-			} else {
-				result = await service.readByQuery(sanitizedQuery);
-			}
+			if (args.keys) result = await service.readMany(args.keys, sanitizedQuery);
+			else result = await service.readByQuery(sanitizedQuery);
 			return {
 				type: "text",
 				data: result || null
@@ -80,26 +76,18 @@ const folders = defineTool({
 		if (args.action === "update") {
 			const sanitizedQuery = await buildSanitizedQueryFromArgs(args, schema, accountability);
 			let updatedKeys = [];
-			if (Array.isArray(args.data)) {
-				updatedKeys = await service.updateBatch(args.data);
-			} else if (args.keys) {
-				updatedKeys = await service.updateMany(args.keys, args.data);
-			} else {
-				updatedKeys = await service.updateByQuery(sanitizedQuery, args.data);
-			}
-			const result = await service.readMany(updatedKeys, sanitizedQuery);
-			return {
-				type: "text",
-				data: result
-			};
-		}
-		if (args.action === "delete") {
-			const deletedKeys = await service.deleteMany(args.keys);
+			if (Array.isArray(args.data)) updatedKeys = await service.updateBatch(args.data);
+			else if (args.keys) updatedKeys = await service.updateMany(args.keys, args.data);
+			else updatedKeys = await service.updateByQuery(sanitizedQuery, args.data);
 			return {
 				type: "text",
-				data: deletedKeys
+				data: await service.readMany(updatedKeys, sanitizedQuery)
 			};
 		}
+		if (args.action === "delete") return {
+			type: "text",
+			data: await service.deleteMany(args.keys)
+		};
 		throw new Error("Invalid action.");
 	}
 });

package/dist/ai/tools/items/index.js

@@ -55,9 +55,7 @@ const items = defineTool({
 	inputSchema: ItemsInputSchema,
 	validateSchema: ItemsValidateSchema,
 	endpoint({ input, data }) {
-		if (!isObject$1(data) || !("id" in data)) {
-			return;
-		}
+		if (!isObject$1(data) || !("id" in data)) return;
 		return [
 			"content",
 			input.collection,
@@ -65,12 +63,8 @@ const items = defineTool({
 		];
 	},
 	async handler({ args, schema, accountability }) {
-		if (isSystemCollection(args.collection)) {
-			throw new InvalidPayloadError({ reason: "Cannot provide a core collection" });
-		}
-		if (args.collection in schema.collections === false) {
-			throw new ForbiddenError();
-		}
+		if (isSystemCollection(args.collection)) throw new InvalidPayloadError({ reason: "Cannot provide a core collection" });
+		if (args.collection in schema.collections === false) throw new ForbiddenError();
 		const isSingleton = schema.collections[args.collection]?.singleton ?? false;
 		const itemsService = new ItemsService(args.collection, {
 			schema,
@@ -80,33 +74,25 @@ const items = defineTool({
 			const sanitizedQuery = await buildSanitizedQueryFromArgs(args, schema, accountability);
 			const data = toArray(args.data);
 			if (isSingleton) {
-				if (Array.isArray(args.data)) {
-					throw new InvalidPayloadError({ reason: "Invalid data payload, object exptected" });
-				}
+				if (Array.isArray(args.data)) throw new InvalidPayloadError({ reason: "Invalid data payload, object exptected" });
 				await itemsService.upsertSingleton(args.data);
-				const item = await itemsService.readSingleton(sanitizedQuery);
 				return {
 					type: "text",
-					data: item || null
+					data: await itemsService.readSingleton(sanitizedQuery) || null
 				};
 			}
 			const savedKeys = await itemsService.createMany(data);
-			const result = await itemsService.readMany(savedKeys, sanitizedQuery);
 			return {
 				type: "text",
-				data: result || null
+				data: await itemsService.readMany(savedKeys, sanitizedQuery) || null
 			};
 		}
 		if (args.action === "read") {
 			const sanitizedQuery = await buildSanitizedQueryFromArgs(args, schema, accountability);
 			let result = null;
-			if (isSingleton) {
-				result = await itemsService.readSingleton(sanitizedQuery);
-			} else if (args.keys) {
-				result = await itemsService.readMany(args.keys, sanitizedQuery);
-			} else {
-				result = await itemsService.readByQuery(sanitizedQuery);
-			}
+			if (isSingleton) result = await itemsService.readSingleton(sanitizedQuery);
+			else if (args.keys) result = await itemsService.readMany(args.keys, sanitizedQuery);
+			else result = await itemsService.readByQuery(sanitizedQuery);
 			return {
 				type: "text",
 				data: result
@@ -115,37 +101,26 @@ const items = defineTool({
 		if (args.action === "update") {
 			const sanitizedQuery = await buildSanitizedQueryFromArgs(args, schema, accountability);
 			if (isSingleton) {
-				if (Array.isArray(args.data)) {
-					throw new InvalidPayloadError({ reason: "Invalid data payload, object exptected" });
-				}
+				if (Array.isArray(args.data)) throw new InvalidPayloadError({ reason: "Invalid data payload, object exptected" });
 				await itemsService.upsertSingleton(args.data);
-				const item = await itemsService.readSingleton(sanitizedQuery);
 				return {
 					type: "text",
-					data: item || null
+					data: await itemsService.readSingleton(sanitizedQuery) || null
 				};
 			}
 			let updatedKeys = [];
-			if (Array.isArray(args.data)) {
-				updatedKeys = await itemsService.updateBatch(args.data);
-			} else if (args.keys) {
-				updatedKeys = await itemsService.updateMany(args.keys, args.data);
-			} else {
-				updatedKeys = await itemsService.updateByQuery(sanitizedQuery, args.data);
-			}
-			const result = await itemsService.readMany(updatedKeys, sanitizedQuery);
-			return {
-				type: "text",
-				data: result
-			};
-		}
-		if (args.action === "delete") {
-			const deletedKeys = await itemsService.deleteMany(args.keys);
+			if (Array.isArray(args.data)) updatedKeys = await itemsService.updateBatch(args.data);
+			else if (args.keys) updatedKeys = await itemsService.updateMany(args.keys, args.data);
+			else updatedKeys = await itemsService.updateByQuery(sanitizedQuery, args.data);
 			return {
 				type: "text",
-				data: deletedKeys
+				data: await itemsService.readMany(updatedKeys, sanitizedQuery)
 			};
 		}
+		if (args.action === "delete") return {
+			type: "text",
+			data: await itemsService.deleteMany(args.keys)
+		};
 		throw new Error("Invalid action.");
 	}
 });

package/dist/ai/tools/operations/index.js

@@ -54,36 +54,30 @@ const operations = defineTool({
 		});
 		if (args.action === "create") {
 			const savedKey = await operationService.createOne(args.data);
-			const result = await operationService.readOne(savedKey);
 			return {
 				type: "text",
-				data: result || null
+				data: await operationService.readOne(savedKey) || null
 			};
 		}
 		if (args.action === "read") {
 			const sanitizedQuery = await buildSanitizedQueryFromArgs(args, schema, accountability);
-			const result = await operationService.readByQuery(sanitizedQuery);
 			return {
 				type: "text",
-				data: result || null
+				data: await operationService.readByQuery(sanitizedQuery) || null
 			};
 		}
 		if (args.action === "update") {
 			const sanitizedQuery = await buildSanitizedQueryFromArgs(args, schema, accountability);
 			const updatedKey = await operationService.updateOne(args.key, args.data);
-			const result = await operationService.readOne(updatedKey, sanitizedQuery);
 			return {
 				type: "text",
-				data: result || null
-			};
-		}
-		if (args.action === "delete") {
-			const deletedKey = await operationService.deleteOne(args.key);
-			return {
-				type: "text",
-				data: deletedKey
+				data: await operationService.readOne(updatedKey, sanitizedQuery) || null
 			};
 		}
+		if (args.action === "delete") return {
+			type: "text",
+			data: await operationService.deleteOne(args.key)
+		};
 		throw new Error("Invalid action.");
 	}
 });

package/dist/ai/tools/relations/index.js

@@ -58,21 +58,16 @@ const relations = defineTool({
 		});
 		if (args.action === "create") {
 			await service.createOne(args.data);
-			const result = await service.readOne(args.collection, args.field || args.data.field);
 			return {
 				type: "text",
-				data: result || null
+				data: await service.readOne(args.collection, args.field || args.data.field) || null
 			};
 		}
 		if (args.action === "read") {
 			let result = null;
-			if (args.field && args.collection) {
-				result = await service.readOne(args.collection, args.field);
-			} else if (args.collection) {
-				result = await service.readAll(args.collection);
-			} else {
-				result = await service.readAll();
-			}
+			if (args.field && args.collection) result = await service.readOne(args.collection, args.field);
+			else if (args.collection) result = await service.readAll(args.collection);
+			else result = await service.readAll();
 			return {
 				type: "text",
 				data: result || null
@@ -80,10 +75,9 @@ const relations = defineTool({
 		}
 		if (args.action === "update") {
 			await service.updateOne(args.collection, args.field, args.data);
-			const result = await service.readOne(args.collection, args.field);
 			return {
 				type: "text",
-				data: result || null
+				data: await service.readOne(args.collection, args.field) || null
 			};
 		}
 		if (args.action === "delete") {