@directus/api 35.0.2 → 35.1.0

package/dist/database/migrations/20240806A-permissions-policies.js

@@ -18,18 +18,14 @@ async function fetchRoleAccess(roles, context) {
 		enforce_tfa: false
 	};
 	const accessRows = await context.knex("directus_access").select("directus_policies.id", "directus_policies.admin_access", "directus_policies.app_access", "directus_policies.ip_access", "directus_policies.enforce_tfa").where("role", "in", roles).leftJoin("directus_policies", "directus_policies.id", "directus_access.policy");
-	const ipAccess = new Set();
+	const ipAccess = /* @__PURE__ */ new Set();
 	for (const { admin_access, app_access, ip_access, enforce_tfa } of accessRows) {
 		roleAccess.admin_access ||= toBoolean(admin_access);
 		roleAccess.app_access ||= toBoolean(app_access);
 		roleAccess.enforce_tfa ||= toBoolean(enforce_tfa);
-		if (ip_access && ip_access.length) {
-			ip_access.split(",").forEach((ip) => ipAccess.add(ip));
-		}
-	}
-	if (ipAccess.size > 0) {
-		roleAccess.ip_access = Array.from(ipAccess).join(",");
+		if (ip_access && ip_access.length) ip_access.split(",").forEach((ip) => ipAccess.add(ip));
 	}
