@directus/api 35.0.2 → 35.1.0

package/dist/utils/redact-object.js

@@ -14,14 +14,10 @@ import { isObject } from "@directus/utils";
 function redactObject(input, redact, replacement) {
 	const wildcardChars = ["*", "**"];
 	const clone = JSON.parse(JSON.stringify(input, getReplacer(replacement, redact.values)));
-	if (redact.keys) {
-		traverse(clone, redact.keys);
-	}
+	if (redact.keys) traverse(clone, redact.keys);
 	return clone;
 	function traverse(object, checkKeyPaths) {
-		if (checkKeyPaths.length === 0) {
-			return;
-		}
+		if (checkKeyPaths.length === 0) return;
 		const REDACTED_TEXT$1 = replacement();
 		const globalCheckPaths = [];
 		for (const key of Object.keys(object)) {
@@ -31,9 +27,8 @@ function redactObject(input, redact, replacement) {
 				const escapedKey = wildcardChars.includes(key) ? `\\${key}` : key;
 				switch (current) {
 					case escapedKey:
-						if (remaining.length > 0) {
-							localCheckPaths.push(remaining);
-						} else {
+						if (remaining.length > 0) localCheckPaths.push(remaining);
+						else {
 							object[key] = REDACTED_TEXT$1;
 							checkKeyPaths.splice(index, 1);
 						}
@@ -42,34 +37,21 @@ function redactObject(input, redact, replacement) {
 						if (remaining.length > 0) {
 							globalCheckPaths.push(remaining);
 							checkKeyPaths.splice(index, 1);
-						} else {
-							object[key] = REDACTED_TEXT$1;
-						}
+						} else object[key] = REDACTED_TEXT$1;
 						break;
 					case "**":
 						if (remaining.length > 0) {
 							const [next, ...nextRemaining] = remaining;
-							if (next === escapedKey) {
-								if (nextRemaining.length === 0) {
-									object[key] = REDACTED_TEXT$1;
-								} else {
-									localCheckPaths.push(nextRemaining);
-								}
-							} else if (next !== undefined && wildcardChars.includes(next)) {
-								localCheckPaths.push(remaining);
-							} else {
-								localCheckPaths.push(path);
-							}
-						} else {
-							object[key] = REDACTED_TEXT$1;
-						}
+							if (next === escapedKey) if (nextRemaining.length === 0) object[key] = REDACTED_TEXT$1;
+							else localCheckPaths.push(nextRemaining);
+							else if (next !== void 0 && wildcardChars.includes(next)) localCheckPaths.push(remaining);
+							else localCheckPaths.push(path);
+						} else object[key] = REDACTED_TEXT$1;
 						break;
 				}
 			}
 			const value = object[key];
-			if (isObject(value)) {
-				traverse(value, [...globalCheckPaths, ...localCheckPaths]);
-			}
+			if (isObject(value)) traverse(value, [...globalCheckPaths, ...localCheckPaths]);
 		}
 	}
 }
