@directus/api 29.1.1 → 31.0.0

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

@@ -1,7 +1,5 @@
 import { parseFilterFunctionPath } from '@directus/utils';
 import { omit } from 'lodash-es';
-import { mergeVersionsRaw, mergeVersionsRecursive } from '../../../utils/merge-version-data.js';
-import { VersionsService } from '../../versions.js';
 import { parseArgs } from '../schema/parse-args.js';
 import { getQuery } from '../schema/parse-query.js';
 import { getAggregateQuery } from '../utils/aggregate-query.js';
@@ -19,7 +17,6 @@ export async function resolveQuery(gql, info) {
         return null;
     const args = parseArgs(info.fieldNodes[0].arguments || [], info.variableValues);
     let query;
-    let versionRaw = false;
     const isAggregate = collection.endsWith('_aggregated') && collection in gql.schema.collections === false;
     if (isAggregate) {
         query = await getAggregateQuery(args, selections, gql.schema, gql.accountability);
@@ -32,50 +29,18 @@ export async function resolveQuery(gql, info) {
         }
         if (collection.endsWith('_by_version') && collection in gql.schema.collections === false) {
             collection = collection.slice(0, -11);
-            versionRaw = true;
+            query.versionRaw = true;
         }
     }
-    if (args['id']) {
-        query.filter = {
-            _and: [
-                query.filter || {},
-                {
-                    [gql.schema.collections[collection].primary]: {
-                        _eq: args['id'],
-                    },
-                },
-            ],
-        };
-        query.limit = 1;
-    }
     // Transform count(a.b.c) into a.b.count(c)
     if (query.fields?.length) {
         for (let fieldIndex = 0; fieldIndex < query.fields.length; fieldIndex++) {
             query.fields[fieldIndex] = parseFilterFunctionPath(query.fields[fieldIndex]);
         }
     }
-    const result = await gql.read(collection, query);
-    if (args['version']) {
-        const versionsService = new VersionsService({ accountability: gql.accountability, schema: gql.schema });
-        const saves = await versionsService.getVersionSaves(args['version'], collection, args['id']);
-        if (saves) {
-            if (gql.schema.collections[collection].singleton) {
-                return versionRaw
-                    ? mergeVersionsRaw(result, saves)
-                    : mergeVersionsRecursive(result, saves, collection, gql.schema);
-            }
-            else {
-                if (result?.[0] === undefined)
-                    return null;
-                return versionRaw
-                    ? mergeVersionsRaw(result[0], saves)
-                    : mergeVersionsRecursive(result[0], saves, collection, gql.schema);
-            }
-        }
-    }
-    if (args['id']) {
-        return result?.[0] || null;
-    }
+    const result = await gql.read(collection, query, args['id']);
+    if (args['id'])
+        return result;
     if (query.group) {
         // for every entry in result add a group field based on query.group;
         const aggregateKeys = Object.keys(query.aggregate ?? {});

package/dist/services/items.js

@@ -18,6 +18,7 @@ import { shouldClearCache } from '../utils/should-clear-cache.js';
 import { transaction } from '../utils/transaction.js';
 import { validateKeys } from '../utils/validate-keys.js';
 import { validateUserCountIntegrity } from '../utils/validate-user-count-integrity.js';
+import { handleVersion } from '../utils/versioning/handle-version.js';
 import { PayloadService } from './payload.js';
 const env = useEnv();
 export class ItemsService {
@@ -96,8 +97,6 @@ export class ItemsService {
         if (!opts.bypassLimits) {
             opts.mutationTracker.trackMutations(1);
         }
-        const { ActivityService } = await import('./activity.js');
-        const { RevisionsService } = await import('./revisions.js');
         const primaryKeyField = this.schema.collections[this.collection].primary;
         const fields = Object.keys(this.schema.collections[this.collection].fields);
         const aliases = Object.values(this.schema.collections[this.collection].fields)
@@ -149,6 +148,7 @@ export class ItemsService {
                 knex: trx,
                 schema: this.schema,
                 nested: this.nested,
+                overwriteDefaults: opts.overwriteDefaults,
             });
             const { payload: payloadWithM2O, revisions: revisionsM2O, nestedActionEvents: nestedActionEventsM2O, userIntegrityCheckFlags: userIntegrityCheckFlagsM2O, } = await payloadService.processM2O(payloadWithPresets, opts);
             const { payload: payloadWithA2O, revisions: revisionsA2O, nestedActionEvents: nestedActionEventsA2O, userIntegrityCheckFlags: userIntegrityCheckFlagsA2O, } = await payloadService.processA2O(payloadWithM2O, opts);
@@ -226,7 +226,11 @@ export class ItemsService {
                 }
             }
             // If this is an authenticated action, and accountability tracking is enabled, save activity row
-            if (this.accountability && this.schema.collections[this.collection].accountability !== null) {
+            if (opts.skipTracking !== true &&
+                this.accountability &&
+                this.schema.collections[this.collection].accountability !== null) {
+                const { ActivityService } = await import('./activity.js');
+                const { RevisionsService } = await import('./revisions.js');
                 const activityService = new ActivityService({
                     knex: trx,
                     schema: this.schema,
@@ -267,6 +271,9 @@ export class ItemsService {
             if (autoIncrementSequenceNeedsToBeReset) {
                 await getHelpers(trx).sequence.resetAutoIncrementSequence(this.collection, primaryKeyField);
             }
+            if (opts.onItemCreate) {
+                opts.onItemCreate(this.collection, primaryKey);
+            }
             return primaryKey;
         });
         if (opts.emitEvents !== false) {
@@ -332,6 +339,7 @@ export class ItemsService {
                     onRequireUserIntegrityCheck: (flags) => (userIntegrityCheckFlags |= flags),
                     bypassEmitAction: (params) => nestedActionEvents.push(params),
                     mutationTracker: opts.mutationTracker,
+                    overwriteDefaults: opts.overwriteDefaults?.[index],
                     bypassAutoIncrementSequenceReset,
                 });
                 primaryKeys.push(primaryKey);
@@ -427,7 +435,13 @@ export class ItemsService {
         validateKeys(this.schema, this.collection, primaryKeyField, key);
         const filterWithKey = assign({}, query.filter, { [primaryKeyField]: { _eq: key } });
         const queryWithKey = assign({}, query, { filter: filterWithKey });
-        const results = await this.readByQuery(queryWithKey, opts);
+        let results = [];
+        if (query.version) {
+            results = [await handleVersion(this, key, queryWithKey, opts)];
+        }
+        else {
+            results = await this.readByQuery(queryWithKey, opts);
+        }
         if (results.length === 0) {
             throw new ForbiddenError();
         }
@@ -485,13 +499,15 @@ export class ItemsService {
             await transaction(this.knex, async (knex) => {
                 const service = this.fork({ knex });
                 let userIntegrityCheckFlags = opts.userIntegrityCheckFlags ?? UserIntegrityCheckFlag.None;
-                for (const item of data) {
+                for (const index in data) {
+                    const item = data[index];
                     const primaryKey = item[primaryKeyField];
                     if (!primaryKey)
                         throw new InvalidPayloadError({ reason: `Item in update misses primary key` });
                     const combinedOpts = {
                         autoPurgeCache: false,
                         ...opts,
+                        overwriteDefaults: opts.overwriteDefaults?.[index],
                         onRequireUserIntegrityCheck: (flags) => (userIntegrityCheckFlags |= flags),
                     };
                     keys.push(await service.updateOne(primaryKey, omit(item, primaryKeyField), combinedOpts));
@@ -522,8 +538,6 @@ export class ItemsService {
         if (!opts.bypassLimits) {
             opts.mutationTracker.trackMutations(keys.length);
         }
-        const { ActivityService } = await import('./activity.js');
-        const { RevisionsService } = await import('./revisions.js');
         const primaryKeyField = this.schema.collections[this.collection].primary;
         validateKeys(this.schema, this.collection, primaryKeyField, keys);
         const fields = Object.keys(this.schema.collections[this.collection].fields);
@@ -581,6 +595,7 @@ export class ItemsService {
                 knex: trx,
                 schema: this.schema,
                 nested: this.nested,
+                overwriteDefaults: opts.overwriteDefaults,
             });
             const { payload: payloadWithM2O, revisions: revisionsM2O, nestedActionEvents: nestedActionEventsM2O, userIntegrityCheckFlags: userIntegrityCheckFlagsM2O, } = await payloadService.processM2O(payloadWithPresets, opts);
             const { payload: payloadWithA2O, revisions: revisionsA2O, nestedActionEvents: nestedActionEventsA2O, userIntegrityCheckFlags: userIntegrityCheckFlagsA2O, } = await payloadService.processA2O(payloadWithM2O, opts);
@@ -616,7 +631,11 @@ export class ItemsService {
                 }
             }
             // If this is an authenticated action, and accountability tracking is enabled, save activity row
-            if (this.accountability && this.schema.collections[this.collection].accountability !== null) {
+            if (opts.skipTracking !== true &&
+                this.accountability &&
+                this.schema.collections[this.collection].accountability !== null) {
+                const { ActivityService } = await import('./activity.js');
+                const { RevisionsService } = await import('./revisions.js');
                 const activityService = new ActivityService({
                     knex: trx,
                     schema: this.schema,
@@ -738,8 +757,13 @@ export class ItemsService {
         const primaryKeys = await transaction(this.knex, async (knex) => {
             const service = this.fork({ knex });
             const primaryKeys = [];
-            for (const payload of payloads) {
-                const primaryKey = await service.upsertOne(payload, { ...(opts || {}), autoPurgeCache: false });
+            for (const index in payloads) {
+                const payload = payloads[index];
+                const primaryKey = await service.upsertOne(payload, {
+                    ...(opts || {}),
+                    overwriteDefaults: opts.overwriteDefaults?.[index],
+                    autoPurgeCache: false,
+                });
                 primaryKeys.push(primaryKey);
             }
             return primaryKeys;
@@ -780,7 +804,6 @@ export class ItemsService {
         if (!opts.bypassLimits) {
             opts.mutationTracker.trackMutations(keys.length);
         }
-        const { ActivityService } = await import('./activity.js');
         const primaryKeyField = this.schema.collections[this.collection].primary;
         validateKeys(this.schema, this.collection, primaryKeyField, keys);
         if (this.accountability) {
@@ -816,7 +839,10 @@ export class ItemsService {
                     await validateUserCountIntegrity({ flags: opts.userIntegrityCheckFlags, knex: trx });
                 }
             }
-            if (this.accountability && this.schema.collections[this.collection].accountability !== null) {
+            if (opts.skipTracking !== true &&
+                this.accountability &&
+                this.schema.collections[this.collection].accountability !== null) {
+                const { ActivityService } = await import('./activity.js');
                 const activityService = new ActivityService({
                     knex: trx,
                     schema: this.schema,

package/dist/services/payload.d.ts

@@ -1,4 +1,4 @@
-import type { AbstractServiceOptions, Accountability, Aggregate, FieldOverview, Item, MutationOptions, PayloadAction, PayloadServiceProcessRelationResult, PrimaryKey, SchemaOverview } from '@directus/types';
+import type { AbstractServiceOptions, Accountability, Aggregate, DefaultOverwrite, FieldOverview, Item, MutationOptions, PayloadAction, PayloadServiceProcessRelationResult, PrimaryKey, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 import type { Helpers } from '../database/helpers/index.js';
 type Transformers = {
@@ -9,6 +9,7 @@ type Transformers = {
         accountability: Accountability | null;
         specials: string[];
         helpers: Helpers;
+        overwriteDefaults: DefaultOverwrite | undefined;
     }) => Promise<any>;
 };
 /**
@@ -22,7 +23,10 @@ export declare class PayloadService {
     collection: string;
     schema: SchemaOverview;
     nested: string[];
-    constructor(collection: string, options: AbstractServiceOptions);
+    overwriteDefaults: DefaultOverwrite | undefined;
+    constructor(collection: string, options: AbstractServiceOptions & {
+        overwriteDefaults?: DefaultOverwrite | undefined;
+    });
     transformers: Transformers;
     processValues(action: PayloadAction, payloads: Partial<Item>[]): Promise<Partial<Item>[]>;
     processValues(action: PayloadAction, payload: Partial<Item>): Promise<Partial<Item>>;
@@ -62,6 +66,6 @@ export declare class PayloadService {
      * Transforms the input partial payload to match the output structure, to have consistency
      * between delta and data
      */
-    prepareDelta(data: Partial<Item>): Promise<string | null>;
+    prepareDelta(delta: Partial<Item>): Promise<string | null>;
 }
 export {};

package/dist/services/payload.js

@@ -21,6 +21,7 @@ export class PayloadService {
     collection;
     schema;
     nested;
+    overwriteDefaults;
     constructor(collection, options) {
         this.accountability = options.accountability || null;
         this.knex = options.knex || getDatabase();
@@ -28,6 +29,7 @@ export class PayloadService {
         this.collection = collection;
         this.schema = options.schema;
         this.nested = options.nested ?? [];
+        this.overwriteDefaults = options.overwriteDefaults;
         return this;
     }
     transformers = {
@@ -77,14 +79,14 @@ export class PayloadService {
                 return value ? '**********' : null;
             return value;
         },
-        async 'user-created'({ action, value, accountability }) {
+        async 'user-created'({ action, value, accountability, overwriteDefaults }) {
             if (action === 'create')
-                return accountability?.user || null;
+                return (overwriteDefaults ? overwriteDefaults._user : accountability?.user) ?? null;
             return value;
         },
-        async 'user-updated'({ action, value, accountability }) {
+        async 'user-updated'({ action, value, accountability, overwriteDefaults }) {
             if (action === 'update')
-                return accountability?.user || null;
+                return (overwriteDefaults ? overwriteDefaults._user : accountability?.user) ?? null;
             return value;
         },
         async 'role-created'({ action, value, accountability }) {
@@ -97,14 +99,14 @@ export class PayloadService {
                 return accountability?.role || null;
             return value;
         },
-        async 'date-created'({ action, value, helpers }) {
+        async 'date-created'({ action, value, helpers, overwriteDefaults }) {
             if (action === 'create')
-                return new Date(helpers.date.writeTimestamp(new Date().toISOString()));
+                return new Date(overwriteDefaults ? overwriteDefaults._date : helpers.date.writeTimestamp(new Date().toISOString()));
             return value;
         },
-        async 'date-updated'({ action, value, helpers }) {
+        async 'date-updated'({ action, value, helpers, overwriteDefaults }) {
             if (action === 'update')
-                return new Date(helpers.date.writeTimestamp(new Date().toISOString()));
+                return new Date(overwriteDefaults ? overwriteDefaults._date : helpers.date.writeTimestamp(new Date().toISOString()));
             return value;
         },
         async 'cast-csv'({ action, value }) {
@@ -212,6 +214,7 @@ export class PayloadService {
                     accountability,
                     specials: fieldSpecials,
                     helpers: this.helpers,
+                    overwriteDefaults: this.overwriteDefaults,
                 });
             }
         }
@@ -402,6 +405,11 @@ export class PayloadService {
                         onRequireUserIntegrityCheck: (flags) => (userIntegrityCheckFlags |= flags),
                         bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params),
                         emitEvents: opts?.emitEvents,
+                        autoPurgeCache: opts?.autoPurgeCache,
+                        autoPurgeSystemCache: opts?.autoPurgeSystemCache,
+                        skipTracking: opts?.skipTracking,
+                        overwriteDefaults: opts?.overwriteDefaults?.[relation.field],
+                        onItemCreate: opts?.onItemCreate,
                         mutationTracker: opts?.mutationTracker,
                     });
                 }
@@ -412,6 +420,11 @@ export class PayloadService {
                     onRequireUserIntegrityCheck: (flags) => (userIntegrityCheckFlags |= flags),
                     bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params),
                     emitEvents: opts?.emitEvents,
+                    autoPurgeCache: opts?.autoPurgeCache,
+                    autoPurgeSystemCache: opts?.autoPurgeSystemCache,
+                    skipTracking: opts?.skipTracking,
+                    overwriteDefaults: opts?.overwriteDefaults?.[relation.field],
+                    onItemCreate: opts?.onItemCreate,
                     mutationTracker: opts?.mutationTracker,
                 });
             }
@@ -468,6 +481,11 @@ export class PayloadService {
                         onRequireUserIntegrityCheck: (flags) => (userIntegrityCheckFlags |= flags),
                         bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params),
                         emitEvents: opts?.emitEvents,
+                        autoPurgeCache: opts?.autoPurgeCache,
+                        autoPurgeSystemCache: opts?.autoPurgeSystemCache,
+                        skipTracking: opts?.skipTracking,
+                        overwriteDefaults: opts?.overwriteDefaults?.[relation.field],
+                        onItemCreate: opts?.onItemCreate,
                         mutationTracker: opts?.mutationTracker,
                     });
                 }
@@ -478,6 +496,11 @@ export class PayloadService {
                     onRequireUserIntegrityCheck: (flags) => (userIntegrityCheckFlags |= flags),
                     bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params),
                     emitEvents: opts?.emitEvents,
+                    autoPurgeCache: opts?.autoPurgeCache,
+                    autoPurgeSystemCache: opts?.autoPurgeSystemCache,
+                    skipTracking: opts?.skipTracking,
+                    overwriteDefaults: opts?.overwriteDefaults?.[relation.field],
+                    onItemCreate: opts?.onItemCreate,
                     mutationTracker: opts?.mutationTracker,
                 });
             }
@@ -570,6 +593,11 @@ export class PayloadService {
                     onRequireUserIntegrityCheck: (flags) => (userIntegrityCheckFlags |= flags),
                     bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params),
                     emitEvents: opts?.emitEvents,
+                    autoPurgeCache: opts?.autoPurgeCache,
+                    autoPurgeSystemCache: opts?.autoPurgeSystemCache,
+                    skipTracking: opts?.skipTracking,
+                    overwriteDefaults: opts?.overwriteDefaults?.[relation.meta.one_field],
+                    onItemCreate: opts?.onItemCreate,
                     mutationTracker: opts?.mutationTracker,
                 })));
                 const query = {
@@ -596,6 +624,11 @@ export class PayloadService {
                         onRequireUserIntegrityCheck: (flags) => (userIntegrityCheckFlags |= flags),
                         bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params),
                         emitEvents: opts?.emitEvents,
+                        autoPurgeCache: opts?.autoPurgeCache,
+                        autoPurgeSystemCache: opts?.autoPurgeSystemCache,
+                        skipTracking: opts?.skipTracking,
+                        overwriteDefaults: opts?.overwriteDefaults?.[relation.meta.one_field],
+                        onItemCreate: opts?.onItemCreate,
                         mutationTracker: opts?.mutationTracker,
                     });
                 }
@@ -605,6 +638,11 @@ export class PayloadService {
                         onRequireUserIntegrityCheck: (flags) => (userIntegrityCheckFlags |= flags),
                         bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params),
                         emitEvents: opts?.emitEvents,
+                        autoPurgeCache: opts?.autoPurgeCache,
+                        autoPurgeSystemCache: opts?.autoPurgeSystemCache,
+                        skipTracking: opts?.skipTracking,
+                        overwriteDefaults: opts?.overwriteDefaults?.[relation.meta.one_field],
+                        onItemCreate: opts?.onItemCreate,
                         mutationTracker: opts?.mutationTracker,
                     });
                 }
@@ -648,12 +686,17 @@ export class PayloadService {
                         onRequireUserIntegrityCheck: (flags) => (userIntegrityCheckFlags |= flags),
                         bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params),
                         emitEvents: opts?.emitEvents,
+                        autoPurgeCache: opts?.autoPurgeCache,
+                        autoPurgeSystemCache: opts?.autoPurgeSystemCache,
+                        skipTracking: opts?.skipTracking,
+                        overwriteDefaults: opts?.overwriteDefaults?.[relation.meta.one_field]?.['create'],
+                        onItemCreate: opts?.onItemCreate,
                         mutationTracker: opts?.mutationTracker,
                     });
                 }
                 if (alterations.update) {
-                    for (const item of alterations.update) {
-                        const { [relatedPrimaryKeyField]: key, ...record } = item;
+                    for (const index in alterations.update) {
+                        const { [relatedPrimaryKeyField]: key, ...record } = alterations.update[index];
                         const existingRecord = await this.knex
                             .select(relatedPrimaryKeyField, relation.field)
                             .from(relation.collection)
@@ -667,6 +710,11 @@ export class PayloadService {
                             onRequireUserIntegrityCheck: (flags) => (userIntegrityCheckFlags |= flags),
                             bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params),
                             emitEvents: opts?.emitEvents,
+                            autoPurgeCache: opts?.autoPurgeCache,
+                            autoPurgeSystemCache: opts?.autoPurgeSystemCache,
+                            skipTracking: opts?.skipTracking,
+                            overwriteDefaults: opts?.overwriteDefaults?.[relation.meta.one_field]?.['update'][index],
+                            onItemCreate: opts?.onItemCreate,
                             mutationTracker: opts?.mutationTracker,
                         });
                     }
@@ -694,6 +742,11 @@ export class PayloadService {
                             onRequireUserIntegrityCheck: (flags) => (userIntegrityCheckFlags |= flags),
                             bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params),
                             emitEvents: opts?.emitEvents,
+                            autoPurgeCache: opts?.autoPurgeCache,
+                            autoPurgeSystemCache: opts?.autoPurgeSystemCache,
+                            skipTracking: opts?.skipTracking,
+                            overwriteDefaults: opts?.overwriteDefaults?.[relation.meta.one_field]?.['delete'],
+                            onItemCreate: opts?.onItemCreate,
                             mutationTracker: opts?.mutationTracker,
                         });
                     }
@@ -703,6 +756,11 @@ export class PayloadService {
                             onRequireUserIntegrityCheck: (flags) => (userIntegrityCheckFlags |= flags),
                             bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params),
                             emitEvents: opts?.emitEvents,
+                            autoPurgeCache: opts?.autoPurgeCache,
+                            autoPurgeSystemCache: opts?.autoPurgeSystemCache,
+                            skipTracking: opts?.skipTracking,
+                            overwriteDefaults: opts?.overwriteDefaults?.[relation.meta.one_field]?.['delete'],
+                            onItemCreate: opts?.onItemCreate,
                             mutationTracker: opts?.mutationTracker,
                         });
                     }
