@directus/api 35.0.2 → 35.2.0

package/dist/database/migrations/run.js

@@ -22,9 +22,7 @@ async function run(database, direction, log = true) {
 	const completedMigrations = await database.select("*").from("directus_migrations").orderBy("version");
 	const migrations = [...migrationFiles.map((path$1) => parseFilePath(path$1)), ...customMigrationFiles.map((path$1) => parseFilePath(path$1, true))].sort((a, b) => a.version > b.version ? 1 : -1);
 	const migrationKeys = new Set(migrations.map((m) => m.version));
-	if (migrations.length > migrationKeys.size) {
-		throw new Error("Migration keys collide! Please ensure that every migration uses a unique key.");
-	}
+	if (migrations.length > migrationKeys.size) throw new Error("Migration keys collide! Please ensure that every migration uses a unique key.");
 	function parseFilePath(filePath, custom = false) {
 		const version = filePath.split("-")[0];
 		const name = formatTitle(filePath.split("-").slice(1).join("_").split(".")[0]);
@@ -42,23 +40,14 @@ async function run(database, direction, log = true) {
 	async function up() {
 		const currentVersion = completedMigrations[completedMigrations.length - 1];
 		let nextVersion;
-		if (!currentVersion) {
-			nextVersion = migrations[0];
-		} else {
-			nextVersion = migrations.find((migration) => {
-				return migration.version > currentVersion.version && migration.completed === false;
-			});
-		}
-		if (!nextVersion) {
-			throw Error("Nothing to upgrade");
-		}
+		if (!currentVersion) nextVersion = migrations[0];
+		else nextVersion = migrations.find((migration) => {
+			return migration.version > currentVersion.version && migration.completed === false;
+		});
+		if (!nextVersion) throw Error("Nothing to upgrade");
 		const { up: up$1 } = await import(`file://${nextVersion.file}`);
-		if (!up$1) {
-			logger.warn(`Couldn't find the "up" function from migration ${nextVersion.file}`);
-		}
-		if (log) {
-			logger.info(`Applying ${nextVersion.name}...`);
-		}
+		if (!up$1) logger.warn(`Couldn't find the "up" function from migration ${nextVersion.file}`);
+		if (log) logger.info(`Applying ${nextVersion.name}...`);
 		await up$1(database);
 		await database.insert({
 			version: nextVersion.version,
@@ -68,46 +57,30 @@ async function run(database, direction, log = true) {
 	}
 	async function down() {
 		const lastAppliedMigration = orderBy(completedMigrations, ["timestamp", "version"], ["desc", "desc"])[0];
-		if (!lastAppliedMigration) {
-			throw Error("Nothing to downgrade");
-		}
+		if (!lastAppliedMigration) throw Error("Nothing to downgrade");
 		const migration = migrations.find((migration$1) => migration$1.version === lastAppliedMigration.version);
-		if (!migration) {
-			throw new Error("Couldn't find migration");
-		}
+		if (!migration) throw new Error("Couldn't find migration");
 		const { down: down$1 } = await import(`file://${migration.file}`);
-		if (!down$1) {
-			logger.warn(`Couldn't find the "down" function from migration ${migration.file}`);
-		}
-		if (log) {
-			logger.info(`Undoing ${migration.name}...`);
-		}
+		if (!down$1) logger.warn(`Couldn't find the "down" function from migration ${migration.file}`);
+		if (log) logger.info(`Undoing ${migration.name}...`);
 		await down$1(database);
 		await database("directus_migrations").delete().where({ version: migration.version });
 		await flushCaches(true);
 	}
 	async function latest() {
 		let needsCacheFlush = false;
-		for (const migration of migrations) {
-			if (migration.completed === false) {
-				needsCacheFlush = true;
-				const { up: up$1 } = getModuleDefault(await import(`file://${migration.file}`));
-				if (!up$1) {
-					logger.warn(`Couldn't find the "up" function from migration ${migration.file}`);
-				}
-				if (log) {
-					logger.info(`Applying ${migration.name}...`);
-				}
-				await up$1(database);
-				await database.insert({
-					version: migration.version,
-					name: migration.name
-				}).into("directus_migrations");
-			}
-		}
-		if (needsCacheFlush) {
-			await flushCaches(true);
+		for (const migration of migrations) if (migration.completed === false) {
+			needsCacheFlush = true;
+			const { up: up$1 } = getModuleDefault(await import(`file://${migration.file}`));
+			if (!up$1) logger.warn(`Couldn't find the "up" function from migration ${migration.file}`);
+			if (log) logger.info(`Applying ${migration.name}...`);
+			await up$1(database);
+			await database.insert({
+				version: migration.version,
+				name: migration.name
+			}).into("directus_migrations");
 		}
+		if (needsCacheFlush) await flushCaches(true);
 	}
 }
 

package/dist/database/run-ast/lib/apply-query/add-join.js

@@ -20,11 +20,8 @@ function addJoin({ path, collection, aliasMap, rootQuery, schema, knex }) {
 		*/
 		const pathRoot = pathParts[0].split(":")[0];
 		const { relation, relationType } = getRelationInfo(schema.relations, parentCollection, pathRoot);
-		if (!relation) {
-			return;
-		}
-		const existingAlias = parentFields ? aliasMap[`${parentFields}.${pathParts[0]}`]?.alias : aliasMap[pathParts[0]]?.alias;
-		if (!existingAlias) {
+		if (!relation) return;
+		if (!(parentFields ? aliasMap[`${parentFields}.${pathParts[0]}`]?.alias : aliasMap[pathParts[0]]?.alias)) {
 			const alias = generateJoinAlias(parentCollection, pathParts, relationType, parentFields);
 			const aliasKey = parentFields ? `${parentFields}.${pathParts[0]}` : pathParts[0];
 			const aliasedParentCollection = aliasMap[parentFields ?? ""]?.alias || parentCollection;
@@ -38,9 +35,7 @@ function addJoin({ path, collection, aliasMap, rootQuery, schema, knex }) {
 				isJoinAdded = true;
 			} else if (relationType === "a2o") {
 				const pathScope = pathParts[0].split(":")[1];
-				if (!pathScope) {
-					throw new InvalidQueryError({ reason: `You have to provide a collection scope when sorting or filtering on a many-to-any item` });
-				}
+				if (!pathScope) throw new InvalidQueryError({ reason: `You have to provide a collection scope when sorting or filtering on a many-to-any item` });
 				rootQuery.leftJoin({ [alias]: pathScope }, (joinClause) => {
 					joinClause.onVal(`${aliasedParentCollection}.${relation.meta.one_collection_field}`, "=", pathScope).andOn(`${aliasedParentCollection}.${relation.field}`, "=", knex.raw(getHelpers(knex).schema.castA2oPrimaryKey(), `${alias}.${schema.collections[pathScope].primary}`));
 				});
@@ -61,20 +56,13 @@ function addJoin({ path, collection, aliasMap, rootQuery, schema, knex }) {
 			}
 		}
 		let parent;
-		if (relationType === "m2o") {
-			parent = relation.related_collection;
-		} else if (relationType === "a2o") {
+		if (relationType === "m2o") parent = relation.related_collection;
+		else if (relationType === "a2o") {
 			const pathScope = pathParts[0].split(":")[1];
-			if (!pathScope) {
-				throw new InvalidQueryError({ reason: `You have to provide a collection scope when sorting or filtering on a many-to-any item` });
-			}
+			if (!pathScope) throw new InvalidQueryError({ reason: `You have to provide a collection scope when sorting or filtering on a many-to-any item` });
 			parent = pathScope;
-		} else {
-			parent = relation.collection;
-		}
-		if (pathParts.length > 1) {
-			followRelation(pathParts.slice(1), parent, `${parentFields ? parentFields + "." : ""}${pathParts[0]}`);
-		}
+		} else parent = relation.collection;
+		if (pathParts.length > 1) followRelation(pathParts.slice(1), parent, `${parentFields ? parentFields + "." : ""}${pathParts[0]}`);
 	}
 }
 

package/dist/database/run-ast/lib/apply-query/aggregate.js

@@ -24,9 +24,7 @@ function applyAggregate(schema, dbQuery, aggregate, collection, hasJoins) {
 				"sumDistinct",
 				"min",
 				"max"
-			].includes(operation)) {
-				dbQuery[operation](`${collection}.${field}`, { as: `${operation}->${field}` });
-			}
+			].includes(operation)) dbQuery[operation](`${collection}.${field}`, { as: `${operation}->${field}` });
 		}
 	}
 }

package/dist/database/run-ast/lib/apply-query/filter/get-filter-type.js

@@ -6,17 +6,11 @@ import { getFunctionsForType, getOutputTypeForFunction } from "@directus/utils";
 function getFilterType(fields, key, collection = "unknown") {
 	const { fieldName, functionName } = parseFilterKey(key);
 	const field = fields[fieldName];
-	if (!field) {
-		throw new InvalidQueryError({ reason: `Invalid filter key "${key}" on "${collection}"` });
-	}
+	if (!field) throw new InvalidQueryError({ reason: `Invalid filter key "${key}" on "${collection}"` });
 	const { type } = field;
 	if (functionName) {
-		const availableFunctions = getFunctionsForType(type);
-		if (!availableFunctions.includes(functionName)) {
-			throw new InvalidQueryError({ reason: `Invalid filter key "${key}" on "${collection}"` });
-		}
-		const functionType = getOutputTypeForFunction(functionName);
-		return { type: functionType };
+		if (!getFunctionsForType(type).includes(functionName)) throw new InvalidQueryError({ reason: `Invalid filter key "${key}" on "${collection}"` });
+		return { type: getOutputTypeForFunction(functionName) };
 	}
 	return {
 		type,

package/dist/database/run-ast/lib/apply-query/filter/index.js

@@ -26,13 +26,8 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, aliasMap,
 	function addJoins(dbQuery, filter, collection$1) {
 		for (let [key, value] of Object.entries(filter)) {
 			if (key === "_or" || key === "_and") {
-				if (key === "_or" && value.some((subFilter) => Object.keys(subFilter).length === 0)) {
-					if (value !== cases || value.length === 1) {
-						continue;
-					} else {
-						value = value.filter((subFilter) => Object.keys(subFilter).length > 0);
-					}
-				}
+				if (key === "_or" && value.some((subFilter) => Object.keys(subFilter).length === 0)) if (value !== cases || value.length === 1) continue;
+				else value = value.filter((subFilter) => Object.keys(subFilter).length > 0);
 				value.forEach((subFilter) => {
 					addJoins(dbQuery, subFilter, collection$1);
 				});
@@ -48,21 +43,15 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, aliasMap,
 					rootQuery,
 					aliasMap
 				});
-				if (!hasJoins) {
-					hasJoins = isJoinAdded;
-				}
-				if (!hasMultiRelationalFilter) {
-					hasMultiRelationalFilter = hasMultiRelational;
-				}
+				if (!hasJoins) hasJoins = isJoinAdded;
+				if (!hasMultiRelationalFilter) hasMultiRelationalFilter = hasMultiRelational;
 			}
 		}
 	}
 	function addWhereClauses(knex$1, dbQuery, filter, collection$1, logical = "and") {
 		for (const [key, value] of Object.entries(filter)) {
 			if (key === "_or" || key === "_and") {
-				if (key === "_or" && value.some((subFilter) => Object.keys(subFilter).length === 0)) {
-					continue;
-				}
+				if (key === "_or" && value.some((subFilter) => Object.keys(subFilter).length === 0)) continue;
 				/** @NOTE this callback function isn't called until Knex runs the query */
 				dbQuery[logical].where((subQuery) => {
 					value.forEach((subFilter) => {
@@ -84,9 +73,7 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, aliasMap,
 				if (!relation) continue;
 				if (relationType === "o2m" || relationType === "o2a") {
 					let pkField = `${collection$1}.${schema.collections[relation.related_collection].primary}`;
-					if (relationType === "o2a") {
-						pkField = knex$1.raw(getHelpers(knex$1).schema.castA2oPrimaryKey(), [pkField]);
-					}
+					if (relationType === "o2a") pkField = knex$1.raw(getHelpers(knex$1).schema.castA2oPrimaryKey(), [pkField]);
 					const childKey = Object.keys(value)?.[0];
 					if (childKey === "_none" || childKey === "_some") {
 						const subQueryBuilder = (filter$1, cases$1) => (subQueryKnex) => {
@@ -106,9 +93,7 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, aliasMap,
 						}
 					}
 				}
-				if (filterPath.includes("_none") || filterPath.includes("_some")) {
-					throw new InvalidQueryError({ reason: `"${filterPath.includes("_none") ? "_none" : "_some"}" can only be used with top level relational alias field` });
-				}
+				if (filterPath.includes("_none") || filterPath.includes("_some")) throw new InvalidQueryError({ reason: `"${filterPath.includes("_none") ? "_none" : "_some"}" can only be used with top level relational alias field` });
 				const { columnPath, targetCollection, addNestedPkField } = getColumnPath({
 					path: filterPath,
 					collection: collection$1,
@@ -116,9 +101,7 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, aliasMap,
 					aliasMap,
 					schema
 				});
-				if (addNestedPkField) {
-					filterPath.push(addNestedPkField);
-				}
+				if (addNestedPkField) filterPath.push(addNestedPkField);
 				if (!columnPath) continue;
 				const { type, special } = getFilterType(schema.collections[targetCollection].fields, filterPath.at(-1), targetCollection);
 				validateOperator(type, filterOperator, special);
@@ -126,8 +109,7 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, aliasMap,
 			} else {
 				const { type, special } = getFilterType(schema.collections[collection$1].fields, filterPath[0], collection$1);
 				validateOperator(type, filterOperator, special);
-				const aliasedCollection = aliasMap[""]?.alias || collection$1;
-				applyOperator(knex$1, dbQuery, schema, `${aliasedCollection}.${filterPath[0]}`, filterOperator, filterValue, logical, collection$1);
+				applyOperator(knex$1, dbQuery, schema, `${aliasMap[""]?.alias || collection$1}.${filterPath[0]}`, filterOperator, filterValue, logical, collection$1);
 			}
 		}
 	}

package/dist/database/run-ast/lib/apply-query/filter/operator.js

@@ -5,13 +5,11 @@ import { getOutputTypeForFunction } from "@directus/utils";
 
 //#region src/database/run-ast/lib/apply-query/filter/operator.ts
 function castToNumber(value) {
-	if (Array.isArray(value)) {
-		return value.map((val) => {
-			const num$1 = Number(val);
-			if (Number.isNaN(num$1)) throw new InvalidQueryError({ reason: `Invalid numeric value` });
-			return num$1;
-		});
-	}
+	if (Array.isArray(value)) return value.map((val) => {
+		const num$1 = Number(val);
+		if (Number.isNaN(num$1)) throw new InvalidQueryError({ reason: `Invalid numeric value` });
+		return num$1;
+	});
 	const num = Number(value);
 	if (Number.isNaN(num)) throw new InvalidQueryError({ reason: `Invalid numeric value` });
 	return num;
@@ -28,20 +26,14 @@ function applyOperator(knex, dbQuery, schema, key, operator, compareValue, logic
 		dbQuery[logical].whereNotNull(selectionRaw);
 		return;
 	}
-	if (operator === "_empty" && compareValue !== false || operator === "_nempty" && compareValue === false) {
-		dbQuery[logical].andWhere((query) => {
-			query.whereNull(key).orWhere(key, "=", "");
-		});
-	}
-	if (operator === "_nempty" && compareValue !== false || operator === "_empty" && compareValue === false) {
-		dbQuery[logical].andWhere((query) => {
-			query.whereNotNull(key).andWhere(key, "!=", "");
-		});
-	}
-	if (compareValue === undefined) return;
-	if (Array.isArray(compareValue)) {
-		compareValue = compareValue.filter((val) => val !== undefined);
-	}
+	if (operator === "_empty" && compareValue !== false || operator === "_nempty" && compareValue === false) dbQuery[logical].andWhere((query) => {
+		query.whereNull(key).orWhere(key, "=", "");
+	});
+	if (operator === "_nempty" && compareValue !== false || operator === "_empty" && compareValue === false) dbQuery[logical].andWhere((query) => {
+		query.whereNotNull(key).andWhere(key, "!=", "");
+	});
+	if (compareValue === void 0) return;
+	if (Array.isArray(compareValue)) compareValue = compareValue.filter((val) => val !== void 0);
 	if (column.includes("(") && column.includes(")")) {
 		const functionName = column.split("(")[0];
 		const type = getOutputTypeForFunction(functionName);
@@ -49,9 +41,7 @@ function applyOperator(knex, dbQuery, schema, key, operator, compareValue, logic
 			"integer",
 			"float",
 			"decimal"
-		].includes(type)) {
-			compareValue = castToNumber(compareValue);
-		}
+		].includes(type)) compareValue = castToNumber(compareValue);
 	}
 	const [collection, field] = key.split(".");
 	const mappedCollection = originalCollectionName || collection;
@@ -62,81 +52,34 @@ function applyOperator(knex, dbQuery, schema, key, operator, compareValue, logic
 			"dateTime",
 			"time",
 			"timestamp"
-		].includes(type)) {
-			if (Array.isArray(compareValue)) {
-				compareValue = compareValue.map((val) => helpers.date.parse(val));
-			} else {
-				compareValue = helpers.date.parse(compareValue);
-			}
-		}
+		].includes(type)) if (Array.isArray(compareValue)) compareValue = compareValue.map((val) => helpers.date.parse(val));
+		else compareValue = helpers.date.parse(compareValue);
 		if ([
 			"integer",
 			"float",
 			"decimal"
-		].includes(type)) {
-			compareValue = castToNumber(compareValue);
-		}
-	}
-	if (operator === "_eq") {
-		dbQuery[logical].where(selectionRaw, "=", compareValue);
-	}
-	if (operator === "_neq") {
-		dbQuery[logical].whereNot(selectionRaw, compareValue);
-	}
-	if (operator === "_ieq") {
-		dbQuery[logical].whereRaw(`LOWER(??) = ?`, [selectionRaw, `${compareValue.toLowerCase()}`]);
-	}
-	if (operator === "_nieq") {
-		dbQuery[logical].whereRaw(`LOWER(??) <> ?`, [selectionRaw, `${compareValue.toLowerCase()}`]);
-	}
-	if (operator === "_contains") {
-		dbQuery[logical].where(selectionRaw, "like", `%${compareValue}%`);
-	}
-	if (operator === "_ncontains") {
-		dbQuery[logical].whereNot(selectionRaw, "like", `%${compareValue}%`);
-	}
-	if (operator === "_icontains") {
-		dbQuery[logical].whereRaw(`LOWER(??) LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}%`]);
-	}
-	if (operator === "_nicontains") {
-		dbQuery[logical].whereRaw(`LOWER(??) NOT LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}%`]);
-	}
-	if (operator === "_starts_with") {
-		dbQuery[logical].where(key, "like", `${compareValue}%`);
-	}
-	if (operator === "_nstarts_with") {
-		dbQuery[logical].whereNot(key, "like", `${compareValue}%`);
-	}
-	if (operator === "_istarts_with") {
-		dbQuery[logical].whereRaw(`LOWER(??) LIKE ?`, [selectionRaw, `${compareValue.toLowerCase()}%`]);
-	}
-	if (operator === "_nistarts_with") {
-		dbQuery[logical].whereRaw(`LOWER(??) NOT LIKE ?`, [selectionRaw, `${compareValue.toLowerCase()}%`]);
-	}
-	if (operator === "_ends_with") {
-		dbQuery[logical].where(key, "like", `%${compareValue}`);
-	}
-	if (operator === "_nends_with") {
-		dbQuery[logical].whereNot(key, "like", `%${compareValue}`);
-	}
-	if (operator === "_iends_with") {
-		dbQuery[logical].whereRaw(`LOWER(??) LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}`]);
-	}
-	if (operator === "_niends_with") {
-		dbQuery[logical].whereRaw(`LOWER(??) NOT LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}`]);
-	}
-	if (operator === "_gt") {
-		dbQuery[logical].where(selectionRaw, ">", compareValue);
-	}
-	if (operator === "_gte") {
-		dbQuery[logical].where(selectionRaw, ">=", compareValue);
-	}
-	if (operator === "_lt") {
-		dbQuery[logical].where(selectionRaw, "<", compareValue);
-	}
-	if (operator === "_lte") {
-		dbQuery[logical].where(selectionRaw, "<=", compareValue);
-	}
+		].includes(type)) compareValue = castToNumber(compareValue);
+	}
+	if (operator === "_eq") dbQuery[logical].where(selectionRaw, "=", compareValue);
+	if (operator === "_neq") dbQuery[logical].whereNot(selectionRaw, compareValue);
+	if (operator === "_ieq") dbQuery[logical].whereRaw(`LOWER(??) = ?`, [selectionRaw, `${compareValue.toLowerCase()}`]);
+	if (operator === "_nieq") dbQuery[logical].whereRaw(`LOWER(??) <> ?`, [selectionRaw, `${compareValue.toLowerCase()}`]);
+	if (operator === "_contains") dbQuery[logical].where(selectionRaw, "like", `%${compareValue}%`);
+	if (operator === "_ncontains") dbQuery[logical].whereNot(selectionRaw, "like", `%${compareValue}%`);
+	if (operator === "_icontains") dbQuery[logical].whereRaw(`LOWER(??) LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}%`]);
+	if (operator === "_nicontains") dbQuery[logical].whereRaw(`LOWER(??) NOT LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}%`]);
+	if (operator === "_starts_with") dbQuery[logical].where(key, "like", `${compareValue}%`);
+	if (operator === "_nstarts_with") dbQuery[logical].whereNot(key, "like", `${compareValue}%`);
+	if (operator === "_istarts_with") dbQuery[logical].whereRaw(`LOWER(??) LIKE ?`, [selectionRaw, `${compareValue.toLowerCase()}%`]);
+	if (operator === "_nistarts_with") dbQuery[logical].whereRaw(`LOWER(??) NOT LIKE ?`, [selectionRaw, `${compareValue.toLowerCase()}%`]);
+	if (operator === "_ends_with") dbQuery[logical].where(key, "like", `%${compareValue}`);
+	if (operator === "_nends_with") dbQuery[logical].whereNot(key, "like", `%${compareValue}`);
+	if (operator === "_iends_with") dbQuery[logical].whereRaw(`LOWER(??) LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}`]);
+	if (operator === "_niends_with") dbQuery[logical].whereRaw(`LOWER(??) NOT LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}`]);
+	if (operator === "_gt") dbQuery[logical].where(selectionRaw, ">", compareValue);
+	if (operator === "_gte") dbQuery[logical].where(selectionRaw, ">=", compareValue);
+	if (operator === "_lt") dbQuery[logical].where(selectionRaw, "<", compareValue);
+	if (operator === "_lte") dbQuery[logical].where(selectionRaw, "<=", compareValue);
 	if (operator === "_in") {
 		let value = compareValue;
 		if (typeof value === "string") value = value.split(",");
@@ -159,18 +102,10 @@ function applyOperator(knex, dbQuery, schema, key, operator, compareValue, logic
 		if (value.length !== 2) return;
 		dbQuery[logical].whereNotBetween(selectionRaw, value);
 	}
-	if (operator == "_intersects") {
-		dbQuery[logical].whereRaw(helpers.st.intersects(key, compareValue));
-	}
-	if (operator == "_nintersects") {
-		dbQuery[logical].whereRaw(helpers.st.nintersects(key, compareValue));
-	}
-	if (operator == "_intersects_bbox") {
-		dbQuery[logical].whereRaw(helpers.st.intersects_bbox(key, compareValue));
-	}
-	if (operator == "_nintersects_bbox") {
-		dbQuery[logical].whereRaw(helpers.st.nintersects_bbox(key, compareValue));
-	}
+	if (operator == "_intersects") dbQuery[logical].whereRaw(helpers.st.intersects(key, compareValue));
+	if (operator == "_nintersects") dbQuery[logical].whereRaw(helpers.st.nintersects(key, compareValue));
+	if (operator == "_intersects_bbox") dbQuery[logical].whereRaw(helpers.st.intersects_bbox(key, compareValue));
+	if (operator == "_nintersects_bbox") dbQuery[logical].whereRaw(helpers.st.nintersects_bbox(key, compareValue));
 }
 
 //#endregion

