directus 9.22.3 → 9.23.1

package/dist/utils/apply-diff.js

@@ -0,0 +1,259 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNestedMetaUpdate = exports.applyDiff = void 0;
+const services_1 = require("../services");
+const types_1 = require("../types");
+const get_schema_1 = require("./get-schema");
+const database_1 = __importDefault(require("../database"));
+const deep_diff_1 = require("deep-diff");
+const lodash_1 = require("lodash");
+const logger_1 = __importDefault(require("../logger"));
+const emitter_1 = __importDefault(require("../emitter"));
+const cache_1 = require("../cache");
+async function applyDiff(currentSnapshot, snapshotDiff, options) {
+    var _a, _b;
+    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, bypassCache: true }));
+    const nestedActionEvents = [];
+    const mutationOptions = {
+        autoPurgeSystemCache: false,
+        bypassEmitAction: (params) => nestedActionEvents.push(params),
+    };
+    await database.transaction(async (trx) => {
+        const collectionsService = new services_1.CollectionsService({ knex: trx, schema });
+        const getNestedCollectionsToCreate = (currentLevelCollection) => snapshotDiff.collections.filter(({ diff }) => { var _a, _b; return ((_b = (_a = diff[0].rhs) === null || _a === void 0 ? void 0 : _a.meta) === null || _b === void 0 ? void 0 : _b.group) === currentLevelCollection; });
+        const getNestedCollectionsToDelete = (currentLevelCollection) => snapshotDiff.collections.filter(({ diff }) => { var _a, _b; return ((_b = (_a = diff[0].lhs) === null || _a === void 0 ? void 0 : _a.meta) === null || _b === void 0 ? void 0 : _b.group) === currentLevelCollection; });
+        const createCollections = async (collections) => {
+            for (const { collection, diff } of collections) {
+                if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === types_1.DiffKind.NEW && diff[0].rhs) {
+                    // We'll nest the to-be-created fields in the same collection creation, to prevent
+                    // creating a collection without a primary key
+                    const fields = snapshotDiff.fields
+                        .filter((fieldDiff) => fieldDiff.collection === collection)
+                        .map((fieldDiff) => fieldDiff.diff[0].rhs)
+                        .map((fieldDiff) => {
+                        var _a, _b, _c, _d, _e;
+                        // Casts field type to UUID when applying non-PostgreSQL schema onto PostgreSQL database.
+                        // This is needed because they snapshots UUID fields as char/varchar with length 36.
+                        if (['char', 'varchar'].includes(String((_a = fieldDiff.schema) === null || _a === void 0 ? void 0 : _a.data_type).toLowerCase()) &&
+                            ((_b = fieldDiff.schema) === null || _b === void 0 ? void 0 : _b.max_length) === 36 &&
+                            (((_c = fieldDiff.schema) === null || _c === void 0 ? void 0 : _c.is_primary_key) ||
+                                (((_d = fieldDiff.schema) === null || _d === void 0 ? void 0 : _d.foreign_key_table) && ((_e = fieldDiff.schema) === null || _e === void 0 ? void 0 : _e.foreign_key_column)))) {
+                            return (0, lodash_1.merge)(fieldDiff, { type: 'uuid', schema: { data_type: 'uuid', max_length: null } });
+                        }
+                        else {
+                            return fieldDiff;
+                        }
+                    });
+                    try {
+                        await collectionsService.createOne({
+                            ...diff[0].rhs,
+                            fields,
+                        }, mutationOptions);
+                    }
+                    catch (err) {
+                        logger_1.default.error(`Failed to create collection "${collection}"`);
+                        throw err;
+                    }
+                    // Now that the fields are in for this collection, we can strip them from the field edits
+                    snapshotDiff.fields = snapshotDiff.fields.filter((fieldDiff) => fieldDiff.collection !== collection);
+                    await createCollections(getNestedCollectionsToCreate(collection));
+                }
+            }
+        };
+        const deleteCollections = async (collections) => {
+            for (const { collection, diff } of collections) {
+                if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === types_1.DiffKind.DELETE) {
+                    const relations = schema.relations.filter((r) => r.related_collection === collection || r.collection === collection);
+                    if (relations.length > 0) {
+                        const relationsService = new services_1.RelationsService({ knex: trx, schema });
+                        for (const relation of relations) {
+                            try {
+                                await relationsService.deleteOne(relation.collection, relation.field, mutationOptions);
+                            }
+                            catch (err) {
+                                logger_1.default.error(`Failed to delete collection "${collection}" due to relation "${relation.collection}.${relation.field}"`);
+                                throw err;
+                            }
+                        }
+                        // clean up deleted relations from existing schema
+                        schema.relations = schema.relations.filter((r) => r.related_collection !== collection && r.collection !== collection);
+                    }
+                    await deleteCollections(getNestedCollectionsToDelete(collection));
+                    try {
+                        await collectionsService.deleteOne(collection, mutationOptions);
+                    }
+                    catch (err) {
+                        logger_1.default.error(`Failed to delete collection "${collection}"`);
+                        throw err;
+                    }
+                }
+            }
+        };
+        // Finds all collections that need to be created
+        const filterCollectionsForCreation = ({ diff }) => {
+            var _a;
+            // Check new collections only
+            const isNewCollection = diff[0].kind === types_1.DiffKind.NEW;
+            if (!isNewCollection)
+                return false;
+            // Create now if no group
+            const groupName = (_a = diff[0].rhs.meta) === null || _a === void 0 ? void 0 : _a.group;
+            if (!groupName)
+                return true;
+            // Check if parent collection already exists in schema
+            const parentExists = currentSnapshot.collections.find((c) => c.collection === groupName) !== undefined;
+            // If this is a new collection and the parent collection doesn't exist in current schema ->
+            // Check if the parent collection will be created as part of applying this snapshot ->
+            // If yes -> this collection will be created recursively
+            // If not -> create now
+            // (ex.)
+            // TopLevelCollection - I exist in current schema
+            // 		NestedCollection - I exist in snapshotDiff as a new collection
+            //			TheCurrentCollectionInIteration - I exist in snapshotDiff as a new collection but will be created as part of NestedCollection
+            const parentWillBeCreatedInThisApply = snapshotDiff.collections.filter(({ collection, diff }) => diff[0].kind === types_1.DiffKind.NEW && collection === groupName).length > 0;
+            // Has group, but parent is not new, parent is also not being created in this snapshot apply
+            if (parentExists && !parentWillBeCreatedInThisApply)
+                return true;
+            return false;
+        };
+        // Create top level collections (no group, or highest level in existing group) first,
+        // then continue with nested collections recursively
+        await createCollections(snapshotDiff.collections.filter(filterCollectionsForCreation));
+        // delete top level collections (no group) first, then continue with nested collections recursively
+        await deleteCollections(snapshotDiff.collections.filter(({ diff }) => { var _a; return diff[0].kind === types_1.DiffKind.DELETE && ((_a = diff[0].lhs.meta) === null || _a === void 0 ? void 0 : _a.group) === null; }));
+        for (const { collection, diff } of snapshotDiff.collections) {
+            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === types_1.DiffKind.EDIT || (diff === null || diff === void 0 ? void 0 : diff[0].kind) === types_1.DiffKind.ARRAY) {
+                const currentCollection = currentSnapshot.collections.find((field) => {
+                    return field.collection === collection;
+                });
+                if (currentCollection) {
+                    try {
+                        const newValues = diff.reduce((acc, currentDiff) => {
+                            (0, deep_diff_1.applyChange)(acc, undefined, currentDiff);
+                            return acc;
+                        }, (0, lodash_1.cloneDeep)(currentCollection));
+                        await collectionsService.updateOne(collection, newValues, mutationOptions);
+                    }
+                    catch (err) {
+                        logger_1.default.error(`Failed to update collection "${collection}"`);
+                        throw err;
+                    }
+                }
+            }
+        }
+        const fieldsService = new services_1.FieldsService({
+            knex: trx,
+            schema: await (0, get_schema_1.getSchema)({ database: trx, bypassCache: true }),
+        });
+        for (const { collection, field, diff } of snapshotDiff.fields) {
+            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === types_1.DiffKind.NEW && !isNestedMetaUpdate(diff === null || diff === void 0 ? void 0 : diff[0])) {
+                try {
+                    await fieldsService.createField(collection, diff[0].rhs, undefined, mutationOptions);
+                }
+                catch (err) {
+                    logger_1.default.error(`Failed to create field "${collection}.${field}"`);
+                    throw err;
+                }
+            }
+            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === types_1.DiffKind.EDIT || (diff === null || diff === void 0 ? void 0 : diff[0].kind) === types_1.DiffKind.ARRAY || isNestedMetaUpdate(diff === null || diff === void 0 ? void 0 : diff[0])) {
+                const currentField = currentSnapshot.fields.find((snapshotField) => {
+                    return snapshotField.collection === collection && snapshotField.field === field;
+                });
+                if (currentField) {
+                    try {
+                        const newValues = diff.reduce((acc, currentDiff) => {
+                            (0, deep_diff_1.applyChange)(acc, undefined, currentDiff);
+                            return acc;
+                        }, (0, lodash_1.cloneDeep)(currentField));
+                        await fieldsService.updateField(collection, newValues, mutationOptions);
+                    }
+                    catch (err) {
+                        logger_1.default.error(`Failed to update field "${collection}.${field}"`);
+                        throw err;
+                    }
+                }
+            }
+            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === types_1.DiffKind.DELETE && !isNestedMetaUpdate(diff === null || diff === void 0 ? void 0 : diff[0])) {
+                try {
+                    await fieldsService.deleteField(collection, field, mutationOptions);
+                }
+                catch (err) {
+                    logger_1.default.error(`Failed to delete field "${collection}.${field}"`);
+                    throw err;
+                }
+                // Field deletion also cleans up the relationship. We should ignore any relationship
+                // changes attached to this now non-existing field
+                snapshotDiff.relations = snapshotDiff.relations.filter((relation) => (relation.collection === collection && relation.field === field) === false);
+            }
+        }
+        const relationsService = new services_1.RelationsService({
+            knex: trx,
+            schema: await (0, get_schema_1.getSchema)({ database: trx, bypassCache: true }),
+        });
+        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) === types_1.DiffKind.NEW) {
+                try {
+                    await relationsService.createOne(diff[0].rhs, mutationOptions);
+                }
+                catch (err) {
+                    logger_1.default.error(`Failed to create relation "${collection}.${field}"`);
+                    throw err;
+                }
+            }
+            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === types_1.DiffKind.EDIT || (diff === null || diff === void 0 ? void 0 : diff[0].kind) === types_1.DiffKind.ARRAY) {
+                const currentRelation = currentSnapshot.relations.find((relation) => {
+                    return relation.collection === collection && relation.field === field;
+                });
+                if (currentRelation) {
+                    try {
+                        const newValues = diff.reduce((acc, currentDiff) => {
+                            (0, deep_diff_1.applyChange)(acc, undefined, currentDiff);
+                            return acc;
+                        }, (0, lodash_1.cloneDeep)(currentRelation));
+                        await relationsService.updateOne(collection, field, newValues, mutationOptions);
+                    }
+                    catch (err) {
+                        logger_1.default.error(`Failed to update relation "${collection}.${field}"`);
+                        throw err;
+                    }
+                }
+            }
+            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === types_1.DiffKind.DELETE) {
+                try {
+                    await relationsService.deleteOne(collection, field, mutationOptions);
+                }
+                catch (err) {
+                    logger_1.default.error(`Failed to delete relation "${collection}.${field}"`);
+                    throw err;
+                }
+            }
+        }
+    });
+    await (0, cache_1.clearSystemCache)();
+    if (nestedActionEvents.length > 0) {
+        const updatedSchema = await (0, get_schema_1.getSchema)({ database, bypassCache: true });
+        for (const nestedActionEvent of nestedActionEvents) {
+            nestedActionEvent.context.schema = updatedSchema;
+            emitter_1.default.emitAction(nestedActionEvent.event, nestedActionEvent.meta, nestedActionEvent.context);
+        }
+    }
+}
+exports.applyDiff = applyDiff;
+function isNestedMetaUpdate(diff) {
+    if (!diff)
+        return false;
+    if (diff.kind !== types_1.DiffKind.NEW && diff.kind !== types_1.DiffKind.DELETE)
+        return false;
+    if (!diff.path || diff.path.length < 2 || diff.path[0] !== 'meta')
+        return false;
+    return true;
+}
+exports.isNestedMetaUpdate = isNestedMetaUpdate;

