Extract comments to a separate table

.changeset/blue-pets-beam.md

@@ -0,0 +1,10 @@
+---
+'@directus/api': major
+'@directus/sdk': major
+'@directus/system-data': minor
+'@directus/specs': minor
+'@directus/types': minor
+'@directus/app': minor
+---
+
+Extracted comments to a separate table

api/src/app.ts

@@ -15,6 +15,7 @@ import activityRouter from './controllers/activity.js';
 import assetsRouter from './controllers/assets.js';
 import authRouter from './controllers/auth.js';
 import collectionsRouter from './controllers/collections.js';
+import commentsRouter from './controllers/comments.js';
 import dashboardsRouter from './controllers/dashboards.js';
 import extensionsRouter from './controllers/extensions.js';
 import fieldsRouter from './controllers/fields.js';
@@ -280,6 +281,7 @@ export default async function createApp(): Promise<express.Application> {
 	app.use('/activity', activityRouter);
 	app.use('/assets', assetsRouter);
 	app.use('/collections', collectionsRouter);
+	app.use('/comments', commentsRouter);
 	app.use('/dashboards', dashboardsRouter);
 	app.use('/extensions', extensionsRouter);
 	app.use('/fields', fieldsRouter);

api/src/controllers/activity.ts

@@ -1,15 +1,13 @@
 import { Action } from '@directus/constants';
-import { isDirectusError } from '@directus/errors';
+import { ErrorCode, ForbiddenError, InvalidPayloadError, isDirectusError } from '@directus/errors';
 import express from 'express';
 import Joi from 'joi';
-import { ErrorCode, ForbiddenError, InvalidPayloadError } from '@directus/errors';
 import { respond } from '../middleware/respond.js';
 import useCollection from '../middleware/use-collection.js';
 import { validateBatch } from '../middleware/validate-batch.js';
 import { ActivityService } from '../services/activity.js';
 import { MetaService } from '../services/meta.js';
 import asyncHandler from '../utils/async-handler.js';
-import { getIPFromReq } from '../utils/get-ip-from-req.js';
 
 const router = express.Router();
 
@@ -68,54 +66,7 @@ router.get(
 	respond,
 );
 
-const createCommentSchema = Joi.object({
-	comment: Joi.string().required(),
-	collection: Joi.string().required(),
-	item: [Joi.number().required(), Joi.string().required()],
-});
-
-router.post(
-	'/comment',
-	asyncHandler(async (req, res, next) => {
-		const service = new ActivityService({
-			accountability: req.accountability,
-			schema: req.schema,
-		});
-
-		const { error } = createCommentSchema.validate(req.body);
-
-		if (error) {
-			throw new InvalidPayloadError({ reason: error.message });
-		}
-
-		const primaryKey = await service.createOne({
-			...req.body,
-			action: Action.COMMENT,
-			user: req.accountability?.user,
-			ip: getIPFromReq(req),
-			user_agent: req.accountability?.userAgent,
-			origin: req.get('origin'),
-		});
-
-		try {
-			const record = await service.readOne(primaryKey, req.sanitizedQuery);
-
-			res.locals['payload'] = {
-				data: record || null,
-			};
-		} catch (error: any) {
-			if (isDirectusError(error, ErrorCode.Forbidden)) {
-				return next();
-			}
-
-			throw error;
-		}
-
-		return next();
-	}),
-	respond,
-);
-
+// TODO: Remove legacy commenting in upcoming version
 const updateCommentSchema = Joi.object({
 	comment: Joi.string().required(),
 });

api/src/controllers/comments.ts

@@ -0,0 +1,199 @@
+import { ErrorCode, isDirectusError } from '@directus/errors';
+import type { PrimaryKey } from '@directus/types';
+import express from 'express';
+import { respond } from '../middleware/respond.js';
+import useCollection from '../middleware/use-collection.js';
+import { validateBatch } from '../middleware/validate-batch.js';
+import { CommentsService } from '../services/comments.js';
+import { MetaService } from '../services/meta.js';
+import asyncHandler from '../utils/async-handler.js';
+import { sanitizeQuery } from '../utils/sanitize-query.js';
+
+const router = express.Router();
+
+router.use(useCollection('directus_comments'));
+
+router.post(
+	'/',
+	asyncHandler(async (req, res, next) => {
+		const service = new CommentsService({
+			accountability: req.accountability,
+			schema: req.schema,
+		});
+
+		const savedKeys: PrimaryKey[] = [];
+
+		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 records = await service.readMany(savedKeys, req.sanitizedQuery);
+				res.locals['payload'] = { data: records };
+			} else {
+				const record = await service.readOne(savedKeys[0]!, req.sanitizedQuery);
+				res.locals['payload'] = { data: record };
+			}
+		} catch (error: any) {
+			if (isDirectusError(error, ErrorCode.Forbidden)) {
+				return next();
+			}
+
+			throw error;
+		}
+
+		return next();
+	}),
+	respond,
+);
+
+const readHandler = asyncHandler(async (req, res, next) => {
+	const service = new CommentsService({
+		accountability: req.accountability,
+		schema: req.schema,
+	});
+
+	const metaService = new MetaService({
+		accountability: req.accountability,
+		schema: req.schema,
+	});
+
+	let result;
+
+	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('directus_comments', req.sanitizedQuery);
+
+	res.locals['payload'] = { data: result, meta };
+	return next();
+});
+
+router.get('/', validateBatch('read'), readHandler, respond);
+router.search('/', validateBatch('read'), readHandler, respond);
+
+router.get(
+	'/:pk',
+	asyncHandler(async (req, res, next) => {
+		const service = new CommentsService({
+			accountability: req.accountability,
+			schema: req.schema,
+		});
+
+		const record = await service.readOne(req.params['pk']!, req.sanitizedQuery);
+
+		res.locals['payload'] = { data: record || null };
+		return next();
+	}),
+	respond,
+);
+
+router.patch(
+	'/',
+	validateBatch('update'),
+	asyncHandler(async (req, res, next) => {
+		const service = new CommentsService({
+			accountability: req.accountability,
+			schema: req.schema,
+		});
+
+		let keys: PrimaryKey[] = [];
+
+		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 = sanitizeQuery(req.body.query, 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: any) {
+			if (isDirectusError(error, ErrorCode.Forbidden)) {
+				return next();
+			}
+
+			throw error;
+		}
+
+		return next();
+	}),
+	respond,
+);
+
+router.patch(
+	'/:pk',
+	asyncHandler(async (req, res, next) => {
+		const service = new CommentsService({
+			accountability: req.accountability,
+			schema: req.schema,
+		});
+
+		const primaryKey = await service.updateOne(req.params['pk']!, req.body);
+
+		try {
+			const record = await service.readOne(primaryKey, req.sanitizedQuery);
+			res.locals['payload'] = { data: record };
+		} catch (error: any) {
+			if (isDirectusError(error, ErrorCode.Forbidden)) {
+				return next();
+			}
+
+			throw error;
+		}
+
+		return next();
+	}),
+	respond,
+);
+
+router.delete(
+	'/',
+	validateBatch('delete'),
+	asyncHandler(async (req, _res, next) => {
+		const service = new CommentsService({
+			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 = sanitizeQuery(req.body.query, req.accountability);
+			await service.deleteByQuery(sanitizedQuery);
+		}
+
+		return next();
+	}),
+	respond,
+);
+
+router.delete(
+	'/:pk',
+	asyncHandler(async (req, _res, next) => {
+		const service = new CommentsService({
+			accountability: req.accountability,
+			schema: req.schema,
+		});
+
+		await service.deleteOne(req.params['pk']!);
+
+		return next();
+	}),
+	respond,
+);
+
+export default router;