@directus/api 35.0.2 → 35.1.0

package/dist/utils/get-column-path.js

@@ -16,23 +16,16 @@ function getColumnPath({ path, collection, aliasMap, relations, schema }) {
 		*/
 		const pathRoot = pathParts[0].split(":")[0];
 		const { relation, relationType } = getRelationInfo(relations, parentCollection, pathRoot);
-		if (!relation) {
-			throw new InvalidQueryError({ reason: `"${parentCollection}.${pathRoot}" is not a relational field` });
-		}
+		if (!relation) throw new InvalidQueryError({ reason: `"${parentCollection}.${pathRoot}" is not a relational field` });
 		const alias = parentFields ? aliasMap[`${parentFields}.${pathParts[0]}`]?.alias : aliasMap[pathParts[0]]?.alias;
 		const remainingParts = pathParts.slice(1);
 		let parent;
 		if (relationType === "a2o") {
 			const pathScope = pathParts[0].split(":")[1];
-			if (!pathScope) {
-				throw new InvalidQueryError({ reason: `You have to provide a collection scope when sorting on a many-to-any item` });
-			}
+			if (!pathScope) throw new InvalidQueryError({ reason: `You have to provide a collection scope when sorting on a many-to-any item` });
 			parent = pathScope;
-		} else if (relationType === "m2o") {
-			parent = relation.related_collection;
-		} else {
-			parent = relation.collection;
-		}
+		} else if (relationType === "m2o") parent = relation.related_collection;
+		else parent = relation.collection;
 		if (schema && !((remainingParts[0] ?? parent).includes("(") && (remainingParts[0] ?? parent).includes(")"))) {
 			if (remainingParts.length === 0) {
 				remainingParts.push(schema.collections[parent].primary);
@@ -42,16 +35,12 @@ function getColumnPath({ path, collection, aliasMap, relations, schema }) {
 				addNestedPkField = schema.collections[relation.related_collection].primary;
 			}
 		}
-		if (remainingParts.length === 1) {
-			return {
-				columnPath: `${alias || parent}.${remainingParts[0]}`,
-				targetCollection: parent,
-				addNestedPkField
-			};
-		}
-		if (remainingParts.length) {
-			return followRelation(remainingParts, parent, `${parentFields ? parentFields + "." : ""}${pathParts[0]}`, addNestedPkField);
-		}
+		if (remainingParts.length === 1) return {
+			columnPath: `${alias || parent}.${remainingParts[0]}`,
+			targetCollection: parent,
+			addNestedPkField
+		};
+		if (remainingParts.length) return followRelation(remainingParts, parent, `${parentFields ? parentFields + "." : ""}${pathParts[0]}`, addNestedPkField);
 		return {
 			columnPath: "",
 			targetCollection: "",

package/dist/utils/get-config-from-env.js

@@ -15,27 +15,18 @@ function getConfigFromEnv(prefix, options) {
 		const lowerCaseKey = key.toLowerCase();
 		if (lowerCaseKey.startsWith(lowerCasePrefix) === false) continue;
 		if (omitKeys.length > 0) {
-			const isKeyInOmitKeys = omitKeys.some((keyToOmit) => lowerCaseKey === keyToOmit);
-			if (isKeyInOmitKeys) continue;
+			if (omitKeys.some((keyToOmit) => lowerCaseKey === keyToOmit)) continue;
 		}
 		if (omitPrefixes.length > 0) {
-			const keyStartsWithAnyPrefix = omitPrefixes.some((prefix$1) => lowerCaseKey.startsWith(prefix$1));
-			if (keyStartsWithAnyPrefix) continue;
-		}
-		if (key.includes("__")) {
-			const path = key.split("__").map((key$1, index) => index === 0 ? transform$1(transform$1(key$1.slice(prefix.length))) : transform$1(key$1));
-			set(config, path.join("."), value);
-		} else {
-			config[transform$1(key.slice(prefix.length))] = value;
+			if (omitPrefixes.some((prefix$1) => lowerCaseKey.startsWith(prefix$1))) continue;
 		}
+		if (key.includes("__")) set(config, key.split("__").map((key$1, index) => index === 0 ? transform$1(transform$1(key$1.slice(prefix.length))) : transform$1(key$1)).join("."), value);
+		else config[transform$1(key.slice(prefix.length))] = value;
 	}
 	return config;
 	function transform$1(key) {
-		if (type === "camelcase") {
-			return camelcase(key, { locale: false });
-		} else if (type === "underscore") {
-			return key.toLowerCase();
-		}
+		if (type === "camelcase") return camelcase(key, { locale: false });
+		else if (type === "underscore") return key.toLowerCase();
 		return key;
 	}
 }

package/dist/utils/get-default-index-name.js

@@ -13,12 +13,10 @@ import { getSimpleHash } from "@directus/utils";
 function getDefaultIndexName(type, collection, fields, options) {
 	const maxLength = options?.maxLength ?? 60;
 	if (!Array.isArray(fields)) fields = fields ? [fields] : [];
-	const table = collection.replace(/\.|-/g, "_");
-	const indexName = (table + "_" + fields.join("_") + "_" + type).toLowerCase();
+	const indexName = (collection.replace(/\.|-/g, "_") + "_" + fields.join("_") + "_" + type).toLowerCase();
 	if (indexName.length <= maxLength) return indexName;
 	const suffix = `__${getSimpleHash(indexName)}_${type}`;
-	const prefix = indexName.substring(0, maxLength - suffix.length);
-	return `${prefix}${suffix}`;
+	return `${indexName.substring(0, maxLength - suffix.length)}${suffix}`;
 }
 
 //#endregion

package/dist/utils/get-default-value.js

@@ -31,15 +31,11 @@ function castToObject(value) {
 	const logger = useLogger();
 	if (!value) return value;
 	if (typeof value === "object") return value;
-	if (typeof value === "string") {
-		try {
-			return parseJSON(value);
-		} catch (err) {
-			if (getNodeEnv() === "development") {
-				logger.error(err);
-			}
-			return value;
-		}
+	if (typeof value === "string") try {
+		return parseJSON(value);
+	} catch (err) {
+		if (getNodeEnv() === "development") logger.error(err);
+		return value;
 	}
 	return {};
 }

package/dist/utils/get-field-relational-depth.js

@@ -13,13 +13,10 @@
 */
 function getFieldRelationalDepth(field) {
 	const openParenIndex = field.indexOf("(");
-	if (openParenIndex === -1) {
-		return field.split(".").length;
-	}
+	if (openParenIndex === -1) return field.split(".").length;
 	const functionDepth = field.slice(0, openParenIndex).split(".").length - 1;
 	const commaIndex = field.indexOf(",", openParenIndex);
-	const fieldDepth = field.slice(openParenIndex, commaIndex).split(".").length;
-	return functionDepth + fieldDepth;
+	return functionDepth + field.slice(openParenIndex, commaIndex).split(".").length;
 }
 
 //#endregion

package/dist/utils/get-graphql-query-and-variables.js

@@ -2,8 +2,7 @@ import { pick } from "lodash-es";
 
 //#region src/utils/get-graphql-query-and-variables.ts
 function getGraphqlQueryAndVariables(req) {
-	const isGet = req.method?.toLowerCase() === "get";
-	return pick(isGet ? req.query : req.body, ["query", "variables"]);
+	return pick(req.method?.toLowerCase() === "get" ? req.query : req.body, ["query", "variables"]);
 }
 
 //#endregion

package/dist/utils/get-graphql-type.js

@@ -7,9 +7,7 @@ import { GraphQLJSON } from "graphql-compose";
 
 //#region src/utils/get-graphql-type.ts
 function getGraphQLType(localType, special) {
-	if (special.includes("conceal")) {
-		return GraphQLHash;
-	}
+	if (special.includes("conceal")) return GraphQLHash;
 	switch (localType) {
 		case "boolean": return GraphQLBoolean;
 		case "bigInteger": return GraphQLBigInt;

package/dist/utils/get-ip-from-req.js

@@ -10,13 +10,9 @@ import proxyAddr from "proxy-addr";
 * Adapted to have feature parity with the express equivalent https://github.com/expressjs/express/blob/9f4dbe3a1332cd883069ba9b73a9eed99234cfc7/lib/utils.js#L192
 */
 function getTrustValue(trust) {
-	if (typeof trust === "boolean") {
-		return (_addr, _i) => trust;
-	} else if (typeof trust === "number") {
-		return (_addr, i) => i < trust;
-	} else if (typeof trust === "string") {
-		trust = trust.split(",").map((v) => v.trim());
-	}
+	if (typeof trust === "boolean") return (_addr, _i) => trust;
+	else if (typeof trust === "number") return (_addr, i) => i < trust;
+	else if (typeof trust === "string") trust = trust.split(",").map((v) => v.trim());
 	return proxyAddr.compile(trust || []);
 }
 function getIPFromReq(req) {
@@ -26,14 +22,9 @@ function getIPFromReq(req) {
 	if (env["IP_CUSTOM_HEADER"]) {
 		const customIPHeaderName = env["IP_CUSTOM_HEADER"].toLowerCase();
 		let customIPHeaderValue = req.headers[customIPHeaderName];
-		if (customIPHeaderName === "referer" || customIPHeaderName === "referrer") {
-			customIPHeaderValue = req.headers["referrer"] || req.headers["referer"];
-		}
-		if (typeof customIPHeaderValue === "string" && isIP(customIPHeaderValue) !== 0) {
-			ip = customIPHeaderValue;
-		} else {
-			logger.warn(`Custom IP header didn't return valid IP address: ${JSON.stringify(customIPHeaderValue)}`);
-		}
+		if (customIPHeaderName === "referer" || customIPHeaderName === "referrer") customIPHeaderValue = req.headers["referrer"] || req.headers["referer"];
+		if (typeof customIPHeaderValue === "string" && isIP(customIPHeaderValue) !== 0) ip = customIPHeaderValue;
+		else logger.warn(`Custom IP header didn't return valid IP address: ${JSON.stringify(customIPHeaderValue)}`);
 	}
 	return ip?.startsWith("::ffff:") ? ip.substring(7) : ip ?? null;
 }

package/dist/utils/get-local-type.js

@@ -99,22 +99,14 @@ function getLocalType(column, field) {
 		if (special.includes("uuid") || special.includes("file")) return "uuid";
 		if (special.includes("cast-timestamp")) return "timestamp";
 		if (special.includes("cast-datetime")) return "dateTime";
-		if (type?.startsWith("geometry")) {
-			return special[0] || "geometry";
-		}
+		if (type?.startsWith("geometry")) return special[0] || "geometry";
 	}
 	/** Handle Postgres numeric decimals */
-	if (dataType === "numeric" && column.numeric_precision !== null && column.numeric_scale !== null) {
-		return "decimal";
-	}
-	/** Handle MS SQL varchar(MAX) (eg TEXT) types */
-	if (column.data_type === "nvarchar" && column.max_length === -1) {
-		return "text";
-	}
+	if (dataType === "numeric" && column.numeric_precision !== null && column.numeric_scale !== null) return "decimal";
+	/** Handle MS SQL varchar(MAX) and nvarchar(MAX) types */
+	if ((column.data_type === "nvarchar" || column.data_type === "varchar") && (column.max_length === -1 || column.max_length === null)) return "text";
 	/** Handle CockroachDB 64-bit integers (reported as 'integer' with precision 64) */
-	if ((dataType === "integer" || dataType === "int") && column.numeric_precision === 64) {
-		return "bigInteger";
-	}
+	if ((dataType === "integer" || dataType === "int") && column.numeric_precision === 64) return "bigInteger";
 	return type ?? "unknown";
 }
 

package/dist/utils/get-milliseconds.js

@@ -5,9 +5,7 @@ import ms from "ms";
 * Safely parse human readable time format into milliseconds
 */
 function getMilliseconds(value, fallback) {
-	if (typeof value !== "string" && typeof value !== "number" || value === "") {
-		return fallback;
-	}
+	if (typeof value !== "string" && typeof value !== "number" || value === "") return fallback;
 	return ms(String(value)) ?? fallback;
 }
 

package/dist/utils/get-module-default.js

@@ -1,8 +1,6 @@
 //#region src/utils/get-module-default.ts
 function getModuleDefault(mod) {
-	if ("default" in mod) {
-		return mod.default;
-	}
+	if ("default" in mod) return mod.default;
 	return mod;
 }
 

package/dist/utils/get-schema.js

@@ -23,35 +23,25 @@ async function getSchema(options, attempt = 0) {
 	const env = useEnv();
 	if (options?.bypassCache || env["CACHE_SCHEMA"] === false) {
 		const database = options?.database || database_default();
-		const schemaInspector = createInspector(database);
-		return await getDatabaseSchema(database, schemaInspector);
+		return await getDatabaseSchema(database, createInspector(database));
 	}
 	const cached = getMemorySchemaCache();
-	if (cached) {
-		return cached;
-	}
-	if (attempt >= MAX_ATTEMPTS) {
-		throw new Error(`Failed to get Schema information: hit infinite loop`);
-	}
+	if (cached) return cached;
+	if (attempt >= MAX_ATTEMPTS) throw new Error(`Failed to get Schema information: hit infinite loop`);
 	const lock = useLock();
 	const bus = useBus();
 	const lockKey = "schemaCache--preparing";
 	const messageKey = "schemaCache--done";
 	const processId = await lock.increment(lockKey);
-	if (processId >= env["CACHE_SCHEMA_MAX_ITERATIONS"]) {
-		await lock.delete(lockKey);
-	}
-	const currentProcessShouldHandleOperation = processId === 1;
-	if (currentProcessShouldHandleOperation === false) {
+	if (processId >= env["CACHE_SCHEMA_MAX_ITERATIONS"]) await lock.delete(lockKey);
+	if (processId === 1 === false) {
 		logger.trace("Schema cache is prepared in another process, waiting for result.");
 		const timeout = new Promise((_, reject) => setTimeout(reject, env["CACHE_SCHEMA_SYNC_TIMEOUT"]));
 		const subscription = new Promise((resolve, reject) => {
 			bus.subscribe(messageKey, busListener).catch(reject);
 			function busListener(options$1) {
 				cleanup();
-				if (options$1.schema === null) {
-					return reject();
-				}
+				if (options$1.schema === null) return reject();
 				try {
 					setMemorySchemaCache(options$1.schema);
 					resolve(options$1.schema);
@@ -68,8 +58,7 @@ async function getSchema(options, attempt = 0) {
 	let schema = null;
 	try {
 		const database = options?.database || database_default();
-		const schemaInspector = createInspector(database);
-		schema = await getDatabaseSchema(database, schemaInspector);
+		schema = await getDatabaseSchema(database, createInspector(database));
 		setMemorySchemaCache(schema);
 		return schema;
 	} finally {
@@ -152,11 +141,10 @@ async function getDatabaseSchema(database, schemaInspector) {
 			searchable: toBoolean(field.searchable) ?? true
 		};
 	}
-	const relationsService = new RelationsService({
+	result.relations = await new RelationsService({
 		knex: database,
 		schema: result
-	});
-	result.relations = await relationsService.readAll(undefined, undefined, true);
+	}).readAll(void 0, void 0, true);
 	return result;
 }
 

package/dist/utils/get-secret.js

@@ -4,13 +4,9 @@ import { nanoid } from "nanoid";
 //#region src/utils/get-secret.ts
 const _cache = { secret: null };
 const getSecret = () => {
-	if (_cache.secret) {
-		return _cache.secret;
-	}
+	if (_cache.secret) return _cache.secret;
 	const env = useEnv();
-	if (env["SECRET"]) {
-		return env["SECRET"];
-	}
+	if (env["SECRET"]) return env["SECRET"];
 	_cache.secret = nanoid(32);
 	return _cache.secret;
 };

package/dist/utils/get-snapshot-diff.js

@@ -7,29 +7,26 @@ function getSnapshotDiff(current, after) {
 	const diffedSnapshot = {
 		collections: [...current.collections.map((currentCollection) => {
 			const afterCollection = after.collections.find((afterCollection$1) => afterCollection$1.collection === currentCollection.collection);
-			const afterCollectionSanitized = afterCollection ? sanitizeCollection(afterCollection) : undefined;
+			const afterCollectionSanitized = afterCollection ? sanitizeCollection(afterCollection) : void 0;
 			return {
 				collection: currentCollection.collection,
 				diff: deepDiff.diff(sanitizeCollection(currentCollection), afterCollectionSanitized)
 			};
 		}), ...after.collections.filter((afterCollection) => {
-			const currentCollection = current.collections.find((currentCollection$1) => currentCollection$1.collection === afterCollection.collection);
-			return !!currentCollection === false;
+			return !!current.collections.find((currentCollection) => currentCollection.collection === afterCollection.collection) === false;
 		}).map((afterCollection) => ({
 			collection: afterCollection.collection,
-			diff: deepDiff.diff(undefined, sanitizeCollection(afterCollection))
+			diff: deepDiff.diff(void 0, sanitizeCollection(afterCollection))
 		}))].filter((obj) => Array.isArray(obj.diff)),
 		fields: [...current.fields.map((currentField) => {
 			const afterField = after.fields.find((afterField$1) => afterField$1.collection === currentField.collection && afterField$1.field === currentField.field);
 			const isAutoIncrementPrimaryKey = !!currentField.schema?.is_primary_key && !!currentField.schema?.has_auto_increment;
-			if (afterField && currentField.type !== afterField.type && (currentField.type === "alias" || afterField.type === "alias")) {
-				return {
-					collection: currentField.collection,
-					field: currentField.field,
-					diff: deepDiff.diff(sanitizeField(currentField, isAutoIncrementPrimaryKey), undefined)
-				};
-			}
-			const afterFieldSanitized = afterField ? sanitizeField(afterField, isAutoIncrementPrimaryKey) : undefined;
+			if (afterField && currentField.type !== afterField.type && (currentField.type === "alias" || afterField.type === "alias")) return {
+				collection: currentField.collection,
+				field: currentField.field,
+				diff: deepDiff.diff(sanitizeField(currentField, isAutoIncrementPrimaryKey), void 0)
+			};
+			const afterFieldSanitized = afterField ? sanitizeField(afterField, isAutoIncrementPrimaryKey) : void 0;
 			return {
 				collection: currentField.collection,
 				field: currentField.field,
@@ -37,14 +34,12 @@ function getSnapshotDiff(current, after) {
 			};
 		}), ...after.fields.filter((afterField) => {
 			let currentField = current.fields.find((currentField$1) => currentField$1.collection === afterField.collection && afterField.field === currentField$1.field);
-			if (currentField && currentField.type !== afterField.type && (currentField.type === "alias" || afterField.type === "alias")) {
-				currentField = undefined;
-			}
+			if (currentField && currentField.type !== afterField.type && (currentField.type === "alias" || afterField.type === "alias")) currentField = void 0;
 			return !!currentField === false;
 		}).map((afterField) => ({
 			collection: afterField.collection,
 			field: afterField.field,
-			diff: deepDiff.diff(undefined, sanitizeField(afterField))
+			diff: deepDiff.diff(void 0, sanitizeField(afterField))
 		}))].filter((obj) => Array.isArray(obj.diff)),
 		systemFields: [...(current.systemFields ?? []).map((currentSystemField) => {
 			const afterSystemField = (after.systemFields ?? []).find((afterSystemField$1) => afterSystemField$1.collection === currentSystemField.collection && afterSystemField$1.field === currentSystemField.field);
@@ -69,7 +64,7 @@ function getSnapshotDiff(current, after) {
 		})].filter((obj) => Array.isArray(obj.diff)),
 		relations: [...current.relations.map((currentRelation) => {
 			const afterRelation = after.relations.find((afterRelation$1) => afterRelation$1.collection === currentRelation.collection && afterRelation$1.field === currentRelation.field);
-			const afterRelationSanitized = afterRelation ? sanitizeRelation(afterRelation) : undefined;
+			const afterRelationSanitized = afterRelation ? sanitizeRelation(afterRelation) : void 0;
 			return {
 				collection: currentRelation.collection,
 				field: currentRelation.field,
@@ -77,13 +72,12 @@ function getSnapshotDiff(current, after) {
 				diff: deepDiff.diff(sanitizeRelation(currentRelation), afterRelationSanitized)
 			};
 		}), ...after.relations.filter((afterRelation) => {
-			const currentRelation = current.relations.find((currentRelation$1) => currentRelation$1.collection === afterRelation.collection && afterRelation.field === currentRelation$1.field);
-			return !!currentRelation === false;
+			return !!current.relations.find((currentRelation) => currentRelation.collection === afterRelation.collection && afterRelation.field === currentRelation.field) === false;
 		}).map((afterRelation) => ({
 			collection: afterRelation.collection,
 			field: afterRelation.field,
 			related_collection: afterRelation.related_collection,
-			diff: deepDiff.diff(undefined, sanitizeRelation(afterRelation))
+			diff: deepDiff.diff(void 0, sanitizeRelation(afterRelation))
 		}))].filter((obj) => Array.isArray(obj.diff))
 	};
 	/**
@@ -96,9 +90,7 @@ function getSnapshotDiff(current, after) {
 }
 function invertIndexed(field) {
 	const newSchema = { ...field.schema };
-	if ("is_indexed" in field.schema) {
-		newSchema.is_indexed = !field.schema.is_indexed;
-	}
+	if ("is_indexed" in field.schema) newSchema.is_indexed = !field.schema.is_indexed;
 	return {
 		...field,
 		schema: newSchema

package/dist/utils/get-snapshot.js

@@ -36,18 +36,14 @@ async function getSnapshot(options) {
 	const fieldsFiltered = fieldsRaw.filter((item) => excludeSystem(item) && excludeUntracked(item));
 	const relationsFiltered = relationsRaw.filter((item) => excludeSystem(item) && excludeUntracked(item));
 	const systemFieldsFiltered = fieldsRaw.filter((item) => systemFieldWithIndex(item));
-	const collectionsSorted = sortBy(mapValues(collectionsFiltered, sortDeep), ["collection"]).map((collection) => sanitizeCollection(collection));
-	const fieldsSorted = sortBy(mapValues(fieldsFiltered, sortDeep), ["collection", "meta.id"]).map((field) => sanitizeField(omitID(field)));
-	const systemFieldsSorted = sortBy(systemFieldsFiltered, ["collection", "field"]).map((field) => sanitizeSystemField(field));
-	const relationsSorted = sortBy(mapValues(relationsFiltered, sortDeep), ["collection", "meta.id"]).map((relation) => sanitizeRelation(omitID(relation)));
 	return {
 		version: 1,
 		directus: version,
 		vendor,
-		collections: collectionsSorted,
-		fields: fieldsSorted,
-		systemFields: systemFieldsSorted,
-		relations: relationsSorted
+		collections: sortBy(mapValues(collectionsFiltered, sortDeep), ["collection"]).map((collection) => sanitizeCollection(collection)),
+		fields: sortBy(mapValues(fieldsFiltered, sortDeep), ["collection", "meta.id"]).map((field) => sanitizeField(omitID(field))),
+		systemFields: sortBy(systemFieldsFiltered, ["collection", "field"]).map((field) => sanitizeSystemField(field)),
+		relations: sortBy(mapValues(relationsFiltered, sortDeep), ["collection", "meta.id"]).map((relation) => sanitizeRelation(omitID(relation)))
 	};
 }
 function excludeSystem(item) {
@@ -65,15 +61,8 @@ function omitID(item) {
 	return omit(item, "meta.id");
 }
 function sortDeep(raw) {
-	if (isPlainObject(raw)) {
-		const mapped = mapValues(raw, sortDeep);
-		const pairs = toPairs(mapped);
-		const sorted = sortBy(pairs);
-		return fromPairs(sorted);
-	}
-	if (isArray(raw)) {
-		return raw.map((raw$1) => sortDeep(raw$1));
-	}
+	if (isPlainObject(raw)) return fromPairs(sortBy(toPairs(mapValues(raw, sortDeep))));
+	if (isArray(raw)) return raw.map((raw$1) => sortDeep(raw$1));
 	return raw;
 }
 

package/dist/utils/is-directus-jwt.js

@@ -7,8 +7,7 @@ import jwt from "jsonwebtoken";
 */
 function isDirectusJWT(string) {
 	try {
-		const payload = jwt.decode(string, { json: true });
-		if (payload?.iss !== "directus") return false;
+		if (jwt.decode(string, { json: true })?.iss !== "directus") return false;
 		return true;
 	} catch {
 		return false;

package/dist/utils/is-field-allowed.js

@@ -3,9 +3,7 @@
 * Check if a specific field is allowed within a set of allowed fields
 */
 function isFieldAllowed(allowedFields, field) {
-	if (Array.isArray(allowedFields)) {
-		return allowedFields.includes(field) || allowedFields.includes("*");
-	}
+	if (Array.isArray(allowedFields)) return allowedFields.includes(field) || allowedFields.includes("*");
 	return allowedFields.has(field) || allowedFields.has("*");
 }
 

package/dist/utils/job-queue.js

@@ -8,16 +8,11 @@ var JobQueue = class {
 	}
 	enqueue(job) {
 		this.jobs.push(job);
-		if (!this.running) {
-			this.run();
-		}
+		if (!this.running) this.run();
 	}
 	async run() {
 		this.running = true;
-		while (this.jobs.length > 0) {
-			const job = this.jobs.shift();
-			await job();
-		}
+		while (this.jobs.length > 0) await this.jobs.shift()();
 		this.running = false;
 	}
 	get size() {

package/dist/utils/jwt.js

@@ -7,24 +7,18 @@ function verifyJWT(token, secret) {
 	try {
 		payload = jwt.verify(token, secret, { issuer: "directus" });
 	} catch (err) {
-		if (err instanceof jwt.TokenExpiredError) {
-			throw new TokenExpiredError();
-		} else if (err instanceof jwt.JsonWebTokenError) {
-			throw new InvalidTokenError();
-		} else {
-			throw new ServiceUnavailableError({
-				service: "jwt",
-				reason: `Couldn't verify token.`
-			});
-		}
+		if (err instanceof jwt.TokenExpiredError) throw new TokenExpiredError();
+		else if (err instanceof jwt.JsonWebTokenError) throw new InvalidTokenError();
+		else throw new ServiceUnavailableError({
+			service: "jwt",
+			reason: `Couldn't verify token.`
+		});
 	}
 	return payload;
 }
 function verifyAccessJWT(token, secret) {
 	const payload = verifyJWT(token, secret);
-	if (payload.role === undefined || payload.app_access === undefined || payload.admin_access === undefined) {
-		throw new InvalidTokenError();
-	}
+	if (payload.role === void 0 || payload.app_access === void 0 || payload.admin_access === void 0) throw new InvalidTokenError();
 	return payload;
 }
 

package/dist/utils/md.js

@@ -6,8 +6,7 @@ import sanitizeHTML from "sanitize-html";
 * Render and sanitize a markdown string
 */
 function md(value) {
-	const markdown = marked.parse(value);
-	return sanitizeHTML(markdown);
+	return sanitizeHTML(marked.parse(value));
 }
 
 //#endregion

package/dist/utils/parse-filter-key.js

@@ -13,11 +13,9 @@ const FILTER_KEY_REGEX = /^([^()]+)(\(([^)]+)\))?/;
 function parseFilterKey(key) {
 	const match = key.match(FILTER_KEY_REGEX);
 	const fieldNameWithFunction = match?.[3]?.trim();
-	const fieldName = fieldNameWithFunction || key.trim();
-	const functionName = fieldNameWithFunction ? match?.[1]?.trim() : undefined;
 	return {
-		fieldName,
-		functionName
+		fieldName: fieldNameWithFunction || key.trim(),
+		functionName: fieldNameWithFunction ? match?.[1]?.trim() : void 0
 	};
 }
 

package/dist/utils/parse-numeric-string.js

@@ -1,19 +1,13 @@
 //#region src/utils/parse-numeric-string.ts
 function parseNumericString(stringValue) {
 	let number = Number(stringValue);
-	if (isNaN(number) || !Number.isFinite(number)) {
-		return null;
-	}
-	if (number > Number.MAX_SAFE_INTEGER || number < Number.MIN_SAFE_INTEGER) {
-		try {
-			number = BigInt(stringValue);
-		} catch {
-			return null;
-		}
-	}
-	if (String(number) !== stringValue) {
+	if (isNaN(number) || !Number.isFinite(number)) return null;
+	if (number > Number.MAX_SAFE_INTEGER || number < Number.MIN_SAFE_INTEGER) try {
+		number = BigInt(stringValue);
+	} catch {
 		return null;
 	}
+	if (String(number) !== stringValue) return null;
 	return number;
 }
 

package/dist/utils/permissions-cacheable.js

@@ -8,38 +8,25 @@ import { createDefaultAccountability } from "../permissions/utils/create-default
 * If they do, the permissions are not cacheable.
 */
 async function permissionsCacheable(collection, context, accountability) {
-	if (!collection) {
-		return true;
-	}
-	if (!accountability) {
-		accountability = createDefaultAccountability();
-	}
-	const policies = await fetchPolicies(accountability, context);
-	const permissions = await fetchPermissions({
+	if (!collection) return true;
+	if (!accountability) accountability = createDefaultAccountability();
+	return !(await fetchPermissions({
 		action: "read",
-		policies,
+		policies: await fetchPolicies(accountability, context),
 		collections: [collection],
 		accountability,
 		bypassDynamicVariableProcessing: true
-	}, context);
-	const has_now = permissions.some((permission) => {
-		if (!permission.permissions) {
-			return false;
-		}
+	}, context)).some((permission) => {
+		if (!permission.permissions) return false;
 		return filterHasNow(permission.permissions);
 	});
-	return !has_now;
 }
 function filterHasNow(filter) {
 	if (filter === null) return false;
 	return Object.entries(filter).some(([key, value]) => {
-		if (key === "_and" || key === "_or") {
-			return value.some((sub_filter) => filterHasNow(sub_filter));
-		} else if (typeof value === "object") {
-			return filterHasNow(value);
-		} else if (typeof value === "string") {
-			return value.startsWith("$NOW");
-		}
+		if (key === "_and" || key === "_or") return value.some((sub_filter) => filterHasNow(sub_filter));
+		else if (typeof value === "object") return filterHasNow(value);
+		else if (typeof value === "string") return value.startsWith("$NOW");
 		return false;
 	});
 }