directus 9.23.1 → 9.23.4

package/dist/utils/apply-query.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyAggregate = exports.applySearch = exports.applyFilter = exports.applyOffset = exports.applyLimit = exports.applySort = exports.generateAlias = void 0;
+const utils_1 = require("@directus/shared/utils");
 const lodash_1 = require("lodash");
 const uuid_validate_1 = __importDefault(require("uuid-validate"));
 const helpers_1 = require("../database/helpers");
@@ -11,7 +12,6 @@ const invalid_query_1 = require("../exceptions/invalid-query");
 const get_column_1 = require("./get-column");
 const get_column_path_1 = require("./get-column-path");
 const get_relation_info_1 = require("./get-relation-info");
-const utils_1 = require("@directus/shared/utils");
 const strip_function_1 = require("./strip-function");
 // @ts-ignore
 const non_secure_1 = require("nanoid/non-secure");
@@ -20,8 +20,7 @@ exports.generateAlias = (0, non_secure_1.customAlphabet)('abcdefghijklmnopqrstuv
  * Apply the Query to a given Knex query builder instance
  */
 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);
+    const aliasMap = options?.aliasMap ?? Object.create(null);
     let hasMultiRelationalFilter = false;
     applyLimit(knex, dbQuery, query.limit);
     if (query.offset) {
@@ -30,7 +29,7 @@ function applyQuery(knex, collection, dbQuery, query, schema, options) {
     if (query.page && query.limit && query.limit !== -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)) {
+    if (query.sort && !options?.isInnerQuery && !options?.hasMultiRelationalSort) {
         applySort(knex, schema, dbQuery, query.sort, collection, aliasMap);
     }
     if (query.search) {
@@ -54,7 +53,6 @@ function addJoin({ path, collection, aliasMap, rootQuery, schema, relations, kne
     followRelation(path);
     return hasMultiRelational;
     function followRelation(pathParts, parentCollection = collection, parentFields) {
-        var _a, _b, _c;
         /**
          * For A2M fields, the path can contain an optional collection scope <field>:<scope>
          */
@@ -64,12 +62,12 @@ function addJoin({ path, collection, aliasMap, rootQuery, schema, relations, kne
             return;
         }
         const existingAlias = parentFields
-            ? (_a = aliasMap[`${parentFields}.${pathParts[0]}`]) === null || _a === void 0 ? void 0 : _a.alias
-            : (_b = aliasMap[pathParts[0]]) === null || _b === void 0 ? void 0 : _b.alias;
+            ? aliasMap[`${parentFields}.${pathParts[0]}`]?.alias
+            : aliasMap[pathParts[0]]?.alias;
         if (!existingAlias) {
             const alias = (0, exports.generateAlias)();
             const aliasKey = parentFields ? `${parentFields}.${pathParts[0]}` : pathParts[0];
-            const aliasedParentCollection = ((_c = aliasMap[parentFields !== null && parentFields !== void 0 ? parentFields : '']) === null || _c === void 0 ? void 0 : _c.alias) || parentCollection;
+            const aliasedParentCollection = aliasMap[parentFields ?? '']?.alias || parentCollection;
             aliasMap[aliasKey] = { alias, collection: '' };
             if (relationType === 'm2o') {
                 rootQuery.leftJoin({ [alias]: relation.related_collection }, `${aliasedParentCollection}.${relation.field}`, `${alias}.${schema.collections[relation.related_collection].primary}`);
@@ -136,7 +134,7 @@ function applySort(knex, schema, rootQuery, rootSort, collection, aliasMap, retu
         if (column.length === 1) {
             const pathRoot = column[0].split(':')[0];
             const { relation, relationType } = (0, get_relation_info_1.getRelationInfo)(relations, collection, pathRoot);
-            if (!relation || ['m2o', 'a2o'].includes(relationType !== null && relationType !== void 0 ? relationType : '')) {
+            if (!relation || ['m2o', 'a2o'].includes(relationType ?? '')) {
                 return {
                     order,
                     column: returnRecords ? column[0] : (0, get_column_1.getColumn)(knex, collection, column[0], false, schema),
@@ -173,6 +171,7 @@ function applySort(knex, schema, rootQuery, rootSort, collection, aliasMap, retu
     // Clears the order if any, eg: from MSSQL offset
     rootQuery.clear('order');
     rootQuery.orderBy(sortRecords);
+    return undefined;
 }
 exports.applySort = applySort;
 function applyLimit(knex, rootQuery, limit) {
@@ -225,7 +224,6 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, aliasMap)
         }
     }
     function addWhereClauses(knex, dbQuery, filter, collection, logical = 'and') {
-        var _a;
         for (const [key, value] of Object.entries(filter)) {
             if (key === '_or' || key === '_and') {
                 // If the _or array contains an empty object (full permissions), we should short-circuit and ignore all other
@@ -267,7 +265,7 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, aliasMap)
                             .whereNotNull(column);
                         applyQuery(knex, relation.collection, subQueryKnex, { filter }, schema);
                     };
-                    const childKey = (_a = Object.keys(value)) === null || _a === void 0 ? void 0 : _a[0];
+                    const childKey = Object.keys(value)?.[0];
                     if (childKey === '_none') {
                         dbQuery[logical].whereNotIn(pkField, subQueryBuilder(Object.values(value)[0]));
                         continue;
@@ -340,7 +338,7 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, aliasMap)
             }
             if (operator === '_nempty' || (operator === '_empty' && compareValue === false)) {
                 dbQuery[logical].andWhere((query) => {
-                    query.whereNotNull(key).orWhere(key, '!=', '');
+                    query.whereNotNull(key).andWhere(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,6 +1,6 @@
-import { SchemaOverview } from '@directus/shared/types';
-import { Knex } from 'knex';
-import { Snapshot, SnapshotDiff } from '../types';
+import type { SchemaOverview } from '@directus/shared/types';
+import type { Knex } from 'knex';
+import type { Snapshot, SnapshotDiff } from '../types';
 export declare function applySnapshot(snapshot: Snapshot, options?: {
     database?: Knex;
     schema?: SchemaOverview;

package/dist/utils/apply-snapshot.js

@@ -11,13 +11,12 @@ const get_schema_1 = require("./get-schema");
 const get_snapshot_1 = require("./get-snapshot");
 const get_snapshot_diff_1 = require("./get-snapshot-diff");
 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 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 === null || systemCache === void 0 ? void 0 : systemCache.clear());
+    await systemCache?.clear();
 }
 exports.applySnapshot = applySnapshot;

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/dynamic-import.js

@@ -2,6 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dynamicImport = void 0;
 const dynamicImport = async (mod) => {
-    return process.env.VITEST ? await import(mod) : require(mod);
+    return process.env['VITEST'] ? await import(mod) : require(mod);
 };
 exports.dynamicImport = dynamicImport;

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/generate-hash.js

@@ -10,7 +10,7 @@ function generateHash(stringToHash) {
     const argon2HashConfigOptions = (0, get_config_from_env_1.getConfigFromEnv)('HASH_', 'HASH_RAW'); // Disallow the HASH_RAW option, see https://github.com/directus/directus/discussions/7670#discussioncomment-1255805
     // associatedData, if specified, must be passed as a Buffer to argon2.hash, see https://github.com/ranisalt/node-argon2/wiki/Options#associateddata
     'associatedData' in argon2HashConfigOptions &&
-        (argon2HashConfigOptions.associatedData = Buffer.from(argon2HashConfigOptions.associatedData));
+        (argon2HashConfigOptions['associatedData'] = Buffer.from(argon2HashConfigOptions['associatedData']));
     return argon2_1.default.hash(stringToHash, argon2HashConfigOptions);
 }
 exports.generateHash = generateHash;

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-auth-providers.js

@@ -7,7 +7,7 @@ exports.getAuthProviders = void 0;
 const utils_1 = require("@directus/shared/utils");
 const env_1 = __importDefault(require("../env"));
 function getAuthProviders() {
-    return (0, utils_1.toArray)(env_1.default.AUTH_PROVIDERS)
+    return (0, utils_1.toArray)(env_1.default['AUTH_PROVIDERS'])
         .filter((provider) => provider && env_1.default[`AUTH_${provider.toUpperCase()}_DRIVER`])
         .map((provider) => ({
         name: provider,

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

@@ -1,4 +1,4 @@
-import { Request } from 'express';
+import type { Request } from 'express';
 /**
  * Returns the Cache-Control header for the current request
  *

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

@@ -5,6 +5,7 @@ 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
  *
@@ -14,30 +15,28 @@ const env_1 = __importDefault(require("../env"));
  * @param personalized Whether requests depend on the authentication status of users
  */
 function getCacheControlHeader(req, ttl, globalCacheSettings, personalized) {
-    var _a, _b, _c;
-    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)
+    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 (globalCacheSettings && env_1.default.CACHE_AUTO_PURGE === true)
+    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';
+        const access = !!req.accountability?.role === false ? 'public' : 'private';
         headerValues.push(access);
     }
     // Cache control header uses seconds for everything
     const ttlSeconds = Math.round(ttl / 1000);
     headerValues.push(`max-age=${ttlSeconds}`);
     // When the s-maxage flag should be included
-    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}`);
+    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 headerValues.join(', ');
 }

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-collection-from-alias.js

@@ -11,5 +11,6 @@ function getCollectionFromAlias(alias, aliasMap) {
             return aliasValue.collection;
         }
     }
+    return undefined;
 }
 exports.getCollectionFromAlias = getCollectionFromAlias;

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.

package/dist/utils/get-column-path.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getColumnPath = void 0;
-const get_relation_info_1 = require("./get-relation-info");
 const exceptions_1 = require("../exceptions");
+const get_relation_info_1 = require("./get-relation-info");
 /**
  * Converts a Directus field list path to the correct SQL names based on the constructed alias map.
  * For example: ['author', 'role', 'name'] -> 'ljnsv.name'
@@ -12,7 +12,6 @@ const exceptions_1 = require("../exceptions");
 function getColumnPath({ path, collection, aliasMap, relations, schema }) {
     return followRelation(path);
     function followRelation(pathParts, parentCollection = collection, parentFields, addNestedPkField) {
-        var _a, _b, _c, _d;
         /**
          * For A2M fields, the path can contain an optional collection scope <field>:<scope>
          */
@@ -21,7 +20,7 @@ function getColumnPath({ path, collection, aliasMap, relations, schema }) {
         if (!relation) {
             throw new exceptions_1.InvalidQueryException(`"${parentCollection}.${pathRoot}" is not a relational field`);
         }
-        const alias = parentFields ? (_a = aliasMap[`${parentFields}.${pathParts[0]}`]) === null || _a === void 0 ? void 0 : _a.alias : (_b = aliasMap[pathParts[0]]) === null || _b === void 0 ? void 0 : _b.alias;
+        const alias = parentFields ? aliasMap[`${parentFields}.${pathParts[0]}`]?.alias : aliasMap[pathParts[0]]?.alias;
         const remainingParts = pathParts.slice(1);
         let parent;
         if (relationType === 'a2o') {
@@ -38,7 +37,7 @@ function getColumnPath({ path, collection, aliasMap, relations, schema }) {
             parent = relation.collection;
         }
         // Top level alias field
-        if (schema && !(((_c = remainingParts[0]) !== null && _c !== void 0 ? _c : parent).includes('(') && ((_d = remainingParts[0]) !== null && _d !== void 0 ? _d : parent).includes(')'))) {
+        if (schema && !((remainingParts[0] ?? parent).includes('(') && (remainingParts[0] ?? parent).includes(')'))) {
             if (remainingParts.length === 0) {
                 remainingParts.push(schema.collections[parent].primary);
                 addNestedPkField = schema.collections[parent].primary;

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

@@ -1,8 +1,8 @@
-import { Query, SchemaOverview } from '@directus/shared/types';
-import { Knex } from 'knex';
+import type { Query, SchemaOverview } from '@directus/shared/types';
+import type { Knex } from 'knex';
 type GetColumnOptions = {
-    query?: Query;
-    originalCollectionName?: string;
+    query?: Query | undefined;
+    originalCollectionName?: string | undefined;
 };
 /**
  * Return column prefixed by table. If column includes functions (like `year(date_created)`), the

package/dist/utils/get-column.js

@@ -19,22 +19,21 @@ const apply_function_to_column_name_1 = require("./apply-function-to-column-name
  * @returns Knex raw instance
  */
 function getColumn(knex, table, column, alias = (0, apply_function_to_column_name_1.applyFunctionToColumnName)(column), schema, options) {
-    var _a, _b, _c, _d;
     const fn = (0, helpers_1.getFunctions)(knex, schema);
     if (column.includes('(') && column.includes(')')) {
         const functionName = column.split('(')[0];
         const columnName = column.match(constants_1.REGEX_BETWEEN_PARENS)[1];
         if (functionName in fn) {
-            const collectionName = (options === null || options === void 0 ? void 0 : options.originalCollectionName) || table;
-            const type = (_d = (_c = (_b = (_a = schema === null || schema === void 0 ? void 0 : schema.collections[collectionName]) === null || _a === void 0 ? void 0 : _a.fields) === null || _b === void 0 ? void 0 : _b[columnName]) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : 'unknown';
+            const collectionName = options?.originalCollectionName || table;
+            const type = schema?.collections[collectionName]?.fields?.[columnName]?.type ?? 'unknown';
             const allowedFunctions = (0, utils_1.getFunctionsForType)(type);
             if (allowedFunctions.includes(functionName) === false) {
                 throw new exceptions_1.InvalidQueryException(`Invalid function specified "${functionName}"`);
             }
             const result = fn[functionName](table, columnName, {
                 type,
-                query: options === null || options === void 0 ? void 0 : options.query,
-                originalCollectionName: options === null || options === void 0 ? void 0 : options.originalCollectionName,
+                query: options?.query,
+                originalCollectionName: options?.originalCollectionName,
             });
             if (alias) {
                 return knex.raw(result + ' AS ??', [alias]);

package/dist/utils/get-default-value.d.ts

@@ -1,3 +1,3 @@
-import { SchemaOverview } from '@directus/schema/types/overview';
-import { Column } from 'knex-schema-inspector/dist/types/column';
+import type { SchemaOverview } from '@directus/schema/types/overview';
+import type { Column } from 'knex-schema-inspector/dist/types/column';
 export default function getDefaultValue(column: SchemaOverview[string]['columns'][string] | Column): string | boolean | number | Record<string, any> | any[] | null;

package/dist/utils/get-default-value.js

@@ -8,9 +8,8 @@ const env_1 = __importDefault(require("../env"));
 const logger_1 = __importDefault(require("../logger"));
 const get_local_type_1 = __importDefault(require("./get-local-type"));
 function getDefaultValue(column) {
-    var _a;
     const type = (0, get_local_type_1.default)(column);
-    const defaultValue = (_a = column.default_value) !== null && _a !== void 0 ? _a : null;
+    const defaultValue = column.default_value ?? null;
     if (defaultValue === null)
         return null;
     if (defaultValue === '0000-00-00 00:00:00')
@@ -53,7 +52,7 @@ function castToObject(value) {
             return (0, utils_1.parseJSON)(value);
         }
         catch (err) {
-            if (env_1.default.NODE_ENV === 'development') {
+            if (env_1.default['NODE_ENV'] === 'development') {
                 logger_1.default.error(err);
             }
             return value;

package/dist/utils/get-graphql-query-and-variables.d.ts

@@ -1,2 +1,2 @@
-import { Request } from 'express';
+import type { Request } from 'express';
 export declare function getGraphqlQueryAndVariables(req: Request): Pick<any, "query" | "variables">;

package/dist/utils/get-graphql-query-and-variables.js

@@ -3,8 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getGraphqlQueryAndVariables = void 0;
 const lodash_1 = require("lodash");
 function getGraphqlQueryAndVariables(req) {
-    var _a;
-    const isGet = ((_a = req.method) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'get';
+    const isGet = req.method?.toLowerCase() === 'get';
     return (0, lodash_1.pick)(isGet ? req.query : req.body, ['query', 'variables']);
 }
 exports.getGraphqlQueryAndVariables = getGraphqlQueryAndVariables;

package/dist/utils/get-graphql-type.d.ts

@@ -1,3 +1,3 @@
-import { GraphQLScalarType, GraphQLList, GraphQLType } from 'graphql';
-import { Type } from '@directus/shared/types';
+import type { Type } from '@directus/shared/types';
+import { GraphQLList, GraphQLScalarType, GraphQLType } from 'graphql';
 export declare function getGraphQLType(localType: Type | 'alias' | 'unknown', special: string[]): GraphQLScalarType | GraphQLList<GraphQLType>;