directus 9.1.0 → 9.2.1

package/dist/exceptions/invalid-token.d.ts

@@ -0,0 +1,4 @@
+import { BaseException } from '@directus/shared/exceptions';
+export declare class InvalidTokenException extends BaseException {
+    constructor(message?: string);
+}

package/dist/exceptions/invalid-token.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidTokenException = void 0;
+const exceptions_1 = require("@directus/shared/exceptions");
+class InvalidTokenException extends exceptions_1.BaseException {
+    constructor(message = 'Invalid token') {
+        super(message, 403, 'INVALID_TOKEN');
+    }
+}
+exports.InvalidTokenException = InvalidTokenException;

package/dist/extensions.js

@@ -31,6 +31,7 @@ const database_1 = __importDefault(require("./database"));
 const emitter_1 = __importDefault(require("./emitter"));
 const env_1 = __importDefault(require("./env"));
 const exceptions = __importStar(require("./exceptions"));
+const sharedExceptions = __importStar(require("@directus/shared/exceptions"));
 const logger_1 = __importDefault(require("./logger"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const get_schema_1 = require("./utils/get-schema");
@@ -231,7 +232,14 @@ class ExtensionManager {
                 }
             },
         };
-        register(registerFunctions, { services, exceptions, env: env_1.default, database: (0, database_1.default)(), logger: logger_1.default, getSchema: get_schema_1.getSchema });
+        register(registerFunctions, {
+            services,
+            exceptions: { ...exceptions, ...sharedExceptions },
+            env: env_1.default,
+            database: (0, database_1.default)(),
+            logger: logger_1.default,
+            getSchema: get_schema_1.getSchema,
+        });
     }
     registerEndpoint(endpoint, router) {
         const endpointPath = path_1.default.resolve(endpoint.path, endpoint.entrypoint || '');
@@ -241,7 +249,14 @@ class ExtensionManager {
         const routeName = typeof mod === 'function' ? endpoint.name : mod.id;
         const scopedRouter = express_1.default.Router();
         router.use(`/${routeName}`, scopedRouter);
-        register(scopedRouter, { services, exceptions, env: env_1.default, database: (0, database_1.default)(), logger: logger_1.default, getSchema: get_schema_1.getSchema });
+        register(scopedRouter, {
+            services,
+            exceptions: { ...exceptions, ...sharedExceptions },
+            env: env_1.default,
+            database: (0, database_1.default)(),
+            logger: logger_1.default,
+            getSchema: get_schema_1.getSchema,
+        });
         this.apiEndpoints.push({
             path: endpointPath,
         });

package/dist/middleware/sanitize-query.js

@@ -6,7 +6,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const sanitize_query_1 = require("../utils/sanitize-query");
 const validate_query_1 = require("../utils/validate-query");
-const sanitizeQueryMiddleware = (req, res, next) => {
+const sanitizeQueryMiddleware = (req, _res, next) => {
     req.sanitizedQuery = {};
     if (!req.query)
         return;

package/dist/services/activity.js

@@ -15,6 +15,7 @@ const logger_1 = __importDefault(require("../logger"));
 const user_name_1 = require("../utils/user-name");
 const lodash_1 = require("lodash");
 const env_1 = __importDefault(require("../env"));
+const uuid_validate_1 = __importDefault(require("uuid-validate"));
 class ActivityService extends index_1.ItemsService {
     constructor(options) {
         super('directus_activity', options);
@@ -55,9 +56,13 @@ class ActivityService extends index_1.ItemsService {
                     }, {});
                     let comment = data.comment;
                     for (const mention of mentions) {
-                        comment = comment.replace(mention, (_h = userPreviews[mention.substring(1)]) !== null && _h !== void 0 ? _h : '@Unknown User');
+                        const uuid = mention.substring(1);
+                        // We only match on UUIDs in the first place. This is just an extra sanity check
+                        if ((0, uuid_validate_1.default)(uuid) === false)
+                            continue;
+                        comment = comment.replace(new RegExp(mention, 'gm'), (_h = userPreviews[uuid]) !== null && _h !== void 0 ? _h : '@Unknown User');
                     }
-                    comment = `> ${comment}`;
+                    comment = `> ${comment.replace(/\n+/gm, '\n> ')}`;
                     const message = `
 Hello ${(0, user_name_1.userName)(user)},
 

package/dist/services/assets.js

@@ -34,6 +34,7 @@ const exceptions_1 = require("../exceptions");
 const storage_1 = __importDefault(require("../storage"));
 const authorization_1 = require("./authorization");
 const TransformationUtils = __importStar(require("../utils/transformations"));
+const uuid_validate_1 = __importDefault(require("uuid-validate"));
 sharp_1.default.concurrency(1);
 // Note: don't put this in the service. The service can be initialized in multiple places, but they
 // should all share the same semaphore instance.
@@ -54,7 +55,20 @@ class AssetsService {
         if (systemPublicKeys.includes(id) === false && ((_a = this.accountability) === null || _a === void 0 ? void 0 : _a.admin) !== true) {
             await this.authorizationService.checkAccess('read', 'directus_files', id);
         }
+        /**
+         * This is a little annoying. Postgres will error out if you're trying to search in `where`
+         * with a wrong type. In case of directus_files where id is a uuid, we'll have to verify the
+         * validity of the uuid ahead of time.
+         */
+        const isValidUUID = (0, uuid_validate_1.default)(id, 4);
+        if (isValidUUID === false)
+            throw new exceptions_1.ForbiddenException();
         const file = (await this.knex.select('*').from('directus_files').where({ id }).first());
+        if (!file)
+            throw new exceptions_1.ForbiddenException();
+        const { exists } = await storage_1.default.disk(file.storage).exists(file.filename_disk);
+        if (!exists)
+            throw new exceptions_1.ForbiddenException();
         if (range) {
             if (range.start >= file.filesize || (range.end && range.end >= file.filesize)) {
                 throw new exceptions_1.RangeNotSatisfiableException(range);

package/dist/services/fields.d.ts

@@ -6,9 +6,11 @@ import { PayloadService } from '../services/payload';
 import { AbstractServiceOptions, SchemaOverview } from '../types';
 import { Accountability } from '@directus/shared/types';
 import { Field, RawField, Type } from '@directus/shared/types';
+import { Helpers } from '../database/helpers';
 import Keyv from 'keyv';
 export declare class FieldsService {
     knex: Knex;
+    helpers: Helpers;
     accountability: Accountability | null;
     itemsService: ItemsService;
     payloadService: PayloadService;

package/dist/services/fields.js

@@ -39,10 +39,11 @@ const get_local_type_1 = __importDefault(require("../utils/get-local-type"));
 const utils_1 = require("@directus/shared/utils");
 const lodash_1 = require("lodash");
 const relations_1 = require("./relations");
-const geometry_1 = require("../database/helpers/geometry");
+const helpers_1 = require("../database/helpers");
 class FieldsService {
     constructor(options) {
         this.knex = options.knex || (0, database_1.default)();
+        this.helpers = (0, helpers_1.getHelpers)(this.knex);
         this.schemaInspector = options.knex ? (0, schema_1.default)(options.knex) : (0, database_1.getSchemaInspector)();
         this.accountability = options.accountability || null;
         this.itemsService = new items_1.ItemsService('directus_fields', options);
@@ -211,23 +212,39 @@ class FieldsService {
                 accountability: this.accountability,
                 schema: this.schema,
             });
-            if (field.type && constants_1.ALIAS_TYPES.includes(field.type) === false) {
+            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, field);
+                    this.addColumnToTable(table, hookAdjustedField);
                 }
                 else {
                     await trx.schema.alterTable(collection, (table) => {
-                        this.addColumnToTable(table, field);
+                        this.addColumnToTable(table, hookAdjustedField);
                     });
                 }
             }
-            if (field.meta) {
+            if (hookAdjustedField.meta) {
                 await itemsService.createOne({
-                    ...field.meta,
+                    ...hookAdjustedField.meta,
                     collection: collection,
-                    field: field.field,
-                });
+                    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,
+            });
         });
         if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
             await this.cache.clear();
@@ -238,12 +255,23 @@ class FieldsService {
         if (this.accountability && this.accountability.admin !== true) {
             throw new exceptions_1.ForbiddenException();
         }
-        if (field.schema) {
-            const existingColumn = await this.schemaInspector.columnInfo(collection, field.field);
-            if (!(0, lodash_1.isEqual)(existingColumn, field.schema)) {
+        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 (!field.schema)
+                        if (!hookAdjustedField.schema)
                             return;
                         this.addColumnToTable(table, field, existingColumn);
                     });
@@ -253,31 +281,35 @@ class FieldsService {
                 }
             }
         }
-        if (field.meta) {
-            const record = await this.knex
-                .select('id')
-                .from('directus_fields')
-                .where({ collection, field: field.field })
-                .first();
+        if (hookAdjustedField.meta) {
             if (record) {
                 await this.itemsService.updateOne(record.id, {
-                    ...field.meta,
+                    ...hookAdjustedField.meta,
                     collection: collection,
-                    field: field.field,
-                });
+                    field: hookAdjustedField.field,
+                }, { emitEvents: false });
             }
             else {
                 await this.itemsService.createOne({
-                    ...field.meta,
+                    ...hookAdjustedField.meta,
                     collection: collection,
-                    field: field.field,
-                });
+                    field: hookAdjustedField.field,
+                }, { emitEvents: false });
             }
         }
         if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
             await this.cache.clear();
         }
         await this.systemCache.clear();
+        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) {
@@ -402,8 +434,7 @@ class FieldsService {
             column = table.timestamp(field.field, { useTz: true });
         }
         else if (field.type.startsWith('geometry')) {
-            const helper = (0, geometry_1.getGeometryHelper)();
-            column = helper.createColumn(table, field);
+            column = this.helpers.st.createColumn(table, field);
         }
         else {
             // @ts-ignore

package/dist/services/files.d.ts

@@ -9,7 +9,7 @@ export declare class FilesService extends ItemsService {
     uploadOne(stream: NodeJS.ReadableStream, data: Partial<File> & {
         filename_download: string;
         storage: string;
-    }, primaryKey?: PrimaryKey): Promise<PrimaryKey>;
+    }, primaryKey?: PrimaryKey, opts?: MutationOptions): Promise<PrimaryKey>;
     /**
      * Import a single file from an external URL
      */

package/dist/services/files.js

@@ -26,7 +26,7 @@ class FilesService extends items_1.ItemsService {
     /**
      * Upload a single new file to the configured storage adapter
      */
-    async uploadOne(stream, data, primaryKey) {
+    async uploadOne(stream, data, primaryKey, opts) {
         var _a, _b, _c, _d, _e, _f;
         const payload = (0, lodash_1.clone)(data);
         if ('folder' in payload === false) {
@@ -109,15 +109,17 @@ class FilesService extends items_1.ItemsService {
         if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
             await this.cache.clear();
         }
-        emitter_1.default.emitAction('files.upload', {
-            payload,
-            key: primaryKey,
-            collection: this.collection,
-        }, {
-            database: this.knex,
-            schema: this.schema,
-            accountability: this.accountability,
-        });
+        if ((opts === null || opts === void 0 ? void 0 : opts.emitEvents) !== false) {
+            emitter_1.default.emitAction('files.upload', {
+                payload,
+                key: primaryKey,
+                collection: this.collection,
+            }, {
+                database: this.knex,
+                schema: this.schema,
+                accountability: this.accountability,
+            });
+        }
         return primaryKey;
     }
     /**
@@ -126,7 +128,7 @@ class FilesService extends items_1.ItemsService {
     async importOne(importURL, body) {
         var _a, _b, _c;
         const fileCreatePermissions = (_b = (_a = this.accountability) === null || _a === void 0 ? void 0 : _a.permissions) === null || _b === void 0 ? void 0 : _b.find((permission) => permission.collection === 'directus_files' && permission.action === 'create');
-        if (((_c = this.accountability) === null || _c === void 0 ? void 0 : _c.admin) !== true && !fileCreatePermissions) {
+        if (this.accountability && ((_c = this.accountability) === null || _c === void 0 ? void 0 : _c.admin) !== true && !fileCreatePermissions) {
             throw new exceptions_1.ForbiddenException();
         }
         let fileResponse;

package/dist/services/graphql.js

@@ -726,6 +726,9 @@ class GraphQLService {
                     args: {
                         groupBy: new graphql_1.GraphQLList(graphql_1.GraphQLString),
                         filter: ReadableCollectionFilterTypes[collection.collection],
+                        limit: {
+                            type: graphql_1.GraphQLInt,
+                        },
                         search: {
                             type: graphql_1.GraphQLString,
                         },

package/dist/services/items.js

@@ -213,8 +213,16 @@ class ItemsService {
         if (records === null) {
             throw new exceptions_1.ForbiddenException();
         }
+        const filteredRecords = await emitter_1.default.emitFilter(`${this.eventScope}.read`, records, {
+            query,
+            collection: this.collection,
+        }, {
+            database: this.knex,
+            schema: this.schema,
+            accountability: this.accountability,
+        });
         emitter_1.default.emitAction(`${this.eventScope}.read`, {
-            payload: records,
+            payload: filteredRecords,
             query,
             collection: this.collection,
         }, {
@@ -222,23 +230,15 @@ class ItemsService {
             schema: this.schema,
             accountability: this.accountability,
         });
-        return records;
+        return filteredRecords;
     }
     /**
      * Get single item by primary key
      */
-    async readOne(key, query, opts) {
-        query = query !== null && query !== void 0 ? query : {};
+    async readOne(key, query = {}, opts) {
         const primaryKeyField = this.schema.collections[this.collection].primary;
-        const queryWithKey = {
-            ...query,
-            filter: {
-                ...(query.filter || {}),
-                [primaryKeyField]: {
-                    _eq: key,
-                },
-            },
-        };
+        const filterWithKey = (0, lodash_1.assign)({}, query.filter, { [primaryKeyField]: { _eq: key } });
+        const queryWithKey = (0, lodash_1.assign)({}, query, { filter: filterWithKey });
         const results = await this.readByQuery(queryWithKey, opts);
         if (results.length === 0) {
             throw new exceptions_1.ForbiddenException();
@@ -248,23 +248,12 @@ class ItemsService {
     /**
      * Get multiple items by primary keys
      */
-    async readMany(keys, query, opts) {
-        query = query !== null && query !== void 0 ? query : {};
+    async readMany(keys, query = {}, opts) {
+        var _a;
         const primaryKeyField = this.schema.collections[this.collection].primary;
-        const queryWithKeys = {
-            ...query,
-            filter: {
-                _and: [
-                    query.filter || {},
-                    {
-                        [primaryKeyField]: {
-                            _in: keys,
-                        },
-                    },
-                ],
-            },
-        };
-        const results = await this.readByQuery(queryWithKeys, opts);
+        const filterWithKey = { _and: [{ [primaryKeyField]: { _in: keys } }, (_a = query.filter) !== null && _a !== void 0 ? _a : {}] };
+        const queryWithKey = (0, lodash_1.assign)({}, query, { filter: filterWithKey });
+        const results = await this.readByQuery(queryWithKey, opts);
         return results;
     }
     /**

package/dist/services/payload.d.ts

@@ -1,6 +1,7 @@
 import { Knex } from 'knex';
 import { AbstractServiceOptions, Item, PrimaryKey, SchemaOverview } from '../types';
 import { Accountability } from '@directus/shared/types';
+import { Helpers } from '../database/helpers';
 declare type Action = 'create' | 'read' | 'update';
 declare type Transformers = {
     [type: string]: (context: {
@@ -18,6 +19,7 @@ declare type Transformers = {
 export declare class PayloadService {
     accountability: Accountability | null;
     knex: Knex;
+    helpers: Helpers;
     collection: string;
     schema: SchemaOverview;
     constructor(collection: string, options: AbstractServiceOptions);

package/dist/services/payload.js

@@ -13,7 +13,7 @@ const exceptions_1 = require("../exceptions");
 const utils_1 = require("@directus/shared/utils");
 const items_1 = require("./items");
 const flat_1 = require("flat");
-const geometry_1 = require("../database/helpers/geometry");
+const helpers_1 = require("../database/helpers");
 const wellknown_1 = require("wellknown");
 const generate_hash_1 = require("../utils/generate-hash");
 /**
@@ -111,6 +111,7 @@ class PayloadService {
         };
         this.accountability = options.accountability || null;
         this.knex = options.knex || (0, database_1.default)();
+        this.helpers = (0, helpers_1.getHelpers)(this.knex);
         this.collection = collection;
         this.schema = options.schema;
         return this;
@@ -188,10 +189,9 @@ class PayloadService {
      * to check if the value is a raw instance before stringifying it in the next step.
      */
     processGeometries(payloads, action) {
-        const helper = (0, geometry_1.getGeometryHelper)();
         const process = action == 'read'
             ? (value) => (typeof value === 'string' ? (0, wellknown_1.parse)(value) : value)
-            : (value) => helper.fromGeoJSON(typeof value == 'string' ? JSON.parse(value) : value);
+            : (value) => this.helpers.st.fromGeoJSON(typeof value == 'string' ? JSON.parse(value) : value);
         const fieldsInCollection = Object.entries(this.schema.collections[this.collection].fields);
         const geometryColumns = fieldsInCollection.filter(([_, field]) => field.type.startsWith('geometry'));
         for (const [name] of geometryColumns) {

package/dist/utils/apply-query.js

@@ -8,11 +8,9 @@ const lodash_1 = require("lodash");
 const nanoid_1 = require("nanoid");
 const uuid_validate_1 = __importDefault(require("uuid-validate"));
 const exceptions_1 = require("../exceptions");
-const apply_function_to_column_name_1 = require("./apply-function-to-column-name");
 const get_column_1 = require("./get-column");
 const get_relation_type_1 = require("./get-relation-type");
-const geometry_1 = require("../database/helpers/geometry");
-const date_1 = require("../database/helpers/date");
+const helpers_1 = require("../database/helpers");
 const generateAlias = (0, nanoid_1.customAlphabet)('abcdefghijklmnopqrstuvwxyz', 5);
 /**
  * Apply the Query to a given Knex query builder instance
@@ -45,7 +43,7 @@ function applyQuery(knex, collection, dbQuery, query, schema, subQuery = false)
         applySearch(schema, dbQuery, query.search, collection);
     }
     if (query.group) {
-        dbQuery.groupBy(query.group.map(apply_function_to_column_name_1.applyFunctionToColumnName));
+        dbQuery.groupBy(query.group.map((column) => (0, get_column_1.getColumn)(knex, collection, column, false)));
     }
     if (query.aggregate) {
         applyAggregate(dbQuery, query.aggregate, collection);
@@ -117,6 +115,7 @@ exports.default = applyQuery;
  * ```
  */
 function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery = false) {
+    const helpers = (0, helpers_1.getHelpers)(knex);
     const relations = schema.relations;
     const aliasMap = {};
     addJoins(rootQuery, rootFilter, collection);
@@ -273,16 +272,15 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
                     query.where(key, '!=', '');
                 });
             }
-            const dateHelper = (0, date_1.getDateHelper)();
             const [collection, field] = key.split('.');
             if (collection in schema.collections && field in schema.collections[collection].fields) {
                 const type = schema.collections[collection].fields[field].type;
                 if (['date', 'dateTime', 'time', 'timestamp'].includes(type)) {
                     if (Array.isArray(compareValue)) {
-                        compareValue = compareValue.map((val) => dateHelper.parseDate(val));
+                        compareValue = compareValue.map((val) => helpers.date.parse(val));
                     }
                     else {
-                        compareValue = dateHelper.parseDate(compareValue);
+                        compareValue = helpers.date.parse(compareValue);
                     }
                 }
             }
@@ -361,18 +359,17 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
                     value = value.split(',');
                 dbQuery[logical].whereNotBetween(selectionRaw, value);
             }
-            const geometryHelper = (0, geometry_1.getGeometryHelper)();
             if (operator == '_intersects') {
-                dbQuery[logical].whereRaw(geometryHelper.intersects(key, compareValue));
+                dbQuery[logical].whereRaw(helpers.st.intersects(key, compareValue));
             }
             if (operator == '_nintersects') {
-                dbQuery[logical].whereRaw(geometryHelper.nintersects(key, compareValue));
+                dbQuery[logical].whereRaw(helpers.st.nintersects(key, compareValue));
             }
             if (operator == '_intersects_bbox') {
-                dbQuery[logical].whereRaw(geometryHelper.intersects_bbox(key, compareValue));
+                dbQuery[logical].whereRaw(helpers.st.intersects_bbox(key, compareValue));
             }
             if (operator == '_nintersects_bbox') {
-                dbQuery[logical].whereRaw(geometryHelper.nintersects_bbox(key, compareValue));
+                dbQuery[logical].whereRaw(helpers.st.nintersects_bbox(key, compareValue));
             }
         }
         function getWhereColumn(path, collection) {

package/dist/utils/apply-snapshot.js

@@ -36,14 +36,13 @@ async function applySnapshot(snapshot, options) {
                 // edits
                 snapshotDiff.fields = snapshotDiff.fields.filter((fieldDiff) => fieldDiff.collection !== collection);
             }
-            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'E') {
-                const updates = diff.reduce((acc, edit) => {
-                    if (edit.kind !== 'E')
-                        return acc;
-                    (0, lodash_1.set)(acc, edit.path, edit.rhs);
-                    return acc;
-                }, {});
-                await collectionsService.updateOne(collection, updates);
+            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'E' || (diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'A') {
+                const newValues = snapshot.collections.find((field) => {
+                    return field.collection === collection;
+                });
+                if (newValues) {
+                    await collectionsService.updateOne(collection, newValues);
+                }
             }
         }
         const fieldsService = new services_1.FieldsService({ knex: trx, schema: await (0, get_schema_1.getSchema)({ database: trx }) });
