@directus/api 35.0.2 → 35.1.0

package/dist/telemetry/utils/get-item-count.js

@@ -10,9 +10,7 @@ import pLimit from "p-limit";
 */
 const countCollection = async (db, task) => {
 	const query = db.count("*", { as: "count" }).from(task.collection);
-	if (task.where) {
-		query.where(...task.where);
-	}
+	if (task.where) query.where(...task.where);
 	const count = await query.first();
 	return {
 		collection: task.collection,
@@ -38,8 +36,7 @@ const mergeResults = (acc, value) => {
 const getItemCount = async (db, tasks) => {
 	const limit = pLimit(3);
 	const calls = tasks.map((task) => limit(countCollection, db, task));
-	const results = await Promise.all(calls);
-	return results.reduce(mergeResults, {});
+	return (await Promise.all(calls)).reduce(mergeResults, {});
 };
 
 //#endregion

package/dist/telemetry/utils/get-settings.js

@@ -6,11 +6,10 @@ import { toBoolean } from "@directus/utils";
 //#region src/telemetry/utils/get-settings.ts
 const getSettings = async (db) => {
 	const env = useEnv();
-	const settingsService = new SettingsService({
+	const settings = await new SettingsService({
 		knex: db,
 		schema: await getSchema({ database: db })
-	});
-	const settings = await settingsService.readSingleton({ fields: [
+	}).readSingleton({ fields: [
 		"project_id",
 		"mcp_enabled",
 		"mcp_allow_deletes",

package/dist/telemetry/utils/get-user-item-count.js

@@ -15,11 +15,9 @@ const getUserItemCount = async (db) => {
 	const schema = await getSchema({ database: db });
 	const userCollections = Object.keys(schema.collections).filter((collection) => isSystemCollection(collection) === false).map((collection) => ({ collection }));
 	const counts = await getItemCount(db, userCollections);
-	const collections = userCollections.length;
-	const items = Object.values(counts).reduce(sum, 0);
 	return {
-		collections,
-		items
+		collections: userCollections.length,
+		items: Object.values(counts).reduce(sum, 0)
 	};
 };
 

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

@@ -6,9 +6,7 @@ import { useEnv } from "@directus/env";
 */
 function shouldCheckUserLimits() {
 	const env = useEnv();
-	if (Number(env["USERS_ADMIN_ACCESS_LIMIT"]) !== Infinity || Number(env["USERS_APP_ACCESS_LIMIT"]) !== Infinity || Number(env["USERS_API_ACCESS_LIMIT"]) !== Infinity) {
-		return true;
-	}
+	if (Number(env["USERS_ADMIN_ACCESS_LIMIT"]) !== Infinity || Number(env["USERS_APP_ACCESS_LIMIT"]) !== Infinity || Number(env["USERS_API_ACCESS_LIMIT"]) !== Infinity) return true;
 	return false;
 }
 

package/dist/types/index.js

@@ -1,9 +1,3 @@
-import "./ast.js";
-import "./auth.js";
-import "./collection.js";
-import "./events.js";
 import { Meta } from "./meta.js";
-import "./migration.js";
-import "./revision.js";
 
 export { Meta };

package/dist/utils/apply-diff.js

@@ -35,97 +35,82 @@ async function applyDiff(currentSnapshot, snapshotDiff, options) {
 		});
 		const getNestedCollectionsToCreate = (currentLevelCollection) => snapshotDiff.collections.filter(({ diff }) => diff[0].rhs?.meta?.group === currentLevelCollection);
 		const createCollections = async (collections) => {
-			for (const { collection, diff } of collections) {
-				if (diff?.[0]?.kind === DiffKind.NEW && diff[0].rhs) {
-					const fields = snapshotDiff.fields.filter((fieldDiff) => fieldDiff.collection === collection).map((fieldDiff) => fieldDiff.diff[0].rhs).map((fieldDiff) => {
-						if (["char", "varchar"].includes(String(fieldDiff.schema?.data_type).toLowerCase()) && fieldDiff.schema?.max_length === 36 && (fieldDiff.schema?.is_primary_key || fieldDiff.schema?.foreign_key_table && fieldDiff.schema?.foreign_key_column)) {
-							return merge(fieldDiff, {
-								type: "uuid",
-								schema: {
-									data_type: "uuid",
-									max_length: null
-								}
-							});
-						} else {
-							return fieldDiff;
+			for (const { collection, diff } of collections) if (diff?.[0]?.kind === DiffKind.NEW && diff[0].rhs) {
+				const fields = snapshotDiff.fields.filter((fieldDiff) => fieldDiff.collection === collection).map((fieldDiff) => fieldDiff.diff[0].rhs).map((fieldDiff) => {
+					if (["char", "varchar"].includes(String(fieldDiff.schema?.data_type).toLowerCase()) && fieldDiff.schema?.max_length === 36 && (fieldDiff.schema?.is_primary_key || fieldDiff.schema?.foreign_key_table && fieldDiff.schema?.foreign_key_column)) return merge(fieldDiff, {
+						type: "uuid",
+						schema: {
+							data_type: "uuid",
+							max_length: null
 						}
 					});
-					try {
-						await collectionsService.createOne({
-							...diff[0].rhs,
-							fields
-						}, mutationOptions);
-					} catch (err) {
-						logger.error(`Failed to create collection "${collection}"`);
-						throw err;
-					}
-					snapshotDiff.fields = snapshotDiff.fields.filter((fieldDiff) => fieldDiff.collection !== collection);
-					await createCollections(getNestedCollectionsToCreate(collection));
+					else return fieldDiff;
+				});
+				try {
+					await collectionsService.createOne({
+						...diff[0].rhs,
+						fields
+					}, mutationOptions);
+				} catch (err) {
+					logger.error(`Failed to create collection "${collection}"`);
+					throw err;
 				}
+				snapshotDiff.fields = snapshotDiff.fields.filter((fieldDiff) => fieldDiff.collection !== collection);
+				await createCollections(getNestedCollectionsToCreate(collection));
 			}
 		};
 		const deleteCollections = async (collections) => {
-			for (const { collection, diff } of collections) {
-				if (diff?.[0]?.kind === DiffKind.DELETE) {
-					const relations = schema.relations.filter((r) => r.related_collection === collection || r.collection === collection);
-					if (relations.length > 0) {
-						const relationsService$1 = new RelationsService({
-							knex: trx,
-							schema
-						});
-						for (const relation of relations) {
-							try {
-								await relationsService$1.deleteOne(relation.collection, relation.field, mutationOptions);
-							} catch (err) {
-								logger.error(`Failed to delete collection "${collection}" due to relation "${relation.collection}.${relation.field}"`);
-								throw err;
-							}
-						}
-						schema.relations = schema.relations.filter((r) => r.related_collection !== collection && r.collection !== collection);
-					}
-					try {
-						await collectionsService.deleteOne(collection, mutationOptions);
+			for (const { collection, diff } of collections) if (diff?.[0]?.kind === DiffKind.DELETE) {
+				const relations = schema.relations.filter((r) => r.related_collection === collection || r.collection === collection);
+				if (relations.length > 0) {
+					const relationsService$1 = new RelationsService({
+						knex: trx,
+						schema
+					});
+					for (const relation of relations) try {
+						await relationsService$1.deleteOne(relation.collection, relation.field, mutationOptions);
 					} catch (err) {
-						logger.error(`Failed to delete collection "${collection}"`);
+						logger.error(`Failed to delete collection "${collection}" due to relation "${relation.collection}.${relation.field}"`);
 						throw err;
 					}
+					schema.relations = schema.relations.filter((r) => r.related_collection !== collection && r.collection !== collection);
+				}
+				try {
+					await collectionsService.deleteOne(collection, mutationOptions);
+				} catch (err) {
+					logger.error(`Failed to delete collection "${collection}"`);
+					throw err;
 				}
 			}
 		};
 		const filterCollectionsForCreation = ({ diff }) => {
-			const isNewCollection = diff[0]?.kind === DiffKind.NEW;
-			if (!isNewCollection) return false;
+			if (!(diff[0]?.kind === DiffKind.NEW)) return false;
 			const groupName = diff[0].rhs.meta?.group;
 			if (!groupName) return true;
-			const parentExists = currentSnapshot.collections.find((c) => c.collection === groupName) !== undefined;
+			const parentExists = currentSnapshot.collections.find((c) => c.collection === groupName) !== void 0;
 			const parentWillBeCreatedInThisApply = snapshotDiff.collections.filter(({ collection, diff: diff$1 }) => diff$1[0]?.kind === DiffKind.NEW && collection === groupName).length > 0;
 			if (parentExists && !parentWillBeCreatedInThisApply) return true;
 			return false;
 		};
 		await createCollections(snapshotDiff.collections.filter(filterCollectionsForCreation));
 		const collectionsToDelete = snapshotDiff.collections.filter(({ diff }) => {
-			if (diff.length === 0 || diff[0] === undefined) return false;
-			const collectionDiff = diff[0];
-			return collectionDiff.kind === DiffKind.DELETE;
+			if (diff.length === 0 || diff[0] === void 0) return false;
+			return diff[0].kind === DiffKind.DELETE;
 		});
 		if (collectionsToDelete.length > 0) await deleteCollections(collectionsToDelete);
-		for (const { collection, diff } of snapshotDiff.collections) {
-			if (diff?.[0]?.kind === DiffKind.EDIT || diff?.[0]?.kind === DiffKind.ARRAY) {
-				const currentCollection = currentSnapshot.collections.find((field) => {
-					return field.collection === collection;
-				});
-				if (currentCollection) {
-					try {
-						const newValues = diff.reduce((acc, currentDiff) => {
-							deepDiff.applyChange(acc, undefined, currentDiff);
-							return acc;
-						}, cloneDeep(currentCollection));
-						await collectionsService.updateOne(collection, newValues, mutationOptions);
-					} catch (err) {
-						logger.error(`Failed to update collection "${collection}"`);
-						throw err;
-					}
-				}
+		for (const { collection, diff } of snapshotDiff.collections) if (diff?.[0]?.kind === DiffKind.EDIT || diff?.[0]?.kind === DiffKind.ARRAY) {
+			const currentCollection = currentSnapshot.collections.find((field) => {
+				return field.collection === collection;
+			});
+			if (currentCollection) try {
+				const newValues = diff.reduce((acc, currentDiff) => {
+					deepDiff.applyChange(acc, void 0, currentDiff);
+					return acc;
+				}, cloneDeep(currentCollection));
+				await collectionsService.updateOne(collection, newValues, mutationOptions);
+			} catch (err) {
+				logger.error(`Failed to update collection "${collection}"`);
+				throw err;
 			}
 		}
 		let fieldsService = new FieldsService({
@@ -136,36 +121,33 @@ async function applyDiff(currentSnapshot, snapshotDiff, options) {
 			})
 		});
 		for (const { collection, field, diff } of snapshotDiff.fields) {
-			if (diff?.[0]?.kind === DiffKind.NEW && !isNestedMetaUpdate(diff?.[0])) {
-				try {
-					await fieldsService.createField(collection, diff[0].rhs, undefined, mutationOptions);
-					fieldsService = new FieldsService({
-						knex: trx,
-						schema: await getSchema({
-							database: trx,
-							bypassCache: true
-						})
-					});
-				} catch (err) {
-					logger.error(`Failed to create field "${collection}.${field}"`);
-					throw err;
-				}
+			if (diff?.[0]?.kind === DiffKind.NEW && !isNestedMetaUpdate(diff?.[0])) try {
+				const rhs = diff[0].rhs;
+				await fieldsService.createField(collection, rhs, void 0, mutationOptions);
+				fieldsService = new FieldsService({
+					knex: trx,
+					schema: await getSchema({
+						database: trx,
+						bypassCache: true
+					})
+				});
+			} catch (err) {
+				logger.error(`Failed to create field "${collection}.${field}"`);
+				throw err;
 			}
 			if (diff?.[0]?.kind === DiffKind.EDIT || diff?.[0]?.kind === DiffKind.ARRAY || isNestedMetaUpdate(diff[0])) {
 				const currentField = currentSnapshot.fields.find((snapshotField) => {
 					return snapshotField.collection === collection && snapshotField.field === field;
 				});
-				if (currentField) {
-					try {
-						const newValues = diff.reduce((acc, currentDiff) => {
-							deepDiff.applyChange(acc, undefined, currentDiff);
-							return acc;
-						}, cloneDeep(currentField));
-						await fieldsService.updateField(collection, newValues, mutationOptions);
-					} catch (err) {
-						logger.error(`Failed to update field "${collection}.${field}"`);
-						throw err;
-					}
+				if (currentField) try {
+					const newValues = diff.reduce((acc, currentDiff) => {
+						deepDiff.applyChange(acc, void 0, currentDiff);
+						return acc;
+					}, cloneDeep(currentField));
+					await fieldsService.updateField(collection, newValues, mutationOptions);
+				} catch (err) {
+					logger.error(`Failed to update field "${collection}.${field}"`);
+					throw err;
 				}
 			}
 			if (diff?.[0]?.kind === DiffKind.DELETE && !isNestedMetaUpdate(diff?.[0])) {
@@ -185,22 +167,18 @@ async function applyDiff(currentSnapshot, snapshotDiff, options) {
 				snapshotDiff.relations = snapshotDiff.relations.filter((relation) => (relation.collection === collection && relation.field === field && !relation.diff.some((diff$1) => diff$1.kind === DiffKind.NEW)) === false);
 			}
 		}
-		for (const { collection, field, diff } of snapshotDiff.systemFields) {
-			if (diff?.[0]?.kind === DiffKind.EDIT) {
-				try {
-					const newValues = diff.reduce((acc, currentDiff) => {
-						deepDiff.applyChange(acc, undefined, currentDiff);
-						return acc;
-					}, {
-						collection,
-						field
-					});
-					await fieldsService.updateField(collection, newValues, mutationOptions);
-				} catch (err) {
-					logger.error(`Failed to update field "${collection}.${field}"`);
-					throw err;
-				}
-			}
+		for (const { collection, field, diff } of snapshotDiff.systemFields) if (diff?.[0]?.kind === DiffKind.EDIT) try {
+			const newValues = diff.reduce((acc, currentDiff) => {
+				deepDiff.applyChange(acc, void 0, currentDiff);
+				return acc;
+			}, {
+				collection,
+				field
+			});
+			await fieldsService.updateField(collection, newValues, mutationOptions);
+		} catch (err) {
+			logger.error(`Failed to update field "${collection}.${field}"`);
+			throw err;
 		}
 		const relationsService = new RelationsService({
 			knex: trx,
@@ -211,51 +189,41 @@ async function applyDiff(currentSnapshot, snapshotDiff, options) {
 		});
 		for (const { collection, field, diff } of snapshotDiff.relations) {
 			const structure = {};
-			for (const diffEdit of diff) {
-				set(structure, diffEdit.path, undefined);
-			}
-			if (diff?.[0]?.kind === DiffKind.NEW) {
-				try {
-					await relationsService.createOne({
-						...diff[0].rhs,
-						collection,
-						field
-					}, mutationOptions);
-				} catch (err) {
-					logger.error(`Failed to create relation "${collection}.${field}"`);
-					throw err;
-				}
+			for (const diffEdit of diff) set(structure, diffEdit.path, void 0);
+			if (diff?.[0]?.kind === DiffKind.NEW) try {
+				await relationsService.createOne({
+					...diff[0].rhs,
+					collection,
+					field
+				}, mutationOptions);
+			} catch (err) {
+				logger.error(`Failed to create relation "${collection}.${field}"`);
+				throw err;
 			}
 			if (diff?.[0]?.kind === DiffKind.EDIT || diff?.[0]?.kind === DiffKind.ARRAY) {
 				const currentRelation = currentSnapshot.relations.find((relation) => {
 					return relation.collection === collection && relation.field === field;
 				});
-				if (currentRelation) {
-					try {
-						const newValues = diff.reduce((acc, currentDiff) => {
-							deepDiff.applyChange(acc, undefined, currentDiff);
-							return acc;
-						}, cloneDeep(currentRelation));
-						await relationsService.updateOne(collection, field, newValues, mutationOptions);
-					} catch (err) {
-						logger.error(`Failed to update relation "${collection}.${field}"`);
-						throw err;
-					}
-				}
-			}
-			if (diff?.[0]?.kind === DiffKind.DELETE) {
-				try {
-					await relationsService.deleteOne(collection, field, mutationOptions);
+				if (currentRelation) try {
+					const newValues = diff.reduce((acc, currentDiff) => {
+						deepDiff.applyChange(acc, void 0, currentDiff);
+						return acc;
+					}, cloneDeep(currentRelation));
+					await relationsService.updateOne(collection, field, newValues, mutationOptions);
 				} catch (err) {
-					logger.error(`Failed to delete relation "${collection}.${field}"`);
+					logger.error(`Failed to update relation "${collection}.${field}"`);
 					throw err;
 				}
 			}
+			if (diff?.[0]?.kind === DiffKind.DELETE) try {
+				await relationsService.deleteOne(collection, field, mutationOptions);
+			} catch (err) {
+				logger.error(`Failed to delete relation "${collection}.${field}"`);
+				throw err;
+			}
 		}
 	});
-	if (runPostColumnChange) {
-		await helpers.schema.postColumnChange();
-	}
+	if (runPostColumnChange) await helpers.schema.postColumnChange();
 	await flushCaches();
 	if (nestedActionEvents.length > 0) {
 		const updatedSchema = await getSchema({

package/dist/utils/apply-snapshot.js

@@ -16,8 +16,7 @@ async function applySnapshot(snapshot, options) {
 		database,
 		schema
 	});
-	const snapshotDiff = options?.diff ?? getSnapshotDiff(current, snapshot);
-	await applyDiff(current, snapshotDiff, {
+	await applyDiff(current, options?.diff ?? getSnapshotDiff(current, snapshot), {
 		database,
 		schema
 	});

package/dist/utils/calculate-field-depth.js

@@ -34,35 +34,22 @@ import { isArray, isPlainObject } from "lodash-es";
 * ```
 */
 function calculateFieldDepth(obj, dotNotationKeys = []) {
-	if (!obj) {
-		return 0;
-	}
+	if (!obj) return 0;
 	let depth = 0;
 	const keys = Object.keys(obj);
 	for (const key of keys) {
 		const nestedValue = obj[key];
 		if (dotNotationKeys.includes(key) && nestedValue) {
 			let sortDepth = 0;
-			for (const sortKey of nestedValue) {
-				if (sortKey) {
-					sortDepth = Math.max(sortKey.split(".").length, sortDepth);
-				}
-			}
-			if (sortDepth > depth) {
-				depth = sortDepth;
-			}
+			for (const sortKey of nestedValue) if (sortKey) sortDepth = Math.max(sortKey.split(".").length, sortDepth);
+			if (sortDepth > depth) depth = sortDepth;
 		} else {
 			if (!isPlainObject(nestedValue) && !isArray(nestedValue)) continue;
 			let nestedDepth = 0;
-			if (Array.isArray(nestedValue)) {
-				nestedDepth = Math.max(...nestedValue.map((val) => calculateFieldDepth(val, dotNotationKeys)));
-			} else {
-				nestedDepth = calculateFieldDepth(nestedValue, dotNotationKeys);
-			}
+			if (Array.isArray(nestedValue)) nestedDepth = Math.max(...nestedValue.map((val) => calculateFieldDepth(val, dotNotationKeys)));
+			else nestedDepth = calculateFieldDepth(nestedValue, dotNotationKeys);
 			if (key.startsWith("_") === false) nestedDepth += 1;
-			if (nestedDepth > depth) {
-				depth = nestedDepth;
-			}
+			if (nestedDepth > depth) depth = nestedDepth;
 		}
 	}
 	return depth;

package/dist/utils/construct-flow-tree.js

@@ -2,30 +2,23 @@ import { omit } from "lodash-es";
 
 //#region src/utils/construct-flow-tree.ts
 function constructFlowTree(flow) {
-	const rootOperation = flow.operations.find((operation) => operation.id === flow.operation) ?? null;
-	const operationTree = constructOperationTree(rootOperation, flow.operations);
-	const flowTree = {
+	const operationTree = constructOperationTree(flow.operations.find((operation) => operation.id === flow.operation) ?? null, flow.operations);
+	return {
 		...omit(flow, "operations"),
 		operation: operationTree,
 		options: flow.options ?? {}
 	};
-	return flowTree;
 }
 function constructOperationTree(root, operations) {
-	if (root === null) {
-		return null;
-	}
+	if (root === null) return null;
 	const resolveOperation = root.resolve !== null ? operations.find((operation) => operation.id === root.resolve) : null;
 	const rejectOperation = root.reject !== null ? operations.find((operation) => operation.id === root.reject) : null;
-	if (resolveOperation === undefined || rejectOperation === undefined) {
-		throw new Error("Undefined reference in operations");
-	}
-	const operationTree = {
+	if (resolveOperation === void 0 || rejectOperation === void 0) throw new Error("Undefined reference in operations");
+	return {
 		...omit(root, "flow"),
 		resolve: constructOperationTree(resolveOperation, operations),
 		reject: constructOperationTree(rejectOperation, operations)
 	};
-	return operationTree;
 }
 
 //#endregion

package/dist/utils/create-admin.js

@@ -30,8 +30,7 @@ async function createAdmin(schema, admin) {
 	logger.info("Setting up first admin role...");
 	const accessService = new AccessService({ schema });
 	const policiesService = new PoliciesService({ schema });
-	const rolesService = new RolesService({ schema });
-	const role = await rolesService.createOne(defaultAdminRole);
+	const role = await new RolesService({ schema }).createOne(defaultAdminRole);
 	const policy = await policiesService.createOne(defaultAdminPolicy);
 	await accessService.createOne({
 		policy,

package/dist/utils/deep-map-response.js

@@ -16,41 +16,37 @@ function deepMapResponse(object, callback, context) {
 		if (!field) return [key, value];
 		const relationInfo = getRelationInfo(context.schema.relations, collection.collection, field.field);
 		let leaf = true;
-		if (relationInfo.relation && typeof value === "object" && value !== null && isPlainObject(object)) {
-			switch (relationInfo.relationType) {
-				case "m2o":
-					value = deepMapResponse(value, callback, {
-						schema: context.schema,
-						collection: relationInfo.relation.related_collection,
-						relationInfo
-					});
-					leaf = false;
-					break;
-				case "o2m":
-					value = value.map((childValue) => {
-						if (isPlainObject(childValue) && typeof childValue === "object" && childValue !== null) {
-							leaf = false;
-							return deepMapResponse(childValue, callback, {
-								schema: context.schema,
-								collection: relationInfo.relation.collection,
-								relationInfo
-							});
-						} else return childValue;
-					});
-					break;
-				case "a2o": {
-					const related_collection = object[relationInfo.relation.meta.one_collection_field];
-					if (!related_collection) {
-						throw new InvalidQueryError({ reason: `When selecting '${collection.collection}.${field.field}', the field '${collection.collection}.${relationInfo.relation.meta.one_collection_field}' has to be selected when using versioning and m2a relations ` });
-					}
-					value = deepMapResponse(value, callback, {
-						schema: context.schema,
-						collection: related_collection,
-						relationInfo
-					});
-					leaf = false;
-					break;
-				}
+		if (relationInfo.relation && typeof value === "object" && value !== null && isPlainObject(object)) switch (relationInfo.relationType) {
+			case "m2o":
+				value = deepMapResponse(value, callback, {
+					schema: context.schema,
+					collection: relationInfo.relation.related_collection,
+					relationInfo
+				});
+				leaf = false;
+				break;
+			case "o2m":
+				value = value.map((childValue) => {
+					if (isPlainObject(childValue) && typeof childValue === "object" && childValue !== null) {
+						leaf = false;
+						return deepMapResponse(childValue, callback, {
+							schema: context.schema,
+							collection: relationInfo.relation.collection,
+							relationInfo
+						});
+					} else return childValue;
+				});
+				break;
+			case "a2o": {
+				const related_collection = object[relationInfo.relation.meta.one_collection_field];
+				if (!related_collection) throw new InvalidQueryError({ reason: `When selecting '${collection.collection}.${field.field}', the field '${collection.collection}.${relationInfo.relation.meta.one_collection_field}' has to be selected when using versioning and m2a relations ` });
+				value = deepMapResponse(value, callback, {
+					schema: context.schema,
+					collection: related_collection,
+					relationInfo
+				});
+				leaf = false;
+				break;
 			}
 		}
 		return callback([key, value], {

package/dist/utils/encrypt.js

@@ -42,15 +42,14 @@ const decrypt = async (encryptedText, password) => {
 	if (kdf !== KDF) throw new Error(`Unsupported kdf: ${kdf}`);
 	if (!saltB64) throw new Error("No salt in encrypted string");
 	if (!ivB64) throw new Error("No iv in encrypted string");
-	if (cipherText === undefined) throw new Error("No cipherText in encrypted string");
+	if (cipherText === void 0) throw new Error("No cipherText in encrypted string");
 	if (!tagB64) throw new Error("No tag in encrypted string");
 	const opts = {
 		N: Number(nStr) || SCRYPT_DEFAULTS.N,
 		r: Number(rStr) || SCRYPT_DEFAULTS.r,
 		p: Number(pStr) || SCRYPT_DEFAULTS.p
 	};
-	const salt = Buffer.from(saltB64, "base64");
-	const keyBuf = await deriveKey(password, salt, opts);
+	const keyBuf = await deriveKey(password, Buffer.from(saltB64, "base64"), opts);
 	const iv = Buffer.from(ivB64, "base64");
 	const tag = Buffer.from(tagB64, "base64");
 	const decipher = crypto.createDecipheriv("aes-256-gcm", keyBuf, iv);

package/dist/utils/fetch-user-count/fetch-access-lookup.js

@@ -1,21 +1,11 @@
 //#region src/utils/fetch-user-count/fetch-access-lookup.ts
 async function fetchAccessLookup(options) {
 	let query = options.knex.select("directus_access.role", "directus_access.user", "directus_policies.app_access", "directus_policies.admin_access", "directus_users.status as user_status", "directus_users.role as user_role").from("directus_access").leftJoin("directus_policies", "directus_access.policy", "directus_policies.id").leftJoin("directus_users", "directus_access.user", "directus_users.id");
-	if (options.excludeAccessRows && options.excludeAccessRows.length > 0) {
-		query = query.whereNotIn("directus_access.id", options.excludeAccessRows);
-	}
-	if (options.excludePolicies && options.excludePolicies.length > 0) {
-		query = query.whereNotIn("directus_access.policy", options.excludePolicies);
-	}
-	if (options.excludeUsers && options.excludeUsers.length > 0) {
-		query = query.where((q) => q.whereNotIn("directus_access.user", options.excludeUsers).orWhereNull("directus_access.user"));
-	}
-	if (options.excludeRoles && options.excludeRoles.length > 0) {
-		query = query.where((q) => q.whereNotIn("directus_access.role", options.excludeRoles).orWhereNull("directus_access.role"));
-	}
-	if (options.adminOnly) {
-		query = query.where("directus_policies.admin_access", 1);
-	}
+	if (options.excludeAccessRows && options.excludeAccessRows.length > 0) query = query.whereNotIn("directus_access.id", options.excludeAccessRows);
+	if (options.excludePolicies && options.excludePolicies.length > 0) query = query.whereNotIn("directus_access.policy", options.excludePolicies);
+	if (options.excludeUsers && options.excludeUsers.length > 0) query = query.where((q) => q.whereNotIn("directus_access.user", options.excludeUsers).orWhereNull("directus_access.user"));
+	if (options.excludeRoles && options.excludeRoles.length > 0) query = query.where((q) => q.whereNotIn("directus_access.role", options.excludeRoles).orWhereNull("directus_access.role"));
+	if (options.adminOnly) query = query.where("directus_policies.admin_access", 1);
 	return query;
 }
 

package/dist/utils/fetch-user-count/get-user-count-query.js

@@ -1,18 +1,10 @@
 //#region src/utils/fetch-user-count/get-user-count-query.ts
 function getUserCountQuery(knex, options) {
-	if (options.includeRoles && options.includeRoles.length === 0) {
-		return Promise.resolve({ count: 0 });
-	}
+	if (options.includeRoles && options.includeRoles.length === 0) return Promise.resolve({ count: 0 });
 	let query = knex("directus_users").count({ count: "*" }).as("count").where("status", "=", "active");
-	if (options.excludeIds && options.excludeIds.length > 0) {
-		query = query.whereNotIn("id", options.excludeIds);
-	}
-	if (options.excludeRoles && options.excludeRoles.length > 0) {
-		query = query.whereNotIn("role", options.excludeRoles);
-	}
-	if (options.includeRoles && options.includeRoles.length > 0) {
-		query = query.whereIn("role", options.includeRoles);
-	}
+	if (options.excludeIds && options.excludeIds.length > 0) query = query.whereNotIn("id", options.excludeIds);
+	if (options.excludeRoles && options.excludeRoles.length > 0) query = query.whereNotIn("role", options.excludeRoles);
+	if (options.includeRoles && options.includeRoles.length > 0) query = query.whereIn("role", options.includeRoles);
 	return query.first();
 }