@directus/api 35.0.2 → 35.1.0

package/dist/services/translations.js

@@ -11,31 +11,25 @@ var TranslationsService = class extends ItemsService {
 		this.schema = options.schema;
 	}
 	async translationKeyExists(key, language) {
-		const result = await this.knex.select("id").from(this.collection).where({
+		return (await this.knex.select("id").from(this.collection).where({
 			key,
 			language
-		});
-		return result.length > 0;
+		})).length > 0;
 	}
 	async createOne(data, opts) {
-		if (await this.translationKeyExists(data["key"], data["language"])) {
-			throw new InvalidPayloadError({ reason: "Duplicate key and language combination" });
-		}
+		if (await this.translationKeyExists(data["key"], data["language"])) throw new InvalidPayloadError({ reason: "Duplicate key and language combination" });
 		return await super.createOne(data, opts);
 	}
 	async updateMany(keys, data, opts) {
-		if (keys.length > 0 && "key" in data && "language" in data) {
-			throw new InvalidPayloadError({ reason: "Duplicate key and language combination" });
-		} else if ("key" in data || "language" in data) {
+		if (keys.length > 0 && "key" in data && "language" in data) throw new InvalidPayloadError({ reason: "Duplicate key and language combination" });
+		else if ("key" in data || "language" in data) {
 			const items = await this.readMany(keys);
 			for (const item of items) {
 				const updatedData = {
 					...item,
 					...data
 				};
-				if (await this.translationKeyExists(updatedData["key"], updatedData["language"])) {
-					throw new InvalidPayloadError({ reason: "Duplicate key and language combination" });
-				}
+				if (await this.translationKeyExists(updatedData["key"], updatedData["language"])) throw new InvalidPayloadError({ reason: "Duplicate key and language combination" });
 			}
 		}
 		return await super.updateMany(keys, data, opts);

package/dist/services/tus/data-store.js

@@ -4,7 +4,6 @@ import { ItemsService } from "../items.js";
 import { omit } from "lodash-es";
 import { extname } from "node:path";
 import { extension } from "mime-types";
-import "node:stream";
 import formatTitle from "@directus/format-title";
 import { DataStore, ERRORS, Upload } from "@tus/utils";
 
@@ -34,27 +33,17 @@ var TusDataStore = class extends DataStore {
 			schema: this.schema,
 			knex
 		});
-		upload.creation_date = new Date().toISOString();
-		if (!upload.size || !upload.metadata || !upload.metadata["filename_download"]) {
-			throw ERRORS.INVALID_METADATA;
-		}
-		if (!upload.metadata["type"]) {
-			upload.metadata["type"] = "application/octet-stream";
-		}
-		if (!upload.metadata["title"]) {
-			upload.metadata["title"] = formatTitle(upload.metadata["filename_download"]);
-		}
+		upload.creation_date = (/* @__PURE__ */ new Date()).toISOString();
+		if (!upload.size || !upload.metadata || !upload.metadata["filename_download"]) throw ERRORS.INVALID_METADATA;
+		if (!upload.metadata["type"]) upload.metadata["type"] = "application/octet-stream";
+		if (!upload.metadata["title"]) upload.metadata["title"] = formatTitle(upload.metadata["filename_download"]);
 		let existingFile = null;
 		if (upload.metadata["id"]) {
 			existingFile = await knex.select("folder", "filename_download", "filename_disk", "title", "description", "metadata", "tus_id").from("directus_files").andWhere({ id: upload.metadata["id"] }).first() ?? null;
-			if (existingFile && existingFile["tus_id"] !== null) {
-				throw ERRORS.INVALID_METADATA;
-			}
+			if (existingFile && existingFile["tus_id"] !== null) throw ERRORS.INVALID_METADATA;
 		}
 		const isReplacement = existingFile !== null && !!upload.metadata["id"];
-		if (isReplacement === true && upload.metadata["id"]) {
-			upload.metadata["replace_id"] = upload.metadata["id"];
-		}
+		if (isReplacement === true && upload.metadata["id"]) upload.metadata["replace_id"] = upload.metadata["id"];
 		const fileData = {
 			...omit(upload.metadata, ["id", "replace_id"]),
 			tus_id: upload.id,
@@ -64,14 +53,10 @@ var TusDataStore = class extends DataStore {
 		};
 		if ("folder" in fileData === false) {
 			const settings = await knex.select("storage_default_folder").from("directus_settings").first();
-			if (settings?.storage_default_folder) {
-				fileData.folder = settings.storage_default_folder;
-			}
+			if (settings?.storage_default_folder) fileData.folder = settings.storage_default_folder;
 		}
 		const primaryKey = await filesItemsService.createOne(fileData, { emitEvents: false });
-		if (!upload.metadata["id"]) {
-			upload.metadata["id"] = primaryKey;
-		}
+		if (!upload.metadata["id"]) upload.metadata["id"] = primaryKey;
 		const fileExtension = extname(upload.metadata["filename_download"]) || upload.metadata["type"] && "." + extension(upload.metadata["type"]) || "";
 		fileData.filename_disk ||= primaryKey + (fileExtension || "");
 		try {
@@ -82,14 +67,11 @@ var TusDataStore = class extends DataStore {
 		} catch (err) {
 			logger.warn(`Couldn't create chunked upload for ${fileData.filename_disk}`);
 			logger.warn(err);
-			if (isReplacement) {
-				await filesItemsService.updateOne(primaryKey, {
-					tus_id: null,
-					tus_data: null
-				}, { emitEvents: false });
-			} else {
-				await filesItemsService.deleteOne(primaryKey, { emitEvents: false });
-			}
+			if (isReplacement) await filesItemsService.updateOne(primaryKey, {
+				tus_id: null,
+				tus_data: null
+			}, { emitEvents: false });
+			else await filesItemsService.deleteOne(primaryKey, { emitEvents: false });
 			throw ERRORS.UNKNOWN_ERROR;
 		}
 	}
@@ -111,22 +93,17 @@ var TusDataStore = class extends DataStore {
 					await this.remove(fileData.tus_id);
 					throw err;
 				}
-				const isReplacement = Boolean(fileData.tus_data?.["metadata"]?.["replace_id"]);
-				if (isReplacement === true) {
+				if (Boolean(fileData.tus_data?.["metadata"]?.["replace_id"]) === true) {
 					const replaceId = fileData.tus_data["metadata"]["replace_id"];
 					const replaceData = await sudoFilesItemsService.readOne(replaceId, { fields: ["filename_disk"] });
-					for await (const partPath of this.storageDriver.list(replaceId)) {
-						await this.storageDriver.delete(partPath);
-					}
+					for await (const partPath of this.storageDriver.list(replaceId)) await this.storageDriver.delete(partPath);
 					await this.storageDriver.move(filePath, replaceData.filename_disk);
 				}
 			}
 			return newOffset;
 		} catch (err) {
 			logger.error(err, "Error writing chunk for upload \"%s\" at offset %d", tus_id, offset);
-			if ("status_code" in err && err.status_code === 500) {
-				throw err;
-			}
+			if ("status_code" in err && err.status_code === 500) throw err;
 			throw ERRORS.FILE_WRITE_ERROR;
 		}
 	}
