directus 9.22.4 → 9.23.3

package/dist/utils/apply-snapshot.js

@@ -3,251 +3,20 @@ 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)();
-    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 database = options?.database ?? (0, database_1.default)();
+    const schema = options?.schema ?? (await (0, get_schema_1.getSchema)({ database, bypassCache: true }));
     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 (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);
-        }
-    }
+    const current = options?.current ?? (await (0, get_snapshot_1.getSnapshot)({ database, schema }));
+    const snapshotDiff = options?.diff ?? (0, get_snapshot_diff_1.getSnapshotDiff)(current, snapshot);
+    await (0, apply_diff_1.applyDiff)(current, snapshotDiff, { database, schema });
+    await systemCache?.clear();
 }
 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/construct-flow-tree.d.ts

@@ -1,2 +1,2 @@
-import { Flow, FlowRaw } from '@directus/shared/types';
+import type { Flow, FlowRaw } from '@directus/shared/types';
 export declare function constructFlowTree(flow: FlowRaw): Flow;

package/dist/utils/construct-flow-tree.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.constructFlowTree = void 0;
 const lodash_1 = require("lodash");
 function constructFlowTree(flow) {
-    var _a;
-    const rootOperation = (_a = flow.operations.find((operation) => operation.id === flow.operation)) !== null && _a !== void 0 ? _a : null;
+    const rootOperation = flow.operations.find((operation) => operation.id === flow.operation) ?? null;
     const operationTree = constructOperationTree(rootOperation, flow.operations);
     const flowTree = {
         ...(0, lodash_1.omit)(flow, 'operations'),
         operation: operationTree,
+        options: flow.options ?? {},
     };
     return flowTree;
 }

package/dist/utils/filter-items.d.ts

@@ -1,2 +1,2 @@
-import { Query } from '@directus/shared/types';
+import type { Query } from '@directus/shared/types';
 export declare function filterItems(items: Record<string, any>[], filter: Query['filter']): Record<string, any>[];

package/dist/utils/get-accountability-for-role.d.ts