+	if (ipAccess.size > 0) roleAccess.ip_access = Array.from(ipAccess).join(",");
 	return roleAccess;
 }
 /**
@@ -39,9 +35,7 @@ async function fetchRoleAccess(roles, context) {
 const PUBLIC_POLICY_ID = "abf8a154-5b1c-4a46-ac9c-7300570f4f17";
 async function up(knex) {
 	const logger = useLogger();
-	if (await knex.schema.hasTable("directus_policies")) {
-		return;
-	}
+	if (await knex.schema.hasTable("directus_policies")) return;
 	await knex.schema.createTable("directus_policies", (table) => {
 		table.uuid("id").primary();
 		table.string("name", 100).notNullable();
@@ -53,11 +47,9 @@ async function up(knex) {
 		table.boolean("app_access").defaultTo(false).notNullable();
 	});
 	const roles = await knex.select("id", "name", "icon", "description", "ip_access", "enforce_tfa", "admin_access", "app_access").from("directus_roles");
-	if (roles.length > 0) {
-		await processChunk(roles, 100, async (chunk$1) => {
-			await knex("directus_policies").insert(chunk$1);
-		});
-	}
+	if (roles.length > 0) await processChunk(roles, 100, async (chunk$1) => {
+		await knex("directus_policies").insert(chunk$1);
+	});
 	await knex.insert({
 		id: PUBLIC_POLICY_ID,
 		name: "$t:public_label",
@@ -77,9 +69,7 @@ async function up(knex) {
 		table.uuid("policy");
 	});
 	try {
-		const inspector = await getSchemaInspector(knex);
-		const foreignKeys = await inspector.foreignKeys("directus_permissions");
-		const foreignConstraint = foreignKeys.find((foreign) => foreign.foreign_key_table === "directus_roles" && foreign.column === "role")?.constraint_name || undefined;
+		const foreignConstraint = (await (await getSchemaInspector(knex)).foreignKeys("directus_permissions")).find((foreign) => foreign.foreign_key_table === "directus_roles" && foreign.column === "role")?.constraint_name || void 0;
 		await knex.schema.alterTable("directus_permissions", (table) => {
 			table.dropForeign("role", foreignConstraint);
 		});
@@ -100,14 +90,13 @@ async function up(knex) {
 		table.uuid("policy").references("directus_policies.id").notNullable().onDelete("CASCADE");
 		table.integer("sort");
 	});
-	const policyAttachments = roles.map((role) => ({
+	await processChunk(roles.map((role) => ({
 		id: randomUUID(),
 		role: role.id,
 		user: null,
 		policy: role.id,
 		sort: 1
-	}));
-	await processChunk(policyAttachments, 100, async (chunk$1) => {
+	})), 100, async (chunk$1) => {
 		await knex("directus_access").insert(chunk$1);
 	});
 	await knex("directus_access").insert({
@@ -150,7 +139,7 @@ async function down(knex) {
 				user: null,
 				ip: null
 			}, context);
-			const rawPermissions = await fetchPermissions({
+			mergePermissions("or", await fetchPermissions({
 				accountability: {
 					role: null,
 					roles: roleTree,
@@ -159,23 +148,12 @@ async function down(knex) {
 				},
 				policies,
 				bypassDynamicVariableProcessing: true
-			}, context);
-			mergePermissions("or", rawPermissions).forEach((permission) => {
-				if (permission.system) {
-					return;
-				}
-				if (Array.isArray(permission.fields)) {
-					permission.fields = permission.fields.join(",");
-				}
-				if (permission.permissions) {
-					permission.permissions = JSON.stringify(permission.permissions);
-				}
-				if (permission.validation) {
-					permission.validation = JSON.stringify(permission.validation);
-				}
-				if (permission.presets) {
-					permission.presets = JSON.stringify(permission.presets);
-				}
+			}, context)).forEach((permission) => {
+				if (permission.system) return;
+				if (Array.isArray(permission.fields)) permission.fields = permission.fields.join(",");
+				if (permission.permissions) permission.permissions = JSON.stringify(permission.permissions);
+				if (permission.validation) permission.validation = JSON.stringify(permission.validation);
+				if (permission.presets) permission.presets = JSON.stringify(permission.presets);
 				rolePermissions.push({
 					role: role.id,
 					...omit(permission, ["id", "policy"])

package/dist/database/migrations/20240909A-separate-comments.js

@@ -27,23 +27,20 @@ async function down(knex) {
 		await knex.transaction(async (trx) => {
 			for (const comment of comments) {
 				const migratedRecords = await trx("directus_activity").select("id").where("collection", "=", "directus_comments").andWhere("item", "=", comment.id).andWhere("action", "=", Action.CREATE).limit(1);
-				if (migratedRecords[0]) {
-					await trx("directus_activity").update({
-						action: Action.COMMENT,
-						collection: comment.collection,
-						item: comment.item,
-						comment: comment.comment
-					}).where("id", "=", migratedRecords[0].id);
-				} else {
-					await trx("directus_activity").insert({
-						action: Action.COMMENT,
-						collection: comment.collection,
-						item: comment.item,
-						comment: comment.comment,
-						user: comment.user_created,
-						timestamp: comment.date_created
-					});
-				}
+				if (migratedRecords[0]) await trx("directus_activity").update({
+					action: Action.COMMENT,
+					collection: comment.collection,
+					item: comment.item,
+					comment: comment.comment
+				}).where("id", "=", migratedRecords[0].id);
+				else await trx("directus_activity").insert({
+					action: Action.COMMENT,
+					collection: comment.collection,
+					item: comment.item,
+					comment: comment.comment,
+					user: comment.user_created,
+					timestamp: comment.date_created
+				});
 				await trx("directus_comments").where("id", "=", comment.id).delete();
 			}
 		});

package/dist/database/migrations/20240924A-migrate-legacy-comments.js

@@ -10,8 +10,8 @@ async function up(knex) {
 	} catch {}
 	const rowsLimit = 50;
 	let hasMore = true;
-	const existingUsers = new Set();
-	const missingUsers = new Set();
+	const existingUsers = /* @__PURE__ */ new Set();
+	const missingUsers = /* @__PURE__ */ new Set();
 	while (hasMore) {
 		const legacyComments = await knex.select("*").from("directus_activity").where("action", "=", Action.COMMENT).limit(rowsLimit);
 		if (legacyComments.length === 0) {
@@ -25,16 +25,11 @@ async function up(knex) {
 					primaryKey = randomUUID();
 					let legacyCommentUserId = legacyComment.user;
 					if (legacyCommentUserId) {
-						if (missingUsers.has(legacyCommentUserId)) {
+						if (missingUsers.has(legacyCommentUserId)) legacyCommentUserId = null;
+						else if (!existingUsers.has(legacyCommentUserId)) if (await trx.select("id").from("directus_users").where("id", "=", legacyCommentUserId).first()) existingUsers.add(legacyCommentUserId);
+						else {
+							missingUsers.add(legacyCommentUserId);
 							legacyCommentUserId = null;
-						} else if (!existingUsers.has(legacyCommentUserId)) {
-							const userExists = await trx.select("id").from("directus_users").where("id", "=", legacyCommentUserId).first();
-							if (userExists) {
-								existingUsers.add(legacyCommentUserId);
-							} else {
-								missingUsers.add(legacyCommentUserId);
-								legacyCommentUserId = null;
-							}
 						}
 					}
 					await trx("directus_comments").insert({

package/dist/database/migrations/20240924B-populate-versioning-deltas.js

@@ -13,9 +13,7 @@ async function up(knex) {
 		}
 		await knex.transaction(async (trx) => {
 			for (const missingDeltaVersion of missingDeltaVersions) {
-				const revisions = await trx.select("delta").from("directus_revisions").where("version", "=", missingDeltaVersion.id).orderBy("id");
-				const deltas = revisions.map((revision) => typeof revision.delta === "string" ? parseJSON(revision.delta) : revision.delta ?? {});
-				const consolidatedDelta = assign({}, ...deltas);
+				const consolidatedDelta = assign({}, ...(await trx.select("delta").from("directus_revisions").where("version", "=", missingDeltaVersion.id).orderBy("id")).map((revision) => typeof revision.delta === "string" ? parseJSON(revision.delta) : revision.delta ?? {}));
 				await trx("directus_versions").update({ delta: JSON.stringify(consolidatedDelta) }).where("id", "=", missingDeltaVersion.id);
 			}
 		});

package/dist/database/migrations/20250224A-visual-editor.js

@@ -24,8 +24,7 @@ async function down(knex) {
 async function updateModuleBar(knex, modify) {
 	const result = await knex("directus_settings").select("module_bar", "id").first();
 	if (result && result.module_bar) {
-		const moduleBar = typeof result.module_bar === "string" ? JSON.parse(result.module_bar) : result.module_bar;
-		const updatedModuleBar = modify(moduleBar);
+		const updatedModuleBar = modify(typeof result.module_bar === "string" ? JSON.parse(result.module_bar) : result.module_bar);
 		if (!updatedModuleBar) return;
 		await knex("directus_settings").update({ module_bar: JSON.stringify(updatedModuleBar) }).where("id", result.id);
 	}

package/dist/database/migrations/20250609A-license-banner.js

@@ -3,8 +3,7 @@ import { toBoolean } from "@directus/utils";
 
 //#region src/database/migrations/20250609A-license-banner.ts
 async function up(knex) {
-	const env = useEnv();
-	const acceptedTerms = toBoolean(env["ACCEPT_TERMS"]);
+	const acceptedTerms = toBoolean(useEnv()["ACCEPT_TERMS"]);
 	await knex.schema.alterTable("directus_settings", (table) => {
 		table.boolean("accepted_terms").defaultTo(acceptedTerms);
 	});

package/dist/database/migrations/20250613A-add-project-id.js

@@ -8,11 +8,8 @@ async function up(knex) {
 	const existing = await knex("directus_settings").select("id").first();
 	const timestamp = await knex("directus_migrations").select("timestamp").first();
 	const msecs = timestamp ? new Date(timestamp.timestamp).getTime() : Date.now();
-	if (existing) {
-		await knex("directus_settings").update({ project_id: v7({ msecs }) });
-	} else {
-		await knex("directus_settings").insert({ project_id: v7() });
-	}
+	if (existing) await knex("directus_settings").update({ project_id: v7({ msecs }) });
+	else await knex("directus_settings").insert({ project_id: v7() });
 }
 async function down(knex) {
 	await knex.schema.alterTable("directus_settings", (table) => {

package/dist/database/migrations/20251014A-add-project-owner.js

@@ -16,18 +16,15 @@ async function up(knex) {
 	});
 	const env = useEnv();
 	const settingsService = new SettingsService({ schema: await getSchema() });
-	if (email().safeParse(env["PROJECT_OWNER"]).success) {
-		await settingsService.setOwner({
-			project_owner: env["PROJECT_OWNER"],
-			org_name: null,
-			project_usage: null,
-			product_updates: false
-		});
-	}
+	if (email().safeParse(env["PROJECT_OWNER"]).success) await settingsService.setOwner({
+		project_owner: env["PROJECT_OWNER"],
+		org_name: null,
+		project_usage: null,
+		product_updates: false
+	});
 }
 async function down(knex) {
-	const env = useEnv();
-	const acceptedTerms = toBoolean(env["ACCEPT_TERMS"]);
+	const acceptedTerms = toBoolean(useEnv()["ACCEPT_TERMS"]);
 	await knex.schema.alterTable("directus_settings", (table) => {
 		table.dropColumn("project_owner");
 		table.dropColumn("project_usage");

package/dist/database/migrations/20251028A-add-retention-indexes.js

@@ -17,37 +17,29 @@ const RETENTION_INDEXES = [{
 async function up(knex) {
 	const client = getDatabaseClient(knex);
 	const helpers = getHelpers(knex);
-	const schema = await getSchema();
 	const service = new FieldsService({
 		knex,
-		schema
+		schema: await getSchema()
 	});
 	for (const { collection, field, ignore } of RETENTION_INDEXES) {
 		if (ignore.includes(client)) continue;
-		const existingColumn = await service.columnInfo(collection, field);
-		if (!existingColumn.is_indexed) {
-			await helpers.schema.createIndex(collection, field, { attemptConcurrentIndex: true });
-		}
+		if (!(await service.columnInfo(collection, field)).is_indexed) await helpers.schema.createIndex(collection, field, { attemptConcurrentIndex: true });
 	}
 }
 async function down(knex) {
 	const client = getDatabaseClient(knex);
 	const helpers = getHelpers(knex);
-	const schema = await getSchema();
 	const service = new FieldsService({
 		knex,
-		schema
+		schema: await getSchema()
 	});
 	for (const { collection, field, ignore } of RETENTION_INDEXES) {
 		if (ignore.includes(client)) continue;
-		const existingColumn = await service.columnInfo(collection, field);
-		if (existingColumn.is_indexed) {
-			await transaction(knex, async (trx) => {
-				await trx.schema.alterTable(collection, async (table) => {
-					table.dropIndex([field], helpers.schema.generateIndexName("index", collection, field));
-				});
+		if ((await service.columnInfo(collection, field)).is_indexed) await transaction(knex, async (trx) => {
+			await trx.schema.alterTable(collection, async (table) => {
+				table.dropIndex([field], helpers.schema.generateIndexName("index", collection, field));
 			});
-		}
+		});
 	}
 }
 

package/dist/database/migrations/20260113A-add-revisions-index.js

@@ -13,37 +13,29 @@ const RETENTION_INDEXES = [{
 async function up(knex) {
 	const client = getDatabaseClient(knex);
 	const helpers = getHelpers(knex);
-	const schema = await getSchema();
 	const service = new FieldsService({
 		knex,
-		schema
+		schema: await getSchema()
 	});
 	for (const { collection, field, ignore } of RETENTION_INDEXES) {
 		if (ignore.includes(client)) continue;
-		const existingColumn = await service.columnInfo(collection, field);
-		if (!existingColumn.is_indexed) {
-			await helpers.schema.createIndex(collection, field, { attemptConcurrentIndex: true });
-		}
+		if (!(await service.columnInfo(collection, field)).is_indexed) await helpers.schema.createIndex(collection, field, { attemptConcurrentIndex: true });
 	}
 }
 async function down(knex) {
 	const client = getDatabaseClient(knex);
 	const helpers = getHelpers(knex);
-	const schema = await getSchema();
 	const service = new FieldsService({
 		knex,
-		schema
+		schema: await getSchema()
 	});
 	for (const { collection, field, ignore } of RETENTION_INDEXES) {
 		if (ignore.includes(client)) continue;
-		const existingColumn = await service.columnInfo(collection, field);
-		if (existingColumn.is_indexed) {
-			await transaction(knex, async (trx) => {
-				await trx.schema.alterTable(collection, async (table) => {
-					table.dropIndex([field], helpers.schema.generateIndexName("index", collection, field));
-				});
+		if ((await service.columnInfo(collection, field)).is_indexed) await transaction(knex, async (trx) => {
+			await trx.schema.alterTable(collection, async (table) => {
+				table.dropIndex([field], helpers.schema.generateIndexName("index", collection, field));
 			});
-		}
+		});
 	}
 }
 

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