package/dist/utils/apply-diff.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/apply-query.js

@@ -23,15 +23,15 @@ function applyQuery(knex, collection, dbQuery, query, schema, options) {
     var _a;
     const aliasMap = (_a = options === null || options === void 0 ? void 0 : options.aliasMap) !== null && _a !== void 0 ? _a : Object.create(null);
     let hasMultiRelationalFilter = false;
-    if (query.sort && !(options === null || options === void 0 ? void 0 : options.isInnerQuery) && !(options === null || options === void 0 ? void 0 : options.hasMultiRelationalSort)) {
-        applySort(knex, schema, dbQuery, query.sort, collection, aliasMap);
-    }
     applyLimit(knex, dbQuery, query.limit);
     if (query.offset) {
         applyOffset(knex, dbQuery, query.offset);
     }
     if (query.page && query.limit && query.limit !== -1) {
-        dbQuery.offset(query.limit * (query.page - 1));
+        applyOffset(knex, dbQuery, query.limit * (query.page - 1));
+    }
+    if (query.sort && !(options === null || options === void 0 ? void 0 : options.isInnerQuery) && !(options === null || options === void 0 ? void 0 : options.hasMultiRelationalSort)) {
+        applySort(knex, schema, dbQuery, query.sort, collection, aliasMap);
     }
     if (query.search) {
         applySearch(schema, dbQuery, query.search, collection);
@@ -170,6 +170,8 @@ function applySort(knex, schema, rootQuery, rootSort, collection, aliasMap, retu
     });
     if (returnRecords)
         return { sortRecords, hasMultiRelationalSort };
+    // Clears the order if any, eg: from MSSQL offset
+    rootQuery.clear('order');
     rootQuery.orderBy(sortRecords);
 }
 exports.applySort = applySort;
