@directus/api 22.2.0 → 23.1.0

package/dist/app.js

@@ -14,6 +14,7 @@ import accessRouter from './controllers/access.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';
@@ -209,6 +210,7 @@ export default async function createApp() {
     app.use('/access', accessRouter);
     app.use('/assets', assetsRouter);
     app.use('/collections', collectionsRouter);
+    app.use('/comments', commentsRouter);
     app.use('/dashboards', dashboardsRouter);
     app.use('/extensions', extensionsRouter);
     app.use('/fields', fieldsRouter);

package/dist/auth/drivers/ldap.js

@@ -172,7 +172,7 @@ export class LDAPAuthDriver extends AuthDriver {
         }
         const logger = useLogger();
         await this.validateBindClient();
-        const { userDn, userScope, userAttribute, groupDn, groupScope, groupAttribute, defaultRoleId } = this.config;
+        const { userDn, userScope, userAttribute, groupDn, groupScope, groupAttribute, defaultRoleId, syncUserInfo } = this.config;
         const userInfo = await this.fetchUserInfo(userDn, new ldap.EqualityFilter({
             attribute: userAttribute ?? 'cn',
             value: payload['identifier'],
@@ -201,11 +201,22 @@ export class LDAPAuthDriver extends AuthDriver {
         if (userId) {
             // Run hook so the end user has the chance to augment the
             // user that is about to be updated
-            let updatedUserPayload = await emitter.emitFilter(`auth.update`, {}, { identifier: userInfo.dn, provider: this.config['provider'], providerPayload: { userInfo, userRole } }, { database: getDatabase(), schema: this.schema, accountability: null });
+            let emitPayload = {};
             // Only sync roles if the AD groups are configured
             if (groupDn) {
-                updatedUserPayload = { role: userRole?.id ?? defaultRoleId ?? null, ...updatedUserPayload };
+                emitPayload = {
+                    role: userRole?.id ?? defaultRoleId ?? null,
+                };
             }
+            if (syncUserInfo) {
+                emitPayload = {
+                    ...emitPayload,
+                    first_name: userInfo.firstName,
+                    last_name: userInfo.lastName,
+                    email: userInfo.email,
+                };
+            }
+            const updatedUserPayload = await emitter.emitFilter(`auth.update`, emitPayload, { identifier: userInfo.dn, provider: this.config['provider'], providerPayload: { userInfo, userRole } }, { database: getDatabase(), schema: this.schema, accountability: null });
             // Update user to update properties that might have changed
             await this.usersService.updateOne(userId, updatedUserPayload);
             return userId;

package/dist/auth/drivers/oauth2.js

@@ -106,7 +106,7 @@ export class OAuth2AuthDriver extends LocalAuthDriver {
         }
         // Flatten response to support dot indexes
         userInfo = flatten(userInfo);
-        const { provider, emailKey, identifierKey, allowPublicRegistration } = this.config;
+        const { provider, emailKey, identifierKey, allowPublicRegistration, syncUserInfo } = this.config;
         const email = userInfo[emailKey ?? 'email'] ? String(userInfo[emailKey ?? 'email']) : undefined;
         // Fallback to email if explicit identifier not found
         const identifier = userInfo[identifierKey] ? String(userInfo[identifierKey]) : email;
@@ -127,7 +127,18 @@ export class OAuth2AuthDriver extends LocalAuthDriver {
         if (userId) {
             // Run hook so the end user has the chance to augment the
             // user that is about to be updated
-            const updatedUserPayload = await emitter.emitFilter(`auth.update`, { auth_data: userPayload.auth_data }, {
+            let emitPayload = {
+                auth_data: userPayload.auth_data,
+            };
+            if (syncUserInfo) {
+                emitPayload = {
+                    ...emitPayload,
+                    first_name: userPayload.first_name,
+                    last_name: userPayload.last_name,
+                    email: userPayload.email,
+                };
+            }
+            const updatedUserPayload = await emitter.emitFilter(`auth.update`, emitPayload, {
                 identifier,
                 provider: this.config['provider'],
                 providerPayload: { accessToken: tokenSet.access_token, userInfo },

package/dist/auth/drivers/openid.js

@@ -125,7 +125,7 @@ export class OpenIDAuthDriver extends LocalAuthDriver {
         }
         // Flatten response to support dot indexes
         userInfo = flatten(userInfo);
-        const { provider, identifierKey, allowPublicRegistration, requireVerifiedEmail } = this.config;
+        const { provider, identifierKey, allowPublicRegistration, requireVerifiedEmail, syncUserInfo } = this.config;
         const email = userInfo['email'] ? String(userInfo['email']) : undefined;
         // Fallback to email if explicit identifier not found
         const identifier = userInfo[identifierKey ?? 'sub'] ? String(userInfo[identifierKey ?? 'sub']) : email;
@@ -146,7 +146,18 @@ export class OpenIDAuthDriver extends LocalAuthDriver {
         if (userId) {
             // Run hook so the end user has the chance to augment the
             // user that is about to be updated
-            const updatedUserPayload = await emitter.emitFilter(`auth.update`, { auth_data: userPayload.auth_data }, {
+            let emitPayload = {
+                auth_data: userPayload.auth_data,
+            };
+            if (syncUserInfo) {
+                emitPayload = {
+                    ...emitPayload,
+                    first_name: userPayload.first_name,
+                    last_name: userPayload.last_name,
+                    email: userPayload.email,
+                };
+            }
+            const updatedUserPayload = await emitter.emitFilter(`auth.update`, emitPayload, {
                 identifier,
                 provider: this.config['provider'],
                 providerPayload: { accessToken: tokenSet.access_token, userInfo },

package/dist/cache.js

@@ -1,13 +1,13 @@
 import { useEnv } from '@directus/env';
-import Keyv from 'keyv';
+import Keyv, {} from 'keyv';
 import { useBus } from './bus/index.js';
 import { useLogger } from './logger/index.js';
+import { clearCache as clearPermissionCache } from './permissions/cache.js';
 import { redisConfigAvailable } from './redis/index.js';
 import { compress, decompress } from './utils/compress.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
 import { getMilliseconds } from './utils/get-milliseconds.js';
 import { validateEnv } from './utils/validate-env.js';
-import { clearCache as clearPermissionCache } from './permissions/cache.js';
 import { createRequire } from 'node:module';
 const logger = useLogger();
 const env = useEnv();
@@ -106,10 +106,10 @@ function getKeyvInstance(store, ttl, namespaceSuffix) {
 function getConfig(store = 'memory', ttl, namespaceSuffix = '') {
     const config = {
         namespace: `${env['CACHE_NAMESPACE']}${namespaceSuffix}`,
-        ttl,
+        ...(ttl && { ttl }),
     };
     if (store === 'redis') {
-        const KeyvRedis = require('@keyv/redis');
+        const { default: KeyvRedis } = require('@keyv/redis');
         config.store = new KeyvRedis(env['REDIS'] || getConfigFromEnv('REDIS'), { useRedisSets: false });
     }
     return config;

package/dist/cli/commands/init/questions.d.ts

@@ -4,18 +4,18 @@ export declare const databaseQuestions: {
         filepath: string;
     }) => Record<string, string>)[];
     mysql2: (({ client }: {
-        client: Exclude<Driver, 'sqlite3'>;
+        client: Exclude<Driver, "sqlite3">;
     }) => Record<string, any>)[];
     pg: (({ client }: {
-        client: Exclude<Driver, 'sqlite3'>;
+        client: Exclude<Driver, "sqlite3">;
     }) => Record<string, any>)[];
     cockroachdb: (({ client }: {
-        client: Exclude<Driver, 'sqlite3'>;
+        client: Exclude<Driver, "sqlite3">;
     }) => Record<string, any>)[];
     oracledb: (({ client }: {
-        client: Exclude<Driver, 'sqlite3'>;
+        client: Exclude<Driver, "sqlite3">;
     }) => Record<string, any>)[];
     mssql: (({ client }: {
-        client: Exclude<Driver, 'sqlite3'>;
+        client: Exclude<Driver, "sqlite3">;
     }) => Record<string, any>)[];
 };

package/dist/cli/commands/schema/apply.d.ts

@@ -1,4 +1,5 @@
 export declare function apply(snapshotPath: string, options?: {
     yes: boolean;
     dryRun: boolean;
+    ignoreRules: string;
 }): Promise<void>;

package/dist/cli/commands/schema/apply.js

@@ -11,6 +11,22 @@ import { isNestedMetaUpdate } from '../../../utils/apply-diff.js';
 import { applySnapshot } from '../../../utils/apply-snapshot.js';
 import { getSnapshotDiff } from '../../../utils/get-snapshot-diff.js';
 import { getSnapshot } from '../../../utils/get-snapshot.js';
+function filterSnapshotDiff(snapshot, filters) {
+    const filterSet = new Set(filters);
+    function shouldKeep(item) {
+        if (filterSet.has(item.collection))
+            return false;
+        if (item.field && filterSet.has(`${item.collection}.${item.field}`))
+            return false;
+        return true;
+    }
+    const filteredDiff = {
+        collections: snapshot.collections.filter((item) => shouldKeep(item)),
+        fields: snapshot.fields.filter((item) => shouldKeep(item)),
+        relations: snapshot.relations.filter((item) => shouldKeep(item)),
+    };
+    return filteredDiff;
+}
 export async function apply(snapshotPath, options) {
     const logger = useLogger();
     const filename = path.resolve(process.cwd(), snapshotPath);
@@ -31,7 +47,10 @@ export async function apply(snapshotPath, options) {
             snapshot = parseJSON(fileContents);
         }
         const currentSnapshot = await getSnapshot({ database });
-        const snapshotDiff = getSnapshotDiff(currentSnapshot, snapshot);
+        let snapshotDiff = getSnapshotDiff(currentSnapshot, snapshot);
+        if (options?.ignoreRules) {
+            snapshotDiff = filterSnapshotDiff(snapshotDiff, options.ignoreRules.split(','));
+        }
         if (snapshotDiff.collections.length === 0 &&
             snapshotDiff.fields.length === 0 &&
             snapshotDiff.relations.length === 0) {

package/dist/cli/index.js

@@ -81,6 +81,7 @@ export async function createCli() {
         .description('Apply a snapshot file to the current database')
         .option('-y, --yes', `Assume "yes" as answer to all prompts and run non-interactively`)
         .option('-d, --dry-run', 'Plan and log changes to be applied', false)
+        .option('--ignoreRules <value>', `Comma-separated list of collections and or fields to ignore. Format: "products.title,reviews" this will ignore applying changes to the title field in the products collection and the entire reviews collection`)
         .argument('<path>', 'Path to snapshot file')
         .action(apply);
     await emitter.emitInit('cli.after', { program });

package/dist/cli/utils/create-env/env-stub.liquid

@@ -313,7 +313,7 @@ EXTENSIONS_AUTO_RELOAD=false
 EMAIL_FROM="no-reply@example.com"
 
 # What to use to send emails. One of
-# sendmail, smtp, mailgun, sendgrid, ses.
+# sendmail, smtp, mailgun, ses.
 EMAIL_TRANSPORT="sendmail"
 EMAIL_SENDMAIL_NEW_LINE="unix"
 EMAIL_SENDMAIL_PATH="/usr/sbin/sendmail"
@@ -340,6 +340,3 @@ EMAIL_SENDMAIL_PATH="/usr/sbin/sendmail"
 ## Email (Mailgun Transport)
 # EMAIL_MAILGUN_API_KEY="key-1234123412341234"
 # EMAIL_MAILGUN_DOMAIN="a domain name from https://app.mailgun.com/app/sending/domains"
-
-## Email (SendGrid Transport)
-# EMAIL_SENDGRID_API_KEY="key-1234123412341234"

package/dist/controllers/activity.js

@@ -1,15 +1,13 @@
-import { Action } from '@directus/constants';
-import { isDirectusError } from '@directus/errors';
+import { ErrorCode, 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 { CommentsService } from '../services/comments.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();
 router.use(useCollection('directus_activity'));
 const readHandler = asyncHandler(async (req, res, next) => {
@@ -22,6 +20,7 @@ const readHandler = asyncHandler(async (req, res, next) => {
         schema: req.schema,
     });
     let result;
+    let isComment;
     if (req.singleton) {
         result = await service.readSingleton(req.sanitizedQuery);
     }
@@ -29,9 +28,24 @@ const readHandler = asyncHandler(async (req, res, next) => {
         result = await service.readMany(req.body.keys, req.sanitizedQuery);
     }
     else {
-        result = await service.readByQuery(req.sanitizedQuery);
+        const sanitizedFilter = req.sanitizedQuery.filter;
+        if (sanitizedFilter &&
+            '_and' in sanitizedFilter &&
+            Array.isArray(sanitizedFilter['_and']) &&
+            sanitizedFilter['_and'].find((andItem) => 'action' in andItem && '_eq' in andItem['action'] && andItem['action']['_eq'] === 'comment')) {
+            const commentsService = new CommentsService({
+                accountability: req.accountability,
+                schema: req.schema,
+                serviceOrigin: 'activity',
+            });
+            result = await commentsService.readByQuery(req.sanitizedQuery);
+            isComment = true;
+        }
+        else {
+            result = await service.readByQuery(req.sanitizedQuery);
+        }
     }
-    const meta = await metaService.getMetaForQuery('directus_activity', req.sanitizedQuery);
+    const meta = await metaService.getMetaForQuery(isComment ? 'directus_comments' : 'directus_activity', req.sanitizedQuery);
     res.locals['payload'] = {
         data: result,
         meta,
@@ -57,22 +71,16 @@ const createCommentSchema = Joi.object({
     item: [Joi.number().required(), Joi.string().required()],
 });
 router.post('/comment', asyncHandler(async (req, res, next) => {
-    const service = new ActivityService({
+    const service = new CommentsService({
         accountability: req.accountability,
         schema: req.schema,
+        serviceOrigin: 'activity',
     });
     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'),
-    });
+    const primaryKey = await service.createOne(req.body);
     try {
         const record = await service.readOne(primaryKey, req.sanitizedQuery);
         res.locals['payload'] = {
@@ -91,17 +99,18 @@ const updateCommentSchema = Joi.object({
     comment: Joi.string().required(),
 });
 router.patch('/comment/:pk', asyncHandler(async (req, res, next) => {
-    const service = new ActivityService({
+    const commentsService = new CommentsService({
         accountability: req.accountability,
         schema: req.schema,
+        serviceOrigin: 'activity',
     });
     const { error } = updateCommentSchema.validate(req.body);
     if (error) {
         throw new InvalidPayloadError({ reason: error.message });
     }
-    const primaryKey = await service.updateOne(req.params['pk'], req.body);
+    const primaryKey = await commentsService.updateOne(req.params['pk'], req.body);
     try {
-        const record = await service.readOne(primaryKey, req.sanitizedQuery);
+        const record = await commentsService.readOne(primaryKey, req.sanitizedQuery);
         res.locals['payload'] = {
             data: record || null,
         };
@@ -115,18 +124,12 @@ router.patch('/comment/:pk', asyncHandler(async (req, res, next) => {
     return next();
 }), respond);
 router.delete('/comment/:pk', asyncHandler(async (req, _res, next) => {
-    const service = new ActivityService({
+    const commentsService = new CommentsService({
         accountability: req.accountability,
         schema: req.schema,
+        serviceOrigin: 'activity',
     });
-    const adminService = new ActivityService({
-        schema: req.schema,
-    });
-    const item = await adminService.readOne(req.params['pk'], { fields: ['action'] });
-    if (!item || item['action'] !== Action.COMMENT) {
-        throw new ForbiddenError();
-    }
-    await service.deleteOne(req.params['pk']);
+    await commentsService.deleteOne(req.params['pk']);
     return next();
 }), respond);
 export default router;

package/dist/controllers/assets.js

@@ -104,7 +104,7 @@ asyncHandler(async (req, res, next) => {
     return helmet.contentSecurityPolicy(merge({
         useDefaults: false,
         directives: {
-            defaultSrc: ['none'],
+            defaultSrc: [`'none'`],
         },
     }, getConfigFromEnv('ASSETS_CONTENT_SECURITY_POLICY')))(req, res, next);
 }), 

package/dist/controllers/comments.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/controllers/comments.js

@@ -0,0 +1,153 @@
+import { ErrorCode, isDirectusError } from '@directus/errors';
+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,
+        serviceOrigin: 'comments',
+    });
+    const savedKeys = [];
+    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) {
+        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,
+        serviceOrigin: 'comments',
+    });
+    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,
+        serviceOrigin: 'comments',
+    });
+    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,
+        serviceOrigin: 'comments',
+    });
+    let keys = [];
+    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) {
+        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,
+        serviceOrigin: 'comments',
+    });
+    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) {
+        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,
+        serviceOrigin: 'comments',
+    });
+    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,
+        serviceOrigin: 'comments',
+    });
+    await service.deleteOne(req.params['pk']);
+    return next();
+}), respond);
+export default router;

package/dist/controllers/versions.js

@@ -154,8 +154,14 @@ router.get('/:pk/compare', asyncHandler(async (req, res, next) => {
     });
     const version = await service.readOne(req.params['pk']);
     const { outdated, mainHash } = await service.verifyHash(version['collection'], version['item'], version['hash']);
-    const saves = await service.getVersionSavesById(version['id']);
-    const current = assign({}, ...saves);
+    let current;
+    if (version['delta']) {
+        current = version['delta'];
+    }
+    else {
+        const saves = await service.getVersionSavesById(version['id']);
+        current = assign({}, ...saves);
+    }
     const main = await service.getMainItem(version['collection'], version['item']);
     res.locals['payload'] = { data: { outdated, mainHash, current, main } };
     return next();
@@ -167,9 +173,8 @@ router.post('/:pk/save', asyncHandler(async (req, res, next) => {
     });
     const version = await service.readOne(req.params['pk']);
     const mainItem = await service.getMainItem(version['collection'], version['item']);
-    await service.save(req.params['pk'], req.body);
-    const saves = await service.getVersionSavesById(req.params['pk']);
-    const result = assign(mainItem, ...saves);
+    const updatedVersion = await service.save(req.params['pk'], req.body);
+    const result = assign(mainItem, updatedVersion);
     res.locals['payload'] = { data: result || null };
     return next();
 }), respond);

package/dist/database/index.js

@@ -140,6 +140,9 @@ export function getDatabase() {
             times.delete(queryInfo.__knexUid);
         }
         logger.trace(`[${delta ? delta.toFixed(3) : '?'}ms] ${queryInfo.sql} [${(queryInfo.bindings ?? []).join(', ')}]`);
+    })
+        .on('query-error', (_, queryInfo) => {
+        times.delete(queryInfo.__knexUid);
     });
     return database;
 }

package/dist/database/migrations/20210518A-add-foreign-key-constraints.js

@@ -43,7 +43,7 @@ export async function up(knex) {
                     .update({ [constraint.many_field]: null })
                     .whereIn(currentPrimaryKeyField, ids);
             }
-            catch (err) {
+            catch {
                 logger.error(`${constraint.many_collection}.${constraint.many_field} contains illegal foreign keys which couldn't be set to NULL. Please fix these references and rerun this migration to complete the upgrade.`);
                 if (ids.length < 25) {
                     logger.error(`Items with illegal foreign keys: ${ids.join(', ')}`);

package/dist/database/migrations/20240806A-permissions-policies.js

@@ -198,7 +198,7 @@ export async function up(knex) {
             table.dropForeign('role', foreignConstraint);
         });
     }
-    catch (err) {
+    catch {
         logger.warn('Failed to drop foreign key constraint on `role` column in `directus_permissions` table');
     }
     await knex('directus_permissions')

package/dist/database/migrations/20240909A-separate-comments.d.ts

@@ -0,0 +1,3 @@
+import type { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20240909A-separate-comments.js

@@ -0,0 +1,65 @@
+import { Action } from '@directus/constants';
+export async function up(knex) {
+    await knex.schema.createTable('directus_comments', (table) => {
+        table.uuid('id').primary().notNullable();
+        table
+            .string('collection', 64)
+            .notNullable()
+            .references('collection')
+            .inTable('directus_collections')
+            .onDelete('CASCADE');
+        table.string('item').notNullable();
+        table.text('comment').notNullable();
+        table.timestamp('date_created').defaultTo(knex.fn.now());
+        table.timestamp('date_updated').defaultTo(knex.fn.now());
+        table.uuid('user_created').references('id').inTable('directus_users').onDelete('SET NULL');
+        // Cannot have two constraints from/to the same table, handled on API side
+        table.uuid('user_updated').references('id').inTable('directus_users');
+    });
+}
+export async function down(knex) {
+    const rowsLimit = 50;
+    let hasMore = true;
+    while (hasMore) {
+        const comments = await knex
+            .select('id', 'collection', 'item', 'comment', 'date_created', 'user_created')
+            .from('directus_comments')
+            .limit(rowsLimit);
+        if (comments.length === 0) {
+            hasMore = false;
+            break;
+        }
+        await knex.transaction(async (trx) => {
+            for (const comment of comments) {
+                const migratedRecords = await trx('directus_activity')
+                    .select('id')
+                    .where('collection', '=', 'directus_comments')
+                    .andWhere('item', '=', comment.id)
+                    .andWhere('action', '=', Action.CREATE)
+                    .limit(1);
+                if (migratedRecords[0]) {
+                    await trx('directus_activity')
+                        .update({
+                        action: Action.COMMENT,
+                        collection: comment.collection,
+                        item: comment.item,
+                        comment: comment.comment,
+                    })
+                        .where('id', '=', migratedRecords[0].id);
+                }
+                else {
+                    await trx('directus_activity').insert({
+                        action: Action.COMMENT,
+                        collection: comment.collection,
+                        item: comment.item,
+                        comment: comment.comment,
+                        user: comment.user_created,
+                        timestamp: comment.date_created,
+                    });
+                }
+                await trx('directus_comments').where('id', '=', comment.id).delete();
+            }
+        });
+    }
+    await knex.schema.dropTable('directus_comments');
+}

package/dist/database/migrations/20240909B-consolidate-content-versioning.d.ts

@@ -0,0 +1,3 @@
+import type { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;