package/dist/database/run-ast/lib/apply-query/filter/validate-operator.js

@@ -3,15 +3,9 @@ import { getFilterOperatorsForType } from "@directus/utils";
 
 //#region src/database/run-ast/lib/apply-query/filter/validate-operator.ts
 function validateOperator(type, filterOperator, special) {
-	if (filterOperator.startsWith("_")) {
-		filterOperator = filterOperator.slice(1);
-	}
-	if (!getFilterOperatorsForType(type).includes(filterOperator)) {
-		throw new InvalidQueryError({ reason: `"${type}" field type does not contain the "_${filterOperator}" filter operator` });
-	}
-	if (special?.includes("conceal") && !getFilterOperatorsForType("hash").includes(filterOperator)) {
-		throw new InvalidQueryError({ reason: `Field with "conceal" special does not allow the "_${filterOperator}" filter operator` });
-	}
+	if (filterOperator.startsWith("_")) filterOperator = filterOperator.slice(1);
+	if (!getFilterOperatorsForType(type).includes(filterOperator)) throw new InvalidQueryError({ reason: `"${type}" field type does not contain the "_${filterOperator}" filter operator` });
+	if (special?.includes("conceal") && !getFilterOperatorsForType("hash").includes(filterOperator)) throw new InvalidQueryError({ reason: `Field with "conceal" special does not allow the "_${filterOperator}" filter operator` });
 }
 
 //#endregion

