@directus/api 35.0.2 → 35.2.0

package/dist/services/utils.js

@@ -18,11 +18,8 @@ var UtilsService = class {
 		this.schema = options.schema;
 	}
 	async sort(collection, { item, to }) {
-		const sortFieldResponse = await this.knex.select("sort_field").from("directus_collections").where({ collection }).first() || systemCollectionRows;
-		const sortField = sortFieldResponse?.sort_field;
-		if (!sortField) {
-			throw new InvalidPayloadError({ reason: `Collection "${collection}" doesn't have a sort field` });
-		}
+		const sortField = (await this.knex.select("sort_field").from("directus_collections").where({ collection }).first() || systemCollectionRows)?.sort_field;
+		if (!sortField) throw new InvalidPayloadError({ reason: `Collection "${collection}" doesn't have a sort field` });
 		if (this.accountability && this.accountability.admin !== true) {
 			await validateAccess({
 				accountability: this.accountability,
@@ -40,9 +37,7 @@ var UtilsService = class {
 				schema: this.schema,
 				knex: this.knex
 			});
-			if (allowedFields[0] !== "*" && allowedFields.includes(sortField) === false) {
-				throw new ForbiddenError();
-			}
+			if (allowedFields[0] !== "*" && allowedFields.includes(sortField) === false) throw new ForbiddenError();
 		}
 		const primaryKeyField = this.schema.collections[collection].primary;
 		const countResponse = await this.knex.count("* as count").from(collection).whereNull(sortField).first();
@@ -55,27 +50,17 @@ var UtilsService = class {
 				await this.knex(collection).update({ [sortField]: lastSortValue }).where({ [primaryKeyField]: row[primaryKeyField] });
 			}
 		}
-		const duplicates = await this.knex.select(sortField).count(sortField, { as: "count" }).groupBy(sortField).from(collection).havingRaw("count(??) > 1", [sortField]);
-		if (duplicates?.length > 0) {
+		if ((await this.knex.select(sortField).count(sortField, { as: "count" }).groupBy(sortField).from(collection).havingRaw("count(??) > 1", [sortField]))?.length > 0) {
 			const ids = await this.knex.select(primaryKeyField).from(collection).orderBy(sortField);
-			for (let i = 0; i < ids.length; i++) {
-				await this.knex(collection).update({ [sortField]: i + 1 }).where(ids[i]);
-			}
+			for (let i = 0; i < ids.length; i++) await this.knex(collection).update({ [sortField]: i + 1 }).where(ids[i]);
 		}
-		const targetSortValueResponse = await this.knex.select(sortField).from(collection).where({ [primaryKeyField]: to }).first();
-		const targetSortValue = targetSortValueResponse[sortField];
-		const sourceSortValueResponse = await this.knex.select(sortField).from(collection).where({ [primaryKeyField]: item }).first();
-		const sourceSortValue = sourceSortValueResponse[sortField];
+		const targetSortValue = (await this.knex.select(sortField).from(collection).where({ [primaryKeyField]: to }).first())[sortField];
+		const sourceSortValue = (await this.knex.select(sortField).from(collection).where({ [primaryKeyField]: item }).first())[sortField];
 		await this.knex(collection).update({ [sortField]: targetSortValue }).where({ [primaryKeyField]: item });
-		if (sourceSortValue < targetSortValue) {
-			await this.knex(collection).decrement(sortField, 1).where(sortField, ">", sourceSortValue).andWhere(sortField, "<=", targetSortValue).andWhereNot({ [primaryKeyField]: item });
-		} else {
-			await this.knex(collection).increment(sortField, 1).where(sortField, ">=", targetSortValue).andWhere(sortField, "<=", sourceSortValue).andWhereNot({ [primaryKeyField]: item });
-		}
+		if (sourceSortValue < targetSortValue) await this.knex(collection).decrement(sortField, 1).where(sortField, ">", sourceSortValue).andWhere(sortField, "<=", targetSortValue).andWhereNot({ [primaryKeyField]: item });
+		else await this.knex(collection).increment(sortField, 1).where(sortField, ">=", targetSortValue).andWhere(sortField, "<=", sourceSortValue).andWhereNot({ [primaryKeyField]: item });
 		const { cache } = getCache();
-		if (shouldClearCache(cache, undefined, collection)) {
-			await cache.clear();
-		}
+		if (shouldClearCache(cache, void 0, collection)) await cache.clear();
 		emitter_default.emitAction(["items.sort", `${collection}.items.sort`], {
 			collection,
 			item,
@@ -87,13 +72,9 @@ var UtilsService = class {
 		});
 	}
 	async clearCache({ system }) {
-		if (this.accountability?.admin !== true) {
-			throw new ForbiddenError();
-		}
+		if (this.accountability?.admin !== true) throw new ForbiddenError();
 		const { cache } = getCache();
-		if (system) {
-			await clearSystemCache({ forced: true });
-		}
+		if (system) await clearSystemCache({ forced: true });
 		return cache?.clear();
 	}
 };

package/dist/services/versions.js

@@ -21,66 +21,53 @@ var VersionsService = class VersionsService extends ItemsService {
 		super("directus_versions", options);
 	}
 	async validateCreateData(data) {
-		const versionCreateSchema = Joi.object({
+		const { error } = Joi.object({
 			key: Joi.string().required(),
 			name: Joi.string().allow(null),
 			collection: Joi.string().required(),
 			item: Joi.string().required()
-		});
-		const { error } = versionCreateSchema.validate(data);
+		}).validate(data);
 		if (error) throw new InvalidPayloadError({ reason: error.message });
 		if (data["key"] === "main") throw new InvalidPayloadError({ reason: `"main" is a reserved version key` });
-		if (this.accountability) {
-			try {
-				await validateAccess({
-					accountability: this.accountability,
-					action: "read",
-					collection: data["collection"],
-					primaryKeys: [data["item"]]
-				}, {
-					schema: this.schema,
-					knex: this.knex
-				});
-			} catch {
-				throw new ForbiddenError();
-			}
+		if (this.accountability) try {
+			await validateAccess({
+				accountability: this.accountability,
+				action: "read",
+				collection: data["collection"],
+				primaryKeys: [data["item"]]
+			}, {
+				schema: this.schema,
+				knex: this.knex
+			});
+		} catch {
+			throw new ForbiddenError();
 		}
 		const { CollectionsService } = await import("./collections.js");
-		const collectionsService = new CollectionsService({
+		if (!(await new CollectionsService({
 			knex: this.knex,
 			schema: this.schema
-		});
-		const existingCollection = await collectionsService.readOne(data["collection"]);
-		if (!existingCollection.meta?.versioning) {
-			throw new UnprocessableContentError({ reason: `Content Versioning is not enabled for collection "${data["collection"]}"` });
-		}
-		const sudoService = new VersionsService({
+		}).readOne(data["collection"])).meta?.versioning) throw new UnprocessableContentError({ reason: `Content Versioning is not enabled for collection "${data["collection"]}"` });
+		if ((await new VersionsService({
 			knex: this.knex,
 			schema: this.schema
-		});
-		const existingVersions = await sudoService.readByQuery({
+		}).readByQuery({
 			aggregate: { count: ["*"] },
 			filter: {
 				key: { _eq: data["key"] },
 				collection: { _eq: data["collection"] },
 				item: { _eq: data["item"] }
 			}
-		});
-		if (existingVersions[0]["count"] > 0) {
-			throw new UnprocessableContentError({ reason: `Version "${data["key"]}" already exists for item "${data["item"]}" in collection "${data["collection"]}"` });
-		}
+		}))[0]["count"] > 0) throw new UnprocessableContentError({ reason: `Version "${data["key"]}" already exists for item "${data["item"]}" in collection "${data["collection"]}"` });
 	}
 	async getMainItem(collection, item, query) {
-		const itemsService = new ItemsService(collection, {
+		return await new ItemsService(collection, {
 			knex: this.knex,
 			accountability: this.accountability,
 			schema: this.schema
-		});
-		return await itemsService.readOne(item, query);
+		}).readOne(item, query);
 	}
 	async verifyHash(collection, item, hash$1) {
-		const mainItem = await this.getMainItem(collection, item);
-		const mainHash = hash(mainItem);
+		const mainHash = hash(await this.getMainItem(collection, item));
 		return {
 			outdated: hash$1 !== mainHash,
 			mainHash
@@ -97,8 +84,7 @@ var VersionsService = class VersionsService extends ItemsService {
 	}
 	async createOne(data, opts) {
 		await this.validateCreateData(data);
-		const mainItem = await this.getMainItem(data["collection"], data["item"]);
-		data["hash"] = hash(mainItem);
+		data["hash"] = hash(await this.getMainItem(data["collection"], data["item"]));
 		return super.createOne(data, opts);
 	}
 	async readOne(key, query = {}, opts) {
@@ -107,37 +93,30 @@ var VersionsService = class VersionsService extends ItemsService {
 		return version;
 	}
 	async createMany(data, opts) {
-		if (!Array.isArray(data)) {
-			throw new InvalidPayloadError({ reason: "Input should be an array of items" });
-		}
-		const keyCombos = new Set();
+		if (!Array.isArray(data)) throw new InvalidPayloadError({ reason: "Input should be an array of items" });
+		const keyCombos = /* @__PURE__ */ new Set();
 		for (const item of data) {
 			const keyCombo = `${item["key"]}-${item["collection"]}-${item["item"]}`;
-			if (keyCombos.has(keyCombo)) {
-				throw new UnprocessableContentError({ reason: `Cannot create multiple versions on "${item["item"]}" in collection "${item["collection"]}" with the same key "${item["key"]}"` });
-			}
+			if (keyCombos.has(keyCombo)) throw new UnprocessableContentError({ reason: `Cannot create multiple versions on "${item["item"]}" in collection "${item["collection"]}" with the same key "${item["key"]}"` });
 			keyCombos.add(keyCombo);
 		}
 		return super.createMany(data, opts);
 	}
 	async updateMany(keys, data, opts) {
-		const versionUpdateSchema = Joi.object({
+		const { error } = Joi.object({
 			key: Joi.string(),
 			name: Joi.string().allow(null)
-		});
-		const { error } = versionUpdateSchema.validate(data);
+		}).validate(data);
 		if (error) throw new InvalidPayloadError({ reason: error.message });
 		if ("key" in data) {
 			if (data["key"] === "main") throw new InvalidPayloadError({ reason: `"main" is a reserved version key` });
-			const keyCombos = new Set();
+			const keyCombos = /* @__PURE__ */ new Set();
 			for (const pk of keys) {
 				const { collection, item } = await this.readOne(pk, { fields: ["collection", "item"] });
 				const keyCombo = `${data["key"]}-${collection}-${item}`;
-				if (keyCombos.has(keyCombo)) {
-					throw new UnprocessableContentError({ reason: `Cannot update multiple versions on "${item}" in collection "${collection}" to the same key "${data["key"]}"` });
-				}
+				if (keyCombos.has(keyCombo)) throw new UnprocessableContentError({ reason: `Cannot update multiple versions on "${item}" in collection "${collection}" to the same key "${data["key"]}"` });
 				keyCombos.add(keyCombo);
-				const existingVersions = await super.readByQuery({
+				if ((await super.readByQuery({
 					aggregate: { count: ["*"] },
 					filter: {
 						id: { _neq: pk },
@@ -145,10 +124,7 @@ var VersionsService = class VersionsService extends ItemsService {
 						collection: { _eq: collection },
 						item: { _eq: item }
 					}
-				});
-				if (existingVersions[0]["count"] > 0) {
-					throw new UnprocessableContentError({ reason: `Version "${data["key"]}" already exists for item "${item}" in collection "${collection}"` });
-				}
+				}))[0]["count"] > 0) throw new UnprocessableContentError({ reason: `Version "${data["key"]}" already exists for item "${item}" in collection "${collection}"` });
 			}
 		}
 		return super.updateMany(keys, data, opts);
@@ -160,36 +136,37 @@ var VersionsService = class VersionsService extends ItemsService {
 			knex: this.knex,
 			schema: this.schema
 		});
-		const activityService = new ActivityService({
-			knex: this.knex,
-			schema: this.schema
-		});
-		const revisionsService = new RevisionsService({
-			knex: this.knex,
-			schema: this.schema
-		});
 		const { item, collection, delta: existingDelta } = version;
-		const activity = await activityService.createOne({
-			action: Action.VERSION_SAVE,
-			user: this.accountability?.user ?? null,
-			collection,
-			ip: this.accountability?.ip ?? null,
-			user_agent: this.accountability?.userAgent ?? null,
-			origin: this.accountability?.origin ?? null,
-			item
-		});
 		const helpers = getHelpers(this.knex);
 		let revisionDelta = await payloadService.prepareDelta(delta);
-		await revisionsService.createOne({
-			activity,
-			version: key,
-			collection,
-			item,
-			data: revisionDelta,
-			delta: revisionDelta
-		});
+		const trackingAccountability = this.schema.collections[collection]?.accountability ?? null;
+		if (trackingAccountability !== null) {
+			const activity = await new ActivityService({
+				knex: this.knex,
+				schema: this.schema
+			}).createOne({
+				action: Action.VERSION_SAVE,
+				user: this.accountability?.user ?? null,
+				collection,
+				ip: this.accountability?.ip ?? null,
+				user_agent: this.accountability?.userAgent ?? null,
+				origin: this.accountability?.origin ?? null,
+				item
+			});
+			if (trackingAccountability === "all") await new RevisionsService({
+				knex: this.knex,
+				schema: this.schema
+			}).createOne({
+				activity,
+				version: key,
+				collection,
+				item,
+				data: revisionDelta,
+				delta: revisionDelta
+			});
+		}
 		revisionDelta = revisionDelta ? revisionDelta : null;
-		const date = new Date(helpers.date.writeTimestamp(new Date().toISOString()));
+		const date = new Date(helpers.date.writeTimestamp((/* @__PURE__ */ new Date()).toISOString()));
 		deepMapObjects(revisionDelta, (object, path) => {
 			const existing = get(existingDelta, path);
 			if (existing && isEqual(existing, object)) return;
@@ -197,41 +174,32 @@ var VersionsService = class VersionsService extends ItemsService {
 			object["_date"] = date;
 		});
 		const finalVersionDelta = assign({}, existingDelta, revisionDelta);
-		const sudoService = new ItemsService(this.collection, {
+		await new ItemsService(this.collection, {
 			knex: this.knex,
 			schema: this.schema,
 			accountability: {
 				...this.accountability,
 				admin: true
 			}
-		});
-		await sudoService.updateOne(key, { delta: finalVersionDelta });
+		}).updateOne(key, { delta: finalVersionDelta });
 		const { cache } = getCache();
-		if (shouldClearCache(cache, undefined, collection)) {
-			cache.clear();
-		}
+		if (shouldClearCache(cache, void 0, collection)) cache.clear();
 		return finalVersionDelta;
 	}
 	async promote(version, mainHash, fields) {
 		const { collection, item, delta } = await super.readOne(version);
-		if (this.accountability) {
-			await validateAccess({
-				accountability: this.accountability,
-				action: "update",
-				collection,
-				primaryKeys: [item]
-			}, {
-				schema: this.schema,
-				knex: this.knex
-			});
-		}
-		if (!delta) {
-			throw new UnprocessableContentError({ reason: `No changes to promote` });
-		}
+		if (this.accountability) await validateAccess({
+			accountability: this.accountability,
+			action: "update",
+			collection,
+			primaryKeys: [item]
+		}, {
+			schema: this.schema,
+			knex: this.knex
+		});
+		if (!delta) throw new UnprocessableContentError({ reason: `No changes to promote` });
 		const { outdated } = await this.verifyHash(collection, item, mainHash);
-		if (outdated) {
-			throw new UnprocessableContentError({ reason: `Main item has changed since this version was last updated` });
-		}
+		if (outdated) throw new UnprocessableContentError({ reason: `Main item has changed since this version was last updated` });
 		const { rawDelta, defaultOverwrites } = splitRecursive(delta);
 		const payloadToUpdate = fields ? pick(rawDelta, fields) : rawDelta;
 		const itemsService = new ItemsService(collection, {
@@ -267,22 +235,13 @@ var VersionsService = class VersionsService extends ItemsService {
 		return deepMapWithSchema(delta, ([key, value], context) => {
 			if (key === "_user" || key === "_date") return;
 			if (context.collection.primary in context.object) {
-				if (context.field.special.includes("user-updated")) {
-					return [key, context.object["_user"]];
-				}
-				if (context.field.special.includes("date-updated")) {
-					return [key, context.object["_date"]];
-				}
+				if (context.field.special.includes("user-updated")) return [key, context.object["_user"]];
+				if (context.field.special.includes("date-updated")) return [key, context.object["_date"]];
 			} else {
-				if (context.field.special.includes("user-created")) {
-					return [key, context.object["_user"]];
-				}
-				if (context.field.special.includes("date-created")) {
-					return [key, context.object["_date"]];
-				}
+				if (context.field.special.includes("user-created")) return [key, context.object["_user"]];
+				if (context.field.special.includes("date-created")) return [key, context.object["_date"]];
 			}
 			if (key in context.object) return [key, value];
-			return undefined;
 		}, {
 			collection: version.collection,
 			schema: this.schema
@@ -297,9 +256,7 @@ function deepMapObjects(object, fn, path = []) {
 	if (isPlainObject(object) && typeof object === "object" && object !== null) {
 		fn(object, path);
 		Object.entries(object).map(([key, value]) => deepMapObjects(value, fn, [...path, key]));
-	} else if (Array.isArray(object)) {
-		object.map((value, index) => deepMapObjects(value, fn, [...path, String(index)]));
-	}
+	} else if (Array.isArray(object)) object.map((value, index) => deepMapObjects(value, fn, [...path, String(index)]));
 }
 
 //#endregion

package/dist/services/websocket.js

@@ -9,19 +9,15 @@ const env = useEnv();
 var WebSocketService = class {
 	controller;
 	constructor() {
-		if (!toBoolean(env["WEBSOCKETS_ENABLED"]) || !toBoolean(env["WEBSOCKETS_REST_ENABLED"])) {
-			throw new ServiceUnavailableError({
-				service: "ws",
-				reason: "WebSocket server is disabled"
-			});
-		}
+		if (!toBoolean(env["WEBSOCKETS_ENABLED"]) || !toBoolean(env["WEBSOCKETS_REST_ENABLED"])) throw new ServiceUnavailableError({
+			service: "ws",
+			reason: "WebSocket server is disabled"
+		});
 		const controller = getWebSocketController();
-		if (!controller) {
-			throw new ServiceUnavailableError({
-				service: "ws",
-				reason: "WebSocket server is not initialized"
-			});
-		}
+		if (!controller) throw new ServiceUnavailableError({
+			service: "ws",
+			reason: "WebSocket server is not initialized"
+		});
 		this.controller = controller;
 	}
 	on(event, callback) {

package/dist/storage/get-storage-driver.js

@@ -8,11 +8,8 @@ const _aliasMap = {
 	cloudinary: "@directus/storage-driver-cloudinary"
 };
 const getStorageDriver = async (driverName) => {
-	if (driverName in _aliasMap) {
-		driverName = _aliasMap[driverName];
-	} else {
-		throw new Error(`Driver "${driverName}" doesn't exist.`);
-	}
+	if (driverName in _aliasMap) driverName = _aliasMap[driverName];
+	else throw new Error(`Driver "${driverName}" doesn't exist.`);
 	return (await import(driverName)).default;
 };
 

package/dist/storage/register-drivers.js

@@ -11,9 +11,7 @@ const registerDrivers = async (storage) => {
 	}
 	for (const driverName of usedDrivers) {
 		const storageDriver = await getStorageDriver(driverName);
-		if (storageDriver) {
-			storage.registerDriver(driverName, storageDriver);
-		}
+		if (storageDriver) storage.registerDriver(driverName, storageDriver);
 	}
 };
 

package/dist/storage/register-locations.js

@@ -5,16 +5,14 @@ import { toArray } from "@directus/utils";
 
 //#region src/storage/register-locations.ts
 const registerLocations = async (storage) => {
-	const env = useEnv();
-	const locations = toArray(env["STORAGE_LOCATIONS"]);
+	const locations = toArray(useEnv()["STORAGE_LOCATIONS"]);
 	const tus = {
 		enabled: RESUMABLE_UPLOADS.ENABLED,
 		chunkSize: RESUMABLE_UPLOADS.CHUNK_SIZE
 	};
 	locations.forEach((location) => {
 		location = location.trim();
-		const driverConfig = getConfigFromEnv(`STORAGE_${location.toUpperCase()}_`);
-		const { driver,...options } = driverConfig;
+		const { driver,...options } = getConfigFromEnv(`STORAGE_${location.toUpperCase()}_`);
 		storage.registerLocation(location, {
 			driver,
 			options: {

package/dist/synchronization.js

@@ -6,12 +6,8 @@ import { Redis } from "ioredis";
 let synchronizationManager;
 function getSynchronizationManager() {
 	if (synchronizationManager) return synchronizationManager;
-	const env = useEnv();
-	if (env["SYNCHRONIZATION_STORE"] === "redis") {
-		synchronizationManager = new SynchronizationManagerRedis();
-	} else {
-		synchronizationManager = new SynchronizationManagerMemory();
-	}
+	if (useEnv()["SYNCHRONIZATION_STORE"] === "redis") synchronizationManager = new SynchronizationManagerRedis();
+	else synchronizationManager = new SynchronizationManagerMemory();
 	return synchronizationManager;
 }
 var SynchronizationManagerMemory = class {
@@ -33,10 +29,7 @@ var SynchronizationManagerMemory = class {
 	}
 	async setGreaterThan(key, value) {
 		if (this.existsSync(key)) {
-			const oldValue = Number(this.getSync(key));
-			if (value <= oldValue) {
-				return false;
-			}
+			if (value <= Number(this.getSync(key))) return false;
 		}
 		this.setSync(key, value);
 		return true;
@@ -93,13 +86,10 @@ var SynchronizationManagerRedis = class {
 		await this.client.del(this.getNamespacedKey(key));
 	}
 	async exists(key) {
-		const doesExist = await this.client.exists(this.getNamespacedKey(key));
-		return doesExist === 1;
+		return await this.client.exists(this.getNamespacedKey(key)) === 1;
 	}
 	async setGreaterThan(key, value) {
-		const client = this.client;
-		const wasSet = await client.setGreaterThan(this.getNamespacedKey(key), value);
-		return wasSet === 1;
+		return await this.client.setGreaterThan(this.getNamespacedKey(key), value) === 1;
 	}
 	getNamespacedKey(key) {
 		return `${this.namespace}:${key}`;
@@ -113,8 +103,7 @@ var SynchronizedClock = class {
 		this.synchronizationManager = getSynchronizationManager();
 	}
 	async set(timestamp) {
-		const wasSet = await this.synchronizationManager.setGreaterThan(this.key, timestamp);
-		return wasSet;
+		return await this.synchronizationManager.setGreaterThan(this.key, timestamp);
 	}
 	async reset() {
 		await this.synchronizationManager.delete(this.key);

package/dist/telemetry/counter/use-buffered-counter.js

@@ -27,15 +27,9 @@ const useBufferedCounter = (key, options) => {
 			timer: null
 		};
 		flusherEntry.timer = setInterval(() => {
-			for (const [subKey, state] of Object.entries(flusherEntry.counters)) {
-				if (state.count > 0 && !state.flushing) {
-					void flush(subKey);
-				}
-			}
+			for (const [subKey, state] of Object.entries(flusherEntry.counters)) if (state.count > 0 && !state.flushing) flush(subKey);
 		}, opts.flushIntervalMs);
-		if (flusherEntry.timer && typeof flusherEntry.timer === "object" && "unref" in flusherEntry.timer) {
-			flusherEntry.timer.unref();
-		}
+		if (flusherEntry.timer && typeof flusherEntry.timer === "object" && "unref" in flusherEntry.timer) flusherEntry.timer.unref();
 		_bufferedCounterCache[key] = flusherEntry;
 	}
 	const flusher = _bufferedCounterCache[key];
@@ -95,14 +89,9 @@ const useBufferedCounter = (key, options) => {
 		const localKeys = Object.keys(flusher.counters);
 		const subKeys = expectedKeys ? [...new Set([...localKeys, ...expectedKeys])] : localKeys;
 		const result = {};
-		for (const subKey of subKeys) {
-			const value = await counter.get(`${key}:${subKey}`);
-			result[subKey] = value ?? 0;
-		}
+		for (const subKey of subKeys) result[subKey] = await counter.get(`${key}:${subKey}`) ?? 0;
 		await Promise.all(subKeys.map((subKey) => {
-			if (result[subKey] > 0) {
-				return counter.increment(`${key}:${subKey}`, -result[subKey]);
-			}
+			if (result[subKey] > 0) return counter.increment(`${key}:${subKey}`, -result[subKey]);
 			return Promise.resolve();
 		}));
 		return result;
@@ -111,9 +100,7 @@ const useBufferedCounter = (key, options) => {
 		increment(subKey, amount = 1) {
 			const state = getOrCreateState(subKey);
 			state.count += amount;
-			if (state.count >= flusher.options.maxBucketSize) {
-				flush(subKey);
-			}
+			if (state.count >= flusher.options.maxBucketSize) flush(subKey);
 		},
 		flush,
 		flushAll,
@@ -127,10 +114,7 @@ const useBufferedCounter = (key, options) => {
 */
 const terminateAllBufferedCounters = async () => {
 	await Promise.all(Object.keys(_bufferedCounterCache).map((key) => {
-		if (_bufferedCounterCache[key]) {
-			return useBufferedCounter(key).terminate();
-		}
-		return undefined;
+		if (_bufferedCounterCache[key]) return useBufferedCounter(key).terminate();
 	}));
 };
 

package/dist/telemetry/counter/use-counters.js

@@ -10,9 +10,7 @@ const _cache = { counter: null };
 * Returns a shared counter kv instance, creating one if it doesn't exist.
 */
 const useCounters = () => {
-	if (_cache.counter) {
-		return _cache.counter;
-	}
+	if (_cache.counter) return _cache.counter;
 	let counter;
 	if (redisConfigAvailable()) {
 		const env = useEnv();
@@ -21,9 +19,7 @@ const useCounters = () => {
 			redis: useRedis(),
 			namespace: env["REDIS_COUNTERS_NAMESPACE"] ?? "directus:counters"
 		});
-	} else {
-		counter = createKv({ type: "local" });
-	}
+	} else counter = createKv({ type: "local" });
 	_cache.counter = counter;
 	return counter;
 };

package/dist/telemetry/lib/send-report.js

@@ -9,17 +9,13 @@ const sendReport = async (report) => {
 	const env = useEnv();
 	const url = "project_owner" in report ? new URL("/v1/owner", String(env["COMPLIANCE_URL"])) : new URL("/v1/metrics", String(env["TELEMETRY_URL"]));
 	const headers = { "Content-Type": "application/json" };
-	if (env["TELEMETRY_AUTHORIZATION"]) {
-		headers["Authorization"] = env["TELEMETRY_AUTHORIZATION"];
-	}
+	if (env["TELEMETRY_AUTHORIZATION"]) headers["Authorization"] = env["TELEMETRY_AUTHORIZATION"];
 	const res = await fetch(url, {
 		method: "POST",
 		body: JSON.stringify(report),
 		headers
 	});
-	if (!res.ok) {
-		throw new Error(`[${res.status}] ${await res.text()}`);
-	}
+	if (!res.ok) throw new Error(`[${res.status}] ${await res.text()}`);
 };
 
 //#endregion

package/dist/telemetry/lib/track.js

@@ -15,17 +15,12 @@ import { setTimeout } from "timers/promises";
 */
 const track = async (opts = { wait: true }) => {
 	const logger = useLogger();
-	if (opts.wait) {
-		await setTimeout(getRandomWaitTime());
-	}
+	if (opts.wait) await setTimeout(getRandomWaitTime());
 	try {
-		const report = await getReport();
-		await sendReport(report);
+		await sendReport(await getReport());
 		return true;
 	} catch (err) {
-		if (getNodeEnv() === "development") {
-			logger.error(err);
-		}
+		if (getNodeEnv() === "development") logger.error(err);
 		return false;
 	}
 };

package/dist/telemetry/utils/check-user-limits.js

@@ -8,15 +8,9 @@ const env = useEnv();
 * Ensure that user limits are not reached
 */
 async function checkUserLimits(userCounts) {
-	if (userCounts.admin > Number(env["USERS_ADMIN_ACCESS_LIMIT"])) {
-		throw new LimitExceededError({ category: "Active Admin users" });
-	}
-	if (userCounts.app + userCounts.admin > Number(env["USERS_APP_ACCESS_LIMIT"])) {
-		throw new LimitExceededError({ category: "Active App users" });
-	}
-	if (userCounts.api > Number(env["USERS_API_ACCESS_LIMIT"])) {
-		throw new LimitExceededError({ category: "Active API users" });
-	}
+	if (userCounts.admin > Number(env["USERS_ADMIN_ACCESS_LIMIT"])) throw new LimitExceededError({ category: "Active Admin users" });
+	if (userCounts.app + userCounts.admin > Number(env["USERS_APP_ACCESS_LIMIT"])) throw new LimitExceededError({ category: "Active App users" });
+	if (userCounts.api > Number(env["USERS_API_ACCESS_LIMIT"])) throw new LimitExceededError({ category: "Active API users" });
 }
 
 //#endregion