@directus/api 32.1.0 → 32.2.0

package/dist/permissions/utils/with-cache.d.ts

@@ -1,10 +1,12 @@
 /**
- * The `pick` parameter can be used to stabilize cache keys, by only using a subset of the available parameters and
- * ensuring key order.
+ * Wraps a function with caching capabilities.
  *
- * If the `pick` function is provided, we pass the picked result to the handler, in order for TypeScript to ensure that
- * the function only relies on the parameters that are used for generating the cache key.
+ * @param namespace - A unique namespace for the cache key.
+ * @param handler - The function to be wrapped.
+ * @param prepareArg - Optional function to prepare arguments for hashing.
+ * @returns A new function that caches the results of the original function.
  *
- * @NOTE only uses the first parameter for memoization
+ * @NOTE Ensure that the `namespace` is unique to avoid cache key collisions.
+ * @NOTE Ensure that the `prepareArg` function returns a JSON stringifiable representation of the arguments.
  */
-export declare function withCache<F extends (arg0: Arg0, ...args: any[]) => R, R, Arg0 = Parameters<F>[0]>(namespace: string, handler: F, prepareArg?: (arg0: Arg0) => Arg0): F;
+export declare function withCache<F extends (...args: any) => any>(namespace: string, handler: F, prepareArg?: (...args: Parameters<F>) => Record<string, unknown>): (...args: Parameters<F>) => Promise<Awaited<ReturnType<F>>>;

package/dist/permissions/utils/with-cache.js

@@ -1,25 +1,27 @@
 import { getSimpleHash } from '@directus/utils';
 import { useCache } from '../cache.js';
 /**
- * The `pick` parameter can be used to stabilize cache keys, by only using a subset of the available parameters and
- * ensuring key order.
+ * Wraps a function with caching capabilities.
  *
- * If the `pick` function is provided, we pass the picked result to the handler, in order for TypeScript to ensure that
- * the function only relies on the parameters that are used for generating the cache key.
+ * @param namespace - A unique namespace for the cache key.
+ * @param handler - The function to be wrapped.
+ * @param prepareArg - Optional function to prepare arguments for hashing.
+ * @returns A new function that caches the results of the original function.
  *
- * @NOTE only uses the first parameter for memoization
+ * @NOTE Ensure that the `namespace` is unique to avoid cache key collisions.
+ * @NOTE Ensure that the `prepareArg` function returns a JSON stringifiable representation of the arguments.
  */
 export function withCache(namespace, handler, prepareArg) {
     const cache = useCache();
-    return (async (arg0, ...args) => {
-        arg0 = prepareArg ? prepareArg(arg0) : arg0;
-        const key = namespace + '-' + getSimpleHash(JSON.stringify(arg0));
+    return async (...args) => {
+        const hashArgs = prepareArg ? prepareArg(...args) : args;
+        const key = namespace + '-' + getSimpleHash(JSON.stringify(hashArgs));
         const cached = await cache.get(key);
         if (cached !== undefined) {
             return cached;
         }
-        const res = await handler(arg0, ...args);
+        const res = await handler(...args);
         cache.set(key, res);
         return res;
-    });
+    };
 }

package/dist/request/is-denied-ip.js

@@ -1,8 +1,8 @@
 import { useEnv } from '@directus/env';
-import os from 'node:os';
+import { ipInNetworks } from '@directus/utils/node';
 import { matches } from 'ip-matching';
+import os from 'node:os';
 import { useLogger } from '../logger/index.js';
