@directus/api 35.0.2 → 35.1.0

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;
 }
 

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

@@ -2,14 +2,10 @@ import { getHelpers } from "../../../helpers/index.js";
 
 //#region src/database/run-ast/lib/apply-query/pagination.ts
 function applyLimit(knex, rootQuery, limit) {
-	if (typeof limit === "number") {
-		getHelpers(knex).schema.applyLimit(rootQuery, limit);
-	}
+	if (typeof limit === "number") getHelpers(knex).schema.applyLimit(rootQuery, limit);
 }
 function applyOffset(knex, rootQuery, offset) {
-	if (typeof offset === "number") {
-		getHelpers(knex).schema.applyOffset(rootQuery, offset);
-	}
+	if (typeof offset === "number") getHelpers(knex).schema.applyOffset(rootQuery, offset);
 }
 
 //#endregion

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

@@ -13,60 +13,36 @@ function applySearch(knex, schema, dbQuery, searchQuery, collection, aliasMap, p
 	let fields = Object.entries(schema.collections[collection].fields);
 	fields = fields.filter(([_name, field]) => field.searchable !== false && field.special.includes("conceal") !== true);
 	const { cases, caseMap } = getCases(collection, permissions, []);
-	if (cases.length !== 0 && !allowedFields.has("*")) {
-		fields = fields.filter((field) => allowedFields.has(field[0]));
-	}
+	if (cases.length !== 0 && !allowedFields.has("*")) fields = fields.filter((field) => allowedFields.has(field[0]));
 	dbQuery.andWhere(function(queryBuilder) {
 		let needsFallbackCondition = true;
 		fields.forEach(([name, field]) => {
 			const whenCases = allowedFields.has("*") ? [] : (caseMap[name] ?? []).map((caseIndex) => cases[caseIndex]);
 			const fieldType = getFieldType(field);
-			if (fieldType !== null) {
-				needsFallbackCondition = false;
-			} else {
-				return;
-			}
-			if (cases.length !== 0 && whenCases?.length !== 0) {
-				queryBuilder.orWhere((subQuery) => {
-					addSearchCondition(subQuery, name, fieldType, "and");
-					applyFilter(knex, schema, subQuery, { _or: whenCases }, collection, aliasMap, cases, permissions);
-				});
-			} else {
-				addSearchCondition(queryBuilder, name, fieldType, "or");
-			}
+			if (fieldType !== null) needsFallbackCondition = false;
+			else return;
+			if (cases.length !== 0 && whenCases?.length !== 0) queryBuilder.orWhere((subQuery) => {
+				addSearchCondition(subQuery, name, fieldType, "and");
+				applyFilter(knex, schema, subQuery, { _or: whenCases }, collection, aliasMap, cases, permissions);
+			});
+			else addSearchCondition(queryBuilder, name, fieldType, "or");
 		});
-		if (needsFallbackCondition) {
-			queryBuilder.orWhereRaw("1 = 0");
-		}
+		if (needsFallbackCondition) queryBuilder.orWhereRaw("1 = 0");
 	});
 	function addSearchCondition(queryBuilder, name, fieldType, logical) {
-		if (fieldType === null) {
-			return;
-		}
-		if (fieldType === "string") {
-			queryBuilder[logical].whereRaw(`LOWER(??) LIKE ?`, [`${collection}.${name}`, `%${searchQuery.toLowerCase()}%`]);
-		} else if (fieldType === "numeric") {
-			numberHelper.addSearchCondition(queryBuilder, collection, name, parseNumericString(searchQuery), logical);
-		} else if (fieldType === "uuid") {
-			queryBuilder[logical].where({ [`${collection}.${name}`]: searchQuery });
-		}
+		if (fieldType === null) return;
+		if (fieldType === "string") queryBuilder[logical].whereRaw(`LOWER(??) LIKE ?`, [`${collection}.${name}`, `%${searchQuery.toLowerCase()}%`]);
+		else if (fieldType === "numeric") numberHelper.addSearchCondition(queryBuilder, collection, name, parseNumericString(searchQuery), logical);
+		else if (fieldType === "uuid") queryBuilder[logical].where({ [`${collection}.${name}`]: searchQuery });
 	}
 	function getFieldType(field) {
-		if (["text", "string"].includes(field.type)) {
-			return "string";
-		}
+		if (["text", "string"].includes(field.type)) return "string";
 		if (isNumericField(field)) {
 			const number = parseNumericString(searchQuery);
-			if (number === null) {
-				return null;
-			}
-			if (numberHelper.isNumberValid(number, field)) {
-				return "numeric";
-			}
-		}
-		if (field.type === "uuid" && isValidUuid(searchQuery)) {
-			return "uuid";
+			if (number === null) return null;
+			if (numberHelper.isNumberValid(number, field)) return "numeric";
 		}
+		if (field.type === "uuid" && isValidUuid(searchQuery)) return "uuid";
 		return null;
 	}
 }

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

