@directus/api 35.0.2 → 35.1.0

package/dist/utils/filter-items.js

@@ -6,20 +6,15 @@ function filterItems(items, filter) {
 	return items.filter((item) => passesFilter(item, filter));
 	function passesFilter(item, filter$1) {
 		if (!filter$1 || Object.keys(filter$1).length === 0) return true;
-		if (Object.keys(filter$1)[0] === "_and") {
-			const subfilter = Object.values(filter$1)[0];
-			return subfilter.every((subFilter) => {
-				return passesFilter(item, subFilter);
-			});
-		} else if (Object.keys(filter$1)[0] === "_or") {
-			const subfilter = Object.values(filter$1)[0];
-			return subfilter.some((subFilter) => {
-				return passesFilter(item, subFilter);
-			});
-		} else {
-			const schema = generateJoi(filter$1);
-			const { error } = schema.validate(item);
-			return error === undefined;
+		if (Object.keys(filter$1)[0] === "_and") return Object.values(filter$1)[0].every((subFilter) => {
+			return passesFilter(item, subFilter);
+		});
+		else if (Object.keys(filter$1)[0] === "_or") return Object.values(filter$1)[0].some((subFilter) => {
+			return passesFilter(item, subFilter);
+		});
+		else {
+			const { error } = generateJoi(filter$1).validate(item);
+			return error === void 0;
 		}
 	}
 }

package/dist/utils/freeze-schema.js

@@ -4,9 +4,7 @@ import { cloneDeep } from "lodash-es";
 function freezeSchema(schema) {
 	for (const collectionName of Object.keys(schema.collections)) {
 		if (!schema.collections[collectionName]) continue;
-		for (const fieldName of Object.keys(schema.collections[collectionName].fields)) {
-			Object.freeze(schema.collections[collectionName].fields[fieldName]);
-		}
+		for (const fieldName of Object.keys(schema.collections[collectionName].fields)) Object.freeze(schema.collections[collectionName].fields[fieldName]);
 		Object.freeze(schema.collections[collectionName]);
 	}
 	Object.freeze(schema.collections);
@@ -19,11 +17,8 @@ function freezeSchema(schema) {
 	return Object.freeze(schema);
 }
 function unfreezeSchema(schema) {
-	if (Object.isFrozen(schema)) {
-		return cloneDeep(schema);
-	} else {
-		return schema;
-	}
+	if (Object.isFrozen(schema)) return cloneDeep(schema);
+	else return schema;
 }
 
 //#endregion

package/dist/utils/generate-translations.js

@@ -43,12 +43,8 @@ const GenerateTranslationsInput = z.object({
 });
 async function generateTranslations(input, options) {
 	const parseResult = GenerateTranslationsInput.safeParse(input);
-	if (!parseResult.success) {
-		throw new InvalidPayloadError({ reason: fromZodError(parseResult.error).message });
-	}
-	if (!options.knex) {
-		throw new Error("Knex instance is required to generate translations");
-	}
+	if (!parseResult.success) throw new InvalidPayloadError({ reason: fromZodError(parseResult.error).message });
+	if (!options.knex) throw new Error("Knex instance is required to generate translations");
 	const { collection, fields: fieldNames, translationsCollection = `${parseResult.data.collection}_translations`, languagesCollection = "languages", parentFkField, languageFkField, createLanguagesCollection = true, seedLanguages = true } = parseResult.data;
 	const nestedActionEvents = [];
 	const mutationOptions = {
@@ -67,13 +63,9 @@ async function generateTranslations(input, options) {
 			schema
 		});
 		const sourceCollection = currentSchema.collections[collection];
-		if (!sourceCollection) {
-			throw new InvalidPayloadError({ reason: `Collection "${collection}" does not exist` });
-		}
+		if (!sourceCollection) throw new InvalidPayloadError({ reason: `Collection "${collection}" does not exist` });
 		const duplicateRequestedField = findDuplicate(fieldNames);
-		if (duplicateRequestedField) {
-			throw new InvalidPayloadError({ reason: `Field "${duplicateRequestedField}" would be created multiple times on "${translationsCollection}"` });
-		}
+		if (duplicateRequestedField) throw new InvalidPayloadError({ reason: `Field "${duplicateRequestedField}" would be created multiple times on "${translationsCollection}"` });
 		const readSourceFields = async () => {
 			const sourceFieldsService = new FieldsService(getServiceOptions(currentSchema));
 			return Promise.all(fieldNames.map(async (fieldName) => await sourceFieldsService.readOne(collection, fieldName)));
@@ -90,13 +82,11 @@ async function generateTranslations(input, options) {
 					if (!orphanedLanguageRelation) throw invalidCollectionError;
 					const resolvedLangsCollection = orphanedLanguageRelation.related_collection;
 					const langsFields = currentSchema.collections[resolvedLangsCollection]?.fields ?? {};
-					const fieldsService$1 = new FieldsService(getServiceOptions(currentSchema));
-					await fieldsService$1.createField(collection, buildTranslationsAliasField(langsFields), undefined, mutationOptions);
-					const relationsItemService = new ItemsService("directus_relations", {
+					await new FieldsService(getServiceOptions(currentSchema)).createField(collection, buildTranslationsAliasField(langsFields), void 0, mutationOptions);
+					await new ItemsService("directus_relations", {
 						knex: trx,
 						schema: currentSchema
-					});
-					await relationsItemService.updateOne(orphanedRelation.meta.id, { one_field: "translations" }, mutationOptions);
+					}).updateOne(orphanedRelation.meta.id, { one_field: "translations" }, mutationOptions);
 					currentSchema = await getSchema({
 						database: trx,
 						bypassCache: true
@@ -107,12 +97,9 @@ async function generateTranslations(input, options) {
 			if (parentRelations.length !== 1) throw invalidCollectionError;
 			const parentRelation = parentRelations[0];
 			const translationField = parentRelation.meta.one_field;
-			const currentSourceCollection = currentSchema.collections[collection];
-			const sourceTranslationField = currentSourceCollection?.fields[translationField];
+			const sourceTranslationField = currentSchema.collections[collection]?.fields[translationField];
 			const sourceTranslationSpecials = Array.isArray(sourceTranslationField?.special) ? sourceTranslationField.special : [];
-			if (!sourceTranslationField || !sourceTranslationSpecials.includes("translations")) {
-				throw invalidCollectionError;
-			}
+			if (!sourceTranslationField || !sourceTranslationSpecials.includes("translations")) throw invalidCollectionError;
 			const languageForeignKeyField = parentRelation.meta.junction_field;
 			const languageRelation = currentSchema.relations.find((relation) => relation.collection === translationsCollection && relation.field === languageForeignKeyField && relation.meta?.junction_field === parentRelation.field && typeof relation.related_collection === "string" && relation.related_collection.length > 0);
 			if (!languageRelation) throw invalidCollectionError;
@@ -125,10 +112,8 @@ async function generateTranslations(input, options) {
 		if (existingTranslationsCollection) {
 			const { parentRelation, languageRelation } = await validateExistingTranslationsCollection();
 			const newFieldNames = fieldNames.filter((fieldName) => {
-				if (sourceCollection.fields[fieldName] === undefined) {
-					throw new InvalidPayloadError({ reason: `Field "${fieldName}" does not exist on "${collection}"` });
-				}
-				return existingTranslationsCollection.fields[fieldName] === undefined;
+				if (sourceCollection.fields[fieldName] === void 0) throw new InvalidPayloadError({ reason: `Field "${fieldName}" does not exist on "${collection}"` });
+				return existingTranslationsCollection.fields[fieldName] === void 0;
 			});
 			if (newFieldNames.length > 0) {
 				const sourceFieldsService = new FieldsService(getServiceOptions(currentSchema));
@@ -155,33 +140,25 @@ async function generateTranslations(input, options) {
 					return a.localeCompare(b);
 				});
 				let nextSort = maxSystemSort + 1;
-				const sortAssignments = new Map();
-				for (const fieldName of allContentFieldNames) {
-					sortAssignments.set(fieldName, nextSort++);
-				}
+				const sortAssignments = /* @__PURE__ */ new Map();
+				for (const fieldName of allContentFieldNames) sortAssignments.set(fieldName, nextSort++);
 				for (const existing of existingContentFields) {
 					const newSort = sortAssignments.get(existing.field);
-					if (newSort !== undefined && newSort !== existing.sort) {
-						await trx("directus_fields").where({
-							collection: translationsCollection,
-							field: existing.field
-						}).update({ sort: newSort });
-					}
+					if (newSort !== void 0 && newSort !== existing.sort) await trx("directus_fields").where({
+						collection: translationsCollection,
+						field: existing.field
+					}).update({ sort: newSort });
 				}
 				for (const clonedField of clonedFields$1) {
 					const sort = sortAssignments.get(clonedField.field);
-					if (sort !== undefined) {
-						clonedField.meta = {
-							...clonedField.meta,
-							sort
-						};
-					}
+					if (sort !== void 0) clonedField.meta = {
+						...clonedField.meta,
+						sort
+					};
 				}
 				clonedFields$1.sort((a, b) => (sortAssignments.get(a.field) ?? Infinity) - (sortAssignments.get(b.field) ?? Infinity));
 				const fieldsService$1 = new FieldsService(getServiceOptions(currentSchema));
-				for (const clonedField of clonedFields$1) {
-					await fieldsService$1.createField(translationsCollection, clonedField, undefined, mutationOptions);
-				}
+				for (const clonedField of clonedFields$1) await fieldsService$1.createField(translationsCollection, clonedField, void 0, mutationOptions);
 			}
 			return {
 				created: false,
@@ -189,24 +166,13 @@ async function generateTranslations(input, options) {
 				fields: fieldNames
 			};
 		}
-		const hasTranslationsSpecial = Object.values(sourceCollection.fields).some((field) => Array.isArray(field.special) && field.special.includes("translations"));
-		if (hasTranslationsSpecial) {
-			throw new InvalidPayloadError({ reason: `Field with special "translations" already exists on "${collection}"` });
-		}
-		if (sourceCollection.fields["translations"]) {
-			throw new InvalidPayloadError({ reason: `Field "translations" already exists on "${collection}"` });
-		}
+		if (Object.values(sourceCollection.fields).some((field) => Array.isArray(field.special) && field.special.includes("translations"))) throw new InvalidPayloadError({ reason: `Field with special "translations" already exists on "${collection}"` });
+		if (sourceCollection.fields["translations"]) throw new InvalidPayloadError({ reason: `Field "translations" already exists on "${collection}"` });
 		const parentFieldNames = Object.keys(sourceCollection.fields);
 		const parentPrimaryKeyField = sourceCollection.primary;
-		if (!parentPrimaryKeyField) {
-			throw new InvalidPayloadError({ reason: `Collection "${collection}" does not have a primary key` });
-		}
+		if (!parentPrimaryKeyField) throw new InvalidPayloadError({ reason: `Collection "${collection}" does not have a primary key` });
 		const parentPrimaryKeyType = sourceCollection.fields[parentPrimaryKeyField]?.type ?? "integer";
-		for (const fieldName of fieldNames) {
-			if (!parentFieldNames.includes(fieldName)) {
-				throw new InvalidPayloadError({ reason: `Field "${fieldName}" does not exist on "${collection}"` });
-			}
-		}
+		for (const fieldName of fieldNames) if (!parentFieldNames.includes(fieldName)) throw new InvalidPayloadError({ reason: `Field "${fieldName}" does not exist on "${collection}"` });
 		let languagePrimaryKeyField;
 		let languagePrimaryKeyType;
 		if (currentSchema.collections[languagesCollection]) {
@@ -214,8 +180,7 @@ async function generateTranslations(input, options) {
 			languagePrimaryKeyField = existingLanguagesCollection.primary;
 			languagePrimaryKeyType = existingLanguagesCollection.fields[languagePrimaryKeyField]?.type ?? "string";
 		} else if (createLanguagesCollection) {
-			const collectionsService$1 = new CollectionsService(getServiceOptions(currentSchema));
-			await collectionsService$1.createOne({
+			await new CollectionsService(getServiceOptions(currentSchema)).createOne({
 				collection: languagesCollection,
 				meta: {},
 				schema: { name: languagesCollection },
@@ -265,79 +230,68 @@ async function generateTranslations(input, options) {
 				bypassCache: true
 			});
 			const createdLanguagesCollection = currentSchema.collections[languagesCollection];
-			if (!createdLanguagesCollection) {
-				throw new InvalidPayloadError({ reason: `Languages collection "${languagesCollection}" was not found in refreshed schema` });
-			}
+			if (!createdLanguagesCollection) throw new InvalidPayloadError({ reason: `Languages collection "${languagesCollection}" was not found in refreshed schema` });
 			languagePrimaryKeyField = createdLanguagesCollection.primary;
 			languagePrimaryKeyType = createdLanguagesCollection.fields[languagePrimaryKeyField]?.type ?? "string";
-			if (seedLanguages) {
-				const itemsService = new ItemsService(languagesCollection, getServiceOptions(currentSchema));
-				await itemsService.createMany([
-					{
-						code: "en-US",
-						name: "English",
-						direction: "ltr"
-					},
-					{
-						code: "ar-SA",
-						name: "Arabic",
-						direction: "rtl"
-					},
-					{
-						code: "de-DE",
-						name: "German",
-						direction: "ltr"
-					},
-					{
-						code: "fr-FR",
-						name: "French",
-						direction: "ltr"
-					},
-					{
-						code: "ru-RU",
-						name: "Russian",
-						direction: "ltr"
-					},
-					{
-						code: "es-ES",
-						name: "Spanish",
-						direction: "ltr"
-					},
-					{
-						code: "it-IT",
-						name: "Italian",
-						direction: "ltr"
-					},
-					{
-						code: "pt-BR",
-						name: "Portuguese",
-						direction: "ltr"
-					}
-				], mutationOptions);
-			}
-		} else {
-			throw new InvalidPayloadError({ reason: `Languages collection "${languagesCollection}" does not exist` });
-		}
+			if (seedLanguages) await new ItemsService(languagesCollection, getServiceOptions(currentSchema)).createMany([
+				{
+					code: "en-US",
+					name: "English",
+					direction: "ltr"
+				},
+				{
+					code: "ar-SA",
+					name: "Arabic",
+					direction: "rtl"
+				},
+				{
+					code: "de-DE",
+					name: "German",
+					direction: "ltr"
+				},
+				{
+					code: "fr-FR",
+					name: "French",
+					direction: "ltr"
+				},
+				{
+					code: "ru-RU",
+					name: "Russian",
+					direction: "ltr"
+				},
+				{
+					code: "es-ES",
+					name: "Spanish",
+					direction: "ltr"
+				},
+				{
+					code: "it-IT",
+					name: "Italian",
+					direction: "ltr"
+				},
+				{
+					code: "pt-BR",
+					name: "Portuguese",
+					direction: "ltr"
+				}
+			], mutationOptions);
+		} else throw new InvalidPayloadError({ reason: `Languages collection "${languagesCollection}" does not exist` });
 		const sourceFields = await readSourceFields();
 		validateFieldsEligibility(sourceFields);
 		const resolvedParentForeignKeyField = parentFkField ?? `${collection}_${parentPrimaryKeyField}`;
 		const resolvedLanguageForeignKeyField = languageFkField ?? `${languagesCollection}_${languagePrimaryKeyField}`;
-		const targetFieldNames = [
+		const duplicateTargetField = findDuplicate([
 			"id",
 			resolvedParentForeignKeyField,
 			resolvedLanguageForeignKeyField,
 			...fieldNames
-		];
-		const duplicateTargetField = findDuplicate(targetFieldNames);
-		if (duplicateTargetField) {
-			throw new InvalidPayloadError({ reason: `Field "${duplicateTargetField}" would be created multiple times on "${translationsCollection}"` });
-		}
+		]);
+		if (duplicateTargetField) throw new InvalidPayloadError({ reason: `Field "${duplicateTargetField}" would be created multiple times on "${translationsCollection}"` });
 		const clonedFields = cloneFields({
 			fields: fieldNames,
 			sourceFields
 		});
-		const collectionsService = new CollectionsService(getServiceOptions(currentSchema));
-		await collectionsService.createOne({
+		await new CollectionsService(getServiceOptions(currentSchema)).createOne({
 			collection: translationsCollection,
 			meta: {
 				hidden: true,
@@ -404,10 +358,8 @@ async function generateTranslations(input, options) {
 		});
 		const fieldsService = new FieldsService(getServiceOptions(currentSchema));
 		const resolvedLanguagesCollection = currentSchema.collections[languagesCollection];
-		if (!resolvedLanguagesCollection) {
-			throw new InvalidPayloadError({ reason: `Languages collection "${languagesCollection}" was not found in refreshed schema` });
-		}
-		await fieldsService.createField(collection, buildTranslationsAliasField(resolvedLanguagesCollection.fields), undefined, mutationOptions);
+		if (!resolvedLanguagesCollection) throw new InvalidPayloadError({ reason: `Languages collection "${languagesCollection}" was not found in refreshed schema` });
+		await fieldsService.createField(collection, buildTranslationsAliasField(resolvedLanguagesCollection.fields), void 0, mutationOptions);
 		return {
 			created: true,
 			translationsCollection,
@@ -415,19 +367,17 @@ async function generateTranslations(input, options) {
 			fields: fieldNames
 		};
 	});
-	if (nestedActionEvents.length > 0) {
-		try {
-			const updatedSchema = await getSchema({
-				database: options.knex,
-				bypassCache: true
-			});
-			for (const nestedActionEvent of nestedActionEvents) {
-				nestedActionEvent.context.schema = updatedSchema;
-				emitter_default.emitAction(nestedActionEvent.event, nestedActionEvent.meta, nestedActionEvent.context);
-			}
-		} catch (error) {
-			logger.warn(error, "Failed to emit nested translation actions after generate-translations commit");
+	if (nestedActionEvents.length > 0) try {
+		const updatedSchema = await getSchema({
+			database: options.knex,
+			bypassCache: true
+		});
+		for (const nestedActionEvent of nestedActionEvents) {
+			nestedActionEvent.context.schema = updatedSchema;
+			emitter_default.emitAction(nestedActionEvent.event, nestedActionEvent.meta, nestedActionEvent.context);
 		}
+	} catch (error) {
+		logger.warn(error, "Failed to emit nested translation actions after generate-translations commit");
 	}
 	return result;
 }

package/dist/utils/get-accountability-for-role.js

@@ -5,28 +5,23 @@ import { createDefaultAccountability } from "../permissions/utils/create-default
 //#region src/utils/get-accountability-for-role.ts
 async function getAccountabilityForRole(role, context) {
 	let generatedAccountability;
-	if (role === null) {
-		generatedAccountability = createDefaultAccountability();
-	} else if (role === "system") {
-		generatedAccountability = createDefaultAccountability({
-			admin: true,
-			app: true
-		});
-	} else {
+	if (role === null) generatedAccountability = createDefaultAccountability();
+	else if (role === "system") generatedAccountability = createDefaultAccountability({
+		admin: true,
+		app: true
+	});
+	else {
 		const roles = await fetchRolesTree(role, { knex: context.database });
-		if (roles.length === 0) {
-			throw new Error(`Configured role "${role}" isn't a valid role ID or doesn't exist.`);
-		}
-		const globalAccess = await fetchGlobalAccess({
-			user: null,
-			roles,
-			ip: context.accountability?.ip ?? null
-		}, { knex: context.database });
+		if (roles.length === 0) throw new Error(`Configured role "${role}" isn't a valid role ID or doesn't exist.`);
 		generatedAccountability = createDefaultAccountability({
 			role,
 			roles,
 			user: null,
-			...globalAccess
+			...await fetchGlobalAccess({
+				user: null,
+				roles,
+				ip: context.accountability?.ip ?? null
+			}, { knex: context.database })
 		});
 	}
 	return generatedAccountability;

package/dist/utils/get-accountability-for-token.js

@@ -10,39 +10,33 @@ import { InvalidCredentialsError } from "@directus/errors";
 
 //#region src/utils/get-accountability-for-token.ts
 async function getAccountabilityForToken(token, accountability) {
-	if (!accountability) {
-		accountability = createDefaultAccountability();
-	}
+	if (!accountability) accountability = createDefaultAccountability();
 	const database = database_default();
-	if (token) {
-		if (isDirectusJWT(token)) {
-			const payload = verifyAccessJWT(token, getSecret());
-			if ("session" in payload) {
-				await verifySessionJWT(payload);
-				accountability.session = payload.session;
-			}
-			if (payload.share) accountability.share = payload.share;
-			if (payload.id) accountability.user = payload.id;
-			accountability.role = payload.role;
-			accountability.roles = await fetchRolesTree(payload.role, { knex: database });
-			const { admin, app } = await fetchGlobalAccess(accountability, { knex: database });
-			accountability.admin = admin;
-			accountability.app = app;
-		} else {
-			const user = await database.select("directus_users.id", "directus_users.role").from("directus_users").where({
-				"directus_users.token": token,
-				status: "active"
-			}).first();
-			if (!user) {
-				throw new InvalidCredentialsError();
-			}
-			accountability.user = user.id;
-			accountability.role = user.role;
-			accountability.roles = await fetchRolesTree(user.role, { knex: database });
-			const { admin, app } = await fetchGlobalAccess(accountability, { knex: database });
-			accountability.admin = admin;
-			accountability.app = app;
+	if (token) if (isDirectusJWT(token)) {
+		const payload = verifyAccessJWT(token, getSecret());
+		if ("session" in payload) {
+			await verifySessionJWT(payload);
+			accountability.session = payload.session;
 		}
+		if (payload.share) accountability.share = payload.share;
+		if (payload.id) accountability.user = payload.id;
+		accountability.role = payload.role;
+		accountability.roles = await fetchRolesTree(payload.role, { knex: database });
+		const { admin, app } = await fetchGlobalAccess(accountability, { knex: database });
+		accountability.admin = admin;
+		accountability.app = app;
+	} else {
+		const user = await database.select("directus_users.id", "directus_users.role").from("directus_users").where({
+			"directus_users.token": token,
+			status: "active"
+		}).first();
+		if (!user) throw new InvalidCredentialsError();
+		accountability.user = user.id;
+		accountability.role = user.role;
+		accountability.roles = await fetchRolesTree(user.role, { knex: database });
+		const { admin, app } = await fetchGlobalAccess(accountability, { knex: database });
+		accountability.admin = admin;
+		accountability.app = app;
 	}
 	return accountability;
 }

package/dist/utils/get-address.js

@@ -1,19 +1,14 @@
 import { useEnv } from "@directus/env";
-import "http";
 
 //#region src/utils/get-address.ts
 function getAddress(server) {
 	const env = useEnv();
 	const address = server.address();
 	if (address === null) {
-		if (env["UNIX_SOCKET_PATH"]) {
-			return env["UNIX_SOCKET_PATH"];
-		}
+		if (env["UNIX_SOCKET_PATH"]) return env["UNIX_SOCKET_PATH"];
 		return `${env["HOST"]}:${env["PORT"]}`;
 	}
-	if (typeof address === "string") {
-		return address;
-	}
+	if (typeof address === "string") return address;
 	return `${address.address}:${address.port}`;
 }
 

package/dist/utils/get-allowed-log-levels.js

@@ -4,9 +4,7 @@ import { useLogger } from "../logger/index.js";
 const logger = useLogger();
 const getAllowedLogLevels = (level) => {
 	const levelValue = logger.levels.values[level];
-	if (levelValue === undefined) {
-		throw new Error(`Invalid "${level}" log level`);
-	}
+	if (levelValue === void 0) throw new Error(`Invalid "${level}" log level`);
 	return Object.fromEntries(Object.entries(logger.levels.values).filter(([_, value]) => value >= levelValue).sort((a, b) => a[1] - b[1]));
 };
 

package/dist/utils/get-auth-providers.js

@@ -5,20 +5,18 @@ import { toArray } from "@directus/utils";
 function getAuthProviders({ sessionOnly } = { sessionOnly: false }) {
 	const env = useEnv();
 	let providers = toArray(env["AUTH_PROVIDERS"]).filter((provider) => provider && env[`AUTH_${provider.toUpperCase()}_DRIVER`]);
-	if (sessionOnly) {
-		providers = providers.filter((provider) => {
-			const driver = env[`AUTH_${provider.toUpperCase()}_DRIVER`];
-			if ([
-				"oauth2",
-				"openid",
-				"saml"
-			].includes(driver)) {
-				const mode = env[`AUTH_${provider.toUpperCase()}_MODE`];
-				return !mode || mode === "session";
-			}
-			return true;
-		});
-	}
+	if (sessionOnly) providers = providers.filter((provider) => {
+		const driver = env[`AUTH_${provider.toUpperCase()}_DRIVER`];
+		if ([
+			"oauth2",
+			"openid",
+			"saml"
+		].includes(driver)) {
+			const mode = env[`AUTH_${provider.toUpperCase()}_MODE`];
+			return !mode || mode === "session";
+		}
+		return true;
+	});
 	return providers.map((provider) => ({
 		name: provider,
 		label: env[`AUTH_${provider.toUpperCase()}_LABEL`],

package/dist/utils/get-cache-headers.js

@@ -13,7 +13,7 @@ import { useEnv } from "@directus/env";
 function getCacheControlHeader(req, ttl, globalCacheSettings, personalized) {
 	const env = useEnv();
 	if (shouldSkipCache(req)) return "no-store";
-	if (ttl === undefined || ttl < 0) return "no-cache";
+	if (ttl === void 0 || ttl < 0) return "no-cache";
 	if (globalCacheSettings && env["CACHE_AUTO_PURGE"] === true) return "no-cache";
 	const headerValues = [];
 	if (personalized) {
@@ -22,9 +22,7 @@ function getCacheControlHeader(req, ttl, globalCacheSettings, personalized) {
 	}
 	const ttlSeconds = Math.round(ttl / 1e3);
 	headerValues.push(`max-age=${ttlSeconds}`);
-	if (globalCacheSettings && Number.isInteger(env["CACHE_CONTROL_S_MAXAGE"]) && env["CACHE_CONTROL_S_MAXAGE"] >= 0) {
-		headerValues.push(`s-maxage=${env["CACHE_CONTROL_S_MAXAGE"]}`);
-	}
+	if (globalCacheSettings && Number.isInteger(env["CACHE_CONTROL_S_MAXAGE"]) && env["CACHE_CONTROL_S_MAXAGE"] >= 0) headerValues.push(`s-maxage=${env["CACHE_CONTROL_S_MAXAGE"]}`);
 	return headerValues.join(", ");
 }
 

package/dist/utils/get-cache-key.js

@@ -1,29 +1,41 @@
 import database_default from "../database/index.js";
 import { fetchPoliciesIpAccess } from "../permissions/modules/fetch-policies-ip-access/fetch-policies-ip-access.js";
 import { getGraphqlQueryAndVariables } from "./get-graphql-query-and-variables.js";
+import { getFlowManager } from "../flows.js";
+import { toArray } from "@directus/utils";
+import { isEmpty, pick } from "lodash-es";
 import { ipInNetworks } from "@directus/utils/node";
 import hash from "object-hash";
 import url from "url";
 import { version } from "directus/version";
 
 //#region src/utils/get-cache-key.ts
+const FLOW_TRIGGER_PATTERN = /^\/flows\/trigger\/([0-9a-f-]+)/i;
 async function getCacheKey(req) {
 	const path = url.parse(req.originalUrl).pathname;
 	const isGraphQl = path?.startsWith("/graphql");
+	let flowTriggerQuery = void 0;
+	if (path) {
+		const flowMatch = path.match(FLOW_TRIGGER_PATTERN);
+		if (flowMatch) {
+			const cacheQueryParams = toArray(getFlowManager().getFlow(flowMatch[1])?.options?.["cacheQueryParams"] ?? []);
+			const picked = pick(req.query, cacheQueryParams);
+			if (!isEmpty(picked)) flowTriggerQuery = picked;
+		}
+	}
 	let includeIp = false;
 	if (req.accountability && req.accountability.ip) {
 		const ipFilters = await fetchPoliciesIpAccess(req.accountability, database_default());
 		includeIp = ipFilters.length > 0 && ipFilters.some((networks) => ipInNetworks(req.accountability.ip, networks));
 	}
-	const info = {
+	return hash({
 		version,
 		user: req.accountability?.user || null,
 		path,
 		query: isGraphQl ? getGraphqlQueryAndVariables(req) : req.sanitizedQuery,
+		...flowTriggerQuery && { rawQuery: flowTriggerQuery },
 		...includeIp && { ip: req.accountability.ip }
-	};
-	const key = hash(info);
-	return key;
+	});
 }
 
 //#endregion

package/dist/utils/get-collection-from-alias.js

@@ -4,12 +4,7 @@
 * For example: 'ljnsv.name' -> 'authors'
 */
 function getCollectionFromAlias(alias, aliasMap) {
-	for (const aliasValue of Object.values(aliasMap)) {
-		if (aliasValue.alias === alias) {
-			return aliasValue.collection;
-		}
-	}
-	return undefined;
+	for (const aliasValue of Object.values(aliasMap)) if (aliasValue.alias === alias) return aliasValue.collection;
 }
 
 //#endregion