@directus/api 21.0.0-rc.0 → 22.0.0

package/dist/permissions/modules/process-ast/lib/inject-cases.js

@@ -20,11 +20,7 @@ function processChildren(collection, children, permissions) {
     // TODO this can be optimized if all cases are the same for all requested keys, as those should be
     //
     for (const child of children) {
-        // If there's one or more permissions that allow full access to this field, we can safe some
-        // query perf overhead by ignoring the whole case/where system
         const fieldKey = getUnaliasedFieldKey(child);
-        if (allowedFields.has('*') || allowedFields.has(fieldKey))
-            continue;
         const globalWhenCase = caseMap['*'];
         const fieldWhenCase = caseMap[fieldKey];
         // Validation should catch any fields that are attempted to be read that don't have any access control configured.
@@ -33,8 +29,12 @@ function processChildren(collection, children, permissions) {
         if (!globalWhenCase && !fieldWhenCase) {
             throw new Error(`Cannot extract access permissions for field "${fieldKey}" in collection "${collection}"`);
         }
-        // Global and field can't both be undefined as per the error check prior
-        child.whenCase = [...(globalWhenCase ?? []), ...(fieldWhenCase ?? [])];
+        // The case/when system only needs to take place if no full access is given on this field,
+        // otherwise we can skip and thus safe some query perf overhead
+        if (!allowedFields.has('*') && !allowedFields.has(fieldKey)) {
+            // Global and field can't both be undefined as per the error check prior
+            child.whenCase = [...(globalWhenCase ?? []), ...(fieldWhenCase ?? [])];
+        }
         if (child.type === 'm2o') {
             child.cases = processChildren(child.relation.related_collection, child.children, permissions);
         }

package/dist/permissions/modules/process-ast/types.d.ts

@@ -16,9 +16,3 @@ export type FieldMap = {
     read: FieldMapEntries;
     other: FieldMapEntries;
 };
-export interface AccessRow {
-    policy: {
-        id: string;
-        ip_access: string[] | null;
-    };
-}

package/dist/permissions/modules/process-ast/utils/extract-paths-from-query.js

@@ -24,12 +24,22 @@ export function extractPathsFromQuery(query) {
         for (const field of query.sort) {
             // Sort can have dot notation fields for sorting on m2o values Sort fields can start with
             // `-` to indicate descending order, which should be dropped for permissions checks
-            readOnlyPaths.push(field.split('.').map((field) => (field.startsWith('-') ? field.substring(1) : field)));
+            const parts = field.split('.').map((field) => (field.startsWith('-') ? field.substring(1) : field));
+            if (query.aggregate && parts.length > 0 && parts[0] in query.aggregate) {
+                // If query is an aggregate query and the first part is a requested aggregate operation, ignore the whole field.
+                // The correct field is extracted into the field map when processing the `query.aggregate` fields.
+                continue;
+            }
+            readOnlyPaths.push(parts);
         }
     }
     if (query.aggregate) {
         for (const fields of Object.values(query.aggregate)) {
             for (const field of fields) {
+                if (field === '*') {
+                    // Don't add wildcard field to the paths
+                    continue;
+                }
                 // Aggregate doesn't currently support aggregating on nested fields, but it doesn't hurt
                 // to standardize it in the validation layer
                 paths.push(field.split('.'));

package/dist/permissions/utils/filter-policies-by-ip.d.ts

@@ -1,2 +1,2 @@
-import type { AccessRow } from '../modules/process-ast/types.js';
+import type { AccessRow } from '../lib/fetch-policies.js';
 export declare function filterPoliciesByIp(policies: AccessRow[], ip: string | null | undefined): AccessRow[];

package/dist/services/assets.js

@@ -14,6 +14,7 @@ import { getMilliseconds } from '../utils/get-milliseconds.js';
 import { isValidUuid } from '../utils/is-valid-uuid.js';
 import * as TransformationUtils from '../utils/transformations.js';
 import { FilesService } from './files.js';
+import { getSharpInstance } from './files/lib/get-sharp-instance.js';
 const env = useEnv();
 const logger = useLogger();
 export class AssetsService {
@@ -121,11 +122,7 @@ export class AssetsService {
                 });
             }
             const readStream = await storage.location(file.storage).read(file.filename_disk, range);
-            const transformer = sharp({
-                limitInputPixels: Math.pow(env['ASSETS_TRANSFORM_IMAGE_MAX_DIMENSION'], 2),
-                sequentialRead: true,
-                failOn: env['ASSETS_INVALID_IMAGE_SENSITIVITY_LEVEL'],
-            });
+            const transformer = getSharpInstance();
             transformer.timeout({
                 seconds: clamp(Math.round(getMilliseconds(env['ASSETS_TRANSFORM_TIMEOUT'], 0) / 1000), 1, 3600),
             });

package/dist/services/fields.d.ts

@@ -16,7 +16,10 @@ export declare class FieldsService {
     schema: SchemaOverview;
     cache: Keyv<any> | null;
     systemCache: Keyv<any>;
+    schemaCache: Keyv<any>;
     constructor(options: AbstractServiceOptions);
+    columnInfo(collection?: string): Promise<Column[]>;
+    columnInfo(collection: string, field: string): Promise<Column>;
     readAll(collection?: string): Promise<Field[]>;
     readOne(collection: string, field: string): Promise<Record<string, any>>;
     createField(collection: string, field: Partial<Field> & {

package/dist/services/fields.js

@@ -1,9 +1,10 @@
 import { DEFAULT_NUMERIC_PRECISION, DEFAULT_NUMERIC_SCALE, KNEX_TYPES, REGEX_BETWEEN_PARENS, } from '@directus/constants';
+import { useEnv } from '@directus/env';
 import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
 import { createInspector } from '@directus/schema';
 import { addFieldFlag, toArray } from '@directus/utils';
 import { isEqual, isNil, merge } from 'lodash-es';
-import { clearSystemCache, getCache } from '../cache.js';
+import { clearSystemCache, getCache, getCacheValue, setCacheValue } from '../cache.js';
 import { ALIAS_TYPES } from '../constants.js';
 import { translateDatabaseError } from '../database/errors/translate.js';
 import { getHelpers } from '../database/helpers/index.js';
@@ -23,6 +24,7 @@ import { ItemsService } from './items.js';
 import { PayloadService } from './payload.js';
 import { RelationsService } from './relations.js';
 const systemFieldRows = getSystemFieldRowsWithAuthProviders();
+const env = useEnv();
 export class FieldsService {
     knex;
     helpers;
@@ -33,6 +35,7 @@ export class FieldsService {
     schema;
     cache;
     systemCache;
+    schemaCache;
     constructor(options) {
         this.knex = options.knex || getDatabase();
         this.helpers = getHelpers(this.knex);
@@ -41,9 +44,30 @@ export class FieldsService {
         this.itemsService = new ItemsService('directus_fields', options);
         this.payloadService = new PayloadService('directus_fields', options);
         this.schema = options.schema;
-        const { cache, systemCache } = getCache();
+        const { cache, systemCache, localSchemaCache } = getCache();
         this.cache = cache;
         this.systemCache = systemCache;
+        this.schemaCache = localSchemaCache;
+    }
+    async columnInfo(collection, field) {
+        const schemaCacheIsEnabled = Boolean(env['CACHE_SCHEMA']);
+        let columnInfo = null;
+        if (schemaCacheIsEnabled) {
+            columnInfo = await getCacheValue(this.schemaCache, 'columnInfo');
+        }
+        if (!columnInfo) {
+            columnInfo = await this.schemaInspector.columnInfo();
+            if (schemaCacheIsEnabled) {
+                setCacheValue(this.schemaCache, 'columnInfo', columnInfo);
+            }
+        }
+        if (collection) {
+            columnInfo = columnInfo.filter((column) => column.table === collection);
+        }
+        if (field) {
+            return columnInfo.find((column) => column.name === field);
+        }
+        return columnInfo;
     }
     async readAll(collection) {
         let fields;
@@ -72,7 +96,7 @@ export class FieldsService {
             fields = (await nonAuthorizedItemsService.readByQuery({ limit: -1 }));
             fields.push(...systemFieldRows);
         }
-        const columns = (await this.schemaInspector.columnInfo(collection)).map((column) => ({
+        const columns = (await this.columnInfo(collection)).map((column) => ({
             ...column,
             default_value: getDefaultValue(column, fields.find((field) => field.collection === column.table && field.field === column.name)),
         }));
@@ -204,7 +228,7 @@ export class FieldsService {
             fieldInfo ||
                 systemFieldRows.find((fieldMeta) => fieldMeta.collection === collection && fieldMeta.field === field);
         try {
-            column = await this.schemaInspector.columnInfo(collection, field);
+            column = await this.columnInfo(collection, field);
         }
         catch {
             // Do nothing
@@ -359,7 +383,7 @@ export class FieldsService {
                 throw new InvalidPayloadError({ reason: 'Alias type cannot be changed' });
             }
             if (hookAdjustedField.schema) {
-                const existingColumn = await this.schemaInspector.columnInfo(collection, hookAdjustedField.field);
+                const existingColumn = await this.columnInfo(collection, hookAdjustedField.field);
                 if (hookAdjustedField.schema?.is_nullable === true && existingColumn.is_primary_key) {
                     throw new InvalidPayloadError({ reason: 'Primary key cannot be null' });
                 }

package/dist/services/files/lib/get-sharp-instance.d.ts

@@ -0,0 +1,2 @@
+import { type Sharp } from 'sharp';
+export declare function getSharpInstance(): Sharp;

package/dist/services/files/lib/get-sharp-instance.js

@@ -0,0 +1,10 @@
+import { useEnv } from '@directus/env';
+import sharp, {} from 'sharp';
+export function getSharpInstance() {
+    const env = useEnv();
+    return sharp({
+        limitInputPixels: Math.trunc(Math.pow(env['ASSETS_TRANSFORM_IMAGE_MAX_DIMENSION'], 2)),
+        sequentialRead: true,
+        failOn: env['ASSETS_INVALID_IMAGE_SENSITIVITY_LEVEL'],
+    });
+}

package/dist/services/files/utils/get-metadata.js

@@ -1,19 +1,20 @@
+import { useEnv } from '@directus/env';
 import exif, {} from 'exif-reader';
 import { parse as parseIcc } from 'icc';
 import { pick } from 'lodash-es';
 import { pipeline } from 'node:stream/promises';
-import sharp from 'sharp';
-import { useEnv } from '@directus/env';
 import { useLogger } from '../../../logger/index.js';
+import { getSharpInstance } from '../lib/get-sharp-instance.js';
 import { parseIptc, parseXmp } from './parse-image-metadata.js';
 const env = useEnv();
 const logger = useLogger();
 export async function getMetadata(stream, allowList = env['FILE_METADATA_ALLOW_LIST']) {
-    return new Promise((resolve, reject) => {
-        pipeline(stream, sharp().metadata(async (err, sharpMetadata) => {
+    const transformer = getSharpInstance();
+    return new Promise((resolve) => {
+        pipeline(stream, transformer.metadata(async (err, sharpMetadata) => {
             if (err) {
-                reject(err);
-                return;
+                logger.error(err);
+                return resolve({});
             }
             const metadata = {};
             if (sharpMetadata.orientation && sharpMetadata.orientation >= 5) {

package/dist/services/files.js

@@ -58,6 +58,10 @@ export class FilesService extends ItemsService {
         const fileExtension = path.extname(payload.filename_download) || (payload.type && '.' + extension(payload.type)) || '';
         // The filename_disk is the FINAL filename on disk
         payload.filename_disk ||= primaryKey + (fileExtension || '');
+        // If the filename_disk extension doesn't match the new mimetype, update it
+        if (isReplacement === true && path.extname(payload.filename_disk) !== fileExtension) {
+            payload.filename_disk = primaryKey + (fileExtension || '');
+        }
         // Temp filename is used for replacements
         const tempFilenameDisk = 'temp_' + payload.filename_disk;
         if (!payload.type) {
@@ -126,6 +130,7 @@ export class FilesService extends ItemsService {
         const { size } = await storage.location(data.storage).stat(payload.filename_disk);
         payload.filesize = size;
         const metadata = await extractMetadata(data.storage, payload);
+        payload.uploaded_on = new Date().toISOString();
         // We do this in a service without accountability. Even if you don't have update permissions to the file,
         // we still want to be able to set the extracted values from the file on create
         const sudoService = new ItemsService('directus_files', {

package/dist/services/import-export.d.ts

@@ -2,7 +2,7 @@
 import type { Accountability, File, Query, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 import type { Readable } from 'node:stream';
-import type { AbstractServiceOptions } from '../types/index.js';
+import type { AbstractServiceOptions, FunctionFieldNode, FieldNode, NestedCollectionNode } from '../types/index.js';
 type ExportFormat = 'csv' | 'json' | 'xml' | 'yaml';
 export declare class ImportService {
     knex: Knex;
@@ -32,6 +32,8 @@ export declare class ExportService {
     transform(input: Record<string, any>[], format: ExportFormat, options?: {
         includeHeader?: boolean;
         includeFooter?: boolean;
+        fields?: string[] | null;
     }): string;
 }
+export declare function getHeadingsForCsvExport(nodes: (NestedCollectionNode | FieldNode | FunctionFieldNode)[] | undefined, prefix?: string): string[];
 export {};

package/dist/services/import-export.js

@@ -24,6 +24,7 @@ import { userName } from '../utils/user-name.js';
 import { FilesService } from './files.js';
 import { NotificationsService } from './notifications.js';
 import { UsersService } from './users.js';
+import { parseFields } from '../database/get-ast-from-query/lib/parse-fields.js';
 const env = useEnv();
 const logger = useLogger();
 export class ImportService {
@@ -262,9 +263,26 @@ export class ExportService {
                     });
                     readCount += result.length;
                     if (result.length) {
+                        let csvHeadings = null;
+                        if (format === 'csv') {
+                            if (!query.fields)
+                                query.fields = ['*'];
+                            // to ensure the all headings are included in the CSV file, all possible fields need to be determined.
+                            const parsedFields = await parseFields({
+                                parentCollection: collection,
+                                fields: query.fields,
+                                query: query,
+                                accountability: this.accountability,
+                            }, {
+                                schema: this.schema,
+                                knex: database,
+                            });
+                            csvHeadings = getHeadingsForCsvExport(parsedFields);
+                        }
                         await appendFile(tmpFile.path, this.transform(result, format, {
                             includeHeader: batch === 0,
                             includeFooter: batch + 1 === batchesRequired,
+                            fields: csvHeadings,
                         }));
                     }
                 }
@@ -359,11 +377,12 @@ Your export of ${collection} is ready. <a href="${href}">Click here to view.</a>
         if (format === 'csv') {
             if (input.length === 0)
                 return '';
-            const parser = new CSVParser({
-                transforms: [CSVTransforms.flatten({ separator: '.' })],
-                header: options?.includeHeader !== false,
-            });
-            let string = parser.parse(input);
+            const transforms = [CSVTransforms.flatten({ separator: '.' })];
+            const header = options?.includeHeader !== false;
+            const transformOptions = options?.fields
+                ? { transforms, header, fields: options?.fields }
+                : { transforms, header };
+            let string = new CSVParser(transformOptions).parse(input);
             if (options?.includeHeader === false) {
                 string = '\n' + string;
             }
@@ -375,3 +394,28 @@ Your export of ${collection} is ready. <a href="${href}">Click here to view.</a>
         throw new ServiceUnavailableError({ service: 'export', reason: `Illegal export type used: "${format}"` });
     }
 }
+/*
+ * Recursive function to traverse the field nodes, to determine the headings for the CSV export file.
+ *
+ * Relational nodes which target a single item get expanded, which means that their nested fields get their own column in the csv file.
+ * For relational nodes which target a multiple items, the nested field names are not going to be expanded.
+ * Instead they will be stored as a single value/cell of the CSV file.
+ */
+export function getHeadingsForCsvExport(nodes, prefix = '') {
+    let fieldNames = [];
+    if (!nodes)
+        return fieldNames;
+    nodes.forEach((node) => {
+        switch (node.type) {
+            case 'field':
+            case 'functionField':
+            case 'o2m':
+            case 'a2o':
+                fieldNames.push(prefix ? `${prefix}.${node.fieldKey}` : node.fieldKey);
+                break;
+            case 'm2o':
+                fieldNames = fieldNames.concat(getHeadingsForCsvExport(node.children, prefix ? `${prefix}.${node.fieldKey}` : node.fieldKey));
+        }
+    });
+    return fieldNames;
+}

package/dist/services/mail/index.d.ts

@@ -14,7 +14,7 @@ export declare class MailService {
     knex: Knex;
     mailer: Transporter;
     constructor(opts: AbstractServiceOptions);
-    send<T>(options: EmailOptions): Promise<T>;
+    send<T>(options: EmailOptions): Promise<T | null>;
     private renderTemplate;
     private getDefaultTemplateData;
 }

package/dist/services/mail/index.js

@@ -8,6 +8,7 @@ import getDatabase from '../../database/index.js';
 import { useLogger } from '../../logger/index.js';
 import getMailer from '../../mailer.js';
 import { Url } from '../../utils/url.js';
+import emitter from '../../emitter.js';
 const env = useEnv();
 const logger = useLogger();
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -35,7 +36,14 @@ export class MailService {
         }
     }
     async send(options) {
-        const { template, ...emailOptions } = options;
+        const payload = await emitter.emitFilter(`email.send`, options, {
+            database: getDatabase(),
+            schema: null,
+            accountability: null,
+        });
+        if (!payload)
+            return null;
+        const { template, ...emailOptions } = payload;
         let { html } = options;
         const defaultTemplateData = await this.getDefaultTemplateData();
         const from = `${defaultTemplateData.projectName} <${options.from || env['EMAIL_FROM']}>`;

package/dist/services/relations.d.ts

@@ -1,4 +1,4 @@
-import type { SchemaInspector } from '@directus/schema';
+import type { ForeignKey, SchemaInspector } from '@directus/schema';
 import type { Accountability, Relation, RelationMeta, SchemaOverview } from '@directus/types';
 import type Keyv from 'keyv';
 import type { Knex } from 'knex';
@@ -12,8 +12,10 @@ export declare class RelationsService {
     schema: SchemaOverview;
     relationsItemService: ItemsService<RelationMeta>;
     systemCache: Keyv<any>;
+    schemaCache: Keyv<any>;
     helpers: Helpers;
     constructor(options: AbstractServiceOptions);
+    foreignKeys(collection?: string): Promise<ForeignKey[]>;
     readAll(collection?: string, opts?: QueryOptions): Promise<Relation[]>;
     readOne(collection: string, field: string): Promise<Relation>;
     /**

package/dist/services/relations.js

@@ -1,8 +1,9 @@
+import { useEnv } from '@directus/env';
 import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
 import { createInspector } from '@directus/schema';
 import { systemRelationRows } from '@directus/system-data';
 import { toArray } from '@directus/utils';
-import { clearSystemCache, getCache } from '../cache.js';
+import { clearSystemCache, getCache, getCacheValue, setCacheValue } from '../cache.js';
 import { getHelpers } from '../database/helpers/index.js';
 import getDatabase, { getSchemaInspector } from '../database/index.js';
 import emitter from '../emitter.js';
@@ -13,6 +14,7 @@ import { getDefaultIndexName } from '../utils/get-default-index-name.js';
 import { getSchema } from '../utils/get-schema.js';
 import { transaction } from '../utils/transaction.js';
 import { ItemsService } from './items.js';
+const env = useEnv();
 export class RelationsService {
     knex;
     schemaInspector;
@@ -20,6 +22,7 @@ export class RelationsService {
     schema;
     relationsItemService;
     systemCache;
+    schemaCache;
     helpers;
     constructor(options) {
         this.knex = options.knex || getDatabase();
@@ -33,9 +36,28 @@ export class RelationsService {
             // allowed to extract the relations regardless of permissions to directus_relations. This
             // happens in `filterForbidden` down below
         });
-        this.systemCache = getCache().systemCache;
+        const cache = getCache();
+        this.systemCache = cache.systemCache;
+        this.schemaCache = cache.localSchemaCache;
         this.helpers = getHelpers(this.knex);
     }
+    async foreignKeys(collection) {
+        const schemaCacheIsEnabled = Boolean(env['CACHE_SCHEMA']);
+        let foreignKeys = null;
+        if (schemaCacheIsEnabled) {
+            foreignKeys = await getCacheValue(this.schemaCache, 'foreignKeys');
+        }
+        if (!foreignKeys) {
+            foreignKeys = await this.schemaInspector.foreignKeys();
+            if (schemaCacheIsEnabled) {
+                setCacheValue(this.schemaCache, 'foreignKeys', foreignKeys);
+            }
+        }
+        if (collection) {
+            return foreignKeys.filter((row) => row.table === collection);
+        }
+        return foreignKeys;
+    }
     async readAll(collection, opts) {
         if (this.accountability) {
             await validateAccess({
@@ -65,7 +87,7 @@ export class RelationsService {
                 return true;
             return metaRow.many_collection === collection;
         });
-        const schemaRows = await this.schemaInspector.foreignKeys(collection);
+        const schemaRows = await this.foreignKeys(collection);
         const results = this.stitchRelations(metaRows, schemaRows);
         return await this.filterForbidden(results);
     }
@@ -101,7 +123,7 @@ export class RelationsService {
                 ],
             },
         });
-        const schemaRow = (await this.schemaInspector.foreignKeys(collection)).find((foreignKey) => foreignKey.column === field);
+        const schemaRow = (await this.foreignKeys(collection)).find((foreignKey) => foreignKey.column === field);
         const stitched = this.stitchRelations(metaRow, schemaRow ? [schemaRow] : []);
         const results = await this.filterForbidden(stitched);
         if (results.length === 0) {
@@ -316,7 +338,7 @@ export class RelationsService {
         const nestedActionEvents = [];
         try {
             await transaction(this.knex, async (trx) => {
-                const existingConstraints = await this.schemaInspector.foreignKeys();
+                const existingConstraints = await this.foreignKeys();
                 const constraintNames = existingConstraints.map((key) => key.constraint_name);
                 if (existingRelation.schema?.constraint_name &&
                     constraintNames.includes(existingRelation.schema.constraint_name)) {

package/dist/services/tus/data-store.js

@@ -79,16 +79,15 @@ export class TusDataStore extends DataStore {
         }
         // If this is a new file upload, we need to generate a new primary key and DB record
         const primaryKey = await itemsService.createOne(fileData, { emitEvents: false });
+        // Set the file id, so it is available to be sent as a header on upload creation / resume
+        if (!upload.metadata['id']) {
+            upload.metadata['id'] = primaryKey;
+        }
         const fileExtension = extname(upload.metadata['filename_download']) ||
             (upload.metadata['type'] && '.' + extension(upload.metadata['type'])) ||
             '';
         // The filename_disk is the FINAL filename on disk
         fileData.filename_disk ||= primaryKey + (fileExtension || '');
-        // Temp filename is used for replacements
-        // const tempFilenameDisk = fileData.tus_id! + (fileExtension || '');
-        // if (isReplacement) {
-        // 	upload.metadata['temp_file'] = tempFilenameDisk;
-        // }
         try {
             // If this is a replacement, we'll write the file to a temp location first to ensure we don't overwrite the existing file if something goes wrong
             upload = (await this.storageDriver.createChunkedUpload(fileData.filename_disk, upload));

package/dist/services/tus/server.d.ts

@@ -4,5 +4,5 @@ type Context = {
     schema: SchemaOverview;
     accountability?: Accountability | undefined;
 };
-export declare function createTusServer(context: Context): Promise<Server>;
+export declare function createTusServer(context: Context): Promise<[Server, () => void]>;
 export {};

package/dist/services/tus/server.js

@@ -6,7 +6,7 @@
 import { useEnv } from '@directus/env';
 import { supportsTus } from '@directus/storage';
 import { toArray } from '@directus/utils';
-import { Server } from '@tus/server';
+import { Server, EVENTS } from '@tus/server';
 import { RESUMABLE_UPLOADS } from '../../constants.js';
 import { getStorage } from '../../storage/index.js';
 import { extractMetadata } from '../files/lib/extract-metadata.js';
@@ -33,7 +33,7 @@ async function createTusStore(context) {
 export async function createTusServer(context) {
     const env = useEnv();
     const store = await createTusStore(context);
-    return new Server({
+    const server = new Server({
         path: '/files/tus',
         datastore: store,
         locker: getTusLocker(),
@@ -77,4 +77,11 @@ export async function createTusServer(context) {
         },
         relativeLocation: String(env['PUBLIC_URL']).startsWith('http'),
     });
+    server.on(EVENTS.POST_CREATE, async (_req, res, upload) => {
+        res.setHeader('Directus-File-Id', upload.metadata['id']);
+    });
+    return [server, cleanup];
+    function cleanup() {
+        server.removeAllListeners();
+    }
 }

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

@@ -2,14 +2,16 @@ import type { Aggregate, Filter, Query, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 import type { AliasMap } from './get-column-path.js';
 export declare const generateAlias: (size?: number | undefined) => string;
-/**
- * Apply the Query to a given Knex query builder instance
- */
-export default function applyQuery(knex: Knex, collection: string, dbQuery: Knex.QueryBuilder, query: Query, schema: SchemaOverview, cases: Filter[], options?: {
+type ApplyQueryOptions = {
     aliasMap?: AliasMap;
     isInnerQuery?: boolean;
     hasMultiRelationalSort?: boolean | undefined;
-}): {
+    groupWhenCases?: number[][] | undefined;
+};
+/**
+ * Apply the Query to a given Knex query builder instance
+ */
+export default function applyQuery(knex: Knex, collection: string, dbQuery: Knex.QueryBuilder, query: Query, schema: SchemaOverview, cases: Filter[], options?: ApplyQueryOptions): {
     query: Knex.QueryBuilder<any, any>;
     hasJoins: boolean;
     hasMultiRelationalFilter: boolean;
@@ -40,3 +42,4 @@ export declare function applyFilter(knex: Knex, schema: SchemaOverview, rootQuer
 export declare function applySearch(knex: Knex, schema: SchemaOverview, dbQuery: Knex.QueryBuilder, searchQuery: string, collection: string): void;
 export declare function applyAggregate(schema: SchemaOverview, dbQuery: Knex.QueryBuilder, aggregate: Aggregate, collection: string, hasJoins: boolean): void;
 export declare function joinFilterWithCases(filter: Filter | null | undefined, cases: Filter[]): Filter | null;
+export {};