@directus/api 34.0.1 → 35.0.0

package/dist/controllers/graphql.js

@@ -1,31 +1,36 @@
-import { Router } from 'express';
-import { parseGraphQL } from '../middleware/graphql.js';
-import { respond } from '../middleware/respond.js';
-import { GraphQLService } from '../services/graphql/index.js';
-import asyncHandler from '../utils/async-handler.js';
+import async_handler_default from "../utils/async-handler.js";
+import { respond } from "../middleware/respond.js";
+import { GraphQLService } from "../services/graphql/index.js";
+import { parseGraphQL } from "../middleware/graphql.js";
+import { Router } from "express";
+
+//#region src/controllers/graphql.ts
 const router = Router();
-router.use('/system', parseGraphQL, asyncHandler(async (req, res, next) => {
-    const service = new GraphQLService({
-        accountability: req.accountability,
-        schema: req.schema,
-        scope: 'system',
-    });
-    res.locals['payload'] = await service.execute(res.locals['graphqlParams']);
-    if (res.locals['payload']?.errors?.length > 0) {
-        res.locals['cache'] = false;
-    }
-    return next();
+router.use("/system", parseGraphQL, async_handler_default(async (req, res, next) => {
+	const service = new GraphQLService({
+		accountability: req.accountability,
+		schema: req.schema,
+		scope: "system"
+	});
+	res.locals["payload"] = await service.execute(res.locals["graphqlParams"]);
+	if (res.locals["payload"]?.errors?.length > 0) {
+		res.locals["cache"] = false;
+	}
+	return next();
 }), respond);
-router.use('/', parseGraphQL, asyncHandler(async (req, res, next) => {
-    const service = new GraphQLService({
-        accountability: req.accountability,
-        schema: req.schema,
-        scope: 'items',
-    });
-    res.locals['payload'] = await service.execute(res.locals['graphqlParams']);
-    if (res.locals['payload']?.errors?.length > 0) {
-        res.locals['cache'] = false;
-    }
-    return next();
+router.use("/", parseGraphQL, async_handler_default(async (req, res, next) => {
+	const service = new GraphQLService({
+		accountability: req.accountability,
+		schema: req.schema,
+		scope: "items"
+	});
+	res.locals["payload"] = await service.execute(res.locals["graphqlParams"]);
+	if (res.locals["payload"]?.errors?.length > 0) {
+		res.locals["cache"] = false;
+	}
+	return next();
 }), respond);
-export default router;
+var graphql_default = router;
+
+//#endregion
+export { graphql_default as default };

package/dist/controllers/items.js

@@ -1,180 +1,165 @@
-import { ErrorCode, ForbiddenError, isDirectusError, RouteNotFoundError } from '@directus/errors';
-import { isSystemCollection } from '@directus/system-data';
-import express from 'express';
-import collectionExists from '../middleware/collection-exists.js';
-import { respond } from '../middleware/respond.js';
-import { validateBatch } from '../middleware/validate-batch.js';
-import { ItemsService } from '../services/items.js';
-import { MetaService } from '../services/meta.js';
-import asyncHandler from '../utils/async-handler.js';
-import { sanitizeQuery } from '../utils/sanitize-query.js';
+import async_handler_default from "../utils/async-handler.js";
+import { ItemsService } from "../services/items.js";
+import { sanitizeQuery } from "../utils/sanitize-query.js";
+import { respond } from "../middleware/respond.js";
+import { MetaService } from "../services/meta.js";
+import { validateBatch } from "../middleware/validate-batch.js";
+import collection_exists_default from "../middleware/collection-exists.js";
+import { ErrorCode, ForbiddenError, RouteNotFoundError, isDirectusError } from "@directus/errors";
+import express from "express";
+import { isSystemCollection } from "@directus/system-data";
+
+//#region src/controllers/items.ts
 const router = express.Router();
-router.post('/:collection', collectionExists, asyncHandler(async (req, res, next) => {
-    if (isSystemCollection(req.params['collection']))
-        throw new ForbiddenError();
-    if (req.singleton) {
-        throw new RouteNotFoundError({ path: req.path });
-    }
-    const service = new ItemsService(req.collection, {
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    const savedKeys = [];
-    if (Array.isArray(req.body)) {
-        const keys = await service.createMany(req.body);
-        savedKeys.push(...keys);
-    }
-    else {
-        const key = await service.createOne(req.body);
-        savedKeys.push(key);
-    }
-    try {
-        if (Array.isArray(req.body)) {
-            const result = await service.readMany(savedKeys, req.sanitizedQuery);
-            res.locals['payload'] = { data: result || null };
-        }
-        else {
-            const result = await service.readOne(savedKeys[0], req.sanitizedQuery);
-            res.locals['payload'] = { data: result || null };
-        }
-    }
-    catch (error) {
-        if (isDirectusError(error, ErrorCode.Forbidden)) {
-            return next();
-        }
-        throw error;
-    }
-    return next();
+router.post("/:collection", collection_exists_default, async_handler_default(async (req, res, next) => {
+	if (isSystemCollection(req.params["collection"])) throw new ForbiddenError();
+	if (req.singleton) {
+		throw new RouteNotFoundError({ path: req.path });
+	}
+	const service = new ItemsService(req.collection, {
+		accountability: req.accountability,
+		schema: req.schema
+	});
+	const savedKeys = [];
+	if (Array.isArray(req.body)) {
+		const keys = await service.createMany(req.body);
+		savedKeys.push(...keys);
+	} else {
+		const key = await service.createOne(req.body);
+		savedKeys.push(key);
+	}
+	try {
+		if (Array.isArray(req.body)) {
+			const result = await service.readMany(savedKeys, req.sanitizedQuery);
+			res.locals["payload"] = { data: result || null };
+		} else {
+			const result = await service.readOne(savedKeys[0], req.sanitizedQuery);
+			res.locals["payload"] = { data: result || null };
+		}
+	} catch (error) {
+		if (isDirectusError(error, ErrorCode.Forbidden)) {
+			return next();
+		}
+		throw error;
+	}
+	return next();
 }), respond);
-const readHandler = asyncHandler(async (req, res, next) => {
-    if (isSystemCollection(req.params['collection']))
-        throw new ForbiddenError();
-    const service = new ItemsService(req.collection, {
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    const metaService = new MetaService({
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    let result;
-    if (req.singleton) {
-        result = await service.readSingleton(req.sanitizedQuery);
-    }
-    else if (req.body.keys) {
-        result = await service.readMany(req.body.keys, req.sanitizedQuery);
-    }
-    else {
-        result = await service.readByQuery(req.sanitizedQuery);
-    }
-    const meta = await metaService.getMetaForQuery(req.collection, req.sanitizedQuery);
-    res.locals['payload'] = {
-        meta: meta,
-        data: result,
-    };
-    return next();
+const readHandler = async_handler_default(async (req, res, next) => {
+	if (isSystemCollection(req.params["collection"])) throw new ForbiddenError();
+	const service = new ItemsService(req.collection, {
+		accountability: req.accountability,
+		schema: req.schema
+	});
+	const metaService = new MetaService({
+		accountability: req.accountability,
+		schema: req.schema
+	});
+	let result;
+	if (req.singleton) {
+		result = await service.readSingleton(req.sanitizedQuery);
+	} else if (req.body.keys) {
+		result = await service.readMany(req.body.keys, req.sanitizedQuery);
+	} else {
+		result = await service.readByQuery(req.sanitizedQuery);
+	}
+	const meta = await metaService.getMetaForQuery(req.collection, req.sanitizedQuery);
+	res.locals["payload"] = {
+		meta,
+		data: result
+	};
+	return next();
 });
-router.search('/:collection', collectionExists, validateBatch('read'), readHandler, respond);
-router.get('/:collection', collectionExists, readHandler, respond);
-router.get('/:collection/:pk', collectionExists, asyncHandler(async (req, res, next) => {
-    if (isSystemCollection(req.params['collection']))
-        throw new ForbiddenError();
-    const service = new ItemsService(req.collection, {
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    const result = await service.readOne(req.params['pk'], req.sanitizedQuery);
-    res.locals['payload'] = {
-        data: result || null,
-    };
-    return next();
+router.search("/:collection", collection_exists_default, validateBatch("read"), readHandler, respond);
+router.get("/:collection", collection_exists_default, readHandler, respond);
+router.get("/:collection/:pk", collection_exists_default, async_handler_default(async (req, res, next) => {
+	if (isSystemCollection(req.params["collection"])) throw new ForbiddenError();
+	const service = new ItemsService(req.collection, {
+		accountability: req.accountability,
+		schema: req.schema
+	});
+	const result = await service.readOne(req.params["pk"], req.sanitizedQuery);
+	res.locals["payload"] = { data: result || null };
+	return next();
 }), respond);
-router.patch('/:collection', collectionExists, validateBatch('update'), asyncHandler(async (req, res, next) => {
-    if (isSystemCollection(req.params['collection']))
-        throw new ForbiddenError();
-    const service = new ItemsService(req.collection, {
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    if (req.singleton === true) {
-        await service.upsertSingleton(req.body);
-        const item = await service.readSingleton(req.sanitizedQuery);
-        res.locals['payload'] = { data: item || null };
-        return next();
-    }
-    let keys = [];
-    if (Array.isArray(req.body)) {
-        keys = await service.updateBatch(req.body);
-    }
-    else if (req.body.keys) {
-        keys = await service.updateMany(req.body.keys, req.body.data);
-    }
-    else {
-        const sanitizedQuery = await sanitizeQuery(req.body.query, req.schema, req.accountability);
-        keys = await service.updateByQuery(sanitizedQuery, req.body.data);
-    }
-    try {
-        const result = await service.readMany(keys, req.sanitizedQuery);
-        res.locals['payload'] = { data: result };
-    }
-    catch (error) {
-        if (isDirectusError(error, ErrorCode.Forbidden)) {
-            return next();
-        }
-        throw error;
-    }
-    return next();
+router.patch("/:collection", collection_exists_default, validateBatch("update"), async_handler_default(async (req, res, next) => {
+	if (isSystemCollection(req.params["collection"])) throw new ForbiddenError();
+	const service = new ItemsService(req.collection, {
+		accountability: req.accountability,
+		schema: req.schema
+	});
+	if (req.singleton === true) {
+		await service.upsertSingleton(req.body);
+		const item = await service.readSingleton(req.sanitizedQuery);
+		res.locals["payload"] = { data: item || null };
+		return next();
+	}
+	let keys = [];
+	if (Array.isArray(req.body)) {
+		keys = await service.updateBatch(req.body);
+	} else if (req.body.keys) {
+		keys = await service.updateMany(req.body.keys, req.body.data);
+	} else {
+		const sanitizedQuery = await sanitizeQuery(req.body.query, req.schema, req.accountability);
+		keys = await service.updateByQuery(sanitizedQuery, req.body.data);
+	}
+	try {
+		const result = await service.readMany(keys, req.sanitizedQuery);
+		res.locals["payload"] = { data: result };
+	} catch (error) {
+		if (isDirectusError(error, ErrorCode.Forbidden)) {
+			return next();
+		}
+		throw error;
+	}
+	return next();
 }), respond);
-router.patch('/:collection/:pk', collectionExists, asyncHandler(async (req, res, next) => {
-    if (isSystemCollection(req.params['collection']))
-        throw new ForbiddenError();
-    if (req.singleton) {
-        throw new RouteNotFoundError({ path: req.path });
-    }
-    const service = new ItemsService(req.collection, {
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    const updatedPrimaryKey = await service.updateOne(req.params['pk'], req.body);
-    try {
-        const result = await service.readOne(updatedPrimaryKey, req.sanitizedQuery);
-        res.locals['payload'] = { data: result || null };
-    }
-    catch (error) {
-        if (isDirectusError(error, ErrorCode.Forbidden)) {
-            return next();
-        }
-        throw error;
-    }
-    return next();
+router.patch("/:collection/:pk", collection_exists_default, async_handler_default(async (req, res, next) => {
+	if (isSystemCollection(req.params["collection"])) throw new ForbiddenError();
+	if (req.singleton) {
+		throw new RouteNotFoundError({ path: req.path });
+	}
+	const service = new ItemsService(req.collection, {
+		accountability: req.accountability,
+		schema: req.schema
+	});
+	const updatedPrimaryKey = await service.updateOne(req.params["pk"], req.body);
+	try {
+		const result = await service.readOne(updatedPrimaryKey, req.sanitizedQuery);
+		res.locals["payload"] = { data: result || null };
+	} catch (error) {
+		if (isDirectusError(error, ErrorCode.Forbidden)) {
+			return next();
+		}
+		throw error;
+	}
+	return next();
 }), respond);
-router.delete('/:collection', collectionExists, validateBatch('delete'), asyncHandler(async (req, _res, next) => {
-    if (isSystemCollection(req.params['collection']))
-        throw new ForbiddenError();
-    const service = new ItemsService(req.collection, {
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    if (Array.isArray(req.body)) {
-        await service.deleteMany(req.body);
-    }
-    else if (req.body.keys) {
-        await service.deleteMany(req.body.keys);
-    }
-    else {
-        const sanitizedQuery = await sanitizeQuery(req.body.query, req.schema, req.accountability);
-        await service.deleteByQuery(sanitizedQuery);
-    }
-    return next();
+router.delete("/:collection", collection_exists_default, validateBatch("delete"), async_handler_default(async (req, _res, next) => {
+	if (isSystemCollection(req.params["collection"])) throw new ForbiddenError();
+	const service = new ItemsService(req.collection, {
+		accountability: req.accountability,
+		schema: req.schema
+	});
+	if (Array.isArray(req.body)) {
+		await service.deleteMany(req.body);
+	} else if (req.body.keys) {
+		await service.deleteMany(req.body.keys);
+	} else {
+		const sanitizedQuery = await sanitizeQuery(req.body.query, req.schema, req.accountability);
+		await service.deleteByQuery(sanitizedQuery);
+	}
+	return next();
 }), respond);
-router.delete('/:collection/:pk', collectionExists, asyncHandler(async (req, _res, next) => {
-    if (isSystemCollection(req.params['collection']))
-        throw new ForbiddenError();
-    const service = new ItemsService(req.collection, {
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    await service.deleteOne(req.params['pk']);
-    return next();
+router.delete("/:collection/:pk", collection_exists_default, async_handler_default(async (req, _res, next) => {
+	if (isSystemCollection(req.params["collection"])) throw new ForbiddenError();
+	const service = new ItemsService(req.collection, {
+		accountability: req.accountability,
+		schema: req.schema
+	});
+	await service.deleteOne(req.params["pk"]);
+	return next();
 }), respond);
-export default router;
+var items_default = router;
+
+//#endregion
+export { items_default as default };

package/dist/controllers/mcp.js

@@ -1,33 +1,35 @@
-import { ForbiddenError } from '@directus/errors';
-import { Router } from 'express';
-import { DirectusMCP } from '../ai/mcp/index.js';
-import { SettingsService } from '../services/settings.js';
-import asyncHandler from '../utils/async-handler.js';
+import async_handler_default from "../utils/async-handler.js";
+import { SettingsService } from "../services/settings.js";
+import { DirectusMCP } from "../ai/mcp/server.js";
+import "../ai/mcp/index.js";
+import { ForbiddenError } from "@directus/errors";
+import { Router } from "express";
+
+//#region src/controllers/mcp.ts
 const router = Router();
-const mcpHandler = asyncHandler(async (req, res) => {
-    const settings = new SettingsService({
-        schema: req.schema,
-    });
-    const { mcp_enabled, mcp_allow_deletes, mcp_prompts_collection, mcp_system_prompt, mcp_system_prompt_enabled } = await settings.readSingleton({
-        fields: [
-            'mcp_enabled',
-            'mcp_allow_deletes',
-            'mcp_prompts_collection',
-            'mcp_system_prompt',
-            'mcp_system_prompt_enabled',
-        ],
-    });
-    if (!mcp_enabled) {
-        throw new ForbiddenError({ reason: 'MCP must be enabled' });
-    }
-    const mcp = new DirectusMCP({
-        promptsCollection: mcp_prompts_collection,
-        allowDeletes: mcp_allow_deletes,
-        systemPromptEnabled: mcp_system_prompt_enabled,
-        systemPrompt: mcp_system_prompt,
-    });
-    mcp.handleRequest(req, res);
+const mcpHandler = async_handler_default(async (req, res) => {
+	const settings = new SettingsService({ schema: req.schema });
+	const { mcp_enabled, mcp_allow_deletes, mcp_prompts_collection, mcp_system_prompt, mcp_system_prompt_enabled } = await settings.readSingleton({ fields: [
+		"mcp_enabled",
+		"mcp_allow_deletes",
+		"mcp_prompts_collection",
+		"mcp_system_prompt",
+		"mcp_system_prompt_enabled"
+	] });
+	if (!mcp_enabled) {
+		throw new ForbiddenError({ reason: "MCP must be enabled" });
+	}
+	const mcp = new DirectusMCP({
+		promptsCollection: mcp_prompts_collection,
+		allowDeletes: mcp_allow_deletes,
+		systemPromptEnabled: mcp_system_prompt_enabled,
+		systemPrompt: mcp_system_prompt
+	});
+	mcp.handleRequest(req, res);
 });
-router.get('/', mcpHandler);
-router.post('/', mcpHandler);
-export default router;
+router.get("/", mcpHandler);
+router.post("/", mcpHandler);
+var mcp_default = router;
+
+//#endregion
+export { mcp_default as default };

package/dist/controllers/metrics.js

@@ -1,33 +1,37 @@
-import { useEnv } from '@directus/env';
-import { ForbiddenError } from '@directus/errors';
-import { Router } from 'express';
-import { useMetrics } from '../metrics/index.js';
-import asyncHandler from '../utils/async-handler.js';
+import async_handler_default from "../utils/async-handler.js";
+import { useMetrics } from "../metrics/lib/use-metrics.js";
+import "../metrics/index.js";
+import { useEnv } from "@directus/env";
+import { ForbiddenError } from "@directus/errors";
+import { Router } from "express";
+
+//#region src/controllers/metrics.ts
 const env = useEnv();
 const router = Router();
 const metrics = useMetrics();
-router.get('/', asyncHandler(async (req, _res, next) => {
-    if (req.accountability?.admin === true) {
-        return next();
-    }
-    // support Bearer Token of type `Metrics`
-    const metricTokens = env['METRICS_TOKENS'];
-    if (!req.headers || !req.headers.authorization || !metricTokens) {
-        throw new ForbiddenError();
-    }
-    const parts = req.headers.authorization.split(' ');
-    if (parts.length !== 2 || parts[0].toLowerCase() !== 'metrics') {
-        throw new ForbiddenError();
-    }
-    if (metricTokens.find((mt) => mt.toString() === parts[1]) !== undefined) {
-        return next();
-    }
-    throw new ForbiddenError();
-}), asyncHandler(async (_req, res) => {
-    res.set('Content-Type', 'text/plain');
-    // Don't cache anything by default
-    res.setHeader('Cache-Control', 'no-cache');
-    res.setHeader('Vary', 'Origin, Cache-Control');
-    return res.send(await metrics?.readAll());
+router.get("/", async_handler_default(async (req, _res, next) => {
+	if (req.accountability?.admin === true) {
+		return next();
+	}
+	const metricTokens = env["METRICS_TOKENS"];
+	if (!req.headers || !req.headers.authorization || !metricTokens) {
+		throw new ForbiddenError();
+	}
+	const parts = req.headers.authorization.split(" ");
+	if (parts.length !== 2 || parts[0].toLowerCase() !== "metrics") {
+		throw new ForbiddenError();
+	}
+	if (metricTokens.find((mt) => mt.toString() === parts[1]) !== undefined) {
+		return next();
+	}
+	throw new ForbiddenError();
+}), async_handler_default(async (_req, res) => {
+	res.set("Content-Type", "text/plain");
+	res.setHeader("Cache-Control", "no-cache");
+	res.setHeader("Vary", "Origin, Cache-Control");
+	return res.send(await metrics?.readAll());
 }));
-export default router;
+var metrics_default = router;
+
+//#endregion
+export { metrics_default as default };

package/dist/controllers/not-found.js

@@ -1,31 +1,38 @@
-import { RouteNotFoundError } from '@directus/errors';
-import getDatabase from '../database/index.js';
-import emitter from '../emitter.js';
+import database_default from "../database/index.js";
+import emitter_default from "../emitter.js";
+import { RouteNotFoundError } from "@directus/errors";
+
+//#region src/controllers/not-found.ts
 /**
- * Handles not found routes.
- *
- * - If a hook throws an error, the error gets forwarded to the error handler.
- * - If a hook returns true, the handler assumes the response has been
- *   processed and won't generate a response.
- *
- * @param req
- * @param res
- * @param next
- */
+* Handles not found routes.
+*
+* - If a hook throws an error, the error gets forwarded to the error handler.
+* - If a hook returns true, the handler assumes the response has been
+*   processed and won't generate a response.
+*
+* @param req
+* @param res
+* @param next
+*/
 const notFound = async (req, res, next) => {
-    try {
-        const hooksResult = await emitter.emitFilter('request.not_found', false, { request: req, response: res }, {
-            database: getDatabase(),
-            schema: req.schema,
-            accountability: req.accountability ?? null,
-        });
-        if (hooksResult) {
-            return next();
-        }
-        next(new RouteNotFoundError({ path: req.path }));
-    }
-    catch (err) {
-        next(err);
-    }
+	try {
+		const hooksResult = await emitter_default.emitFilter("request.not_found", false, {
+			request: req,
+			response: res
+		}, {
+			database: database_default(),
+			schema: req.schema,
+			accountability: req.accountability ?? null
+		});
+		if (hooksResult) {
+			return next();
+		}
+		next(new RouteNotFoundError({ path: req.path }));
+	} catch (err) {
+		next(err);
+	}
 };
-export default notFound;
+var not_found_default = notFound;
+
+//#endregion
+export { not_found_default as default };