@directus/api 30.0.0 → 31.0.0

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,
                 });
             }
         }
@@ -405,6 +408,7 @@ export class PayloadService {
                         autoPurgeCache: opts?.autoPurgeCache,
                         autoPurgeSystemCache: opts?.autoPurgeSystemCache,
                         skipTracking: opts?.skipTracking,
+                        overwriteDefaults: opts?.overwriteDefaults?.[relation.field],
                         onItemCreate: opts?.onItemCreate,
                         mutationTracker: opts?.mutationTracker,
                     });
@@ -419,6 +423,7 @@ export class PayloadService {
                     autoPurgeCache: opts?.autoPurgeCache,
                     autoPurgeSystemCache: opts?.autoPurgeSystemCache,
                     skipTracking: opts?.skipTracking,
+                    overwriteDefaults: opts?.overwriteDefaults?.[relation.field],
                     onItemCreate: opts?.onItemCreate,
                     mutationTracker: opts?.mutationTracker,
                 });
@@ -479,6 +484,7 @@ export class PayloadService {
                         autoPurgeCache: opts?.autoPurgeCache,
                         autoPurgeSystemCache: opts?.autoPurgeSystemCache,
                         skipTracking: opts?.skipTracking,
+                        overwriteDefaults: opts?.overwriteDefaults?.[relation.field],
                         onItemCreate: opts?.onItemCreate,
                         mutationTracker: opts?.mutationTracker,
                     });
@@ -493,6 +499,7 @@ export class PayloadService {
                     autoPurgeCache: opts?.autoPurgeCache,
                     autoPurgeSystemCache: opts?.autoPurgeSystemCache,
                     skipTracking: opts?.skipTracking,
+                    overwriteDefaults: opts?.overwriteDefaults?.[relation.field],
                     onItemCreate: opts?.onItemCreate,
                     mutationTracker: opts?.mutationTracker,
                 });
@@ -589,6 +596,7 @@ export class PayloadService {
                     autoPurgeCache: opts?.autoPurgeCache,
                     autoPurgeSystemCache: opts?.autoPurgeSystemCache,
                     skipTracking: opts?.skipTracking,
+                    overwriteDefaults: opts?.overwriteDefaults?.[relation.meta.one_field],
                     onItemCreate: opts?.onItemCreate,
                     mutationTracker: opts?.mutationTracker,
                 })));
@@ -619,6 +627,7 @@ export class PayloadService {
                         autoPurgeCache: opts?.autoPurgeCache,
                         autoPurgeSystemCache: opts?.autoPurgeSystemCache,
                         skipTracking: opts?.skipTracking,
+                        overwriteDefaults: opts?.overwriteDefaults?.[relation.meta.one_field],
                         onItemCreate: opts?.onItemCreate,
                         mutationTracker: opts?.mutationTracker,
                     });
@@ -632,6 +641,7 @@ export class PayloadService {
                         autoPurgeCache: opts?.autoPurgeCache,
                         autoPurgeSystemCache: opts?.autoPurgeSystemCache,
                         skipTracking: opts?.skipTracking,
+                        overwriteDefaults: opts?.overwriteDefaults?.[relation.meta.one_field],
                         onItemCreate: opts?.onItemCreate,
                         mutationTracker: opts?.mutationTracker,
                     });
@@ -679,13 +689,14 @@ export class PayloadService {
                         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)
@@ -702,6 +713,7 @@ export class PayloadService {
                             autoPurgeCache: opts?.autoPurgeCache,
                             autoPurgeSystemCache: opts?.autoPurgeSystemCache,
                             skipTracking: opts?.skipTracking,
+                            overwriteDefaults: opts?.overwriteDefaults?.[relation.meta.one_field]?.['update'][index],
                             onItemCreate: opts?.onItemCreate,
                             mutationTracker: opts?.mutationTracker,
                         });
@@ -733,6 +745,7 @@ export class PayloadService {
                             autoPurgeCache: opts?.autoPurgeCache,
                             autoPurgeSystemCache: opts?.autoPurgeSystemCache,
                             skipTracking: opts?.skipTracking,
+                            overwriteDefaults: opts?.overwriteDefaults?.[relation.meta.one_field]?.['delete'],
                             onItemCreate: opts?.onItemCreate,
                             mutationTracker: opts?.mutationTracker,
                         });
@@ -746,6 +759,7 @@ export class PayloadService {
                             autoPurgeCache: opts?.autoPurgeCache,
                             autoPurgeSystemCache: opts?.autoPurgeSystemCache,
                             skipTracking: opts?.skipTracking,
+                            overwriteDefaults: opts?.overwriteDefaults?.[relation.meta.one_field]?.['delete'],
                             onItemCreate: opts?.onItemCreate,
                             mutationTracker: opts?.mutationTracker,
                         });
@@ -759,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;
 }

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

