@directus/api 35.0.2 → 35.1.0

package/dist/services/deployment-projects.js

@@ -14,11 +14,10 @@ var DeploymentProjectsService = class DeploymentProjectsService extends ItemsSer
 	* Find a project by its provider-side external ID. Returns null if not tracked.
 	*/
 	async readByExternalId(externalId) {
-		const results = await this.readByQuery({
+		return (await this.readByQuery({
 			filter: { external_id: { _eq: externalId } },
 			limit: 1
-		});
-		return results?.[0] ?? null;
+		}))?.[0] ?? null;
 	}
 	/**
 	* List provider projects merged with DB selection, syncing metadata.
@@ -38,9 +37,7 @@ var DeploymentProjectsService = class DeploymentProjectsService extends ItemsSer
 				deployable: providerProject.deployable
 			};
 		}).filter((update) => update !== null);
-		if (toUpdate.length > 0) {
-			await this.updateBatch(toUpdate);
-		}
+		if (toUpdate.length > 0) await this.updateBatch(toUpdate);
 		return providerProjects.map((project) => ({
 			id: selectedMap.get(project.id)?.id ?? null,
 			external_id: project.id,
@@ -55,14 +52,10 @@ var DeploymentProjectsService = class DeploymentProjectsService extends ItemsSer
 	async validateDeployable(provider, projectsToCreate) {
 		if (projectsToCreate.length === 0) return;
 		const config = await this.readConfig(provider);
-		const driver = this.createDriver(config);
-		const providerProjects = await driver.listProjects();
+		const providerProjects = await this.createDriver(config).listProjects();
 		const projectsMap = new Map(providerProjects.map((p) => [p.id, p]));
 		const nonDeployable = projectsToCreate.filter((p) => !projectsMap.get(p.external_id)?.deployable);
-		if (nonDeployable.length > 0) {
-			const names = nonDeployable.map((p) => projectsMap.get(p.external_id)?.name || p.external_id).join(", ");
-			throw new InvalidPayloadError({ reason: `Cannot add non-deployable projects: ${names}` });
-		}
+		if (nonDeployable.length > 0) throw new InvalidPayloadError({ reason: `Cannot add non-deployable projects: ${nonDeployable.map((p) => projectsMap.get(p.external_id)?.name || p.external_id).join(", ")}` });
 	}
 	/**
 	* Update project selection (create/delete)
@@ -87,19 +80,15 @@ var DeploymentProjectsService = class DeploymentProjectsService extends ItemsSer
 				schema: this.schema,
 				knex: trx
 			});
-			if (deleteIds.length > 0) {
-				await trxService.deleteMany(deleteIds);
-			}
-			if (enrichedCreate.length > 0) {
-				await trxService.createMany(enrichedCreate.map((p) => ({
-					deployment: config.id,
-					external_id: p.external_id,
-					name: p.name,
-					url: p.url,
-					framework: p.framework,
-					deployable: p.deployable
-				})));
-			}
+			if (deleteIds.length > 0) await trxService.deleteMany(deleteIds);
+			if (enrichedCreate.length > 0) await trxService.createMany(enrichedCreate.map((p) => ({
+				deployment: config.id,
+				external_id: p.external_id,
+				name: p.name,
+				url: p.url,
+				framework: p.framework,
+				deployable: p.deployable
+			})));
 			return trxService.readByQuery({
 				filter: { deployment: { _eq: config.id } },
 				limit: -1
@@ -110,18 +99,15 @@ var DeploymentProjectsService = class DeploymentProjectsService extends ItemsSer
 	* Read deployment config by provider (null accountability for internal use).
 	*/
 	async readConfig(provider) {
-		const internalService = new ItemsService("directus_deployments", {
+		const results = await new ItemsService("directus_deployments", {
 			knex: this.knex,
 			schema: this.schema,
 			accountability: null
-		});
-		const results = await internalService.readByQuery({
+		}).readByQuery({
 			filter: { provider: { _eq: provider } },
 			limit: 1
 		});
-		if (!results || results.length === 0) {
-			throw new Error(`Deployment config for "${provider}" not found`);
-		}
+		if (!results || results.length === 0) throw new Error(`Deployment config for "${provider}" not found`);
 		return results[0];
 	}
 	createDriver(config) {

package/dist/services/deployment.js

@@ -14,19 +14,15 @@ import { has, isEmpty } from "lodash-es";
 //#region src/services/deployment.ts
 const env = useEnv();
 const DEPLOYMENT_CACHE_TTL = getMilliseconds(env["CACHE_DEPLOYMENT_TTL"]) || 5e3;
-const SYNC_THRESHOLD_MS = 60 * 60 * 1e3;
+const SYNC_THRESHOLD_MS = 3600 * 1e3;
 var DeploymentService = class DeploymentService extends ItemsService {
 	constructor(options) {
 		super("directus_deployments", options);
 	}
 	async createOne(data, opts) {
 		const provider = data.provider;
-		if (!provider) {
-			throw new InvalidPayloadError({ reason: "Provider is required" });
-		}
-		if (isEmpty(data.credentials)) {
-			throw new InvalidPayloadError({ reason: "Credentials are required" });
-		}
+		if (!provider) throw new InvalidPayloadError({ reason: "Provider is required" });
+		if (isEmpty(data.credentials)) throw new InvalidPayloadError({ reason: "Credentials are required" });
 		let credentials;
 		try {
 			credentials = parseValue(data.credentials, {});
@@ -35,7 +31,7 @@ var DeploymentService = class DeploymentService extends ItemsService {
 		}
 		let options;
 		try {
-			options = parseValue(data.options, undefined);
+			options = parseValue(data.options, void 0);
 		} catch {
 			throw new InvalidPayloadError({ reason: "Options must be valid JSON" });
 		}
@@ -52,42 +48,33 @@ var DeploymentService = class DeploymentService extends ItemsService {
 			...data,
 			credentials: JSON.stringify(credentials)
 		};
-		if (!isEmpty(options)) {
-			payload.options = JSON.stringify(options);
-		}
+		if (!isEmpty(options)) payload.options = JSON.stringify(options);
 		return super.createOne(payload, opts);
 	}
 	async updateOne(key, data, opts) {
 		const hasCredentials = has(data, "credentials");
 		const hasOptions = has(data, "options");
-		if (!hasCredentials && !hasOptions) {
-			return super.updateOne(key, data, opts);
-		}
+		if (!hasCredentials && !hasOptions) return super.updateOne(key, data, opts);
 		const existing = await this.readOne(key);
 		const provider = existing.provider;
-		const internal = await this.readConfig(provider);
-		let credentials = parseValue(internal.credentials, {});
-		if (hasCredentials) {
-			try {
-				const parsed = parseValue(data.credentials, {});
-				credentials = {
-					...credentials,
-					...parsed
-				};
-			} catch {
-				throw new InvalidPayloadError({ reason: "Credentials must be valid JSON or object" });
-			}
+		let credentials = parseValue((await this.readConfig(provider)).credentials, {});
+		if (hasCredentials) try {
+			const parsed = parseValue(data.credentials, {});
+			credentials = {
+				...credentials,
+				...parsed
+			};
+		} catch {
+			throw new InvalidPayloadError({ reason: "Credentials must be valid JSON or object" });
 		}
-		let options = existing.options ?? undefined;
+		let options = existing.options ?? void 0;
 		if (hasOptions) {
 			try {
-				options = parseValue(data.options, undefined);
+				options = parseValue(data.options, void 0);
 			} catch {
 				throw new InvalidPayloadError({ reason: "Options must be valid JSON" });
 			}
-			if (isEmpty(options)) {
-				throw new InvalidPayloadError({ reason: "Options must not be empty" });
-			}
+			if (isEmpty(options)) throw new InvalidPayloadError({ reason: "Options must not be empty" });
 		}
 		const driver = getDeploymentDriver(provider, credentials, options);
 		try {
@@ -112,9 +99,7 @@ var DeploymentService = class DeploymentService extends ItemsService {
 			filter: mergeFilters({ provider: { _eq: provider } }, query?.filter ?? null),
 			limit: 1
 		});
-		if (!results || results.length === 0) {
-			throw new Error(`Deployment config for "${provider}" not found`);
-		}
+		if (!results || results.length === 0) throw new Error(`Deployment config for "${provider}" not found`);
 		return results[0];
 	}
 	/**
@@ -129,14 +114,10 @@ var DeploymentService = class DeploymentService extends ItemsService {
 	*/
 	async deleteByProvider(provider) {
 		const deployment = await this.readByProvider(provider);
-		if (deployment.webhook_ids && deployment.webhook_ids.length > 0) {
-			try {
-				const driver = await this.getDriver(provider);
-				await driver.unregisterWebhook(deployment.webhook_ids);
-			} catch (err) {
-				const logger = useLogger();
-				logger.error(`Failed to unregister webhook for ${provider}: ${err}`);
-			}
+		if (deployment.webhook_ids && deployment.webhook_ids.length > 0) try {
+			await (await this.getDriver(provider)).unregisterWebhook(deployment.webhook_ids);
+		} catch (err) {
+			useLogger().error(`Failed to unregister webhook for ${provider}: ${err}`);
 		}
 		return this.deleteOne(deployment.id);
 	}
@@ -144,18 +125,15 @@ var DeploymentService = class DeploymentService extends ItemsService {
 	* Read deployment config with decrypted credentials (internal use)
 	*/
 	async readConfig(provider) {
-		const internalService = new ItemsService("directus_deployments", {
+		const results = await new ItemsService("directus_deployments", {
 			knex: this.knex,
 			schema: this.schema,
 			accountability: null
-		});
-		const results = await internalService.readByQuery({
+		}).readByQuery({
 			filter: { provider: { _eq: provider } },
 			limit: 1
 		});
-		if (!results || results.length === 0) {
-			throw new Error(`Deployment config for "${provider}" not found`);
-		}
+		if (!results || results.length === 0) throw new Error(`Deployment config for "${provider}" not found`);
 		return results[0];
 	}
 	/**
@@ -185,16 +163,14 @@ var DeploymentService = class DeploymentService extends ItemsService {
 		const logger = useLogger();
 		logger.debug(`[webhook:${provider}] Starting webhook sync`);
 		const config = await this.readConfig(provider);
-		const projectsService = new ItemsService("directus_deployment_projects", {
+		const projectExternalIds = (await new ItemsService("directus_deployment_projects", {
 			knex: this.knex,
 			schema: this.schema,
 			accountability: null
-		});
-		const projects = await projectsService.readByQuery({
+		}).readByQuery({
 			filter: { deployment: { _eq: config.id } },
 			limit: -1
-		});
-		const projectExternalIds = projects.map((p) => p.external_id);
+		})).map((p) => p.external_id);
 		const driver = await this.getDriver(provider);
 		if (projectExternalIds.length === 0) {
 			if (config.webhook_ids && config.webhook_ids.length > 0) {
@@ -219,8 +195,7 @@ var DeploymentService = class DeploymentService extends ItemsService {
 				logger.warn(`[webhook:${provider}] Failed to unregister: ${err}`);
 			}
 		}
-		const publicUrl = env["PUBLIC_URL"];
-		const webhookUrl = `${publicUrl}/deployments/webhooks/${provider}`;
+		const webhookUrl = `${env["PUBLIC_URL"]}/deployments/webhooks/${provider}`;
 		logger.debug(`[webhook:${provider}] Registering webhook → ${webhookUrl} for ${projectExternalIds.length} project(s)`);
 		const result = await driver.registerWebhook(webhookUrl, projectExternalIds);
 		await super.updateOne(config.id, {
@@ -236,14 +211,11 @@ var DeploymentService = class DeploymentService extends ItemsService {
 		const cacheKey = `${provider}:projects`;
 		const { deploymentCache } = getCache();
 		const cached = await getCacheValueWithTTL(deploymentCache, cacheKey);
-		if (cached) {
-			return {
-				data: cached.data,
-				remainingTTL: cached.remainingTTL
-			};
-		}
-		const driver = await this.getDriver(provider);
-		const projects = await driver.listProjects();
+		if (cached) return {
+			data: cached.data,
+			remainingTTL: cached.remainingTTL
+		};
+		const projects = await (await this.getDriver(provider)).listProjects();
 		await setCacheValueWithExpiry(deploymentCache, cacheKey, projects, DEPLOYMENT_CACHE_TTL);
 		return {
 			data: projects,
@@ -257,14 +229,11 @@ var DeploymentService = class DeploymentService extends ItemsService {
 		const cacheKey = `${provider}:project:${projectId}`;
 		const { deploymentCache } = getCache();
 		const cached = await getCacheValueWithTTL(deploymentCache, cacheKey);
-		if (cached) {
-			return {
-				data: cached.data,
-				remainingTTL: cached.remainingTTL
-			};
-		}
-		const driver = await this.getDriver(provider);
-		const project = await driver.getProject(projectId);
+		if (cached) return {
+			data: cached.data,
+			remainingTTL: cached.remainingTTL
+		};
+		const project = await (await this.getDriver(provider)).getProject(projectId);
 		await setCacheValueWithExpiry(deploymentCache, cacheKey, project, DEPLOYMENT_CACHE_TTL);
 		return {
 			data: project,
@@ -288,27 +257,24 @@ var DeploymentService = class DeploymentService extends ItemsService {
 			filter: { deployment: { _eq: deployment.id } },
 			limit: -1
 		});
-		if (selectedProjects.length === 0) {
-			return {
-				projects: [],
-				stats: {
-					active_deployments: 0,
-					successful_builds: 0,
-					failed_builds: 0
-				}
-			};
-		}
+		if (selectedProjects.length === 0) return {
+			projects: [],
+			stats: {
+				active_deployments: 0,
+				successful_builds: 0,
+				failed_builds: 0
+			}
+		};
 		const projectIds = selectedProjects.map((p) => p.id);
 		const [latestRuns, activeResult, statusCounts] = await Promise.all([
 			Promise.all(projectIds.map(async (projectId) => {
-				const runs = await runsService.readByQuery({
-					filter: { project: { _eq: projectId } },
-					sort: ["-date_created"],
-					limit: 1
-				});
 				return {
 					projectId,
-					run: runs?.[0] ?? null
+					run: (await runsService.readByQuery({
+						filter: { project: { _eq: projectId } },
+						sort: ["-date_created"],
+						limit: 1
+					}))?.[0] ?? null
 				};
 			})),
 			runsService.readByQuery({
@@ -331,8 +297,7 @@ var DeploymentService = class DeploymentService extends ItemsService {
 		const latestRunMap = new Map(latestRuns.map((r) => [r.projectId, r.run]));
 		const countByStatus = (status) => Number(statusCounts.find((r) => r["status"] === status)?.["count"] ?? 0);
 		this.syncProjectMetadataIfStale(provider, deployment).catch((err) => {
-			const logger = useLogger();
-			logger.error(`Failed to sync project metadata for ${provider}: ${err}`);
+			useLogger().error(`Failed to sync project metadata for ${provider}: ${err}`);
 		});
 		return {
 			projects: selectedProjects.map((p) => {
@@ -366,8 +331,7 @@ var DeploymentService = class DeploymentService extends ItemsService {
 			const lastSync = new Date(deployment.last_synced_at).getTime();
 			if (Date.now() - lastSync < SYNC_THRESHOLD_MS) return;
 		}
-		const logger = useLogger();
-		logger.debug(`[metadata:${provider}] Syncing project metadata`);
+		useLogger().debug(`[metadata:${provider}] Syncing project metadata`);
 		const projectsService = new DeploymentProjectsService({
 			accountability: null,
 			schema: this.schema
@@ -387,14 +351,11 @@ var DeploymentService = class DeploymentService extends ItemsService {
 				deployable: details.deployable
 			};
 		}));
-		if (updates.length > 0) {
-			await projectsService.updateBatch(updates);
-		}
-		const internalService = new DeploymentService({
+		if (updates.length > 0) await projectsService.updateBatch(updates);
+		await new DeploymentService({
 			accountability: null,
 			schema: this.schema
-		});
-		await internalService.updateOne(deployment.id, { last_synced_at: new Date().toISOString() });
+		}).updateOne(deployment.id, { last_synced_at: (/* @__PURE__ */ new Date()).toISOString() });
 	}
 	/**
 	* Trigger a deployment for a project
@@ -409,8 +370,7 @@ var DeploymentService = class DeploymentService extends ItemsService {
 			schema: this.schema
 		});
 		const project = await projectsService.readOne(projectId);
-		const driver = await this.getDriver(provider);
-		const result = await driver.triggerDeployment(project.external_id, {
+		const result = await (await this.getDriver(provider)).triggerDeployment(project.external_id, {
 			preview: options.preview,
 			clearCache: options.clearCache
 		});
@@ -433,8 +393,7 @@ var DeploymentService = class DeploymentService extends ItemsService {
 			schema: this.schema
 		});
 		const run = await runsService.readOne(runId);
-		const driver = await this.getDriver(provider);
-		const status = await driver.cancelDeployment(run.external_id);
+		const status = await (await this.getDriver(provider)).cancelDeployment(run.external_id);
 		await runsService.updateOne(runId, { status });
 		return runsService.readOne(runId);
 	}
@@ -442,13 +401,11 @@ var DeploymentService = class DeploymentService extends ItemsService {
 	* Get a run with its logs from the provider
 	*/
 	async getRunWithLogs(provider, runId, since) {
-		const runsService = new DeploymentRunsService({
+		const run = await new DeploymentRunsService({
 			accountability: this.accountability,
 			schema: this.schema
-		});
-		const run = await runsService.readOne(runId);
-		const driver = await this.getDriver(provider);
-		const logs = await driver.getDeploymentLogs(run.external_id, since ? { since } : undefined);
+		}).readOne(runId);
+		const logs = await (await this.getDriver(provider)).getDeploymentLogs(run.external_id, since ? { since } : void 0);
 		return {
 			...run,
 			logs

package/dist/services/extensions.js

@@ -35,27 +35,13 @@ var ExtensionsService = class ExtensionsService {
 	async preInstall(extensionId, versionId) {
 		const env = useEnv();
 		const describeOptions = {};
-		if (typeof env["MARKETPLACE_REGISTRY"] === "string") {
-			describeOptions.registry = env["MARKETPLACE_REGISTRY"];
-		}
+		if (typeof env["MARKETPLACE_REGISTRY"] === "string") describeOptions.registry = env["MARKETPLACE_REGISTRY"];
 		const extension = await describe(extensionId, describeOptions);
 		const version = extension.data.versions.find((version$1) => version$1.id === versionId);
-		if (!version) {
-			throw new ForbiddenError();
-		}
+		if (!version) throw new ForbiddenError();
 		const limit = env["EXTENSIONS_LIMIT"] ? Number(env["EXTENSIONS_LIMIT"]) : null;
 		if (limit !== null) {
-			const currentlyInstalledCount = this.extensionsManager.extensions.length;
-			/**
-			* Bundle extensions should be counted as the number of nested entries rather than a single
-			* extension to avoid a vulnerability where you can get around the technical limit by bundling
-			* all extensions you want
-			*/
-			const points = version.bundled.length ?? 1;
-			const afterInstallCount = currentlyInstalledCount + points;
-			if (afterInstallCount >= limit) {
-				throw new LimitExceededError({ category: "Extensions" });
-			}
+			if (this.extensionsManager.extensions.length + (version.bundled.length ?? 1) >= limit) throw new LimitExceededError({ category: "Extensions" });
 		}
 		return {
 			extension,
@@ -71,35 +57,25 @@ var ExtensionsService = class ExtensionsService {
 			source: "registry",
 			bundle: null
 		});
-		if (extension.data.type === "bundle" && version.bundled.length > 0) {
-			await this.extensionsItemService.createMany(version.bundled.map((entry) => ({
-				enabled: true,
-				folder: entry.name,
-				source: "registry",
-				bundle: extensionId
-			})));
-		}
+		if (extension.data.type === "bundle" && version.bundled.length > 0) await this.extensionsItemService.createMany(version.bundled.map((entry) => ({
+			enabled: true,
+			folder: entry.name,
+			source: "registry",
+			bundle: extensionId
+		})));
 		await this.extensionsManager.install(versionId);
 	}
 	async uninstall(id) {
 		const settings = await this.extensionsItemService.readOne(id);
-		if (settings.source !== "registry") {
-			throw new InvalidPayloadError({ reason: "Cannot uninstall extensions that were not installed via marketplace" });
-		}
-		if (settings.bundle !== null) {
-			throw new InvalidPayloadError({ reason: "Cannot uninstall sub extensions of bundles separately" });
-		}
+		if (settings.source !== "registry") throw new InvalidPayloadError({ reason: "Cannot uninstall extensions that were not installed via marketplace" });
+		if (settings.bundle !== null) throw new InvalidPayloadError({ reason: "Cannot uninstall sub extensions of bundles separately" });
 		await this.deleteOne(id);
 		await this.extensionsManager.uninstall(settings.folder);
 	}
 	async reinstall(id) {
 		const settings = await this.extensionsItemService.readOne(id);
-		if (settings.source !== "registry") {
-			throw new InvalidPayloadError({ reason: "Cannot reinstall extensions that were not installed via marketplace" });
-		}
-		if (settings.bundle !== null) {
-			throw new InvalidPayloadError({ reason: "Cannot reinstall sub extensions of bundles separately" });
-		}
+		if (settings.source !== "registry") throw new InvalidPayloadError({ reason: "Cannot reinstall extensions that were not installed via marketplace" });
+		if (settings.bundle !== null) throw new InvalidPayloadError({ reason: "Cannot reinstall sub extensions of bundles separately" });
 		const extensionId = settings.id;
 		const versionId = settings.folder;
 		await this.preInstall(extensionId, versionId);
@@ -111,14 +87,12 @@ var ExtensionsService = class ExtensionsService {
 		const regular = settings.filter(({ bundle }) => bundle === null);
 		const bundled = settings.filter(({ bundle }) => bundle !== null);
 		const output = [];
-		for (const meta of regular) {
-			output.push({
-				id: meta.id,
-				bundle: meta.bundle,
-				meta,
-				schema: this.extensionsManager.getExtension(meta.source, meta.folder) ?? null
-			});
-		}
+		for (const meta of regular) output.push({
+			id: meta.id,
+			bundle: meta.bundle,
+			meta,
+			schema: this.extensionsManager.getExtension(meta.source, meta.folder) ?? null
+		});
 		for (const meta of bundled) {
 			const parentBundle = output.find((ext) => ext.id === meta.bundle);
 			if (!parentBundle) continue;
@@ -146,9 +120,7 @@ var ExtensionsService = class ExtensionsService {
 	}
 	async updateOne(id, data) {
 		const result = await transaction(this.knex, async (trx) => {
-			if (!isObject(data.meta)) {
-				throw new InvalidPayloadError({ reason: `"meta" is required` });
-			}
+			if (!isObject(data.meta)) throw new InvalidPayloadError({ reason: `"meta" is required` });
 			const service = new ExtensionsService({
 				knex: trx,
 				accountability: this.accountability,
@@ -161,9 +133,7 @@ var ExtensionsService = class ExtensionsService {
 			} catch (error) {
 				throw new ExtensionReadError(error);
 			}
-			if ("enabled" in data.meta) {
-				await service.checkBundleAndSyncStatus(trx, id, extension);
-			}
+			if ("enabled" in data.meta) await service.checkBundleAndSyncStatus(trx, id, extension);
 			return extension;
 		});
 		this.extensionsManager.reload().then(() => {
@@ -192,18 +162,10 @@ var ExtensionsService = class ExtensionsService {
 		const parentId = extension.bundle ?? extension.meta.bundle;
 		if (!parentId) return;
 		const parent = await this.readOne(parentId);
-		if (parent.schema?.type !== "bundle") {
-			return;
-		}
-		if (parent.schema.partial === false) {
-			throw new UnprocessableContentError({ reason: "Unable to toggle status of an entry for a bundle marked as non partial" });
-		}
-		const hasEnabledChildren = !!await trx("directus_extensions").where({ bundle: parentId }).where({ enabled: true }).first();
-		if (hasEnabledChildren) {
-			await trx("directus_extensions").update({ enabled: true }).where({ id: parentId });
-		} else {
-			await trx("directus_extensions").update({ enabled: false }).where({ id: parentId });
-		}
+		if (parent.schema?.type !== "bundle") return;
+		if (parent.schema.partial === false) throw new UnprocessableContentError({ reason: "Unable to toggle status of an entry for a bundle marked as non partial" });
+		if (!!await trx("directus_extensions").where({ bundle: parentId }).where({ enabled: true }).first()) await trx("directus_extensions").update({ enabled: true }).where({ id: parentId });
+		else await trx("directus_extensions").update({ enabled: false }).where({ id: parentId });
 	}
 };
 

package/dist/services/fields/build-collection-and-field-relations.js

@@ -16,31 +16,25 @@
 * }
 */
 function buildCollectionAndFieldRelations(relations) {
-	const collectionRelationTree = new Map();
-	const fieldToCollectionList = new Map();
+	const collectionRelationTree = /* @__PURE__ */ new Map();
+	const fieldToCollectionList = /* @__PURE__ */ new Map();
 	for (const relation of relations) {
 		let relatedCollections = [];
-		if (relation.related_collection) {
-			relatedCollections.push(relation.related_collection);
-		} else if (relation.meta?.one_collection_field && relation.meta?.one_allowed_collections) {
-			relatedCollections = relation.meta?.one_allowed_collections;
-		} else {
-			continue;
-		}
+		if (relation.related_collection) relatedCollections.push(relation.related_collection);
+		else if (relation.meta?.one_collection_field && relation.meta?.one_allowed_collections) relatedCollections = relation.meta?.one_allowed_collections;
+		else continue;
 		for (const relatedCollection of relatedCollections) {
 			let fieldToCollectionListKey = relation.collection + ":" + relation.field;
-			const collectionList = collectionRelationTree.get(relatedCollection) ?? new Set();
+			const collectionList = collectionRelationTree.get(relatedCollection) ?? /* @__PURE__ */ new Set();
 			collectionList.add(relation.collection);
 			if (relation.meta?.one_field) {
 				const relatedfieldToCollectionListKey = relatedCollection + ":" + relation.meta.one_field;
-				const realatedCollectionList = collectionRelationTree.get(relation.collection) ?? new Set();
+				const realatedCollectionList = collectionRelationTree.get(relation.collection) ?? /* @__PURE__ */ new Set();
 				realatedCollectionList.add(relatedCollection);
 				fieldToCollectionList.set(relatedfieldToCollectionListKey, relation.collection);
 				collectionRelationTree.set(relation.collection, realatedCollectionList);
 			}
-			if (relation.meta?.one_allowed_collections) {
-				fieldToCollectionListKey += ":" + relatedCollection;
-			}
+			if (relation.meta?.one_allowed_collections) fieldToCollectionListKey += ":" + relatedCollection;
 			fieldToCollectionList.set(fieldToCollectionListKey, relatedCollection);
 			collectionRelationTree.set(relatedCollection, collectionList);
 		}

package/dist/services/fields/get-collection-meta-updates.js

@@ -24,18 +24,14 @@ function getCollectionMetaUpdates(collection, field, collectionMetas, collection
 			const updatedPaths = [];
 			for (const path of itemDuplicationPaths) {
 				const updatedPath = updateItemDuplicationPath(path, collectionMeta.collection, field, collection, collections, fieldToCollectionList);
-				if (updatedPath && updatedPath.length !== 0) {
-					updatedPaths.push(updatedPath.join("."));
-				}
+				if (updatedPath && updatedPath.length !== 0) updatedPaths.push(updatedPath.join("."));
 			}
 			if (updatedPaths.length !== itemDuplicationPaths.length) {
 				meta.updates["item_duplication_fields"] = updatedPaths.length !== 0 ? JSON.stringify(updatedPaths) : null;
 				hasUpdates = true;
 			}
 		}
-		if (hasUpdates) {
-			collectionMetaUpdates.push(meta);
-		}
+		if (hasUpdates) collectionMetaUpdates.push(meta);
 	}
 	return collectionMetaUpdates;
 }
@@ -47,9 +43,7 @@ function updateItemDuplicationPath(path, root, field, collection, collections, f
 		`.${field}`,
 		`.${field}.`,
 		`${field}.`
-	].some((fieldPart) => path.includes(fieldPart)) === false) {
-		return parts;
-	}
+	].some((fieldPart) => path.includes(fieldPart)) === false) return parts;
 	const updatedParts = [];
 	for (let index = 0; index < parts.length; index++) {
 		const part = parts[index];
@@ -59,9 +53,7 @@ function updateItemDuplicationPath(path, root, field, collection, collections, f
 		const nextCollectionNode = fieldToCollectionList.get(`${currentCollection}:${part}`);
 		if (!nextCollectionNode && !isLastPart) return;
 		if (!nextCollectionNode && isLastPart && !isLocalField) return;
-		if (nextCollectionNode) {
-			currentCollection = nextCollectionNode;
-		}
+		if (nextCollectionNode) currentCollection = nextCollectionNode;
 		updatedParts.push(part);
 	}
 	return updatedParts;

package/dist/services/fields/get-collection-relation-list.js

@@ -6,15 +6,13 @@ import { isSystemCollection } from "@directus/system-data";
 * Or in math terms, returns the [strongly connected component](https://en.wikipedia.org/wiki/Strongly_connected_component) that a given node belongs to.
 */
 function getCollectionRelationList(collection, collectionRelationTree) {
-	const collectionRelationList = new Set();
+	const collectionRelationList = /* @__PURE__ */ new Set();
 	traverseCollectionRelationTree(collection);
 	return collectionRelationList;
 	function traverseCollectionRelationTree(root) {
 		const relationTree = collectionRelationTree.get(root);
 		if (!relationTree) return;
-		for (const relationNode of relationTree) {
-			addRelationNode(relationNode);
-		}
+		for (const relationNode of relationTree) addRelationNode(relationNode);
 	}
 	function addRelationNode(node) {
 		if (isSystemCollection(node)) return;