@directus/api 23.1.3 → 23.2.1

package/dist/services/comments.js

@@ -1,96 +1,29 @@
-import { Action } from '@directus/constants';
 import { useEnv } from '@directus/env';
 import { ErrorCode, ForbiddenError, InvalidPayloadError, isDirectusError } from '@directus/errors';
-import { cloneDeep, mergeWith, uniq } from 'lodash-es';
-import { randomUUID } from 'node:crypto';
+import { uniq } from 'lodash-es';
 import { useLogger } from '../logger/index.js';
 import { fetchRolesTree } from '../permissions/lib/fetch-roles-tree.js';
 import { fetchGlobalAccess } from '../permissions/modules/fetch-global-access/fetch-global-access.js';
 import { validateAccess } from '../permissions/modules/validate-access/validate-access.js';
 import { isValidUuid } from '../utils/is-valid-uuid.js';
-import { transaction } from '../utils/transaction.js';
 import { Url } from '../utils/url.js';
 import { userName } from '../utils/user-name.js';
-import { ActivityService } from './activity.js';
 import { ItemsService } from './items.js';
 import { NotificationsService } from './notifications.js';
 import { UsersService } from './users.js';
 const env = useEnv();
 const logger = useLogger();
-// TODO: Remove legacy comments logic
 export class CommentsService extends ItemsService {
-    activityService;
     notificationsService;
     usersService;
-    serviceOrigin;
     constructor(options) {
         super('directus_comments', options);
-        this.activityService = new ActivityService(options);
         this.notificationsService = new NotificationsService({ schema: this.schema });
         this.usersService = new UsersService({ schema: this.schema });
-        this.serviceOrigin = options.serviceOrigin ?? 'comments';
-    }
-    readOne(key, query, opts) {
-        const isLegacyComment = isNaN(Number(key));
-        let result;
-        if (isLegacyComment) {
-            const activityQuery = this.serviceOrigin === 'activity' ? query : this.generateQuery('activity', query || {});
-            result = this.activityService.readOne(key, activityQuery, opts);
-        }
-        else {
-            const commentsQuery = this.serviceOrigin === 'comments' ? query : this.generateQuery('comments', query || {});
-            result = super.readOne(key, commentsQuery, opts);
-        }
-        return result;
-    }
-    async readByQuery(query, opts) {
-        const activityQuery = this.serviceOrigin === 'activity' ? query : this.generateQuery('activity', query);
-        const commentsQuery = this.serviceOrigin === 'comments' ? query : this.generateQuery('comments', query);
-        const activityResult = await this.activityService.readByQuery(activityQuery, opts);
-        const commentsResult = await super.readByQuery(commentsQuery, opts);
-        if (query.aggregate) {
-            // Merging the first result only as the app does not utilise group
-            return [
-                mergeWith({}, activityResult[0], commentsResult[0], (a, b) => {
-                    const numA = Number(a);
-                    const numB = Number(b);
-                    if (!isNaN(numA) && !isNaN(numB)) {
-                        return numA + numB;
-                    }
-                    return;
-                }),
-            ];
-        }
-        else if (query.sort) {
-            return this.sortLegacyResults([...activityResult, ...commentsResult], query.sort);
-        }
-        else {
-            return [...activityResult, ...commentsResult];
-        }
-    }
-    async readMany(keys, query, opts) {
-        const commentsKeys = [];
-        const activityKeys = [];
-        for (const key of keys) {
-            if (isNaN(Number(key))) {
-                commentsKeys.push(key);
-            }
-            else {
-                activityKeys.push(key);
-            }
-        }
-        const activityQuery = this.serviceOrigin === 'activity' ? query : this.generateQuery('activity', query || {});
-        const commentsQuery = this.serviceOrigin === 'comments' ? query : this.generateQuery('comments', query || {});
-        const activityResult = await this.activityService.readMany(activityKeys, activityQuery, opts);
-        const commentsResult = await super.readMany(commentsKeys, commentsQuery, opts);
-        if (query?.sort) {
-            return this.sortLegacyResults([...activityResult, ...commentsResult], query.sort);
-        }
-        else {
-            return [...activityResult, ...commentsResult];
-        }
     }
     async createOne(data, opts) {
+        if (!this.accountability?.user)
+            throw new ForbiddenError();
         if (!data['comment']) {
             throw new InvalidPayloadError({ reason: `"comment" is required` });
         }
@@ -111,8 +44,12 @@ export class CommentsService extends ItemsService {
                 knex: this.knex,
             });
         }
