@directus/api 35.0.2 → 35.2.0

package/dist/utils/validate-query.js

@@ -28,100 +28,77 @@ const querySchema = Joi.object({
 }).id("query");
 function validateQuery(query) {
 	const { error } = querySchema.validate(query);
-	if (query.filter && Object.keys(query.filter).length > 0) {
-		validateFilter(query.filter);
-	}
-	if (query.alias) {
-		validateAlias(query.alias);
-	}
+	if (query.filter && Object.keys(query.filter).length > 0) validateFilter(query.filter);
+	if (query.alias) validateAlias(query.alias);
 	validateRelationalDepth(query);
-	if (error) {
-		throw new InvalidQueryError({ reason: error.message });
-	}
+	if (error) throw new InvalidQueryError({ reason: error.message });
 	return query;
 }
 function validateFilter(filter) {
-	for (const [key, nested] of Object.entries(filter)) {
-		if (key === "_and" || key === "_or") {
-			nested.forEach(validateFilter);
-		} else if (key.startsWith("_")) {
-			const value = nested;
-			switch (key) {
-				case "_in":
-				case "_nin":
-				case "_between":
-				case "_nbetween":
-					validateList(value, key);
-					break;
-				case "_null":
-				case "_nnull":
-				case "_empty":
-				case "_nempty":
-					validateBoolean(value, key);
-					break;
-				case "_intersects":
-				case "_nintersects":
-				case "_intersects_bbox":
-				case "_nintersects_bbox":
-					validateGeometry(value, key);
-					break;
-				case "_none":
-				case "_some":
-					validateFilter(nested);
-					break;
-				case "_eq":
-				case "_neq":
-				case "_contains":
-				case "_ncontains":
-				case "_starts_with":
-				case "_nstarts_with":
-				case "_istarts_with":
-				case "_nistarts_with":
-				case "_ends_with":
-				case "_nends_with":
-				case "_iends_with":
-				case "_niends_with":
-				case "_gt":
-				case "_gte":
-				case "_lt":
-				case "_lte":
-				default:
-					validateFilterPrimitive(value, key);
-					break;
-			}
-		} else if (isPlainObject(nested)) {
-			validateFilter(nested);
-		} else if (Array.isArray(nested) === false) {
-			validateFilterPrimitive(nested, "_eq");
-		} else {
-			validateFilter(nested);
+	for (const [key, nested] of Object.entries(filter)) if (key === "_and" || key === "_or") nested.forEach(validateFilter);
+	else if (key.startsWith("_")) {
+		const value = nested;
+		switch (key) {
+			case "_in":
+			case "_nin":
+			case "_between":
+			case "_nbetween":
+				validateList(value, key);
+				break;
+			case "_null":
+			case "_nnull":
+			case "_empty":
+			case "_nempty":
+				validateBoolean(value, key);
+				break;
+			case "_intersects":
+			case "_nintersects":
+			case "_intersects_bbox":
+			case "_nintersects_bbox":
+				validateGeometry(value, key);
+				break;
+			case "_none":
+			case "_some":
+				validateFilter(nested);
+				break;
+			case "_eq":
+			case "_neq":
+			case "_contains":
+			case "_ncontains":
+			case "_starts_with":
+			case "_nstarts_with":
+			case "_istarts_with":
+			case "_nistarts_with":
+			case "_ends_with":
+			case "_nends_with":
+			case "_iends_with":
+			case "_niends_with":
+			case "_gt":
+			case "_gte":
+			case "_lt":
+			case "_lte":
+			default:
+				validateFilterPrimitive(value, key);
+				break;
 		}
-	}
+	} else if (isPlainObject(nested)) validateFilter(nested);
+	else if (Array.isArray(nested) === false) validateFilterPrimitive(nested, "_eq");
+	else validateFilter(nested);
 }
 function validateFilterPrimitive(value, key) {
 	if (value === null) return true;
-	if ((typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value instanceof Date) === false) {
-		throw new InvalidQueryError({ reason: `The filter value for "${key}" has to be a string, number, or boolean` });
-	}
-	if (typeof value === "number" && (Number.isNaN(value) || value > Number.MAX_SAFE_INTEGER)) {
-		throw new InvalidQueryError({ reason: `The filter value for "${key}" is not a valid number` });
-	}
-	if (typeof value === "string" && value.length === 0) {
-		throw new InvalidQueryError({ reason: `You can't filter for an empty string in "${key}". Use "_empty" or "_nempty" instead` });
-	}
+	if ((typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value instanceof Date) === false) throw new InvalidQueryError({ reason: `The filter value for "${key}" has to be a string, number, or boolean` });
+	if (typeof value === "number" && (Number.isNaN(value) || value > Number.MAX_SAFE_INTEGER)) throw new InvalidQueryError({ reason: `The filter value for "${key}" is not a valid number` });
+	if (typeof value === "string" && value.length === 0) throw new InvalidQueryError({ reason: `You can't filter for an empty string in "${key}". Use "_empty" or "_nempty" instead` });
 	return true;
 }
 function validateList(value, key) {
-	if (Array.isArray(value) === false || value.length === 0) {
-		throw new InvalidQueryError({ reason: `"${key}" has to be an array of values` });
-	}
+	if (Array.isArray(value) === false || value.length === 0) throw new InvalidQueryError({ reason: `"${key}" has to be an array of values` });
 	return true;
 }
 function validateBoolean(value, key) {
 	if (value === null || value === "") return true;
-	if (typeof value !== "boolean") {
-		throw new InvalidQueryError({ reason: `"${key}" has to be a boolean` });
-	}
+	if (typeof value !== "boolean") throw new InvalidQueryError({ reason: `"${key}" has to be a boolean` });
 	return true;
 }
 function validateGeometry(value, key) {
@@ -134,65 +111,37 @@ function validateGeometry(value, key) {
 	return true;
 }
 function validateAlias(alias) {
-	if (isPlainObject(alias) === false) {
-		throw new InvalidQueryError({ reason: `"alias" has to be an object` });
-	}
+	if (isPlainObject(alias) === false) throw new InvalidQueryError({ reason: `"alias" has to be an object` });
 	for (const [key, value] of Object.entries(alias)) {
-		if (typeof key !== "string") {
-			throw new InvalidQueryError({ reason: `"alias" key has to be a string. "${typeof key}" given` });
-		}
-		if (typeof value !== "string") {
-			throw new InvalidQueryError({ reason: `"alias" value has to be a string. "${typeof key}" given` });
-		}
-		if (key.includes(".") || value.includes(".")) {
-			throw new InvalidQueryError({ reason: `"alias" key/value can't contain a period character \`.\`` });
-		}
+		if (typeof key !== "string") throw new InvalidQueryError({ reason: `"alias" key has to be a string. "${typeof key}" given` });
+		if (typeof value !== "string") throw new InvalidQueryError({ reason: `"alias" value has to be a string. "${typeof key}" given` });
+		if (key.includes(".") || value.includes(".")) throw new InvalidQueryError({ reason: `"alias" key/value can't contain a period character \`.\`` });
 	}
 }
 function validateRelationalDepth(query) {
 	const maxRelationalDepth = Number(env["MAX_RELATIONAL_DEPTH"]) > 2 ? Number(env["MAX_RELATIONAL_DEPTH"]) : 2;
 	let fields = ["*"];
-	if (query.fields) {
-		fields = query.fields;
-	}
+	if (query.fields) fields = query.fields;
 	/**
 	* When using aggregate functions, you can't have any other regular fields
 	* selected. This makes sure you never end up in a non-aggregate fields selection error
 	*/
-	if (Object.keys(query.aggregate || {}).length > 0) {
-		fields = [];
-	}
+	if (Object.keys(query.aggregate || {}).length > 0) fields = [];
 	/**
 	* Similarly, when grouping on a specific field, you can't have other non-aggregated fields.
 	* The group query will override the fields query
 	*/
-	if (query.group) {
-		fields = query.group;
-	}
+	if (query.group) fields = query.group;
 	fields = uniq(fields);
-	for (const field of fields) {
-		if (getFieldRelationalDepth(field) > maxRelationalDepth) {
-			throw new InvalidQueryError({ reason: "Max relational depth exceeded" });
-		}
-	}
+	for (const field of fields) if (getFieldRelationalDepth(field) > maxRelationalDepth) throw new InvalidQueryError({ reason: "Max relational depth exceeded" });
 	if (query.filter) {
-		const filterRelationalDepth = calculateFieldDepth(query.filter);
-		if (filterRelationalDepth > maxRelationalDepth) {
-			throw new InvalidQueryError({ reason: "Max relational depth exceeded" });
-		}
+		if (calculateFieldDepth(query.filter) > maxRelationalDepth) throw new InvalidQueryError({ reason: "Max relational depth exceeded" });
 	}
 	if (query.sort) {
-		for (const sort of query.sort) {
-			if (sort.split(".").length > maxRelationalDepth) {
-				throw new InvalidQueryError({ reason: "Max relational depth exceeded" });
-			}
-		}
+		for (const sort of query.sort) if (sort.split(".").length > maxRelationalDepth) throw new InvalidQueryError({ reason: "Max relational depth exceeded" });
 	}
 	if (query.deep) {
-		const deepRelationalDepth = calculateFieldDepth(query.deep, ["_sort"]);
-		if (deepRelationalDepth > maxRelationalDepth) {
-			throw new InvalidQueryError({ reason: "Max relational depth exceeded" });
-		}
+		if (calculateFieldDepth(query.deep, ["_sort"]) > maxRelationalDepth) throw new InvalidQueryError({ reason: "Max relational depth exceeded" });
 	}
 }
 

package/dist/utils/validate-snapshot.js

@@ -51,16 +51,10 @@ function validateSnapshot(snapshot, force = false) {
 	const { error } = snapshotJoiSchema.validate(snapshot);
 	if (error) throw new InvalidPayloadError({ reason: error.message });
 	if (force) return;
-	if (snapshot.directus !== version) {
-		throw new InvalidPayloadError({ reason: `Provided snapshot's directus version ${snapshot.directus} does not match the current instance's version ${version}. You can bypass this check by passing the "force" query parameter` });
-	}
-	if (!snapshot.vendor) {
-		throw new InvalidPayloadError({ reason: "Provided snapshot does not contain the \"vendor\" property. You can bypass this check by passing the \"force\" query parameter" });
-	}
+	if (snapshot.directus !== version) throw new InvalidPayloadError({ reason: `Provided snapshot's directus version ${snapshot.directus} does not match the current instance's version ${version}. You can bypass this check by passing the "force" query parameter` });
+	if (!snapshot.vendor) throw new InvalidPayloadError({ reason: "Provided snapshot does not contain the \"vendor\" property. You can bypass this check by passing the \"force\" query parameter" });
 	const currentVendor = getDatabaseClient();
-	if (snapshot.vendor !== currentVendor) {
-		throw new InvalidPayloadError({ reason: `Provided snapshot's vendor ${snapshot.vendor} does not match the current instance's vendor ${currentVendor}. You can bypass this check by passing the "force" query parameter` });
-	}
+	if (snapshot.vendor !== currentVendor) throw new InvalidPayloadError({ reason: `Provided snapshot's vendor ${snapshot.vendor} does not match the current instance's vendor ${currentVendor}. You can bypass this check by passing the "force" query parameter` });
 }
 
 //#endregion

package/dist/utils/validate-storage.js

@@ -10,27 +10,20 @@ import { constants } from "fs";
 async function validateStorage() {
 	const env = useEnv();
 	const logger = useLogger();
-	if (env["DB_CLIENT"] === "sqlite3") {
-		try {
-			await access(path.dirname(env["DB_FILENAME"]), constants.R_OK | constants.W_OK);
-		} catch {
-			logger.warn(`Directory for SQLite database file (${path.resolve(path.dirname(env["DB_FILENAME"]))}) is not read/writeable!`);
-		}
+	if (env["DB_CLIENT"] === "sqlite3") try {
+		await access(path.dirname(env["DB_FILENAME"]), constants.R_OK | constants.W_OK);
+	} catch {
+		logger.warn(`Directory for SQLite database file (${path.resolve(path.dirname(env["DB_FILENAME"]))}) is not read/writeable!`);
 	}
-	const usedStorageDrivers = toArray(env["STORAGE_LOCATIONS"]).map((location) => env[`STORAGE_${location.toUpperCase()}_DRIVER`]);
-	if (usedStorageDrivers.includes("local")) {
-		try {
-			await access(env["STORAGE_LOCAL_ROOT"], constants.R_OK | constants.W_OK);
-		} catch {
-			logger.warn(`Upload directory (${path.resolve(env["STORAGE_LOCAL_ROOT"])}) is not read/writeable!`);
-		}
+	if (toArray(env["STORAGE_LOCATIONS"]).map((location) => env[`STORAGE_${location.toUpperCase()}_DRIVER`]).includes("local")) try {
+		await access(env["STORAGE_LOCAL_ROOT"], constants.R_OK | constants.W_OK);
+	} catch {
+		logger.warn(`Upload directory (${path.resolve(env["STORAGE_LOCAL_ROOT"])}) is not read/writeable!`);
 	}
-	if (!env["EXTENSIONS_LOCATION"]) {
-		try {
-			await access(getExtensionsPath(), constants.R_OK);
-		} catch {
-			logger.warn(`Extensions directory (${path.resolve(getExtensionsPath())}) is not readable!`);
-		}
+	if (!env["EXTENSIONS_LOCATION"]) try {
+		await access(getExtensionsPath(), constants.R_OK);
+	} catch {
+		logger.warn(`Extensions directory (${path.resolve(getExtensionsPath())}) is not readable!`);
 	}
 }
 

package/dist/utils/validate-user-count-integrity.js

@@ -9,20 +9,14 @@ async function validateUserCountIntegrity(options) {
 	const validateUserLimits = (options.flags & UserIntegrityCheckFlag.UserLimits) !== 0;
 	const validateRemainingAdminUsers = (options.flags & UserIntegrityCheckFlag.RemainingAdmins) !== 0;
 	const limitCheck = validateUserLimits && shouldCheckUserLimits();
-	if (!validateRemainingAdminUsers && !limitCheck) {
-		return;
-	}
+	if (!validateRemainingAdminUsers && !limitCheck) return;
 	const adminOnly = validateRemainingAdminUsers && !limitCheck;
 	const userCounts = await fetchUserCount({
 		...options,
 		adminOnly
 	});
-	if (limitCheck) {
-		await checkUserLimits(userCounts);
-	}
-	if (validateRemainingAdminUsers) {
-		validateRemainingAdminCount(userCounts.admin);
-	}
+	if (limitCheck) await checkUserLimits(userCounts);
+	if (validateRemainingAdminUsers) validateRemainingAdminCount(userCounts.admin);
 }
 
 //#endregion

package/dist/utils/verify-session-jwt.js

@@ -8,15 +8,11 @@ import { InvalidCredentialsError } from "@directus/errors";
 * @throws If session not found.
 */
 async function verifySessionJWT(payload) {
-	const database = database_default();
-	const session = await database.select(1).from("directus_sessions").where({
+	if (!await database_default().select(1).from("directus_sessions").where({
 		token: payload["session"],
 		user: payload["id"] || null,
 		share: payload["share"] || null
-	}).andWhere("expires", ">=", new Date()).first();
-	if (!session) {
-		throw new InvalidCredentialsError();
-	}
+	}).andWhere("expires", ">=", /* @__PURE__ */ new Date()).first()) throw new InvalidCredentialsError();
 }
 
 //#endregion

package/dist/utils/versioning/handle-version.js

@@ -9,15 +9,12 @@ async function handleVersion(self, key, queryWithKey, opts) {
 	const { ItemsService } = await import("../../services/items.js");
 	if (queryWithKey.versionRaw) {
 		const originalData = await self.readByQuery(queryWithKey, opts);
-		if (originalData.length === 0) {
-			throw new ForbiddenError();
-		}
-		const versionsService$1 = new VersionsService({
+		if (originalData.length === 0) throw new ForbiddenError();
+		const version$1 = await new VersionsService({
 			schema: self.schema,
 			accountability: self.accountability,
 			knex: self.knex
-		});
-		const version$1 = await versionsService$1.getVersionSave(queryWithKey.version, self.collection, key);
+		}).getVersionSave(queryWithKey.version, self.collection, key);
 		return Object.assign(originalData[0], version$1?.delta);
 	}
 	let result;
@@ -28,9 +25,7 @@ async function handleVersion(self, key, queryWithKey, opts) {
 	});
 	const createdIDs = {};
 	const version = await versionsService.getVersionSave(queryWithKey.version, self.collection, key, false);
-	if (!version) {
-		throw new ForbiddenError();
-	}
+	if (!version) throw new ForbiddenError();
 	const { delta } = version;
 	await transaction(self.knex, async (trx) => {
 		const itemsServiceAdmin = new ItemsService(self.collection, {
@@ -51,40 +46,26 @@ async function handleVersion(self, key, queryWithKey, opts) {
 				}
 			});
 		}
-		const itemsServiceUser = new ItemsService(self.collection, {
+		result = (await new ItemsService(self.collection, {
 			schema: self.schema,
 			accountability: self.accountability,
 			knex: trx
-		});
-		result = (await itemsServiceUser.readByQuery(queryWithKey, opts))[0];
+		}).readByQuery(queryWithKey, opts))[0];
 		await trx.rollback();
 	});
-	if (!result) {
-		throw new ForbiddenError();
-	}
+	if (!result) throw new ForbiddenError();
 	return deepMapWithSchema(result, ([key$1, value], context) => {
 		if (context.relationType === "m2o" || context.relationType === "a2o") {
-			const ids = createdIDs[context.relation.related_collection];
-			const match = ids?.find((id) => String(id) === String(value));
-			if (match) {
-				return [key$1, null];
-			}
+			if (createdIDs[context.relation.related_collection]?.find((id) => String(id) === String(value))) return [key$1, null];
 		} else if (context.relationType === "o2m" && Array.isArray(value)) {
 			const ids = createdIDs[context.relation.collection];
 			return [key$1, value.map((val) => {
-				const match = ids?.find((id) => String(id) === String(val));
-				if (match) {
-					return null;
-				}
+				if (ids?.find((id) => String(id) === String(val))) return null;
 				return val;
 			})];
 		}
 		if (context.field.field === context.collection.primary) {
-			const ids = createdIDs[context.collection.collection];
-			const match = ids?.find((id) => String(id) === String(value));
-			if (match) {
-				return [key$1, null];
-			}
+			if (createdIDs[context.collection.collection]?.find((id) => String(id) === String(value))) return [key$1, null];
 		}
 		return [key$1, value];
 	}, {

package/dist/utils/versioning/merge-version-data.js

@@ -3,11 +3,7 @@ import { cloneDeep } from "lodash-es";
 //#region src/utils/versioning/merge-version-data.ts
 function mergeVersionsRaw(item, versionData) {
 	const result = cloneDeep(item);
-	for (const versionRecord of versionData) {
-		for (const key of Object.keys(versionRecord)) {
-			result[key] = versionRecord[key];
-		}
-	}
+	for (const versionRecord of versionData) for (const key of Object.keys(versionRecord)) result[key] = versionRecord[key];
 	return result;
 }
 

package/dist/utils/versioning/split-recursive.js

@@ -12,6 +12,10 @@ function splitRecursive(object) {
 			const { rawDelta, defaultOverwrites: innerDefaultOverwrites } = splitRecursive(rest[key]);
 			rest[key] = rawDelta;
 			if (innerDefaultOverwrites) defaultOverwrites[key] = innerDefaultOverwrites;
+			else if (Array.isArray(rest[key]) && _user !== void 0 && _date !== void 0) defaultOverwrites[key] = {
+				_user,
+				_date
+			};
 		}
 		return {
 			rawDelta: rest,
@@ -25,15 +29,14 @@ function splitRecursive(object) {
 			rest[key] = rawDelta;
 			if (innerDefaultOverwrites) defaultOverwrites[key] = innerDefaultOverwrites;
 		}
-		object.map((value) => splitRecursive(value));
 		return {
 			rawDelta: rest,
-			defaultOverwrites
+			defaultOverwrites: defaultOverwrites.length > 0 ? defaultOverwrites : void 0
 		};
 	}
 	return {
 		rawDelta: object,
-		defaultOverwrites: undefined
+		defaultOverwrites: void 0
 	};
 }
 

package/dist/websocket/authenticate.js

@@ -15,20 +15,16 @@ async function authenticateConnection(message, accountabilityOverrides) {
 	let access_token, refresh_token;
 	try {
 		if ("email" in message && "password" in message) {
-			const authenticationService = new AuthenticationService({ schema: await getSchema() });
-			const { accessToken, refreshToken } = await authenticationService.login(DEFAULT_AUTH_PROVIDER, message);
+			const { accessToken, refreshToken } = await new AuthenticationService({ schema: await getSchema() }).login(DEFAULT_AUTH_PROVIDER, message);
 			access_token = accessToken;
 			refresh_token = refreshToken;
 		}
 		if ("refresh_token" in message) {
-			const authenticationService = new AuthenticationService({ schema: await getSchema() });
-			const { accessToken, refreshToken } = await authenticationService.refresh(message.refresh_token);
+			const { accessToken, refreshToken } = await new AuthenticationService({ schema: await getSchema() }).refresh(message.refresh_token);
 			access_token = accessToken;
 			refresh_token = refreshToken;
 		}
-		if ("access_token" in message) {
-			access_token = message.access_token;
-		}
+		if ("access_token" in message) access_token = message.access_token;
 		if (!access_token) throw new Error();
 		const defaultAccountability = createDefaultAccountability(accountabilityOverrides);
 		const authenticationState = {
@@ -41,11 +37,8 @@ async function authenticateConnection(message, accountabilityOverrides) {
 			schema: null,
 			accountability: null
 		});
-		if (customAccountability && isEqual(customAccountability, defaultAccountability) === false) {
-			authenticationState.accountability = customAccountability;
-		} else {
-			authenticationState.accountability = await getAccountabilityForToken(access_token, defaultAccountability);
-		}
+		if (customAccountability && isEqual(customAccountability, defaultAccountability) === false) authenticationState.accountability = customAccountability;
+		else authenticationState.accountability = await getAccountabilityForToken(access_token, defaultAccountability);
 		return authenticationState;
 	} catch {
 		throw new WebSocketError("auth", "AUTH_FAILED", "Authentication failed.", message["uid"]);
@@ -56,12 +49,8 @@ function authenticationSuccess(uid, refresh_token) {
 		type: "auth",
 		status: "ok"
 	};
-	if (uid !== undefined) {
-		message.uid = uid;
-	}
-	if (refresh_token !== undefined) {
-		message["refresh_token"] = refresh_token;
-	}
+	if (uid !== void 0) message.uid = uid;
+	if (refresh_token !== void 0) message["refresh_token"] = refresh_token;
 	return JSON.stringify(message);
 }
 

package/dist/websocket/collab/calculate-cache-metadata.js

@@ -13,51 +13,41 @@ const DYNAMIC_VARIABLE_MAP = {
 */
 function calculateCacheMetadata(collection, itemData, rawPermissions, schema, accountability) {
 	let ttlMs;
-	const dependencies = new Set();
+	const dependencies = /* @__PURE__ */ new Set();
 	if (itemData) {
 		const now = Date.now();
 		let closestExpiry = Infinity;
 		const scan = (val, fieldKey, currentCollection = collection) => {
 			if (!val || typeof val !== "object") return;
 			for (const [key, value] of Object.entries(val)) {
-				if (typeof value === "string" && value.startsWith("$")) {
-					if (value.startsWith("$NOW")) {
-						const field$1 = fieldKey || key;
-						const dateValue = itemData[field$1];
-						if (dateValue) {
-							let ruleDate = new Date();
-							if (value.includes("(")) {
-								const adjustment = value.match(REGEX_BETWEEN_PARENS)?.[1];
-								if (adjustment) ruleDate = adjustDate(ruleDate, adjustment) || ruleDate;
-							}
-							const adjustmentMs = ruleDate.getTime() - now;
-							const expiry = new Date(dateValue).getTime() - adjustmentMs;
-							if (expiry > now && expiry < closestExpiry) {
-								closestExpiry = expiry;
-							}
+				if (typeof value === "string" && value.startsWith("$")) if (value.startsWith("$NOW")) {
+					const dateValue = itemData[fieldKey || key];
+					if (dateValue) {
+						let ruleDate = /* @__PURE__ */ new Date();
+						if (value.includes("(")) {
+							const adjustment = value.match(REGEX_BETWEEN_PARENS)?.[1];
+							if (adjustment) ruleDate = adjustDate(ruleDate, adjustment) || ruleDate;
 						}
-					} else {
-						const parts = value.split(".");
-						const dynamicVariable = parts[0];
-						const rootCollection = DYNAMIC_VARIABLE_MAP[dynamicVariable];
-						if (rootCollection) {
-							if (dynamicVariable === "$CURRENT_USER" && accountability.user) {
-								dependencies.add(`${rootCollection}:${accountability.user}`);
-							} else {
-								dependencies.add(rootCollection);
-							}
-							if (parts.length > 1) {
-								let currentCollection$1 = rootCollection;
-								for (const segment of parts.slice(1, -1)) {
-									if (!currentCollection$1) break;
-									const relation = schema.relations.find((r) => r.collection === currentCollection$1 && r.field === segment || r.related_collection === currentCollection$1 && r.meta?.one_field === segment);
-									if (relation) {
-										currentCollection$1 = relation.collection === currentCollection$1 ? relation.related_collection : relation.collection;
-										if (currentCollection$1) dependencies.add(currentCollection$1);
-									} else {
-										currentCollection$1 = null;
-									}
-								}
+						const adjustmentMs = ruleDate.getTime() - now;
+						const expiry = new Date(dateValue).getTime() - adjustmentMs;
+						if (expiry > now && expiry < closestExpiry) closestExpiry = expiry;
+					}
+				} else {
+					const parts = value.split(".");
+					const dynamicVariable = parts[0];
+					const rootCollection = DYNAMIC_VARIABLE_MAP[dynamicVariable];
+					if (rootCollection) {
+						if (dynamicVariable === "$CURRENT_USER" && accountability.user) dependencies.add(`${rootCollection}:${accountability.user}`);
+						else dependencies.add(rootCollection);
+						if (parts.length > 1) {
+							let currentCollection$1 = rootCollection;
+							for (const segment of parts.slice(1, -1)) {
+								if (!currentCollection$1) break;
+								const relation = schema.relations.find((r) => r.collection === currentCollection$1 && r.field === segment || r.related_collection === currentCollection$1 && r.meta?.one_field === segment);
+								if (relation) {
+									currentCollection$1 = relation.collection === currentCollection$1 ? relation.related_collection : relation.collection;
+									if (currentCollection$1) dependencies.add(currentCollection$1);
+								} else currentCollection$1 = null;
 							}
 						}
 					}
@@ -70,23 +60,15 @@ function calculateCacheMetadata(collection, itemData, rawPermissions, schema, ac
 				if (!field.startsWith("_")) {
 					const relation = schema.relations.find((r) => r.collection === currentCollection && r.field === field || r.related_collection === currentCollection && r.meta?.one_field === field);
 					let targetCol = null;
-					if (relation) {
-						targetCol = relation.collection === currentCollection ? relation.related_collection : relation.collection;
-					}
+					if (relation) targetCol = relation.collection === currentCollection ? relation.related_collection : relation.collection;
 					if (targetCol) {
 						dependencies.add(targetCol);
-						scan(value, undefined, targetCol);
-					} else {
-						scan(value, field.startsWith("_") ? fieldKey : field, currentCollection);
-					}
-				} else {
-					scan(value, fieldKey, currentCollection);
-				}
+						scan(value, void 0, targetCol);
+					} else scan(value, field.startsWith("_") ? fieldKey : field, currentCollection);
+				} else scan(value, fieldKey, currentCollection);
 			}
 		};
-		for (const permission of rawPermissions) {
-			scan(permission.permissions);
-		}
+		for (const permission of rawPermissions) scan(permission.permissions);
 		if (closestExpiry !== Infinity) {
 			ttlMs = closestExpiry - now;
 			ttlMs = Math.max(1e3, Math.min(ttlMs, 36e5));