-import { ipInNetworks } from '../utils/ip-in-networks.js';
 export function isDeniedIp(ip) {
     const env = useEnv();
     const logger = useLogger();

package/dist/services/assets/name-deduper.d.ts

@@ -0,0 +1,7 @@
+export declare class NameDeduper {
+    private map;
+    add(name?: string | null, options?: {
+        group?: string | null;
+        fallback?: string;
+    }): string;
+}

package/dist/services/assets/name-deduper.js

@@ -0,0 +1,23 @@
+import sanitize from 'sanitize-filename';
+const DEFAULT_GROUP = Symbol('undefined');
+export class NameDeduper {
+    map = {};
+    add(name, options) {
+        name = sanitize(name ?? '') || options?.fallback;
+        if (!name) {
+            throw Error('Invalid "name" provided');
+        }
+        const groupKey = options?.group ?? DEFAULT_GROUP;
+        const match = this.map[groupKey]?.[name];
+        if (match) {
+            const dedupedName = `${name} (${match})`;
+            this.map[groupKey][name] += 1;
+            return dedupedName;
+        }
+        if (!this.map[groupKey]) {
+            this.map[groupKey] = {};
+        }
+        this.map[groupKey][name] = 1;
+        return name;
+    }
+}

package/dist/services/assets.d.ts

@@ -1,4 +1,5 @@
-import type { AbstractServiceOptions, Accountability, Range, Stat, SchemaOverview, TransformationSet } from '@directus/types';
+import type { AbstractServiceOptions, Accountability, Range, SchemaOverview, Stat, TransformationSet } from '@directus/types';
+import archiver from 'archiver';
 import type { Knex } from 'knex';
 import type { Readable } from 'node:stream';
 import { FilesService } from './files.js';
@@ -6,8 +7,20 @@ export declare class AssetsService {
     knex: Knex;
     accountability: Accountability | null;
     schema: SchemaOverview;
-    filesService: FilesService;
+    sudoFilesService: FilesService;
     constructor(options: AbstractServiceOptions);
+    private zip;
+    zipFiles(files: string[]): Promise<{
+        archive: archiver.Archiver;
+        complete: () => Promise<void>;
+    }>;
+    zipFolder(root: string): Promise<{
+        archive: archiver.Archiver;
+        complete: () => Promise<void>;
+        metadata: {
+            name: string | undefined;
+        };
+    }>;
     getAsset(id: string, transformation?: TransformationSet, range?: Range, deferStream?: false): Promise<{
         stream: Readable;
         file: any;

package/dist/services/assets.js

@@ -1,7 +1,8 @@
 import { useEnv } from '@directus/env';
-import { ForbiddenError, IllegalAssetTransformationError, InvalidQueryError, RangeNotSatisfiableError, ServiceUnavailableError, } from '@directus/errors';
+import { ForbiddenError, IllegalAssetTransformationError, InvalidPayloadError, InvalidQueryError, RangeNotSatisfiableError, ServiceUnavailableError, } from '@directus/errors';
+import archiver from 'archiver';
 import { clamp } from 'lodash-es';
-import { contentType } from 'mime-types';
+import { contentType, extension } from 'mime-types';
 import hash from 'object-hash';
 import path from 'path';
 import sharp from 'sharp';
@@ -13,20 +14,112 @@ import { getStorage } from '../storage/index.js';
 import { getMilliseconds } from '../utils/get-milliseconds.js';
 import { isValidUuid } from '../utils/is-valid-uuid.js';
 import * as TransformationUtils from '../utils/transformations.js';
+import { NameDeduper } from './assets/name-deduper.js';
 import { FilesService } from './files.js';
 import { getSharpInstance } from './files/lib/get-sharp-instance.js';
+import { FoldersService } from './folders.js';
 const env = useEnv();
 const logger = useLogger();
 export class AssetsService {
     knex;
     accountability;
     schema;
-    filesService;
+    sudoFilesService;
     constructor(options) {
         this.knex = options.knex || getDatabase();
         this.accountability = options.accountability || null;
         this.schema = options.schema;
-        this.filesService = new FilesService({ ...options, accountability: null });
+        this.sudoFilesService = new FilesService({ ...options, accountability: null });
+    }
+    zip(options) {
+        if (options.files.length === 0) {
+            throw new InvalidPayloadError({ reason: 'No files found in the selected folders tree' });
+        }
+        const archive = archiver('zip');
+        const complete = async () => {
+            const deduper = new NameDeduper();
+            const storage = await getStorage();
+            for (const { id, folder, filename_download } of options.files) {
+                const file = await this.sudoFilesService.readOne(id, {
+                    fields: ['id', 'storage', 'filename_disk', 'filename_download', 'modified_on', 'type'],
+                });
+                const exists = await storage.location(file.storage).exists(file.filename_disk);
+                if (!exists)
+                    throw new ForbiddenError();
+                const version = file.modified_on ? (new Date(file.modified_on).getTime() / 1000).toFixed() : undefined;
+                const assetStream = await storage.location(file.storage).read(file.filename_disk, { version });
+                const fileExtension = path.extname(file.filename_download) || (file.type && '.' + extension(file.type)) || '';
+                const dedupedFileName = deduper.add(filename_download, { group: folder, fallback: file.id + fileExtension });
+                const folderName = folder ? options.folders?.get(folder) : undefined;
+                archive.append(assetStream, { name: dedupedFileName, prefix: folderName });
+            }
+            // add any empty folders, does not override already filled folder
+            if (options.folders) {
+                for (const [, folder] of options.folders) {
+                    archive.append('', { name: folder + '/' });
+                }
+            }
+            await archive.finalize();
+        };
+        return { archive, complete };
+    }
+    async zipFiles(files) {
+        const filesService = new FilesService({
+            schema: this.schema,
+            knex: this.knex,
+            accountability: this.accountability,
+        });
+        const filesToZip = await filesService.readByQuery({
+            filter: {
+                id: {
+                    _in: files,
+                },
+            },
+            limit: -1,
+        });
+        return this.zip({
+            files: filesToZip.map((file) => ({
+                id: file['id'],
+                folder: file['folder'],
+                filename_download: file['filename_download'],
+            })),
+        });
+    }
+    async zipFolder(root) {
+        const foldersService = new FoldersService({
+            schema: this.schema,
+            knex: this.knex,
+            accountability: this.accountability,
+        });
+        const folderTree = await foldersService.buildTree(root);
+        const filesService = new FilesService({
+            schema: this.schema,
+            knex: this.knex,
+            accountability: this.accountability,
+        });
+        const filesToZip = await filesService.readByQuery({
+            filter: {
+                folder: {
+                    _in: Array.from(folderTree.keys()),
+                },
+            },
+            limit: -1,
+        });
+        const { archive, complete } = this.zip({
+            folders: folderTree,
+            files: filesToZip.map((file) => ({
+                id: file['id'],
+                folder: file['folder'],
+                filename_download: file['filename_download'],
+            })),
+        });
+        return {
+            archive,
+            complete,
+            metadata: {
+                name: folderTree.get(root),
+            },
+        };
     }
     async getAsset(id, transformation, range, deferStream = false) {
         const storage = await getStorage();
@@ -50,7 +143,7 @@ export class AssetsService {
                 primaryKeys: [id],
             }, { knex: this.knex, schema: this.schema });
         }
-        const file = (await this.filesService.readOne(id, { limit: 1 }));
+        const file = (await this.sudoFilesService.readOne(id, { limit: 1 }));
         const exists = await storage.location(file.storage).exists(file.filename_disk);
         if (!exists)
             throw new ForbiddenError();

package/dist/services/authentication.js

@@ -149,8 +149,8 @@ export class AuthenticationService {
                 throw new InvalidOtpError();
             }
         }
-        const roles = await fetchRolesTree(user.role, this.knex);
-        const globalAccess = await fetchGlobalAccess({ roles, user: user.id, ip: this.accountability?.ip ?? null }, this.knex);
+        const roles = await fetchRolesTree(user.role, { knex: this.knex });
+        const globalAccess = await fetchGlobalAccess({ roles, user: user.id, ip: this.accountability?.ip ?? null }, { knex: this.knex });
         const tokenPayload = {
             id: user.id,
             role: user.role,
@@ -277,8 +277,8 @@ export class AuthenticationService {
                 throw new InvalidCredentialsError();
             }
         }
-        const roles = await fetchRolesTree(record.user_role, this.knex);
-        const globalAccess = await fetchGlobalAccess({ user: record.user_id, roles, ip: this.accountability?.ip ?? null }, this.knex);
+        const roles = await fetchRolesTree(record.user_role, { knex: this.knex });
+        const globalAccess = await fetchGlobalAccess({ user: record.user_id, roles, ip: this.accountability?.ip ?? null }, { knex: this.knex });
         if (record.user_id) {
             const provider = getAuthProvider(record.user_provider);
             await provider.refresh({

package/dist/services/comments.js

@@ -63,10 +63,10 @@ export class CommentsService extends ItemsService {
                 role: user['role']?.id ?? null,
                 admin: false,
                 app: false,
-                roles: await fetchRolesTree(user['role']?.id ?? null, this.knex),
+                roles: await fetchRolesTree(user['role']?.id ?? null, { knex: this.knex }),
                 ip: null,
             };
-            const userGlobalAccess = await fetchGlobalAccess(accountability, this.knex);
+            const userGlobalAccess = await fetchGlobalAccess(accountability, { knex: this.knex });
             accountability.admin = userGlobalAccess.admin;
             accountability.app = userGlobalAccess.app;
             const usersService = new UsersService({ schema: this.schema, accountability });

package/dist/services/extensions.js

@@ -109,6 +109,8 @@ export class ExtensionsService {
         await this.extensionsManager.install(versionId);
     }
     async readAll() {
+        // wait for extensions to be reloaded
+        await this.extensionsManager.isReloading();
         const settings = await this.extensionsItemService.readByQuery({ limit: -1 });
         const regular = settings.filter(({ bundle }) => bundle === null);
         const bundled = settings.filter(({ bundle }) => bundle !== null);
@@ -138,6 +140,8 @@ export class ExtensionsService {
         return output;
     }
     async readOne(id) {
+        // wait for extensions to be reloaded
+        await this.extensionsManager.isReloading();
         const meta = await this.extensionsItemService.readOne(id);
         const schema = this.extensionsManager.getExtension(meta.source, meta.folder) ?? null;
         return {

package/dist/services/folders.d.ts

@@ -1,5 +1,30 @@
-import type { AbstractServiceOptions } from '@directus/types';
+import type { AbstractServiceOptions, Folder } from '@directus/types';
 import { ItemsService } from './items.js';
-export declare class FoldersService extends ItemsService {
+export declare class FoldersService extends ItemsService<Folder> {
     constructor(options: AbstractServiceOptions);
+    /**
+     * Builds a full folder tree starting from a given root folder.
+     *
+     * This method returns a map of folder IDs to their corresponding paths
+     * relative to the root. It resolves all nested child folders and ensures
+     * that folder names are deduplicated within the same parent.
+     *
+     * Access control is applied automatically when non-admin, only folders the user has `read`
+     * access to are included.
+     *
+     * @param {string} root - The ID of the root folder to start building the tree from.
+     * @returns {Promise<Map<string, string>>} A `Map` where:
+     *   - Key: folder ID
+     *   - Value: folder path relative to the root (e.g., "Documents/Photos")
+     *
+     * @example
+     * const foldersService = new FoldersService({ schema, accountability });
+     * const tree = await foldersService.buildTree('root-folder-id');
+     * console.log(tree.get('folder1')); // e.g., "RootFolder/SubFolder1"
+     *
+     * @remarks
+     * - The returned `Map` includes the root folder itself.
+     * - If a folder has no name, its ID will be used as a fallback.
+     */
+    buildTree(root: string): Promise<Map<string, string>>;
 }

package/dist/services/folders.js

@@ -1,6 +1,81 @@
+import { validateAccess } from '../permissions/modules/validate-access/validate-access.js';
+import { NameDeduper } from './assets/name-deduper.js';
 import { ItemsService } from './items.js';
 export class FoldersService extends ItemsService {
     constructor(options) {
         super('directus_folders', options);
     }
+    /**
+     * Builds a full folder tree starting from a given root folder.
+     *
+     * This method returns a map of folder IDs to their corresponding paths
+     * relative to the root. It resolves all nested child folders and ensures
+     * that folder names are deduplicated within the same parent.
+     *
+     * Access control is applied automatically when non-admin, only folders the user has `read`
+     * access to are included.
+     *
+     * @param {string} root - The ID of the root folder to start building the tree from.
+     * @returns {Promise<Map<string, string>>} A `Map` where:
+     *   - Key: folder ID
+     *   - Value: folder path relative to the root (e.g., "Documents/Photos")
+     *
+     * @example
+     * const foldersService = new FoldersService({ schema, accountability });
+     * const tree = await foldersService.buildTree('root-folder-id');
+     * console.log(tree.get('folder1')); // e.g., "RootFolder/SubFolder1"
+     *
+     * @remarks
+     * - The returned `Map` includes the root folder itself.
+     * - If a folder has no name, its ID will be used as a fallback.
+     */
+    async buildTree(root) {
+        if (this.accountability && this.accountability.admin !== true) {
+            await validateAccess({
+                collection: 'directus_folders',
+                accountability: this.accountability,
+                action: 'read',
+                primaryKeys: [root],
+            }, {
+                knex: this.knex,
+                schema: this.schema,
+            });
+        }
+        const folders = await this.readByQuery({ limit: -1 });
+        // build folder and child lookup
+        const folderLookup = new Map();
+        const childFolderLookup = new Map();
+        for (const folder of folders) {
+            if (!folder['id'])
+                continue;
+            folderLookup.set(folder['id'], folder);
+            // root is always at the top level, we can therfor safely skip any parent references to it.
+            if (folder['parent'] && folder['id'] !== root) {
+                const children = childFolderLookup.get(folder['parent']) ?? [];
+                children.push(folder['id']);
+                childFolderLookup.set(folder['parent'], children);
+            }
+        }
+        const deduper = new NameDeduper();
+        const rootName = deduper.add(folderLookup.get(root)?.name, { fallback: root });
+        const stack = [[root, '']];
+        const tree = new Map();
+        // build tree from stack
+        while (stack.length > 0) {
+            const [folderId, path] = stack.pop() ?? [];
+            if (!folderId)
+                continue;
+            const folder = folderLookup.get(folderId);
+            if (!folder)
+                continue;
+            const children = childFolderLookup.get(folderId);
+            const folderName = deduper.add(folder['name'], { group: folder['parent'], fallback: folderId });
+            const folderPath = path === '' ? rootName : `${path}/${folderName}`;
+            tree.set(folderId, folderPath);
+            for (const childFolderId of children ?? []) {
+                stack.push([childFolderId, folderPath]);
+            }
+        }
+        return tree;
+    }
 }

package/dist/services/graphql/resolvers/query.js

@@ -23,10 +23,10 @@ export async function resolveQuery(gql, info) {
         query = await getAggregateQuery(args, selections, gql.schema, gql.accountability, collection);
     }
     else {
-        query = await getQuery(args, gql.schema, selections, info.variableValues, gql.accountability, collection);
         if (collection.endsWith('_by_id') && collection in gql.schema.collections === false) {
             collection = collection.slice(0, -6);
         }
+        query = await getQuery(args, gql.schema, selections, info.variableValues, gql.accountability, collection);
         if (collection.endsWith('_by_version') && collection in gql.schema.collections === false) {
             collection = collection.slice(0, -11);
             query.versionRaw = true;

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

@@ -1,7 +1,7 @@
 import type { AbstractServiceOptions, Accountability, DirectusError, ExportFormat, File, Query, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 import type { Readable } from 'node:stream';
-import type { FunctionFieldNode, FieldNode, NestedCollectionNode } from '../types/index.js';
+import type { FieldNode, FunctionFieldNode, NestedCollectionNode } from '../types/index.js';
 export declare function createErrorTracker(): {
     addCapturedError: (err: any, rowNumber: number) => void;
     buildFinalErrors: () => DirectusError<any>[];

package/dist/services/import-export.js

@@ -1,22 +1,23 @@
 import { useEnv } from '@directus/env';
 import { createError, ErrorCode, ForbiddenError, InvalidPayloadError, ServiceUnavailableError, UnsupportedMediaTypeError, } from '@directus/errors';
 import { isSystemCollection } from '@directus/system-data';
-import { parseJSON, toArray } from '@directus/utils';
+import { getDateTimeFormatted, parseJSON, toArray } from '@directus/utils';
 import { createTmpFile } from '@directus/utils/node';
 import { queue } from 'async';
 import destroyStream from 'destroy';
 import { dump as toYAML } from 'js-yaml';
 import { parse as toXML } from 'js2xmlparser';
 import { Parser as CSVParser, transforms as CSVTransforms } from 'json2csv';
+import { set } from 'lodash-es';
 import { createReadStream, createWriteStream } from 'node:fs';
 import { appendFile } from 'node:fs/promises';
 import Papa from 'papaparse';
 import StreamArray from 'stream-json/streamers/StreamArray.js';
+import { parseFields } from '../database/get-ast-from-query/lib/parse-fields.js';
 import getDatabase from '../database/index.js';
 import emitter from '../emitter.js';
 import { useLogger } from '../logger/index.js';
 import { validateAccess } from '../permissions/modules/validate-access/validate-access.js';
-import { getDateFormatted } from '../utils/get-date-formatted.js';
 import { getService } from '../utils/get-service.js';
 import { transaction } from '../utils/transaction.js';
 import { Url } from '../utils/url.js';
@@ -24,8 +25,6 @@ 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';
-import { set } from 'lodash-es';
 const env = useEnv();
 const logger = useLogger();
 const MAX_IMPORT_ERRORS = env['MAX_IMPORT_ERRORS'];
@@ -514,7 +513,7 @@ export class ExportService {
                 schema: this.schema,
             });
             const storage = toArray(env['STORAGE_LOCATIONS'])[0];
-            const title = `export-${collection}-${getDateFormatted()}`;
+            const title = `export-${collection}-${getDateTimeFormatted()}`;
             const filename = `${title}.${format}`;
             const fileWithDefaults = {
                 ...(options?.file ?? {}),

package/dist/services/notifications.js

@@ -29,12 +29,12 @@ export class NotificationsService extends ItemsService {
                     .addPath('admin', 'users', user['id'])
                     .toString();
                 const html = data.message ? md(data.message) : '';
-                const roles = await fetchRolesTree(user['role'], this.knex);
+                const roles = await fetchRolesTree(user['role'], { knex: this.knex });
                 const { app: app_access } = await fetchGlobalAccess({
                     user: user['id'],
                     roles,
                     ip: null,
-                }, this.knex);
+                }, { knex: this.knex });
                 const mailService = new MailService({
                     schema: this.schema,
                     knex: this.knex,

package/dist/services/payload.js

@@ -10,6 +10,8 @@ import { parse as wktToGeoJSON } from 'wellknown';
 import { getHelpers } from '../database/helpers/index.js';
 import getDatabase from '../database/index.js';
 import { generateHash } from '../utils/generate-hash.js';
+import { decrypt, encrypt } from '../utils/encrypt.js';
+import { getSecret } from '../utils/get-secret.js';
 /**
  * Process a given payload for a collection to ensure the special fields (hash, uuid, date etc) are
  * handled correctly.
@@ -124,6 +126,24 @@ export class PayloadService {
             }
             return value;
         },
+        async encrypt({ action, value, accountability }) {
+            if (!value)
+                return value;
+            if (action === 'read') {
+                // In-system calls can still get the decrypted value
+                if (accountability === null) {
+                    const key = getSecret();
+                    return await decrypt(value, key);
+                }
+                // Requests from the API entrypoints have accountability and shouldn't get the raw value
+                return '**********';
+            }
+            if (typeof value === 'string') {
+                const key = getSecret();
+                return await encrypt(value, key);
+            }
+            return value;
+        },
     };
     async processValues(action, payload, aliasMap = {}, aggregate = {}) {
         const processedPayload = toArray(payload);

package/dist/services/roles.js

@@ -3,8 +3,8 @@ import { UserIntegrityCheckFlag } from '@directus/types';
 import { clearSystemCache } from '../cache.js';
 import { fetchRolesTree } from '../permissions/lib/fetch-roles-tree.js';
 import { transaction } from '../utils/transaction.js';
-import { ItemsService } from './items.js';
 import { AccessService } from './access.js';
+import { ItemsService } from './items.js';
 import { PresetsService } from './presets.js';
 import { UsersService } from './users.js';
 export class RolesService extends ItemsService {
@@ -72,7 +72,7 @@ export class RolesService extends ItemsService {
         if (ids.includes(parent)) {
             throw new InvalidPayloadError({ reason: 'A role cannot be a parent of itself' });
         }
-        const roles = await fetchRolesTree(parent, this.knex);
+        const roles = await fetchRolesTree(parent, { knex: this.knex });
         if (ids.some((id) => roles.includes(id))) {
             // The role tree up from the parent already includes this role, so it would create a circular reference
             throw new InvalidPayloadError({ reason: 'A role cannot have a parent that is already a descendant of itself' });

package/dist/services/tus/server.js

@@ -41,7 +41,7 @@ export async function createTusServer(context) {
         datastore: store,
         locker: getTusLocker(),
         ...(RESUMABLE_UPLOADS.MAX_SIZE !== null && { maxSize: RESUMABLE_UPLOADS.MAX_SIZE }),
-        async onUploadFinish(req, upload) {
+        async onUploadFinish(_req, upload) {
             const schema = await getSchema();
             const service = new ItemsService('directus_files', {
                 schema,
@@ -92,9 +92,9 @@ export async function createTusServer(context) {
                 key: fileData.id,
                 collection: 'directus_files',
             }, {
-                database: getDatabase(),
                 schema,
-                accountability: req.accountability,
+                database: getDatabase(),
+                accountability: context.accountability ?? null,
             });
             return {
                 headers: {

package/dist/telemetry/utils/get-settings.d.ts

@@ -5,5 +5,20 @@ export type TelemetrySettings = {
     mcp_allow_deletes: boolean;
     mcp_system_prompt_enabled: boolean;
     visual_editor_urls: number;
+    ai_openai_api_key: boolean;
+    ai_anthropic_api_key: boolean;
+    ai_system_prompt: boolean;
+};
+export type DatabaseSettings = {
+    project_id: string;
+    mcp_enabled?: boolean;
+    mcp_allow_deletes?: boolean;
+    mcp_system_prompt_enabled?: boolean;
+    visual_editor_urls?: {
+        url: string;
+    }[];
+    ai_openai_api_key?: string;
+    ai_anthropic_api_key?: string;
+    ai_system_prompt?: string;
 };
 export declare const getSettings: (db: Knex) => Promise<TelemetrySettings>;