directus 9.16.0 → 9.17.1

package/dist/middleware/validate-batch.js

@@ -14,39 +14,36 @@ const validateBatch = (scope) => (0, async_handler_1.default)(async (req, res, n
         req.body = {};
         return next();
     }
+    if (req.method.toLowerCase() !== 'search' && scope !== 'read' && req.singleton) {
+        return next();
+    }
     if (!req.body)
         throw new exceptions_1.InvalidPayloadException('Payload in body is required');
-    if (req.singleton)
+    if (['update', 'delete'].includes(scope) && Array.isArray(req.body)) {
         return next();
+    }
+    // In reads, the query in the body should override the query params for searching
+    if (scope === 'read' && req.body.query) {
+        req.sanitizedQuery = (0, sanitize_query_1.sanitizeQuery)(req.body.query, req.accountability);
+    }
     // Every cRUD action has either keys or query
     let batchSchema = joi_1.default.object().keys({
         keys: joi_1.default.array().items(joi_1.default.alternatives(joi_1.default.string(), joi_1.default.number())),
         query: joi_1.default.object().unknown(),
     });
-    // In reads, you can't combine the two, and 1 of the two at  least is required
-    if (scope !== 'read') {
+    if (['update', 'delete'].includes(scope)) {
         batchSchema = batchSchema.xor('query', 'keys');
     }
     // In updates, we add a required `data` that holds the update payload if an array isn't used
     if (scope === 'update') {
-        if (Array.isArray(req.body))
-            return next();
         batchSchema = batchSchema.keys({
             data: joi_1.default.object().unknown().required(),
         });
     }
-    // In deletes, we want to keep supporting an array of just primary keys
-    if (scope === 'delete' && Array.isArray(req.body)) {
-        return next();
-    }
     const { error } = batchSchema.validate(req.body);
     if (error) {
         throw new exceptions_2.FailedValidationException(error.details[0]);
     }
-    // In reads, the query in the body should override the query params for searching
-    if (scope === 'read' && req.body.query) {
-        req.sanitizedQuery = (0, sanitize_query_1.sanitizeQuery)(req.body.query, req.accountability);
-    }
     return next();
 });
 exports.validateBatch = validateBatch;

package/dist/middleware/validate-batch.test.d.ts

@@ -0,0 +1 @@
+import '../../src/types/express.d.ts';