package/dist/database/run-ast/lib/apply-query/get-filter-path.js

@@ -4,13 +4,9 @@ import { isObject } from "@directus/utils";
 function getFilterPath(key, value) {
 	const path = [key];
 	const childKey = Object.keys(value)[0];
-	if (!childKey || childKey.startsWith("_") === true && !["_none", "_some"].includes(childKey)) {
-		return path;
-	}
+	if (!childKey || childKey.startsWith("_") === true && !["_none", "_some"].includes(childKey)) return path;
 	const nestedValue = Object.values(value)[0];
-	if (isObject(value)) {
-		path.push(...getFilterPath(childKey, nestedValue));
-	}
+	if (isObject(value)) path.push(...getFilterPath(childKey, nestedValue));
 	return path;
 }
 

package/dist/database/run-ast/lib/apply-query/get-operation.js

@@ -6,21 +6,16 @@ import { isObject } from "@directus/utils";
 */
 function getOperation(key, value) {
 	if (key === "_and" || key === "_or") return null;
-	if (key.startsWith("_") && key !== "_none" && key !== "_some") {
-		return {
-			operator: key,
-			value
-		};
-	} else if (!isObject(value)) {
-		return {
-			operator: "_eq",
-			value
-		};
-	}
+	if (key.startsWith("_") && key !== "_none" && key !== "_some") return {
+		operator: key,
+		value
+	};
+	else if (!isObject(value)) return {
+		operator: "_eq",
+		value
+	};
 	const childKey = Object.keys(value)[0];
-	if (childKey) {
-		return getOperation(childKey, Object.values(value)[0]);
-	}
+	if (childKey) return getOperation(childKey, Object.values(value)[0]);
 	return null;
 }
 