@@ -333,12 +335,12 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, aliasMap)
             }
             if (operator === '_empty' || (operator === '_nempty' && compareValue === false)) {
                 dbQuery[logical].andWhere((query) => {
-                    query.where(key, '=', '');
+                    query.whereNull(key).orWhere(key, '=', '');
                 });
             }
             if (operator === '_nempty' || (operator === '_empty' && compareValue === false)) {
                 dbQuery[logical].andWhere((query) => {
-                    query.where(key, '!=', '');
+                    query.whereNotNull(key).orWhere(key, '!=', '');
                 });
             }
             // The following fields however, require a value to be run. If no value is passed, we

package/dist/utils/apply-snapshot.d.ts

@@ -1,11 +1,9 @@
 import { SchemaOverview } from '@directus/shared/types';
-import { Diff } from 'deep-diff';
 import { Knex } from 'knex';
-import { Snapshot, SnapshotDiff, SnapshotField } from '../types';
+import { Snapshot, SnapshotDiff } from '../types';
 export declare function applySnapshot(snapshot: Snapshot, options?: {
     database?: Knex;
     schema?: SchemaOverview;
     current?: Snapshot;
     diff?: SnapshotDiff;
 }): Promise<void>;
-export declare function isNestedMetaUpdate(diff: Diff<SnapshotField | undefined>): boolean;