@@ -11,27 +11,19 @@ function applySort(knex, schema, rootQuery, sort, aggregate, collection, aliasMa
 	const sortRecords = sort.map((sortField) => {
 		const column = sortField.split(".");
 		let order = "asc";
-		if (sortField.startsWith("-")) {
-			order = "desc";
-		}
-		if (column[0].startsWith("-")) {
-			column[0] = column[0].substring(1);
-		}
+		if (sortField.startsWith("-")) order = "desc";
+		if (column[0].startsWith("-")) column[0] = column[0].substring(1);
 		if (Object.keys(aggregate ?? {}).includes(column[0])) {
 			const operation = column[0];
 			const field$1 = column[1];
-			if (operation === "countAll") {
-				return {
-					order,
-					column: "countAll"
-				};
-			}
-			if (operation === "count" && (field$1 === "*" || !field$1)) {
-				return {
-					order,
-					column: "count"
-				};
-			}
+			if (operation === "countAll") return {
+				order,
+				column: "countAll"
+			};
+			if (operation === "count" && (field$1 === "*" || !field$1)) return {
+				order,
+				column: "count"
+			};
 			return {
 				order,
 				column: returnRecords ? column[0] : `${operation}->${field$1}`
@@ -40,12 +32,10 @@ function applySort(knex, schema, rootQuery, sort, aggregate, collection, aliasMa
 		if (column.length === 1) {
 			const pathRoot = column[0].split(":")[0];
 			const { relation, relationType } = getRelationInfo(relations, collection, pathRoot);
-			if (!relation || ["m2o", "a2o"].includes(relationType ?? "")) {
-				return {
-					order,
-					column: returnRecords ? column[0] : getColumn(knex, collection, column[0], false, schema)
-				};
-			}
+			if (!relation || ["m2o", "a2o"].includes(relationType ?? "")) return {
+				order,
+				column: returnRecords ? column[0] : getColumn(knex, collection, column[0], false, schema)
+			};
 		}
 		const { hasMultiRelational, isJoinAdded } = addJoin({
 			path: column,
@@ -63,12 +53,8 @@ function applySort(knex, schema, rootQuery, sort, aggregate, collection, aliasMa
 			schema
 		});
 		const [alias, field] = columnPath.split(".");
-		if (!hasJoins) {
-			hasJoins = isJoinAdded;
-		}
-		if (!hasMultiRelationalSort) {
-			hasMultiRelationalSort = hasMultiRelational;
-		}
+		if (!hasJoins) hasJoins = isJoinAdded;
+		if (!hasMultiRelationalSort) hasMultiRelationalSort = hasMultiRelational;
 		return {
 			order,
 			column: returnRecords ? columnPath : getColumn(knex, alias, field, false, schema)

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

@@ -26,18 +26,15 @@ function getDBQuery({ table, fieldNodes, o2mNodes, query, cases, permissions, pe
 		const flatQuery = knex.from(table);
 		const fieldNodeMap = Object.fromEntries(fieldNodes.map((node, index) => [node.fieldKey, [node, index]]));
 		const groupFieldNodes = queryCopy.group?.map((field) => fieldNodeMap[field][0]) ?? [];
-		const groupWhenCases = hasCaseWhen ? groupFieldNodes.map((node) => node.whenCase ?? []) : undefined;
+		const groupWhenCases = hasCaseWhen ? groupFieldNodes.map((node) => node.whenCase ?? []) : void 0;
 		const aggregateCount = Object.entries(queryCopy.aggregate ?? {}).reduce((acc, [_, fields]) => acc + fields.length, 0);
-		const groupColumnPositions = queryCopy.group?.map((field) => fieldNodeMap[field][1] + 1 + aggregateCount) ?? [];
 		const dbQuery$1 = applyQuery(knex, table, flatQuery, queryCopy, schema, cases, permissions, {
 			aliasMap,
 			groupWhenCases,
-			groupColumnPositions
+			groupColumnPositions: queryCopy.group?.map((field) => fieldNodeMap[field][1] + 1 + aggregateCount) ?? []
 		}).query;
 		flatQuery.select(fieldNodes.map((node) => preProcess(node)));
-		if (helpers.capabilities.supportsDeduplicationOfParameters() && !helpers.capabilities.supportsColumnPositionInGroupBy()) {
-			withPreprocessBindings(knex, dbQuery$1);
-		}
+		if (helpers.capabilities.supportsDeduplicationOfParameters() && !helpers.capabilities.supportsColumnPositionInGroupBy()) withPreprocessBindings(knex, dbQuery$1);
 		return dbQuery$1;
 	}
 	const primaryKey = schema.collections[table].primary;
@@ -85,9 +82,7 @@ function getDBQuery({ table, fieldNodes, o2mNodes, query, cases, permissions, pe
 			let orderByString = "";
 			const orderByFields = [];
 			sortRecords.map((sortRecord, index) => {
-				if (orderByString.length !== 0) {
-					orderByString += ", ";
-				}
+				if (orderByString.length !== 0) orderByString += ", ";
 				const sortAlias = generateQueryAlias(table, queryCopy, `sort_${index}_${sortRecord.column}_${sortRecord.order}`);
 				let orderByColumn;
 				if (sortRecord.column.includes(".")) {
@@ -119,9 +114,7 @@ function getDBQuery({ table, fieldNodes, o2mNodes, query, cases, permissions, pe
 				if (sortRecord.column.includes(".")) {
 					const [alias, field] = sortRecord.column.split(".");
 					sortRecord.column = getColumn(knex, alias, field, false, schema, { originalCollectionName: getCollectionFromAlias(alias, aliasMap) });
-				} else {
-					sortRecord.column = getColumn(knex, table, sortRecord.column, false, schema);
-				}
+				} else sortRecord.column = getColumn(knex, table, sortRecord.column, false, schema);
 			});
 			dbQuery.orderBy(sortRecords);
 		}
@@ -137,9 +130,8 @@ function getDBQuery({ table, fieldNodes, o2mNodes, query, cases, permissions, pe
 		dbQuery.groupBy(groupByFields);
 	}
 	const wrapperQuery = knex.from(table).innerJoin(knex.raw("??", dbQuery.as("inner")), `${table}.${primaryKey}`, `inner.${primaryKey}`);
-	if (!hasCaseWhen) {
-		wrapperQuery.select(fieldNodes.map((node) => preProcess(node)));
-	} else {
+	if (!hasCaseWhen) wrapperQuery.select(fieldNodes.map((node) => preProcess(node)));
+	else {
 		const plainColumns = fieldNodes.filter((fieldNode) => !fieldNode.whenCase || fieldNode.whenCase.length === 0);
 		const whenCaseColumns = fieldNodes.filter((fieldNode) => fieldNode.whenCase && fieldNode.whenCase.length > 0);
 		wrapperQuery.select(plainColumns.map((node) => preProcess(node)));

package/dist/database/run-ast/lib/parse-current-level.js

@@ -10,42 +10,29 @@ async function parseCurrentLevel(schema, collection, children, query) {
 	for (const child of children) {
 		if (child.type === "field" || child.type === "functionField") {
 			let fieldName;
-			if (child.type == "functionField" && child.name.startsWith("json")) {
-				fieldName = parseJsonFunction(child.name).field;
-			} else {
-				fieldName = parseFilterKey(child.name).fieldName;
-			}
-			if (columnsInCollection.includes(fieldName)) {
-				columnsToSelectInternal.push(child.fieldKey);
-			}
+			if (child.type == "functionField" && child.name.startsWith("json")) fieldName = parseJsonFunction(child.name).field;
+			else fieldName = parseFilterKey(child.name).fieldName;
+			if (columnsInCollection.includes(fieldName)) columnsToSelectInternal.push(child.fieldKey);
 			continue;
 		}
 		if (!child.relation) continue;
-		if (child.type === "m2o") {
-			columnsToSelectInternal.push(child.relation.field);
-		}
+		if (child.type === "m2o") columnsToSelectInternal.push(child.relation.field);
 		if (child.type === "a2o") {
 			columnsToSelectInternal.push(child.relation.field);
 			columnsToSelectInternal.push(child.relation.meta.one_collection_field);
 		}
 		nestedCollectionNodes.push(child);
 	}
-	const isAggregate = (query.group || query.aggregate && Object.keys(query.aggregate).length > 0) ?? false;
 	/** Always fetch primary key in case there's a nested relation that needs it. Aggregate payloads
 	* can't have nested relational fields
 	*/
-	if (isAggregate === false && columnsToSelectInternal.includes(primaryKeyField) === false) {
-		columnsToSelectInternal.push(primaryKeyField);
-	}
-	/** Make sure select list has unique values */
-	const columnsToSelect = [...new Set(columnsToSelectInternal)];
-	const fieldNodes = columnsToSelect.map((column) => children.find((childNode) => (childNode.type === "field" || childNode.type === "functionField") && childNode.fieldKey === column) ?? {
-		type: "field",
-		name: column,
-		fieldKey: column
-	});
+	if (((query.group || query.aggregate && Object.keys(query.aggregate).length > 0) ?? false) === false && columnsToSelectInternal.includes(primaryKeyField) === false) columnsToSelectInternal.push(primaryKeyField);
 	return {
-		fieldNodes,
+		fieldNodes: [...new Set(columnsToSelectInternal)].map((column) => children.find((childNode) => (childNode.type === "field" || childNode.type === "functionField") && childNode.fieldKey === column) ?? {
+			type: "field",
+			name: column,
+			fieldKey: column
+		}),
 		nestedCollectionNodes,
 		primaryKeyField
 	};