package/dist/database/run-ast/lib/apply-query/index.js

@@ -17,24 +17,16 @@ function applyQuery(knex, collection, dbQuery, query, schema, cases, permissions
 	let hasJoins = false;
 	let hasMultiRelationalFilter = false;
 	applyLimit(knex, dbQuery, query.limit);
-	if (query.offset) {
-		applyOffset(knex, dbQuery, query.offset);
-	}
-	if (query.page && query.limit && query.limit !== -1) {
-		applyOffset(knex, dbQuery, query.limit * (query.page - 1));
-	}
+	if (query.offset) applyOffset(knex, dbQuery, query.offset);
+	if (query.page && query.limit && query.limit !== -1) applyOffset(knex, dbQuery, query.limit * (query.page - 1));
 	if (query.sort && !options?.isInnerQuery && !options?.hasMultiRelationalSort) {
 		const sortResult = applySort(knex, schema, dbQuery, query.sort, query.aggregate, collection, aliasMap);
-		if (!hasJoins) {
-			hasJoins = sortResult.hasJoins;
-		}
+		if (!hasJoins) hasJoins = sortResult.hasJoins;
 	}
 	const filter = joinFilterWithCases(query.filter, cases);
 	if (filter) {
 		const filterResult = applyFilter(knex, schema, dbQuery, filter, collection, aliasMap, cases, permissions);
-		if (!hasJoins) {
-			hasJoins = filterResult.hasJoins;
-		}
+		if (!hasJoins) hasJoins = filterResult.hasJoins;
 		hasMultiRelationalFilter = filterResult.hasMultiRelationalFilter;
 	}
 	if (query.group) {
@@ -42,43 +34,32 @@ function applyQuery(knex, collection, dbQuery, query, schema, cases, permissions
 		const rawColumns = query.group.map((column) => getColumn(knex, collection, column, false, schema));
 		let columns;
 		if (options?.groupWhenCases) {
-			if (helpers.capabilities.supportsColumnPositionInGroupBy() && options.groupColumnPositions) {
-				columns = query.group.map((column, index) => options.groupColumnPositions[index] !== undefined ? knex.raw(options.groupColumnPositions[index]) : column);
-			} else {
-				columns = rawColumns.map((column, index) => applyCaseWhen({
-					columnCases: options.groupWhenCases[index].map((caseIndex) => cases[caseIndex]),
-					column,
-					aliasMap,
-					cases,
-					table: collection,
-					permissions
-				}, {
-					knex,
-					schema
-				}));
-			}
+			if (helpers.capabilities.supportsColumnPositionInGroupBy() && options.groupColumnPositions) columns = query.group.map((column, index) => options.groupColumnPositions[index] !== void 0 ? knex.raw(options.groupColumnPositions[index]) : column);
+			else columns = rawColumns.map((column, index) => applyCaseWhen({
+				columnCases: options.groupWhenCases[index].map((caseIndex) => cases[caseIndex]),
+				column,
+				aliasMap,
+				cases,
+				table: collection,
+				permissions
+			}, {
+				knex,
+				schema
+			}));
 			if (query.sort && query.sort.length === 1 && query.sort[0] === query.group[0]) {
 				dbQuery.clear("order");
 				let order = "asc";
-				if (query.sort[0].startsWith("-")) {
-					order = "desc";
-				}
+				if (query.sort[0].startsWith("-")) order = "desc";
 				dbQuery.orderBy([{
 					column: columns[0],
 					order
 				}]);
 			}
-		} else {
-			columns = rawColumns;
-		}
+		} else columns = rawColumns;
 		dbQuery.groupBy(columns);
 	}
-	if (query.search) {
-		applySearch(knex, schema, dbQuery, query.search, collection, aliasMap, permissions);
-	}
-	if (query.aggregate) {
-		applyAggregate(schema, dbQuery, query.aggregate, collection, hasJoins);
-	}
+	if (query.search) applySearch(knex, schema, dbQuery, query.search, collection, aliasMap, permissions);
+	if (query.aggregate) applyAggregate(schema, dbQuery, query.aggregate, collection, hasJoins);
 	return {
 		query: dbQuery,
 		hasJoins,

package/dist/database/run-ast/lib/apply-query/join-filter-with-cases.js

@@ -1,12 +1,8 @@
 //#region src/database/run-ast/lib/apply-query/join-filter-with-cases.ts
 function joinFilterWithCases(filter, cases) {
-	if (cases.length > 0 && !filter) {
-		return { _or: cases };
-	} else if (filter && cases.length === 0) {
-		return filter ?? null;
-	} else if (filter && cases.length > 0) {
-		return { _and: [filter, { _or: cases }] };
-	}
+	if (cases.length > 0 && !filter) return { _or: cases };
+	else if (filter && cases.length === 0) return filter ?? null;
+	else if (filter && cases.length > 0) return { _and: [filter, { _or: cases }] };
 	return null;
 }