@@ -27,10 +27,11 @@ export interface Session {
 export type DirectusTokenPayload = {
     id?: string;
     role: string | null;
-    session?: string;
     app_access: boolean | number;
     admin_access: boolean | number;
     share?: string;
+    session?: string;
+    enforce_tfa?: boolean;
 };
 export type ShareData = {
     share_id: string;

package/dist/utils/versioning/deep-map-with-schema.d.ts

@@ -0,0 +1,23 @@
+import type { CollectionOverview, FieldOverview, Relation, SchemaOverview } from '@directus/types';
+import { type RelationInfo } from '../get-relation-info.js';
+/**
+ * Allows to deep map the data like a response or delta changes with collection, field and relation context for each entry.
+ * Bottom to Top depth first mapping of values.
+ */
+export declare function deepMapWithSchema(object: Record<string, any>, callback: (entry: [key: string | number, value: unknown], context: {
+    collection: CollectionOverview;
+    field: FieldOverview;
+    relation: Relation | null;
+    leaf: boolean;
+    relationType: RelationInfo['relationType'] | null;
+    object: Record<string, any>;
+}) => [key: string | number, value: unknown] | undefined, context: {
+    schema: SchemaOverview;
+    collection: string;
+    relationInfo?: RelationInfo;
+}, options?: {
+    /** If set to true, non-existent fields will be included in the mapping and will have a value of undefined */
+    mapNonExistentFields?: boolean;
+    /** If set to true, it will map the "create", "update" and "delete" syntax for o2m relations found in deltas */
+    detailedUpdateSyntax?: boolean;
+}): any;

package/dist/utils/versioning/deep-map-with-schema.js

@@ -0,0 +1,81 @@
+import { isPlainObject } from 'lodash-es';
+import assert from 'node:assert';
+import { getRelationInfo } from '../get-relation-info.js';
+import { InvalidQueryError } from '@directus/errors';
+/**
+ * Allows to deep map the data like a response or delta changes with collection, field and relation context for each entry.
+ * Bottom to Top depth first mapping of values.
+ */
+export function deepMapWithSchema(object, callback, context, options) {
+    const collection = context.schema.collections[context.collection];
+    assert(isPlainObject(object) && typeof object === 'object' && object !== null, `DeepMapResponse only works on objects, received ${JSON.stringify(object)}`);
+    let fields;
+    if (options?.mapNonExistentFields) {
+        fields = Object.entries(collection.fields);
+    }
+    else {
+        fields = Object.keys(object).map((key) => [key, collection.fields[key]]);
+    }
+    return Object.fromEntries(fields
+        .map(([key, field]) => {
+        let value = object[key];
+        if (!field)
+            return [key, value];
+        const relationInfo = getRelationInfo(context.schema.relations, collection.collection, field.field);
+        let leaf = true;
+        if (relationInfo.relation && typeof value === 'object' && value !== null && isPlainObject(object)) {
+            switch (relationInfo.relationType) {
+                case 'm2o':
+                    value = deepMapWithSchema(value, callback, {
+                        schema: context.schema,
+                        collection: relationInfo.relation.related_collection,
+                        relationInfo,
+                    }, options);
+                    leaf = false;
+                    break;
+                case 'o2m': {
+                    function map(childValue) {
+                        if (isPlainObject(childValue) && typeof childValue === 'object' && childValue !== null) {
+                            leaf = false;
+                            return deepMapWithSchema(childValue, callback, {
+                                schema: context.schema,
+                                collection: relationInfo.relation.collection,
+                                relationInfo,
+                            }, options);
+                        }
+                        else
+                            return childValue;
+                    }
+                    if (Array.isArray(value)) {
+                        value = value.map(map);
+                    }
+                    else if (options?.detailedUpdateSyntax && isPlainObject(value)) {
+                        value = {
+                            create: value['create']?.map(map),
+                            update: value['update']?.map(map),
+                            delete: value['delete']?.map(map),
+                        };
+                    }
+                    break;
+                }
+                case 'a2o': {
+                    const related_collection = object[relationInfo.relation.meta.one_collection_field];
+                    if (!related_collection) {
+                        throw new InvalidQueryError({
+                            reason: `When selecting '${collection.collection}.${field.field}', the field '${collection.collection}.${relationInfo.relation.meta.one_collection_field}' has to be selected when using versioning and m2a relations `,
+                        });
+                    }
+                    value = deepMapWithSchema(value, callback, {
+                        schema: context.schema,
+                        collection: related_collection,
+                        relationInfo,
+                    }, options);
+                    leaf = false;
+                    break;
+                }
+            }
+        }
+        return callback([key, value], { collection, field, ...relationInfo, leaf, object });
+    })
+        .filter((f) => f));
+}

package/dist/utils/versioning/handle-version.d.ts

@@ -1,3 +1,3 @@
-import type { Item, PrimaryKey, Query, QueryOptions } from '@directus/types';
+import type { PrimaryKey, Query, QueryOptions } from '@directus/types';
 import type { ItemsService as ItemsServiceType } from '../../services/index.js';
-export declare function handleVersion(self: ItemsServiceType, key: PrimaryKey, queryWithKey: Query, opts?: QueryOptions): Promise<(Item | undefined)[]>;
+export declare function handleVersion(self: ItemsServiceType, key: PrimaryKey, queryWithKey: Query, opts?: QueryOptions): Promise<any>;