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 { RolesService } from '../services/roles.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_roles'));
15

16
router.post(
17
	'/',
18
	asyncHandler(async (req, res, next) => {
19
		const service = new RolesService({
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 items = await service.readMany(savedKeys, req.sanitizedQuery);
37
				res.locals['payload'] = { data: items };
38
			} else {
39
				const item = await service.readOne(savedKeys[0]!, req.sanitizedQuery);
40
				res.locals['payload'] = { data: item };
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 RolesService({
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
	const records = await service.readByQuery(req.sanitizedQuery);
67
	const meta = await metaService.getMetaForQuery('directus_roles', req.sanitizedQuery);
68

69
	res.locals['payload'] = { data: records || null, meta };
70
	return next();
71
});
72

73
router.get('/', validateBatch('read'), readHandler, respond);
74
router.search('/', validateBatch('read'), readHandler, respond);
75

76
router.get(
77
	'/:pk',
78
	asyncHandler(async (req, res, next) => {
79
		const service = new RolesService({
80
			accountability: req.accountability,
81
			schema: req.schema,
82
		});
83

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

86
		res.locals['payload'] = { data: record || null };
87
		return next();
88
	}),
89
	respond,
90
);
91

92
router.patch(
93
	'/',
94
	validateBatch('update'),
95
	asyncHandler(async (req, res, next) => {
96
		const service = new RolesService({
97
			accountability: req.accountability,
98
			schema: req.schema,
99
		});
100

101
		let keys: PrimaryKey[] = [];
102

103
		if (Array.isArray(req.body)) {
104
			keys = await service.updateBatch(req.body);
105
		} else if (req.body.keys) {
106
			keys = await service.updateMany(req.body.keys, req.body.data);
107
		} else {
108
			const sanitizedQuery = sanitizeQuery(req.body.query, req.accountability);
109
			keys = await service.updateByQuery(sanitizedQuery, req.body.data);
110
		}
111

112
		try {
113
			const result = await service.readMany(keys, req.sanitizedQuery);
114
			res.locals['payload'] = { data: result };
115
		} catch (error: any) {
116
			if (isDirectusError(error, ErrorCode.Forbidden)) {
117
				return next();
118
			}
119

120
			throw error;
121
		}
122

123
		return next();
124
	}),
125
	respond,
126
);
127

128
router.patch(
129
	'/:pk',
130
	asyncHandler(async (req, res, next) => {
131
		const service = new RolesService({
132
			accountability: req.accountability,
133
			schema: req.schema,
134
		});
135

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

138
		try {
139
			const item = await service.readOne(primaryKey, req.sanitizedQuery);
140
			res.locals['payload'] = { data: item || null };
141
		} catch (error: any) {
142
			if (isDirectusError(error, ErrorCode.Forbidden)) {
143
				return next();
144
			}
145

146
			throw error;
147
		}
148

149
		return next();
150
	}),
151
	respond,
152
);
153

154
router.delete(
155
	'/',
156
	validateBatch('delete'),
157
	asyncHandler(async (req, _res, next) => {
158
		const service = new RolesService({
159
			accountability: req.accountability,
160
			schema: req.schema,
161
		});
162

163
		if (Array.isArray(req.body)) {
164
			await service.deleteMany(req.body);
165
		} else if (req.body.keys) {
166
			await service.deleteMany(req.body.keys);
167
		} else {
168
			const sanitizedQuery = sanitizeQuery(req.body.query, req.accountability);
169
			await service.deleteByQuery(sanitizedQuery);
170
		}
171

172
		return next();
173
	}),
174
	respond,
175
);
176

177
router.delete(
178
	'/:pk',
179
	asyncHandler(async (req, _res, next) => {
180
		const service = new RolesService({
181
			accountability: req.accountability,
182
			schema: req.schema,
183
		});
184

185
		await service.deleteOne(req.params['pk']!);
186

187
		return next();
188
	}),
189
	respond,
190
);
191

192
export default router;
193