@@ -1,5 +1,5 @@
-import { Accountability, SchemaOverview } from '@directus/shared/types';
-import { Knex } from 'knex';
+import type { Accountability, SchemaOverview } from '@directus/shared/types';
+import type { Knex } from 'knex';
 export declare function getAccountabilityForRole(role: null | string, context: {
     accountability: null | Accountability;
     schema: SchemaOverview;

package/dist/utils/get-accountability-for-role.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAccountabilityForRole = void 0;
-const get_permissions_1 = require("./get-permissions");
 const exceptions_1 = require("../exceptions");
+const get_permissions_1 = require("./get-permissions");
 async function getAccountabilityForRole(role, context) {
     let generatedAccountability = context.accountability;
     if (role === null) {

package/dist/utils/get-ast-from-query.d.ts

@@ -1,9 +1,9 @@
 /**
  * Generate an AST based on a given collection and query
  */
-import { Knex } from 'knex';
-import { AST } from '../types';
-import { Query, PermissionsAction, Accountability, SchemaOverview } from '@directus/shared/types';
+import type { Accountability, PermissionsAction, Query, SchemaOverview } from '@directus/shared/types';
+import type { Knex } from 'knex';
+import type { AST } from '../types';
 type GetASTOptions = {
     accountability?: Accountability | null;
     action?: PermissionsAction;

package/dist/utils/get-ast-from-query.js

@@ -3,18 +3,17 @@
  * Generate an AST based on a given collection and query
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("@directus/shared/constants");
 const lodash_1 = require("lodash");
 const get_relation_type_1 = require("../utils/get-relation-type");
-const constants_1 = require("@directus/shared/constants");
 async function getASTFromQuery(collection, query, schema, options) {
-    var _a, _b, _c, _d, _e;
     query = (0, lodash_1.cloneDeep)(query);
-    const accountability = options === null || options === void 0 ? void 0 : options.accountability;
-    const action = (options === null || options === void 0 ? void 0 : options.action) || 'read';
+    const accountability = options?.accountability;
+    const action = options?.action || 'read';
     const permissions = accountability && accountability.admin !== true
-        ? (_b = (_a = accountability === null || accountability === void 0 ? void 0 : accountability.permissions) === null || _a === void 0 ? void 0 : _a.filter((permission) => {
+        ? accountability?.permissions?.filter((permission) => {
             return permission.action === action;
-        })) !== null && _b !== void 0 ? _b : []
+        }) ?? []
         : null;
     const ast = {
         type: 'root',
@@ -49,24 +48,23 @@ async function getASTFromQuery(collection, query, schema, options) {
         // We'll default to the primary key for the standard sort output
         let sortField = schema.collections[collection].primary;
         // If a custom manual sort field is configured, use that
-        if ((_c = schema.collections[collection]) === null || _c === void 0 ? void 0 : _c.sortField) {
+        if (schema.collections[collection]?.sortField) {
             sortField = schema.collections[collection].sortField;
         }
         // When group by is used, default to the first column provided in the group by clause
-        if ((_d = query.group) === null || _d === void 0 ? void 0 : _d[0]) {
+        if (query.group?.[0]) {
             sortField = query.group[0];
         }
         query.sort = [sortField];
     }
     // When no group by is supplied, but an aggregate function is used, only a single row will be
     // returned. In those cases, we'll ignore the sort field altogether
-    if (query.aggregate && Object.keys(query.aggregate).length && !((_e = query.group) === null || _e === void 0 ? void 0 : _e[0])) {
+    if (query.aggregate && Object.keys(query.aggregate).length && !query.group?.[0]) {
         delete query.sort;
     }
     ast.children = await parseFields(collection, fields, deep);
     return ast;
     async function parseFields(parentCollection, fields, deep) {
-        var _a, _b;
         if (!fields)
             return [];
         fields = await convertWildcards(parentCollection, fields);
@@ -85,7 +83,7 @@ async function getASTFromQuery(collection, query, schema, options) {
             const isRelational = name.includes('.') ||
                 // We'll always treat top level o2m fields as a related item. This is an alias field, otherwise it won't return
                 // anything
-                !!schema.relations.find((relation) => { var _a; return relation.related_collection === parentCollection && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field) === name; });
+                !!schema.relations.find((relation) => relation.related_collection === parentCollection && relation.meta?.one_field === name);
             if (isRelational) {
                 // field is relational
                 const parts = fieldKey.split('.');
@@ -123,7 +121,7 @@ async function getASTFromQuery(collection, query, schema, options) {
                     const columnName = fieldKey.match(constants_1.REGEX_BETWEEN_PARENS)[1];
                     const foundField = schema.collections[parentCollection].fields[columnName];
                     if (foundField && foundField.type === 'alias') {
-                        const foundRelation = schema.relations.find((relation) => { var _a; return relation.related_collection === parentCollection && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field) === columnName; });
+                        const foundRelation = schema.relations.find((relation) => relation.related_collection === parentCollection && relation.meta?.one_field === columnName);
                         if (foundRelation) {
                             children.push({
                                 type: 'functionField',
@@ -173,8 +171,8 @@ async function getASTFromQuery(collection, query, schema, options) {
                     relation: relation,
                 };
                 for (const relatedCollection of allowedCollections) {
-                    child.children[relatedCollection] = await parseFields(relatedCollection, Array.isArray(nestedFields) ? nestedFields : nestedFields[relatedCollection] || ['*'], deep === null || deep === void 0 ? void 0 : deep[`${fieldKey}:${relatedCollection}`]);
-                    child.query[relatedCollection] = getDeepQuery((deep === null || deep === void 0 ? void 0 : deep[`${fieldKey}:${relatedCollection}`]) || {});
+                    child.children[relatedCollection] = await parseFields(relatedCollection, Array.isArray(nestedFields) ? nestedFields : nestedFields[relatedCollection] || [], deep?.[`${fieldKey}:${relatedCollection}`]);
+                    child.query[relatedCollection] = getDeepQuery(deep?.[`${fieldKey}:${relatedCollection}`] || {});
                     child.relatedKey[relatedCollection] = schema.collections[relatedCollection].primary;
                 }
             }
@@ -183,7 +181,7 @@ async function getASTFromQuery(collection, query, schema, options) {
                     continue;
                 }
                 // update query alias for children parseFields
-                const deepAlias = (_a = getDeepQuery((deep === null || deep === void 0 ? void 0 : deep[fieldKey]) || {})) === null || _a === void 0 ? void 0 : _a.alias;
+                const deepAlias = getDeepQuery(deep?.[fieldKey] || {})?.alias;
                 if (!(0, lodash_1.isEmpty)(deepAlias))
                     query.alias = deepAlias;
                 child = {
@@ -193,11 +191,11 @@ async function getASTFromQuery(collection, query, schema, options) {
                     parentKey: schema.collections[parentCollection].primary,
                     relatedKey: schema.collections[relatedCollection].primary,
                     relation: relation,
-                    query: getDeepQuery((deep === null || deep === void 0 ? void 0 : deep[fieldKey]) || {}),
-                    children: await parseFields(relatedCollection, nestedFields, (deep === null || deep === void 0 ? void 0 : deep[fieldKey]) || {}),
+                    query: getDeepQuery(deep?.[fieldKey] || {}),
+                    children: await parseFields(relatedCollection, nestedFields, deep?.[fieldKey] || {}),
                 };
                 if (relationType === 'o2m' && !child.query.sort) {
-                    child.query.sort = [((_b = relation.meta) === null || _b === void 0 ? void 0 : _b.sort_field) || schema.collections[relation.collection].primary];
+                    child.query.sort = [relation.meta?.sort_field || schema.collections[relation.collection].primary];
                 }
             }
             if (child) {
@@ -214,12 +212,11 @@ async function getASTFromQuery(collection, query, schema, options) {
         });
     }
     async function convertWildcards(parentCollection, fields) {
-        var _a, _b, _c;
         fields = (0, lodash_1.cloneDeep)(fields);
         const fieldsInCollection = Object.entries(schema.collections[parentCollection].fields).map(([name]) => name);
         let allowedFields = fieldsInCollection;
         if (permissions) {
-            const permittedFields = (_a = permissions.find((permission) => parentCollection === permission.collection)) === null || _a === void 0 ? void 0 : _a.fields;
+            const permittedFields = permissions.find((permission) => parentCollection === permission.collection)?.fields;
             if (permittedFields !== undefined)
                 allowedFields = permittedFields;
         }
@@ -233,7 +230,7 @@ async function getASTFromQuery(collection, query, schema, options) {
             if (fieldKey.includes('*') === false)
                 continue;
             if (fieldKey === '*') {
-                const aliases = Object.keys((_b = query.alias) !== null && _b !== void 0 ? _b : {});
+                const aliases = Object.keys(query.alias ?? {});
                 // Set to all fields in collection
                 if (allowedFields.includes('*')) {
                     fields.splice(index, 1, ...fieldsInCollection, ...aliases);
@@ -254,13 +251,12 @@ async function getASTFromQuery(collection, query, schema, options) {
                     ? schema.relations
                         .filter((relation) => relation.collection === parentCollection || relation.related_collection === parentCollection)
                         .map((relation) => {
-                        var _a;
                         const isMany = relation.collection === parentCollection;
-                        return isMany ? relation.field : (_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field;
+                        return isMany ? relation.field : relation.meta?.one_field;
                     })
                     : allowedFields.filter((fieldKey) => !!getRelation(parentCollection, fieldKey));
                 const nonRelationalFields = allowedFields.filter((fieldKey) => relationalFields.includes(fieldKey) === false);
-                const aliasFields = Object.keys((_c = query.alias) !== null && _c !== void 0 ? _c : {}).map((fieldKey) => {
+                const aliasFields = Object.keys(query.alias ?? {}).map((fieldKey) => {
                     const name = query.alias[fieldKey];
                     if (relationalFields.includes(name)) {
                         return `${fieldKey}.${parts.slice(1).join('.')}`;
@@ -280,21 +276,19 @@ async function getASTFromQuery(collection, query, schema, options) {
     }
     function getRelation(collection, field) {
         const relation = schema.relations.find((relation) => {
-            var _a;
             return ((relation.collection === collection && relation.field === field) ||
-                (relation.related_collection === collection && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field) === field));
+                (relation.related_collection === collection && relation.meta?.one_field === field));
         });
         return relation;
     }
     function getRelatedCollection(collection, field) {
-        var _a;
         const relation = getRelation(collection, field);
         if (!relation)
             return null;
         if (relation.collection === collection && relation.field === field) {
             return relation.related_collection || null;
         }
-        if (relation.related_collection === collection && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field) === field) {
+        if (relation.related_collection === collection && relation.meta?.one_field === field) {
             return relation.collection || null;
         }
         return null;

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

@@ -1,8 +1,10 @@
-import { Request } from 'express';
+import type { Request } from 'express';
 /**
  * Returns the Cache-Control header for the current request
  *
  * @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

@@ -5,39 +5,39 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCacheControlHeader = void 0;
 const env_1 = __importDefault(require("../env"));
+const should_skip_cache_1 = require("./should-skip-cache");
 /**
  * Returns the Cache-Control header for the current request
  *
  * @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) {
-    var _a, _b, _c;
-    // When the resource / current request isn't cached
-    if (ttl === null)
+function getCacheControlHeader(req, ttl, globalCacheSettings, personalized) {
+    // When the user explicitly asked to skip the cache
+    if ((0, should_skip_cache_1.shouldSkipCache)(req))
+        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 (env_1.default.CACHE_AUTO_PURGE === true)
+    if (globalCacheSettings && 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';
+    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 = !!req.accountability?.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-cache-key.d.ts

@@ -1,2 +1,2 @@
-import { Request } from 'express';
+import type { Request } from 'express';
 export declare function getCacheKey(req: Request): string;

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

@@ -8,11 +8,10 @@ const object_hash_1 = __importDefault(require("object-hash"));
 const url_1 = __importDefault(require("url"));
 const get_graphql_query_and_variables_1 = require("./get-graphql-query-and-variables");
 function getCacheKey(req) {
-    var _a;
     const path = url_1.default.parse(req.originalUrl).pathname;
-    const isGraphQl = path === null || path === void 0 ? void 0 : path.startsWith('/graphql');
+    const isGraphQl = path?.startsWith('/graphql');
     const info = {
-        user: ((_a = req.accountability) === null || _a === void 0 ? void 0 : _a.user) || null,
+        user: req.accountability?.user || null,
         path,
         query: isGraphQl ? (0, get_graphql_query_and_variables_1.getGraphqlQueryAndVariables)(req) : req.sanitizedQuery,
     };

package/dist/utils/get-collection-from-alias.d.ts

@@ -1,4 +1,4 @@
-import { AliasMap } from './get-column-path';
+import type { AliasMap } from './get-column-path';
 /**
  * Extract the collection of an alias within an aliasMap
  * For example: 'ljnsv.name' -> 'authors'

package/dist/utils/get-column-path.d.ts

@@ -1,4 +1,4 @@
-import { Relation, SchemaOverview } from '@directus/shared/types';
+import type { Relation, SchemaOverview } from '@directus/shared/types';
 export type AliasMap = {
     [key: string]: {
         alias: string;
@@ -15,7 +15,7 @@ export type ColPathProps = {
 export type ColPathResult = {
     columnPath: string;
     targetCollection: string;
-    addNestedPkField?: string;
+    addNestedPkField: string | undefined;
 };
 /**
  * Converts a Directus field list path to the correct SQL names based on the constructed alias map.