@directus/api 32.1.1 → 33.0.0

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.d.ts

@@ -1,4 +1,4 @@
-import type { ApiOutput, ExtensionSettings, ExtensionManager } from '@directus/types';
+import type { ApiOutput, ExtensionManager, ExtensionSettings } from '@directus/types';
 import type { AbstractServiceOptions, Accountability, DeepPartial, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 import { ItemsService } from './items.js';

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/files/utils/get-metadata.d.ts

@@ -1,4 +1,4 @@
-import type { File } from '@directus/types';
 import type { Readable } from 'node:stream';
+import type { File } from '@directus/types';
 export type Metadata = Partial<Pick<File, 'height' | 'width' | 'description' | 'title' | 'tags' | 'metadata'>>;
 export declare function getMetadata(stream: Readable, allowList?: string | string[]): Promise<Metadata>;

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

@@ -1,8 +1,8 @@
+import { pipeline } from 'node:stream/promises';
 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 { useLogger } from '../../../logger/index.js';
 import { getSharpInstance } from '../lib/get-sharp-instance.js';
 import { parseIptc, parseXmp } from './parse-image-metadata.js';

package/dist/services/files.d.ts

@@ -1,5 +1,5 @@
-import type { AbstractServiceOptions, BusboyFileStream, File, MutationOptions, PrimaryKey, Query, QueryOptions } from '@directus/types';
 import type { Readable } from 'node:stream';
+import type { AbstractServiceOptions, BusboyFileStream, File, MutationOptions, PrimaryKey, Query, QueryOptions } from '@directus/types';
 import { ItemsService } from './items.js';
 export declare class FilesService extends ItemsService<File> {
     constructor(options: AbstractServiceOptions);

package/dist/services/files.js

@@ -1,3 +1,7 @@
+import { PassThrough as PassThroughStream, Transform as TransformStream } from 'node:stream';
+import zlib from 'node:zlib';
+import path from 'path';
+import url from 'url';
 import { useEnv } from '@directus/env';
 import { ContentTooLargeError, InvalidPayloadError, ServiceUnavailableError } from '@directus/errors';
 import formatTitle from '@directus/format-title';
@@ -5,10 +9,6 @@ import { toArray } from '@directus/utils';
 import encodeURL from 'encodeurl';
 import { clone, cloneDeep } from 'lodash-es';
 import { extension } from 'mime-types';
-import { PassThrough as PassThroughStream, Transform as TransformStream } from 'node:stream';
-import zlib from 'node:zlib';
-import path from 'path';
-import url from 'url';
 import { RESUMABLE_UPLOADS } from '../constants.js';
 import emitter from '../emitter.js';
 import { useLogger } from '../logger/index.js';

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/index.d.ts

@@ -1,4 +1,4 @@
-import type { AbstractServiceOptions, Accountability, GraphQLParams, GQLScope, Item, Query, SchemaOverview, PrimaryKey } from '@directus/types';
+import type { AbstractServiceOptions, Accountability, GQLScope, GraphQLParams, Item, PrimaryKey, Query, SchemaOverview } from '@directus/types';
 import type { FormattedExecutionResult, GraphQLSchema } from 'graphql';
 import type { Knex } from 'knex';
 export declare class GraphQLService {

package/dist/services/graphql/index.js

@@ -1,5 +1,5 @@
 import { useEnv } from '@directus/env';
-import { NoSchemaIntrospectionCustomRule, execute, specifiedRules, validate } from 'graphql';
+import { execute, NoSchemaIntrospectionCustomRule, specifiedRules, validate } from 'graphql';
 import getDatabase from '../../database/index.js';
 import { getService } from '../../utils/get-service.js';
 import { formatError } from './errors/format.js';

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

@@ -1,7 +1,7 @@
 import { getService } from '../../../utils/get-service.js';
 import { formatError } from '../errors/format.js';
-import { replaceFragmentsInSelections } from '../utils/replace-fragments.js';
 import { getQuery } from '../schema/parse-query.js';
+import { replaceFragmentsInSelections } from '../utils/replace-fragments.js';
 export async function resolveMutation(gql, args, info) {
     const action = info.fieldName.split('_')[0];
     let collection = info.fieldName.substring(action.length + 1);

package/dist/services/graphql/schema/get-types.d.ts

@@ -1,6 +1,6 @@
+import type { GQLScope } from '@directus/types';
 import type { SchemaComposer } from 'graphql-compose';
 import { ObjectTypeComposer } from 'graphql-compose';
-import type { GQLScope } from '@directus/types';
 import { type InconsistentFields, type Schema } from './index.js';
 /**
  * Construct an object of types for every collection, using the permitted fields per action type

package/dist/services/graphql/schema/read.js

@@ -9,8 +9,8 @@ import { GraphQLDate } from '../types/date.js';
 import { GraphQLGeoJSON } from '../types/geojson.js';
 import { GraphQLHash } from '../types/hash.js';
 import { GraphQLStringOrFloat } from '../types/string-or-float.js';
-import { SYSTEM_DENY_LIST } from './index.js';
 import { getTypes } from './get-types.js';
+import { SYSTEM_DENY_LIST } from './index.js';
 /**
  * Create readable types and attach resolvers for each. Also prepares full filter argument structures
  */

package/dist/services/graphql/subscription.d.ts

@@ -1,5 +1,5 @@
-import type { GraphQLService } from './index.js';
 import type { GraphQLResolveInfo } from 'graphql';
+import type { GraphQLService } from './index.js';
 export declare function bindPubSub(): void;
 export declare function createSubscriptionGenerator(gql: GraphQLService, event: string): (_x: unknown, _y: unknown, _z: unknown, request: GraphQLResolveInfo) => AsyncGenerator<{
     [event]: {

package/dist/services/graphql/types/date.js

@@ -1,4 +1,4 @@
-import { GraphQLString, GraphQLScalarType } from 'graphql';
+import { GraphQLScalarType, GraphQLString } from 'graphql';
 export const GraphQLDate = new GraphQLScalarType({
     ...GraphQLString,
     name: 'Date',

package/dist/services/graphql/types/hash.js

@@ -1,4 +1,4 @@
-import { GraphQLString, GraphQLScalarType } from 'graphql';
+import { GraphQLScalarType, GraphQLString } from 'graphql';
 export const GraphQLHash = new GraphQLScalarType({
     ...GraphQLString,
     name: 'Hash',

package/dist/services/graphql/utils/add-path-to-validation-error.js

@@ -1,4 +1,4 @@
-import { GraphQLError, Token, locatedError } from 'graphql';
+import { GraphQLError, locatedError, Token } from 'graphql';
 export function addPathToValidationError(validationError) {
     const token = validationError.nodes?.[0]?.loc?.startToken;
     if (!token)

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

@@ -1,7 +1,7 @@
+import type { Readable } from 'node:stream';
 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 { createReadStream, createWriteStream } from 'node:fs';
+import { appendFile } from 'node:fs/promises';
 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 { createReadStream, createWriteStream } from 'node:fs';
-import { appendFile } from 'node:fs/promises';
+import { set } from 'lodash-es';
 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/index.d.ts

@@ -35,5 +35,4 @@ export * from './translations.js';
 export * from './users.js';
 export * from './utils.js';
 export * from './versions.js';
-export * from './webhooks.js';
 export * from './websocket.js';

package/dist/services/index.js

@@ -35,5 +35,4 @@ export * from './translations.js';
 export * from './users.js';
 export * from './utils.js';
 export * from './versions.js';
-export * from './webhooks.js';
 export * from './websocket.js';

package/dist/services/mail/index.js

@@ -1,10 +1,10 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
 import { useEnv } from '@directus/env';
 import { InvalidPayloadError } from '@directus/errors';
 import { isObject } from '@directus/utils';
 import fse from 'fs-extra';
 import { Liquid } from 'liquidjs';
-import path from 'path';
-import { fileURLToPath } from 'url';
 import getDatabase from '../../database/index.js';
 import emitter from '../../emitter.js';
 import { useLogger } from '../../logger/index.js';

package/dist/services/mail/rate-limiter.js

@@ -1,8 +1,8 @@
 import { useEnv } from '@directus/env';
+import { EmailLimitExceededError } from '@directus/errors';
+import { toBoolean } from '@directus/utils';
 import { RateLimiterQueue } from 'rate-limiter-flexible';
 import { createRateLimiter } from '../../rate-limiter.js';
-import { toBoolean } from '@directus/utils';
-import { EmailLimitExceededError } from '@directus/errors';
 let emailRateLimiterQueue;
 const env = useEnv();
 if (toBoolean(env['RATE_LIMITER_EMAIL_ENABLED']) === true) {

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

@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto';
 import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
 import { UserIntegrityCheckFlag } from '@directus/types';
 import { parseJSON, toArray } from '@directus/utils';
@@ -5,11 +6,12 @@ import { format, isValid, parseISO } from 'date-fns';
 import { unflatten } from 'flat';
 import Joi from 'joi';
 import { clone, cloneDeep, isNil, isObject, isPlainObject, pick } from 'lodash-es';
-import { randomUUID } from 'node:crypto';
 import { parse as wktToGeoJSON } from 'wellknown';
 import { getHelpers } from '../database/helpers/index.js';
 import getDatabase from '../database/index.js';
+import { decrypt, encrypt } from '../utils/encrypt.js';
 import { generateHash } from '../utils/generate-hash.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/schema.js

@@ -1,5 +1,5 @@
-import getDatabase from '../database/index.js';
 import { ForbiddenError } from '@directus/errors';
+import getDatabase from '../database/index.js';
 import { applyDiff } from '../utils/apply-diff.js';
 import { getSnapshotDiff } from '../utils/get-snapshot-diff.js';
 import { getSnapshot } from '../utils/get-snapshot.js';

package/dist/services/server.js

@@ -1,11 +1,11 @@
+import { Readable } from 'node:stream';
+import { performance } from 'perf_hooks';
 import { useEnv } from '@directus/env';
 import { toArray, toBoolean } from '@directus/utils';
 import { version } from 'directus/version';
 import { merge } from 'lodash-es';
-import { Readable } from 'node:stream';
-import { performance } from 'perf_hooks';
 import { getCache } from '../cache.js';
-import { RESUMABLE_UPLOADS } from '../constants.js';
+import { FILE_UPLOADS, RESUMABLE_UPLOADS } from '../constants.js';
 import getDatabase, { hasDatabaseConnection } from '../database/index.js';
 import { useLogger } from '../logger/index.js';
 import getMailer from '../mailer.js';
@@ -57,9 +57,10 @@ export class ServerService {
             ],
         });
         info['project'] = projectInfo;
-        info['mcp_enabled'] = toBoolean(env['MCP_ENABLED'] ?? true);
         info['setupCompleted'] = setupComplete;
         if (this.accountability?.user) {
+            info['mcp_enabled'] = toBoolean(env['MCP_ENABLED'] ?? true);
+            info['ai_enabled'] = toBoolean(env['AI_ENABLED'] ?? true);
             if (env['RATE_LIMITER_ENABLED']) {
                 info['rateLimit'] = {
                     points: env['RATE_LIMITER_POINTS'],
@@ -112,8 +113,15 @@ export class ServerService {
             else {
                 info['websocket'] = false;
             }
+            if (FILE_UPLOADS.MAX_CONCURRENCY && FILE_UPLOADS.MAX_CONCURRENCY !== Infinity) {
+                info['uploads'] = {
+                    maxConcurrency: FILE_UPLOADS.MAX_CONCURRENCY,
+                };
+            }
             if (RESUMABLE_UPLOADS.ENABLED) {
                 info['uploads'] = {
+                    ...info['uploads'],
+                    tus: true,
                     chunkSize: RESUMABLE_UPLOADS.CHUNK_SIZE,
                 };
             }

package/dist/services/settings.js

@@ -1,6 +1,6 @@
-import { ItemsService } from './items.js';
-import { sendReport } from '../telemetry/index.js';
 import { version } from 'directus/version';
+import { sendReport } from '../telemetry/index.js';
+import { ItemsService } from './items.js';
 export class SettingsService extends ItemsService {
     constructor(options) {
         super('directus_settings', options);

package/dist/services/tfa.js

@@ -1,8 +1,8 @@
 import { InvalidPayloadError } from '@directus/errors';
 import { authenticator } from 'otplib';
+import { DEFAULT_AUTH_PROVIDER } from '../constants.js';
 import getDatabase from '../database/index.js';
 import { ItemsService } from './items.js';
-import { DEFAULT_AUTH_PROVIDER } from '../constants.js';
 export class TFAService {
     knex;
     itemsService;

package/dist/services/translations.js

@@ -1,5 +1,5 @@
-import getDatabase from '../database/index.js';
 import { InvalidPayloadError } from '@directus/errors';
+import getDatabase from '../database/index.js';
 import { ItemsService } from './items.js';
 export class TranslationsService extends ItemsService {
     constructor(options) {

package/dist/services/tus/data-store.d.ts

@@ -1,12 +1,11 @@
+import stream from 'node:stream';
 import type { TusDriver } from '@directus/storage';
 import type { Accountability, File, SchemaOverview } from '@directus/types';
 import { DataStore, Upload } from '@tus/utils';
-import stream from 'node:stream';
 export type TusDataStoreConfig = {
     constants: {
         ENABLED: boolean;
         CHUNK_SIZE: number | null;
-        MAX_SIZE: number | null;
         EXPIRATION_TIME: number;
         SCHEDULE: string;
     };
@@ -18,7 +17,6 @@ export type TusDataStoreConfig = {
 };
 export declare class TusDataStore extends DataStore {
     protected chunkSize: number | undefined;
-    protected maxSize: number | undefined;
     protected expirationTime: number;
     protected location: string;
     protected storageDriver: TusDriver;

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

@@ -1,15 +1,14 @@
+import { extname } from 'node:path';
+import stream from 'node:stream';
 import formatTitle from '@directus/format-title';
 import { DataStore, ERRORS, Upload } from '@tus/utils';
 import { omit } from 'lodash-es';
 import { extension } from 'mime-types';
-import { extname } from 'node:path';
-import stream from 'node:stream';
 import getDatabase from '../../database/index.js';
 import { useLogger } from '../../logger/index.js';
 import { ItemsService } from '../items.js';
 export class TusDataStore extends DataStore {
     chunkSize;
-    maxSize;
     expirationTime;
     location;
     storageDriver;
@@ -19,8 +18,6 @@ export class TusDataStore extends DataStore {
         super();
         if (config.constants.CHUNK_SIZE !== null)
             this.chunkSize = config.constants.CHUNK_SIZE;
-        if (config.constants.MAX_SIZE !== null)
-            this.maxSize = config.constants.MAX_SIZE;
         this.expirationTime = config.constants.EXPIRATION_TIME;
         this.location = config.location;
         this.storageDriver = config.driver;

package/dist/services/tus/server.js

@@ -7,16 +7,16 @@ import { useEnv } from '@directus/env';
 import { supportsTus } from '@directus/storage';
 import { toArray } from '@directus/utils';
 import { Server } from '@tus/server';
-import { RESUMABLE_UPLOADS } from '../../constants.js';
+import { pick } from 'lodash-es';
+import { FILE_UPLOADS, RESUMABLE_UPLOADS } from '../../constants.js';
+import getDatabase from '../../database/index.js';
+import emitter from '../../emitter.js';
 import { getStorage } from '../../storage/index.js';
+import { getSchema } from '../../utils/get-schema.js';
 import { extractMetadata } from '../files/lib/extract-metadata.js';
 import { ItemsService } from '../index.js';
 import { TusDataStore } from './data-store.js';
 import { getTusLocker } from './lockers.js';
-import { pick } from 'lodash-es';
-import emitter from '../../emitter.js';
-import getDatabase from '../../database/index.js';
-import { getSchema } from '../../utils/get-schema.js';
 async function createTusStore(context) {
     const env = useEnv();
     const storage = await getStorage();
@@ -40,8 +40,8 @@ export async function createTusServer(context) {
         path: '/files/tus',
         datastore: store,
         locker: getTusLocker(),
-        ...(RESUMABLE_UPLOADS.MAX_SIZE !== null && { maxSize: RESUMABLE_UPLOADS.MAX_SIZE }),
-        async onUploadFinish(req, upload) {
+        ...(FILE_UPLOADS.MAX_SIZE !== null && { maxSize: FILE_UPLOADS.MAX_SIZE }),
+        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: {