@@ -51,18 +50,15 @@ async function applySnapshot(snapshot, options) {
             if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'N') {
                 await fieldsService.createField(collection, diff[0].rhs);
             }
-            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'E') {
-                const updates = diff.reduce((acc, edit) => {
-                    if (edit.kind !== 'E')
-                        return acc;
-                    (0, lodash_1.set)(acc, edit.path, edit.rhs);
-                    return acc;
-                }, {});
-                await fieldsService.updateField(collection, {
-                    field,
-                    type: 'unknown',
-                    ...updates,
+            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'E' || (diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'A') {
+                const newValues = snapshot.fields.find((snapshotField) => {
+                    return snapshotField.collection === collection && snapshotField.field === field;
                 });
+                if (newValues) {
+                    await fieldsService.updateField(collection, {
+                        ...newValues,
+                    });
+                }
             }
             if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'D') {
                 await fieldsService.deleteField(collection, field);
@@ -72,18 +68,21 @@ async function applySnapshot(snapshot, options) {
             }
         }
         const relationsService = new services_1.RelationsService({ knex: trx, schema: await (0, get_schema_1.getSchema)({ database: trx }) });
-        for (const { collection, field, diff, related_collection } of snapshotDiff.relations) {
+        for (const { collection, field, diff } of snapshotDiff.relations) {
+            const structure = {};
+            for (const diffEdit of diff) {
+                (0, lodash_1.set)(structure, diffEdit.path, undefined);
+            }
             if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'N') {
                 await relationsService.createOne(diff[0].rhs);
             }
-            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'E') {
-                const updates = diff.reduce((acc, edit) => {
-                    if (edit.kind !== 'E')
-                        return acc;
-                    (0, lodash_1.set)(acc, edit.path, edit.rhs);
-                    return acc;
-                }, { collection, field, related_collection });
-                await relationsService.updateOne(collection, field, updates);
+            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'E' || (diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'A') {
+                const newValues = snapshot.relations.find((relation) => {
+                    return relation.collection === collection && relation.field === field;
+                });
+                if (newValues) {
+                    await relationsService.updateOne(collection, field, newValues);
+                }
             }
             if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'D') {
                 await relationsService.deleteOne(collection, field);

package/dist/utils/get-column.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getColumn = void 0;
-const functions_1 = require("../database/functions");
+const helpers_1 = require("../database/helpers");
 const constants_1 = require("@directus/shared/constants");
 const apply_function_to_column_name_1 = require("./apply-function-to-column-name");
 /**
@@ -15,7 +15,7 @@ const apply_function_to_column_name_1 = require("./apply-function-to-column-name
  * @returns Knex raw instance
  */
 function getColumn(knex, table, column, alias = (0, apply_function_to_column_name_1.applyFunctionToColumnName)(column)) {
-    const fn = (0, functions_1.FunctionsHelper)(knex);
+    const { date: fn } = (0, helpers_1.getHelpers)(knex);
     if (column.includes('(') && column.includes(')')) {
         const functionName = column.split('(')[0];
         const columnName = column.match(constants_1.REGEX_BETWEEN_PARENS)[1];