+        const result = await super.createOne(data, opts);
         const usersRegExp = new RegExp(/@[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}/gi);
         const mentions = uniq(data['comment'].match(usersRegExp) ?? []);
+        if (mentions.length === 0) {
+            return result;
+        }
         const sender = await this.usersService.readOne(this.accountability.user, {
             fields: ['id', 'first_name', 'last_name', 'email'],
         });
@@ -190,189 +127,16 @@ ${comment}
                 }
             }
         }
-        return super.createOne(data, opts);
-    }
-    async updateByQuery(query, data, opts) {
-        const keys = await this.getKeysByQuery(query);
-        const migratedKeys = await this.processPrimaryKeys(keys);
-        return super.updateMany(migratedKeys, data, opts);
-    }
-    async updateMany(keys, data, opts) {
-        const migratedKeys = await this.processPrimaryKeys(keys);
-        return super.updateMany(migratedKeys, data, opts);
-    }
-    async updateOne(key, data, opts) {
-        const migratedKey = await this.migrateLegacyComment(key);
-        return super.updateOne(migratedKey, data, opts);
-    }
-    async deleteByQuery(query, opts) {
-        const keys = await this.getKeysByQuery(query);
-        const migratedKeys = await this.processPrimaryKeys(keys);
-        return super.deleteMany(migratedKeys, opts);
-    }
-    async deleteMany(keys, opts) {
-        const migratedKeys = await this.processPrimaryKeys(keys);
-        return super.deleteMany(migratedKeys, opts);
-    }
-    async deleteOne(key, opts) {
-        const migratedKey = await this.migrateLegacyComment(key);
-        return super.deleteOne(migratedKey, opts);
-    }
-    async processPrimaryKeys(keys) {
-        const migratedKeys = [];
-        for (const key of keys) {
-            if (isNaN(Number(key))) {
-                migratedKeys.push(key);
-                continue;
-            }
-            migratedKeys.push(await this.migrateLegacyComment(key));
-        }
-        return migratedKeys;
-    }
-    async migrateLegacyComment(activityPk) {
-        // Skip migration if not a legacy comment
-        if (isNaN(Number(activityPk))) {
-            return activityPk;
-        }
-        return transaction(this.knex, async (trx) => {
-            let primaryKey;
-            const legacyComment = await trx('directus_activity').select('*').where('id', '=', activityPk).first();
-            // Legacy comment
-            if (legacyComment['action'] === Action.COMMENT) {
-                primaryKey = randomUUID();
-                await trx('directus_comments').insert({
-                    id: primaryKey,
-                    collection: legacyComment.collection,
-                    item: legacyComment.item,
-                    comment: legacyComment.comment,
-                    user_created: legacyComment.user,
-                    date_created: legacyComment.timestamp,
-                });
-                await trx('directus_activity')
-                    .update({
-                    action: Action.CREATE,
-                    collection: 'directus_comments',
-                    item: primaryKey,
-                    comment: null,
-                })
-                    .where('id', '=', activityPk);
-            }
-            // Migrated comment
-            else if (legacyComment.collection === 'directus_comment' && legacyComment.action === Action.CREATE) {
-                primaryKey = legacyComment.item;
-            }
-            if (!primaryKey) {
-                throw new ForbiddenError();
-            }
-            return primaryKey;
-        });
+        return result;
     }
