@directus/api 29.1.1 → 30.0.0

package/dist/constants.d.ts

@@ -6,7 +6,7 @@ export declare const FILTER_VARIABLES: string[];
 export declare const ALIAS_TYPES: string[];
 export declare const DEFAULT_AUTH_PROVIDER = "default";
 export declare const COLUMN_TRANSFORMS: string[];
-export declare const GENERATE_SPECIAL: readonly ["uuid", "date-created", "role-created", "user-created"];
+export declare const GENERATE_SPECIAL: readonly ["uuid", "date-created", "date-updated", "role-created", "role-updated", "user-created", "user-updated"];
 export declare const UUID_REGEX = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
 export declare const REFRESH_COOKIE_OPTIONS: CookieOptions;
 export declare const SESSION_COOKIE_OPTIONS: CookieOptions;

package/dist/constants.js

@@ -51,7 +51,15 @@ export const FILTER_VARIABLES = ['$NOW', '$CURRENT_USER', '$CURRENT_ROLE'];
 export const ALIAS_TYPES = ['alias', 'o2m', 'm2m', 'm2a', 'o2a', 'files', 'translations'];
 export const DEFAULT_AUTH_PROVIDER = 'default';
 export const COLUMN_TRANSFORMS = ['year', 'month', 'day', 'weekday', 'hour', 'minute', 'second'];
-export const GENERATE_SPECIAL = ['uuid', 'date-created', 'role-created', 'user-created'];
+export const GENERATE_SPECIAL = [
+    'uuid',
+    'date-created',
+    'date-updated',
+    'role-created',
+    'role-updated',
+    'user-created',
+    'user-updated',
+];
 export const UUID_REGEX = '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}';
 export const REFRESH_COOKIE_OPTIONS = {
     httpOnly: true,

package/dist/controllers/items.js

@@ -2,7 +2,6 @@ import { ErrorCode, ForbiddenError, RouteNotFoundError, isDirectusError } from '
 import { isSystemCollection } from '@directus/system-data';
 import express from 'express';
 import collectionExists from '../middleware/collection-exists.js';
-import { mergeContentVersions } from '../middleware/merge-content-versions.js';
 import { respond } from '../middleware/respond.js';
 import { validateBatch } from '../middleware/validate-batch.js';
 import { ItemsService } from '../services/items.js';
@@ -75,8 +74,8 @@ const readHandler = asyncHandler(async (req, res, next) => {
     };
     return next();
 });