@@ -78,45 +60,33 @@ function redactObject(input, redact, replacement) {
 */
 function getReplacer(replacement, values) {
 	const filteredValues = values ? Object.entries(values).filter(([_k, v]) => typeof v === "string" && v.length > 0) : [];
-	const replacer = (seen$1) => {
+	const replacer = (seen) => {
 		return function(_key, value) {
-			if (value instanceof Error) {
-				return {
-					name: value.name,
-					message: value.message,
-					stack: value.stack,
-					cause: value.cause
-				};
-			}
+			if (value instanceof Error) return {
+				name: value.name,
+				message: value.message,
+				stack: value.stack,
+				cause: value.cause
+			};
 			if (value !== null && typeof value === "object") {
-				if (seen$1.has(value)) {
-					return "[Circular]";
-				}
-				seen$1.add(value);
+				if (seen.has(value)) return "[Circular]";
+				seen.add(value);
 				const newValue = Array.isArray(value) ? [] : {};
-				for (const [key2, value2] of Object.entries(value)) {
-					if (typeof value2 === "string") {
-						newValue[key2] = value2;
-					} else {
-						newValue[key2] = replacer(seen$1)(key2, value2);
-					}
-				}
-				seen$1.delete(value);
+				for (const [key2, value2] of Object.entries(value)) if (typeof value2 === "string") newValue[key2] = value2;
+				else newValue[key2] = replacer(seen)(key2, value2);
+				seen.delete(value);
 				return newValue;
 			}
 			if (!values || filteredValues.length === 0 || typeof value !== "string") return value;
 			let finalValue = value;
-			for (const [redactKey, valueToRedact] of filteredValues) {
-				if (finalValue.includes(valueToRedact)) {
-					const regexp = new RegExp(escapeRegexString(valueToRedact), "g");
-					finalValue = finalValue.replace(regexp, replacement(redactKey));
-				}
+			for (const [redactKey, valueToRedact] of filteredValues) if (finalValue.includes(valueToRedact)) {
+				const regexp = new RegExp(escapeRegexString(valueToRedact), "g");
+				finalValue = finalValue.replace(regexp, replacement(redactKey));
 			}
 			return finalValue;
 		};
 	};
-	const seen = new WeakSet();
-	return replacer(seen);
+	return replacer(/* @__PURE__ */ new WeakSet());
 }
 function escapeRegexString(string) {
 	return string.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");

package/dist/utils/reduce-schema.js

@@ -9,18 +9,11 @@ function reduceSchema(schema, fieldMap) {
 		relations: []
 	};
 	for (const [collectionName, collection] of Object.entries(schema.collections)) {
-		if (!fieldMap[collectionName]) {
-			continue;
-		}
+		if (!fieldMap[collectionName]) continue;
 		const fields = {};
 		for (const [fieldName, field] of Object.entries(schema.collections[collectionName].fields)) {
-			if (!fieldMap[collectionName]?.includes("*") && !fieldMap[collectionName]?.includes(fieldName)) {
-				continue;
-			}
-			const o2mRelation = schema.relations.find((relation) => relation.related_collection === collectionName && relation.meta?.one_field === fieldName);
-			if (o2mRelation && !fieldMap[collectionName]) {
-				continue;
-			}
+			if (!fieldMap[collectionName]?.includes("*") && !fieldMap[collectionName]?.includes(fieldName)) continue;
+			if (schema.relations.find((relation) => relation.related_collection === collectionName && relation.meta?.one_field === fieldName) && !fieldMap[collectionName]) continue;
 			fields[fieldName] = field;
 		}
 		reduced.collections[collectionName] = {
@@ -31,21 +24,11 @@ function reduceSchema(schema, fieldMap) {
 	reduced.relations = schema.relations.filter((relation) => {
 		let collectionsAllowed = true;
 		let fieldsAllowed = true;
-		if (Object.keys(fieldMap).includes(relation.collection) === false) {
-			collectionsAllowed = false;
-		}
-		if (relation.related_collection && (Object.keys(fieldMap).includes(relation.related_collection) === false || fieldMap[relation.related_collection]?.length === 0)) {
-			collectionsAllowed = false;
-		}
-		if (relation.meta?.one_allowed_collections && relation.meta.one_allowed_collections.every((collection) => Object.keys(fieldMap).includes(collection)) === false) {
-			collectionsAllowed = false;
-		}
-		if (!fieldMap[relation.collection] || fieldMap[relation.collection]?.includes("*") === false && fieldMap[relation.collection]?.includes(relation.field) === false) {
-			fieldsAllowed = false;
-		}
-		if (relation.related_collection && relation.meta?.one_field && (!fieldMap[relation.related_collection] || fieldMap[relation.related_collection]?.includes("*") === false && fieldMap[relation.related_collection]?.includes(relation.meta?.one_field) === false)) {
-			fieldsAllowed = false;
-		}
+		if (Object.keys(fieldMap).includes(relation.collection) === false) collectionsAllowed = false;
+		if (relation.related_collection && (Object.keys(fieldMap).includes(relation.related_collection) === false || fieldMap[relation.related_collection]?.length === 0)) collectionsAllowed = false;
+		if (relation.meta?.one_allowed_collections && relation.meta.one_allowed_collections.every((collection) => Object.keys(fieldMap).includes(collection)) === false) collectionsAllowed = false;
+		if (!fieldMap[relation.collection] || fieldMap[relation.collection]?.includes("*") === false && fieldMap[relation.collection]?.includes(relation.field) === false) fieldsAllowed = false;
+		if (relation.related_collection && relation.meta?.one_field && (!fieldMap[relation.related_collection] || fieldMap[relation.related_collection]?.includes("*") === false && fieldMap[relation.related_collection]?.includes(relation.meta?.one_field) === false)) fieldsAllowed = false;
 		return collectionsAllowed && fieldsAllowed;
 	});
 	return reduced;

package/dist/utils/sanitize-query.js

@@ -5,7 +5,6 @@ import { fetchDynamicVariableData } from "../permissions/utils/fetch-dynamic-var
 import { fetchPolicies } from "../permissions/lib/fetch-policies.js";
 import { contextHasDynamicVariables } from "../permissions/modules/process-ast/utils/context-has-dynamic-variables.js";
 import { Meta } from "../types/meta.js";
-import "../types/index.js";
 import { splitFields } from "./split-fields.js";
 import { useEnv } from "@directus/env";
 import { InvalidQueryError } from "@directus/errors";
@@ -20,70 +19,42 @@ async function sanitizeQuery(rawQuery, schema, accountability) {
 	const env = useEnv();
 	const query = {};
 	const hasMaxLimit = "QUERY_LIMIT_MAX" in env && Number(env["QUERY_LIMIT_MAX"]) >= 0 && !Number.isNaN(Number(env["QUERY_LIMIT_MAX"])) && Number.isFinite(Number(env["QUERY_LIMIT_MAX"]));
-	if (rawQuery["limit"] !== undefined) {
+	if (rawQuery["limit"] !== void 0) {
 		const limit = sanitizeLimit(rawQuery["limit"]);
-		if (typeof limit === "number") {
-			query.limit = limit === -1 && hasMaxLimit ? Number(env["QUERY_LIMIT_MAX"]) : limit;
-		}
-	} else if (hasMaxLimit) {
-		query.limit = Math.min(Number(env["QUERY_LIMIT_DEFAULT"]), Number(env["QUERY_LIMIT_MAX"]));
-	}
-	if (rawQuery["fields"]) {
-		query.fields = sanitizeFields(rawQuery["fields"]);
-	}
-	if (rawQuery["groupBy"]) {
-		query.group = sanitizeFields(rawQuery["groupBy"]);
-	}
-	if (rawQuery["aggregate"]) {
-		query.aggregate = sanitizeAggregate(rawQuery["aggregate"]);
-	}
-	if (rawQuery["sort"]) {
-		query.sort = sanitizeSort(rawQuery["sort"]);
-	}
-	if (rawQuery["filter"]) {
-		query.filter = await sanitizeFilter(rawQuery["filter"], schema, accountability || null);
-	}
-	if (rawQuery["offset"] !== undefined) {
-		query.offset = sanitizeOffset(rawQuery["offset"]);
-	}
-	if (rawQuery["page"]) {
-		query.page = sanitizePage(rawQuery["page"]);
-	}
-	if (rawQuery["meta"]) {
-		query.meta = sanitizeMeta(rawQuery["meta"]);
-	}
+		if (typeof limit === "number") query.limit = limit === -1 && hasMaxLimit ? Number(env["QUERY_LIMIT_MAX"]) : limit;
+	} else if (hasMaxLimit) query.limit = Math.min(Number(env["QUERY_LIMIT_DEFAULT"]), Number(env["QUERY_LIMIT_MAX"]));
+	if (rawQuery["fields"]) query.fields = sanitizeFields(rawQuery["fields"]);
+	if (rawQuery["groupBy"]) query.group = sanitizeFields(rawQuery["groupBy"]);
+	if (rawQuery["aggregate"]) query.aggregate = sanitizeAggregate(rawQuery["aggregate"]);
+	if (rawQuery["sort"]) query.sort = sanitizeSort(rawQuery["sort"]);
+	if (rawQuery["filter"]) query.filter = await sanitizeFilter(rawQuery["filter"], schema, accountability || null);
+	if (rawQuery["offset"] !== void 0) query.offset = sanitizeOffset(rawQuery["offset"]);
+	if (rawQuery["page"]) query.page = sanitizePage(rawQuery["page"]);
+	if (rawQuery["meta"]) query.meta = sanitizeMeta(rawQuery["meta"]);
 	if (rawQuery["search"] && typeof rawQuery["search"] === "string") {
-		query.search = rawQuery["search"];
+		const trimmed = rawQuery["search"].trim();
+		if (trimmed) query.search = trimmed;
+		else query.search = rawQuery["search"];
 	}
 	if (rawQuery["version"]) {
 		query.version = rawQuery["version"];
 		query.versionRaw = Boolean("versionRaw" in rawQuery && (rawQuery["versionRaw"] === "" || rawQuery["versionRaw"] === "true"));
 	}
-	if (rawQuery["export"]) {
-		query.export = rawQuery["export"];
-	}
+	if (rawQuery["export"]) query.export = rawQuery["export"];
 	if (rawQuery["deep"]) {
 		if (!query.deep) query.deep = {};
 		query.deep = await sanitizeDeep(rawQuery["deep"], schema, accountability);
 	}
-	if (rawQuery["alias"]) {
-		query.alias = sanitizeAlias(rawQuery["alias"]);
-	}
-	if ("backlink" in rawQuery) {
-		query.backlink = sanitizeBacklink(rawQuery["backlink"]);
-	}
+	if (rawQuery["alias"]) query.alias = sanitizeAlias(rawQuery["alias"]);
+	if ("backlink" in rawQuery) query.backlink = sanitizeBacklink(rawQuery["backlink"]);
 	return query;
 }
 function sanitizeFields(rawFields) {
 	if (!rawFields) return null;
 	let fields = [];
-	if (typeof rawFields === "string") {
-		fields = splitFields(rawFields);
-	} else if (Array.isArray(rawFields)) {
-		fields = rawFields;
-	} else {
-		throw new InvalidQueryError({ reason: "\"fields\" must be a string or array" });
-	}
+	if (typeof rawFields === "string") fields = splitFields(rawFields);
+	else if (Array.isArray(rawFields)) fields = rawFields;
+	else throw new InvalidQueryError({ reason: "\"fields\" must be a string or array" });
 	fields = flatten(fields.map((field) => field.includes(",") ? splitFields(field) : field));
 	fields = fields.map((field) => field.trim());
 	return fields;
@@ -98,27 +69,21 @@ function sanitizeSort(rawSort) {
 function sanitizeAggregate(rawAggregate) {
 	const logger = useLogger();
 	let aggregate = rawAggregate;
-	if (typeof rawAggregate === "string") {
-		try {
-			aggregate = parseJSON(rawAggregate);
-		} catch {
-			logger.warn("Invalid value passed for aggregate query parameter.");
-		}
-	}
-	for (const [operation, fields] of Object.entries(aggregate)) {
-		if (typeof fields === "string") aggregate[operation] = fields.split(",");
-		else if (Array.isArray(fields)) aggregate[operation] = fields;
+	if (typeof rawAggregate === "string") try {
+		aggregate = parseJSON(rawAggregate);
+	} catch {
+		logger.warn("Invalid value passed for aggregate query parameter.");
 	}
+	for (const [operation, fields] of Object.entries(aggregate)) if (typeof fields === "string") aggregate[operation] = fields.split(",");
+	else if (Array.isArray(fields)) aggregate[operation] = fields;
 	return aggregate;
 }
 async function sanitizeFilter(rawFilter, schema, accountability) {
 	let filters = rawFilter;
-	if (typeof filters === "string") {
-		try {
-			filters = parseJSON(filters);
-		} catch {
-			throw new InvalidQueryError({ reason: "Invalid JSON for filter object" });
-		}
+	if (typeof filters === "string") try {
+		filters = parseJSON(filters);
+	} catch {
+		throw new InvalidQueryError({ reason: "Invalid JSON for filter object" });
 	}
 	try {
 		let filterContext;
@@ -144,7 +109,7 @@ async function sanitizeFilter(rawFilter, schema, accountability) {
 	}
 }
 function sanitizeLimit(rawLimit) {
-	if (rawLimit === undefined || rawLimit === null) return null;
+	if (rawLimit === void 0 || rawLimit === null) return null;
 	return Number(rawLimit);
 }
 function sanitizeOffset(rawOffset) {
@@ -154,15 +119,9 @@ function sanitizePage(rawPage) {
 	return Number(rawPage);
 }
 function sanitizeMeta(rawMeta) {
-	if (rawMeta === "*") {
-		return Object.values(Meta);
-	}
-	if (rawMeta.includes(",")) {
-		return rawMeta.split(",");
-	}
-	if (Array.isArray(rawMeta)) {
-		return rawMeta;
-	}
+	if (rawMeta === "*") return Object.values(Meta);
+	if (rawMeta.includes(",")) return rawMeta.split(",");
+	if (Array.isArray(rawMeta)) return rawMeta;
 	return [rawMeta];
 }
 function sanitizeBacklink(rawBacklink) {
@@ -171,12 +130,10 @@ function sanitizeBacklink(rawBacklink) {
 async function sanitizeDeep(deep, schema, accountability) {
 	const logger = useLogger();
 	const result = {};
-	if (typeof deep === "string") {
-		try {
-			deep = parseJSON(deep);
-		} catch {
-			logger.warn("Invalid value passed for deep query parameter.");
-		}
+	if (typeof deep === "string") try {
+		deep = parseJSON(deep);
+	} catch {
+		logger.warn("Invalid value passed for deep query parameter.");
 	}
 	await parse(deep);
 	return result;
@@ -185,32 +142,23 @@ async function sanitizeDeep(deep, schema, accountability) {
 		const parsedLevel = {};
 		for (const [key, value] of Object.entries(level)) {
 			if (!key) break;
-			if (key.startsWith("_")) {
-				subQuery[key.substring(1)] = value;
-			} else if (isPlainObject(value)) {
-				parse(value, [...path, key]);
-			}
+			if (key.startsWith("_")) subQuery[key.substring(1)] = value;
+			else if (isPlainObject(value)) parse(value, [...path, key]);
 		}
 		if (Object.keys(subQuery).length > 0) {
 			const parsedSubQuery = await sanitizeQuery(subQuery, schema, accountability);
-			for (const [parsedKey, parsedValue] of Object.entries(parsedSubQuery)) {
-				parsedLevel[`_${parsedKey}`] = parsedValue;
-			}
-		}
-		if (Object.keys(parsedLevel).length > 0) {
-			set(result, path, merge({}, get(result, path, {}), parsedLevel));
+			for (const [parsedKey, parsedValue] of Object.entries(parsedSubQuery)) parsedLevel[`_${parsedKey}`] = parsedValue;
 		}
+		if (Object.keys(parsedLevel).length > 0) set(result, path, merge({}, get(result, path, {}), parsedLevel));
 	}
 }
 function sanitizeAlias(rawAlias) {
 	const logger = useLogger();
 	let alias = rawAlias;
-	if (typeof rawAlias === "string") {
-		try {
-			alias = parseJSON(rawAlias);
-		} catch {
-			logger.warn("Invalid value passed for alias query parameter.");
-		}
+	if (typeof rawAlias === "string") try {
+		alias = parseJSON(rawAlias);
+	} catch {
+		logger.warn("Invalid value passed for alias query parameter.");
 	}
 	return alias;
 }

package/dist/utils/sanitize-schema.js

@@ -31,7 +31,7 @@ function sanitizeField(field, sanitizeAllSchema = false) {
 		"name",
 		"children"
 	];
-	const pickedPaths = sanitizeAllSchema ? defaultPaths : [
+	return pick(field, sanitizeAllSchema ? defaultPaths : [
 		...defaultPaths,
 		"schema.name",
 		"schema.table",
@@ -49,8 +49,7 @@ function sanitizeField(field, sanitizeAllSchema = false) {
 		"schema.has_auto_increment",
 		"schema.foreign_key_table",
 		"schema.foreign_key_column"
-	];
-	return pick(field, pickedPaths);
+	]);
 }
 function sanitizeColumn(column) {
 	return pick(column, [

package/dist/utils/schedule.js

@@ -10,12 +10,8 @@ function scheduleSynchronizedJob(id, rule, cb) {
 	const job = CronJob.from({
 		cronTime: rule,
 		onTick: async (fireDate) => {
-			const nextDate = job.nextDate();
-			const nextTimestamp = nextDate.toMillis();
-			const wasSet = await clock.set(nextTimestamp);
-			if (wasSet) {
-				await cb(fireDate);
-			}
+			const nextTimestamp = job.nextDate().toMillis();
+			if (await clock.set(nextTimestamp)) await cb(fireDate);
 		},
 		start: true
 	});

package/dist/utils/should-clear-cache.js

@@ -11,12 +11,8 @@ import { useEnv } from "@directus/env";
 function shouldClearCache(cache, opts, collection) {
 	const env = useEnv();
 	if (env["CACHE_AUTO_PURGE"]) {
-		if (collection && env["CACHE_AUTO_PURGE_IGNORE_LIST"].includes(collection)) {
-			return false;
-		}
-		if (cache && opts?.autoPurgeCache !== false) {
-			return true;
-		}
+		if (collection && env["CACHE_AUTO_PURGE_IGNORE_LIST"].includes(collection)) return false;
+		if (cache && opts?.autoPurgeCache !== false) return true;
 	}
 	return false;
 }

package/dist/utils/should-skip-cache.js

@@ -15,11 +15,8 @@ function shouldSkipCache(req) {
 	if (referer) {
 		const adminUrl = new Url(env["PUBLIC_URL"]).addPath("admin");
 		if (adminUrl.isRootRelative()) {
-			const refererUrl = new Url(referer);
-			if (refererUrl.path.join("/").startsWith(adminUrl.path.join("/")) && checkAutoPurge()) return true;
-		} else if (referer.startsWith(adminUrl.toString()) && checkAutoPurge()) {
-			return true;
-		}
+			if (new Url(referer).path.join("/").startsWith(adminUrl.path.join("/")) && checkAutoPurge()) return true;
+		} else if (referer.startsWith(adminUrl.toString()) && checkAutoPurge()) return true;
 	}
 	if (env["CACHE_SKIP_ALLOWED"] && req.get("cache-control")?.includes("no-store")) return true;
 	return false;
@@ -29,9 +26,7 @@ function shouldSkipCache(req) {
 		if (!path) return false;
 		for (const collection of env["CACHE_AUTO_PURGE_IGNORE_LIST"]) {
 			const ignoredPath = getEndpoint(collection);
-			if (path.startsWith(ignoredPath)) {
-				return true;
-			}
+			if (path.startsWith(ignoredPath)) return true;
 		}
 		return false;
 	}

package/dist/utils/split-fields.js

@@ -11,22 +11,14 @@ function splitFields(input) {
 	for (const char of input) {
 		if (char === "(") {
 			depth++;
-			if (depth > 1) {
-				throw new InvalidQueryError({ reason: "Nested functions are not supported in \"fields\"" });
-			}
-		} else if (char === ")") {
-			depth--;
-		}
+			if (depth > 1) throw new InvalidQueryError({ reason: "Nested functions are not supported in \"fields\"" });
+		} else if (char === ")") depth--;
 		if (char === "," && depth === 0) {
 			fields.push(current);
 			current = "";
-		} else {
-			current += char;
-		}
-	}
-	if (depth !== 0) {
-		throw new InvalidQueryError({ reason: "Missing closing parenthesis in \"fields\"" });
+		} else current += char;
 	}
+	if (depth !== 0) throw new InvalidQueryError({ reason: "Missing closing parenthesis in \"fields\"" });
 	fields.push(current);
 	return fields;
 }

package/dist/utils/stall.js

@@ -27,9 +27,7 @@ import { performance } from "perf_hooks";
 * ```
 */
 async function stall(ms, start) {
-	const now = performance.now();
-	const timeElapsed = now - start;
-	const timeRemaining = ms - timeElapsed;
+	const timeRemaining = ms - (performance.now() - start);
 	if (timeRemaining <= 0) return;
 	return new Promise((resolve) => setTimeout(resolve, timeRemaining));
 }

package/dist/utils/store.js

@@ -8,15 +8,12 @@ import { createCache } from "@directus/memory";
 * Shared memory between multiple instances. Scoped to a provided namespace in redis.
 */
 function useStore(namespace, options) {
-	const localOnly = redisConfigAvailable() === false;
-	const config = localOnly ? { type: "local" } : {
+	const config = redisConfigAvailable() === false ? { type: "local" } : {
 		type: "redis",
 		namespace,
 		redis: useRedis()
 	};
-	if (config.type === "redis" && options?.ttl) {
-		config.ttl = options?.ttl;
-	}
+	if (config.type === "redis" && options?.ttl) config.ttl = options?.ttl;
 	const store = createCache(config);
 	return (callback) => store.usingLock(`lock`, async () => {
 		return await callback({

package/dist/utils/transaction.js

@@ -12,72 +12,43 @@ import "knex";
 * while preventing nested transactions.
 */
 const transaction = async (knex$1, handler) => {
-	if (knex$1.isTransaction) {
-		return handler(knex$1);
-	} else {
-		try {
-			return await knex$1.transaction((trx) => handler(trx));
-		} catch (error) {
-			const client = getDatabaseClient(knex$1);
-			if (!shouldRetryTransaction(client, error)) throw error;
-			const MAX_ATTEMPTS = 3;
-			const BASE_DELAY = 100;
-			const logger = useLogger();
-			for (let attempt = 0; attempt < MAX_ATTEMPTS; ++attempt) {
-				const delay = 2 ** attempt * BASE_DELAY;
-				await new Promise((resolve) => setTimeout(resolve, delay));
-				logger.trace(`Restarting failed transaction (attempt ${attempt + 1}/${MAX_ATTEMPTS})`);
-				try {
-					return await knex$1.transaction((trx) => handler(trx));
-				} catch (error$1) {
-					if (!shouldRetryTransaction(client, error$1)) throw error$1;
-				}
+	if (knex$1.isTransaction) return handler(knex$1);
+	else try {
+		return await knex$1.transaction((trx) => handler(trx));
+	} catch (error) {
+		const client = getDatabaseClient(knex$1);
+		if (!shouldRetryTransaction(client, error)) throw error;
+		const MAX_ATTEMPTS = 3;
+		const BASE_DELAY = 100;
+		const logger = useLogger();
+		for (let attempt = 0; attempt < MAX_ATTEMPTS; ++attempt) {
+			const delay = 2 ** attempt * BASE_DELAY;
+			await new Promise((resolve) => setTimeout(resolve, delay));
+			logger.trace(`Restarting failed transaction (attempt ${attempt + 1}/${MAX_ATTEMPTS})`);
+			try {
+				return await knex$1.transaction((trx) => handler(trx));
+			} catch (error$1) {
+				if (!shouldRetryTransaction(client, error$1)) throw error$1;
 			}
-			/** Initial execution + additional attempts */
-			const attempts = 1 + MAX_ATTEMPTS;
-			throw new Error(`Transaction failed after ${attempts} attempts`, { cause: error });
 		}
+		/** Initial execution + additional attempts */
+		const attempts = 1 + MAX_ATTEMPTS;
+		throw new Error(`Transaction failed after ${attempts} attempts`, { cause: error });
 	}
 };
 function shouldRetryTransaction(client, error) {
-	/**
-	* This error code indicates that the transaction failed due to another
-	* concurrent or recent transaction attempting to write to the same data.
-	* This can usually be solved by restarting the transaction on client-side
-	* after a short delay, so that it is executed against the latest state.
-	*
-	* @link https://www.cockroachlabs.com/docs/stable/transaction-retry-error-reference
-	*/
-	const COCKROACH_RETRY_ERROR_CODE = "40001";
-	/**
-	* SQLITE_BUSY is an error code returned by SQLite when an operation can't be
-	* performed due to a locked database file. This often arises due to multiple
-	* processes trying to simultaneously access the database, causing potential
-	* data inconsistencies. There are a few mechanisms to handle this case,
-	* one of which is to retry the complete transaction again
-	* on client-side after a short delay.
-	*
-	* @link https://www.sqlite.org/rescode.html#busy
-	*/
-	const SQLITE_BUSY_ERROR_CODE = "SQLITE_BUSY";
-	const MYSQL_DEADLOCK_CODE = "ER_LOCK_DEADLOCK";
-	const POSTGRES_DEADLOCK_CODE = "40P01";
-	const ORACLE_DEADLOCK_CODE = "ORA-00060";
-	const MSSQL_DEADLOCK_CODE = "EREQUEST";
-	const MSSQL_DEADLOCK_NUMBER = "1205";
-	const codes = {
-		cockroachdb: [{ code: COCKROACH_RETRY_ERROR_CODE }],
-		sqlite: [{ code: SQLITE_BUSY_ERROR_CODE }],
-		mysql: [{ code: MYSQL_DEADLOCK_CODE }],
+	return isObject(error) && {
+		cockroachdb: [{ code: "40001" }],
+		sqlite: [{ code: "SQLITE_BUSY" }],
+		mysql: [{ code: "ER_LOCK_DEADLOCK" }],
 		mssql: [{
-			code: MSSQL_DEADLOCK_CODE,
-			number: MSSQL_DEADLOCK_NUMBER
+			code: "EREQUEST",
+			number: "1205"
 		}],
-		oracle: [{ code: ORACLE_DEADLOCK_CODE }],
-		postgres: [{ code: POSTGRES_DEADLOCK_CODE }],
+		oracle: [{ code: "ORA-00060" }],
+		postgres: [{ code: "40P01" }],
 		redshift: []
-	};
-	return isObject(error) && codes[client].some((code) => {
+	}[client].some((code) => {
 		return Object.entries(code).every(([key, value]) => String(error[key]) === value);
 	});
 }