@directus/api 35.0.2 → 35.1.0

package/dist/controllers/deployment.js

@@ -32,11 +32,8 @@ const deploymentSchema = Joi.object({
 }).unknown();
 router.post("/", async_handler_default(async (req, res, next) => {
 	const { error } = deploymentSchema.validate(req.body);
-	if (error) {
-		throw new InvalidPayloadError({ reason: error.message });
-	}
-	const db = database_default();
-	const item = await transaction(db, async (trx) => {
+	if (error) throw new InvalidPayloadError({ reason: error.message });
+	const item = await transaction(database_default(), async (trx) => {
 		const service = new DeploymentService({
 			accountability: req.accountability,
 			schema: req.schema,
@@ -73,22 +70,17 @@ router.get("/", validateBatch("read"), readHandler, respond);
 router.search("/", validateBatch("read"), readHandler, respond);
 router.get("/:provider", async_handler_default(async (req, res, next) => {
 	const provider = req.params["provider"];
-	if (!validateProvider(provider)) {
-		throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
-	}
-	const service = new DeploymentService({
+	if (!validateProvider(provider)) throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
+	const record = await new DeploymentService({
 		accountability: req.accountability,
 		schema: req.schema
-	});
-	const record = await service.readByProvider(provider, req.sanitizedQuery);
+	}).readByProvider(provider, req.sanitizedQuery);
 	res.locals["payload"] = { data: record || null };
 	return next();
 }), respond);
 router.get("/:provider/projects", async_handler_default(async (req, res, next) => {
 	const provider = req.params["provider"];
-	if (!validateProvider(provider)) {
-		throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
-	}
+	if (!validateProvider(provider)) throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
 	const service = new DeploymentService({
 		accountability: req.accountability,
 		schema: req.schema
@@ -108,18 +100,15 @@ router.get("/:provider/projects", async_handler_default(async (req, res, next) =
 router.get("/:provider/projects/:id", async_handler_default(async (req, res, next) => {
 	const provider = req.params["provider"];
 	const projectId = req.params["id"];
-	if (!validateProvider(provider)) {
-		throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
-	}
+	if (!validateProvider(provider)) throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
 	const service = new DeploymentService({
 		accountability: req.accountability,
 		schema: req.schema
 	});
-	const projectsService = new DeploymentProjectsService({
+	const project = await new DeploymentProjectsService({
 		accountability: req.accountability,
 		schema: req.schema
-	});
-	const project = await projectsService.readOne(projectId);
+	}).readOne(projectId);
 	const { data: details, remainingTTL } = await service.getProviderProject(provider, project.external_id);
 	res.locals["cache"] = false;
 	res.locals["cacheTTL"] = remainingTTL;
@@ -139,13 +128,9 @@ const updateProjectsSchema = Joi.object({
 });
 router.patch("/:provider/projects", async_handler_default(async (req, res, next) => {
 	const provider = req.params["provider"];
-	if (!validateProvider(provider)) {
-		throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
-	}
+	if (!validateProvider(provider)) throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
 	const { error, value } = updateProjectsSchema.validate(req.body);
-	if (error) {
-		throw new InvalidPayloadError({ reason: error.message });
-	}
+	if (error) throw new InvalidPayloadError({ reason: error.message });
 	const service = new DeploymentService({
 		accountability: req.accountability,
 		schema: req.schema
@@ -154,13 +139,10 @@ router.patch("/:provider/projects", async_handler_default(async (req, res, next)
 		accountability: req.accountability,
 		schema: req.schema
 	});
-	if (value.create.length > 0) {
-		await projectsService.validateDeployable(provider, value.create);
-	}
+	if (value.create.length > 0) await projectsService.validateDeployable(provider, value.create);
 	const updatedProjects = await projectsService.updateSelection(provider, value.create, value.delete);
 	service.syncWebhook(provider).catch((err) => {
-		const logger = useLogger();
-		logger.error(`Failed to sync webhook for ${provider}: ${err}`);
+		useLogger().error(`Failed to sync webhook for ${provider}: ${err}`);
 	});
 	res.locals["payload"] = { data: updatedProjects };
 	return next();
@@ -168,19 +150,14 @@ router.patch("/:provider/projects", async_handler_default(async (req, res, next)
 const rangeQuerySchema = Joi.object({ range: Joi.string().pattern(/^\d+(ms|s|m|h|d|w|y)$/).optional() });
 router.get("/:provider/dashboard", async_handler_default(async (req, res, next) => {
 	const provider = req.params["provider"];
-	if (!validateProvider(provider)) {
-		throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
-	}
+	if (!validateProvider(provider)) throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
 	const { error, value } = rangeQuerySchema.validate(req.query);
-	if (error) {
-		throw new InvalidPayloadError({ reason: error.message });
-	}
+	if (error) throw new InvalidPayloadError({ reason: error.message });
 	const sinceDate = parseRange(value.range, 864e5);
-	const service = new DeploymentService({
+	const data = await new DeploymentService({
 		accountability: req.accountability,
 		schema: req.schema
-	});
-	const data = await service.getDashboard(provider, sinceDate);
+	}).getDashboard(provider, sinceDate);
 	res.locals["cache"] = false;
 	res.locals["payload"] = { data };
 	return next();
@@ -192,18 +169,13 @@ const triggerDeploySchema = Joi.object({
 router.post("/:provider/projects/:id/deploy", async_handler_default(async (req, res, next) => {
 	const provider = req.params["provider"];
 	const projectId = req.params["id"];
-	if (!validateProvider(provider)) {
-		throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
-	}
+	if (!validateProvider(provider)) throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
 	const { error, value } = triggerDeploySchema.validate(req.body);
-	if (error) {
-		throw new InvalidPayloadError({ reason: error.message });
-	}
-	const service = new DeploymentService({
+	if (error) throw new InvalidPayloadError({ reason: error.message });
+	const run = await new DeploymentService({
 		accountability: req.accountability,
 		schema: req.schema
-	});
-	const run = await service.triggerDeployment(provider, projectId, {
+	}).triggerDeployment(provider, projectId, {
 		preview: value.preview,
 		clearCache: value.clear_cache
 	});
@@ -212,11 +184,8 @@ router.post("/:provider/projects/:id/deploy", async_handler_default(async (req,
 }), respond);
 router.patch("/:provider", async_handler_default(async (req, res, next) => {
 	const provider = req.params["provider"];
-	if (!validateProvider(provider)) {
-		throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
-	}
-	const db = database_default();
-	const item = await transaction(db, async (trx) => {
+	if (!validateProvider(provider)) throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
+	const item = await transaction(database_default(), async (trx) => {
 		const service = new DeploymentService({
 			accountability: req.accountability,
 			schema: req.schema,
@@ -229,9 +198,7 @@ router.patch("/:provider", async_handler_default(async (req, res, next) => {
 		try {
 			return await service.readOne(primaryKey, req.sanitizedQuery);
 		} catch (error) {
-			if (isDirectusError(error, ErrorCode.Forbidden)) {
-				return null;
-			}
+			if (isDirectusError(error, ErrorCode.Forbidden)) return null;
 			throw error;
 		}
 	});
@@ -240,22 +207,17 @@ router.patch("/:provider", async_handler_default(async (req, res, next) => {
 }), respond);
 router.delete("/:provider", async_handler_default(async (req, _res, next) => {
 	const provider = req.params["provider"];
-	if (!validateProvider(provider)) {
-		throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
-	}
-	const service = new DeploymentService({
+	if (!validateProvider(provider)) throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
+	await new DeploymentService({
 		accountability: req.accountability,
 		schema: req.schema
-	});
-	await service.deleteByProvider(provider);
+	}).deleteByProvider(provider);
 	return next();
 }), respond);
 router.get("/:provider/projects/:id/runs", async_handler_default(async (req, res, next) => {
 	const provider = req.params["provider"];
 	const projectId = req.params["id"];
-	if (!validateProvider(provider)) {
-		throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
-	}
+	if (!validateProvider(provider)) throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
 	const projectsService = new DeploymentProjectsService({
 		accountability: req.accountability,
 		schema: req.schema
@@ -278,11 +240,10 @@ router.get("/:provider/projects/:id/runs", async_handler_default(async (req, res
 		]
 	};
 	const runs = await runsService.readByQuery(query);
-	const metaService = new MetaService({
+	const meta = await new MetaService({
 		accountability: req.accountability,
 		schema: req.schema
-	});
-	const meta = await metaService.getMetaForQuery("directus_deployment_runs", query);
+	}).getMetaForQuery("directus_deployment_runs", query);
 	res.locals["payload"] = {
 		data: runs,
 		meta
@@ -292,13 +253,9 @@ router.get("/:provider/projects/:id/runs", async_handler_default(async (req, res
 router.get("/:provider/projects/:id/runs/stats", async_handler_default(async (req, res, next) => {
 	const provider = req.params["provider"];
 	const projectId = req.params["id"];
-	if (!validateProvider(provider)) {
-		throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
-	}
+	if (!validateProvider(provider)) throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
 	const { error, value } = rangeQuerySchema.validate(req.query);
-	if (error) {
-		throw new InvalidPayloadError({ reason: error.message });
-	}
+	if (error) throw new InvalidPayloadError({ reason: error.message });
 	const sinceDate = parseRange(value.range, 6048e5).toISOString();
 	const projectsService = new DeploymentProjectsService({
 		accountability: req.accountability,
@@ -321,18 +278,13 @@ const runDetailsQuerySchema = Joi.object({
 router.get("/:provider/runs/:id", async_handler_default(async (req, res, next) => {
 	const provider = req.params["provider"];
 	const runId = req.params["id"];
-	if (!validateProvider(provider)) {
-		throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
-	}
+	if (!validateProvider(provider)) throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
 	const { error, value } = runDetailsQuerySchema.validate(req.query);
-	if (error) {
-		throw new InvalidPayloadError({ reason: error.message });
-	}
-	const service = new DeploymentService({
+	if (error) throw new InvalidPayloadError({ reason: error.message });
+	const data = await new DeploymentService({
 		accountability: req.accountability,
 		schema: req.schema
-	});
-	const data = await service.getRunWithLogs(provider, runId, value.since);
+	}).getRunWithLogs(provider, runId, value.since);
 	res.locals["cache"] = false;
 	res.locals["payload"] = { data };
 	return next();
@@ -340,14 +292,11 @@ router.get("/:provider/runs/:id", async_handler_default(async (req, res, next) =
 router.post("/:provider/runs/:id/cancel", async_handler_default(async (req, res, next) => {
 	const provider = req.params["provider"];
 	const runId = req.params["id"];
-	if (!validateProvider(provider)) {
-		throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
-	}
-	const service = new DeploymentService({
+	if (!validateProvider(provider)) throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
+	const data = await new DeploymentService({
 		accountability: req.accountability,
 		schema: req.schema
-	});
-	const data = await service.cancelDeployment(provider, runId);
+	}).cancelDeployment(provider, runId);
 	res.locals["payload"] = { data };
 	return next();
 }), respond);

package/dist/controllers/extensions.js

@@ -6,6 +6,7 @@ import { ExtensionReadError, ExtensionsService } from "../services/extensions.js
 import { getCacheControlHeader } from "../utils/get-cache-headers.js";
 import { respond } from "../middleware/respond.js";
 import use_collection_default from "../middleware/use-collection.js";
+import { handleRegistryError } from "./utils/handle-registry-error.js";
 import { useEnv } from "@directus/env";
 import { ErrorCode, ForbiddenError, RouteNotFoundError, isDirectusError } from "@directus/errors";
 import { isIn } from "@directus/utils";
@@ -19,29 +20,20 @@ const router = express.Router();
 const env = useEnv();
 router.use(use_collection_default("directus_extensions"));
 router.get("/", async_handler_default(async (req, res, next) => {
-	const service = new ExtensionsService({
+	const extensions = await new ExtensionsService({
 		accountability: req.accountability,
 		schema: req.schema
-	});
-	const extensions = await service.readAll();
+	}).readAll();
 	res.locals["payload"] = { data: extensions || null };
 	return next();
 }), respond);
 router.get("/registry", async_handler_default(async (req, res, next) => {
-	if (req.accountability && req.accountability.admin !== true) {
-		throw new ForbiddenError();
-	}
+	if (req.accountability && req.accountability.admin !== true) throw new ForbiddenError();
 	const { search, limit, offset, sort, filter } = req.sanitizedQuery;
 	const query = {};
-	if (!isNil(search)) {
-		query.search = search;
-	}
-	if (!isNil(limit)) {
-		query.limit = limit;
-	}
-	if (!isNil(offset)) {
-		query.offset = offset;
-	}
+	if (!isNil(search)) query.search = search;
+	if (!isNil(limit)) query.limit = limit;
+	if (!isNil(offset)) query.offset = offset;
 	if (filter) {
 		const getFilterValue = (key) => {
 			const field = filter[key];
@@ -50,13 +42,9 @@ router.get("/registry", async_handler_default(async (req, res, next) => {
 		};
 		const by = getFilterValue("by");
 		const type = getFilterValue("type");
-		if (by) {
-			query.by = by;
-		}
+		if (by) query.by = by;
 		if (type) {
-			if (isIn(type, EXTENSION_TYPES) === false) {
-				throw new ForbiddenError();
-			}
+			if (isIn(type, EXTENSION_TYPES) === false) throw new ForbiddenError();
 			query.type = type;
 		}
 	}
@@ -64,102 +52,80 @@ router.get("/registry", async_handler_default(async (req, res, next) => {
 		"popular",
 		"recent",
 		"downloads"
-	])) {
-		query.sort = sort[0];
-	}
-	if (env["MARKETPLACE_TRUST"] === "sandbox") {
-		query.sandbox = true;
-	}
+	])) query.sort = sort[0];
+	if (env["MARKETPLACE_TRUST"] === "sandbox") query.sandbox = true;
 	const options = {};
-	if (env["MARKETPLACE_REGISTRY"] && typeof env["MARKETPLACE_REGISTRY"] === "string") {
-		options.registry = env["MARKETPLACE_REGISTRY"];
+	if (env["MARKETPLACE_REGISTRY"] && typeof env["MARKETPLACE_REGISTRY"] === "string") options.registry = env["MARKETPLACE_REGISTRY"];
+	let payload;
+	try {
+		payload = await list(query, options);
+	} catch (error) {
+		handleRegistryError(error);
 	}
-	const payload = await list(query, options);
 	res.locals["payload"] = payload;
 	return next();
 }), respond);
 router.get(`/registry/account/:pk(${UUID_REGEX})`, async_handler_default(async (req, res, next) => {
-	if (req.accountability && req.accountability.admin !== true) {
-		throw new ForbiddenError();
-	}
-	if (typeof req.params["pk"] !== "string") {
-		throw new ForbiddenError();
-	}
+	if (req.accountability && req.accountability.admin !== true) throw new ForbiddenError();
+	if (typeof req.params["pk"] !== "string") throw new ForbiddenError();
 	const options = {};
-	if (env["MARKETPLACE_REGISTRY"] && typeof env["MARKETPLACE_REGISTRY"] === "string") {
-		options.registry = env["MARKETPLACE_REGISTRY"];
+	if (env["MARKETPLACE_REGISTRY"] && typeof env["MARKETPLACE_REGISTRY"] === "string") options.registry = env["MARKETPLACE_REGISTRY"];
+	let payload;
+	try {
+		payload = await account(req.params["pk"], options);
+	} catch (error) {
+		handleRegistryError(error);
 	}
-	const payload = await account(req.params["pk"], options);
 	res.locals["payload"] = payload;
 	return next();
 }), respond);
 router.get(`/registry/extension/:pk(${UUID_REGEX})`, async_handler_default(async (req, res, next) => {
-	if (req.accountability && req.accountability.admin !== true) {
-		throw new ForbiddenError();
-	}
-	if (typeof req.params["pk"] !== "string") {
-		throw new ForbiddenError();
-	}
+	if (req.accountability && req.accountability.admin !== true) throw new ForbiddenError();
+	if (typeof req.params["pk"] !== "string") throw new ForbiddenError();
 	const options = {};
-	if (env["MARKETPLACE_REGISTRY"] && typeof env["MARKETPLACE_REGISTRY"] === "string") {
-		options.registry = env["MARKETPLACE_REGISTRY"];
+	if (env["MARKETPLACE_REGISTRY"] && typeof env["MARKETPLACE_REGISTRY"] === "string") options.registry = env["MARKETPLACE_REGISTRY"];
+	let payload;
+	try {
+		payload = await describe(req.params["pk"], options);
+	} catch (error) {
+		handleRegistryError(error);
 	}
-	const payload = await describe(req.params["pk"], options);
 	res.locals["payload"] = payload;
 	return next();
 }), respond);
 router.post("/registry/install", async_handler_default(async (req, _res, next) => {
-	if (req.accountability && req.accountability.admin !== true) {
-		throw new ForbiddenError();
-	}
+	if (req.accountability && req.accountability.admin !== true) throw new ForbiddenError();
 	const { version, extension } = req.body;
-	if (!version || !extension) {
-		throw new ForbiddenError();
-	}
-	const service = new ExtensionsService({
+	if (!version || !extension) throw new ForbiddenError();
+	await new ExtensionsService({
 		accountability: req.accountability,
 		schema: req.schema
-	});
-	await service.install(extension, version);
+	}).install(extension, version);
 	return next();
 }), respond);
 router.post("/registry/reinstall", async_handler_default(async (req, _res, next) => {
-	if (req.accountability && req.accountability.admin !== true) {
-		throw new ForbiddenError();
-	}
+	if (req.accountability && req.accountability.admin !== true) throw new ForbiddenError();
 	const { extension } = req.body;
-	if (!extension) {
-		throw new ForbiddenError();
-	}
-	const service = new ExtensionsService({
+	if (!extension) throw new ForbiddenError();
+	await new ExtensionsService({
 		accountability: req.accountability,
 		schema: req.schema
-	});
-	await service.reinstall(extension);
+	}).reinstall(extension);
 	return next();
 }), respond);
 router.delete(`/registry/uninstall/:pk(${UUID_REGEX})`, async_handler_default(async (req, _res, next) => {
-	if (req.accountability && req.accountability.admin !== true) {
-		throw new ForbiddenError();
-	}
+	if (req.accountability && req.accountability.admin !== true) throw new ForbiddenError();
 	const pk = req.params["pk"];
-	if (typeof pk !== "string") {
-		throw new ForbiddenError();
-	}
-	const service = new ExtensionsService({
+	if (typeof pk !== "string") throw new ForbiddenError();
+	await new ExtensionsService({
 		accountability: req.accountability,
 		schema: req.schema
-	});
-	await service.uninstall(pk);
+	}).uninstall(pk);
 	return next();
 }), respond);
 router.patch(`/:pk(${UUID_REGEX})`, async_handler_default(async (req, res, next) => {
-	if (req.accountability && req.accountability.admin !== true) {
-		throw new ForbiddenError();
-	}
-	if (typeof req.params["pk"] !== "string") {
-		throw new ForbiddenError();
-	}
+	if (req.accountability && req.accountability.admin !== true) throw new ForbiddenError();
+	if (typeof req.params["pk"] !== "string") throw new ForbiddenError();
 	const service = new ExtensionsService({
 		accountability: req.accountability,
 		schema: req.schema
@@ -171,26 +137,20 @@ router.patch(`/:pk(${UUID_REGEX})`, async_handler_default(async (req, res, next)
 		let finalError = error;
 		if (error instanceof ExtensionReadError) {
 			finalError = error.originalError;
-			if (isDirectusError(finalError, ErrorCode.Forbidden)) {
-				return next();
-			}
+			if (isDirectusError(finalError, ErrorCode.Forbidden)) return next();
 		}
 		throw finalError;
 	}
 	return next();
 }), respond);
 router.delete(`/:pk(${UUID_REGEX})`, async_handler_default(async (req, _res, next) => {
-	if (req.accountability && req.accountability.admin !== true) {
-		throw new ForbiddenError();
-	}
+	if (req.accountability && req.accountability.admin !== true) throw new ForbiddenError();
 	const service = new ExtensionsService({
 		accountability: req.accountability,
 		schema: req.schema
 	});
 	const pk = req.params["pk"];
-	if (typeof pk !== "string") {
-		throw new ForbiddenError();
-	}
+	if (typeof pk !== "string") throw new ForbiddenError();
 	await service.deleteOne(pk);
 	return next();
 }), respond);
@@ -198,14 +158,9 @@ router.get("/sources/:chunk", async_handler_default(async (req, res) => {
 	const chunk$1 = req.params["chunk"];
 	const extensionManager = getExtensionManager();
 	let source;
-	if (chunk$1 === "index.js") {
-		source = await extensionManager.getAppExtensionChunk();
-	} else {
-		source = await extensionManager.getAppExtensionChunk(chunk$1);
-	}
-	if (source === null) {
-		throw new RouteNotFoundError({ path: req.path });
-	}
+	if (chunk$1 === "index.js") source = await extensionManager.getAppExtensionChunk();
+	else source = await extensionManager.getAppExtensionChunk(chunk$1);
+	if (source === null) throw new RouteNotFoundError({ path: req.path });
 	res.setHeader("Content-Type", "application/javascript; charset=UTF-8");
 	res.setHeader("Cache-Control", getCacheControlHeader(req, getMilliseconds(env["EXTENSIONS_CACHE_TTL"]), false, false));
 	res.setHeader("Vary", "Origin, Cache-Control");

package/dist/controllers/fields.js

@@ -14,29 +14,26 @@ import Joi from "joi";
 const router = Router();
 router.use(use_collection_default("directus_fields"));
 router.get("/", async_handler_default(async (req, res, next) => {
-	const service = new FieldsService({
+	const fields = await new FieldsService({
 		accountability: req.accountability,
 		schema: req.schema
-	});
-	const fields = await service.readAll();
+	}).readAll();
 	res.locals["payload"] = { data: fields || null };
 	return next();
 }), respond);
 router.get("/:collection", collection_exists_default, async_handler_default(async (req, res, next) => {
-	const service = new FieldsService({
+	const fields = await new FieldsService({
 		accountability: req.accountability,
 		schema: req.schema
-	});
-	const fields = await service.readAll(req.params["collection"]);
+	}).readAll(req.params["collection"]);
 	res.locals["payload"] = { data: fields || null };
 	return next();
 }), respond);
 router.get("/:collection/:field", collection_exists_default, async_handler_default(async (req, res, next) => {
-	const service = new FieldsService({
+	const field = await new FieldsService({
 		accountability: req.accountability,
 		schema: req.schema
-	});
-	const field = await service.readOne(req.params["collection"], req.params["field"]);
+	}).readOne(req.params["collection"], req.params["field"]);
 	res.locals["payload"] = { data: field || null };
 	return next();
 }), respond);
@@ -61,18 +58,14 @@ router.post("/:collection", collection_exists_default, async_handler_default(asy
 		schema: req.schema
 	});
 	const { error } = newFieldSchema.validate(req.body);
-	if (error) {
-		throw new InvalidPayloadError({ reason: error.message });
-	}
+	if (error) throw new InvalidPayloadError({ reason: error.message });
 	const field = req.body;
-	await service.createField(req.params["collection"], field, undefined, { attemptConcurrentIndex: "concurrentIndexCreation" in req.query && req.query["concurrentIndexCreation"] !== "false" });
+	await service.createField(req.params["collection"], field, void 0, { attemptConcurrentIndex: "concurrentIndexCreation" in req.query && req.query["concurrentIndexCreation"] !== "false" });
 	try {
 		const createdField = await service.readOne(req.params["collection"], field.field);
 		res.locals["payload"] = { data: createdField || null };
 	} catch (error$1) {
-		if (isDirectusError(error$1, ErrorCode.Forbidden)) {
-			return next();
-		}
+		if (isDirectusError(error$1, ErrorCode.Forbidden)) return next();
 		throw error$1;
 	}
 	return next();
@@ -82,16 +75,10 @@ router.patch("/:collection", collection_exists_default, async_handler_default(as
 		accountability: req.accountability,
 		schema: req.schema
 	});
-	if (Array.isArray(req.body) === false) {
-		throw new InvalidPayloadError({ reason: "Submitted body has to be an array" });
-	}
-	for (const fieldData of req.body) {
-		if (isSystemField(req.params["collection"], fieldData["field"])) {
-			const { error } = systemFieldUpdateSchema.safeParse(fieldData);
-			if (error) {
-				throw new InvalidPayloadError({ reason: "Only \"schema.is_indexed\" may be modified for system fields" });
-			}
-		}
+	if (Array.isArray(req.body) === false) throw new InvalidPayloadError({ reason: "Submitted body has to be an array" });
+	for (const fieldData of req.body) if (isSystemField(req.params["collection"], fieldData["field"])) {
+		const { error } = systemFieldUpdateSchema.safeParse(fieldData);
+		if (error) throw new InvalidPayloadError({ reason: "Only \"schema.is_indexed\" may be modified for system fields" });
 	}
 	await service.updateFields(req.params["collection"], req.body, { attemptConcurrentIndex: "concurrentIndexCreation" in req.query && req.query["concurrentIndexCreation"] !== "false" });
 	try {
@@ -102,9 +89,7 @@ router.patch("/:collection", collection_exists_default, async_handler_default(as
 			res.locals["payload"] = { data: results || null };
 		}
 	} catch (error) {
-		if (isDirectusError(error, ErrorCode.Forbidden)) {
-			return next();
-		}
+		if (isDirectusError(error, ErrorCode.Forbidden)) return next();
 		throw error;
 	}
 	return next();
@@ -129,9 +114,7 @@ router.patch("/:collection/:field", collection_exists_default, async_handler_def
 	});
 	if (isSystemField(req.params["collection"], req.params["field"])) {
 		const { error } = systemFieldUpdateSchema.safeParse(req.body);
-		if (error) {
-			throw new InvalidPayloadError({ reason: "Only \"schema.is_indexed\" may be modified for system fields" });
-		}
+		if (error) throw new InvalidPayloadError({ reason: "Only \"schema.is_indexed\" may be modified for system fields" });
 	} else {
 		const { error } = updateSchema.validate(req.body);
 		if (error) throw new InvalidPayloadError({ reason: error.message });
@@ -143,9 +126,7 @@ router.patch("/:collection/:field", collection_exists_default, async_handler_def
 		const updatedField = await service.readOne(req.params["collection"], req.params["field"]);
 		res.locals["payload"] = { data: updatedField || null };
 	} catch (error) {
-		if (isDirectusError(error, ErrorCode.Forbidden)) {
-			return next();
-		}
+		if (isDirectusError(error, ErrorCode.Forbidden)) return next();
 		throw error;
 	}
 	return next();
@@ -155,9 +136,7 @@ router.delete("/:collection/:field", collection_exists_default, async_handler_de
 		accountability: req.accountability,
 		schema: req.schema
 	});
-	if (isSystemField(req.params["collection"], req.params["field"])) {
-		throw new ForbiddenError();
-	}
+	if (isSystemField(req.params["collection"], req.params["field"])) throw new ForbiddenError();
 	await service.deleteField(req.params["collection"], req.params["field"]);
 	return next();
 }), respond);