@directus/api 35.0.2 → 35.1.0

package/dist/services/collections.js

@@ -43,29 +43,18 @@ var CollectionsService = class CollectionsService {
 	* Create a single new collection
 	*/
 	async createOne(payload, opts) {
-		if (this.accountability && this.accountability.admin !== true) {
-			throw new ForbiddenError();
-		}
+		if (this.accountability && this.accountability.admin !== true) throw new ForbiddenError();
 		if (!("collection" in payload)) throw new InvalidPayloadError({ reason: `"collection" is required` });
-		if (typeof payload.collection !== "string" || payload.collection === "") {
-			throw new InvalidPayloadError({ reason: `"collection" must be a non-empty string` });
-		}
-		if (payload.collection.startsWith("directus_")) {
-			throw new InvalidPayloadError({ reason: `Collections can't start with "directus_"` });
-		}
+		if (typeof payload.collection !== "string" || payload.collection === "") throw new InvalidPayloadError({ reason: `"collection" must be a non-empty string` });
+		if (payload.collection.startsWith("directus_")) throw new InvalidPayloadError({ reason: `Collections can't start with "directus_"` });
 		payload.collection = await this.helpers.schema.parseCollectionName(payload.collection);
 		const nestedActionEvents = [];
 		try {
-			const existingCollections = [...(await this.knex.select("collection").from("directus_collections"))?.map(({ collection }) => collection) ?? [], ...Object.keys(this.schema.collections)];
-			if (existingCollections.includes(payload.collection)) {
-				throw new InvalidPayloadError({ reason: `Collection "${payload.collection}" already exists` });
-			}
+			if ([...(await this.knex.select("collection").from("directus_collections"))?.map(({ collection }) => collection) ?? [], ...Object.keys(this.schema.collections)].includes(payload.collection)) throw new InvalidPayloadError({ reason: `Collection "${payload.collection}" already exists` });
 			const attemptConcurrentIndex = Boolean(opts?.attemptConcurrentIndex);
 			await transaction(this.knex, async (trx) => {
 				if (payload.schema) {
-					if ("fields" in payload && !Array.isArray(payload.fields)) {
-						throw new InvalidPayloadError({ reason: `"fields" must be an array` });
-					}
+					if ("fields" in payload && !Array.isArray(payload.fields)) throw new InvalidPayloadError({ reason: `"fields" must be an array` });
 					/**
 					* Directus heavily relies on the primary key of a collection, so we have to make sure that
 					* every collection that is created has a primary key. If no primary key field is created
@@ -84,23 +73,16 @@ var CollectionsService = class CollectionsService {
 							has_auto_increment: true
 						}
 					};
-					if (!payload.fields || payload.fields.length === 0) {
-						payload.fields = [injectedPrimaryKeyField];
-					} else if (!payload.fields.some((f) => f.schema?.is_primary_key === true || f.schema?.has_auto_increment === true)) {
-						payload.fields = [injectedPrimaryKeyField, ...payload.fields];
-					}
+					if (!payload.fields || payload.fields.length === 0) payload.fields = [injectedPrimaryKeyField];
+					else if (!payload.fields.some((f) => f.schema?.is_primary_key === true || f.schema?.has_auto_increment === true)) payload.fields = [injectedPrimaryKeyField, ...payload.fields];
 					payload.fields = payload.fields.map((field) => {
-						if (field.meta) {
-							field.meta = {
-								...field.meta,
-								field: field.field,
-								collection: payload.collection
-							};
-						}
+						if (field.meta) field.meta = {
+							...field.meta,
+							field: field.field,
+							collection: payload.collection
+						};
 						const flagToAdd = this.helpers.date.fieldFlagForField(field.type);
-						if (flagToAdd) {
-							addFieldFlag(field, flagToAdd);
-						}
+						if (flagToAdd) addFieldFlag(field, flagToAdd);
 						return field;
 					});
 					const fieldsService = new FieldsService({
@@ -108,11 +90,7 @@ var CollectionsService = class CollectionsService {
 						schema: this.schema
 					});
 					await trx.schema.createTable(payload.collection, (table) => {
-						for (const field of payload.fields) {
-							if (field.type && ALIAS_TYPES.includes(field.type) === false) {
-								fieldsService.addColumnToTable(table, payload.collection, field, { attemptConcurrentIndex });
-							}
-						}
+						for (const field of payload.fields) if (field.type && ALIAS_TYPES.includes(field.type) === false) fieldsService.addColumnToTable(table, payload.collection, field, { attemptConcurrentIndex });
 					});
 					const fieldItemsService = new ItemsService("directus_fields", {
 						knex: trx,
@@ -120,47 +98,34 @@ var CollectionsService = class CollectionsService {
 						schema: this.schema
 					});
 					const fieldPayloads = payload.fields.filter((field) => field.meta).map((field) => field.meta);
-					let sortedFieldPayloads = fieldPayloads.filter((field) => field?.group === undefined || field?.group === null).map((field, index) => merge({ sort: index + 1 }, field));
+					let sortedFieldPayloads = fieldPayloads.filter((field) => field?.group === void 0 || field?.group === null).map((field, index) => merge({ sort: index + 1 }, field));
 					if (sortedFieldPayloads.length < fieldPayloads.length) {
 						const fieldsWithGroups = groupBy(fieldPayloads.filter((field) => field?.group), (field) => field?.group);
-						for (const [_group, fields] of Object.entries(fieldsWithGroups)) {
-							sortedFieldPayloads = sortedFieldPayloads.concat(fields.map((field, index) => merge({ sort: index + 1 }, field)));
-						}
+						for (const [_group, fields] of Object.entries(fieldsWithGroups)) sortedFieldPayloads = sortedFieldPayloads.concat(fields.map((field, index) => merge({ sort: index + 1 }, field)));
 					}
 					await fieldItemsService.createMany(sortedFieldPayloads, {
 						bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params),
 						bypassLimits: true
 					});
 				}
-				if (payload.meta) {
-					const collectionsItemsService = new ItemsService("directus_collections", {
-						knex: trx,
-						accountability: this.accountability,
-						schema: this.schema
-					});
-					await collectionsItemsService.createOne({
-						...payload.meta,
-						collection: payload.collection
-					}, { bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params) });
-				}
+				if (payload.meta) await new ItemsService("directus_collections", {
+					knex: trx,
+					accountability: this.accountability,
+					schema: this.schema
+				}).createOne({
+					...payload.meta,
+					collection: payload.collection
+				}, { bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params) });
 				return payload.collection;
 			});
 			if (attemptConcurrentIndex && payload.schema && Array.isArray(payload.fields)) {
 				const fieldsService = new FieldsService({ schema: this.schema });
-				for (const field of payload.fields) {
-					if (field.type && ALIAS_TYPES.includes(field.type) === false) {
-						await fieldsService.addColumnIndex(payload.collection, field, { attemptConcurrentIndex });
-					}
-				}
+				for (const field of payload.fields) if (field.type && ALIAS_TYPES.includes(field.type) === false) await fieldsService.addColumnIndex(payload.collection, field, { attemptConcurrentIndex });
 			}
 			return payload.collection;
 		} finally {
-			if (shouldClearCache(this.cache, opts)) {
-				await this.cache.clear();
-			}
-			if (opts?.autoPurgeSystemCache !== false) {
-				await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
-			}
+			if (shouldClearCache(this.cache, opts)) await this.cache.clear();
+			if (opts?.autoPurgeSystemCache !== false) await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
 			if (opts?.emitEvents !== false && nestedActionEvents.length > 0) {
 				const updatedSchema = await getSchema();
 				for (const nestedActionEvent of nestedActionEvents) {
@@ -176,7 +141,7 @@ var CollectionsService = class CollectionsService {
 	async createMany(payloads, opts) {
 		const nestedActionEvents = [];
 		try {
-			const collections = await transaction(this.knex, async (trx) => {
+			return await transaction(this.knex, async (trx) => {
 				const service = new CollectionsService({
 					schema: this.schema,
 					accountability: this.accountability,
@@ -194,14 +159,9 @@ var CollectionsService = class CollectionsService {
 				}
 				return collectionNames;
 			});
-			return collections;
 		} finally {
-			if (shouldClearCache(this.cache, opts)) {
-				await this.cache.clear();
-			}
-			if (opts?.autoPurgeSystemCache !== false) {
-				await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
-			}
+			if (shouldClearCache(this.cache, opts)) await this.cache.clear();
+			if (opts?.autoPurgeSystemCache !== false) await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
 			if (opts?.emitEvents !== false && nestedActionEvents.length > 0) {
 				const updatedSchema = await getSchema();
 				for (const nestedActionEvent of nestedActionEvents) {
@@ -258,19 +218,12 @@ var CollectionsService = class CollectionsService {
 			};
 			collections.push(collection);
 		}
-		for (const table of tablesInDatabase) {
-			const exists = !!collections.find(({ collection }) => collection === table.name);
-			if (!exists) {
-				collections.push({
-					collection: table.name,
-					schema: table,
-					meta: null
-				});
-			}
-		}
-		if (env["DB_EXCLUDE_TABLES"]) {
-			return collections.filter((collection) => env["DB_EXCLUDE_TABLES"].includes(collection.collection) === false);
-		}
+		for (const table of tablesInDatabase) if (!!!collections.find(({ collection }) => collection === table.name)) collections.push({
+			collection: table.name,
+			schema: table,
+			meta: null
+		});
+		if (env["DB_EXCLUDE_TABLES"]) return collections.filter((collection) => env["DB_EXCLUDE_TABLES"].includes(collection.collection) === false);
 		return collections;
 	}
 	/**
@@ -285,27 +238,22 @@ var CollectionsService = class CollectionsService {
 	* Read many collections by name
 	*/
 	async readMany(collectionKeys) {
-		if (this.accountability) {
-			await Promise.all(collectionKeys.map((collection) => validateAccess({
-				accountability: this.accountability,
-				action: "read",
-				collection,
-				skipCollectionExistsCheck: true
-			}, {
-				schema: this.schema,
-				knex: this.knex
-			})));
-		}
-		const collections = await this.readByQuery();
-		return collections.filter(({ collection }) => collectionKeys.includes(collection));
+		if (this.accountability) await Promise.all(collectionKeys.map((collection) => validateAccess({
+			accountability: this.accountability,
+			action: "read",
+			collection,
+			skipCollectionExistsCheck: true
+		}, {
+			schema: this.schema,
+			knex: this.knex
+		})));
+		return (await this.readByQuery()).filter(({ collection }) => collectionKeys.includes(collection));
 	}
 	/**
 	* Update a single collection by name
 	*/
 	async updateOne(collectionKey, data, opts) {
-		if (this.accountability && this.accountability.admin !== true) {
-			throw new ForbiddenError();
-		}
+		if (this.accountability && this.accountability.admin !== true) throw new ForbiddenError();
 		const nestedActionEvents = [];
 		try {
 			const collectionsItemsService = new ItemsService("directus_collections", {
@@ -314,32 +262,22 @@ var CollectionsService = class CollectionsService {
 				schema: this.schema
 			});
 			const payload = data;
-			if (!payload.meta) {
-				return collectionKey;
-			}
-			const exists = !!await this.knex.select("collection").from("directus_collections").where({ collection: collectionKey }).first();
-			if (exists) {
-				await collectionsItemsService.updateOne(collectionKey, payload.meta, {
-					...opts,
-					bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params)
-				});
-			} else {
-				await collectionsItemsService.createOne({
-					...payload.meta,
-					collection: collectionKey
-				}, {
-					...opts,
-					bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params)
-				});
-			}
+			if (!payload.meta) return collectionKey;
+			if (!!await this.knex.select("collection").from("directus_collections").where({ collection: collectionKey }).first()) await collectionsItemsService.updateOne(collectionKey, payload.meta, {
+				...opts,
+				bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params)
+			});
+			else await collectionsItemsService.createOne({
+				...payload.meta,
+				collection: collectionKey
+			}, {
+				...opts,
+				bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params)
+			});
 			return collectionKey;
 		} finally {
-			if (shouldClearCache(this.cache, opts)) {
-				await this.cache.clear();
-			}
-			if (opts?.autoPurgeSystemCache !== false) {
-				await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
-			}
+			if (shouldClearCache(this.cache, opts)) await this.cache.clear();
+			if (opts?.autoPurgeSystemCache !== false) await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
 			if (opts?.emitEvents !== false && nestedActionEvents.length > 0) {
 				const updatedSchema = await getSchema();
 				for (const nestedActionEvent of nestedActionEvents) {
@@ -353,12 +291,8 @@ var CollectionsService = class CollectionsService {
 	* Update multiple collections in a single transaction
 	*/
 	async updateBatch(data, opts) {
-		if (this.accountability && this.accountability.admin !== true) {
-			throw new ForbiddenError();
-		}
-		if (!Array.isArray(data)) {
-			throw new InvalidPayloadError({ reason: "Input should be an array of collection changes" });
-		}
+		if (this.accountability && this.accountability.admin !== true) throw new ForbiddenError();
+		if (!Array.isArray(data)) throw new InvalidPayloadError({ reason: "Input should be an array of collection changes" });
 		const collectionKey = "collection";
 		const collectionKeys = [];
 		const nestedActionEvents = [];
@@ -370,9 +304,7 @@ var CollectionsService = class CollectionsService {
 					schema: this.schema
 				});
 				for (const payload of data) {
-					if (!payload[collectionKey]) {
-						throw new InvalidPayloadError({ reason: `Collection in update misses collection key` });
-					}
+					if (!payload[collectionKey]) throw new InvalidPayloadError({ reason: `Collection in update misses collection key` });
 					await collectionItemsService.updateOne(payload[collectionKey], omit(payload, collectionKey), {
 						autoPurgeCache: false,
 						autoPurgeSystemCache: false,
@@ -382,12 +314,8 @@ var CollectionsService = class CollectionsService {
 				}
 			});
 		} finally {
-			if (shouldClearCache(this.cache, opts)) {
-				await this.cache.clear();
-			}
-			if (opts?.autoPurgeSystemCache !== false) {
-				await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
-			}
+			if (shouldClearCache(this.cache, opts)) await this.cache.clear();
+			if (opts?.autoPurgeSystemCache !== false) await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
 			if (opts?.emitEvents !== false && nestedActionEvents.length > 0) {
 				const updatedSchema = await getSchema();
 				for (const nestedActionEvent of nestedActionEvents) {
@@ -402,9 +330,7 @@ var CollectionsService = class CollectionsService {
 	* Update multiple collections by name
 	*/
 	async updateMany(collectionKeys, data, opts) {
-		if (this.accountability && this.accountability.admin !== true) {
-			throw new ForbiddenError();
-		}
+		if (this.accountability && this.accountability.admin !== true) throw new ForbiddenError();
 		const nestedActionEvents = [];
 		try {
 			await transaction(this.knex, async (trx) => {
@@ -413,22 +339,16 @@ var CollectionsService = class CollectionsService {
 					accountability: this.accountability,
 					knex: trx
 				});
-				for (const collectionKey of collectionKeys) {
-					await service.updateOne(collectionKey, data, {
-						autoPurgeCache: false,
-						autoPurgeSystemCache: false,
-						bypassEmitAction: (params) => nestedActionEvents.push(params)
-					});
-				}
+				for (const collectionKey of collectionKeys) await service.updateOne(collectionKey, data, {
+					autoPurgeCache: false,
+					autoPurgeSystemCache: false,
+					bypassEmitAction: (params) => nestedActionEvents.push(params)
+				});
 			});
 			return collectionKeys;
 		} finally {
-			if (shouldClearCache(this.cache, opts)) {
-				await this.cache.clear();
-			}
-			if (opts?.autoPurgeSystemCache !== false) {
-				await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
-			}
+			if (shouldClearCache(this.cache, opts)) await this.cache.clear();
+			if (opts?.autoPurgeSystemCache !== false) await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
 			if (opts?.emitEvents !== false && nestedActionEvents.length > 0) {
 				const updatedSchema = await getSchema();
 				for (const nestedActionEvent of nestedActionEvents) {
@@ -443,48 +363,35 @@ var CollectionsService = class CollectionsService {
 	* delete any fields, presets, activity, revisions, and permissions relating to this collection
 	*/
 	async deleteOne(collectionKey, opts) {
-		if (this.accountability && this.accountability.admin !== true) {
-			throw new ForbiddenError();
-		}
+		if (this.accountability && this.accountability.admin !== true) throw new ForbiddenError();
 		const nestedActionEvents = [];
 		try {
-			const collections = await this.readByQuery();
-			const collectionToBeDeleted = collections.find((collection) => collection.collection === collectionKey);
-			if (!!collectionToBeDeleted === false) {
-				throw new ForbiddenError();
-			}
+			const collectionToBeDeleted = (await this.readByQuery()).find((collection) => collection.collection === collectionKey);
+			if (!!collectionToBeDeleted === false) throw new ForbiddenError();
 			await transaction(this.knex, async (trx) => {
-				if (collectionToBeDeleted.schema) {
-					await trx.schema.dropTable(collectionKey);
-				}
+				if (collectionToBeDeleted.schema) await trx.schema.dropTable(collectionKey);
 				await trx("directus_collections").update({ group: null }).where({ group: collectionKey });
-				if (collectionToBeDeleted.meta) {
-					const collectionsItemsService = new ItemsService("directus_collections", {
-						knex: trx,
-						accountability: this.accountability,
-						schema: this.schema
-					});
-					await collectionsItemsService.deleteOne(collectionKey, { bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params) });
-				}
+				if (collectionToBeDeleted.meta) await new ItemsService("directus_collections", {
+					knex: trx,
+					accountability: this.accountability,
+					schema: this.schema
+				}).deleteOne(collectionKey, { bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params) });
 				if (collectionToBeDeleted.schema) {
 					const fieldsService = new FieldsService({
 						knex: trx,
 						accountability: this.accountability,
 						schema: this.schema
 					});
-					const fieldItemsService = new ItemsService("directus_fields", {
+					await new ItemsService("directus_fields", {
 						knex: trx,
 						accountability: this.accountability,
 						schema: this.schema
-					});
-					await fieldItemsService.deleteByQuery({ filter: { collection: { _eq: collectionKey } } }, { bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params) });
+					}).deleteByQuery({ filter: { collection: { _eq: collectionKey } } }, { bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params) });
 					await trx("directus_presets").delete().where("collection", "=", collectionKey);
 					const revisionsToDelete = await trx.select("id").from("directus_revisions").where({ collection: collectionKey });
 					if (revisionsToDelete.length > 0) {
 						const chunks = chunk(revisionsToDelete.map((record) => record.id), 1e4);
-						for (const keys of chunks) {
-							await trx("directus_revisions").update({ parent: null }).whereIn("parent", keys);
-						}
+						for (const keys of chunks) await trx("directus_revisions").update({ parent: null }).whereIn("parent", keys);
 					}
 					await trx("directus_revisions").delete().where("collection", "=", collectionKey);
 					await trx("directus_activity").delete().where("collection", "=", collectionKey);
@@ -496,29 +403,23 @@ var CollectionsService = class CollectionsService {
 						const collectionMetas = await trx.select("collection", "archive_field", "sort_field", "item_duplication_fields").from("directus_collections").whereIn("collection", Array.from(collectionRelationList)).whereNotNull("item_duplication_fields");
 						await Promise.all(Object.keys(this.schema.collections[collectionKey]?.fields ?? {}).map(async (fieldKey) => {
 							const collectionMetaUpdates = getCollectionMetaUpdates(collectionKey, fieldKey, collectionMetas, this.schema.collections, fieldToCollectionList);
-							for (const meta of collectionMetaUpdates) {
-								await trx("directus_collections").update(meta.updates).where({ collection: meta.collection });
-							}
+							for (const meta of collectionMetaUpdates) await trx("directus_collections").update(meta.updates).where({ collection: meta.collection });
 						}));
 					}
 					const relations = this.schema.relations.filter((relation) => {
 						return relation.collection === collectionKey || relation.related_collection === collectionKey;
 					});
 					for (const relation of relations) {
-						if (relation.related_collection && relation.meta?.one_field) {
-							await fieldsService.deleteField(relation.related_collection, relation.meta.one_field, {
-								autoPurgeCache: false,
-								autoPurgeSystemCache: false,
-								bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params)
-							});
-						}
-						if (relation.related_collection === collectionKey) {
-							await fieldsService.deleteField(relation.collection, relation.field, {
-								autoPurgeCache: false,
-								autoPurgeSystemCache: false,
-								bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params)
-							});
-						}
+						if (relation.related_collection && relation.meta?.one_field) await fieldsService.deleteField(relation.related_collection, relation.meta.one_field, {
+							autoPurgeCache: false,
+							autoPurgeSystemCache: false,
+							bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params)
+						});
+						if (relation.related_collection === collectionKey) await fieldsService.deleteField(relation.collection, relation.field, {
+							autoPurgeCache: false,
+							autoPurgeSystemCache: false,
+							bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params)
+						});
 					}
 					const a2oRelationsThatIncludeThisCollection = this.schema.relations.filter((relation) => {
 						return relation.meta?.one_allowed_collections?.includes(collectionKey);
@@ -531,12 +432,8 @@ var CollectionsService = class CollectionsService {
 			});
 			return collectionKey;
 		} finally {
-			if (shouldClearCache(this.cache, opts)) {
-				await this.cache.clear();
-			}
-			if (opts?.autoPurgeSystemCache !== false) {
-				await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
-			}
+			if (shouldClearCache(this.cache, opts)) await this.cache.clear();
+			if (opts?.autoPurgeSystemCache !== false) await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
 			if (opts?.emitEvents !== false && nestedActionEvents.length > 0) {
 				const updatedSchema = await getSchema();
 				for (const nestedActionEvent of nestedActionEvents) {
@@ -550,9 +447,7 @@ var CollectionsService = class CollectionsService {
 	* Delete multiple collections by key
 	*/
 	async deleteMany(collectionKeys, opts) {
-		if (this.accountability && this.accountability.admin !== true) {
-			throw new ForbiddenError();
-		}
+		if (this.accountability && this.accountability.admin !== true) throw new ForbiddenError();
 		const nestedActionEvents = [];
 		try {
 			await transaction(this.knex, async (trx) => {
@@ -561,22 +456,16 @@ var CollectionsService = class CollectionsService {
 					accountability: this.accountability,
 					knex: trx
 				});
-				for (const collectionKey of collectionKeys) {
-					await service.deleteOne(collectionKey, {
-						autoPurgeCache: false,
-						autoPurgeSystemCache: false,
-						bypassEmitAction: (params) => nestedActionEvents.push(params)
-					});
-				}
+				for (const collectionKey of collectionKeys) await service.deleteOne(collectionKey, {
+					autoPurgeCache: false,
+					autoPurgeSystemCache: false,
+					bypassEmitAction: (params) => nestedActionEvents.push(params)
+				});
 			});
 			return collectionKeys;
 		} finally {
-			if (shouldClearCache(this.cache, opts)) {
-				await this.cache.clear();
-			}
-			if (opts?.autoPurgeSystemCache !== false) {
-				await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
-			}
+			if (shouldClearCache(this.cache, opts)) await this.cache.clear();
+			if (opts?.autoPurgeSystemCache !== false) await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
 			if (opts?.emitEvents !== false && nestedActionEvents.length > 0) {
 				const updatedSchema = await getSchema();
 				for (const nestedActionEvent of nestedActionEvents) {

package/dist/services/comments.js

@@ -25,32 +25,22 @@ var CommentsService = class extends ItemsService {
 	}
 	async createOne(data, opts) {
 		if (!this.accountability?.user) throw new ForbiddenError();
-		if (!data["comment"]) {
-			throw new InvalidPayloadError({ reason: `"comment" is required` });
-		}
-		if (!data["collection"]) {
-			throw new InvalidPayloadError({ reason: `"collection" is required` });
-		}
-		if (!data["item"]) {
-			throw new InvalidPayloadError({ reason: `"item" is required` });
-		}
-		if (this.accountability) {
-			await validateAccess({
-				accountability: this.accountability,
-				action: "read",
-				collection: data["collection"],
-				primaryKeys: [data["item"]]
-			}, {
-				schema: this.schema,
-				knex: this.knex
-			});
-		}
+		if (!data["comment"]) throw new InvalidPayloadError({ reason: `"comment" is required` });
+		if (!data["collection"]) throw new InvalidPayloadError({ reason: `"collection" is required` });
+		if (!data["item"]) throw new InvalidPayloadError({ reason: `"item" is required` });
+		if (this.accountability) await validateAccess({
+			accountability: this.accountability,
+			action: "read",
+			collection: data["collection"],
+			primaryKeys: [data["item"]]
+		}, {
+			schema: this.schema,
+			knex: this.knex
+		});
 		const result = await super.createOne(data, opts);
-		const usersRegExp = new RegExp(/@[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}/gi);
+		const usersRegExp = /* @__PURE__ */ new RegExp(/@[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}/gi);
 		const mentions = uniq(data["comment"].match(usersRegExp) ?? []);
-		if (mentions.length === 0) {
-			return result;
-		}
+		if (mentions.length === 0) return result;
 		const sender = await this.usersService.readOne(this.accountability.user, { fields: [
 			"id",
 			"first_name",
@@ -91,7 +81,7 @@ var CommentsService = class extends ItemsService {
 					schema: this.schema,
 					knex: this.knex
 				});
-				const templateData = await usersService.readByQuery({
+				const userPreviews = (await usersService.readByQuery({
 					fields: [
 						"id",
 						"first_name",
@@ -99,8 +89,7 @@ var CommentsService = class extends ItemsService {
 						"email"
 					],
 					filter: { id: { _in: mentions.map((mention$1) => mention$1.substring(1)) } }
-				});
-				const userPreviews = templateData.reduce((acc, user$1) => {
+				})).reduce((acc, user$1) => {
 					acc[user$1["id"]] = `<em>${userName(user$1)}</em>`;
 					return acc;
 				}, {});
@@ -130,11 +119,8 @@ ${comment}
 					item: data["item"]
 				});
 			} catch (err) {
-				if (isDirectusError(err, ErrorCode.Forbidden)) {
-					logger.warn(`User ${userID} doesn't have proper permissions to receive notification for this item.`);
-				} else {
-					throw err;
-				}
+				if (isDirectusError(err, ErrorCode.Forbidden)) logger.warn(`User ${userID} doesn't have proper permissions to receive notification for this item.`);
+				else throw err;
 			}
 		}
 		return result;