@directus/api 35.0.2 → 35.2.0

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

package/dist/database/run-ast/modules/fetch-permitted-ast-root-fields.js

@@ -10,24 +10,20 @@ import { cloneDeep } from "lodash-es";
 * same way as `runAst` but only returns flags (1/null) instead of actual field values.
 */
 async function fetchPermittedAstRootFields(originalAST, { schema, accountability, knex, action }) {
-	const ast = cloneDeep(originalAST);
-	const { name: collection, children, cases, query } = ast;
+	const { name: collection, children, cases, query } = cloneDeep(originalAST);
 	const { fieldNodes } = await parseCurrentLevel(schema, collection, children, query);
 	let permissions = [];
-	if (accountability && !accountability.admin) {
-		const policies = await fetchPolicies(accountability, {
+	if (accountability && !accountability.admin) permissions = await fetchPermissions({
+		action,
+		accountability,
+		policies: await fetchPolicies(accountability, {
 			schema,
 			knex
-		});
-		permissions = await fetchPermissions({
-			action,
-			accountability,
-			policies
-		}, {
-			schema,
-			knex
-		});
-	}
+		})
+	}, {
+		schema,
+		knex
+	});
 	return getDBQuery({
 		table: collection,
 		fieldNodes,

package/dist/database/run-ast/run-ast.js

@@ -20,33 +20,26 @@ async function runAst(originalAST, schema, accountability, options) {
 	const knex = options?.knex || database_default();
 	if (ast.type === "a2o") {
 		const results = {};
-		for (const collection of ast.names) {
-			results[collection] = await run(collection, ast.children[collection], ast.query[collection], ast.cases[collection] ?? [], accountability);
-		}
+		for (const collection of ast.names) results[collection] = await run(collection, ast.children[collection], ast.query[collection], ast.cases[collection] ?? [], accountability);
 		return results;
-	} else {
-		return await run(ast.name, ast.children, options?.query || ast.query, ast.cases, accountability);
-	}
+	} else return await run(ast.name, ast.children, options?.query || ast.query, ast.cases, accountability);
 	async function run(collection, children, query, cases, accountability$1) {
 		const env = useEnv();
 		const { fieldNodes, primaryKeyField, nestedCollectionNodes } = await parseCurrentLevel(schema, collection, children, query);
 		const o2mNodes = nestedCollectionNodes.filter((node) => node.type === "o2m");
 		let permissions = [];
-		if (accountability$1 && !accountability$1.admin) {
-			const policies = await fetchPolicies(accountability$1, {
-				schema,
-				knex
-			});
-			permissions = await fetchPermissions({
-				action: "read",
-				accountability: accountability$1,
-				policies
-			}, {
+		if (accountability$1 && !accountability$1.admin) permissions = await fetchPermissions({
+			action: "read",
+			accountability: accountability$1,
+			policies: await fetchPolicies(accountability$1, {
 				schema,
 				knex
-			});
-		}
-		const dbQuery = getDBQuery({
+			})
+		}, {
+			schema,
+			knex
+		});
+		const rawItems = await getDBQuery({
 			table: collection,
 			fieldNodes,
 			o2mNodes,
@@ -57,7 +50,6 @@ async function runAst(originalAST, schema, accountability, options) {
 			schema,
 			knex
 		});
-		const rawItems = await dbQuery;
 		if (!rawItems) return null;
 		const payloadService = new PayloadService(collection, {
 			accountability: accountability$1,
@@ -65,11 +57,9 @@ async function runAst(originalAST, schema, accountability, options) {
 			schema
 		});
 		const aliasMap = { ...query.alias };
-		for (const child of children) {
-			if (child.type === "functionField" && child.name.startsWith("json(")) {
-				const alias = applyFunctionToColumnName(child.fieldKey);
-				aliasMap[alias] = child.name;
-			}
+		for (const child of children) if (child.type === "functionField" && child.name.startsWith("json(")) {
+			const alias = applyFunctionToColumnName(child.fieldKey);
+			aliasMap[alias] = child.name;
 		}
 		let items = await payloadService.processValues("read", rawItems, aliasMap, query.aggregate ?? {});
 		if (!items || Array.isArray(items) && items.length === 0) return items;
@@ -81,50 +71,38 @@ async function runAst(originalAST, schema, accountability, options) {
 				let batchCount = 0;
 				const hasWhenCase = nestedNode.whenCase && nestedNode.whenCase.length > 0;
 				let fieldAllowed = true;
-				if (hasWhenCase) {
-					if (Array.isArray(items)) {
-						fieldAllowed = [];
-						for (const item of items) {
-							fieldAllowed.push(!!item[nestedNode.fieldKey]);
-							delete item[nestedNode.fieldKey];
-						}
-					} else {
-						fieldAllowed = !!items[nestedNode.fieldKey];
-						delete items[nestedNode.fieldKey];
+				if (hasWhenCase) if (Array.isArray(items)) {
+					fieldAllowed = [];
+					for (const item of items) {
+						fieldAllowed.push(!!item[nestedNode.fieldKey]);
+						delete item[nestedNode.fieldKey];
 					}
+				} else {
+					fieldAllowed = !!items[nestedNode.fieldKey];
+					delete items[nestedNode.fieldKey];
 				}
 				while (hasMore) {
-					const node = merge({}, nestedNode, { query: {
+					nestedItems = await runAst(merge({}, nestedNode, { query: {
 						limit: env["RELATIONAL_BATCH_SIZE"],
 						offset: batchCount * env["RELATIONAL_BATCH_SIZE"],
 						page: null
-					} });
-					nestedItems = await runAst(node, schema, accountability$1, {
+					} }), schema, accountability$1, {
 						knex,
 						nested: true
 					});
-					if (nestedItems) {
-						items = mergeWithParentItems(schema, nestedItems, items, nestedNode, fieldAllowed);
-					}
-					if (!nestedItems || nestedItems.length < env["RELATIONAL_BATCH_SIZE"]) {
-						hasMore = false;
-					}
+					if (nestedItems) items = mergeWithParentItems(schema, nestedItems, items, nestedNode, fieldAllowed);
+					if (!nestedItems || nestedItems.length < env["RELATIONAL_BATCH_SIZE"]) hasMore = false;
 					batchCount++;
 				}
 			} else {
-				const node = merge({}, nestedNode, { query: { limit: -1 } });
-				nestedItems = await runAst(node, schema, accountability$1, {
+				nestedItems = await runAst(merge({}, nestedNode, { query: { limit: -1 } }), schema, accountability$1, {
 					knex,
 					nested: true
 				});
-				if (nestedItems) {
-					items = mergeWithParentItems(schema, nestedItems, items, nestedNode, true);
-				}
+				if (nestedItems) items = mergeWithParentItems(schema, nestedItems, items, nestedNode, true);
 			}
 		}
-		if (options?.nested !== true && options?.stripNonRequested !== false) {
-			items = removeTemporaryFields(schema, items, originalAST, primaryKeyField);
-		}
+		if (options?.nested !== true && options?.stripNonRequested !== false) items = removeTemporaryFields(schema, items, originalAST, primaryKeyField);
 		return items;
 	}
 }

package/dist/database/run-ast/utils/apply-case-when.js

@@ -10,9 +10,7 @@ function applyCaseWhen({ columnCases, table, aliasMap, cases, column, alias, per
 	for (const statement of compiler.grouped.where) {
 		const val = compiler[statement.type](statement);
 		if (val) {
-			if (sqlParts.length > 0) {
-				sqlParts.push(statement.bool);
-			}
+			if (sqlParts.length > 0) sqlParts.push(statement.bool);
 			sqlParts.push(val);
 		}
 	}

package/dist/database/run-ast/utils/apply-function-to-column-name.js

@@ -19,12 +19,8 @@ function applyFunctionToColumnName(column) {
 		if (functionName === "json") {
 			const slug = columnName?.replace(/[.[\],\s]+/g, "_");
 			return `${slug}${slug?.endsWith("_") ? "" : "_"}${functionName}`;
-		} else {
-			return `${columnName}_${functionName}`;
-		}
-	} else {
-		return column;
-	}
+		} else return `${columnName}_${functionName}`;
+	} else return column;
 }
 
 //#endregion

package/dist/database/run-ast/utils/apply-parent-filters.js

@@ -11,27 +11,22 @@ function applyParentFilters(schema, nestedCollectionNodes, parentItem) {
 			const foreignIds = uniq(parentItems.map((res) => res[nestedNode.relation.field])).filter((id) => !isNil(id));
 			merge(nestedNode, { query: { filter: { [foreignField]: { _in: foreignIds } } } });
 		} else if (nestedNode.type === "o2m") {
-			const relatedM2OisFetched = !!nestedNode.children.find((child) => {
+			if (!!nestedNode.children.find((child) => {
 				return child.type === "field" && child.name === nestedNode.relation.field;
+			}) === false) nestedNode.children.push({
+				type: "field",
+				name: nestedNode.relation.field,
+				fieldKey: nestedNode.relation.field,
+				whenCase: [],
+				alias: false
+			});
+			if (nestedNode.relation.meta?.sort_field) nestedNode.children.push({
+				type: "field",
+				name: nestedNode.relation.meta.sort_field,
+				fieldKey: nestedNode.relation.meta.sort_field,
+				whenCase: [],
+				alias: false
 			});
-			if (relatedM2OisFetched === false) {
-				nestedNode.children.push({
-					type: "field",
-					name: nestedNode.relation.field,
-					fieldKey: nestedNode.relation.field,
-					whenCase: [],
-					alias: false
-				});
-			}
-			if (nestedNode.relation.meta?.sort_field) {
-				nestedNode.children.push({
-					type: "field",
-					name: nestedNode.relation.meta.sort_field,
-					fieldKey: nestedNode.relation.meta.sort_field,
-					whenCase: [],
-					alias: false
-				});
-			}
 			const foreignField = nestedNode.relation.field;
 			const foreignIds = uniq(parentItems.map((res) => res[nestedNode.parentKey])).filter((id) => !isNil(id));
 			merge(nestedNode, { query: { filter: { [foreignField]: { _in: foreignIds } } } });

package/dist/database/run-ast/utils/generate-alias.js

@@ -4,38 +4,33 @@ import { customAlphabet } from "nanoid/non-secure";
 //#region src/database/run-ast/utils/generate-alias.ts
 const generateRandomAlias = customAlphabet("abcdefghijklmnopqrstuvwxyz", 5);
 function generateAlias(context = "") {
-	if (context) {
-		return generateDeterministicAlias(context);
-	}
+	if (context) return generateDeterministicAlias(context);
 	return generateRandomAlias();
 }
 function generateQueryAlias(table, query, path = "") {
-	const context = JSON.stringify({
+	return generateDeterministicAlias(JSON.stringify({
 		table,
 		path,
 		sort: query.sort,
 		group: query.group,
 		aggregate: query.aggregate
-	});
-	return generateDeterministicAlias(context);
+	}));
 }
 function generateRelationalQueryAlias(table, column, collectionName, options) {
-	const context = JSON.stringify({
+	return generateDeterministicAlias(JSON.stringify({
 		table,
 		column,
 		collectionName,
 		filter: options?.relationalCountOptions?.query?.filter
-	});
-	return generateDeterministicAlias(context);
+	}));
 }
 function generateJoinAlias(collection, path, relationType, parentFields = "") {
-	const context = JSON.stringify({
+	return generateDeterministicAlias(JSON.stringify({
 		collection,
 		path: path.join("."),
 		relationType,
 		parentFields
-	});
-	return generateDeterministicAlias(context);
+	}));
 }
 function generateDeterministicAlias(context = "") {
 	const hash = getSimpleHash(context);
@@ -43,8 +38,8 @@ function generateDeterministicAlias(context = "") {
 	let result = "";
 	let num = parseInt(hash, 16);
 	for (let i = 0; i < 5; i++) {
-		result += alphabet[num % alphabet.length];
-		num = Math.floor(num / alphabet.length);
+		result += alphabet[num % 26];
+		num = Math.floor(num / 26);
 	}
 	return result;
 }

package/dist/database/run-ast/utils/get-column-pre-processor.js

@@ -17,35 +17,23 @@ function getColumnPreprocessor(knex, schema, table, cases, permissions, aliasMap
 		if (fieldNode.type === "field" || fieldNode.type === "functionField") {
 			const { fieldName } = parseFilterKey(fieldNode.name);
 			field = schema.collections[table].fields[fieldName];
-		} else {
-			field = schema.collections[fieldNode.relation.collection].fields[fieldNode.relation.field];
-		}
+		} else field = schema.collections[fieldNode.relation.collection].fields[fieldNode.relation.field];
 		let column;
-		if (permissionsOnly) {
-			if (noAlias) {
-				column = knex.raw(1);
-			} else {
-				column = knex.raw("1 as ??", [alias]);
-			}
-		} else if (field?.type?.startsWith("geometry")) {
-			column = helpers.st.asText(table, field.field, rawColumnAlias);
-		} else if (fieldNode.type === "functionField") {
-			column = getColumn(knex, table, fieldNode.name, rawColumnAlias, schema, {
-				query: {
-					...fieldNode.query,
-					filter: joinFilterWithCases(fieldNode.query.filter, fieldNode.cases)
-				},
-				permissions,
-				cases: fieldNode.cases
-			});
-		} else {
-			column = getColumn(knex, table, fieldNode.name, rawColumnAlias, schema);
-		}
+		if (permissionsOnly) if (noAlias) column = knex.raw(1);
+		else column = knex.raw("1 as ??", [alias]);
+		else if (field?.type?.startsWith("geometry")) column = helpers.st.asText(table, field.field, rawColumnAlias);
+		else if (fieldNode.type === "functionField") column = getColumn(knex, table, fieldNode.name, rawColumnAlias, schema, {
+			query: {
+				...fieldNode.query,
+				filter: joinFilterWithCases(fieldNode.query.filter, fieldNode.cases)
+			},
+			permissions,
+			cases: fieldNode.cases
+		});
+		else column = getColumn(knex, table, fieldNode.name, rawColumnAlias, schema);
 		if (hasWhenCase) {
 			const columnCases = [];
-			for (const index of fieldNode.whenCase) {
-				columnCases.push(cases[index]);
-			}
+			for (const index of fieldNode.whenCase) columnCases.push(cases[index]);
 			column = applyCaseWhen({
 				column,
 				columnCases,

package/dist/database/run-ast/utils/get-column.js

@@ -33,31 +33,22 @@ function getColumn(knex, table, column, alias = applyFunctionToColumnName(column
 				jsonPath = result$1.path;
 			}
 			const type = schema?.collections[collectionName]?.fields?.[fieldName]?.type ?? "unknown";
-			const allowedFunctions = getFunctionsForType(type);
-			if (allowedFunctions.includes(functionName) === false) {
-				throw new InvalidQueryError({ reason: `Invalid function specified "${functionName}"` });
-			}
+			if (getFunctionsForType(type).includes(functionName) === false) throw new InvalidQueryError({ reason: `Invalid function specified "${functionName}"` });
 			const result = fn[functionName](table, fieldName, {
 				type,
 				relationalCountOptions: isFunctionColumnOptions(options) ? {
 					query: options.query,
 					cases: options.cases,
 					permissions: options.permissions
-				} : undefined,
+				} : void 0,
 				originalCollectionName: options?.originalCollectionName,
 				jsonPath
 			});
-			if (alias) {
-				return knex.raw(result + " AS ??", [alias]);
-			}
+			if (alias) return knex.raw(result + " AS ??", [alias]);
 			return result;
-		} else {
-			throw new InvalidQueryError({ reason: `Invalid function specified "${functionName}"` });
-		}
-	}
-	if (alias && column !== alias) {
-		return knex.ref(`${table}.${column}`).as(alias);
+		} else throw new InvalidQueryError({ reason: `Invalid function specified "${functionName}"` });
 	}
+	if (alias && column !== alias) return knex.ref(`${table}.${column}`).as(alias);
 	return knex.ref(`${table}.${column}`);
 }
 function isFunctionColumnOptions(options) {