directus

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

12
const router = express.Router();
13

14
router.use(useCollection('directus_presets'));
15

16
router.post(
17
	'/',
18
	asyncHandler(async (req, res, next) => {
19
		const service = new PresetsService({
20
			accountability: req.accountability,
21
			schema: req.schema,
22
		});
23

24
		const savedKeys: PrimaryKey[] = [];
25

26
		if (Array.isArray(req.body)) {
27
			const keys = await service.createMany(req.body);
28
			savedKeys.push(...keys);
29
		} else {
30
			const key = await service.createOne(req.body);
31
			savedKeys.push(key);
32
		}
33

34
		try {
35
			if (Array.isArray(req.body)) {
36
				const records = await service.readMany(savedKeys, req.sanitizedQuery);
37
				res.locals['payload'] = { data: records };
38
			} else {
39
				const record = await service.readOne(savedKeys[0]!, req.sanitizedQuery);
40
				res.locals['payload'] = { data: record };
41
			}
42
		} catch (error: any) {
43
			if (isDirectusError(error, ErrorCode.Forbidden)) {
44
				return next();
45
			}
46

47
			throw error;
48
		}
49

50
		return next();
51
	}),
52
	respond,
53
);
54

55
const readHandler = asyncHandler(async (req, res, next) => {
56
	const service = new PresetsService({
57
		accountability: req.accountability,
58
		schema: req.schema,
59
	});
60

61
	const metaService = new MetaService({
62
		accountability: req.accountability,
63
		schema: req.schema,
64
	});
65

66
	let result;
67

68
	if (req.singleton) {
69
		result = await service.readSingleton(req.sanitizedQuery);
70
	} else if (req.body.keys) {
71
		result = await service.readMany(req.body.keys, req.sanitizedQuery);
72
	} else {
73
		result = await service.readByQuery(req.sanitizedQuery);
74
	}
75

76
	const meta = await metaService.getMetaForQuery('directus_presets', req.sanitizedQuery);
77

78
	res.locals['payload'] = { data: result, meta };
79
	return next();
80
});
81

82
router.get('/', validateBatch('read'), readHandler, respond);
83
router.search('/', validateBatch('read'), readHandler, respond);
84

85
router.get(
86
	'/:pk',
87
	asyncHandler(async (req, res, next) => {
88
		const service = new PresetsService({
89
			accountability: req.accountability,
90
			schema: req.schema,
91
		});
92

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

95
		res.locals['payload'] = { data: record || null };
96
		return next();
97
	}),
98
	respond,
99
);
100

101
router.patch(
102
	'/',
103
	validateBatch('update'),
104
	asyncHandler(async (req, res, next) => {
105
		const service = new PresetsService({
106
			accountability: req.accountability,
107
			schema: req.schema,
108
		});
109

110
		let keys: PrimaryKey[] = [];
111

112
		if (Array.isArray(req.body)) {
113
			keys = await service.updateBatch(req.body);
114
		} else if (req.body.keys) {
115
			keys = await service.updateMany(req.body.keys, req.body.data);
116
		} else {
117
			const sanitizedQuery = sanitizeQuery(req.body.query, req.accountability);
118
			keys = await service.updateByQuery(sanitizedQuery, req.body.data);
119
		}
120

121
		try {
122
			const result = await service.readMany(keys, req.sanitizedQuery);
123
			res.locals['payload'] = { data: result };
124
		} catch (error: any) {
125
			if (isDirectusError(error, ErrorCode.Forbidden)) {
126
				return next();
127
			}
128

129
			throw error;
130
		}
131

132
		return next();
133
	}),
134
	respond,
135
);
136

137
router.patch(
138
	'/:pk',
139
	asyncHandler(async (req, res, next) => {
140
		const service = new PresetsService({
141
			accountability: req.accountability,
142
			schema: req.schema,
143
		});
144

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

147
		try {
148
			const record = await service.readOne(primaryKey, req.sanitizedQuery);
149
			res.locals['payload'] = { data: record };
150
		} catch (error: any) {
151
			if (isDirectusError(error, ErrorCode.Forbidden)) {
152
				return next();
153
			}
154

155
			throw error;
156
		}
157

158
		return next();
159
	}),
160
	respond,
161
);
162

163
router.delete(
164
	'/',
165
	validateBatch('delete'),
166
	asyncHandler(async (req, _res, next) => {
167
		const service = new PresetsService({
168
			accountability: req.accountability,
169
			schema: req.schema,
170
		});
171

172
		if (Array.isArray(req.body)) {
173
			await service.deleteMany(req.body);
174
		} else if (req.body.keys) {
175
			await service.deleteMany(req.body.keys);
176
		} else {
177
			const sanitizedQuery = sanitizeQuery(req.body.query, req.accountability);
178
			await service.deleteByQuery(sanitizedQuery);
179
		}
180

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

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

194
		await service.deleteOne(req.params['pk']!);
195

196
		return next();
197
	}),
198
	respond,
199
);
200

201
export default router;
202