-router.search('/:collection', collectionExists, validateBatch('read'), readHandler, mergeContentVersions, respond);
-router.get('/:collection', collectionExists, readHandler, mergeContentVersions, respond);
+router.search('/:collection', collectionExists, validateBatch('read'), readHandler, respond);
+router.get('/:collection', collectionExists, readHandler, respond);
 router.get('/:collection/:pk', collectionExists, asyncHandler(async (req, res, next) => {
     if (isSystemCollection(req.params['collection']))
         throw new ForbiddenError();
@@ -89,7 +88,7 @@ router.get('/:collection/:pk', collectionExists, asyncHandler(async (req, res, n
         data: result || null,
     };
     return next();
-}), mergeContentVersions, respond);
+}), respond);
 router.patch('/:collection', collectionExists, validateBatch('update'), asyncHandler(async (req, res, next) => {
     if (isSystemCollection(req.params['collection']))
         throw new ForbiddenError();

package/dist/mailer.js

@@ -19,11 +19,11 @@ export default function getMailer() {
         });
     }
     else if (transportName === 'ses') {
-        const aws = require('@aws-sdk/client-ses');
+        const { SESv2Client, SendEmailCommand } = require('@aws-sdk/client-sesv2');
         const sesOptions = getConfigFromEnv('EMAIL_SES_');
-        const ses = new aws.SES(sesOptions);
+        const sesClient = new SESv2Client(sesOptions);
         transporter = nodemailer.createTransport({
-            SES: { ses, aws },
+            SES: { sesClient, SendEmailCommand },
         });
     }
     else if (transportName === 'smtp') {

package/dist/middleware/respond.js

@@ -10,7 +10,7 @@ import { getCacheKey } from '../utils/get-cache-key.js';
 import { getDateFormatted } from '../utils/get-date-formatted.js';
 import { getMilliseconds } from '../utils/get-milliseconds.js';
 import { stringByteSize } from '../utils/get-string-byte-size.js';
-import { permissionsCachable } from '../utils/permissions-cachable.js';
+import { permissionsCacheable } from '../utils/permissions-cacheable.js';
 export const respond = asyncHandler(async (req, res) => {
     const env = useEnv();
     const logger = useLogger();
@@ -29,7 +29,7 @@ export const respond = asyncHandler(async (req, res) => {
         !req.sanitizedQuery.export &&
         res.locals['cache'] !== false &&
         exceedsMaxSize === false &&
-        (await permissionsCachable(req.collection, {
+        (await permissionsCacheable(req.collection, {
             knex: getDatabase(),
             schema: req.schema,
         }, req.accountability))) {

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

@@ -1,4 +1,4 @@
-import type { AbstractServiceOptions, Accountability, GraphQLParams, GQLScope, Item, Query, SchemaOverview } from '@directus/types';
+import type { AbstractServiceOptions, Accountability, GraphQLParams, GQLScope, Item, Query, SchemaOverview, PrimaryKey } from '@directus/types';
 import type { FormattedExecutionResult, GraphQLSchema } from 'graphql';
 import type { Knex } from 'knex';
 export declare class GraphQLService {
@@ -22,7 +22,7 @@ export declare class GraphQLService {
     /**
      * Execute the read action on the correct service. Checks for singleton as well.
      */
-    read(collection: string, query: Query): Promise<Partial<Item>>;
+    read(collection: string, query: Query, id?: PrimaryKey): Promise<Partial<Item>>;
     /**
      * Upsert and read singleton item
      */

package/dist/services/graphql/index.js

@@ -61,16 +61,17 @@ export class GraphQLService {
     /**
      * Execute the read action on the correct service. Checks for singleton as well.
      */
-    async read(collection, query) {
+    async read(collection, query, id) {
         const service = getService(collection, {
             knex: this.knex,
             accountability: this.accountability,
             schema: this.schema,
         });
-        const result = this.schema.collections[collection].singleton
-            ? await service.readSingleton(query, { stripNonRequested: false })
-            : await service.readByQuery(query, { stripNonRequested: false });
-        return result;
+        if (this.schema.collections[collection].singleton)
+            return await service.readSingleton(query, { stripNonRequested: false });
+        if (id)
+            return await service.readOne(id, query, { stripNonRequested: false });
+        return await service.readByQuery(query, { stripNonRequested: false });
     }
     /**
      * Upsert and read singleton item

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)
@@ -226,7 +225,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 +270,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) {
@@ -427,7 +433,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();
         }
@@ -522,8 +534,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);
@@ -616,7 +626,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,
@@ -780,7 +794,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 +829,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.js

@@ -402,6 +402,10 @@ 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,
+                        onItemCreate: opts?.onItemCreate,
                         mutationTracker: opts?.mutationTracker,
                     });
                 }
@@ -412,6 +416,10 @@ 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,
+                    onItemCreate: opts?.onItemCreate,
                     mutationTracker: opts?.mutationTracker,
                 });
             }
@@ -468,6 +476,10 @@ 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,
+                        onItemCreate: opts?.onItemCreate,
                         mutationTracker: opts?.mutationTracker,
                     });
                 }
@@ -478,6 +490,10 @@ 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,
+                    onItemCreate: opts?.onItemCreate,
                     mutationTracker: opts?.mutationTracker,
                 });
             }
@@ -570,6 +586,10 @@ 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,
+                    onItemCreate: opts?.onItemCreate,
                     mutationTracker: opts?.mutationTracker,
                 })));
                 const query = {
@@ -596,6 +616,10 @@ 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,
+                        onItemCreate: opts?.onItemCreate,
                         mutationTracker: opts?.mutationTracker,
                     });
                 }
@@ -605,6 +629,10 @@ 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,
+                        onItemCreate: opts?.onItemCreate,
                         mutationTracker: opts?.mutationTracker,
                     });
                 }
@@ -648,6 +676,10 @@ 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,
+                        onItemCreate: opts?.onItemCreate,
                         mutationTracker: opts?.mutationTracker,
                     });
                 }
@@ -667,6 +699,10 @@ 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,
+                            onItemCreate: opts?.onItemCreate,
                             mutationTracker: opts?.mutationTracker,
                         });
                     }
@@ -694,6 +730,10 @@ 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,
+                            onItemCreate: opts?.onItemCreate,
                             mutationTracker: opts?.mutationTracker,
                         });
                     }
@@ -703,6 +743,10 @@ 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,
+                            onItemCreate: opts?.onItemCreate,
                             mutationTracker: opts?.mutationTracker,
                         });
                     }

package/dist/utils/deep-map-response.d.ts

@@ -0,0 +1,17 @@
+import type { CollectionOverview, FieldOverview, Relation, SchemaOverview } from '@directus/types';
+import { type RelationInfo } from './get-relation-info.js';
+/**
+ * Allows to deep map the response from the ItemsService with collection, field and relation context for each entry.
+ * Bottom to Top depth first mapping of values.
+ */
+export declare function deepMapResponse(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;
+}) => [key: string | number, value: unknown], context: {
+    schema: SchemaOverview;
+    collection: string;
+    relationInfo?: RelationInfo;
+}): any;

package/dist/utils/deep-map-response.js

@@ -0,0 +1,61 @@
+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 response from the ItemsService with collection, field and relation context for each entry.
+ * Bottom to Top depth first mapping of values.
+ */
+export function deepMapResponse(object, callback, context) {
+    const collection = context.schema.collections[context.collection];
+    assert(isPlainObject(object) && typeof object === 'object' && object !== null, `DeepMapResponse only works on objects, received ${JSON.stringify(object)}`);
+    return Object.fromEntries(Object.entries(object).map(([key, value]) => {
+        const field = collection?.fields[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 = deepMapResponse(value, callback, {
+                        schema: context.schema,
+                        collection: relationInfo.relation.related_collection,
+                        relationInfo,
+                    });
+                    leaf = false;
+                    break;
+                case 'o2m':
+                    value = value.map((childValue) => {
+                        if (isPlainObject(childValue) && typeof childValue === 'object' && childValue !== null) {
+                            leaf = false;
+                            return deepMapResponse(childValue, callback, {
+                                schema: context.schema,
+                                collection: relationInfo.relation.collection,
+                                relationInfo,
+                            });
+                        }
+                        else
+                            return childValue;
+                    });
+                    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 = deepMapResponse(value, callback, {
+                        schema: context.schema,
+                        collection: related_collection,
+                        relationInfo,
+                    });
+                    leaf = false;
+                    break;
+                }
+            }
+        }
+        return callback([key, value], { collection, field, ...relationInfo, leaf });
+    }));
+}

package/dist/utils/get-relation-info.d.ts

@@ -1,7 +1,6 @@
 import type { Relation } from '@directus/types';
-type RelationInfo = {
+export type RelationInfo = {
     relation: Relation | null;
     relationType: 'o2m' | 'm2o' | 'a2o' | 'o2a' | null;
 };
 export declare function getRelationInfo(relations: Relation[], collection: string, field: string): RelationInfo;
-export {};

package/dist/utils/permissions-cacheable.d.ts

@@ -0,0 +1,8 @@
+import type { Accountability, Filter } from '@directus/types';
+import type { Context } from '../permissions/types.js';
+/**
+ * Check if the read permissions for a collection contain the dynamic variable $NOW.
+ * If they do, the permissions are not cacheable.
+ */
+export declare function permissionsCacheable(collection: string | undefined, context: Context, accountability?: Accountability): Promise<boolean>;
+export declare function filterHasNow(filter: Filter): boolean;

package/dist/utils/{permissions-cachable.js → permissions-cacheable.js}

@@ -3,9 +3,9 @@ import { fetchPolicies } from '../permissions/lib/fetch-policies.js';
 import { createDefaultAccountability } from '../permissions/utils/create-default-accountability.js';
 /**
  * Check if the read permissions for a collection contain the dynamic variable $NOW.
- * If they do, the permissions are not cachable.
+ * If they do, the permissions are not cacheable.
  */
-export async function permissionsCachable(collection, context, accountability) {
+export async function permissionsCacheable(collection, context, accountability) {
     if (!collection) {
         return true;
     }
@@ -18,17 +18,19 @@ export async function permissionsCachable(collection, context, accountability) {
         if (!permission.permissions) {
             return false;
         }
-        return filter_has_now(permission.permissions);
+        return filterHasNow(permission.permissions);
     });
     return !has_now;
 }
-export function filter_has_now(filter) {
+export function filterHasNow(filter) {
+    if (filter === null)
+        return false;
     return Object.entries(filter).some(([key, value]) => {
         if (key === '_and' || key === '_or') {
-            return value.some((sub_filter) => filter_has_now(sub_filter));
+            return value.some((sub_filter) => filterHasNow(sub_filter));
         }
         else if (typeof value === 'object') {
-            return filter_has_now(value);
+            return filterHasNow(value);
         }
         else if (typeof value === 'string') {
             return value.startsWith('$NOW');

package/dist/utils/transaction.d.ts

@@ -6,4 +6,4 @@ import { type Knex } from 'knex';
  * Can be used to ensure the handler is run within a transaction,
  * while preventing nested transactions.
  */
-export declare const transaction: <T = unknown>(knex: Knex, handler: (knex: Knex) => Promise<T>) => Promise<T>;
+export declare const transaction: <T = unknown>(knex: Knex, handler: (knex: Knex.Transaction) => Promise<T>) => Promise<T>;

package/dist/utils/transaction.js

@@ -63,7 +63,23 @@ function shouldRetryTransaction(client, error) {
      * @link https://www.sqlite.org/rescode.html#busy
      */
     const SQLITE_BUSY_ERROR_CODE = 'SQLITE_BUSY';
+    // Both mariadb and mysql
+    const MYSQL_DEADLOCK_CODE = 'ER_LOCK_DEADLOCK';
+    const POSTGRES_DEADLOCK_CODE = '40P01';
+    const ORACLE_DEADLOCK_CODE = 'ORA-00060';
+    const MSSQL_DEADLOCK_CODE = 'EREQUEST';
+    const MSSQL_DEADLOCK_NUMBER = '1205';
+    const codes = {
+        cockroachdb: [{ code: COCKROACH_RETRY_ERROR_CODE }],
+        sqlite: [{ code: SQLITE_BUSY_ERROR_CODE }],
+        mysql: [{ code: MYSQL_DEADLOCK_CODE }],
+        mssql: [{ code: MSSQL_DEADLOCK_CODE, number: MSSQL_DEADLOCK_NUMBER }],
+        oracle: [{ code: ORACLE_DEADLOCK_CODE }],
+        postgres: [{ code: POSTGRES_DEADLOCK_CODE }],
+        redshift: [],
+    };
     return (isObject(error) &&
-        ((client === 'cockroachdb' && error['code'] === COCKROACH_RETRY_ERROR_CODE) ||
-            (client === 'sqlite' && error['code'] === SQLITE_BUSY_ERROR_CODE)));
+        codes[client].some((code) => {
+            return Object.entries(code).every(([key, value]) => String(error[key]) === value);
+        }));
 }

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

@@ -0,0 +1,3 @@
+import type { Item, 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)[]>;

package/dist/utils/versioning/handle-version.js

@@ -0,0 +1,92 @@
+import { ForbiddenError } from '@directus/errors';
+import { deepMapResponse } from '../deep-map-response.js';
+import { transaction } from '../transaction.js';
+import { mergeVersionsRaw } from './merge-version-data.js';
+export async function handleVersion(self, key, queryWithKey, opts) {
+    const { VersionsService } = await import('../../services/versions.js');
+    const { ItemsService } = await import('../../services/items.js');
+    if (queryWithKey.versionRaw) {
+        const originalData = await self.readByQuery(queryWithKey, opts);
+        if (originalData.length === 0) {
+            throw new ForbiddenError();
+        }
+        const versionsService = new VersionsService({
+            schema: self.schema,
+            accountability: self.accountability,
+            knex: self.knex,
+        });
+        const versionData = await versionsService.getVersionSaves(queryWithKey.version, self.collection, key);
+        if (!versionData || versionData.length === 0)
+            return [originalData[0]];
+        return [mergeVersionsRaw(originalData[0], versionData)];
+    }
+    let results = [];
+    const versionsService = new VersionsService({
+        schema: self.schema,
+        accountability: self.accountability,
+        knex: self.knex,
+    });
+    const createdIDs = {};
+    const versionData = await versionsService.getVersionSaves(queryWithKey.version, self.collection, key);
+    await transaction(self.knex, async (trx) => {
+        const itemsServiceAdmin = new ItemsService(self.collection, {
+            schema: self.schema,
+            accountability: {
+                admin: true,
+            },
+            knex: trx,
+        });
+        await Promise.all((versionData ?? []).map((data) => {
+            return itemsServiceAdmin.updateOne(key, data, {
+                emitEvents: false,
+                autoPurgeCache: false,
+                skipTracking: true,
+                onItemCreate: (collection, pk) => {
+                    if (collection in createdIDs === false)
+                        createdIDs[collection] = [];
+                    createdIDs[collection].push(pk);
+                },
+            });
+        }));
+        const itemsServiceUser = new ItemsService(self.collection, {
+            schema: self.schema,
+            accountability: self.accountability,
+            knex: trx,
+        });
+        results = await itemsServiceUser.readByQuery(queryWithKey, opts);
+        await trx.rollback();
+    });
+    results = results.map((result) => {
+        return deepMapResponse(result, ([key, value], context) => {
+            if (context.relationType === 'm2o' || context.relationType === 'a2o') {
+                const ids = createdIDs[context.relation.related_collection];
+                const match = ids?.find((id) => String(id) === String(value));
+                if (match) {
+                    return [key, null];
+                }
+            }
+            else if (context.relationType === 'o2m' && Array.isArray(value)) {
+                const ids = createdIDs[context.relation.collection];
+                return [
+                    key,
+                    value.map((val) => {
+                        const match = ids?.find((id) => String(id) === String(val));
+                        if (match) {
+                            return null;
+                        }
+                        return val;
+                    }),
+                ];
+            }
+            if (context.field.field === context.collection.primary) {
+                const ids = createdIDs[context.collection.collection];
+                const match = ids?.find((id) => String(id) === String(value));
+                if (match) {
+                    return [key, null];
+                }
+            }
+            return [key, value];
+        }, { collection: self.collection, schema: self.schema });
+    });
+    return results;
+}

package/dist/utils/versioning/merge-version-data.d.ts

@@ -0,0 +1,2 @@
+import type { Item } from '@directus/types';
+export declare function mergeVersionsRaw(item: Item, versionData: Partial<Item>[]): Item;

package/dist/utils/versioning/merge-version-data.js

@@ -0,0 +1,10 @@
+import { cloneDeep } from 'lodash-es';
+export function mergeVersionsRaw(item, versionData) {
+    const result = cloneDeep(item);
+    for (const versionRecord of versionData) {
+        for (const key of Object.keys(versionRecord)) {
+            result[key] = versionRecord[key];
+        }
+    }
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@directus/api",
-  "version": "29.1.1",
+  "version": "30.0.0",
   "description": "Directus is a real-time API and App dashboard for managing SQL database content",
   "keywords": [
     "directus",
@@ -59,7 +59,7 @@
   ],
   "dependencies": {
     "@authenio/samlify-node-xmllint": "2.0.0",
-    "@aws-sdk/client-ses": "3.859.0",
+    "@aws-sdk/client-sesv2": "3.864.0",
     "@godaddy/terminus": "4.12.1",
     "@rollup/plugin-alias": "5.1.1",
     "@rollup/plugin-node-resolve": "16.0.1",
@@ -153,30 +153,30 @@
     "ws": "8.18.3",
     "zod": "4.0.14",
     "zod-validation-error": "4.0.1",
+    "@directus/app": "13.14.0",
     "@directus/constants": "13.0.2",
     "@directus/env": "5.1.2",
-    "@directus/app": "13.13.1",
-    "@directus/extensions": "3.0.9",
     "@directus/errors": "2.0.3",
-    "@directus/extensions-sdk": "16.0.0",
-    "@directus/extensions-registry": "3.0.9",
-    "@directus/pressure": "3.0.8",
-    "@directus/memory": "3.0.8",
-    "@directus/schema": "13.0.2",
-    "@directus/schema-builder": "0.0.4",
-    "@directus/storage": "12.0.1",
+    "@directus/extensions-sdk": "16.0.1",
+    "@directus/extensions-registry": "3.0.10",
     "@directus/format-title": "12.0.1",
+    "@directus/extensions": "3.0.10",
+    "@directus/memory": "3.0.8",
+    "@directus/pressure": "3.0.8",
     "@directus/specs": "11.1.1",
+    "@directus/schema-builder": "0.0.5",
+    "@directus/storage": "12.0.1",
     "@directus/storage-driver-azure": "12.0.8",
+    "@directus/schema": "13.0.2",
     "@directus/storage-driver-cloudinary": "12.0.8",
-    "@directus/storage-driver-local": "12.0.1",
-    "@directus/storage-driver-s3": "12.0.8",
     "@directus/storage-driver-gcs": "12.0.8",
+    "@directus/storage-driver-s3": "12.0.8",
     "@directus/storage-driver-supabase": "3.0.8",
-    "@directus/system-data": "3.2.1",
+    "@directus/storage-driver-local": "12.0.1",
     "@directus/utils": "13.0.9",
+    "@directus/system-data": "3.2.1",
     "@directus/validation": "2.0.8",
-    "directus": "11.10.2"
+    "directus": "11.11.0"
   },
   "devDependencies": {
     "@directus/tsconfig": "3.0.0",
@@ -220,8 +220,8 @@
     "knex-mock-client": "3.0.2",
     "typescript": "5.8.3",
     "vitest": "3.2.4",
-    "@directus/schema-builder": "0.0.4",
-    "@directus/types": "13.2.1"
+    "@directus/schema-builder": "0.0.5",
+    "@directus/types": "13.2.2"
   },
   "optionalDependencies": {
     "@keyv/redis": "3.0.1",

package/dist/middleware/merge-content-versions.d.ts

@@ -1,2 +0,0 @@
-import type { RequestHandler } from 'express';
-export declare const mergeContentVersions: RequestHandler;

package/dist/middleware/merge-content-versions.js

@@ -1,26 +0,0 @@
-import { isObject } from '@directus/utils';
-import { VersionsService } from '../services/versions.js';
-import asyncHandler from '../utils/async-handler.js';
-import { mergeVersionsRaw, mergeVersionsRecursive } from '../utils/merge-version-data.js';
-export const mergeContentVersions = asyncHandler(async (req, res, next) => {
-    if (req.sanitizedQuery.version &&
-        req.collection &&
-        (req.singleton || req.params['pk']) &&
-        'data' in res.locals['payload']) {
-        const originalData = res.locals['payload'].data;
-        // only act on single item requests
-        if (!isObject(originalData))
-            return next();
-        const versionsService = new VersionsService({ accountability: req.accountability ?? null, schema: req.schema });
-        const versionData = await versionsService.getVersionSaves(req.sanitizedQuery.version, req.collection, req.params['pk']);
-        if (!versionData || versionData.length === 0)
-            return next();
-        if (req.sanitizedQuery.versionRaw) {
-            res.locals['payload'].data = mergeVersionsRaw(originalData, versionData);
-        }
-        else {
-            res.locals['payload'].data = mergeVersionsRecursive(originalData, versionData, req.collection, req.schema);
-        }
-    }
-    return next();
-});

package/dist/utils/merge-version-data.d.ts

@@ -1,3 +0,0 @@
-import type { Item, SchemaOverview } from '@directus/types';
-export declare function mergeVersionsRaw(item: Item, versionData: Partial<Item>[]): Item;
-export declare function mergeVersionsRecursive(item: Item, versionData: Item[], collection: string, schema: SchemaOverview): Item;

package/dist/utils/merge-version-data.js

@@ -1,134 +0,0 @@
-import { isObject } from '@directus/utils';
-import Joi from 'joi';
-import { cloneDeep } from 'lodash-es';
-const alterationSchema = Joi.object({
-    create: Joi.array().items(Joi.object().unknown()),
-    update: Joi.array().items(Joi.object().unknown()),
-    delete: Joi.array().items(Joi.string(), Joi.number()),
-});
-export function mergeVersionsRaw(item, versionData) {
-    const result = cloneDeep(item);
-    for (const versionRecord of versionData) {
-        for (const key of Object.keys(versionRecord)) {
-            result[key] = versionRecord[key];
-        }
-    }
-    return result;
-}
-export function mergeVersionsRecursive(item, versionData, collection, schema) {
-    if (versionData.length === 0)
-        return item;
-    return recursiveMerging(item, versionData, collection, schema);
-}
-function recursiveMerging(data, versionData, collection, schema) {
-    const result = cloneDeep(data);
-    const relations = getRelations(collection, schema);
-    for (const versionRecord of versionData) {
-        if (!isObject(versionRecord)) {
-            continue;
-        }
-        for (const key of Object.keys(data)) {
-            if (key in versionRecord === false) {
-                continue;
-            }
-            const currentValue = data[key];
-            const newValue = versionRecord[key];
-            if (typeof newValue !== 'object' || newValue === null) {
-                // primitive type substitution, json and non relational array values are handled in the next check
-                result[key] = newValue;
-                continue;
-            }
-            if (key in relations === false) {
-                // check for m2a exception
-                if (isManyToAnyCollection(collection, schema) && key === 'item') {
-                    const item = addMissingKeys(isObject(currentValue) ? currentValue : {}, newValue);
-                    result[key] = recursiveMerging(item, [newValue], data['collection'], schema);
-                }
-                else {
-                    // item is not a relation
-                    result[key] = newValue;
-                }
-                continue;
-            }
-            const { error } = alterationSchema.validate(newValue);
-            if (error) {
-                if (typeof newValue === 'object' && key in relations) {
-                    const newItem = !currentValue || typeof currentValue !== 'object' ? newValue : currentValue;
-                    result[key] = recursiveMerging(newItem, [newValue], relations[key], schema);
-                }
-                continue;
-            }
-            const alterations = newValue;
-            const currentPrimaryKeyField = schema.collections[collection].primary;
-            const relatedPrimaryKeyField = schema.collections[relations[key]].primary;
-            const mergedRelation = [];
-            if (Array.isArray(currentValue)) {
-                if (alterations.delete.length > 0) {
-                    for (const currentItem of currentValue) {
-                        const currentId = typeof currentItem === 'object' ? currentItem[currentPrimaryKeyField] : currentItem;
-                        if (alterations.delete.includes(currentId) === false) {
-                            mergedRelation.push(currentItem);
-                        }
-                    }
-                }
-                else {
-                    mergedRelation.push(...currentValue);
-                }
-                if (alterations.update.length > 0) {
-                    for (const updatedItem of alterations.update) {
-                        // find existing item to update
-                        const itemIndex = mergedRelation.findIndex((currentItem) => currentItem[relatedPrimaryKeyField] === updatedItem[currentPrimaryKeyField]);
-                        if (itemIndex === -1) {
-                            // check for raw primary keys
-                            const pkIndex = mergedRelation.findIndex((currentItem) => currentItem === updatedItem[currentPrimaryKeyField]);
-                            if (pkIndex === -1) {
-                                // nothing to update so add the item as is
-                                mergedRelation.push(updatedItem);
-                            }
-                            else {
-                                mergedRelation[pkIndex] = updatedItem;
-                            }
-                            continue;
-                        }
-                        const item = addMissingKeys(mergedRelation[itemIndex], updatedItem);
-                        mergedRelation[itemIndex] = recursiveMerging(item, [updatedItem], relations[key], schema);
-                    }
-                }
-            }
-            if (alterations.create.length > 0) {
-                for (const createdItem of alterations.create) {
-                    const item = addMissingKeys({}, createdItem);
-                    mergedRelation.push(recursiveMerging(item, [createdItem], relations[key], schema));
-                }
-            }
-            result[key] = mergedRelation;
-        }
-    }
-    return result;
-}
-function addMissingKeys(item, edits) {
-    const result = { ...item };
-    for (const key of Object.keys(edits)) {
-        if (key in item === false) {
-            result[key] = null;
-        }
-    }
-    return result;
-}
-function isManyToAnyCollection(collection, schema) {
-    const relation = schema.relations.find((relation) => relation.collection === collection && relation.meta?.many_collection === collection);
-    if (!relation || !relation.meta?.one_field || !relation.related_collection)
-        return false;
-    return Boolean(schema.collections[relation.related_collection]?.fields[relation.meta.one_field]?.special.includes('m2a'));
-}
-function getRelations(collection, schema) {
-    return schema.relations.reduce((result, relation) => {
-        if (relation.related_collection === collection && relation.meta?.one_field) {
-            result[relation.meta.one_field] = relation.collection;
-        }
-        if (relation.collection === collection && relation.related_collection) {
-            result[relation.field] = relation.related_collection;
-        }
-        return result;
-    }, {});
-}

package/dist/utils/permissions-cachable.d.ts

@@ -1,8 +0,0 @@
-import type { Accountability, Filter } from '@directus/types';
-import type { Context } from '../permissions/types.js';
-/**
- * Check if the read permissions for a collection contain the dynamic variable $NOW.
- * If they do, the permissions are not cachable.
- */
-export declare function permissionsCachable(collection: string | undefined, context: Context, accountability?: Accountability): Promise<boolean>;
-export declare function filter_has_now(filter: Filter): boolean;