@@ -138,7 +115,7 @@ var TusDataStore = class extends DataStore {
 	}
 	async deleteExpired() {
 		const sudoFilesItemsService = new ItemsService("directus_files", { schema: this.schema });
-		const now = new Date();
+		const now = /* @__PURE__ */ new Date();
 		const toDelete = [];
 		const uploadFiles = await sudoFilesItemsService.readByQuery({
 			fields: [
@@ -149,14 +126,9 @@ var TusDataStore = class extends DataStore {
 			filter: { tus_id: { _nnull: true } }
 		});
 		if (!uploadFiles) return 0;
-		for (const fileData of uploadFiles) {
-			if (fileData && fileData.tus_data && this.getExpiration() > 0 && fileData.tus_data["size"] !== fileData.tus_data["offset"] && fileData.modified_on) {
-				const modified = new Date(fileData.modified_on);
-				const expires = new Date(modified.getTime() + this.getExpiration());
-				if (now > expires) {
-					toDelete.push(this.remove(fileData.tus_id));
-				}
-			}
+		for (const fileData of uploadFiles) if (fileData && fileData.tus_data && this.getExpiration() > 0 && fileData.tus_data["size"] !== fileData.tus_data["offset"] && fileData.modified_on) {
+			const modified = new Date(fileData.modified_on);
+			if (now > new Date(modified.getTime() + this.getExpiration())) toDelete.push(this.remove(fileData.tus_id));
 		}
 		await Promise.allSettled(toDelete);
 		return toDelete.length;
@@ -165,19 +137,15 @@ var TusDataStore = class extends DataStore {
 		return this.expirationTime;
 	}
 	async getUpload(id) {
-		const fileData = await this.getFileById(id);
-		return new Upload(fileData.tus_data);
+		return new Upload((await this.getFileById(id)).tus_data);
 	}
 	async getFileById(tus_id) {
-		const sudoFilesItemsService = new ItemsService("directus_files", { schema: this.schema });
-		const results = await sudoFilesItemsService.readByQuery({ filter: {
+		const results = await new ItemsService("directus_files", { schema: this.schema }).readByQuery({ filter: {
 			tus_id: { _eq: tus_id },
 			storage: { _eq: this.location },
 			...this.accountability?.user ? { uploaded_by: { _eq: this.accountability.user } } : {}
 		} });
-		if (!results || !results[0]) {
-			throw ERRORS.FILE_NOT_FOUND;
-		}
+		if (!results || !results[0]) throw ERRORS.FILE_NOT_FOUND;
 		return results[0];
 	}
 };

package/dist/services/tus/lockers.js

@@ -43,15 +43,11 @@ var KvLock = class {
 		const abortSignal = AbortSignal.any([signal, abortController.signal]);
 		const lock = await Promise.race([waitTimeout(this.acquireTimeout, abortSignal), this.acquireLock(this.id, cancelReq, abortSignal)]);
 		abortController.abort();
-		if (!lock) {
-			throw ERRORS.ERR_LOCK_TIMEOUT;
-		}
+		if (!lock) throw ERRORS.ERR_LOCK_TIMEOUT;
 	}
 	async acquireLock(id, requestRelease, signal) {
 		const lockTime = await this.kv.get(id);
-		if (signal.aborted) {
-			return typeof lockTime !== "undefined";
-		}
+		if (signal.aborted) return typeof lockTime !== "undefined";
 		const now = Date.now();
 		if (!lockTime || Number(lockTime) < now - this.lockTimeout) {
 			await this.kv.set(id, now);
@@ -68,11 +64,9 @@ var KvLock = class {
 		await this.kv.delete(this.id);
 	}
 };
-let _locker = undefined;
+let _locker = void 0;
 function getTusLocker() {
-	if (!_locker) {
-		_locker = new TusLocker();
-	}
+	if (!_locker) _locker = new TusLocker();
 	return _locker;
 }
 

package/dist/services/tus/server.js

@@ -20,9 +20,7 @@ async function createTusStore(context) {
 	const storage = await getStorage();
 	const location = toArray(env["STORAGE_LOCATIONS"])[0];
 	const driver = storage.location(location);
-	if (!supportsTus(driver)) {
-		throw new Error(`Storage location ${location} does not support the TUS protocol`);
-	}
+	if (!supportsTus(driver)) throw new Error(`Storage location ${location} does not support the TUS protocol`);
 	return new TusDataStore({
 		constants: RESUMABLE_UPLOADS,
 		accountability: context.accountability,
@@ -33,10 +31,9 @@ async function createTusStore(context) {
 }
 async function createTusServer(context) {
 	const env = useEnv();
-	const store = await createTusStore(context);
 	const server = new Server({
 		path: "/files/tus",
-		datastore: store,
+		datastore: await createTusStore(context),
 		locker: getTusLocker(),
 		...FILE_UPLOADS.MAX_SIZE !== null && { maxSize: FILE_UPLOADS.MAX_SIZE },
 		async onUploadFinish(_req, upload) {

package/dist/services/users.js

@@ -39,61 +39,44 @@ var UsersService = class UsersService extends ItemsService {
 	async checkUniqueEmails(emails, excludeKey) {
 		emails = emails.map((email) => email.toLowerCase());
 		const duplicates = emails.filter((value, index, array) => array.indexOf(value) !== index);
-		if (duplicates.length) {
-			throw new RecordNotUniqueError({
-				collection: "directus_users",
-				field: "email",
-				value: "[" + String(duplicates) + "]"
-			});
-		}
+		if (duplicates.length) throw new RecordNotUniqueError({
+			collection: "directus_users",
+			field: "email",
+			value: "[" + String(duplicates) + "]"
+		});
 		const query = this.knex.select("email").from("directus_users").whereRaw(`LOWER(??) IN (${emails.map(() => "?")})`, ["email", ...emails]);
-		if (excludeKey) {
-			query.whereNot("id", excludeKey);
-		}
-		const results = await query;
-		if (results.length) {
-			throw new RecordNotUniqueError({
-				collection: "directus_users",
-				field: "email",
-				value: "[" + String(emails) + "]"
-			});
-		}
+		if (excludeKey) query.whereNot("id", excludeKey);
+		if ((await query).length) throw new RecordNotUniqueError({
+			collection: "directus_users",
+			field: "email",
+			value: "[" + String(emails) + "]"
+		});
 	}
 	/**
 	* Check if the provided password matches the strictness as configured in
 	* directus_settings.auth_password_policy
 	*/
 	async checkPasswordPolicy(passwords) {
-		const settingsService = new SettingsService({
+		const { auth_password_policy: policyRegExString } = await new SettingsService({
 			schema: this.schema,
 			knex: this.knex
-		});
-		const { auth_password_policy: policyRegExString } = await settingsService.readSingleton({ fields: ["auth_password_policy"] });
-		if (!policyRegExString) {
-			return;
-		}
+		}).readSingleton({ fields: ["auth_password_policy"] });
+		if (!policyRegExString) return;
 		const wrapped = policyRegExString.startsWith("/") && policyRegExString.endsWith("/");
 		const regex = new RegExp(wrapped ? policyRegExString.slice(1, -1) : policyRegExString);
-		for (const password of passwords) {
-			if (!regex.test(password)) {
-				throw new FailedValidationError(joiValidationErrorItemToErrorExtensions({
-					message: `Provided password doesn't match password policy`,
-					path: ["password"],
-					type: "custom.pattern.base",
-					context: { value: password }
-				}));
-			}
-		}
+		for (const password of passwords) if (!regex.test(password)) throw new FailedValidationError(joiValidationErrorItemToErrorExtensions({
+			message: `Provided password doesn't match password policy`,
+			path: ["password"],
+			type: "custom.pattern.base",
+			context: { value: password }
+		}));
 	}
 	/**
 	* Clear users' sessions to log them out
 	*/
 	async clearUserSessions(userKeys, excludeSession) {
-		if (excludeSession) {
-			await this.knex.from("directus_sessions").whereIn("user", userKeys).andWhereNot("token", "=", excludeSession).delete();
-		} else {
-			await this.knex.from("directus_sessions").whereIn("user", userKeys).delete();
-		}
+		if (excludeSession) await this.knex.from("directus_sessions").whereIn("user", userKeys).andWhereNot("token", "=", excludeSession).delete();
+		else await this.knex.from("directus_sessions").whereIn("user", userKeys).delete();
 	}
 	/**
 	* Get basic information of user identified by email
@@ -123,13 +106,11 @@ var UsersService = class UsersService extends ItemsService {
 		const schema = Joi.string().email().required();
 		for (const email of emails) {
 			const { error } = schema.validate(email);
-			if (error) {
-				throw new FailedValidationError({
-					field: "email",
-					type: "email",
-					path: []
-				});
-			}
+			if (error) throw new FailedValidationError({
+				field: "email",
+				type: "email",
+				path: []
+			});
 		}
 	}
 	/**
@@ -137,13 +118,11 @@ var UsersService = class UsersService extends ItemsService {
 	*/
 	async createOne(data, opts = {}) {
 		try {
-			if ("email" in data && data["email"] !== undefined) {
+			if ("email" in data && data["email"] !== void 0) {
 				this.validateEmail(data["email"]);
 				await this.checkUniqueEmails([data["email"]]);
 			}
-			if ("password" in data) {
-				await this.checkPasswordPolicy([data["password"]]);
-			}
+			if ("password" in data) await this.checkPasswordPolicy([data["password"]]);
 		} catch (err) {
 			opts.preMutationError = err;
 		}
@@ -165,9 +144,7 @@ var UsersService = class UsersService extends ItemsService {
 				this.validateEmail(emails);
 				await this.checkUniqueEmails(emails);
 			}
-			if (passwords.length) {
-				await this.checkPasswordPolicy(passwords);
-			}
+			if (passwords.length) await this.checkPasswordPolicy(passwords);
 		} catch (err) {
 			opts.preMutationError = err;
 		}
@@ -175,12 +152,11 @@ var UsersService = class UsersService extends ItemsService {
 			opts.userIntegrityCheckFlags = (opts.userIntegrityCheckFlags ?? UserIntegrityCheckFlag.None) | UserIntegrityCheckFlag.UserLimits;
 			opts.onRequireUserIntegrityCheck?.(opts.userIntegrityCheckFlags);
 		}
-		const itemsService = new ItemsService(this.collection, {
+		return await new ItemsService(this.collection, {
 			schema: this.schema,
 			accountability: this.accountability,
 			knex: this.knex
-		});
-		return await itemsService.createMany(data, opts);
+		}).createMany(data, opts);
 	}
 	/**
 	* Update many users by primary key
@@ -188,76 +164,49 @@ var UsersService = class UsersService extends ItemsService {
 	async updateMany(keys, data, opts = {}) {
 		try {
 			if (data["email"]) {
-				if (keys.length > 1) {
-					throw new RecordNotUniqueError({
-						collection: "directus_users",
-						field: "email",
-						value: data["email"]
-					});
-				}
+				if (keys.length > 1) throw new RecordNotUniqueError({
+					collection: "directus_users",
+					field: "email",
+					value: data["email"]
+				});
 				this.validateEmail(data["email"]);
 				await this.checkUniqueEmails([data["email"]], keys[0]);
 			}
-			if (data["password"]) {
-				await this.checkPasswordPolicy([data["password"]]);
-			}
-			if (data["tfa_secret"] !== undefined) {
-				throw new InvalidPayloadError({ reason: `You can't change the "tfa_secret" value manually` });
-			}
-			if (data["provider"] !== undefined) {
-				if (this.accountability && this.accountability.admin !== true) {
-					throw new InvalidPayloadError({ reason: `You can't change the "provider" value manually` });
-				}
+			if (data["password"]) await this.checkPasswordPolicy([data["password"]]);
+			if (data["tfa_secret"] !== void 0) throw new InvalidPayloadError({ reason: `You can't change the "tfa_secret" value manually` });
+			if (data["provider"] !== void 0) {
+				if (this.accountability && this.accountability.admin !== true) throw new InvalidPayloadError({ reason: `You can't change the "provider" value manually` });
 				data["auth_data"] = null;
 			}
-			if (data["external_identifier"] !== undefined) {
-				if (this.accountability && this.accountability.admin !== true) {
-					throw new InvalidPayloadError({ reason: `You can't change the "external_identifier" value manually` });
-				}
+			if (data["external_identifier"] !== void 0) {
+				if (this.accountability && this.accountability.admin !== true) throw new InvalidPayloadError({ reason: `You can't change the "external_identifier" value manually` });
 				data["auth_data"] = null;
 			}
 		} catch (err) {
 			opts.preMutationError = err;
 		}
-		if ("role" in data) {
-			opts.userIntegrityCheckFlags = UserIntegrityCheckFlag.All;
-		}
-		if ("status" in data) {
-			if (data["status"] === "active") {
-				opts.userIntegrityCheckFlags = (opts.userIntegrityCheckFlags ?? UserIntegrityCheckFlag.None) | UserIntegrityCheckFlag.UserLimits;
-			} else {
-				opts.userIntegrityCheckFlags = UserIntegrityCheckFlag.All;
-			}
-		}
-		if (opts.userIntegrityCheckFlags) {
-			opts.onRequireUserIntegrityCheck?.(opts.userIntegrityCheckFlags);
-		}
+		if ("role" in data) opts.userIntegrityCheckFlags = UserIntegrityCheckFlag.All;
+		if ("status" in data) if (data["status"] === "active") opts.userIntegrityCheckFlags = (opts.userIntegrityCheckFlags ?? UserIntegrityCheckFlag.None) | UserIntegrityCheckFlag.UserLimits;
+		else opts.userIntegrityCheckFlags = UserIntegrityCheckFlag.All;
+		if (opts.userIntegrityCheckFlags) opts.onRequireUserIntegrityCheck?.(opts.userIntegrityCheckFlags);
 		const result = await super.updateMany(keys, data, opts);
-		if (data["status"] !== undefined && data["status"] !== "active") {
-			await this.clearUserSessions(keys);
-		} else if (data["password"] !== undefined || data["email"] !== undefined) {
-			await this.clearUserSessions(keys, this.accountability?.session);
-		}
-		if ("role" in data) {
-			await this.clearCaches(opts);
-		}
+		if (data["status"] !== void 0 && data["status"] !== "active") await this.clearUserSessions(keys);
+		else if (data["password"] !== void 0 || data["email"] !== void 0) await this.clearUserSessions(keys, this.accountability?.session);
+		if ("role" in data) await this.clearCaches(opts);
 		return result;
 	}
 	/**
 	* Delete multiple users by primary key
 	*/
 	async deleteMany(keys, opts = {}) {
-		if (opts?.onRequireUserIntegrityCheck) {
-			opts.onRequireUserIntegrityCheck(opts?.userIntegrityCheckFlags ?? UserIntegrityCheckFlag.None);
-		} else {
-			try {
-				await validateRemainingAdminUsers({ excludeUsers: keys }, {
-					knex: this.knex,
-					schema: this.schema
-				});
-			} catch (err) {
-				opts.preMutationError = err;
-			}
+		if (opts?.onRequireUserIntegrityCheck) opts.onRequireUserIntegrityCheck(opts?.userIntegrityCheckFlags ?? UserIntegrityCheckFlag.None);
+		else try {
+			await validateRemainingAdminUsers({ excludeUsers: keys }, {
+				knex: this.knex,
+				schema: this.schema
+			});
+		} catch (err) {
+			opts.preMutationError = err;
 		}
 		await this.knex("directus_comments").update({ user_updated: null }).whereIn("user_updated", keys);
 		await this.knex("directus_notifications").update({ sender: null }).whereIn("sender", keys);
@@ -269,9 +218,7 @@ var UsersService = class UsersService extends ItemsService {
 	async inviteUser(email, role, url, subject) {
 		const opts = {};
 		try {
-			if (url && isUrlAllowed(url, env["USER_INVITE_URL_ALLOW_LIST"]) === false) {
-				throw new InvalidPayloadError({ reason: `URL "${url}" can't be used to invite users` });
-			}
+			if (url && isUrlAllowed(url, env["USER_INVITE_URL_ALLOW_LIST"]) === false) throw new InvalidPayloadError({ reason: `URL "${url}" can't be used to invite users` });
 		} catch (err) {
 			opts.preMutationError = err;
 		}
@@ -282,15 +229,12 @@ var UsersService = class UsersService extends ItemsService {
 		});
 		for (const email$1 of emails) {
 			const user = await this.getUserByEmail(email$1);
-			if (isEmpty(user)) {
-				await this.createOne({
-					email: email$1,
-					role,
-					status: "invited"
-				}, opts);
-			} else if (user.status === "invited" && user.role !== role) {
-				await this.updateOne(user.id, { role }, opts);
-			}
+			if (isEmpty(user)) await this.createOne({
+				email: email$1,
+				role,
+				status: "invited"
+			}, opts);
+			else if (user.status === "invited" && user.role !== role) await this.updateOne(user.id, { role }, opts);
 			if (isEmpty(user) || user.status === "invited") {
 				const subjectLine = subject ?? "You've been invited";
 				mailService.send({
@@ -313,38 +257,30 @@ var UsersService = class UsersService extends ItemsService {
 		const { email, scope } = verifyJWT(token, getSecret());
 		if (scope !== "invite") throw new ForbiddenError();
 		const user = await this.getUserByEmail(email);
-		if (user?.status !== "invited") {
-			throw new InvalidInviteError();
-		}
-		const service = new UsersService({
+		if (user?.status !== "invited") throw new InvalidInviteError();
+		await new UsersService({
 			knex: this.knex,
 			schema: this.schema
-		});
-		await service.updateOne(user.id, {
+		}).updateOne(user.id, {
 			password,
 			status: "active"
 		});
 	}
 	async registerUser(input) {
-		if (input.verification_url && isUrlAllowed(input.verification_url, env["USER_REGISTER_URL_ALLOW_LIST"]) === false) {
-			throw new InvalidPayloadError({ reason: `URL "${input.verification_url}" can't be used to verify registered users` });
-		}
+		if (input.verification_url && isUrlAllowed(input.verification_url, env["USER_REGISTER_URL_ALLOW_LIST"]) === false) throw new InvalidPayloadError({ reason: `URL "${input.verification_url}" can't be used to verify registered users` });
 		const STALL_TIME = env["REGISTER_STALL_TIME"];
 		const timeStart = performance.now();
 		const serviceOptions = {
 			accountability: this.accountability,
 			schema: this.schema
 		};
-		const settingsService = new SettingsService(serviceOptions);
-		const settings = await settingsService.readSingleton({ fields: [
+		const settings = await new SettingsService(serviceOptions).readSingleton({ fields: [
 			"public_registration",
 			"public_registration_verify_email",
 			"public_registration_role",
 			"public_registration_email_filter"
 		] });
-		if (settings?.["public_registration"] == false) {
-			throw new ForbiddenError();
-		}
+		if (settings?.["public_registration"] == false) throw new ForbiddenError();
 		const publicRegistrationRole = settings?.["public_registration_role"] ?? null;
 		const hasEmailVerification = settings?.["public_registration_verify_email"];
 		const emailFilter = settings?.["public_registration_email_filter"];
@@ -363,9 +299,8 @@ var UsersService = class UsersService extends ItemsService {
 			throw new ForbiddenError();
 		}
 		const user = await this.getUserByEmail(input.email);
-		if (isEmpty(user)) {
-			await this.createOne(partialUser);
-		} else if (user.status !== "unverified") {
+		if (isEmpty(user)) await this.createOne(partialUser);
+		else if (user.status !== "unverified") {
 			await stall(STALL_TIME, timeStart);
 			return;
 		}
@@ -402,18 +337,14 @@ var UsersService = class UsersService extends ItemsService {
 		const { email, scope } = verifyJWT(token, env["SECRET"]);
 		if (scope !== "pending-registration") throw new ForbiddenError();
 		const user = await this.getUserByEmail(email);
-		if (user?.status !== "unverified") {
-			throw new InvalidPayloadError({ reason: "Invalid verification code" });
-		}
+		if (user?.status !== "unverified") throw new InvalidPayloadError({ reason: "Invalid verification code" });
 		await this.updateOne(user.id, { status: "active" });
 		return user.id;
 	}
 	async requestPasswordReset(email, url, subject) {
 		const STALL_TIME = 500;
 		const timeStart = performance.now();
-		if (url && isUrlAllowed(url, env["PASSWORD_RESET_URL_ALLOW_LIST"]) === false) {
-			throw new InvalidPayloadError({ reason: `URL "${url}" can't be used to reset passwords` });
-		}
+		if (url && isUrlAllowed(url, env["PASSWORD_RESET_URL_ALLOW_LIST"]) === false) throw new InvalidPayloadError({ reason: `URL "${url}" can't be used to reset passwords` });
 		const user = await this.getUserByEmail(email);
 		if (user?.status !== "active") {
 			await stall(STALL_TIME, timeStart);
@@ -464,27 +395,22 @@ var UsersService = class UsersService extends ItemsService {
 			opts.preMutationError = err;
 		}
 		const user = await this.getUserByEmail(email);
-		if (user?.status !== "active" || hash !== getSimpleHash("" + user.password)) {
-			throw new ForbiddenError();
-		}
-		const service = new UsersService({
+		if (user?.status !== "active" || hash !== getSimpleHash("" + user.password)) throw new ForbiddenError();
+		await new UsersService({
 			knex: this.knex,
 			schema: this.schema,
 			accountability: {
 				...this.accountability ?? createDefaultAccountability(),
 				admin: true
 			}
-		});
-		await service.updateOne(user.id, {
+		}).updateOne(user.id, {
 			password,
 			status: "active"
 		}, opts);
 	}
 	async clearCaches(opts) {
 		await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
-		if (this.cache && opts?.autoPurgeCache !== false) {
-			await this.cache.clear();
-		}
+		if (this.cache && opts?.autoPurgeCache !== false) await this.cache.clear();
 	}
 };