package/dist/utils/apply-snapshot.js

@@ -3,16 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNestedMetaUpdate = exports.applySnapshot = void 0;
-const lodash_1 = require("lodash");
+exports.applySnapshot = void 0;
+const cache_1 = require("../cache");
 const database_1 = __importDefault(require("../database"));
-const logger_1 = __importDefault(require("../logger"));
-const services_1 = require("../services");
+const apply_diff_1 = require("./apply-diff");
 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");
-const emitter_1 = __importDefault(require("../emitter"));
 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)();
@@ -20,234 +17,7 @@ async function applySnapshot(snapshot, options) {
     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);
-    const nestedActionEvents = [];
-    const mutationOptions = {
-        autoPurgeSystemCache: false,
-        bypassEmitAction: (params) => nestedActionEvents.push(params),
-    };
-    await database.transaction(async (trx) => {
-        const collectionsService = new services_1.CollectionsService({ knex: trx, schema });
-        const getNestedCollectionsToCreate = (currentLevelCollection) => snapshotDiff.collections.filter(({ diff }) => { var _a, _b; return ((_b = (_a = diff[0].rhs) === null || _a === void 0 ? void 0 : _a.meta) === null || _b === void 0 ? void 0 : _b.group) === currentLevelCollection; });
-        const getNestedCollectionsToDelete = (currentLevelCollection) => snapshotDiff.collections.filter(({ diff }) => { var _a, _b; return ((_b = (_a = diff[0].lhs) === null || _a === void 0 ? void 0 : _a.meta) === null || _b === void 0 ? void 0 : _b.group) === currentLevelCollection; });
-        const createCollections = async (collections) => {
-            for (const { collection, diff } of collections) {
-                if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'N' && diff[0].rhs) {
-                    // We'll nest the to-be-created fields in the same collection creation, to prevent
-                    // creating a collection without a primary key
-                    const fields = snapshotDiff.fields
-                        .filter((fieldDiff) => fieldDiff.collection === collection)
-                        .map((fieldDiff) => fieldDiff.diff[0].rhs)
-                        .map((fieldDiff) => {
-                        var _a, _b, _c, _d, _e;
-                        // Casts field type to UUID when applying non-PostgreSQL schema onto PostgreSQL database.
-                        // This is needed because they snapshots UUID fields as char with length 36.
-                        if (((_a = fieldDiff.schema) === null || _a === void 0 ? void 0 : _a.data_type) === 'char' &&
-                            ((_b = fieldDiff.schema) === null || _b === void 0 ? void 0 : _b.max_length) === 36 &&
-                            (((_c = fieldDiff.schema) === null || _c === void 0 ? void 0 : _c.is_primary_key) ||
-                                (((_d = fieldDiff.schema) === null || _d === void 0 ? void 0 : _d.foreign_key_table) && ((_e = fieldDiff.schema) === null || _e === void 0 ? void 0 : _e.foreign_key_column)))) {
-                            return (0, lodash_1.merge)(fieldDiff, { type: 'uuid', schema: { data_type: 'uuid', max_length: null } });
-                        }
-                        else {
-                            return fieldDiff;
-                        }
-                    });
-                    try {
-                        await collectionsService.createOne({
-                            ...diff[0].rhs,
-                            fields,
-                        }, mutationOptions);
-                    }
-                    catch (err) {
-                        logger_1.default.error(`Failed to create collection "${collection}"`);
-                        throw err;
-                    }
-                    // Now that the fields are in for this collection, we can strip them from the field edits
-                    snapshotDiff.fields = snapshotDiff.fields.filter((fieldDiff) => fieldDiff.collection !== collection);
-                    await createCollections(getNestedCollectionsToCreate(collection));
-                }
-            }
-        };
-        const deleteCollections = async (collections) => {
-            for (const { collection, diff } of collections) {
-                if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'D') {
-                    const relations = schema.relations.filter((r) => r.related_collection === collection || r.collection === collection);
-                    if (relations.length > 0) {
-                        const relationsService = new services_1.RelationsService({ knex: trx, schema });
-                        for (const relation of relations) {
-                            try {
-                                await relationsService.deleteOne(relation.collection, relation.field, mutationOptions);
-                            }
-                            catch (err) {
-                                logger_1.default.error(`Failed to delete collection "${collection}" due to relation "${relation.collection}.${relation.field}"`);
-                                throw err;
-                            }
-                        }
-                        // clean up deleted relations from existing schema
-                        schema.relations = schema.relations.filter((r) => r.related_collection !== collection && r.collection !== collection);
-                    }
-                    await deleteCollections(getNestedCollectionsToDelete(collection));
-                    try {
-                        await collectionsService.deleteOne(collection, mutationOptions);
-                    }
-                    catch (err) {
-                        logger_1.default.error(`Failed to delete collection "${collection}"`);
-                        throw err;
-                    }
-                }
-            }
-        };
-        // Finds all collections that need to be created
-        const filterCollectionsForCreation = ({ diff }) => {
-            var _a;
-            // Check new collections only
-            const isNewCollection = diff[0].kind === 'N';
-            if (!isNewCollection)
-                return false;
-            // Create now if no group
-            const groupName = (_a = diff[0].rhs.meta) === null || _a === void 0 ? void 0 : _a.group;
-            if (!groupName)
-                return true;
-            // Check if parent collection already exists in schema
-            const parentExists = current.collections.find((c) => c.collection === groupName) !== undefined;
-            // If this is a new collection and the parent collection doesn't exist in current schema ->
-            // Check if the parent collection will be created as part of applying this snapshot ->
-            // If yes -> this collection will be created recursively
-            // If not -> create now
-            // (ex.)
-            // TopLevelCollection - I exist in current schema
-            // 		NestedCollection - I exist in snapshotDiff as a new collection
-            //			TheCurrentCollectionInIteration - I exist in snapshotDiff as a new collection but will be created as part of NestedCollection
-            const parentWillBeCreatedInThisApply = snapshotDiff.collections.filter(({ collection, diff }) => diff[0].kind === 'N' && collection === groupName)
-                .length > 0;
-            // Has group, but parent is not new, parent is also not being created in this snapshot apply
-            if (parentExists && !parentWillBeCreatedInThisApply)
-                return true;
-            return false;
-        };
-        // Create top level collections (no group, or highest level in existing group) first,
-        // then continue with nested collections recursively
-        await createCollections(snapshotDiff.collections.filter(filterCollectionsForCreation));
-        // delete top level collections (no group) first, then continue with nested collections recursively
-        await deleteCollections(snapshotDiff.collections.filter(({ diff }) => { var _a; return diff[0].kind === 'D' && ((_a = diff[0].lhs.meta) === null || _a === void 0 ? void 0 : _a.group) === null; }));
-        for (const { collection, diff } of snapshotDiff.collections) {
-            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) {
-                    try {
-                        await collectionsService.updateOne(collection, newValues, mutationOptions);
-                    }
-                    catch (err) {
-                        logger_1.default.error(`Failed to update collection "${collection}"`);
-                        throw err;
-                    }
-                }
-            }
-        }
-        const fieldsService = new services_1.FieldsService({
-            knex: trx,
-            schema: await (0, get_schema_1.getSchema)({ database: trx, bypassCache: true }),
-        });
-        for (const { collection, field, diff } of snapshotDiff.fields) {
-            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'N' && !isNestedMetaUpdate(diff === null || diff === void 0 ? void 0 : diff[0])) {
-                try {
-                    await fieldsService.createField(collection, diff[0].rhs, undefined, mutationOptions);
-                }
-                catch (err) {
-                    logger_1.default.error(`Failed to create field "${collection}.${field}"`);
-                    throw err;
-                }
-            }
-            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'E' || (diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'A' || isNestedMetaUpdate(diff === null || diff === void 0 ? void 0 : diff[0])) {
-                const newValues = snapshot.fields.find((snapshotField) => {
-                    return snapshotField.collection === collection && snapshotField.field === field;
-                });
-                if (newValues) {
-                    try {
-                        await fieldsService.updateField(collection, {
-                            ...newValues,
-                        }, mutationOptions);
-                    }
-                    catch (err) {
-                        logger_1.default.error(`Failed to update field "${collection}.${field}"`);
-                        throw err;
-                    }
-                }
-            }
-            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'D' && !isNestedMetaUpdate(diff === null || diff === void 0 ? void 0 : diff[0])) {
-                try {
-                    await fieldsService.deleteField(collection, field, mutationOptions);
-                }
-                catch (err) {
-                    logger_1.default.error(`Failed to delete field "${collection}.${field}"`);
-                    throw err;
-                }
-                // Field deletion also cleans up the relationship. We should ignore any relationship
-                // changes attached to this now non-existing field
-                snapshotDiff.relations = snapshotDiff.relations.filter((relation) => (relation.collection === collection && relation.field === field) === false);
-            }
-        }
-        const relationsService = new services_1.RelationsService({
-            knex: trx,
-            schema: await (0, get_schema_1.getSchema)({ database: trx, bypassCache: true }),
-        });
-        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') {
-                try {
-                    await relationsService.createOne(diff[0].rhs, mutationOptions);
-                }
-                catch (err) {
-                    logger_1.default.error(`Failed to create relation "${collection}.${field}"`);
-                    throw err;
-                }
-            }
-            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) {
-                    try {
-                        await relationsService.updateOne(collection, field, newValues, mutationOptions);
-                    }
-                    catch (err) {
-                        logger_1.default.error(`Failed to update relation "${collection}.${field}"`);
-                        throw err;
-                    }
-                }
-            }
-            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'D') {
-                try {
-                    await relationsService.deleteOne(collection, field, mutationOptions);
-                }
-                catch (err) {
-                    logger_1.default.error(`Failed to delete relation "${collection}.${field}"`);
-                    throw err;
-                }
-            }
-        }
-    });
+    await (0, apply_diff_1.applyDiff)(current, snapshotDiff, { database, schema });
     await (systemCache === null || systemCache === void 0 ? void 0 : systemCache.clear());