package/dist/middleware/validate-batch.test.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const validate_batch_1 = require("./validate-batch");
+require("../../src/types/express.d.ts");
+const exceptions_1 = require("../exceptions");
+const exceptions_2 = require("@directus/shared/exceptions");
+let mockRequest;
+let mockResponse;
+const nextFunction = jest.fn();
+beforeEach(() => {
+    mockRequest = {};
+    mockResponse = {};
+    jest.clearAllMocks();
+});
+test('Sets body to empty, calls next on GET requests', async () => {
+    mockRequest.method = 'GET';
+    await (0, validate_batch_1.validateBatch)('read')(mockRequest, mockResponse, nextFunction);
+    expect(mockRequest.body).toEqual({});
+    expect(nextFunction).toHaveBeenCalledTimes(1);
+});
+test(`Short circuits on singletons that aren't queried through SEARCH`, async () => {
+    mockRequest.method = 'PATCH';
+    mockRequest.singleton = true;
+    mockRequest.body = { title: 'test' };
+    await (0, validate_batch_1.validateBatch)('update')(mockRequest, mockResponse, nextFunction);
+    expect(nextFunction).toHaveBeenCalledTimes(1);
+});
+test('Throws InvalidPayloadException on missing body', async () => {
+    mockRequest.method = 'SEARCH';
+    await (0, validate_batch_1.validateBatch)('read')(mockRequest, mockResponse, nextFunction);
+    expect(nextFunction).toHaveBeenCalledTimes(1);
+    expect(jest.mocked(nextFunction).mock.calls[0][0]).toBeInstanceOf(exceptions_1.InvalidPayloadException);
+});
+test(`Short circuits on Array body in update/delete use`, async () => {
+    mockRequest.method = 'PATCH';
+    mockRequest.body = [1, 2, 3];
+    await (0, validate_batch_1.validateBatch)('update')(mockRequest, mockResponse, nextFunction);
+    expect(mockRequest.sanitizedQuery).toBe(undefined);
+    expect(nextFunction).toHaveBeenCalled();
+});
+test(`Sets sanitizedQuery based on body.query in read operations`, async () => {
+    mockRequest.method = 'SEARCH';
+    mockRequest.body = {
+        query: {
+            sort: 'id',
+        },
+    };
+    await (0, validate_batch_1.validateBatch)('read')(mockRequest, mockResponse, nextFunction);
+    expect(mockRequest.sanitizedQuery).toEqual({
+        sort: ['id'],
+    });
+});
+test(`Doesn't allow both query and keys in a batch delete`, async () => {
+    mockRequest.method = 'DELETE';
+    mockRequest.body = {
+        keys: [1, 2, 3],
+        query: { filter: {} },
+    };
+    await (0, validate_batch_1.validateBatch)('delete')(mockRequest, mockResponse, nextFunction);
+    expect(nextFunction).toHaveBeenCalledTimes(1);
+    expect(jest.mocked(nextFunction).mock.calls[0][0]).toBeInstanceOf(exceptions_2.FailedValidationException);
+});
+test(`Requires 'data' on batch update`, async () => {
+    mockRequest.method = 'PATCH';
+    mockRequest.body = {
+        keys: [1, 2, 3],
+        query: { filter: {} },
+    };
+    await (0, validate_batch_1.validateBatch)('update')(mockRequest, mockResponse, nextFunction);
+    expect(nextFunction).toHaveBeenCalledTimes(1);
+    expect(jest.mocked(nextFunction).mock.calls[0][0]).toBeInstanceOf(exceptions_2.FailedValidationException);
+});
+test(`Calls next when all is well`, async () => {
+    mockRequest.method = 'PATCH';
+    mockRequest.body = {
+        query: { filter: {} },
+        data: {},
+    };
+    await (0, validate_batch_1.validateBatch)('update')(mockRequest, mockResponse, nextFunction);
+    expect(nextFunction).toHaveBeenCalledTimes(1);
+    expect(jest.mocked(nextFunction).mock.calls[0][0]).toBeUndefined();
+});

package/dist/operations/request/index.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@directus/shared/utils");
 const axios_1 = __importDefault(require("axios"));
