directus

1
import { ErrorCode, createError } from '@directus/errors';
2
import express from 'express';
3
import { respond } from '../middleware/respond.js';
4
import useCollection from '../middleware/use-collection.js';
5
import { validateBatch } from '../middleware/validate-batch.js';
6
import { MetaService } from '../services/meta.js';
7
import { WebhooksService } from '../services/webhooks.js';
8
import asyncHandler from '../utils/async-handler.js';
9
import { sanitizeQuery } from '../utils/sanitize-query.js';
10

11
const router = express.Router();
12

13
router.use(useCollection('directus_webhooks'));
14

15
router.post(
16
	'/',
17
	asyncHandler(async (_req, _res, _next) => {
18
		// Disallow creation of new Webhooks as part of the deprecation, see https://github.com/directus/directus/issues/15553
19
		throw new (createError(ErrorCode.MethodNotAllowed, 'Webhooks are deprecated, use Flows instead', 405))();
20
	}),
21
	respond,
22
);
23

24
const readHandler = asyncHandler(async (req, res, next) => {
25
	const service = new WebhooksService({
26
		accountability: req.accountability,
27
		schema: req.schema,
28
	});
29

30
	const metaService = new MetaService({
31
		accountability: req.accountability,
32
		schema: req.schema,
33
	});
34

35
	const records = await service.readByQuery(req.sanitizedQuery);
36
	const meta = await metaService.getMetaForQuery(req.collection, req.sanitizedQuery);
37

38
	res.locals['payload'] = { data: records || null, meta };
39
	return next();
40
});
41

42
router.get('/', validateBatch('read'), readHandler, respond);
43
router.search('/', validateBatch('read'), readHandler, respond);
44

45
router.get(
46
	'/:pk',
47
	asyncHandler(async (req, res, next) => {
48
		const service = new WebhooksService({
49
			accountability: req.accountability,
50
			schema: req.schema,
51
		});
52

53
		const record = await service.readOne(req.params['pk']!, req.sanitizedQuery);
54

55
		res.locals['payload'] = { data: record || null };
56
		return next();
57
	}),
58
	respond,
59
);
60

61
router.patch(
62
	'/',
63
	validateBatch('update'),
64
	asyncHandler(async (_req, _res, _next) => {
65
		// Disallow patching of Webhooks as part of the deprecation, see https://github.com/directus/directus/issues/15553
66
		throw new (createError(ErrorCode.MethodNotAllowed, 'Webhooks are deprecated, use Flows instead', 405))();
67
	}),
68
	respond,
69
);
70

71
router.patch(
72
	'/:pk',
73
	asyncHandler(async (_req, _res, _next) => {
74
		// Disallow patching of Webhooks as part of the deprecation, see https://github.com/directus/directus/issues/15553
75
		throw new (createError(ErrorCode.MethodNotAllowed, 'Webhooks are deprecated, use Flows instead', 405))();
76
	}),
77
	respond,
78
);
79

80
router.delete(
81
	'/',
82
	asyncHandler(async (req, _res, next) => {
83
		const service = new WebhooksService({
84
			accountability: req.accountability,
85
			schema: req.schema,
86
		});
87

88
		if (Array.isArray(req.body)) {
89
			await service.deleteMany(req.body);
90
		} else if (req.body.keys) {
91
			await service.deleteMany(req.body.keys);
92
		} else {
93
			const sanitizedQuery = sanitizeQuery(req.body.query, req.accountability);
94
			await service.deleteByQuery(sanitizedQuery);
95
		}
96

97
		return next();
98
	}),
99
	respond,
100
);
101

102
router.delete(
103
	'/:pk',
104
	asyncHandler(async (req, _res, next) => {
105
		const service = new WebhooksService({
106
			accountability: req.accountability,
107
			schema: req.schema,
108
		});
109

110
		await service.deleteOne(req.params['pk']!);
111

112
		return next();
113
	}),
114
	respond,
115
);
116

117
export default router;
118