directus 9.12.1 → 9.14.0

package/dist/services/items.js

@@ -14,10 +14,10 @@ const env_1 = __importDefault(require("../env"));
 const exceptions_1 = require("../exceptions");
 const translate_1 = require("../exceptions/database/translate");
 const get_ast_from_query_1 = __importDefault(require("../utils/get-ast-from-query"));
+const validate_keys_1 = require("../utils/validate-keys");
 const authorization_1 = require("./authorization");
 const index_1 = require("./index");
 const payload_1 = require("./payload");
-const validate_keys_1 = require("../utils/validate-keys");
 class ItemsService {
     constructor(collection, options) {
         this.collection = collection;
@@ -221,23 +221,27 @@ class ItemsService {
         if (records === null) {
             throw new exceptions_1.ForbiddenException();
         }
-        const filteredRecords = await emitter_1.default.emitFilter(this.eventScope === 'items' ? ['items.read', `${this.collection}.items.read`] : `${this.eventScope}.read`, records, {
-            query,
-            collection: this.collection,
-        }, {
-            database: this.knex,
-            schema: this.schema,
-            accountability: this.accountability,
-        });
-        emitter_1.default.emitAction(this.eventScope === 'items' ? ['items.read', `${this.collection}.items.read`] : `${this.eventScope}.read`, {
-            payload: filteredRecords,
-            query,
-            collection: this.collection,
-        }, {
-            database: this.knex || (0, database_1.default)(),
-            schema: this.schema,
-            accountability: this.accountability,
-        });
+        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,
+                collection: this.collection,
+            }, {
+                database: this.knex,
+                schema: this.schema,
+                accountability: this.accountability,
+            })
+            : records;
+        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,
+                collection: this.collection,
+            }, {
+                database: this.knex || (0, database_1.default)(),
+                schema: this.schema,
+                accountability: this.accountability,
+            });
+        }
         return filteredRecords;
     }
     /**
@@ -289,7 +293,27 @@ class ItemsService {
         return key;
     }
     /**
-     * Update many items by primary key
+     * Update multiple items in a single transaction
+     */
+    async updateBatch(data, opts) {
+        const primaryKeyField = this.schema.collections[this.collection].primary;
+        const keys = [];
+        await this.knex.transaction(async (trx) => {
+            const service = new ItemsService(this.collection, {
+                accountability: this.accountability,
+                knex: trx,
+                schema: this.schema,
+            });
+            for (const item of data) {
+                if (!item[primaryKeyField])
+                    throw new exceptions_1.InvalidPayloadException(`Item in update misses primary key.`);
+                keys.push(await service.updateOne(item[primaryKeyField], (0, lodash_1.omit)(item, primaryKeyField), opts));
+            }
+        });
+        return keys;
+    }
+    /**
+     * Update many items by primary key, setting all items to the same change
      */
     async updateMany(keys, data, opts) {
         const primaryKeyField = this.schema.collections[this.collection].primary;

package/dist/services/mail/index.js

@@ -23,12 +23,14 @@ class MailService {
         this.accountability = opts.accountability || null;
         this.knex = (opts === null || opts === void 0 ? void 0 : opts.knex) || (0, database_1.default)();
         this.mailer = (0, mailer_1.default)();
-        this.mailer.verify((error) => {
-            if (error) {
-                logger_1.default.warn(`Email connection failed:`);
-                logger_1.default.warn(error);
-            }
-        });
+        if (env_1.default.EMAIL_VERIFY_SETUP) {
+            this.mailer.verify((error) => {
+                if (error) {
+                    logger_1.default.warn(`Email connection failed:`);
+                    logger_1.default.warn(error);
+                }
+            });
+        }
     }
     async send(options) {
         const { template, ...emailOptions } = options;

package/dist/services/notifications.js

@@ -1,10 +1,14 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotificationsService = void 0;
 const items_1 = require("./items");
 const md_1 = require("../utils/md");
 const users_1 = require("./users");
 const mail_1 = require("./mail");
+const logger_1 = __importDefault(require("../logger"));
 class NotificationsService extends items_1.ItemsService {
     constructor(options) {
         super('directus_notifications', options);
@@ -12,29 +16,36 @@ class NotificationsService extends items_1.ItemsService {
         this.mailService = new mail_1.MailService({ schema: this.schema, accountability: this.accountability });
     }
     async createOne(data, opts) {
+        const response = await super.createOne(data, opts);
         await this.sendEmail(data);
-        return super.createOne(data, opts);
+        return response;
     }
     async createMany(data, opts) {
+        const response = await super.createMany(data, opts);
         for (const notification of data) {
             await this.sendEmail(notification);
         }
-        return super.createMany(data, opts);
+        return response;
     }
     async sendEmail(data) {
         if (data.recipient) {
             const user = await this.usersService.readOne(data.recipient, { fields: ['email', 'email_notifications'] });
             if (user.email && user.email_notifications === true) {
-                await this.mailService.send({
-                    template: {
-                        name: 'base',
-                        data: {
-                            html: data.message ? (0, md_1.md)(data.message) : '',
+                try {
+                    await this.mailService.send({
+                        template: {
+                            name: 'base',
+                            data: {
+                                html: data.message ? (0, md_1.md)(data.message) : '',
+                            },
                         },
-                    },
-                    to: user.email,
-                    subject: data.subject,
-                });
+                        to: user.email,
+                        subject: data.subject,
+                    });
+                }
+                catch (error) {
+                    logger_1.default.error(error.message);
+                }
             }
         }
     }

package/dist/services/operations.d.ts

@@ -1,13 +1,12 @@
 import { OperationRaw } from '@directus/shared/types';
-import { Messenger } from '../messenger';
 import { AbstractServiceOptions, Item, MutationOptions, PrimaryKey } from '../types';
 import { ItemsService } from './items';
 export declare class OperationsService extends ItemsService<OperationRaw> {
-    messenger: Messenger;
     constructor(options: AbstractServiceOptions);
     createOne(data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
     createMany(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
     updateOne(key: PrimaryKey, data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
+    updateBatch(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
     updateMany(keys: PrimaryKey[], data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
     deleteOne(key: PrimaryKey, opts?: MutationOptions): Promise<PrimaryKey>;
     deleteMany(keys: PrimaryKey[], opts?: MutationOptions): Promise<PrimaryKey[]>;

package/dist/services/operations.js

@@ -1,41 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OperationsService = void 0;
-const messenger_1 = require("../messenger");
+const flows_1 = require("../flows");
 const items_1 = require("./items");
 class OperationsService extends items_1.ItemsService {
     constructor(options) {
         super('directus_operations', options);
-        this.messenger = (0, messenger_1.getMessenger)();
     }
     async createOne(data, opts) {
+        const flowManager = (0, flows_1.getFlowManager)();
         const result = await super.createOne(data, opts);
-        this.messenger.publish('flows', { type: 'reload' });
+        await flowManager.reload();
         return result;
     }
     async createMany(data, opts) {
+        const flowManager = (0, flows_1.getFlowManager)();
         const result = await super.createMany(data, opts);
-        this.messenger.publish('flows', { type: 'reload' });
+        await flowManager.reload();
         return result;
     }
     async updateOne(key, data, opts) {
+        const flowManager = (0, flows_1.getFlowManager)();
         const result = await super.updateOne(key, data, opts);
-        this.messenger.publish('flows', { type: 'reload' });
+        await flowManager.reload();
+        return result;
+    }
+    async updateBatch(data, opts) {
+        const flowManager = (0, flows_1.getFlowManager)();
+        const result = await super.updateBatch(data, opts);
+        await flowManager.reload();
         return result;
     }
     async updateMany(keys, data, opts) {
+        const flowManager = (0, flows_1.getFlowManager)();
         const result = await super.updateMany(keys, data, opts);
-        this.messenger.publish('flows', { type: 'reload' });
+        await flowManager.reload();
         return result;
     }
     async deleteOne(key, opts) {
+        const flowManager = (0, flows_1.getFlowManager)();
         const result = await super.deleteOne(key, opts);
-        this.messenger.publish('flows', { type: 'reload' });
+        await flowManager.reload();
         return result;
     }
     async deleteMany(keys, opts) {
+        const flowManager = (0, flows_1.getFlowManager)();
         const result = await super.deleteMany(keys, opts);
-        this.messenger.publish('flows', { type: 'reload' });
+        await flowManager.reload();
         return result;
     }
 }

package/dist/services/payload.js

@@ -4,8 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PayloadService = void 0;
-const utils_1 = require("@directus/shared/utils");
 const date_fns_1 = require("date-fns");
+const utils_1 = require("@directus/shared/utils");
 const flat_1 = require("flat");
 const joi_1 = __importDefault(require("joi"));
 const lodash_1 = require("lodash");
@@ -15,7 +15,6 @@ const database_1 = __importDefault(require("../database"));
 const helpers_1 = require("../database/helpers");
 const exceptions_1 = require("../exceptions");
 const generate_hash_1 = require("../utils/generate-hash");
-const parse_json_1 = require("../utils/parse-json");
 const items_1 = require("./items");
 /**
  * Process a given payload for a collection to ensure the special fields (hash, uuid, date etc) are
@@ -56,7 +55,7 @@ class PayloadService {
                 if (action === 'read') {
                     if (typeof value === 'string') {
                         try {
-                            return (0, parse_json_1.parseJSON)(value);
+                            return (0, utils_1.parseJSON)(value);
                         }
                         catch {
                             return value;
@@ -197,7 +196,7 @@ class PayloadService {
     processGeometries(payloads, action) {
         const process = action == 'read'
             ? (value) => (typeof value === 'string' ? (0, wellknown_1.parse)(value) : value)
-            : (value) => this.helpers.st.fromGeoJSON(typeof value == 'string' ? (0, parse_json_1.parseJSON)(value) : value);
+            : (value) => this.helpers.st.fromGeoJSON(typeof value == 'string' ? (0, utils_1.parseJSON)(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) {
@@ -260,15 +259,18 @@ class PayloadService {
                 else {
                     if (value instanceof Date === false && typeof value === 'string') {
                         if (dateColumn.type === 'date') {
-                            const [date] = value.split('T');
-                            const [year, month, day] = date.split('-');
-                            payload[name] = new Date(Number(year), Number(month) - 1, Number(day));
+                            const parsedDate = (0, date_fns_1.parseISO)(value);
+                            if (!(0, date_fns_1.isValid)(parsedDate)) {
+                                throw new exceptions_1.InvalidPayloadException(`Invalid Date format in field "${dateColumn.field}"`);
+                            }
+                            payload[name] = parsedDate;
                         }
                         if (dateColumn.type === 'dateTime') {
-                            const [date, time] = value.split('T');
-                            const [year, month, day] = date.split('-');
-                            const [hours, minutes, seconds] = time.substring(0, 8).split(':');
-                            payload[name] = new Date(Number(year), Number(month) - 1, Number(day), Number(hours), Number(minutes), Number(seconds));
+                            const parsedDate = (0, date_fns_1.parseISO)(value);
+                            if (!(0, date_fns_1.isValid)(parsedDate)) {
+                                throw new exceptions_1.InvalidPayloadException(`Invalid DateTime format in field "${dateColumn.field}"`);
+                            }
+                            payload[name] = parsedDate;
                         }
                         if (dateColumn.type === 'timestamp') {
                             const newValue = this.helpers.date.writeTimestamp(value);

package/dist/services/permissions.d.ts

@@ -12,6 +12,7 @@ export declare class PermissionsService extends ItemsService {
     createMany(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
     updateByQuery(query: Query, data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
     updateOne(key: PrimaryKey, data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
+    updateBatch(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
     updateMany(keys: PrimaryKey[], data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
     upsertOne(payload: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
     upsertMany(payloads: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;

package/dist/services/permissions.js

@@ -70,6 +70,11 @@ class PermissionsService extends items_1.ItemsService {
         await (0, cache_1.clearSystemCache)();
         return res;
     }
+    async updateBatch(data, opts) {
+        const res = await super.updateBatch(data, opts);
+        await (0, cache_1.clearSystemCache)();
+        return res;
+    }
     async updateMany(keys, data, opts) {
         const res = await super.updateMany(keys, data, opts);
         await (0, cache_1.clearSystemCache)();

package/dist/services/relations.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/dist/services/roles.d.ts

@@ -6,6 +6,7 @@ export declare class RolesService extends ItemsService {
     private checkForOtherAdminRoles;
     private checkForOtherAdminUsers;
     updateOne(key: PrimaryKey, data: Record<string, any>, opts?: MutationOptions): Promise<PrimaryKey>;
+    updateBatch(data: Record<string, any>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
     updateMany(keys: PrimaryKey[], data: Record<string, any>, opts?: MutationOptions): Promise<PrimaryKey[]>;
     deleteOne(key: PrimaryKey): Promise<PrimaryKey>;
     deleteMany(keys: PrimaryKey[]): Promise<PrimaryKey[]>;

package/dist/services/roles.js

@@ -64,6 +64,15 @@ class RolesService extends items_1.ItemsService {
         }
         return super.updateOne(key, data, opts);
     }
+    async updateBatch(data, opts) {
+        const primaryKeyField = this.schema.collections[this.collection].primary;
+        const keys = data.map((item) => item[primaryKeyField]);
+        const setsToNoAdmin = data.some((item) => item.admin_access === false);
+        if (setsToNoAdmin) {
+            await this.checkForOtherAdminRoles(keys);
+        }
+        return super.updateBatch(data, opts);
+    }
     async updateMany(keys, data, opts) {
         if ('admin_access' in data && data.admin_access === false) {
             await this.checkForOtherAdminRoles(keys);

package/dist/services/server.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/dist/services/users.d.ts

@@ -38,6 +38,7 @@ export declare class UsersService extends ItemsService {
      * Update a single user by primary key
      */
     updateOne(key: PrimaryKey, data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
+    updateBatch(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
     /**
      * Update many users by primary key
      */

package/dist/services/users.js

@@ -153,6 +153,23 @@ class UsersService extends items_1.ItemsService {
         await this.updateMany([key], data, opts);
         return key;
     }
+    async updateBatch(data, opts) {
+        const primaryKeyField = this.schema.collections[this.collection].primary;
+        const keys = [];
+        await this.knex.transaction(async (trx) => {
+            const service = new UsersService({
+                accountability: this.accountability,
+                knex: trx,
+                schema: this.schema,
+            });
+            for (const item of data) {
+                if (!item[primaryKeyField])
+                    throw new exceptions_2.InvalidPayloadException(`User in update misses primary key.`);
+                keys.push(await service.updateOne(item[primaryKeyField], item, opts));
+            }
+        });
+        return keys;
+    }
     /**
      * Update many users by primary key
      */
@@ -305,6 +322,7 @@ class UsersService extends items_1.ItemsService {
         await (0, stall_1.stall)(STALL_TIME, timeStart);
     }
     async resetPassword(token, password) {
+        var _a;
         const { email, scope, hash } = jsonwebtoken_1.default.verify(token, env_1.default.SECRET, { issuer: 'directus' });
         if (scope !== 'password-reset' || !hash)
             throw new exceptions_2.ForbiddenException();
@@ -317,6 +335,10 @@ class UsersService extends items_1.ItemsService {
         const service = new UsersService({
             knex: this.knex,
             schema: this.schema,
+            accountability: {
+                ...((_a = this.accountability) !== null && _a !== void 0 ? _a : { role: null }),
+                admin: true, // We need to skip permissions checks for the update call below
+            },
         });
         await service.updateOne(user.id, { password, status: 'active' });
     }

package/dist/types/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/dist/utils/apply-query.js

@@ -211,7 +211,15 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
                     const columnName = (0, get_column_path_1.getColumnPath)({ path: filterPath, collection, relations, aliasMap });
                     if (!columnName)
                         continue;
-                    applyFilterToQuery(columnName, filterOperator, filterValue, logical);
+                    if (relation === null || relation === void 0 ? void 0 : relation.related_collection) {
+                        applyFilterToQuery(columnName, filterOperator, filterValue, logical, relation.related_collection); // m2o
+                    }
+                    else if (filterPath[0].includes(':')) {
+                        applyFilterToQuery(columnName, filterOperator, filterValue, logical, filterPath[0].split(':')[1]); // a2o
+                    }
+                    else {
+                        applyFilterToQuery(columnName, filterOperator, filterValue, logical);
+                    }
                 }
                 else {
                     applyFilterToQuery(`${collection}.${filterPath[0]}`, filterOperator, filterValue, logical);
@@ -245,7 +253,7 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
                 }
             }
         }
-        function applyFilterToQuery(key, operator, compareValue, logical = 'and') {
+        function applyFilterToQuery(key, operator, compareValue, logical = 'and', originalCollectionName) {
             const [table, column] = key.split('.');
             // Is processed through Knex.Raw, so should be safe to string-inject into these where queries
             const selectionRaw = (0, get_column_1.getColumn)(knex, table, column, false, schema);
@@ -268,6 +276,17 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
                     query.where(key, '!=', '');
                 });
             }
+            // The following fields however, require a value to be run. If no value is passed, we
+            // ignore them. This allows easier use in GraphQL, where you wouldn't be able to
+            // conditionally build out your filter structure (#4471)
+            if (compareValue === undefined)
+                return;
+            if (Array.isArray(compareValue)) {
+                // Tip: when using a `[Type]` type in GraphQL, but don't provide the variable, it'll be
+                // reported as [undefined].
+                // We need to remove any undefined values, as they are useless
+                compareValue = compareValue.filter((val) => val !== undefined);
+            }
             // Cast filter value (compareValue) based on function used
             if (column.includes('(') && column.includes(')')) {
                 const functionName = column.split('(')[0];
@@ -278,8 +297,9 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
             }
             // Cast filter value (compareValue) based on type of field being filtered against
             const [collection, field] = key.split('.');
-            if (collection in schema.collections && field in schema.collections[collection].fields) {
-                const type = schema.collections[collection].fields[field].type;
+            const mappedCollection = originalCollectionName || collection;
+            if (mappedCollection in schema.collections && field in schema.collections[mappedCollection].fields) {
+                const type = schema.collections[mappedCollection].fields[field].type;
                 if (['date', 'dateTime', 'time', 'timestamp'].includes(type)) {
                     if (Array.isArray(compareValue)) {
                         compareValue = compareValue.map((val) => helpers.date.parse(val));
@@ -297,17 +317,6 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
                     }
                 }
             }
-            // The following fields however, require a value to be run. If no value is passed, we
-            // ignore them. This allows easier use in GraphQL, where you wouldn't be able to
-            // conditionally build out your filter structure (#4471)
-            if (compareValue === undefined)
-                return;
-            if (Array.isArray(compareValue)) {
-                // Tip: when using a `[Type]` type in GraphQL, but don't provide the variable, it'll be
-                // reported as [undefined].
-                // We need to remove any undefined values, as they are useless
-                compareValue = compareValue.filter((val) => val !== undefined);
-            }
             if (operator === '_eq') {
                 dbQuery[logical].where(selectionRaw, '=', compareValue);
             }

package/dist/utils/apply-snapshot.js

@@ -11,10 +11,12 @@ const services_1 = require("../services");
 const get_schema_1 = require("./get-schema");
 const get_snapshot_1 = require("./get-snapshot");
 const get_snapshot_diff_1 = require("./get-snapshot-diff");
+const cache_1 = require("../cache");
 async function applySnapshot(snapshot, options) {
     var _a, _b, _c, _d;
     const database = (_a = options === null || options === void 0 ? void 0 : options.database) !== null && _a !== void 0 ? _a : (0, database_1.default)();
     const schema = (_b = options === null || options === void 0 ? void 0 : options.schema) !== null && _b !== void 0 ? _b : (await (0, get_schema_1.getSchema)({ database }));
+    const { systemCache } = (0, cache_1.getCache)();
     const current = (_c = options === null || options === void 0 ? void 0 : options.current) !== null && _c !== void 0 ? _c : (await (0, get_snapshot_1.getSnapshot)({ database, schema }));
     const snapshotDiff = (_d = options === null || options === void 0 ? void 0 : options.diff) !== null && _d !== void 0 ? _d : (0, get_snapshot_diff_1.getSnapshotDiff)(current, snapshot);
     await database.transaction(async (trx) => {
@@ -178,6 +180,7 @@ async function applySnapshot(snapshot, options) {
             }
         }
     });
+    await (systemCache === null || systemCache === void 0 ? void 0 : systemCache.clear());
 }
 exports.applySnapshot = applySnapshot;
 function isNestedMetaUpdate(diff) {

package/dist/utils/calculate-field-depth.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Calculates the depth of a given JSON structure, not counting any _ prefixed properties
+ *
+ * Used to calculate the field depth in a filter or deep query structure
+ *
+ * @example
+ *
+ * ```js
+ * const deep = {
+ * 	translations: {
+ * 		_filter: {
+ * 			_and: [
+ * 				{
+ * 					language_id: {
+ * 						name: {
+ * 							_eq: 'English'
+ * 						}
+ * 					}
+ * 				},
+ * 				{
+ * 					status: {
+ * 						_eq: 'Published'
+ * 					}
+ * 				}
+ * 			]
+ * 		}
+ * 	}
+ * };
+ *
+ * const result = calculateFieldDepth(deep); // => 3
+ * ```
+ */
+export declare function calculateFieldDepth(obj?: Record<string, any> | null, dotNotationKeys?: string[]): number;