@directus/api 35.0.2 → 35.1.0

package/dist/services/permissions.js

@@ -14,9 +14,7 @@ var PermissionsService = class extends ItemsService {
 	}
 	async clearCaches(opts) {
 		await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
-		if (this.cache && opts?.autoPurgeCache !== false) {
-			await this.cache.clear();
-		}
+		if (this.cache && opts?.autoPurgeCache !== false) await this.cache.clear();
 	}
 	async readByQuery(query, opts) {
 		const result = await super.readByQuery(query, opts);
@@ -54,13 +52,11 @@ var PermissionsService = class extends ItemsService {
 	}
 	async getItemPermissions(collection, primaryKey) {
 		if (!this.accountability?.user) throw new ForbiddenError();
-		if (this.accountability?.admin) {
-			return {
-				update: { access: true },
-				delete: { access: true },
-				share: { access: true }
-			};
-		}
+		if (this.accountability?.admin) return {
+			update: { access: true },
+			delete: { access: true },
+			share: { access: true }
+		};
 		const itemPermissions = {
 			update: { access: false },
 			delete: { access: false },
@@ -78,8 +74,7 @@ var PermissionsService = class extends ItemsService {
 				limit: 1
 			};
 			try {
-				const result = await itemsService.readByQuery(query);
-				if (!result[0]) updateAction = "create";
+				if (!(await itemsService.readByQuery(query))[0]) updateAction = "create";
 			} catch {
 				updateAction = "create";
 			}
@@ -96,9 +91,7 @@ var PermissionsService = class extends ItemsService {
 				action: checkAction,
 				collection
 			};
-			if (primaryKey) {
-				opts.primaryKeys = [primaryKey];
-			}
+			if (primaryKey) opts.primaryKeys = [primaryKey];
 			return validateAccess(opts, {
 				schema: this.schema,
 				knex: this.knex
@@ -109,9 +102,8 @@ var PermissionsService = class extends ItemsService {
 				schema: this.schema,
 				knex: this.knex
 			};
-			const policies = await fetchPolicies(this.accountability, context);
 			const permissions = await fetchPermissions({
-				policies,
+				policies: await fetchPolicies(this.accountability, context),
 				accountability: this.accountability,
 				action: updateAction,
 				collections: [collection]
@@ -121,16 +113,12 @@ var PermissionsService = class extends ItemsService {
 			for (const permission of permissions) {
 				if (permission.fields && fields[0] !== "*") {
 					fields = uniq([...fields, ...permission.fields]);
-					if (fields.includes("*")) {
-						fields = ["*"];
-					}
-				}
-				if (permission.presets) {
-					presets = {
-						...presets ?? {},
-						...permission.presets
-					};
+					if (fields.includes("*")) fields = ["*"];
 				}
+				if (permission.presets) presets = {
+					...presets ?? {},
+					...permission.presets
+				};
 			}
 			itemPermissions.update.fields = fields;
 			itemPermissions.update.presets = presets;

package/dist/services/policies.js

@@ -12,19 +12,16 @@ var PoliciesService = class extends ItemsService {
 	}
 	async clearCaches(opts) {
 		await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
-		if (this.cache && opts?.autoPurgeCache !== false) {
-			await this.cache.clear();
-		}
+		if (this.cache && opts?.autoPurgeCache !== false) await this.cache.clear();
 	}
 	isIpAccessValid(value) {
-		if (value === undefined) return false;
+		if (value === void 0) return false;
 		if (value === null) return true;
 		if (Array.isArray(value) && value.length === 0) return true;
 		for (const ip of value) {
 			if (typeof ip !== "string" || ip.includes("*")) return false;
 			try {
-				const match = getMatch(ip);
-				if (match.type == "IPMask") return false;
+				if (getMatch(ip).type == "IPMask") return false;
 			} catch {
 				return false;
 			}
@@ -32,9 +29,7 @@ var PoliciesService = class extends ItemsService {
 		return true;
 	}
 	assertValidIpAccess(partialItem) {
-		if ("ip_access" in partialItem && !this.isIpAccessValid(partialItem["ip_access"])) {
-			throw new InvalidPayloadError({ reason: "IP Access contains an incorrect value. Valid values are: IP addresses, IP ranges and CIDR blocks" });
-		}
+		if ("ip_access" in partialItem && !this.isIpAccessValid(partialItem["ip_access"])) throw new InvalidPayloadError({ reason: "IP Access contains an incorrect value. Valid values are: IP addresses, IP ranges and CIDR blocks" });
 	}
 	async createOne(data, opts = {}) {
 		this.assertValidIpAccess(data);
@@ -46,19 +41,13 @@ var PoliciesService = class extends ItemsService {
 		this.assertValidIpAccess(data);
 		if ("admin_access" in data) {
 			let flags = UserIntegrityCheckFlag.RemainingAdmins;
-			if (data["admin_access"] === true) {
-				flags |= UserIntegrityCheckFlag.All;
-			}
+			if (data["admin_access"] === true) flags |= UserIntegrityCheckFlag.All;
 			opts.userIntegrityCheckFlags = (opts.userIntegrityCheckFlags ?? UserIntegrityCheckFlag.None) | flags;
 		}
-		if ("app_access" in data) {
-			opts.userIntegrityCheckFlags = (opts.userIntegrityCheckFlags ?? UserIntegrityCheckFlag.None) | UserIntegrityCheckFlag.UserLimits;
-		}
+		if ("app_access" in data) opts.userIntegrityCheckFlags = (opts.userIntegrityCheckFlags ?? UserIntegrityCheckFlag.None) | UserIntegrityCheckFlag.UserLimits;
 		if (opts.userIntegrityCheckFlags) opts.onRequireUserIntegrityCheck?.(opts.userIntegrityCheckFlags);
 		const result = await super.updateMany(keys, data, opts);
-		if ("admin_access" in data || "app_access" in data || "ip_access" in data || "enforce_tfa" in data) {
-			await this.clearCaches(opts);
-		}
+		if ("admin_access" in data || "app_access" in data || "ip_access" in data || "enforce_tfa" in data) await this.clearCaches(opts);
 		return result;
 	}
 	async deleteMany(keys, opts = {}) {

package/dist/services/relations.js

@@ -43,43 +43,31 @@ var RelationsService = class {
 	async foreignKeys(collection) {
 		const schemaCacheIsEnabled = Boolean(env["CACHE_SCHEMA"]);
 		let foreignKeys = null;
-		if (schemaCacheIsEnabled) {
-			foreignKeys = await getCacheValue(this.schemaCache, "foreignKeys");
-		}
+		if (schemaCacheIsEnabled) foreignKeys = await getCacheValue(this.schemaCache, "foreignKeys");
 		if (!foreignKeys) {
 			foreignKeys = await this.schemaInspector.foreignKeys();
-			if (schemaCacheIsEnabled) {
-				setCacheValue(this.schemaCache, "foreignKeys", foreignKeys);
-			}
-		}
-		if (collection) {
-			return foreignKeys.filter((row) => row.table === collection);
+			if (schemaCacheIsEnabled) setCacheValue(this.schemaCache, "foreignKeys", foreignKeys);
 		}
+		if (collection) return foreignKeys.filter((row) => row.table === collection);
 		return foreignKeys;
 	}
 	async readAll(collection, opts, bypassCache) {
-		if (this.accountability) {
-			await validateAccess({
-				accountability: this.accountability,
-				action: "read",
-				collection: "directus_relations"
-			}, {
-				knex: this.knex,
-				schema: this.schema
-			});
-		}
+		if (this.accountability) await validateAccess({
+			accountability: this.accountability,
+			action: "read",
+			collection: "directus_relations"
+		}, {
+			knex: this.knex,
+			schema: this.schema
+		});
 		const metaReadQuery = { limit: -1 };
-		if (collection) {
-			metaReadQuery.filter = { many_collection: { _eq: collection } };
-		}
+		if (collection) metaReadQuery.filter = { many_collection: { _eq: collection } };
 		const metaRows = [...await this.relationsItemService.readByQuery(metaReadQuery, opts), ...systemRelationRows].filter((metaRow) => {
 			if (!collection) return true;
 			return metaRow.many_collection === collection;
 		});
 		let schemaRows = bypassCache ? await this.schemaInspector.foreignKeys() : await this.foreignKeys(collection);
-		if (collection && bypassCache) {
-			schemaRows = schemaRows.filter((row) => row.table === collection);
-		}
+		if (collection && bypassCache) schemaRows = schemaRows.filter((row) => row.table === collection);
 		const results = this.stitchRelations(metaRows, schemaRows);
 		return await this.filterForbidden(results);
 	}
@@ -101,9 +89,7 @@ var RelationsService = class {
 				schema: this.schema,
 				knex: this.knex
 			});
-			if (allowedFields.includes("*") === false && allowedFields.includes(field) === false) {
-				throw new ForbiddenError();
-			}
+			if (allowedFields.includes("*") === false && allowedFields.includes(field) === false) throw new ForbiddenError();
 		}
 		const metaRow = await this.relationsItemService.readByQuery({
 			limit: 1,
@@ -112,42 +98,23 @@ var RelationsService = class {
 		const schemaRow = (await this.foreignKeys(collection)).find((foreignKey) => foreignKey.column === field);
 		const stitched = this.stitchRelations(metaRow, schemaRow ? [schemaRow] : []);
 		const results = await this.filterForbidden(stitched);
-		if (results.length === 0) {
-			throw new ForbiddenError();
-		}
+		if (results.length === 0) throw new ForbiddenError();
 		return results[0];
 	}
 	/**
 	* Create a new relationship / foreign key constraint
 	*/
 	async createOne(relation, opts) {
-		if (this.accountability && this.accountability.admin !== true) {
-			throw new ForbiddenError();
-		}
-		if (!relation.collection) {
-			throw new InvalidPayloadError({ reason: "\"collection\" is required" });
-		}
-		if (!relation.field) {
-			throw new InvalidPayloadError({ reason: "\"field\" is required" });
-		}
+		if (this.accountability && this.accountability.admin !== true) throw new ForbiddenError();
+		if (!relation.collection) throw new InvalidPayloadError({ reason: "\"collection\" is required" });
+		if (!relation.field) throw new InvalidPayloadError({ reason: "\"field\" is required" });
 		const collectionSchema = this.schema.collections[relation.collection];
-		if (!collectionSchema) {
-			throw new InvalidPayloadError({ reason: `Collection "${relation.collection}" doesn't exist` });
-		}
+		if (!collectionSchema) throw new InvalidPayloadError({ reason: `Collection "${relation.collection}" doesn't exist` });
 		const fieldSchema = collectionSchema.fields[relation.field];
-		if (!fieldSchema) {
-			throw new InvalidPayloadError({ reason: `Field "${relation.field}" doesn't exist in collection "${relation.collection}"` });
-		}
-		if (collectionSchema.primary === relation.field) {
-			throw new InvalidPayloadError({ reason: `Field "${relation.field}" in collection "${relation.collection}" is a primary key` });
-		}
-		if (relation.related_collection && relation.related_collection in this.schema.collections === false) {
-			throw new InvalidPayloadError({ reason: `Collection "${relation.related_collection}" doesn't exist` });
-		}
-		const existingRelation = this.schema.relations.find((existingRelation$1) => existingRelation$1.collection === relation.collection && existingRelation$1.field === relation.field);
-		if (existingRelation) {
-			throw new InvalidPayloadError({ reason: `Field "${relation.field}" in collection "${relation.collection}" already has an associated relationship` });
-		}
+		if (!fieldSchema) throw new InvalidPayloadError({ reason: `Field "${relation.field}" doesn't exist in collection "${relation.collection}"` });
+		if (collectionSchema.primary === relation.field) throw new InvalidPayloadError({ reason: `Field "${relation.field}" in collection "${relation.collection}" is a primary key` });
+		if (relation.related_collection && relation.related_collection in this.schema.collections === false) throw new InvalidPayloadError({ reason: `Collection "${relation.related_collection}" doesn't exist` });
+		if (this.schema.relations.find((existingRelation) => existingRelation.collection === relation.collection && existingRelation.field === relation.field)) throw new InvalidPayloadError({ reason: `Field "${relation.field}" in collection "${relation.collection}" already has an associated relationship` });
 		const runPostColumnChange = await this.helpers.schema.preColumnChange();
 		this.helpers.schema.preRelationChange(relation);
 		const nestedActionEvents = [];
@@ -159,32 +126,21 @@ var RelationsService = class {
 				one_collection: relation.related_collection || null
 			};
 			await transaction(this.knex, async (trx) => {
-				if (relation.related_collection) {
-					await trx.schema.alterTable(relation.collection, async (table) => {
-						this.alterType(table, relation, fieldSchema.nullable);
-						const constraintName = getDefaultIndexName("foreign", relation.collection, relation.field);
-						const builder = table.foreign(relation.field, constraintName).references(`${relation.related_collection}.${this.schema.collections[relation.related_collection].primary}`);
-						if (relation.schema?.on_delete) {
-							builder.onDelete(relation.schema.on_delete);
-						}
-						if (relation.schema?.on_update) {
-							builder.onUpdate(relation.schema.on_update);
-						}
-					});
-				}
-				const relationsItemService = new ItemsService("directus_relations", {
+				if (relation.related_collection) await trx.schema.alterTable(relation.collection, async (table) => {
+					this.alterType(table, relation, fieldSchema.nullable);
+					const constraintName = getDefaultIndexName("foreign", relation.collection, relation.field);
+					const builder = table.foreign(relation.field, constraintName).references(`${relation.related_collection}.${this.schema.collections[relation.related_collection].primary}`);
+					if (relation.schema?.on_delete) builder.onDelete(relation.schema.on_delete);
+					if (relation.schema?.on_update) builder.onUpdate(relation.schema.on_update);
+				});
+				await new ItemsService("directus_relations", {
 					knex: trx,
 					schema: this.schema
-				});
-				await relationsItemService.createOne(metaRow, { bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params) });
+				}).createOne(metaRow, { bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params) });
 			});
 		} finally {
-			if (runPostColumnChange) {
-				await this.helpers.schema.postColumnChange();
-			}
-			if (opts?.autoPurgeSystemCache !== false) {
-				await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
-			}
+			if (runPostColumnChange) await this.helpers.schema.postColumnChange();
+			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) {
@@ -200,69 +156,46 @@ var RelationsService = class {
 	* Note: You can update anything under meta, but only the `on_delete` trigger under schema
 	*/
 	async updateOne(collection, field, relation, opts) {
-		if (this.accountability && this.accountability.admin !== true) {
-			throw new ForbiddenError();
-		}
+		if (this.accountability && this.accountability.admin !== true) throw new ForbiddenError();
 		const collectionSchema = this.schema.collections[collection];
-		if (!collectionSchema) {
-			throw new InvalidPayloadError({ reason: `Collection "${collection}" doesn't exist` });
-		}
+		if (!collectionSchema) throw new InvalidPayloadError({ reason: `Collection "${collection}" doesn't exist` });
 		const fieldSchema = collectionSchema.fields[field];
-		if (!fieldSchema) {
-			throw new InvalidPayloadError({ reason: `Field "${field}" doesn't exist in collection "${collection}"` });
-		}
+		if (!fieldSchema) throw new InvalidPayloadError({ reason: `Field "${field}" doesn't exist in collection "${collection}"` });
 		const existingRelation = this.schema.relations.find((existingRelation$1) => existingRelation$1.collection === collection && existingRelation$1.field === field);
-		if (!existingRelation) {
-			throw new InvalidPayloadError({ reason: `Field "${field}" in collection "${collection}" doesn't have a relationship.` });
-		}
+		if (!existingRelation) throw new InvalidPayloadError({ reason: `Field "${field}" in collection "${collection}" doesn't have a relationship.` });
 		const runPostColumnChange = await this.helpers.schema.preColumnChange();
 		this.helpers.schema.preRelationChange(relation);
 		const nestedActionEvents = [];
 		try {
 			await transaction(this.knex, async (trx) => {
-				if (existingRelation.related_collection) {
-					await trx.schema.alterTable(collection, async (table) => {
-						let constraintName = getDefaultIndexName("foreign", collection, field);
-						if (existingRelation?.schema) {
-							constraintName = existingRelation.schema.constraint_name || constraintName;
-							table.dropForeign(field, constraintName);
-							constraintName = this.helpers.schema.constraintName(constraintName);
-							existingRelation.schema.constraint_name = constraintName;
-						}
-						this.alterType(table, relation, fieldSchema.nullable);
-						const builder = table.foreign(field, constraintName || undefined).references(`${existingRelation.related_collection}.${this.schema.collections[existingRelation.related_collection].primary}`);
-						if (relation.schema?.on_delete) {
-							builder.onDelete(relation.schema.on_delete);
-						}
-						if (relation.schema?.on_update) {
-							builder.onUpdate(relation.schema.on_update);
-						}
-					});
-				}
+				if (existingRelation.related_collection) await trx.schema.alterTable(collection, async (table) => {
+					let constraintName = getDefaultIndexName("foreign", collection, field);
+					if (existingRelation?.schema) {
+						constraintName = existingRelation.schema.constraint_name || constraintName;
+						table.dropForeign(field, constraintName);
+						constraintName = this.helpers.schema.constraintName(constraintName);
+						existingRelation.schema.constraint_name = constraintName;
+					}
+					this.alterType(table, relation, fieldSchema.nullable);
+					const builder = table.foreign(field, constraintName || void 0).references(`${existingRelation.related_collection}.${this.schema.collections[existingRelation.related_collection].primary}`);
+					if (relation.schema?.on_delete) builder.onDelete(relation.schema.on_delete);
+					if (relation.schema?.on_update) builder.onUpdate(relation.schema.on_update);
+				});
 				const relationsItemService = new ItemsService("directus_relations", {
 					knex: trx,
 					schema: this.schema
 				});
-				if (relation.meta) {
-					if (existingRelation?.meta) {
-						await relationsItemService.updateOne(existingRelation.meta.id, relation.meta, { bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params) });
-					} else {
-						await relationsItemService.createOne({
-							...relation.meta || {},
-							many_collection: relation.collection,
-							many_field: relation.field,
-							one_collection: existingRelation.related_collection || null
-						}, { bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params) });
-					}
-				}
+				if (relation.meta) if (existingRelation?.meta) await relationsItemService.updateOne(existingRelation.meta.id, relation.meta, { bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params) });
+				else await relationsItemService.createOne({
+					...relation.meta || {},
+					many_collection: relation.collection,
+					many_field: relation.field,
+					one_collection: existingRelation.related_collection || null
+				}, { bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params) });
 			});
 		} finally {
-			if (runPostColumnChange) {
-				await this.helpers.schema.postColumnChange();
-			}
-			if (opts?.autoPurgeSystemCache !== false) {
-				await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
-			}
+			if (runPostColumnChange) await this.helpers.schema.postColumnChange();
+			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) {
@@ -276,36 +209,23 @@ var RelationsService = class {
 	* Delete an existing relationship
 	*/
 	async deleteOne(collection, field, opts) {
-		if (this.accountability && this.accountability.admin !== true) {
-			throw new ForbiddenError();
-		}
-		if (collection in this.schema.collections === false) {
-			throw new InvalidPayloadError({ reason: `Collection "${collection}" doesn't exist` });
-		}
-		if (field in this.schema.collections[collection].fields === false) {
-			throw new InvalidPayloadError({ reason: `Field "${field}" doesn't exist in collection "${collection}"` });
-		}
+		if (this.accountability && this.accountability.admin !== true) throw new ForbiddenError();
+		if (collection in this.schema.collections === false) throw new InvalidPayloadError({ reason: `Collection "${collection}" doesn't exist` });
+		if (field in this.schema.collections[collection].fields === false) throw new InvalidPayloadError({ reason: `Field "${field}" doesn't exist in collection "${collection}"` });
 		const existingRelation = this.schema.relations.find((existingRelation$1) => existingRelation$1.collection === collection && existingRelation$1.field === field);
-		if (!existingRelation) {
-			throw new InvalidPayloadError({ reason: `Field "${field}" in collection "${collection}" doesn't have a relationship.` });
-		}
+		if (!existingRelation) throw new InvalidPayloadError({ reason: `Field "${field}" in collection "${collection}" doesn't have a relationship.` });
 		const runPostColumnChange = await this.helpers.schema.preColumnChange();
 		const nestedActionEvents = [];
 		try {
 			await transaction(this.knex, async (trx) => {
-				const existingConstraints = await this.foreignKeys();
-				const constraintNames = existingConstraints.map((key) => key.constraint_name);
-				if (existingRelation.schema?.constraint_name && constraintNames.includes(existingRelation.schema.constraint_name)) {
-					await trx.schema.alterTable(existingRelation.collection, (table) => {
-						table.dropForeign(existingRelation.field, existingRelation.schema.constraint_name);
-					});
-				}
-				if (existingRelation.meta) {
-					await trx("directus_relations").delete().where({
-						many_collection: collection,
-						many_field: field
-					});
-				}
+				const constraintNames = (await this.foreignKeys()).map((key) => key.constraint_name);
+				if (existingRelation.schema?.constraint_name && constraintNames.includes(existingRelation.schema.constraint_name)) await trx.schema.alterTable(existingRelation.collection, (table) => {
+					table.dropForeign(existingRelation.field, existingRelation.schema.constraint_name);
+				});
+				if (existingRelation.meta) await trx("directus_relations").delete().where({
+					many_collection: collection,
+					many_field: field
+				});
 				const actionEvent = {
 					event: "relations.delete",
 					meta: {
@@ -318,19 +238,12 @@ var RelationsService = class {
 						accountability: this.accountability
 					}
 				};
-				if (opts?.bypassEmitAction) {
-					opts.bypassEmitAction(actionEvent);
-				} else {
-					nestedActionEvents.push(actionEvent);
-				}
+				if (opts?.bypassEmitAction) opts.bypassEmitAction(actionEvent);
+				else nestedActionEvents.push(actionEvent);
 			});
 		} finally {
-			if (runPostColumnChange) {
-				await this.helpers.schema.postColumnChange();
-			}
-			if (opts?.autoPurgeSystemCache !== false) {
-				await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
-			}
+			if (runPostColumnChange) await this.helpers.schema.postColumnChange();
+			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) {
@@ -394,21 +307,11 @@ var RelationsService = class {
 		return relations.filter((relation) => {
 			let collectionsAllowed = true;
 			let fieldsAllowed = true;
-			if (allowedCollections.includes(relation.collection) === false) {
-				collectionsAllowed = false;
-			}
-			if (relation.related_collection && allowedCollections.includes(relation.related_collection) === false) {
-				collectionsAllowed = false;
-			}
-			if (relation.meta?.one_allowed_collections && relation.meta?.one_allowed_collections.every((collection) => allowedCollections.includes(collection)) === false) {
-				collectionsAllowed = false;
-			}
-			if (!allowedFields[relation.collection] || allowedFields[relation.collection]?.includes("*") === false && allowedFields[relation.collection]?.includes(relation.field) === false) {
-				fieldsAllowed = false;
-			}
-			if (relation.related_collection && relation.meta?.one_field && (!allowedFields[relation.related_collection] || allowedFields[relation.related_collection]?.includes("*") === false && allowedFields[relation.related_collection]?.includes(relation.meta.one_field) === false)) {
-				fieldsAllowed = false;
-			}
+			if (allowedCollections.includes(relation.collection) === false) collectionsAllowed = false;
+			if (relation.related_collection && allowedCollections.includes(relation.related_collection) === false) collectionsAllowed = false;
+			if (relation.meta?.one_allowed_collections && relation.meta?.one_allowed_collections.every((collection) => allowedCollections.includes(collection)) === false) collectionsAllowed = false;
+			if (!allowedFields[relation.collection] || allowedFields[relation.collection]?.includes("*") === false && allowedFields[relation.collection]?.includes(relation.field) === false) fieldsAllowed = false;
+			if (relation.related_collection && relation.meta?.one_field && (!allowedFields[relation.related_collection] || allowedFields[relation.related_collection]?.includes("*") === false && allowedFields[relation.related_collection]?.includes(relation.meta.one_field) === false)) fieldsAllowed = false;
 			return collectionsAllowed && fieldsAllowed;
 		});
 	}
@@ -427,9 +330,7 @@ var RelationsService = class {
 		const relatedFieldDBType = this.schema.collections[relation.related_collection].fields[this.schema.collections[relation.related_collection].primary].dbType;
 		if (m2oFieldDBType !== relatedFieldDBType && m2oFieldDBType === "int" && relatedFieldDBType === "int unsigned") {
 			const alterField = table.specificType(relation.field, "int unsigned");
-			if (!nullable) {
-				alterField.notNullable();
-			}
+			if (!nullable) alterField.notNullable();
 			alterField.alter();
 		}
 	}

package/dist/services/revisions.js

@@ -10,26 +10,19 @@ var RevisionsService = class extends ItemsService {
 		const revision = await super.readOne(pk);
 		if (!revision) throw new ForbiddenError();
 		if (!revision["data"]) throw new InvalidPayloadError({ reason: `Revision doesn't contain data to revert to` });
-		const service = new ItemsService(revision["collection"], {
+		await new ItemsService(revision["collection"], {
 			accountability: this.accountability,
 			knex: this.knex,
 			schema: this.schema
-		});
-		await service.updateOne(revision["item"], revision["data"]);
+		}).updateOne(revision["item"], revision["data"]);
 	}
 	setDefaultOptions(opts) {
-		if (!opts) {
-			return {
-				autoPurgeCache: false,
-				bypassLimits: true
-			};
-		}
-		if (!("autoPurgeCache" in opts)) {
-			opts.autoPurgeCache = false;
-		}
-		if (!("bypassLimits" in opts)) {
-			opts.bypassLimits = true;
-		}
+		if (!opts) return {
+			autoPurgeCache: false,
+			bypassLimits: true
+		};
+		if (!("autoPurgeCache" in opts)) opts.autoPurgeCache = false;
+		if (!("bypassLimits" in opts)) opts.bypassLimits = true;
 		return opts;
 	}
 	async createOne(data, opts) {

package/dist/services/roles.js

@@ -20,9 +20,7 @@ var RolesService = class RolesService extends ItemsService {
 			await this.validateRoleNesting(keys, data["parent"]);
 		}
 		const result = await super.updateMany(keys, data, opts);
-		if ("parent" in data) {
-			await this.clearCaches();
-		}
+		if ("parent" in data) await this.clearCaches();
 		return result;
 	}
 	async deleteMany(keys, opts = {}) {
@@ -61,19 +59,13 @@ var RolesService = class RolesService extends ItemsService {
 		return keys;
 	}
 	async validateRoleNesting(ids, parent) {
-		if (ids.includes(parent)) {
-			throw new InvalidPayloadError({ reason: "A role cannot be a parent of itself" });
-		}
+		if (ids.includes(parent)) throw new InvalidPayloadError({ reason: "A role cannot be a parent of itself" });
 		const roles = await fetchRolesTree(parent, { knex: this.knex });
-		if (ids.some((id) => roles.includes(id))) {
-			throw new InvalidPayloadError({ reason: "A role cannot have a parent that is already a descendant of itself" });
-		}
+		if (ids.some((id) => roles.includes(id))) throw new InvalidPayloadError({ reason: "A role cannot have a parent that is already a descendant of itself" });
 	}
 	async clearCaches(opts) {
 		await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
-		if (this.cache && opts?.autoPurgeCache !== false) {
-			await this.cache.clear();
-		}
+		if (this.cache && opts?.autoPurgeCache !== false) await this.cache.clear();
 	}
 };
 

package/dist/services/schema.js

@@ -17,24 +17,19 @@ var SchemaService = class {
 	}
 	async snapshot() {
 		if (this.accountability?.admin !== true) throw new ForbiddenError();
-		const currentSnapshot = await getSnapshot({ database: this.knex });
-		return currentSnapshot;
+		return await getSnapshot({ database: this.knex });
 	}
 	async apply(payload) {
 		if (this.accountability?.admin !== true) throw new ForbiddenError();
 		const currentSnapshot = await this.snapshot();
-		const snapshotWithHash = this.getHashedSnapshot(currentSnapshot);
-		if (!validateApplyDiff(payload, snapshotWithHash)) return;
+		if (!validateApplyDiff(payload, this.getHashedSnapshot(currentSnapshot))) return;
 		await applyDiff(currentSnapshot, payload.diff, { database: this.knex });
 	}
 	async diff(snapshot, options) {
 		if (this.accountability?.admin !== true) throw new ForbiddenError();
 		validateSnapshot(snapshot, options?.force);
-		const currentSnapshot = options?.currentSnapshot ?? await getSnapshot({ database: this.knex });
-		const diff = getSnapshotDiff(currentSnapshot, snapshot);
-		if (diff.collections.length === 0 && diff.fields.length === 0 && diff.relations.length === 0 && (!diff.systemFields || diff.systemFields.length === 0)) {
-			return null;
-		}
+		const diff = getSnapshotDiff(options?.currentSnapshot ?? await getSnapshot({ database: this.knex }), snapshot);
+		if (diff.collections.length === 0 && diff.fields.length === 0 && diff.relations.length === 0 && (!diff.systemFields || diff.systemFields.length === 0)) return null;
 		return diff;
 	}
 	getHashedSnapshot(snapshot) {