directus

1
import { ErrorCode, isDirectusError } from '@directus/errors';
2
import type { PrimaryKey } from '@directus/types';
3
import express from 'express';
4
import { UUID_REGEX } from '../constants.js';
5
import { getFlowManager } from '../flows.js';
6
import { respond } from '../middleware/respond.js';
7
import useCollection from '../middleware/use-collection.js';
8
import { validateBatch } from '../middleware/validate-batch.js';
9
import { FlowsService } from '../services/flows.js';
10
import { MetaService } from '../services/meta.js';
11
import asyncHandler from '../utils/async-handler.js';
12
import { sanitizeQuery } from '../utils/sanitize-query.js';
13

14
const router = express.Router();
15

16
router.use(useCollection('directus_flows'));
17

18
const webhookFlowHandler = asyncHandler(async (req, res, next) => {
19
	const flowManager = getFlowManager();
20

21
	const { result, cacheEnabled } = await flowManager.runWebhookFlow(
22
		`${req.method}-${req.params['pk']}`,
23
		{
24
			path: req.path,
25
			query: req.query,
26
			body: req.body,
27
			method: req.method,
28
			headers: req.headers,
29
		},
30
		{
31
			accountability: req.accountability,
32
			schema: req.schema,
33
		},
34
	);
35

36
	if (!cacheEnabled) {
37
		res.locals['cache'] = false;
38
	}
39

40
	res.locals['payload'] = result;
41
	return next();
42
});
43

44
router.get(`/trigger/:pk(${UUID_REGEX})`, webhookFlowHandler, respond);
45
router.post(`/trigger/:pk(${UUID_REGEX})`, webhookFlowHandler, respond);
46

47
router.post(
48
	'/',
49
	asyncHandler(async (req, res, next) => {
50
		const service = new FlowsService({
51
			accountability: req.accountability,
52
			schema: req.schema,
53
		});
54

55
		const savedKeys: PrimaryKey[] = [];
56

57
		if (Array.isArray(req.body)) {
58
			const keys = await service.createMany(req.body);
59
			savedKeys.push(...keys);
60
		} else {
61
			const key = await service.createOne(req.body);
62
			savedKeys.push(key);
63
		}
64

65
		try {
66
			if (Array.isArray(req.body)) {
67
				const items = await service.readMany(savedKeys, req.sanitizedQuery);
68
				res.locals['payload'] = { data: items };
69
			} else {
70
				const item = await service.readOne(savedKeys[0]!, req.sanitizedQuery);
71
				res.locals['payload'] = { data: item };
72
			}
73
		} catch (error: any) {
74
			if (isDirectusError(error, ErrorCode.Forbidden)) {
75
				return next();
76
			}
77

78
			throw error;
79
		}
80

81
		return next();
82
	}),
83
	respond,
84
);
85

86
const readHandler = asyncHandler(async (req, res, next) => {
87
	const service = new FlowsService({
88
		accountability: req.accountability,
89
		schema: req.schema,
90
	});
91

92
	const metaService = new MetaService({
93
		accountability: req.accountability,
94
		schema: req.schema,
95
	});
96

97
	const records = await service.readByQuery(req.sanitizedQuery);
98
	const meta = await metaService.getMetaForQuery(req.collection, req.sanitizedQuery);
99

100
	res.locals['payload'] = { data: records || null, meta };
101
	return next();
102
});
103

104
router.get('/', validateBatch('read'), readHandler, respond);
105
router.search('/', validateBatch('read'), readHandler, respond);
106

107
router.get(
108
	'/:pk',
109
	asyncHandler(async (req, res, next) => {
110
		const service = new FlowsService({
111
			accountability: req.accountability,
112
			schema: req.schema,
113
		});
114

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

117
		res.locals['payload'] = { data: record || null };
118
		return next();
119
	}),
120
	respond,
121
);
122

123
router.patch(
124
	'/',
125
	validateBatch('update'),
126
	asyncHandler(async (req, res, next) => {
127
		const service = new FlowsService({
128
			accountability: req.accountability,
129
			schema: req.schema,
130
		});
131

132
		let keys: PrimaryKey[] = [];
133

134
		if (Array.isArray(req.body)) {
135
			keys = await service.updateBatch(req.body);
136
		} else if (req.body.keys) {
137
			keys = await service.updateMany(req.body.keys, req.body.data);
138
		} else {
139
			const sanitizedQuery = sanitizeQuery(req.body.query, req.accountability);
140
			keys = await service.updateByQuery(sanitizedQuery, req.body.data);
141
		}
142

143
		try {
144
			const result = await service.readMany(keys, req.sanitizedQuery);
145
			res.locals['payload'] = { data: result };
146
		} catch (error: any) {
147
			if (isDirectusError(error, ErrorCode.Forbidden)) {
148
				return next();
149
			}
150

151
			throw error;
152
		}
153

154
		return next();
155
	}),
156
	respond,
157
);
158

159
router.patch(
160
	'/:pk',
161
	asyncHandler(async (req, res, next) => {
162
		const service = new FlowsService({
163
			accountability: req.accountability,
164
			schema: req.schema,
165
		});
166

167
		const primaryKey = await service.updateOne(req.params['pk']!, req.body);
168

169
		try {
170
			const item = await service.readOne(primaryKey, req.sanitizedQuery);
171
			res.locals['payload'] = { data: item || null };
172
		} catch (error: any) {
173
			if (isDirectusError(error, ErrorCode.Forbidden)) {
174
				return next();
175
			}
176

177
			throw error;
178
		}
179

180
		return next();
181
	}),
182
	respond,
183
);
184

185
router.delete(
186
	'/',
187
	asyncHandler(async (req, _res, next) => {
188
		const service = new FlowsService({
189
			accountability: req.accountability,
190
			schema: req.schema,
191
		});
192

193
		if (Array.isArray(req.body)) {
194
			await service.deleteMany(req.body);
195
		} else if (req.body.keys) {
196
			await service.deleteMany(req.body.keys);
197
		} else {
198
			const sanitizedQuery = sanitizeQuery(req.body.query, req.accountability);
199
			await service.deleteByQuery(sanitizedQuery);
200
		}
201

202
		return next();
203
	}),
204
	respond,
205
);
206

207
router.delete(
208
	'/:pk',
209
	asyncHandler(async (req, _res, next) => {
210
		const service = new FlowsService({
211
			accountability: req.accountability,
212
			schema: req.schema,
213
		});
214

215
		await service.deleteOne(req.params['pk']!);
216

217
		return next();
218
	}),
219
	respond,
220
);
221

222
export default router;
223