directus 9.7.1 → 9.8.0

package/dist/services/fields.js

@@ -199,211 +199,222 @@ class FieldsService {
         if (this.accountability && this.accountability.admin !== true) {
             throw new exceptions_1.ForbiddenException();
         }
-        const exists = field.field in this.schema.collections[collection].fields ||
-            (0, lodash_1.isNil)(await this.knex.select('id').from('directus_fields').where({ collection, field: field.field }).first()) ===
-                false;
-        // Check if field already exists, either as a column, or as a row in directus_fields
-        if (exists) {
-            throw new exceptions_1.InvalidPayloadException(`Field "${field.field}" already exists in collection "${collection}"`);
-        }
-        await this.knex.transaction(async (trx) => {
-            const itemsService = new items_1.ItemsService('directus_fields', {
-                knex: trx,
-                accountability: this.accountability,
-                schema: this.schema,
+        try {
+            const exists = field.field in this.schema.collections[collection].fields ||
+                (0, lodash_1.isNil)(await this.knex.select('id').from('directus_fields').where({ collection, field: field.field }).first()) === false;
+            // Check if field already exists, either as a column, or as a row in directus_fields
+            if (exists) {
+                throw new exceptions_1.InvalidPayloadException(`Field "${field.field}" already exists in collection "${collection}"`);
+            }
+            await this.knex.transaction(async (trx) => {
+                const itemsService = new items_1.ItemsService('directus_fields', {
+                    knex: trx,
+                    accountability: this.accountability,
+                    schema: this.schema,
+                });
+                const hookAdjustedField = await emitter_1.default.emitFilter(`fields.create`, field, {
+                    collection: collection,
+                }, {
+                    database: trx,
+                    schema: this.schema,
+                    accountability: this.accountability,
+                });
+                if (hookAdjustedField.type && constants_1.ALIAS_TYPES.includes(hookAdjustedField.type) === false) {
+                    if (table) {
+                        this.addColumnToTable(table, hookAdjustedField);
+                    }
+                    else {
+                        await trx.schema.alterTable(collection, (table) => {
+                            this.addColumnToTable(table, hookAdjustedField);
+                        });
+                    }
+                }
+                if (hookAdjustedField.meta) {
+                    await itemsService.createOne({
+                        ...hookAdjustedField.meta,
+                        collection: collection,
+                        field: hookAdjustedField.field,
+                    }, { emitEvents: false });
+                }
+                emitter_1.default.emitAction(`fields.create`, {
+                    payload: hookAdjustedField,
+                    key: hookAdjustedField.field,
+                    collection: collection,
+                }, {
+                    database: (0, database_1.default)(),
+                    schema: this.schema,
+                    accountability: this.accountability,
+                });
             });
-            const hookAdjustedField = await emitter_1.default.emitFilter(`fields.create`, field, {
+        }
+        finally {
+            if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
+                await this.cache.clear();
+            }
+            await (0, cache_1.clearSystemCache)();
+        }
+    }
+    async updateField(collection, field) {
+        if (this.accountability && this.accountability.admin !== true) {
+            throw new exceptions_1.ForbiddenException();
+        }
+        try {
+            const hookAdjustedField = await emitter_1.default.emitFilter(`fields.update`, field, {
+                keys: [field.field],
                 collection: collection,
             }, {
-                database: trx,
+                database: this.knex,
                 schema: this.schema,
                 accountability: this.accountability,
             });
-            if (hookAdjustedField.type && constants_1.ALIAS_TYPES.includes(hookAdjustedField.type) === false) {
-                if (table) {
-                    this.addColumnToTable(table, hookAdjustedField);
-                }
-                else {
-                    await trx.schema.alterTable(collection, (table) => {
-                        this.addColumnToTable(table, hookAdjustedField);
-                    });
+            const record = field.meta
+                ? await this.knex.select('id').from('directus_fields').where({ collection, field: field.field }).first()
+                : null;
+            if (hookAdjustedField.schema) {
+                const existingColumn = await this.schemaInspector.columnInfo(collection, hookAdjustedField.field);
+                if (!(0, lodash_1.isEqual)(existingColumn, hookAdjustedField.schema)) {
+                    try {
+                        await this.knex.schema.alterTable(collection, (table) => {
+                            if (!hookAdjustedField.schema)
+                                return;
+                            this.addColumnToTable(table, field, existingColumn);
+                        });
+                    }
+                    catch (err) {
+                        throw await (0, translate_1.translateDatabaseError)(err);
+                    }
                 }
             }
             if (hookAdjustedField.meta) {
-                await itemsService.createOne({
-                    ...hookAdjustedField.meta,
-                    collection: collection,
-                    field: hookAdjustedField.field,
-                }, { emitEvents: false });
+                if (record) {
+                    await this.itemsService.updateOne(record.id, {
+                        ...hookAdjustedField.meta,
+                        collection: collection,
+                        field: hookAdjustedField.field,
+                    }, { emitEvents: false });
+                }
+                else {
+                    await this.itemsService.createOne({
+                        ...hookAdjustedField.meta,
+                        collection: collection,
+                        field: hookAdjustedField.field,
+                    }, { emitEvents: false });
+                }
             }
-            emitter_1.default.emitAction(`fields.create`, {
+            emitter_1.default.emitAction(`fields.update`, {
                 payload: hookAdjustedField,
-                key: hookAdjustedField.field,
+                keys: [hookAdjustedField.field],
                 collection: collection,
             }, {
                 database: (0, database_1.default)(),
                 schema: this.schema,
                 accountability: this.accountability,
             });
-        });
-        if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
-            await this.cache.clear();
+            return field.field;
         }
-        await (0, cache_1.clearSystemCache)();
-    }
-    async updateField(collection, field) {
-        if (this.accountability && this.accountability.admin !== true) {
-            throw new exceptions_1.ForbiddenException();
-        }
-        const hookAdjustedField = await emitter_1.default.emitFilter(`fields.update`, field, {
-            keys: [field.field],
-            collection: collection,
-        }, {
-            database: this.knex,
-            schema: this.schema,
-            accountability: this.accountability,
-        });
-        const record = field.meta
-            ? await this.knex.select('id').from('directus_fields').where({ collection, field: field.field }).first()
-            : null;
-        if (hookAdjustedField.schema) {
-            const existingColumn = await this.schemaInspector.columnInfo(collection, hookAdjustedField.field);
-            if (!(0, lodash_1.isEqual)(existingColumn, hookAdjustedField.schema)) {
-                try {
-                    await this.knex.schema.alterTable(collection, (table) => {
-                        if (!hookAdjustedField.schema)
-                            return;
-                        this.addColumnToTable(table, field, existingColumn);
-                    });
-                }
-                catch (err) {
-                    throw await (0, translate_1.translateDatabaseError)(err);
-                }
+        finally {
+            if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
+                await this.cache.clear();
             }
+            await (0, cache_1.clearSystemCache)();
         }
-        if (hookAdjustedField.meta) {
-            if (record) {
-                await this.itemsService.updateOne(record.id, {
-                    ...hookAdjustedField.meta,
-                    collection: collection,
-                    field: hookAdjustedField.field,
-                }, { emitEvents: false });
-            }
-            else {
-                await this.itemsService.createOne({
-                    ...hookAdjustedField.meta,
-                    collection: collection,
-                    field: hookAdjustedField.field,
-                }, { emitEvents: false });
-            }
-        }
-        if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
-            await this.cache.clear();
-        }
-        await (0, cache_1.clearSystemCache)();
-        emitter_1.default.emitAction(`fields.update`, {
-            payload: hookAdjustedField,
-            keys: [hookAdjustedField.field],
-            collection: collection,
-        }, {
-            database: (0, database_1.default)(),
-            schema: this.schema,
-            accountability: this.accountability,
-        });
-        return field.field;
     }
     async deleteField(collection, field) {
         if (this.accountability && this.accountability.admin !== true) {
             throw new exceptions_1.ForbiddenException();
         }
-        await emitter_1.default.emitFilter('fields.delete', [field], {
-            collection: collection,
-        }, {
-            database: this.knex,
-            schema: this.schema,
-            accountability: this.accountability,
-        });
-        await this.knex.transaction(async (trx) => {
-            var _a, _b;
-            if (this.schema.collections[collection] &&
-                field in this.schema.collections[collection].fields &&
-                this.schema.collections[collection].fields[field].alias === false) {
-                await trx.schema.table(collection, (table) => {
-                    table.dropColumn(field);
-                });
-            }
-            const relations = this.schema.relations.filter((relation) => {
-                var _a;
-                return ((relation.collection === collection && relation.field === field) ||
-                    (relation.related_collection === collection && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field) === field));
-            });
-            const relationsService = new relations_1.RelationsService({
-                knex: trx,
-                accountability: this.accountability,
+        try {
+            await emitter_1.default.emitFilter('fields.delete', [field], {
+                collection: collection,
+            }, {
+                database: this.knex,
                 schema: this.schema,
-            });
-            const fieldsService = new FieldsService({
-                knex: trx,
                 accountability: this.accountability,
-                schema: this.schema,
             });
-            for (const relation of relations) {
-                const isM2O = relation.collection === collection && relation.field === field;
-                // If the current field is a m2o, delete the related o2m if it exists and remove the relationship
-                if (isM2O) {
-                    await relationsService.deleteOne(collection, field);
-                    if (relation.related_collection && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field)) {
-                        await fieldsService.deleteField(relation.related_collection, relation.meta.one_field);
+            await this.knex.transaction(async (trx) => {
+                var _a, _b;
+                if (this.schema.collections[collection] &&
+                    field in this.schema.collections[collection].fields &&
+                    this.schema.collections[collection].fields[field].alias === false) {
+                    await trx.schema.table(collection, (table) => {
+                        table.dropColumn(field);
+                    });
+                }
+                const relations = this.schema.relations.filter((relation) => {
+                    var _a;
+                    return ((relation.collection === collection && relation.field === field) ||
+                        (relation.related_collection === collection && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field) === field));
+                });
+                const relationsService = new relations_1.RelationsService({
+                    knex: trx,
+                    accountability: this.accountability,
+                    schema: this.schema,
+                });
+                const fieldsService = new FieldsService({
+                    knex: trx,
+                    accountability: this.accountability,
+                    schema: this.schema,
+                });
+                for (const relation of relations) {
+                    const isM2O = relation.collection === collection && relation.field === field;
+                    // If the current field is a m2o, delete the related o2m if it exists and remove the relationship
+                    if (isM2O) {
+                        await relationsService.deleteOne(collection, field);
+                        if (relation.related_collection && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field)) {
+                            await fieldsService.deleteField(relation.related_collection, relation.meta.one_field);
+                        }
+                    }
+                    // If the current field is a o2m, just delete the one field config from the relation
+                    if (!isM2O && ((_b = relation.meta) === null || _b === void 0 ? void 0 : _b.one_field)) {
+                        await trx('directus_relations')
+                            .update({ one_field: null })
+                            .where({ many_collection: relation.collection, many_field: relation.field });
                     }
                 }
-                // If the current field is a o2m, just delete the one field config from the relation
-                if (!isM2O && ((_b = relation.meta) === null || _b === void 0 ? void 0 : _b.one_field)) {
-                    await trx('directus_relations')
-                        .update({ one_field: null })
-                        .where({ many_collection: relation.collection, many_field: relation.field });
+                const collectionMeta = await trx
+                    .select('archive_field', 'sort_field')
+                    .from('directus_collections')
+                    .where({ collection })
+                    .first();
+                const collectionMetaUpdates = {};
+                if ((collectionMeta === null || collectionMeta === void 0 ? void 0 : collectionMeta.archive_field) === field) {
+                    collectionMetaUpdates.archive_field = null;
                 }
+                if ((collectionMeta === null || collectionMeta === void 0 ? void 0 : collectionMeta.sort_field) === field) {
+                    collectionMetaUpdates.sort_field = null;
+                }
+                if (Object.keys(collectionMetaUpdates).length > 0) {
+                    await trx('directus_collections').update(collectionMetaUpdates).where({ collection });
+                }
+                // Cleanup directus_fields
+                const metaRow = await trx
+                    .select('collection', 'field')
+                    .from('directus_fields')
+                    .where({ collection, field })
+                    .first();
+                if (metaRow) {
+                    // Handle recursive FK constraints
+                    await trx('directus_fields')
+                        .update({ group: null })
+                        .where({ group: metaRow.field, collection: metaRow.collection });
+                }
+                await trx('directus_fields').delete().where({ collection, field });
+            });
+            emitter_1.default.emitAction('fields.delete', {
+                payload: [field],
+                collection: collection,
+            }, {
+                database: this.knex,
+                schema: this.schema,
+                accountability: this.accountability,
+            });
+        }
+        finally {
+            if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
+                await this.cache.clear();
             }
-            const collectionMeta = await trx
-                .select('archive_field', 'sort_field')
-                .from('directus_collections')
-                .where({ collection })
-                .first();
-            const collectionMetaUpdates = {};
-            if ((collectionMeta === null || collectionMeta === void 0 ? void 0 : collectionMeta.archive_field) === field) {
-                collectionMetaUpdates.archive_field = null;
-            }
-            if ((collectionMeta === null || collectionMeta === void 0 ? void 0 : collectionMeta.sort_field) === field) {
-                collectionMetaUpdates.sort_field = null;
-            }
-            if (Object.keys(collectionMetaUpdates).length > 0) {
-                await trx('directus_collections').update(collectionMetaUpdates).where({ collection });
-            }
-            // Cleanup directus_fields
-            const metaRow = await trx
-                .select('collection', 'field')
-                .from('directus_fields')
-                .where({ collection, field })
-                .first();
-            if (metaRow) {
-                // Handle recursive FK constraints
-                await trx('directus_fields')
-                    .update({ group: null })
-                    .where({ group: metaRow.field, collection: metaRow.collection });
-            }
-            await trx('directus_fields').delete().where({ collection, field });
-        });
-        if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
-            await this.cache.clear();
-        }
-        await (0, cache_1.clearSystemCache)();
-        emitter_1.default.emitAction('fields.delete', {
-            payload: [field],
-            collection: collection,
-        }, {
-            database: this.knex,
-            schema: this.schema,
-            accountability: this.accountability,
-        });
+            await (0, cache_1.clearSystemCache)();
+        }
     }
     addColumnToTable(table, field, alter = null) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;

package/dist/services/payload.js

@@ -247,7 +247,7 @@ class PayloadService {
                         payload[name] = newValue;
                     }
                     if (dateColumn.type === 'date') {
-                        const [year, month, day] = value.toISOString().substr(0, 10).split('-');
+                        const [year, month, day] = value.toISOString().slice(0, 10).split('-');
                         // Strip off the time / timezone information from a date-only value
                         const newValue = `${year}-${month}-${day}`;
                         payload[name] = newValue;
@@ -429,7 +429,7 @@ class PayloadService {
             delete: joi_1.default.array().items(joi_1.default.string(), joi_1.default.number()),
         });
         for (const relation of relationsToProcess) {
-            if (!relation.meta || !payload[relation.meta.one_field])
+            if (!relation.meta)
                 continue;
             const currentPrimaryKeyField = this.schema.collections[relation.related_collection].primary;
             const relatedPrimaryKeyField = this.schema.collections[relation.collection].primary;
@@ -441,9 +441,11 @@ class PayloadService {
             const recordsToUpsert = [];
             const savedPrimaryKeys = [];
             // Nested array of individual items
-            if (Array.isArray(payload[relation.meta.one_field])) {
-                for (let i = 0; i < (payload[relation.meta.one_field] || []).length; i++) {
-                    const relatedRecord = (payload[relation.meta.one_field] || [])[i];
+            const field = payload[relation.meta.one_field];
+            if (!field || Array.isArray(field)) {
+                const updates = field || []; // treat falsey values as removing all children
+                for (let i = 0; i < updates.length; i++) {
+                    const relatedRecord = updates[i];
                     let record = (0, lodash_1.cloneDeep)(relatedRecord);
                     if (typeof relatedRecord === 'string' || typeof relatedRecord === 'number') {
                         const existingRecord = await this.knex
@@ -507,7 +509,7 @@ class PayloadService {
             }
             // "Updates" object w/ create/update/delete
             else {
-                const alterations = payload[relation.meta.one_field];
+                const alterations = field;
                 const { error } = nestedUpdateSchema.validate(alterations);
                 if (error)
                     throw new exceptions_1.InvalidPayloadException(`Invalid one-to-many update structure: ${error.message}`);

package/dist/services/relations.js

@@ -146,36 +146,40 @@ class RelationsService {
         if (existingRelation) {
             throw new exceptions_1.InvalidPayloadException(`Field "${relation.field}" in collection "${relation.collection}" already has an associated relationship`);
         }
-        const metaRow = {
-            ...(relation.meta || {}),
-            many_collection: relation.collection,
-            many_field: relation.field,
-            one_collection: relation.related_collection || null,
-        };
-        await this.knex.transaction(async (trx) => {
-            if (relation.related_collection) {
-                await trx.schema.alterTable(relation.collection, async (table) => {
-                    var _a;
-                    this.alterType(table, relation);
-                    const constraintName = (0, get_default_index_name_1.getDefaultIndexName)('foreign', relation.collection, relation.field);
-                    const builder = table
-                        .foreign(relation.field, constraintName)
-                        .references(`${relation.related_collection}.${this.schema.collections[relation.related_collection].primary}`);
-                    if ((_a = relation.schema) === null || _a === void 0 ? void 0 : _a.on_delete) {
-                        builder.onDelete(relation.schema.on_delete);
-                    }
+        try {
+            const metaRow = {
+                ...(relation.meta || {}),
+                many_collection: relation.collection,
+                many_field: relation.field,
+                one_collection: relation.related_collection || null,
+            };
+            await this.knex.transaction(async (trx) => {
+                if (relation.related_collection) {
+                    await trx.schema.alterTable(relation.collection, async (table) => {
+                        var _a;
+                        this.alterType(table, relation);
+                        const constraintName = (0, get_default_index_name_1.getDefaultIndexName)('foreign', relation.collection, relation.field);
+                        const builder = table
+                            .foreign(relation.field, constraintName)
+                            .references(`${relation.related_collection}.${this.schema.collections[relation.related_collection].primary}`);
+                        if ((_a = relation.schema) === null || _a === void 0 ? void 0 : _a.on_delete) {
+                            builder.onDelete(relation.schema.on_delete);
+                        }
+                    });
+                }
+                const relationsItemService = new items_1.ItemsService('directus_relations', {
+                    knex: trx,
+                    schema: this.schema,
+                    // We don't set accountability here. If you have read access to certain fields, you are
+                    // allowed to extract the relations regardless of permissions to directus_relations. This
+                    // happens in `filterForbidden` down below
                 });
-            }
-            const relationsItemService = new items_1.ItemsService('directus_relations', {
-                knex: trx,
-                schema: this.schema,
-                // We don't set accountability here. If you have read access to certain fields, you are
-                // allowed to extract the relations regardless of permissions to directus_relations. This
-                // happens in `filterForbidden` down below
+                await relationsItemService.createOne(metaRow);
             });
-            await relationsItemService.createOne(metaRow);
-        });
-        await (0, cache_1.clearSystemCache)();
+        }
+        finally {
+            await (0, cache_1.clearSystemCache)();
+        }
     }
     /**
      * Update an existing foreign key constraint
@@ -196,47 +200,51 @@ class RelationsService {
         if (!existingRelation) {
             throw new exceptions_1.InvalidPayloadException(`Field "${field}" in collection "${collection}" doesn't have a relationship.`);
         }
-        await this.knex.transaction(async (trx) => {
-            if (existingRelation.related_collection) {
-                await trx.schema.alterTable(collection, async (table) => {
-                    var _a;
-                    let constraintName = (0, get_default_index_name_1.getDefaultIndexName)('foreign', collection, field);
-                    // If the FK already exists in the DB, drop it first
-                    if (existingRelation === null || existingRelation === void 0 ? void 0 : existingRelation.schema) {
-                        constraintName = existingRelation.schema.constraint_name || constraintName;
-                        table.dropForeign(field, constraintName);
+        try {
+            await this.knex.transaction(async (trx) => {
+                if (existingRelation.related_collection) {
+                    await trx.schema.alterTable(collection, async (table) => {
+                        var _a;
+                        let constraintName = (0, get_default_index_name_1.getDefaultIndexName)('foreign', collection, field);
+                        // If the FK already exists in the DB, drop it first
+                        if (existingRelation === null || existingRelation === void 0 ? void 0 : existingRelation.schema) {
+                            constraintName = existingRelation.schema.constraint_name || constraintName;
+                            table.dropForeign(field, constraintName);
+                        }
+                        this.alterType(table, relation);
+                        const builder = table
+                            .foreign(field, constraintName || undefined)
+                            .references(`${existingRelation.related_collection}.${this.schema.collections[existingRelation.related_collection].primary}`);
+                        if ((_a = relation.schema) === null || _a === void 0 ? void 0 : _a.on_delete) {
+                            builder.onDelete(relation.schema.on_delete);
+                        }
+                    });
+                }
+                const relationsItemService = new items_1.ItemsService('directus_relations', {
+                    knex: trx,
+                    schema: this.schema,
+                    // We don't set accountability here. If you have read access to certain fields, you are
+                    // allowed to extract the relations regardless of permissions to directus_relations. This
+                    // happens in `filterForbidden` down below
+                });
+                if (relation.meta) {
+                    if (existingRelation === null || existingRelation === void 0 ? void 0 : existingRelation.meta) {
+                        await relationsItemService.updateOne(existingRelation.meta.id, relation.meta);
                     }
-                    this.alterType(table, relation);
-                    const builder = table
-                        .foreign(field, constraintName || undefined)
-                        .references(`${existingRelation.related_collection}.${this.schema.collections[existingRelation.related_collection].primary}`);
-                    if ((_a = relation.schema) === null || _a === void 0 ? void 0 : _a.on_delete) {
-                        builder.onDelete(relation.schema.on_delete);
+                    else {
+                        await relationsItemService.createOne({
+                            ...(relation.meta || {}),
+                            many_collection: relation.collection,
+                            many_field: relation.field,
+                            one_collection: existingRelation.related_collection || null,
+                        });
                     }
-                });
-            }
-            const relationsItemService = new items_1.ItemsService('directus_relations', {
-                knex: trx,
-                schema: this.schema,
-                // We don't set accountability here. If you have read access to certain fields, you are
-                // allowed to extract the relations regardless of permissions to directus_relations. This
-                // happens in `filterForbidden` down below
-            });
-            if (relation.meta) {
-                if (existingRelation === null || existingRelation === void 0 ? void 0 : existingRelation.meta) {
-                    await relationsItemService.updateOne(existingRelation.meta.id, relation.meta);
-                }
-                else {
-                    await relationsItemService.createOne({
-                        ...(relation.meta || {}),
-                        many_collection: relation.collection,
-                        many_field: relation.field,
-                        one_collection: existingRelation.related_collection || null,
-                    });
                 }
-            }
-        });
-        await (0, cache_1.clearSystemCache)();
+            });
+        }
+        finally {
+            await (0, cache_1.clearSystemCache)();
+        }
     }
     /**
      * Delete an existing relationship
@@ -255,21 +263,25 @@ class RelationsService {
         if (!existingRelation) {
             throw new exceptions_1.InvalidPayloadException(`Field "${field}" in collection "${collection}" doesn't have a relationship.`);
         }
-        await this.knex.transaction(async (trx) => {
-            var _a;
-            const existingConstraints = await this.schemaInspector.foreignKeys();
-            const constraintNames = existingConstraints.map((key) => key.constraint_name);
-            if (((_a = existingRelation.schema) === null || _a === void 0 ? void 0 : _a.constraint_name) &&
-                constraintNames.includes(existingRelation.schema.constraint_name)) {
-                await trx.schema.alterTable(existingRelation.collection, (table) => {
-                    table.dropForeign(existingRelation.field, existingRelation.schema.constraint_name);
-                });
-            }
-            if (existingRelation.meta) {
-                await trx('directus_relations').delete().where({ many_collection: collection, many_field: field });
-            }
-        });
-        await (0, cache_1.clearSystemCache)();
+        try {
+            await this.knex.transaction(async (trx) => {
+                var _a;
+                const existingConstraints = await this.schemaInspector.foreignKeys();
+                const constraintNames = existingConstraints.map((key) => key.constraint_name);
+                if (((_a = existingRelation.schema) === null || _a === void 0 ? void 0 : _a.constraint_name) &&
+                    constraintNames.includes(existingRelation.schema.constraint_name)) {
+                    await trx.schema.alterTable(existingRelation.collection, (table) => {
+                        table.dropForeign(existingRelation.field, existingRelation.schema.constraint_name);
+                    });
+                }
+                if (existingRelation.meta) {
+                    await trx('directus_relations').delete().where({ many_collection: collection, many_field: field });
+                }
+            });
+        }
+        finally {
+            await (0, cache_1.clearSystemCache)();
+        }
     }
     /**
      * Whether or not the current user has read access to relations

package/dist/services/server.js

@@ -55,6 +55,7 @@ class ServerService {
                 'project_descriptor',
                 'project_logo',
                 'project_color',
+                'default_language',
                 'public_foreground',
                 'public_background',
                 'public_note',