@directus/api 30.0.0 → 32.0.0

package/dist/services/tfa.js

@@ -2,6 +2,7 @@ import { InvalidPayloadError } from '@directus/errors';
 import { authenticator } from 'otplib';
 import getDatabase from '../database/index.js';
 import { ItemsService } from './items.js';
+import { DEFAULT_AUTH_PROVIDER } from '../constants.js';
 export class TFAService {
     knex;
     itemsService;
@@ -19,26 +20,40 @@ export class TFAService {
         }
         return authenticator.check(otp, user.tfa_secret);
     }
-    async generateTFA(key) {
-        const user = await this.knex.select('email', 'tfa_secret').from('directus_users').where({ id: key }).first();
+    async generateTFA(key, requiresPassword = true) {
+        const user = await this.knex
+            .select('email', 'tfa_secret', 'provider', 'external_identifier')
+            .from('directus_users')
+            .where({ id: key })
+            .first();
         if (user?.tfa_secret !== null) {
             throw new InvalidPayloadError({ reason: 'TFA Secret is already set for this user' });
         }
-        if (!user?.email) {
+        // Only require email for non-OAuth users
+        if (user?.provider === DEFAULT_AUTH_PROVIDER && !user?.email) {
             throw new InvalidPayloadError({ reason: 'User must have a valid email to enable TFA' });
         }
+        if (!requiresPassword && user?.provider === DEFAULT_AUTH_PROVIDER) {
+            throw new InvalidPayloadError({ reason: 'This method is only available for OAuth users' });
+        }
         const secret = authenticator.generateSecret();
         const project = await this.knex.select('project_name').from('directus_settings').limit(1).first();
+        // For OAuth users without email, use external_identifier as fallback
+        const accountName = user.email || user.external_identifier || `user_${key}`;
         return {
             secret,
-            url: authenticator.keyuri(user.email, project?.project_name || 'Directus', secret),
+            url: authenticator.keyuri(accountName, project?.project_name || 'Directus', secret),
         };
     }
     async enableTFA(key, otp, secret) {
-        const user = await this.knex.select('tfa_secret').from('directus_users').where({ id: key }).first();
+        const user = await this.knex.select('tfa_secret', 'provider').from('directus_users').where({ id: key }).first();
+        const requiresPassword = user?.['provider'] === DEFAULT_AUTH_PROVIDER;
         if (user?.tfa_secret !== null) {
             throw new InvalidPayloadError({ reason: 'TFA Secret is already set for this user' });
         }
+        if (!requiresPassword && user?.provider === DEFAULT_AUTH_PROVIDER) {
+            throw new InvalidPayloadError({ reason: 'This method is only available for OAuth users' });
+        }
         if (!authenticator.check(otp, secret)) {
             throw new InvalidPayloadError({ reason: `"otp" is invalid` });
         }

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, EVENTS } from '@tus/server';
+import { Server } from '@tus/server';
 import { RESUMABLE_UPLOADS } from '../../constants.js';
 import { getStorage } from '../../storage/index.js';
 import { extractMetadata } from '../files/lib/extract-metadata.js';
@@ -16,6 +16,7 @@ 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,16 +41,17 @@ export async function createTusServer(context) {
         datastore: store,
         locker: getTusLocker(),
         ...(RESUMABLE_UPLOADS.MAX_SIZE !== null && { maxSize: RESUMABLE_UPLOADS.MAX_SIZE }),
-        async onUploadFinish(req, res, upload) {
+        async onUploadFinish(req, upload) {
+            const schema = await getSchema();
             const service = new ItemsService('directus_files', {
-                schema: req.schema,
+                schema,
             });
             const file = (await service.readByQuery({
                 filter: { tus_id: { _eq: upload.id } },
                 limit: 1,
             }))[0];
             if (!file)
-                return res;
+                return {};
             let fileData;
             // update metadata when file is replaced
             if (file.tus_data?.['metadata']?.['replace_id']) {
@@ -91,19 +93,22 @@ export async function createTusServer(context) {
                 collection: 'directus_files',
             }, {
                 database: getDatabase(),
-                schema: req.schema,
+                schema,
                 accountability: req.accountability,
             });
-            return res;
+            return {
+                headers: {
+                    'Directus-File-Id': upload.metadata['id'],
+                },
+            };
         },
         generateUrl(_req, opts) {
             return env['PUBLIC_URL'] + '/files/tus/' + opts.id;
         },
+        allowedHeaders: env['CORS_ALLOWED_HEADERS'],
+        exposedHeaders: env['CORS_EXPOSED_HEADERS'],
         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/services/versions.d.ts

@@ -1,6 +1,6 @@
-import type { AbstractServiceOptions, Item, MutationOptions, PrimaryKey, Query } from '@directus/types';
+import type { AbstractServiceOptions, ContentVersion, Item, MutationOptions, PrimaryKey, Query, QueryOptions } from '@directus/types';
 import { ItemsService } from './items.js';
-export declare class VersionsService extends ItemsService {
+export declare class VersionsService extends ItemsService<ContentVersion> {
     constructor(options: AbstractServiceOptions);
     private validateCreateData;
     getMainItem(collection: string, item: PrimaryKey, query?: Query): Promise<Item>;
@@ -8,10 +8,12 @@ export declare class VersionsService extends ItemsService {
         outdated: boolean;
         mainHash: string;
     }>;
-    getVersionSaves(key: string, collection: string, item: string | undefined): Promise<Partial<Item>[] | null>;
+    getVersionSave(key: string, collection: string, item: string, mapDelta?: boolean): Promise<ContentVersion | undefined>;
     createOne(data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
+    readOne(key: PrimaryKey, query?: Query, opts?: QueryOptions): Promise<ContentVersion>;
     createMany(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
     updateMany(keys: PrimaryKey[], data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
-    save(key: PrimaryKey, data: Partial<Item>): Promise<Partial<Item>>;
+    save(key: PrimaryKey, delta: Partial<Item>): Promise<Partial<Item>>;
     promote(version: PrimaryKey, mainHash: string, fields?: string[]): Promise<PrimaryKey>;
+    private mapDelta;
 }

package/dist/services/versions.js

@@ -1,16 +1,19 @@
 import { Action } from '@directus/constants';
 import { ForbiddenError, InvalidPayloadError, UnprocessableContentError } from '@directus/errors';
 import Joi from 'joi';
-import { assign, pick } from 'lodash-es';
+import { assign, get, isEqual, isPlainObject, pick } from 'lodash-es';
 import objectHash from 'object-hash';
 import { getCache } from '../cache.js';
+import { getHelpers } from '../database/helpers/index.js';
 import emitter from '../emitter.js';
 import { validateAccess } from '../permissions/modules/validate-access/validate-access.js';
 import { shouldClearCache } from '../utils/should-clear-cache.js';
+import { splitRecursive } from '../utils/versioning/split-recursive.js';
 import { ActivityService } from './activity.js';
 import { ItemsService } from './items.js';
 import { PayloadService } from './payload.js';
 import { RevisionsService } from './revisions.js';
+import { deepMapWithSchema } from '../utils/versioning/deep-map-with-schema.js';
 export class VersionsService extends ItemsService {
     constructor(options) {
         super('directus_versions', options);
@@ -59,10 +62,10 @@ export class VersionsService extends ItemsService {
             knex: this.knex,
             schema: this.schema,
         });
-        const existingVersions = await sudoService.readByQuery({
+        const existingVersions = (await sudoService.readByQuery({
             aggregate: { count: ['*'] },
             filter: { key: { _eq: data['key'] }, collection: { _eq: data['collection'] }, item: { _eq: data['item'] } },
-        });
+        }));
         if (existingVersions[0]['count'] > 0) {
             throw new UnprocessableContentError({
                 reason: `Version "${data['key']}" already exists for item "${data['item']}" in collection "${data['collection']}"`,
@@ -82,21 +85,17 @@ export class VersionsService extends ItemsService {
         const mainHash = objectHash(mainItem);
         return { outdated: hash !== mainHash, mainHash };
     }
-    async getVersionSaves(key, collection, item) {
-        const filter = {
-            key: { _eq: key },
-            collection: { _eq: collection },
-        };
-        if (item) {
-            filter['item'] = { _eq: item };
-        }
-        const versions = await this.readByQuery({ filter });
-        if (!versions?.[0])
-            return null;
-        if (versions[0]['delta']) {
-            return [versions[0]['delta']];
-        }
-        return null;
+    async getVersionSave(key, collection, item, mapDelta = true) {
+        const version = (await this.readByQuery({
+            filter: {
+                key: { _eq: key },
+                collection: { _eq: collection },
+                item: { _eq: item },
+            },
+        }))[0];
+        if (mapDelta && version?.delta)
+            version.delta = this.mapDelta(version);
+        return version;
     }
     async createOne(data, opts) {
         await this.validateCreateData(data);
@@ -104,6 +103,12 @@ export class VersionsService extends ItemsService {
         data['hash'] = objectHash(mainItem);
         return super.createOne(data, opts);
     }
+    async readOne(key, query = {}, opts) {
+        const version = await super.readOne(key, query, opts);
+        if (version?.delta)
+            version.delta = this.mapDelta(version);
+        return version;
+    }
     async createMany(data, opts) {
         if (!Array.isArray(data)) {
             throw new InvalidPayloadError({ reason: 'Input should be an array of items' });
@@ -156,7 +161,7 @@ export class VersionsService extends ItemsService {
         }
         return super.updateMany(keys, data, opts);
     }
-    async save(key, data) {
+    async save(key, delta) {
         const version = await super.readOne(key);
         const payloadService = new PayloadService(this.collection, {
             accountability: this.accountability,
@@ -171,7 +176,7 @@ export class VersionsService extends ItemsService {
             knex: this.knex,
             schema: this.schema,
         });
-        const { item, collection } = version;
+        const { item, collection, delta: existingDelta } = version;
         const activity = await activityService.createOne({
             action: Action.VERSION_SAVE,
             user: this.accountability?.user ?? null,
@@ -181,7 +186,8 @@ export class VersionsService extends ItemsService {
             origin: this.accountability?.origin ?? null,
             item,
         });
-        const revisionDelta = await payloadService.prepareDelta(data);
+        const helpers = getHelpers(this.knex);
+        let revisionDelta = await payloadService.prepareDelta(delta);
         await revisionsService.createOne({
             activity,
             version: key,
@@ -190,10 +196,23 @@ export class VersionsService extends ItemsService {
             data: revisionDelta,
             delta: revisionDelta,
         });
-        const finalVersionDelta = assign({}, version['delta'], revisionDelta ? JSON.parse(revisionDelta) : null);
+        revisionDelta = revisionDelta ? JSON.parse(revisionDelta) : null;
+        const date = new Date(helpers.date.writeTimestamp(new Date().toISOString()));
+        deepMapObjects(revisionDelta, (object, path) => {
+            const existing = get(existingDelta, path);
+            if (existing && isEqual(existing, object))
+                return;
+            object['_user'] = this.accountability?.user;
+            object['_date'] = date;
+        });
+        const finalVersionDelta = assign({}, existingDelta, revisionDelta);
         const sudoService = new ItemsService(this.collection, {
             knex: this.knex,
             schema: this.schema,
+            accountability: {
+                ...this.accountability,
+                admin: true,
+            },
         });
         await sudoService.updateOne(key, { delta: finalVersionDelta });
         const { cache } = getCache();
@@ -203,7 +222,7 @@ export class VersionsService extends ItemsService {
         return finalVersionDelta;
     }
     async promote(version, mainHash, fields) {
-        const { collection, item, delta } = (await this.readOne(version));
+        const { collection, item, delta } = (await super.readOne(version));
         // will throw an error if the accountability does not have permission to update the item
         if (this.accountability) {
             await validateAccess({
@@ -227,7 +246,8 @@ export class VersionsService extends ItemsService {
                 reason: `Main item has changed since this version was last updated`,
             });
         }
-        const payloadToUpdate = fields ? pick(delta, fields) : delta;
+        const { rawDelta, defaultOverwrites } = splitRecursive(delta);
+        const payloadToUpdate = fields ? pick(rawDelta, fields) : rawDelta;
         const itemsService = new ItemsService(collection, {
             accountability: this.accountability,
             knex: this.knex,
@@ -242,7 +262,9 @@ export class VersionsService extends ItemsService {
             schema: this.schema,
             accountability: this.accountability,
         });
-        const updatedItemKey = await itemsService.updateOne(item, payloadAfterHooks);
+        const updatedItemKey = await itemsService.updateOne(item, payloadAfterHooks, {
+            overwriteDefaults: defaultOverwrites,
+        });
         emitter.emitAction(['items.promote', `${collection}.items.promote`], {
             payload: payloadAfterHooks,
             collection,
@@ -255,4 +277,41 @@ export class VersionsService extends ItemsService {
         });
         return updatedItemKey;
     }
+    mapDelta(version) {
+        const delta = version.delta ?? {};
+        delta[this.schema.collections[version.collection].primary] = version.item;
+        return deepMapWithSchema(delta, ([key, value], context) => {
+            if (key === '_user' || key === '_date')
+                return;
+            if (context.collection.primary in context.object) {
+                if (context.field.special.includes('user-updated')) {
+                    return [key, context.object['_user']];
+                }
+                if (context.field.special.includes('date-updated')) {
+                    return [key, context.object['_date']];
+                }
+            }
+            else {
+                if (context.field.special.includes('user-created')) {
+                    return [key, context.object['_user']];
+                }
+                if (context.field.special.includes('date-created')) {
+                    return [key, context.object['_date']];
+                }
+            }
+            if (key in context.object)
+                return [key, value];
+            return undefined;
+        }, { collection: version.collection, schema: this.schema }, { mapNonExistentFields: true, detailedUpdateSyntax: true });
+    }
+}
+/** Deeply maps all objects of a structure. Only calls the callback for objects, not for arrays. Objects in arrays will continued to be mapped. */
+function deepMapObjects(object, fn, path = []) {
+    if (isPlainObject(object) && typeof object === 'object' && object !== null) {
+        fn(object, path);
+        Object.entries(object).map(([key, value]) => deepMapObjects(value, fn, [...path, key]));
+    }
+    else if (Array.isArray(object)) {
+        object.map((value, index) => deepMapObjects(value, fn, [...path, String(index)]));
+    }
 }

package/dist/telemetry/lib/get-report.js

@@ -7,8 +7,8 @@ import { getExtensionCount } from '../utils/get-extension-count.js';
 import { getFieldCount } from '../utils/get-field-count.js';
 import { getFilesizeSum } from '../utils/get-filesize-sum.js';
 import { getItemCount } from '../utils/get-item-count.js';
+import { getSettings } from '../utils/get-settings.js';
 import { getUserItemCount } from '../utils/get-user-item-count.js';
-import { getProjectId } from '../utils/get-project-id.js';
 const basicCountTasks = [
     { collection: 'directus_dashboards' },
     { collection: 'directus_files' },
@@ -26,7 +26,7 @@ export const getReport = async () => {
     const db = getDatabase();
     const env = useEnv();
     const helpers = getHelpers(db);
-    const [basicCounts, userCounts, userItemCount, fieldsCounts, extensionsCounts, databaseSize, filesizes, projectId] = await Promise.all([
+    const [basicCounts, userCounts, userItemCount, fieldsCounts, extensionsCounts, databaseSize, filesizes, settings] = await Promise.all([
         getItemCount(db, basicCountTasks),
         fetchUserCount({ knex: db }),
         getUserItemCount(db),
@@ -34,7 +34,7 @@ export const getReport = async () => {
         getExtensionCount(db),
         helpers.schema.getDatabaseSize(),
         getFilesizeSum(db),
-        getProjectId(db),
+        getSettings(db),
     ]);
     return {
         url: env['PUBLIC_URL'],
@@ -55,6 +55,6 @@ export const getReport = async () => {
         extensions: extensionsCounts.totalEnabled,
         database_size: databaseSize ?? 0,
         files_size_total: filesizes.total,
-        project_id: projectId,
+        ...settings,
     };
 };

package/dist/telemetry/lib/send-report.d.ts

@@ -1,5 +1,10 @@
 import type { TelemetryReport } from '../types/report.js';
+import type { OwnerInformation } from '@directus/types';
+export type OwnerReport = OwnerInformation & {
+    project_id: string;
+    version: string;
+};
 /**
  * Post an anonymous usage report to the centralized intake server
  */
-export declare const sendReport: (report: TelemetryReport) => Promise<void>;
+export declare const sendReport: (report: TelemetryReport | OwnerReport) => Promise<void>;

package/dist/telemetry/lib/send-report.js

@@ -5,7 +5,9 @@ import { URL } from 'node:url';
  */
 export const sendReport = async (report) => {
     const env = useEnv();
-    const url = new URL('/v1/metrics', env['TELEMETRY_URL']);
+    const url = 'project_owner' in report
+        ? new URL('/v1/owner', String(env['COMPLIANCE_URL']))
+        : new URL('/v1/metrics', String(env['TELEMETRY_URL']));
     const headers = {
         'Content-Type': 'application/json',
     };

package/dist/telemetry/types/report.d.ts

@@ -74,5 +74,21 @@ export interface TelemetryReport {
     /**
      * Unique project identifier
      */
-    project_id?: string | null;
+    project_id: string;
+    /**
+     * Whether the project has enabled MCP
+     */
+    mcp_enabled: boolean;
+    /**
+     * Whether the project allows deletes in MCP
+     */
+    mcp_allow_deletes: boolean;
+    /**
+     * Whether the project has enabled MCP system prompt
+     */
+    mcp_system_prompt_enabled: boolean;
+    /**
+     * Number of Visual Editor URLs configured in the system
+     */
+    visual_editor_urls: number;
 }

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

@@ -0,0 +1,9 @@
+import type { Knex } from 'knex';
+export type TelemetrySettings = {
+    project_id: string;
+    mcp_enabled: boolean;
+    mcp_allow_deletes: boolean;
+    mcp_system_prompt_enabled: boolean;
+    visual_editor_urls: number;
+};
+export declare const getSettings: (db: Knex) => Promise<TelemetrySettings>;

package/dist/telemetry/utils/get-settings.js

@@ -0,0 +1,14 @@
+import { toBoolean } from '@directus/utils';
+export const getSettings = async (db) => {
+    const settings = await db
+        .select('project_id', 'mcp_enabled', 'mcp_allow_deletes', 'mcp_system_prompt_enabled', 'visual_editor_urls')
+        .from('directus_settings')
+        .first();
+    return {
+        project_id: settings.project_id,
+        mcp_enabled: toBoolean(settings?.mcp_enabled),
+        mcp_allow_deletes: toBoolean(settings?.mcp_allow_deletes),
+        mcp_system_prompt_enabled: toBoolean(settings?.mcp_system_prompt_enabled),
+        visual_editor_urls: settings.visual_editor_urls ? JSON.parse(settings.visual_editor_urls).length : 0,
+    };
+};