-    if (nestedActionEvents.length > 0) {
-        const updatedSchema = await (0, get_schema_1.getSchema)({ database, bypassCache: true });
-        for (const nestedActionEvent of nestedActionEvents) {
-            nestedActionEvent.context.schema = updatedSchema;
-            emitter_1.default.emitAction(nestedActionEvent.event, nestedActionEvent.meta, nestedActionEvent.context);
-        }
-    }
 }
 exports.applySnapshot = applySnapshot;
-function isNestedMetaUpdate(diff) {
-    if (!diff)
-        return false;
-    if (diff.kind !== 'N' && diff.kind !== 'D')
-        return false;
-    if (!diff.path || diff.path.length < 2 || diff.path[0] !== 'meta')
-        return false;
-    return true;
-}
-exports.isNestedMetaUpdate = isNestedMetaUpdate;

package/dist/utils/get-cache-headers.d.ts

@@ -4,5 +4,7 @@ import { Request } from 'express';
  *
  * @param req Express request object
  * @param ttl TTL of the cache in ms
+ * @param globalCacheSettings Whether requests are affected by the global cache settings (i.e. for dynamic API requests)
+ * @param personalized Whether requests depend on the authentication status of users
  */
-export declare function getCacheControlHeader(req: Request, ttl: number | null): string;
+export declare function getCacheControlHeader(req: Request, ttl: number | undefined, globalCacheSettings: boolean, personalized: boolean): string;

