@directus/api 35.1.0 → 36.0.0-rc.0

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

@@ -1,5 +1,7 @@
+import { getOperation } from "../get-operation.js";
+import { parseJsonPath } from "../../../../helpers/fn/json/parse-function.js";
 import { getColumn } from "../../../utils/get-column.js";
-import { getHelpers } from "../../../../helpers/index.js";
+import { getFunctions, getHelpers } from "../../../../helpers/index.js";
 import { InvalidQueryError } from "@directus/errors";
 import { getOutputTypeForFunction } from "@directus/utils";
 
@@ -14,9 +16,51 @@ function castToNumber(value) {
 	if (Number.isNaN(num)) throw new InvalidQueryError({ reason: `Invalid numeric value` });
 	return num;
 }
+/**
+* Splits "table.column" into ["table", "column"], respecting dots inside parentheses.
+* Handles keys like "table.json(col,path.with.dots)" correctly.
+*/
+function splitTableColumn(key) {
+	let depth = 0;
+	for (let i = 0; i < key.length; i++) if (key[i] === "(") depth++;
+	else if (key[i] === ")") depth--;
+	else if (key[i] === "." && depth === 0) return [key.substring(0, i), key.substring(i + 1)];
+	return ["", key];
+}
 function applyOperator(knex, dbQuery, schema, key, operator, compareValue, logical = "and", originalCollectionName) {
 	const helpers = getHelpers(knex);
-	const [table, column] = key.split(".");
+	const [table, column] = splitTableColumn(key);
+	if (operator === "_json") {
+		if (!Object.entries(compareValue).length) return;
+		const applyJsonConditions = (group, filterObj, innerLogical) => {
+			for (const [jsonPath, innerFilter] of Object.entries(filterObj)) {
+				if (jsonPath === "_or" || jsonPath === "_and") {
+					const subLogical = jsonPath === "_or" ? "or" : "and";
+					group[innerLogical].where((subGroup) => {
+						for (const subFilter of innerFilter) applyJsonConditions(subGroup, subFilter, subLogical);
+					});
+					continue;
+				}
+				const normalizedPath = parseJsonPath(jsonPath);
+				const innerValue = innerFilter[Object.keys(innerFilter)[0]];
+				const castNumeric = typeof innerValue === "number" || Array.isArray(innerValue) && innerValue.length > 0 && typeof innerValue[0] === "number";
+				const jsonExtractionRaw = getFunctions(knex, schema).json(table, column, {
+					type: "json",
+					jsonPath: normalizedPath,
+					originalCollectionName,
+					relationalCountOptions: void 0,
+					jsonReturnType: castNumeric ? "numeric" : "text"
+				});
+				const innerOp = getOperation(Object.keys(innerFilter)[0], Object.values(innerFilter)[0]);
+				if (!innerOp) continue;
+				applyOperatorToRaw(group, helpers, jsonExtractionRaw, innerOp.operator, innerOp.value, innerLogical);
+			}
+		};
+		dbQuery[logical].where((group) => {
+			applyJsonConditions(group, compareValue, "and");
+		});
+		return;
+	}
 	const selectionRaw = getColumn(knex, table, column, false, schema, { originalCollectionName });
 	if (operator === "_null" && compareValue !== false || operator === "_nnull" && compareValue === false || operator === "_eq" && compareValue === null) {
 		dbQuery[logical].whereNull(selectionRaw);
@@ -26,12 +70,18 @@ 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 (operator === "_empty" && compareValue !== false || operator === "_nempty" && compareValue === false) {
+		dbQuery[logical].andWhere((query) => {
+			query.whereNull(selectionRaw).orWhere(selectionRaw, "=", "");
+		});
+		return;
+	}
+	if (operator === "_nempty" && compareValue !== false || operator === "_empty" && compareValue === false) {
+		dbQuery[logical].andWhere((query) => {
+			query.whereNotNull(selectionRaw).andWhere(selectionRaw, "!=", "");
+		});
+		return;
+	}
 	if (compareValue === void 0) return;
 	if (Array.isArray(compareValue)) compareValue = compareValue.filter((val) => val !== void 0);
 	if (column.includes("(") && column.includes(")")) {
@@ -43,7 +93,7 @@ function applyOperator(knex, dbQuery, schema, key, operator, compareValue, logic
 			"decimal"
 		].includes(type)) compareValue = castToNumber(compareValue);
 	}
-	const [collection, field] = key.split(".");
+	const [collection, field] = splitTableColumn(key);
 	const mappedCollection = originalCollectionName || collection;
 	if (mappedCollection in schema.collections && field in schema.collections[mappedCollection].fields) {
 		const type = schema.collections[mappedCollection].fields[field].type;
@@ -60,47 +110,80 @@ function applyOperator(knex, dbQuery, schema, key, operator, compareValue, logic
 			"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);
+	applyOperatorToRaw(dbQuery, helpers, selectionRaw, operator, compareValue, logical, key);
+}
+function applyOperatorToRaw(dbQuery, helpers, raw, operator, compareValue, logical, key) {
+	if (operator === "_null" && compareValue !== false || operator === "_nnull" && compareValue === false || operator === "_eq" && compareValue === null) {
+		dbQuery[logical].whereNull(raw);
+		return;
+	}
+	if (operator === "_nnull" && compareValue !== false || operator === "_null" && compareValue === false || operator === "_neq" && compareValue === null) {
+		dbQuery[logical].whereNotNull(raw);
+		return;
+	}
+	if (operator === "_empty" && compareValue !== false || operator === "_nempty" && compareValue === false) {
+		dbQuery[logical].andWhere((query) => {
+			query.whereNull(raw).orWhere(raw, "=", "");
+		});
+		return;
+	}
+	if (operator === "_nempty" && compareValue !== false || operator === "_empty" && compareValue === false) {
+		dbQuery[logical].andWhere((query) => {
+			query.whereNotNull(raw).andWhere(raw, "!=", "");
+		});
+		return;
+	}
+	if (compareValue === void 0) return;
+	if (Array.isArray(compareValue)) compareValue = compareValue.filter((val) => val !== void 0);
+	if (operator === "_eq") dbQuery[logical].where(raw, "=", compareValue);
+	if (operator === "_neq") dbQuery[logical].whereNot(raw, compareValue);
+	if (operator === "_ieq") dbQuery[logical].whereRaw(`LOWER(??) = ?`, [raw, `${compareValue.toLowerCase()}`]);
+	if (operator === "_nieq") dbQuery[logical].whereRaw(`LOWER(??) <> ?`, [raw, `${compareValue.toLowerCase()}`]);
+	if (operator === "_contains") dbQuery[logical].where(raw, "like", `%${compareValue}%`);
+	if (operator === "_ncontains") dbQuery[logical].whereNot(raw, "like", `%${compareValue}%`);
+	if (operator === "_icontains") dbQuery[logical].whereRaw(`LOWER(??) LIKE ?`, [raw, `%${compareValue.toLowerCase()}%`]);
+	if (operator === "_nicontains") dbQuery[logical].whereRaw(`LOWER(??) NOT LIKE ?`, [raw, `%${compareValue.toLowerCase()}%`]);
+	if (operator === "_starts_with") dbQuery[logical].where(raw, "like", `${compareValue}%`);
+	if (operator === "_nstarts_with") dbQuery[logical].whereNot(raw, "like", `${compareValue}%`);
+	if (operator === "_istarts_with") dbQuery[logical].whereRaw(`LOWER(??) LIKE ?`, [raw, `${compareValue.toLowerCase()}%`]);
+	if (operator === "_nistarts_with") dbQuery[logical].whereRaw(`LOWER(??) NOT LIKE ?`, [raw, `${compareValue.toLowerCase()}%`]);
+	if (operator === "_ends_with") dbQuery[logical].where(raw, "like", `%${compareValue}`);
+	if (operator === "_nends_with") dbQuery[logical].whereNot(raw, "like", `%${compareValue}`);
+	if (operator === "_iends_with") dbQuery[logical].whereRaw(`LOWER(??) LIKE ?`, [raw, `%${compareValue.toLowerCase()}`]);
+	if (operator === "_niends_with") dbQuery[logical].whereRaw(`LOWER(??) NOT LIKE ?`, [raw, `%${compareValue.toLowerCase()}`]);
+	if (operator === "_gt") dbQuery[logical].where(raw, ">", compareValue);
+	if (operator === "_gte") dbQuery[logical].where(raw, ">=", compareValue);
+	if (operator === "_lt") dbQuery[logical].where(raw, "<", compareValue);
+	if (operator === "_lte") dbQuery[logical].where(raw, "<=", compareValue);
 	if (operator === "_in") {
 		let value = compareValue;
 		if (typeof value === "string") value = value.split(",");
-		dbQuery[logical].whereIn(selectionRaw, value);
+		if (value.length === 0) dbQuery[logical].whereIn(raw, []);
+		else {
+			const placeholders = value.map(() => "?").join(", ");
+			dbQuery[logical].whereRaw(`?? in (${placeholders})`, [raw, ...value]);
+		}
 	}
 	if (operator === "_nin") {
 		let value = compareValue;
 		if (typeof value === "string") value = value.split(",");
-		dbQuery[logical].whereNotIn(selectionRaw, value);
+		if (value.length === 0) dbQuery[logical].whereNotIn(raw, []);
+		else {
+			const placeholders = value.map(() => "?").join(", ");
+			dbQuery[logical].whereRaw(`?? not in (${placeholders})`, [raw, ...value]);
+		}
 	}
 	if (operator === "_between") {
 		let value = compareValue;
 		if (typeof value === "string") value = value.split(",");
 		if (value.length !== 2) return;
-		dbQuery[logical].whereBetween(selectionRaw, value);
+		dbQuery[logical].whereBetween(raw, value);
 	}
 	if (operator === "_nbetween") {
 		let value = compareValue;
 		if (typeof value === "string") value = value.split(",");
 		if (value.length !== 2) return;
-		dbQuery[logical].whereNotBetween(selectionRaw, value);
+		dbQuery[logical].whereNotBetween(raw, value);
 	}
 	if (operator == "_intersects") dbQuery[logical].whereRaw(helpers.st.intersects(key, compareValue));
 	if (operator == "_nintersects") dbQuery[logical].whereRaw(helpers.st.nintersects(key, compareValue));

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

@@ -20,7 +20,10 @@ function applyQuery(knex, collection, dbQuery, query, schema, cases, permissions
 	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);
+		const sortResult = applySort(knex, schema, dbQuery, query.sort, collection, aliasMap, {
+			aggregate: query.aggregate,
+			fieldAliasMap: { ...query.alias ?? {} }
+		});
 		if (!hasJoins) hasJoins = sortResult.hasJoins;
 	}
 	const filter = joinFilterWithCases(query.filter, cases);

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

@@ -1,15 +1,18 @@
 import { getColumnPath } from "../../../../utils/get-column-path.js";
 import { addJoin } from "./add-join.js";
 import { getColumn } from "../../utils/get-column.js";
+import { extractFunctionName } from "../../../../utils/extract-function-name.js";
+import { splitFieldPath } from "../../../../utils/split-field-path.js";
 import { getRelationInfo } from "@directus/utils";
 
 //#region src/database/run-ast/lib/apply-query/sort.ts
-function applySort(knex, schema, rootQuery, sort, aggregate, collection, aliasMap, returnRecords = false) {
+function applySort(knex, schema, rootQuery, sort, collection, aliasMap, options) {
+	const { aggregate, returnRecords = false, fieldAliasMap } = options ?? {};
 	const relations = schema.relations;
 	let hasJoins = false;
 	let hasMultiRelationalSort = false;
 	const sortRecords = sort.map((sortField) => {
-		const column = sortField.split(".");
+		const column = splitFieldPath(sortField);
 		let order = "asc";
 		if (sortField.startsWith("-")) order = "desc";
 		if (column[0].startsWith("-")) column[0] = column[0].substring(1);
@@ -30,11 +33,17 @@ function applySort(knex, schema, rootQuery, sort, aggregate, collection, aliasMa
 			};
 		}
 		if (column.length === 1) {
-			const pathRoot = column[0].split(":")[0];
+			const rawField = column[0];
+			const resolvedField = fieldAliasMap?.[rawField] ?? rawField;
+			if (extractFunctionName(resolvedField) === "json") return {
+				order,
+				column: returnRecords ? resolvedField : getColumn(knex, collection, resolvedField, false, schema, { jsonReturnType: "text" })
+			};
+			const pathRoot = resolvedField.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)
+				column: returnRecords ? resolvedField : getColumn(knex, collection, resolvedField, false, schema)
 			};
 		}
 		const { hasMultiRelational, isJoinAdded } = addJoin({
@@ -45,19 +54,20 @@ function applySort(knex, schema, rootQuery, sort, aggregate, collection, aliasMa
 			schema,
 			knex
 		});
-		const { columnPath } = getColumnPath({
+		const { columnPath, targetCollection } = getColumnPath({
 			path: column,
 			collection,
 			aliasMap,
 			relations,
 			schema
 		});
-		const [alias, field] = columnPath.split(".");
+		const [alias, ...rest] = splitFieldPath(columnPath);
+		const field = rest.join(".");
 		if (!hasJoins) hasJoins = isJoinAdded;
 		if (!hasMultiRelationalSort) hasMultiRelationalSort = hasMultiRelational;
 		return {
 			order,
-			column: returnRecords ? columnPath : getColumn(knex, alias, field, false, schema)
+			column: returnRecords ? columnPath : getColumn(knex, alias, field, false, schema, { originalCollectionName: targetCollection })
 		};
 	});
 	if (returnRecords) return {

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

@@ -1,7 +1,10 @@
 import { generateQueryAlias } from "../utils/generate-alias.js";
 import { applyCaseWhen } from "../utils/apply-case-when.js";
+import { applyFunctionToColumnName } from "../utils/apply-function-to-column-name.js";
 import { getColumn } from "../utils/get-column.js";
 import { applyLimit } from "./apply-query/pagination.js";
+import { extractFunctionName } from "../../../utils/extract-function-name.js";
+import { splitFieldPath } from "../../../utils/split-field-path.js";
 import { applySort } from "./apply-query/sort.js";
 import applyQuery from "./apply-query/index.js";
 import { getHelpers } from "../../helpers/index.js";
@@ -43,7 +46,13 @@ function getDBQuery({ table, fieldNodes, o2mNodes, query, cases, permissions, pe
 	const innerQuerySortRecords = [];
 	let hasMultiRelationalSort;
 	if (queryCopy.sort) {
-		const sortResult = applySort(knex, schema, dbQuery, queryCopy.sort, queryCopy.aggregate, table, aliasMap, true);
+		const fieldAliasMap = { ...queryCopy.alias ?? {} };
+		for (const node of fieldNodes) if (node.type === "functionField" && extractFunctionName(node.name) === "json") fieldAliasMap[applyFunctionToColumnName(node.fieldKey)] = node.name;
+		const sortResult = applySort(knex, schema, dbQuery, queryCopy.sort, table, aliasMap, {
+			aggregate: queryCopy.aggregate,
+			returnRecords: true,
+			fieldAliasMap
+		});
 		if (sortResult) {
 			sortRecords = sortResult.sortRecords;
 			hasMultiRelationalSort = sortResult.hasMultiRelationalSort;
@@ -85,16 +94,18 @@ function getDBQuery({ table, fieldNodes, o2mNodes, query, cases, permissions, pe
 				if (orderByString.length !== 0) orderByString += ", ";
 				const sortAlias = generateQueryAlias(table, queryCopy, `sort_${index}_${sortRecord.column}_${sortRecord.order}`);
 				let orderByColumn;
-				if (sortRecord.column.includes(".")) {
-					const [alias, field] = sortRecord.column.split(".");
+				const colParts = splitFieldPath(sortRecord.column);
+				if (colParts.length > 1) {
+					const [alias, ...rest] = colParts;
+					const field = rest.join(".");
 					const originalCollectionName = getCollectionFromAlias(alias, aliasMap);
 					dbQuery.select(getColumn(knex, alias, field, sortAlias, schema, { originalCollectionName }));
 					orderByString += `?? ${sortRecord.order}`;
 					orderByColumn = getColumn(knex, alias, field, false, schema, { originalCollectionName });
 				} else {
-					dbQuery.select(getColumn(knex, table, sortRecord.column, sortAlias, schema));
+					dbQuery.select(getColumn(knex, table, sortRecord.column, sortAlias, schema, { jsonReturnType: "text" }));
 					orderByString += `?? ${sortRecord.order}`;
-					orderByColumn = getColumn(knex, table, sortRecord.column, false, schema);
+					orderByColumn = getColumn(knex, table, sortRecord.column, false, schema, { jsonReturnType: "text" });
 				}
 				orderByFields.push(orderByColumn);
 				innerQuerySortRecords.push({
@@ -111,10 +122,11 @@ function getDBQuery({ table, fieldNodes, o2mNodes, query, cases, permissions, pe
 			dbQuery.orderByRaw(orderByString, orderByFields);
 		} else {
 			sortRecords.map((sortRecord) => {
-				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);
+				const colParts = splitFieldPath(sortRecord.column);
+				if (colParts.length > 1) {
+					const [alias, ...rest] = colParts;
+					sortRecord.column = getColumn(knex, alias, rest.join("."), false, schema, { originalCollectionName: getCollectionFromAlias(alias, aliasMap) });
+				} else sortRecord.column = getColumn(knex, table, sortRecord.column, false, schema, { jsonReturnType: "text" });
 			});
 			dbQuery.orderBy(sortRecords);
 		}

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

@@ -1,4 +1,5 @@
 import { parseJsonFunction } from "../../helpers/fn/json/parse-function.js";
+import { extractFunctionName } from "../../../utils/extract-function-name.js";
 import { parseFilterKey } from "../../../utils/parse-filter-key.js";
 
 //#region src/database/run-ast/lib/parse-current-level.ts
@@ -10,7 +11,7 @@ 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;
+			if (child.type === "functionField" && extractFunctionName(child.name) === "json") fieldName = parseJsonFunction(child.name).field;
 			else fieldName = parseFilterKey(child.name).fieldName;
 			if (columnsInCollection.includes(fieldName)) columnsToSelectInternal.push(child.fieldKey);
 			continue;

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

@@ -1,4 +1,5 @@
 import { applyFunctionToColumnName } from "./utils/apply-function-to-column-name.js";
+import { extractFunctionName } from "../../utils/extract-function-name.js";
 import database_default from "../index.js";
 import { fetchPolicies } from "../../permissions/lib/fetch-policies.js";
 import { fetchPermissions } from "../../permissions/lib/fetch-permissions.js";
@@ -57,7 +58,7 @@ 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(")) {
+		for (const child of children) if (child.type === "functionField" && extractFunctionName(child.name) === "json") {
 			const alias = applyFunctionToColumnName(child.fieldKey);
 			aliasMap[alias] = child.name;
 		}

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

@@ -42,7 +42,8 @@ function getColumn(knex, table, column, alias = applyFunctionToColumnName(column
 					permissions: options.permissions
 				} : void 0,
 				originalCollectionName: options?.originalCollectionName,
-				jsonPath
+				jsonPath,
+				...options?.jsonReturnType && { jsonReturnType: options.jsonReturnType }
 			});
 			if (alias) return knex.raw(result + " AS ??", [alias]);
 			return result;

package/dist/extensions/lib/installation/manager.js

@@ -10,7 +10,7 @@ import { Readable } from "node:stream";
 import { download } from "@directus/extensions-registry";
 import { EXTENSION_PKG_KEY, ExtensionManifest } from "@directus/extensions";
 import DriverLocal from "@directus/storage-driver-local";
-import Queue from "p-queue";
+import PQueue from "p-queue";
 import { extract } from "tar";
 
 //#region src/extensions/lib/installation/manager.ts
@@ -50,7 +50,7 @@ var InstallationManager = class {
 			if (!(await ExtensionManifest.parseAsync(packageFile))[EXTENSION_PKG_KEY]?.type) throw new Error(`Extension type not found in package.json`);
 			if (env["EXTENSIONS_LOCATION"]) {
 				const remoteDisk = (await getStorage()).location(env["EXTENSIONS_LOCATION"]);
-				const queue = new Queue({ concurrency: 1e3 });
+				const queue = new PQueue({ concurrency: 1e3 });
 				for await (const filepath of tmpStorage.list(extractedPath)) {
 					const readStream = await tmpStorage.read(filepath);
 					const remotePath = join(env["EXTENSIONS_PATH"], ".registry", versionId, filepath.substring(7));
@@ -74,7 +74,7 @@ var InstallationManager = class {
 	async uninstall(folder) {
 		if (env["EXTENSIONS_LOCATION"]) {
 			const remoteDisk = (await getStorage()).location(env["EXTENSIONS_LOCATION"]);
-			const queue = new Queue({ concurrency: 1e3 });
+			const queue = new PQueue({ concurrency: 1e3 });
 			const prefix = join(env["EXTENSIONS_PATH"], ".registry", folder);
 			for await (const filepath of remoteDisk.list(prefix)) queue.add(() => remoteDisk.delete(filepath));
 			await queue.onIdle();

package/dist/extensions/lib/sandbox/register/operation.js

@@ -1,5 +1,5 @@
-import { callReference } from "./call-reference.js";
 import { getFlowManager } from "../../../../flows.js";
+import { callReference } from "./call-reference.js";
 
 //#region src/extensions/lib/sandbox/register/operation.ts
 function registerOperationGenerator() {

package/dist/extensions/lib/sync/sync.js

@@ -14,7 +14,7 @@ import { normalizePath } from "@directus/utils";
 import { dirname, join, relative, resolve, sep } from "node:path";
 import { pipeline } from "node:stream/promises";
 import { createWriteStream } from "node:fs";
-import Queue from "p-queue";
+import PQueue from "p-queue";
 import mid from "node-machine-id";
 
 //#region src/extensions/lib/sync/sync.ts
@@ -50,7 +50,7 @@ async function syncExtensions(options) {
 				return;
 			}
 		}
-		const queue = new Queue({ concurrency: 1e3 });
+		const queue = new PQueue({ concurrency: 1e3 });
 		const fileTracker = new SyncFileTracker();
 		const hasLocalFiles = await fileTracker.readLocalFiles(localExtensionsPath) > 0;
 		for await (const filepath of disk.list(remoteExtensionsPath)) {

package/dist/extensions/manager.js

@@ -4,12 +4,12 @@ import { useLogger } from "../logger/index.js";
 import { getExtensionsPath } from "./lib/get-extensions-path.js";
 import database_default from "../database/index.js";
 import emitter_default, { Emitter } from "../emitter.js";
+import { scheduleSynchronizedJob, validateCron } from "../utils/schedule.js";
 import { getSchema } from "../utils/get-schema.js";
+import { getFlowManager } from "../flows.js";
 import { deleteFromRequireCache } from "../utils/delete-from-require-cache.js";
 import getModuleDefault from "../utils/get-module-default.js";
 import { importFileUrl } from "../utils/import-file-url.js";
-import { JobQueue } from "../utils/job-queue.js";
-import { scheduleSynchronizedJob, validateCron } from "../utils/schedule.js";
 import { getExtensionsSettings } from "./lib/get-extensions-settings.js";
 import { getExtensions } from "./lib/get-extensions.js";
 import { getSharedDepsMapping } from "./lib/get-shared-deps-mapping.js";
@@ -19,7 +19,6 @@ import { instantiateSandboxSdk } from "./lib/sandbox/sdk/instantiate.js";
 import { syncExtensions } from "./lib/sync/sync.js";
 import { wrapEmbeds } from "./lib/wrap-embeds.js";
 import { services_exports } from "../services/index.js";
-import { getFlowManager } from "../flows.js";
 import { readFile, readdir } from "node:fs/promises";
 import path from "path";
 import { useEnv } from "@directus/env";
@@ -39,6 +38,7 @@ import nodeResolveDefault from "@rollup/plugin-node-resolve";
 import virtualDefault from "@rollup/plugin-virtual";
 import chokidar from "chokidar";
 import ivm from "isolated-vm";
+import PQueue from "p-queue";
 import { rolldown } from "rolldown";
 import { rollup } from "rollup";
 
@@ -97,7 +97,7 @@ var ExtensionManager = class {
 	* Used to prevent race conditions when reloading extensions. Forces each reload to happen in
 	* sequence.
 	*/
-	reloadQueue = new JobQueue();
+	reloadQueue = new PQueue({ concurrency: 1 });
 	/**
 	* Used to prevent race condition when reading extension data while reloading extensions
 	*/
@@ -248,7 +248,7 @@ var ExtensionManager = class {
 			resolve$1 = res;
 			reject = rej;
 		});
-		this.reloadQueue.enqueue(async () => {
+		this.reloadQueue.add(async () => {
 			if (this.isLoaded) {
 				const prevExtensions = clone(this.extensions);
 				await this.unload();

package/dist/flows.js

@@ -5,22 +5,22 @@ import database_default from "./database/index.js";
 import { fetchPolicies } from "./permissions/lib/fetch-policies.js";
 import { fetchPermissions } from "./permissions/lib/fetch-permissions.js";
 import emitter_default from "./emitter.js";
-import { getSchema } from "./utils/get-schema.js";
+import { scheduleSynchronizedJob, validateCron } from "./utils/schedule.js";
 import { ActivityService } from "./services/activity.js";
 import { getService } from "./utils/get-service.js";
-import { JobQueue } from "./utils/job-queue.js";
-import { scheduleSynchronizedJob, validateCron } from "./utils/schedule.js";
+import { getSchema } from "./utils/get-schema.js";
+import { FlowsService } from "./services/flows.js";
 import { RevisionsService } from "./services/revisions.js";
-import { services_exports } from "./services/index.js";
 import { constructFlowTree } from "./utils/construct-flow-tree.js";
 import { redactObject } from "./utils/redact-object.js";
-import { FlowsService } from "./services/flows.js";
+import { services_exports } from "./services/index.js";
 import { useEnv } from "@directus/env";
 import { ForbiddenError } from "@directus/errors";
 import { applyOptionsData, deepMap, getRedactedString, isValidJSON, parseJSON, toArray } from "@directus/utils";
 import { pick } from "lodash-es";
 import { Action } from "@directus/constants";
 import { isSystemCollection } from "@directus/system-data";
+import PQueue from "p-queue";
 import { get as get$1 } from "micromustache";
 
 //#region src/flows.ts
@@ -41,15 +41,15 @@ var FlowManager = class {
 	triggerHandlers = [];
 	operationFlowHandlers = {};
 	webhookFlowHandlers = {};
-	reloadQueue;
+	reloadQueue = new PQueue({ concurrency: 1 });
 	envs;
 	constructor() {
 		const env = useEnv();
-		const logger = useLogger();
-		this.reloadQueue = new JobQueue();
 		this.envs = env["FLOWS_ENV_ALLOW_LIST"] ? pick(env, toArray(env["FLOWS_ENV_ALLOW_LIST"])) : {};
-		useBus().subscribe("flows", (event) => {
-			if (event["type"] === "reload") this.reloadQueue.enqueue(async () => {
+		const messenger = useBus();
+		const logger = useLogger();
+		messenger.subscribe("flows", (event) => {
+			if (event.type === "reload") this.reloadQueue.add(async () => {
 				if (this.isLoaded) {
 					await this.unload();
 					await this.load();
@@ -70,6 +70,7 @@ var FlowManager = class {
 		this.operations.delete(id);
 	}
 	async runOperationFlow(id, data, context) {
+		if (this.reloadQueue.pending > 0) await this.reloadQueue.onIdle();
 		const logger = useLogger();
 		if (!(id in this.operationFlowHandlers)) {
 			logger.warn(`Couldn't find operation triggered flow with id "${id}"`);
@@ -79,6 +80,7 @@ var FlowManager = class {
 		return handler(data, context);
 	}
 	async runWebhookFlow(id, data, context) {
+		if (this.reloadQueue.pending > 0) await this.reloadQueue.onIdle();
 		const logger = useLogger();
 		if (!(id in this.webhookFlowHandlers)) {
 			logger.warn(`Couldn't find webhook or manual triggered flow with id "${id}"`);

package/dist/license/entitlements/lib/collections.js

@@ -0,0 +1,37 @@
+import database_default from "../../../database/index.js";
+import { getSchema } from "../../../utils/get-schema.js";
+import "../../../services/index.js";
+import { CollectionsService } from "../../../services/collections.js";
+import { useEnv } from "@directus/env";
+import { isSystemCollection } from "@directus/system-data";
+
+//#region src/license/entitlements/lib/collections.ts
+async function getActiveCollections(opts) {
+	const env = useEnv();
+	const knex = opts?.knex ?? database_default();
+	return (await new CollectionsService({
+		schema: await getSchema({ database: knex }),
+		knex
+	}).readByQuery()).filter((collection) => {
+		const isFolder = collection.schema === null;
+		const isDBOnly = collection.meta === null;
+		const isDisabled = collection.meta?.status !== "active";
+		const isEnvExcluded = env["DB_EXCLUDE_TABLES"].includes(collection.collection);
+		return !isFolder && !isSystemCollection(collection.collection) && !isDBOnly && !isDisabled && !isEnvExcluded;
+	}).map((collection) => collection.collection);
+}
+async function countActiveCollections(opts) {
+	return (await getActiveCollections(opts)).length;
+}
+async function resolveCollections(collections, ctx) {
+	const collectionsService = new CollectionsService({
+		schema: await getSchema(),
+		accountability: ctx?.accountability
+	});
+	await Promise.allSettled(collections.map((collection) => {
+		return collectionsService.updateOne(collection, { meta: { status: "inactive" } });
+	}));
+}
+
+//#endregion
+export { countActiveCollections, getActiveCollections, resolveCollections };

package/dist/license/entitlements/lib/custom-llms-enabled.js

@@ -0,0 +1,18 @@
+import { CUSTOM_LLM_FIELDS } from "../../../constants.js";
+import database_default from "../../../database/index.js";
+import { getSchema } from "../../../utils/get-schema.js";
+import { SettingsService } from "../../../services/settings.js";
+import "../../../services/index.js";
+
+//#region src/license/entitlements/lib/custom-llms-enabled.ts
+async function checkCustomLLM(opts) {
+	const knex = opts?.knex ?? database_default();
+	const data = await new SettingsService({
+		schema: await getSchema({ database: knex }),
+		knex
+	}).readSingleton({ fields: [...CUSTOM_LLM_FIELDS] });
+	return !CUSTOM_LLM_FIELDS.find((key) => data[key] !== null);
+}
+
+//#endregion
+export { checkCustomLLM };