-    generateQuery(type, originalQuery) {
-        const query = cloneDeep(originalQuery);
-        const defaultActivityCommentFilter = { action: { _eq: Action.COMMENT } };
-        const commentsToActivityFieldMap = {
-            id: 'id',
-            comment: 'comment',
-            item: 'item',
-            collection: 'collection',
-            user_created: 'user',
-            date_created: 'timestamp',
-        };
-        const activityToCommentsFieldMap = {
-            id: 'id',
-            comment: 'comment',
-            item: 'item',
-            collection: 'collection',
-            user: 'user_created',
-            timestamp: 'date_created',
-        };
-        const targetFieldMap = type === 'activity' ? commentsToActivityFieldMap : activityToCommentsFieldMap;
-        for (const key of Object.keys(originalQuery)) {
-            switch (key) {
-                case 'fields':
-                    if (!originalQuery.fields)
-                        break;
-                    query.fields = [];
-                    for (const field of originalQuery.fields) {
-                        if (field === '*') {
-                            query.fields = ['*'];
-                            break;
-                        }
-                        const parts = field.split('.');
-                        const firstPart = parts[0];
-                        if (firstPart && targetFieldMap[firstPart]) {
-                            query.fields.push(field);
-                            if (firstPart !== targetFieldMap[firstPart]) {
-                                (query.alias = query.alias || {})[firstPart] = targetFieldMap[firstPart];
-                            }
-                        }
-                    }
-                    break;
-                case 'filter':
-                    if (!originalQuery.filter)
-                        break;
-                    if (type === 'activity') {
-                        query.filter = { _and: [defaultActivityCommentFilter, originalQuery.filter] };
-                    }
-                    if (type === 'comments' && this.serviceOrigin === 'activity') {
-                        if ('_and' in originalQuery.filter && Array.isArray(originalQuery.filter['_and'])) {
-                            query.filter = {
-                                _and: originalQuery.filter['_and'].filter((andItem) => !('action' in andItem && '_eq' in andItem['action'] && andItem['action']['_eq'] === 'comment')),
-                            };
-                        }
-                        else {
-                            query.filter = originalQuery.filter;
-                        }
-                    }
-                    break;
-                case 'aggregate':
-                    if (originalQuery.aggregate) {
-                        query.aggregate = originalQuery.aggregate;
-                    }
-                    break;
-                case 'sort':
-                    if (!originalQuery.sort)
-                        break;
-                    query.sort = [];
-                    for (const sort of originalQuery.sort) {
-                        const isDescending = sort.startsWith('-');
-                        const field = isDescending ? sort.slice(1) : sort;
-                        if (field && targetFieldMap[field]) {
-                            query.sort.push(`${isDescending ? '-' : ''}${targetFieldMap[field]}`);
-                        }
-                    }
-                    break;
-            }
-        }
-        if (type === 'activity' && !query.filter) {
-            query.filter = defaultActivityCommentFilter;
-        }
-        return query;
+    updateOne(key, data, opts) {
+        if (!this.accountability?.user)
+            throw new ForbiddenError();
+        return super.updateOne(key, data, opts);
     }
-    sortLegacyResults(results, sort) {
-        if (!sort)
-            return results;
-        let sortKeys = sort;
-        // Fix legacy app sort query which uses id
-        if (sortKeys.length === 1 && sortKeys[0]?.endsWith('id') && results[0]?.['timestamp']) {
-            sortKeys = [`${sortKeys[0].startsWith('-') ? '-' : ''}timestamp`];
-        }
-        return results.sort((a, b) => {
-            for (const key of sortKeys) {
-                const isDescending = key.startsWith('-');
-                const actualKey = isDescending ? key.substring(1) : key;
-                let aValue = a[actualKey];
-                let bValue = b[actualKey];
-                if (actualKey === 'date_created' || actualKey === 'timestamp') {
-                    aValue = new Date(aValue);
-                    bValue = new Date(bValue);
-                }
-                if (aValue < bValue)
-                    return isDescending ? 1 : -1;
-                if (aValue > bValue)
-                    return isDescending ? -1 : 1;
-            }
-            return 0;
-        });
+    deleteOne(key, opts) {
+        if (!this.accountability?.user)
+            throw new ForbiddenError();
+        return super.deleteOne(key, opts);
     }
 }

package/dist/services/graphql/index.d.ts

@@ -67,11 +67,10 @@ export declare class GraphQLService {
      * Effectively merges the selections with the fragments used in those selections
      */
     replaceFragmentsInSelections(selections: readonly SelectionNode[] | undefined, fragments: Record<string, FragmentDefinitionNode>): readonly SelectionNode[] | null;
-    injectSystemResolvers(schemaComposer: SchemaComposer<GraphQLParams['contextValue']>, { CreateCollectionTypes, ReadCollectionTypes, UpdateCollectionTypes, DeleteCollectionTypes, }: {
+    injectSystemResolvers(schemaComposer: SchemaComposer<GraphQLParams['contextValue']>, { CreateCollectionTypes, ReadCollectionTypes, UpdateCollectionTypes, }: {
         CreateCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
         ReadCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
         UpdateCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
-        DeleteCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
     }, schema: {
         create: SchemaOverview;
         read: SchemaOverview;

package/dist/services/graphql/index.js

@@ -29,7 +29,6 @@ import { sanitizeQuery } from '../../utils/sanitize-query.js';
 import { validateQuery } from '../../utils/validate-query.js';
 import { AuthenticationService } from '../authentication.js';
 import { CollectionsService } from '../collections.js';
-import { CommentsService } from '../comments.js';
 import { ExtensionsService } from '../extensions.js';
 import { FieldsService } from '../fields.js';
 import { FilesService } from '../files.js';
@@ -196,7 +195,6 @@ export class GraphQLService {
                 CreateCollectionTypes,
                 ReadCollectionTypes,
                 UpdateCollectionTypes,
-                DeleteCollectionTypes,
             }, schema);
         }
         const readableCollections = Object.values(schema.read.collections)
@@ -1650,7 +1648,7 @@ export class GraphQLService {
         })).filter((s) => s);
         return result;
     }
-    injectSystemResolvers(schemaComposer, { CreateCollectionTypes, ReadCollectionTypes, UpdateCollectionTypes, DeleteCollectionTypes, }, schema) {
+    injectSystemResolvers(schemaComposer, { CreateCollectionTypes, ReadCollectionTypes, UpdateCollectionTypes, }, schema) {
         const AuthTokens = schemaComposer.createObjectTC({
             name: 'auth_tokens',
             fields: {
@@ -2764,78 +2762,6 @@ export class GraphQLService {
                 },
             });
         }
-        if ('directus_activity' in schema.create.collections) {
-            schemaComposer.Mutation.addFields({
-                create_comment: {
-                    type: ReadCollectionTypes['directus_activity'] ?? GraphQLBoolean,
-                    args: {
-                        collection: new GraphQLNonNull(GraphQLString),
-                        item: new GraphQLNonNull(GraphQLID),
-                        comment: new GraphQLNonNull(GraphQLString),
-                    },
-                    resolve: async (_, args, __, info) => {
-                        const service = new CommentsService({
-                            accountability: this.accountability,
-                            schema: this.schema,
-                            serviceOrigin: 'activity',
-                        });
-                        const primaryKey = await service.createOne({
-                            ...args,
-                        });
-                        if ('directus_activity' in ReadCollectionTypes) {
-                            const selections = this.replaceFragmentsInSelections(info.fieldNodes[0]?.selectionSet?.selections, info.fragments);
-                            const query = this.getQuery(args, selections || [], info.variableValues);
-                            return await service.readOne(primaryKey, query);
-                        }
-                        return true;
-                    },
-                },
-            });
-        }
-        if ('directus_activity' in schema.update.collections) {
-            schemaComposer.Mutation.addFields({
-                update_comment: {
-                    type: ReadCollectionTypes['directus_activity'] ?? GraphQLBoolean,
-                    args: {
-                        id: new GraphQLNonNull(GraphQLID),
-                        comment: new GraphQLNonNull(GraphQLString),
-                    },
-                    resolve: async (_, args, __, info) => {
-                        const commentsService = new CommentsService({
-                            accountability: this.accountability,
-                            schema: this.schema,
-                            serviceOrigin: 'activity',
-                        });
-                        const primaryKey = await commentsService.updateOne(args['id'], { comment: args['comment'] });
-                        if ('directus_activity' in ReadCollectionTypes) {
-                            const selections = this.replaceFragmentsInSelections(info.fieldNodes[0]?.selectionSet?.selections, info.fragments);
-                            const query = this.getQuery(args, selections || [], info.variableValues);
-                            return { ...(await commentsService.readOne(primaryKey, query)), id: args['id'] };
-                        }
-                        return true;
-                    },
-                },
-            });
-        }
-        if ('directus_activity' in schema.delete.collections) {
-            schemaComposer.Mutation.addFields({
-                delete_comment: {
-                    type: DeleteCollectionTypes['one'],
-                    args: {
-                        id: new GraphQLNonNull(GraphQLID),
-                    },
-                    resolve: async (_, args) => {
-                        const commentsService = new CommentsService({
-                            accountability: this.accountability,
-                            schema: this.schema,
-                            serviceOrigin: 'activity',
-                        });
-                        await commentsService.deleteOne(args['id']);
-                        return { id: args['id'] };
-                    },
-                },
-            });
-        }
         if ('directus_files' in schema.create.collections) {
             schemaComposer.Mutation.addFields({
                 import_file: {

package/dist/services/specifications.js

@@ -299,8 +299,19 @@ class OASSpecsService {
                     properties: {},
                     'x-collection': collection.collection,
                 };
+                // Track required fields
+                const requiredFields = [];
                 for (const field of fieldsInCollection) {
-                    schemaComponent.properties[field.field] = this.generateField(schema, collection.collection, field, tags);
+                    const fieldSchema = this.generateField(schema, collection.collection, field, tags);
+                    schemaComponent.properties[field.field] = fieldSchema;
+                    // Check if field is required
+                    if (field.nullable === false && field.defaultValue === null && field.generated === false) {
+                        requiredFields.push(field.field);
+                    }
+                }
+                // Only add required if there are actually required fields
+                if (requiredFields.length > 0) {
+                    schemaComponent.required = requiredFields;
                 }
                 components.schemas[tag.name] = schemaComponent;
             }

package/dist/services/users.js

@@ -131,7 +131,7 @@ export class UsersService extends ItemsService {
      */
     async createOne(data, opts = {}) {
         try {
-            if ('email' in data) {
+            if ('email' in data && data['email'] !== undefined) {
                 this.validateEmail(data['email']);
                 await this.checkUniqueEmails([data['email']]);
             }

package/dist/services/versions.d.ts

@@ -9,7 +9,6 @@ export declare class VersionsService extends ItemsService {
         outdated: boolean;
         mainHash: string;
     }>;
-    getVersionSavesById(id: PrimaryKey): Promise<Partial<Item>[]>;
     getVersionSaves(key: string, collection: string, item: string | undefined): Promise<Partial<Item>[] | null>;
     createOne(data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
     createMany(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;

package/dist/services/versions.js

@@ -82,17 +82,6 @@ export class VersionsService extends ItemsService {
         const mainHash = objectHash(mainItem);
         return { outdated: hash !== mainHash, mainHash };
     }
-    async getVersionSavesById(id) {
-        const revisionsService = new RevisionsService({
-            knex: this.knex,
-            schema: this.schema,
-        });
-        const result = await revisionsService.readByQuery({
-            filter: { version: { _eq: id } },
-        });
-        return result.map((revision) => revision['delta']);
-    }
-    // TODO: Remove legacy need to return a version array in subsequent release
     async getVersionSaves(key, collection, item) {
         const filter = {
             key: { _eq: key },
@@ -107,8 +96,7 @@ export class VersionsService extends ItemsService {
         if (versions[0]['delta']) {
             return [versions[0]['delta']];
         }
-        const saves = await this.getVersionSavesById(versions[0]['id']);
-        return saves;
+        return null;
     }
     async createOne(data, opts) {
         await this.validateCreateData(data);
@@ -202,12 +190,7 @@ export class VersionsService extends ItemsService {
             data: revisionDelta,
             delta: revisionDelta,
         });
-        let existingDelta = version['delta'];
-        if (!existingDelta) {
-            const saves = await this.getVersionSavesById(key);
-            existingDelta = assign({}, ...saves);
-        }
-        const finalVersionDelta = assign({}, existingDelta, revisionDelta ? JSON.parse(revisionDelta) : null);
+        const finalVersionDelta = assign({}, version['delta'], revisionDelta ? JSON.parse(revisionDelta) : null);
         const sudoService = new ItemsService(this.collection, {
             knex: this.knex,
             schema: this.schema,
@@ -220,7 +203,7 @@ export class VersionsService extends ItemsService {
         return finalVersionDelta;
     }
     async promote(version, mainHash, fields) {
-        const { id, collection, item, delta } = (await this.readOne(version));
+        const { collection, item, delta } = (await this.readOne(version));
         // will throw an error if the accountability does not have permission to update the item
         if (this.accountability) {
             await validateAccess({
@@ -233,21 +216,18 @@ export class VersionsService extends ItemsService {
                 knex: this.knex,
             });
         }
+        if (!delta) {
+            throw new UnprocessableContentError({
+                reason: `No changes to promote`,
+            });
+        }
         const { outdated } = await this.verifyHash(collection, item, mainHash);
         if (outdated) {
             throw new UnprocessableContentError({
                 reason: `Main item has changed since this version was last updated`,
             });
         }
-        let versionResult;
-        if (delta) {
-            versionResult = delta;
-        }
-        else {
-            const saves = await this.getVersionSavesById(id);
-            versionResult = assign({}, ...saves);
-        }
-        const payloadToUpdate = fields ? pick(versionResult, fields) : versionResult;
+        const payloadToUpdate = fields ? pick(delta, fields) : delta;
         const itemsService = new ItemsService(collection, {
             accountability: this.accountability,
             knex: this.knex,

package/dist/telemetry/index.d.ts

@@ -1,4 +1,3 @@
 export * from './lib/get-report.js';
-export * from './lib/init-telemetry.js';
 export * from './lib/send-report.js';
 export * from './lib/track.js';

package/dist/telemetry/index.js

@@ -1,4 +1,3 @@
 export * from './lib/get-report.js';
-export * from './lib/init-telemetry.js';
 export * from './lib/send-report.js';
 export * from './lib/track.js';

package/dist/utils/apply-diff.js

@@ -148,7 +148,7 @@ export async function applyDiff(currentSnapshot, snapshotDiff, options) {
                 }
             }
         }
-        const fieldsService = new FieldsService({
+        let fieldsService = new FieldsService({
             knex: trx,
             schema: await getSchema({ database: trx, bypassCache: true }),
         });
@@ -156,6 +156,11 @@ export async function applyDiff(currentSnapshot, snapshotDiff, options) {
             if (diff?.[0]?.kind === DiffKind.NEW && !isNestedMetaUpdate(diff?.[0])) {
                 try {
                     await fieldsService.createField(collection, diff[0].rhs, undefined, mutationOptions);
+                    // Refresh the schema
+                    fieldsService = new FieldsService({
+                        knex: trx,
+                        schema: await getSchema({ database: trx, bypassCache: true }),
+                    });
                 }
                 catch (err) {
                     logger.error(`Failed to create field "${collection}.${field}"`);
@@ -183,14 +188,21 @@ export async function applyDiff(currentSnapshot, snapshotDiff, options) {
             if (diff?.[0]?.kind === DiffKind.DELETE && !isNestedMetaUpdate(diff?.[0])) {
                 try {
                     await fieldsService.deleteField(collection, field, mutationOptions);
+                    // Refresh the schema
+                    fieldsService = new FieldsService({
+                        knex: trx,
+                        schema: await getSchema({ database: trx, bypassCache: true }),
+                    });
                 }
                 catch (err) {
                     logger.error(`Failed to delete field "${collection}.${field}"`);
                     throw err;
                 }
                 // Field deletion also cleans up the relationship. We should ignore any relationship
-                // changes attached to this now non-existing field
-                snapshotDiff.relations = snapshotDiff.relations.filter((relation) => (relation.collection === collection && relation.field === field) === false);
+                // changes attached to this now non-existing field except newly created relationship
+                snapshotDiff.relations = snapshotDiff.relations.filter((relation) => (relation.collection === collection &&
+                    relation.field === field &&
+                    !relation.diff.some((diff) => diff.kind === DiffKind.NEW)) === false);
             }
         }
         const relationsService = new RelationsService({

package/dist/utils/get-service.js

@@ -11,7 +11,7 @@ export function getService(collection, opts) {
         case 'directus_activity':
             return new ActivityService(opts);
         case 'directus_comments':
-            return new CommentsService({ ...opts, serviceOrigin: 'comments' });
+            return new CommentsService(opts);
         case 'directus_dashboards':
             return new DashboardsService(opts);
         case 'directus_files':

package/dist/utils/get-snapshot-diff.js

@@ -25,6 +25,16 @@ export function getSnapshotDiff(current, after) {
             ...current.fields.map((currentField) => {
                 const afterField = after.fields.find((afterField) => afterField.collection === currentField.collection && afterField.field === currentField.field);
                 const isAutoIncrementPrimaryKey = !!currentField.schema?.is_primary_key && !!currentField.schema?.has_auto_increment;
+                // Changing to/from alias fields should delete the current field
+                if (afterField &&
+                    currentField.type !== afterField.type &&
+                    (currentField.type === 'alias' || afterField.type === 'alias')) {
+                    return {
+                        collection: currentField.collection,
+                        field: currentField.field,
+                        diff: deepDiff.diff(sanitizeField(currentField, isAutoIncrementPrimaryKey), sanitizeField(undefined, isAutoIncrementPrimaryKey)),
+                    };
+                }
                 return {
                     collection: currentField.collection,
                     field: currentField.field,
@@ -33,7 +43,13 @@ export function getSnapshotDiff(current, after) {
             }),
             ...after.fields
                 .filter((afterField) => {
-                const currentField = current.fields.find((currentField) => currentField.collection === afterField.collection && afterField.field === currentField.field);
+                let currentField = current.fields.find((currentField) => currentField.collection === afterField.collection && afterField.field === currentField.field);
+                // Changing to/from alias fields should create the new field
+                if (currentField &&
+                    currentField.type !== afterField.type &&
+                    (currentField.type === 'alias' || afterField.type === 'alias')) {
+                    currentField = undefined;
+                }
                 return !!currentField === false;
             })
                 .map((afterField) => ({

package/dist/websocket/controllers/base.js

@@ -16,6 +16,7 @@ import { AuthMode, WebSocketAuthMessage, WebSocketMessage } from '../messages.js
 import { getExpiresAtForToken } from '../utils/get-expires-at-for-token.js';
 import { getMessageType } from '../utils/message.js';
 import { waitForAnyMessage, waitForMessageType } from '../utils/wait-for-message.js';
+import { createDefaultAccountability } from '../../permissions/utils/create-default-accountability.js';
 const TOKEN_CHECK_INTERVAL = 15 * 60 * 1000; // 15 minutes
 const logger = useLogger();
 export default class SocketController {
@@ -116,7 +117,7 @@ export default class SocketController {
         }
         this.server.handleUpgrade(request, socket, head, async (ws) => {
             this.catchInvalidMessages(ws);
-            const state = { accountability: null, expires_at: null };
+            const state = { accountability: createDefaultAccountability(), expires_at: null };
             this.server.emit('connection', ws, state);
         });
     }