package/dist/utils/get-cache-headers.js

@@ -10,34 +10,35 @@ const env_1 = __importDefault(require("../env"));
  *
  * @param req Express request object
  * @param ttl TTL of the cache in ms
+ * @param globalCacheSettings Whether requests are affected by the global cache settings (i.e. for dynamic API requests)
+ * @param personalized Whether requests depend on the authentication status of users
  */
-function getCacheControlHeader(req, ttl) {
+function getCacheControlHeader(req, ttl, globalCacheSettings, personalized) {
     var _a, _b, _c;
-    // When the resource / current request isn't cached
-    if (ttl === null)
-        return 'no-cache';
-    // When the API cache can invalidate at any moment
-    if (env_1.default.CACHE_AUTO_PURGE === true)
-        return 'no-cache';
     const noCacheRequested = ((_a = req.headers['cache-control']) === null || _a === void 0 ? void 0 : _a.includes('no-store')) || ((_b = req.headers['Cache-Control']) === null || _b === void 0 ? void 0 : _b.includes('no-store'));
     // When the user explicitly asked to skip the cache
     if (noCacheRequested)
         return 'no-store';
+    // When the resource / current request shouldn't be cached
+    if (ttl === undefined || ttl < 0)
+        return 'no-cache';
+    // When the API cache can invalidate at any moment
+    if (globalCacheSettings && env_1.default.CACHE_AUTO_PURGE === true)
+        return 'no-cache';
+    const headerValues = [];
+    // When caching depends on the authentication status of the users
+    if (personalized) {
+        // Allow response to be stored in shared cache (public) or local cache only (private)
+        const access = !!((_c = req.accountability) === null || _c === void 0 ? void 0 : _c.role) === false ? 'public' : 'private';
+        headerValues.push(access);
+    }
     // Cache control header uses seconds for everything
     const ttlSeconds = Math.round(ttl / 1000);
-    const access = !!((_c = req.accountability) === null || _c === void 0 ? void 0 : _c.role) === false ? 'public' : 'private';
-    let headerValue = `${access}, max-age=${ttlSeconds}`;
+    headerValues.push(`max-age=${ttlSeconds}`);
     // When the s-maxage flag should be included
-    if (env_1.default.CACHE_CONTROL_S_MAXAGE !== false) {
-        // Default to regular max-age flag when true
-        if (env_1.default.CACHE_CONTROL_S_MAXAGE === true) {
-            headerValue += `, s-maxage=${ttlSeconds}`;
-        }
-        else {
-            // Set to custom value
-            headerValue += `, s-maxage=${env_1.default.CACHE_CONTROL_S_MAXAGE}`;
-        }
+    if (globalCacheSettings && Number.isInteger(env_1.default.CACHE_CONTROL_S_MAXAGE) && env_1.default.CACHE_CONTROL_S_MAXAGE >= 0) {
+        headerValues.push(`s-maxage=${env_1.default.CACHE_CONTROL_S_MAXAGE}`);
     }
-    return headerValue;
+    return headerValues.join(', ');
 }
 exports.getCacheControlHeader = getCacheControlHeader;

package/dist/utils/get-cache-headers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/get-milliseconds.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Safely parse human readable time format into milliseconds
+ */
+export declare function getMilliseconds<T>(value: unknown, fallback?: T): number | T;