+const encodeurl_1 = __importDefault(require("encodeurl"));
 exports.default = (0, utils_1.defineOperationApi)({
     id: 'request',
     handler: async ({ url, method, body, headers }) => {
@@ -16,9 +17,8 @@ exports.default = (0, utils_1.defineOperationApi)({
         if (!customHeaders['Content-Type'] && isValidJSON(body)) {
             customHeaders['Content-Type'] = 'application/json';
         }
-        const shouldEncode = decodeURI(url) === url;
         const result = await (0, axios_1.default)({
-            url: shouldEncode ? encodeURI(url) : url,
+            url: (0, encodeurl_1.default)(url),
             method,
             data: body,
             headers: customHeaders,

package/dist/operations/transform/index.d.ts

@@ -1,5 +1,5 @@
 declare type Options = {
-    json: string;
+    json: string | Record<string, any>;
 };
 declare const _default: import("@directus/shared/types").OperationApiConfig<Options>;
 export default _default;

package/dist/operations/transform/index.js

@@ -4,6 +4,6 @@ const utils_1 = require("@directus/shared/utils");
 exports.default = (0, utils_1.defineOperationApi)({
     id: 'transform',
     handler: ({ json }) => {
-        return (0, utils_1.parseJSON)(json);
+        return (0, utils_1.optionToObject)(json);
     },
 });

package/dist/services/authentication.js

@@ -36,15 +36,23 @@ class AuthenticationService {
      * to handle password existence checks elsewhere
      */
     async login(providerName = constants_1.DEFAULT_AUTH_PROVIDER, payload, otp) {
-        var _a, _b;
-        const STALL_TIME = 100;
+        var _a, _b, _c;
+        const STALL_TIME = env_1.default.LOGIN_STALL_TIME;
         const timeStart = perf_hooks_1.performance.now();
         const provider = (0, auth_1.getAuthProvider)(providerName);
+        let userId;
+        try {
+            userId = await provider.getUserID((0, lodash_1.cloneDeep)(payload));
+        }
+        catch (err) {
+            await (0, stall_1.stall)(STALL_TIME, timeStart);
+            throw err;
+        }
         const user = await this.knex
             .select('u.id', 'u.first_name', 'u.last_name', 'u.email', 'u.password', 'u.status', 'u.role', 'r.admin_access', 'r.app_access', 'u.tfa_secret', 'u.provider', 'u.external_identifier', 'u.auth_data')
             .from('directus_users as u')
             .leftJoin('directus_roles as r', 'u.role', 'r.id')
-            .where('u.id', await provider.getUserID((0, lodash_1.cloneDeep)(payload)))
+            .where('u.id', userId)
             .first();
         const updatedPayload = await emitter_1.default.emitFilter('auth.login', payload, {
             status: 'pending',
@@ -151,6 +159,7 @@ class AuthenticationService {
             expires: refreshTokenExpiration,
             ip: (_a = this.accountability) === null || _a === void 0 ? void 0 : _a.ip,
             user_agent: (_b = this.accountability) === null || _b === void 0 ? void 0 : _b.userAgent,
+            origin: (_c = this.accountability) === null || _c === void 0 ? void 0 : _c.origin,
         });
         await this.knex('directus_sessions').delete().where('expires', '<', new Date());
         if (this.accountability) {
@@ -159,6 +168,7 @@ class AuthenticationService {
                 user: user.id,
                 ip: this.accountability.ip,
                 user_agent: this.accountability.userAgent,
+                origin: this.accountability.origin,
                 collection: 'directus_users',
                 item: user.id,
             });

package/dist/services/fields.js

@@ -222,6 +222,7 @@ class FieldsService {
         if (this.accountability && this.accountability.admin !== true) {
             throw new exceptions_1.ForbiddenException();
         }
+        const runPostColumnChange = await this.helpers.schema.preColumnChange();
         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;
@@ -276,6 +277,9 @@ class FieldsService {
             });
         }
         finally {
+            if (runPostColumnChange) {
+                await this.helpers.schema.postColumnChange();
+            }
             if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
                 await this.cache.clear();
             }
@@ -286,6 +290,7 @@ class FieldsService {
         if (this.accountability && this.accountability.admin !== true) {
             throw new exceptions_1.ForbiddenException();
         }
+        const runPostColumnChange = await this.helpers.schema.preColumnChange();
         try {
             const hookAdjustedField = await emitter_1.default.emitFilter(`fields.update`, field, {
                 keys: [field.field],
@@ -341,6 +346,9 @@ class FieldsService {
             return field.field;
         }
         finally {
+            if (runPostColumnChange) {
+                await this.helpers.schema.postColumnChange();
+            }
             if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
                 await this.cache.clear();
             }
@@ -351,7 +359,7 @@ class FieldsService {
         if (this.accountability && this.accountability.admin !== true) {
             throw new exceptions_1.ForbiddenException();
         }
-        const runPostColumnDelete = await this.helpers.schema.preColumnDelete();
+        const runPostColumnChange = await this.helpers.schema.preColumnChange();
         try {
             await emitter_1.default.emitFilter('fields.delete', [field], {
                 collection: collection,
@@ -440,8 +448,8 @@ class FieldsService {
             });
         }
         finally {
-            if (runPostColumnDelete) {
-                await this.helpers.schema.postColumnDelete();
+            if (runPostColumnChange) {
+                await this.helpers.schema.postColumnChange();
             }
             if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
                 await this.cache.clear();

package/dist/services/files.js

@@ -46,6 +46,7 @@ const utils_1 = require("@directus/shared/utils");
 const items_1 = require("./items");
 const net_1 = __importDefault(require("net"));
 const os_1 = __importDefault(require("os"));
+const encodeurl_1 = __importDefault(require("encodeurl"));
 const lookupDNS = (0, util_1.promisify)(dns_1.lookup);
 class FilesService extends items_1.ItemsService {
     constructor(options) {
@@ -229,8 +230,7 @@ class FilesService extends items_1.ItemsService {
         }
         let fileResponse;
         try {
-            const shouldEncode = decodeURI(importURL) === importURL;
-            fileResponse = await axios_1.default.get(shouldEncode ? encodeURI(importURL) : importURL, {
+            fileResponse = await axios_1.default.get((0, encodeurl_1.default)(importURL), {
                 responseType: 'stream',
             });
         }

package/dist/services/graphql/index.js

@@ -293,41 +293,43 @@ class GraphQLService {
                                 return obj[field.field];
                             },
                         };
-                        if (field.type === 'date') {
-                            acc[`${field.field}_func`] = {
-                                type: DateFunctions,
-                                resolve: (obj) => {
-                                    const funcFields = Object.keys(DateFunctions.getFields()).map((key) => `${field.field}_${key}`);
-                                    return (0, lodash_1.mapKeys)((0, lodash_1.pick)(obj, funcFields), (_value, key) => key.substring(field.field.length + 1));
-                                },
-                            };
-                        }
-                        if (field.type === 'time') {
-                            acc[`${field.field}_func`] = {
-                                type: TimeFunctions,
-                                resolve: (obj) => {
-                                    const funcFields = Object.keys(TimeFunctions.getFields()).map((key) => `${field.field}_${key}`);
-                                    return (0, lodash_1.mapKeys)((0, lodash_1.pick)(obj, funcFields), (_value, key) => key.substring(field.field.length + 1));
-                                },
-                            };
-                        }
-                        if (field.type === 'dateTime' || field.type === 'timestamp') {
-                            acc[`${field.field}_func`] = {
-                                type: DateTimeFunctions,
-                                resolve: (obj) => {
-                                    const funcFields = Object.keys(DateTimeFunctions.getFields()).map((key) => `${field.field}_${key}`);
-                                    return (0, lodash_1.mapKeys)((0, lodash_1.pick)(obj, funcFields), (_value, key) => key.substring(field.field.length + 1));
-                                },
-                            };
-                        }
-                        if (field.type === 'json' || field.type === 'alias') {
-                            acc[`${field.field}_func`] = {
-                                type: CountFunctions,
-                                resolve: (obj) => {
-                                    const funcFields = Object.keys(CountFunctions.getFields()).map((key) => `${field.field}_${key}`);
-                                    return (0, lodash_1.mapKeys)((0, lodash_1.pick)(obj, funcFields), (_value, key) => key.substring(field.field.length + 1));
-                                },
-                            };
+                        if (action === 'read') {
+                            if (field.type === 'date') {
+                                acc[`${field.field}_func`] = {
+                                    type: DateFunctions,
+                                    resolve: (obj) => {
+                                        const funcFields = Object.keys(DateFunctions.getFields()).map((key) => `${field.field}_${key}`);
+                                        return (0, lodash_1.mapKeys)((0, lodash_1.pick)(obj, funcFields), (_value, key) => key.substring(field.field.length + 1));
+                                    },
+                                };
+                            }
+                            if (field.type === 'time') {
+                                acc[`${field.field}_func`] = {
+                                    type: TimeFunctions,
+                                    resolve: (obj) => {
+                                        const funcFields = Object.keys(TimeFunctions.getFields()).map((key) => `${field.field}_${key}`);
+                                        return (0, lodash_1.mapKeys)((0, lodash_1.pick)(obj, funcFields), (_value, key) => key.substring(field.field.length + 1));
+                                    },
+                                };
+                            }
+                            if (field.type === 'dateTime' || field.type === 'timestamp') {
+                                acc[`${field.field}_func`] = {
+                                    type: DateTimeFunctions,
+                                    resolve: (obj) => {
+                                        const funcFields = Object.keys(DateTimeFunctions.getFields()).map((key) => `${field.field}_${key}`);
+                                        return (0, lodash_1.mapKeys)((0, lodash_1.pick)(obj, funcFields), (_value, key) => key.substring(field.field.length + 1));
+                                    },
+                                };
+                            }
+                            if (field.type === 'json' || field.type === 'alias') {
+                                acc[`${field.field}_func`] = {
+                                    type: CountFunctions,
+                                    resolve: (obj) => {
+                                        const funcFields = Object.keys(CountFunctions.getFields()).map((key) => `${field.field}_${key}`);
+                                        return (0, lodash_1.mapKeys)((0, lodash_1.pick)(obj, funcFields), (_value, key) => key.substring(field.field.length + 1));
+                                    },
+                                };
+                            }
                         }
                         return acc;
                     }, {}),
@@ -1615,6 +1617,7 @@ class GraphQLService {
                     const accountability = {
                         ip: req === null || req === void 0 ? void 0 : req.ip,
                         userAgent: req === null || req === void 0 ? void 0 : req.get('user-agent'),
+                        origin: req === null || req === void 0 ? void 0 : req.get('origin'),
                         role: null,
                     };
                     const authenticationService = new authentication_1.AuthenticationService({
@@ -1649,6 +1652,7 @@ class GraphQLService {
                     const accountability = {
                         ip: req === null || req === void 0 ? void 0 : req.ip,
                         userAgent: req === null || req === void 0 ? void 0 : req.get('user-agent'),
+                        origin: req === null || req === void 0 ? void 0 : req.get('origin'),
                         role: null,
                     };
                     const authenticationService = new authentication_1.AuthenticationService({
@@ -1685,6 +1689,7 @@ class GraphQLService {
                     const accountability = {
                         ip: req === null || req === void 0 ? void 0 : req.ip,
                         userAgent: req === null || req === void 0 ? void 0 : req.get('user-agent'),
+                        origin: req === null || req === void 0 ? void 0 : req.get('origin'),
                         role: null,
                     };
                     const authenticationService = new authentication_1.AuthenticationService({
@@ -1709,6 +1714,7 @@ class GraphQLService {
                     const accountability = {
                         ip: req === null || req === void 0 ? void 0 : req.ip,
                         userAgent: req === null || req === void 0 ? void 0 : req.get('user-agent'),
+                        origin: req === null || req === void 0 ? void 0 : req.get('origin'),
                         role: null,
                     };
                     const service = new users_1.UsersService({ accountability, schema: this.schema });
@@ -1733,6 +1739,7 @@ class GraphQLService {
                     const accountability = {
                         ip: req === null || req === void 0 ? void 0 : req.ip,
                         userAgent: req === null || req === void 0 ? void 0 : req.get('user-agent'),
+                        origin: req === null || req === void 0 ? void 0 : req.get('origin'),
                         role: null,
                     };
                     const service = new users_1.UsersService({ accountability, schema: this.schema });
@@ -2303,7 +2310,7 @@ class GraphQLService {
                         comment: (0, graphql_1.GraphQLNonNull)(graphql_1.GraphQLString),
                     },
                     resolve: async (_, args, __, info) => {
-                        var _a, _b, _c, _d, _e;
+                        var _a, _b, _c, _d, _e, _f;
                         const service = new activity_1.ActivityService({
                             accountability: this.accountability,
                             schema: this.schema,
@@ -2314,9 +2321,10 @@ class GraphQLService {
                             user: (_a = this.accountability) === null || _a === void 0 ? void 0 : _a.user,
                             ip: (_b = this.accountability) === null || _b === void 0 ? void 0 : _b.ip,
                             user_agent: (_c = this.accountability) === null || _c === void 0 ? void 0 : _c.userAgent,
+                            origin: (_d = this.accountability) === null || _d === void 0 ? void 0 : _d.origin,
                         });
                         if ('directus_activity' in ReadCollectionTypes) {
-                            const selections = this.replaceFragmentsInSelections((_e = (_d = info.fieldNodes[0]) === null || _d === void 0 ? void 0 : _d.selectionSet) === null || _e === void 0 ? void 0 : _e.selections, info.fragments);
+                            const selections = this.replaceFragmentsInSelections((_f = (_e = info.fieldNodes[0]) === null || _e === void 0 ? void 0 : _e.selectionSet) === null || _f === void 0 ? void 0 : _f.selections, info.fragments);
                             const query = this.getQuery(args, selections || [], info.variableValues);
                             return await service.readOne(primaryKey, query);
                         }

package/dist/services/items.js

@@ -130,6 +130,7 @@ class ItemsService {
                     collection: this.collection,
                     ip: this.accountability.ip,
                     user_agent: this.accountability.userAgent,
+                    origin: this.accountability.origin,
                     item: primaryKey,
                 });
                 // If revisions are tracked, create revisions record
@@ -214,7 +215,16 @@ class ItemsService {
      * Get items by query
      */
     async readByQuery(query, opts) {
-        let ast = await (0, get_ast_from_query_1.default)(this.collection, query, this.schema, {
+        const updatedQuery = (opts === null || opts === void 0 ? void 0 : opts.emitEvents) !== false
+            ? await emitter_1.default.emitFilter(`${this.eventScope}.query`, query, {
+                collection: this.collection,
+            }, {
+                database: this.knex,
+                schema: this.schema,
+                accountability: this.accountability,
+            })
+            : query;
+        let ast = await (0, get_ast_from_query_1.default)(this.collection, updatedQuery, this.schema, {
             accountability: this.accountability,
             // By setting the permissions action, you can read items using the permissions for another
             // operation's permissions. This is used to dynamically check if you have update/delete
@@ -240,7 +250,7 @@ class ItemsService {
         }
         const filteredRecords = (opts === null || opts === void 0 ? void 0 : opts.emitEvents) !== false
             ? await emitter_1.default.emitFilter(this.eventScope === 'items' ? ['items.read', `${this.collection}.items.read`] : `${this.eventScope}.read`, records, {
-                query,
+                query: updatedQuery,
                 collection: this.collection,
             }, {
                 database: this.knex,
@@ -251,7 +261,7 @@ class ItemsService {
         if ((opts === null || opts === void 0 ? void 0 : opts.emitEvents) !== false) {
             emitter_1.default.emitAction(this.eventScope === 'items' ? ['items.read', `${this.collection}.items.read`] : `${this.eventScope}.read`, {
                 payload: filteredRecords,
-                query,
+                query: updatedQuery,
                 collection: this.collection,
             }, {
                 database: this.knex || (0, database_1.default)(),
@@ -406,6 +416,7 @@ class ItemsService {
                     collection: this.collection,
                     ip: this.accountability.ip,
                     user_agent: this.accountability.userAgent,
+                    origin: this.accountability.origin,
                     item: key,
                 })));
                 if (this.schema.collections[this.collection].accountability === 'all') {
@@ -573,6 +584,7 @@ class ItemsService {
                     collection: this.collection,
                     ip: this.accountability.ip,
                     user_agent: this.accountability.userAgent,
+                    origin: this.accountability.origin,
                     item: key,
                 })));
             }

package/dist/services/payload.js

@@ -538,10 +538,34 @@ class PayloadService {
                 if (error)
                     throw new exceptions_1.InvalidPayloadException(`Invalid one-to-many update structure: ${error.message}`);
                 if (alterations.create) {
-                    await itemsService.createMany(alterations.create.map((item) => ({
-                        ...item,
-                        [relation.field]: parent || payload[currentPrimaryKeyField],
-                    })), {
+                    const sortField = relation.meta.sort_field;
+                    let createPayload;
+                    if (sortField !== null) {
+                        const highestOrderNumber = await this.knex
+                            .from(relation.collection)
+                            .where({ [relation.field]: parent })
+                            .whereNotNull(sortField)
+                            .max(sortField)
+                            .first();
+                        createPayload = alterations.create.map((item, index) => {
+                            const record = (0, lodash_1.cloneDeep)(item);
+                            // add sort field value if it is not supplied in the item
+                            if (parent !== null && record[sortField] === undefined) {
+                                record[sortField] = (highestOrderNumber === null || highestOrderNumber === void 0 ? void 0 : highestOrderNumber.max) ? highestOrderNumber.max + index + 1 : index + 1;
+                            }
+                            return {
+                                ...record,
+                                [relation.field]: parent || payload[currentPrimaryKeyField],
+                            };
+                        });
+                    }
+                    else {
+                        createPayload = alterations.create.map((item) => ({
+                            ...item,
+                            [relation.field]: parent || payload[currentPrimaryKeyField],
+                        }));
+                    }
+                    await itemsService.createMany(createPayload, {
                         onRevisionCreate: (pk) => revisions.push(pk),
                         bypassEmitAction: (params) => nestedActionEvents.push(params),
                         emitEvents: opts === null || opts === void 0 ? void 0 : opts.emitEvents,

package/dist/services/relations.d.ts

@@ -5,6 +5,7 @@ import { PermissionsService } from './permissions';
 import SchemaInspector from '@directus/schema';
 import Keyv from 'keyv';
 import { AbstractServiceOptions } from '../types';
+import { Helpers } from '../database/helpers';
 export declare class RelationsService {
     knex: Knex;
     permissionsService: PermissionsService;
@@ -13,6 +14,7 @@ export declare class RelationsService {
     schema: SchemaOverview;
     relationsItemService: ItemsService<RelationMeta>;
     systemCache: Keyv<any>;
+    helpers: Helpers;
     constructor(options: AbstractServiceOptions);
     readAll(collection?: string, opts?: QueryOptions): Promise<Relation[]>;
     readOne(collection: string, field: string): Promise<Relation>;

package/dist/services/relations.js

@@ -36,6 +36,7 @@ const schema_1 = __importDefault(require("@directus/schema"));
 const database_1 = __importStar(require("../database"));
 const get_default_index_name_1 = require("../utils/get-default-index-name");
 const cache_1 = require("../cache");
+const helpers_1 = require("../database/helpers");
 class RelationsService {
     constructor(options) {
         this.knex = options.knex || (0, database_1.default)();
@@ -51,6 +52,7 @@ class RelationsService {
             // happens in `filterForbidden` down below
         });
         this.systemCache = (0, cache_1.getCache)().systemCache;
+        this.helpers = (0, helpers_1.getHelpers)(this.knex);
     }
     async readAll(collection, opts) {
         if (this.accountability && this.accountability.admin !== true && this.hasReadAccess === false) {
@@ -150,6 +152,7 @@ class RelationsService {
         if (existingRelation) {
             throw new exceptions_1.InvalidPayloadException(`Field "${relation.field}" in collection "${relation.collection}" already has an associated relationship`);
         }
+        const runPostColumnChange = await this.helpers.schema.preColumnChange();
         try {
             const metaRow = {
                 ...(relation.meta || {}),
@@ -182,6 +185,9 @@ class RelationsService {
             });
         }
         finally {
+            if (runPostColumnChange) {
+                await this.helpers.schema.postColumnChange();
+            }
             await (0, cache_1.clearSystemCache)();
         }
     }
@@ -204,6 +210,7 @@ class RelationsService {
         if (!existingRelation) {
             throw new exceptions_1.InvalidPayloadException(`Field "${field}" in collection "${collection}" doesn't have a relationship.`);
         }
+        const runPostColumnChange = await this.helpers.schema.preColumnChange();
         try {
             await this.knex.transaction(async (trx) => {
                 if (existingRelation.related_collection) {
@@ -247,6 +254,9 @@ class RelationsService {
             });
         }
         finally {
+            if (runPostColumnChange) {
+                await this.helpers.schema.postColumnChange();
+            }
             await (0, cache_1.clearSystemCache)();
         }
     }
@@ -267,6 +277,7 @@ class RelationsService {
         if (!existingRelation) {
             throw new exceptions_1.InvalidPayloadException(`Field "${field}" in collection "${collection}" doesn't have a relationship.`);
         }
+        const runPostColumnChange = await this.helpers.schema.preColumnChange();
         try {
             await this.knex.transaction(async (trx) => {
                 var _a;
@@ -284,6 +295,9 @@ class RelationsService {
             });
         }
         finally {
+            if (runPostColumnChange) {
+                await this.helpers.schema.postColumnChange();
+            }
             await (0, cache_1.clearSystemCache)();
         }
     }