@directus/api 35.0.2 → 35.1.0

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) {

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

@@ -7,9 +7,7 @@ function getInnerQueryColumnPreProcessor(knex, schema, table, cases, permissions
 		const alias = getNodeAlias(fieldNode);
 		if (fieldNode.whenCase && fieldNode.whenCase.length > 0) {
 			const columnCases = [];
-			for (const index of fieldNode.whenCase) {
-				columnCases.push(cases[index]);
-			}
+			for (const index of fieldNode.whenCase) columnCases.push(cases[index]);
 			const caseWhen = applyCaseWhen({
 				column: knex.raw(1),
 				columnCases,

package/dist/database/run-ast/utils/merge-with-parent-items.js

@@ -8,66 +8,45 @@ function mergeWithParentItems(schema, nestedItem, parentItem, nestedNode, fieldA
 	const nestedItems = toArray(nestedItem);
 	const parentItems = clone(toArray(parentItem));
 	if (nestedNode.type === "m2o") {
-		const parentsByForeignKey = new Map();
+		const parentsByForeignKey = /* @__PURE__ */ new Map();
 		for (const parentItem$1 of parentItems) {
 			const relationKey = parentItem$1[nestedNode.relation.field];
-			if (!parentsByForeignKey.has(relationKey)) {
-				parentsByForeignKey.set(relationKey, []);
-			}
+			if (!parentsByForeignKey.has(relationKey)) parentsByForeignKey.set(relationKey, []);
 			parentItem$1[nestedNode.fieldKey] = null;
 			parentsByForeignKey.get(relationKey).push(parentItem$1);
 		}
 		const nestedPrimaryKeyField = schema.collections[nestedNode.relation.related_collection].primary;
 		for (const nestedItem$1 of nestedItems) {
 			const nestedPK = nestedItem$1[nestedPrimaryKeyField];
-			if (nestedPK === null) {
-				continue;
-			}
-			if (!parentsByForeignKey.has(nestedPK)) {
-				continue;
-			}
-			for (const parentItem$1 of parentsByForeignKey.get(nestedPK)) {
-				parentItem$1[nestedNode.fieldKey] = nestedItem$1;
-			}
+			if (nestedPK === null) continue;
+			if (!parentsByForeignKey.has(nestedPK)) continue;
+			for (const parentItem$1 of parentsByForeignKey.get(nestedPK)) parentItem$1[nestedNode.fieldKey] = nestedItem$1;
 		}
 	} else if (nestedNode.type === "o2m") {
 		const parentCollectionName = nestedNode.relation.related_collection;
 		const parentPrimaryKeyField = schema.collections[parentCollectionName].primary;
 		const parentRelationField = nestedNode.fieldKey;
 		const nestedParentKeyField = nestedNode.relation.field;
-		const parentsByPrimaryKey = new Map();
+		const parentsByPrimaryKey = /* @__PURE__ */ new Map();
 		for (const parentItem$1 of parentItems) {
-			if (!parentItem$1[parentRelationField]) {
-				parentItem$1[parentRelationField] = [];
-			}
+			if (!parentItem$1[parentRelationField]) parentItem$1[parentRelationField] = [];
 			let parentPrimaryKey = parentItem$1[parentPrimaryKeyField];
-			if (parentPrimaryKey === null) {
-				continue;
-			} else {
-				parentPrimaryKey = parentPrimaryKey.toString();
-			}
-			if (parentsByPrimaryKey.has(parentPrimaryKey)) {
-				throw new Error(`Duplicate parent primary key '${parentPrimaryKey}' of '${parentCollectionName}' when merging o2m nested items`);
-			}
+			if (parentPrimaryKey === null) continue;
+			else parentPrimaryKey = parentPrimaryKey.toString();
+			if (parentsByPrimaryKey.has(parentPrimaryKey)) throw new Error(`Duplicate parent primary key '${parentPrimaryKey}' of '${parentCollectionName}' when merging o2m nested items`);
 			parentsByPrimaryKey.set(parentPrimaryKey, parentItem$1);
 		}
 		const toAddToAllParents = [];
 		for (const nestedItem$1 of nestedItems) {
-			if (nestedItem$1 === null) {
-				continue;
-			}
+			if (nestedItem$1 === null) continue;
 			if (Array.isArray(nestedItem$1[nestedParentKeyField])) {
 				toAddToAllParents.push(nestedItem$1);
 				continue;
 			}
 			const parentPrimaryKey = nestedItem$1[nestedParentKeyField]?.[parentPrimaryKeyField] ?? nestedItem$1[nestedParentKeyField];
-			if (parentPrimaryKey === null) {
-				continue;
-			}
+			if (parentPrimaryKey === null) continue;
 			const parentItem$1 = parentsByPrimaryKey.get(parentPrimaryKey.toString());
-			if (!parentItem$1) {
-				continue;
-			}
+			if (!parentItem$1) continue;
 			parentItem$1[parentRelationField].push(nestedItem$1);
 		}
 		for (const [index, parentItem$1] of parentItems.entries()) {
@@ -77,15 +56,9 @@ function mergeWithParentItems(schema, nestedItem, parentItem, nestedNode, fieldA
 			}
 			parentItem$1[parentRelationField].push(...toAddToAllParents);
 			const limit = nestedNode.query.limit ?? Number(env["QUERY_LIMIT_DEFAULT"]);
-			if (nestedNode.query.page && nestedNode.query.page > 1) {
-				parentItem$1[nestedNode.fieldKey] = parentItem$1[nestedNode.fieldKey].slice(limit * (nestedNode.query.page - 1));
-			}
-			if (nestedNode.query.offset && nestedNode.query.offset >= 0) {
-				parentItem$1[nestedNode.fieldKey] = parentItem$1[nestedNode.fieldKey].slice(nestedNode.query.offset);
-			}
-			if (limit !== -1) {
-				parentItem$1[nestedNode.fieldKey] = parentItem$1[nestedNode.fieldKey].slice(0, limit);
-			}
+			if (nestedNode.query.page && nestedNode.query.page > 1) parentItem$1[nestedNode.fieldKey] = parentItem$1[nestedNode.fieldKey].slice(limit * (nestedNode.query.page - 1));
+			if (nestedNode.query.offset && nestedNode.query.offset >= 0) parentItem$1[nestedNode.fieldKey] = parentItem$1[nestedNode.fieldKey].slice(nestedNode.query.offset);
+			if (limit !== -1) parentItem$1[nestedNode.fieldKey] = parentItem$1[nestedNode.fieldKey].slice(0, limit);
 			parentItem$1[nestedNode.fieldKey] = parentItem$1[nestedNode.fieldKey].sort((a, b) => {
 				const sortField = nestedNode.query.sort[0];
 				let column = sortField;
@@ -97,29 +70,24 @@ function mergeWithParentItems(schema, nestedItem, parentItem, nestedNode, fieldA
 				if (a[column] === b[column]) return 0;
 				if (a[column] === null) return 1;
 				if (b[column] === null) return -1;
-				if (order === "asc") {
-					return a[column] < b[column] ? -1 : 1;
-				} else {
-					return a[column] < b[column] ? 1 : -1;
-				}
+				if (order === "asc") return a[column] < b[column] ? -1 : 1;
+				else return a[column] < b[column] ? 1 : -1;
 			});
 		}
-	} else if (nestedNode.type === "a2o") {
-		for (const parentItem$1 of parentItems) {
-			if (!nestedNode.relation.meta?.one_collection_field) {
-				parentItem$1[nestedNode.fieldKey] = null;
-				continue;
-			}
-			const relatedCollection = parentItem$1[nestedNode.relation.meta.one_collection_field];
-			if (!nestedItem[relatedCollection]) {
-				parentItem$1[nestedNode.fieldKey] = null;
-				continue;
-			}
-			const itemChild = nestedItem[relatedCollection].find((nestedItem$1) => {
-				return nestedItem$1[nestedNode.relatedKey[relatedCollection]] == parentItem$1[nestedNode.fieldKey];
-			});
-			parentItem$1[nestedNode.fieldKey] = itemChild || null;
+	} else if (nestedNode.type === "a2o") for (const parentItem$1 of parentItems) {
+		if (!nestedNode.relation.meta?.one_collection_field) {
+			parentItem$1[nestedNode.fieldKey] = null;
+			continue;
+		}
+		const relatedCollection = parentItem$1[nestedNode.relation.meta.one_collection_field];
+		if (!nestedItem[relatedCollection]) {
+			parentItem$1[nestedNode.fieldKey] = null;
+			continue;
 		}
+		const itemChild = nestedItem[relatedCollection].find((nestedItem$1) => {
+			return nestedItem$1[nestedNode.relatedKey[relatedCollection]] == parentItem$1[nestedNode.fieldKey];
+		});
+		parentItem$1[nestedNode.fieldKey] = itemChild || null;
 	}
 	return Array.isArray(parentItem) ? parentItems : parentItems[0];
 }

package/dist/database/run-ast/utils/remove-temporary-fields.js

@@ -12,22 +12,17 @@ function removeTemporaryFields(schema, rawItem, ast, primaryKeyField, parentItem
 		for (const relatedCollection of ast.names) {
 			if (!fields[relatedCollection]) fields[relatedCollection] = [];
 			if (!nestedCollectionNodes[relatedCollection]) nestedCollectionNodes[relatedCollection] = [];
-			for (const child of ast.children[relatedCollection]) {
-				if (child.type === "field" || child.type === "functionField") {
-					fields[relatedCollection].push(child.name);
-				} else {
-					fields[relatedCollection].push(child.fieldKey);
-					nestedCollectionNodes[relatedCollection].push(child);
-				}
+			for (const child of ast.children[relatedCollection]) if (child.type === "field" || child.type === "functionField") fields[relatedCollection].push(child.name);
+			else {
+				fields[relatedCollection].push(child.fieldKey);
+				nestedCollectionNodes[relatedCollection].push(child);
 			}
 		}
 		for (const rawItem$1 of rawItems) {
 			const relatedCollection = parentItem?.[ast.relation.meta.one_collection_field];
-			if (rawItem$1 === null || rawItem$1 === undefined) return rawItem$1;
+			if (rawItem$1 === null || rawItem$1 === void 0) return rawItem$1;
 			let item = rawItem$1;
-			for (const nestedNode of nestedCollectionNodes[relatedCollection]) {
-				item[nestedNode.fieldKey] = removeTemporaryFields(schema, item[nestedNode.fieldKey], nestedNode, schema.collections[nestedNode.relation.collection].primary, item);
-			}
+			for (const nestedNode of nestedCollectionNodes[relatedCollection]) item[nestedNode.fieldKey] = removeTemporaryFields(schema, item[nestedNode.fieldKey], nestedNode, schema.collections[nestedNode.relation.collection].primary, item);
 			const fieldsWithFunctionsApplied = fields[relatedCollection].map((field) => applyFunctionToColumnName(field));
 			item = fields[relatedCollection].length > 0 ? pick(rawItem$1, fieldsWithFunctionsApplied) : rawItem$1[primaryKeyField];
 			items.push(item);
@@ -37,28 +32,19 @@ function removeTemporaryFields(schema, rawItem, ast, primaryKeyField, parentItem
 		const aliasFields = [];
 		const nestedCollectionNodes = [];
 		for (const child of ast.children) {
-			if ("alias" in child && child.alias === true) {
-				aliasFields.push(child.fieldKey);
-			} else {
-				fields.push(child.fieldKey);
-			}
-			if (child.type !== "field" && child.type !== "functionField") {
-				nestedCollectionNodes.push(child);
-			}
+			if ("alias" in child && child.alias === true) aliasFields.push(child.fieldKey);
+			else fields.push(child.fieldKey);
+			if (child.type !== "field" && child.type !== "functionField") nestedCollectionNodes.push(child);
 		}
-		if (ast.query?.aggregate) {
-			for (const [operation, aggregateFields] of Object.entries(ast.query.aggregate)) {
-				if (!fields) continue;
-				if (operation === "count" && aggregateFields.includes("*")) fields.push("count");
-				fields.push(...aggregateFields.map((field) => `${operation}.${field}`));
-			}
+		if (ast.query?.aggregate) for (const [operation, aggregateFields] of Object.entries(ast.query.aggregate)) {
+			if (!fields) continue;
+			if (operation === "count" && aggregateFields.includes("*")) fields.push("count");
+			fields.push(...aggregateFields.map((field) => `${operation}.${field}`));
 		}
 		for (const rawItem$1 of rawItems) {
-			if (rawItem$1 === null || rawItem$1 === undefined) return rawItem$1;
+			if (rawItem$1 === null || rawItem$1 === void 0) return rawItem$1;
 			let item = rawItem$1;
-			for (const nestedNode of nestedCollectionNodes) {
-				item[nestedNode.fieldKey] = removeTemporaryFields(schema, item[nestedNode.fieldKey], nestedNode, nestedNode.type === "m2o" ? schema.collections[nestedNode.relation.related_collection].primary : schema.collections[nestedNode.relation.collection].primary, item);
-			}
+			for (const nestedNode of nestedCollectionNodes) item[nestedNode.fieldKey] = removeTemporaryFields(schema, item[nestedNode.fieldKey], nestedNode, nestedNode.type === "m2o" ? schema.collections[nestedNode.relation.related_collection].primary : schema.collections[nestedNode.relation.collection].primary, item);
 			const fieldsWithFunctionsApplied = fields.map((field) => applyFunctionToColumnName(field));
 			item = fields.length > 0 ? pick(rawItem$1, fieldsWithFunctionsApplied, aliasFields) : rawItem$1[primaryKeyField];
 			items.push(item);

package/dist/database/run-ast/utils/with-preprocess-bindings.js

@@ -4,12 +4,8 @@ import { getHelpers } from "../../helpers/index.js";
 function withPreprocessBindings(knex, dbQuery) {
 	const schemaHelper = getHelpers(knex).schema;
 	dbQuery.client = new Proxy(dbQuery.client, { get(target, prop, receiver) {
-		if (prop === "query") {
-			return (connection, queryParams) => Reflect.get(target, prop, receiver).bind(dbQuery.client)(connection, schemaHelper.prepQueryParams(queryParams));
-		}
-		if (prop === "prepBindings") {
-			return (bindings) => schemaHelper.prepBindings(Reflect.get(target, prop, receiver).bind(dbQuery.client)(bindings));
-		}
+		if (prop === "query") return (connection, queryParams) => Reflect.get(target, prop, receiver).bind(dbQuery.client)(connection, schemaHelper.prepQueryParams(queryParams));
+		if (prop === "prepBindings") return (bindings) => schemaHelper.prepBindings(Reflect.get(target, prop, receiver).bind(dbQuery.client)(bindings));
 		return Reflect.get(target, prop, receiver);
 	} });
 }