@@ -715,8 +773,8 @@ export class PayloadService {
      * Transforms the input partial payload to match the output structure, to have consistency
      * between delta and data
      */
-    async prepareDelta(data) {
-        let payload = cloneDeep(data);
+    async prepareDelta(delta) {
+        let payload = cloneDeep(delta);
         for (const key in payload) {
             if (payload[key]?.isRawInstance) {
                 payload[key] = payload[key].bindings[0];

package/dist/services/server.js

@@ -53,6 +53,7 @@ export class ServerService {
             ],
         });
         info['project'] = projectInfo;
+        info['mcp_enabled'] = toBoolean(env['MCP_ENABLED'] ?? true);
         if (this.accountability?.user) {
             if (env['RATE_LIMITER_ENABLED']) {
                 info['rateLimit'] = {

package/dist/services/tfa.d.ts

@@ -6,7 +6,7 @@ export declare class TFAService {
     itemsService: ItemsService;
     constructor(options: AbstractServiceOptions);
     verifyOTP(key: PrimaryKey, otp: string, secret?: string): Promise<boolean>;
-    generateTFA(key: PrimaryKey): Promise<Record<string, string>>;
+    generateTFA(key: PrimaryKey, requiresPassword?: boolean): Promise<Record<string, string>>;
     enableTFA(key: PrimaryKey, otp: string, secret: string): Promise<void>;
     disableTFA(key: PrimaryKey): Promise<void>;
 }

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/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;
 }