@directus/api 15.0.0 → 17.0.0

package/dist/services/extensions.js

@@ -1,50 +1,39 @@
-import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
-import { createInspector } from '@directus/schema';
-import Joi from 'joi';
+import { ForbiddenError, InvalidPayloadError, UnprocessableContentError } from '@directus/errors';
+import { isObject } from '@directus/utils';
 import { omit, pick } from 'lodash-es';
-import { getCache } from '../cache.js';
-import { getHelpers } from '../database/helpers/index.js';
-import getDatabase, { getSchemaInspector } from '../database/index.js';
+import getDatabase from '../database/index.js';
 import { getExtensionManager } from '../extensions/index.js';
 import { ItemsService } from './items.js';
-import { PermissionsService } from './permissions.js';
+export class ExtensionReadError extends Error {
+    originalError;
+    constructor(originalError) {
+        super();
+        this.originalError = originalError;
+    }
+}
 export class ExtensionsService {
     knex;
-    permissionsService;
-    schemaInspector;
     accountability;
     schema;
     extensionsItemService;
-    systemCache;
-    helpers;
     extensionsManager;
     constructor(options) {
         this.knex = options.knex || getDatabase();
-        this.permissionsService = new PermissionsService(options);
-        this.schemaInspector = options.knex ? createInspector(options.knex) : getSchemaInspector();
         this.schema = options.schema;
         this.accountability = options.accountability || null;
         this.extensionsManager = getExtensionManager();
         this.extensionsItemService = new ItemsService('directus_extensions', {
             knex: this.knex,
             schema: this.schema,
-            // No accountability here, as every other method is hardcoded to be admin only
+            accountability: this.accountability,
         });
-        this.systemCache = getCache().systemCache;
-        this.helpers = getHelpers(this.knex);
     }
     async readAll() {
-        if (this.accountability?.admin !== true) {
-            throw new ForbiddenError();
-        }
         const installedExtensions = this.extensionsManager.getExtensions();
         const configuredExtensions = await this.extensionsItemService.readByQuery({ limit: -1 });
         return this.stitch(installedExtensions, configuredExtensions);
     }
     async readOne(bundle, name) {
-        if (this.accountability?.admin !== true) {
-            throw new ForbiddenError();
-        }
         const key = this.getKey(bundle, name);
         const schema = this.extensionsManager.getExtensions().find((extension) => extension.name === (bundle ?? name));
         const meta = await this.extensionsItemService.readOne(key);
@@ -54,27 +43,73 @@ export class ExtensionsService {
         throw new ForbiddenError();
     }
     async updateOne(bundle, name, data) {
-        if (this.accountability?.admin !== true) {
-            throw new ForbiddenError();
-        }
-        const key = this.getKey(bundle, name);
-        const updateExtensionSchema = Joi.object({
-            meta: Joi.object({
-                enabled: Joi.boolean(),
-            }),
+        const result = await this.knex.transaction(async (trx) => {
+            if (!isObject(data.meta)) {
+                throw new InvalidPayloadError({ reason: `"meta" is required` });
+            }
+            const service = new ExtensionsService({
+                knex: trx,
+                accountability: this.accountability,
+                schema: this.schema,
+            });
+            const key = this.getKey(bundle, name);
+            await service.extensionsItemService.updateOne(key, data.meta);
+            let extension;
+            try {
+                extension = await service.readOne(bundle, name);
+            }
+            catch (error) {
+                throw new ExtensionReadError(error);
+            }
+            if ('enabled' in data.meta) {
+                await service.checkBundleAndSyncStatus(trx, extension);
+            }
+            return extension;
         });
-        const { error } = updateExtensionSchema.validate(data);
-        if (error) {
-            throw new InvalidPayloadError({ reason: error.message });
-        }
-        if ('meta' in data && 'enabled' in data.meta) {
-            await this.knex('directus_extensions').update({ enabled: data.meta.enabled }).where({ name: key });
-            this.extensionsManager.reload();
-        }
+        this.extensionsManager.reload();
+        return result;
     }
     getKey(bundle, name) {
         return bundle ? `${bundle}/${name}` : name;
     }
+    /**
+     * Sync a bundles enabled status
+     *  - If the extension or extensions parent is not a bundle changes are skipped
+     *  - If a bundles status is toggled, all children are set to that status
+     *  - If an entries status is toggled, then if the:
+     *    - Parent bundle is non-partial throws UnprocessableContentError
+     *    - Entry status change resulted in all children being disabled then the parent bundle is disabled
+     *    - Entry status change resulted in at least one child being enabled then the parent bundle is enabled
+     */
+    async checkBundleAndSyncStatus(trx, extension) {
+        if (extension.bundle === null) {
+            if (extension.schema?.type === 'bundle') {
+                await trx('directus_extensions')
+                    .update({ enabled: extension.meta.enabled })
+                    .where('name', 'LIKE', this.getKey(extension.name, '%'));
+            }
+            return;
+        }
+        const parent = await this.readOne(null, extension.bundle);
+        if (parent.schema?.type !== 'bundle') {
+            return;
+        }
+        if (parent.schema.partial === false) {
+            throw new UnprocessableContentError({
+                reason: 'Unable to toggle status of an entry for a bundle marked as non partial',
+            });
+        }
+        const child = await trx('directus_extensions')
+            .where('name', 'LIKE', this.getKey(extension.bundle, '%'))
+            .where({ enabled: true })
+            .first();
+        if (!child && parent.meta.enabled) {
+            await trx('directus_extensions').update({ enabled: false }).where({ name: parent.name });
+        }
+        else if (child && !parent.meta.enabled) {
+            await trx('directus_extensions').update({ enabled: true }).where({ name: parent.name });
+        }
+    }
     /**
      * Combine the settings stored in the database with the information available from the installed
      * extensions into the standardized extensions api output
@@ -128,7 +163,7 @@ export class ExtensionsService {
             return {
                 name,
                 bundle: bundleName,
-                schema: schema ? pick(schema, 'type', 'local', 'version') : null,
+                schema: schema ? pick(schema, 'type', 'local', 'version', 'partial') : null,
                 meta: omit(meta, 'name'),
             };
         });

package/dist/services/fields.js

@@ -319,14 +319,19 @@ export class FieldsService {
             }
             if (hookAdjustedField.schema) {
                 const existingColumn = await this.schemaInspector.columnInfo(collection, hookAdjustedField.field);
+                if (hookAdjustedField.schema?.is_nullable === true && existingColumn.is_primary_key) {
+                    throw new InvalidPayloadError({ reason: 'Primary key cannot be null' });
+                }
                 // Sanitize column only when applying snapshot diff as opts is only passed from /utils/apply-diff.ts
                 const columnToCompare = opts?.bypassLimits && opts.autoPurgeSystemCache === false ? sanitizeColumn(existingColumn) : existingColumn;
                 if (!isEqual(columnToCompare, hookAdjustedField.schema)) {
                     try {
-                        await this.knex.schema.alterTable(collection, (table) => {
-                            if (!hookAdjustedField.schema)
-                                return;
-                            this.addColumnToTable(table, field, existingColumn);
+                        await this.knex.transaction(async (trx) => {
+                            await trx.schema.alterTable(collection, async (table) => {
+                                if (!hookAdjustedField.schema)
+                                    return;
+                                this.addColumnToTable(table, field, existingColumn);
+                            });
                         });
                     }
                     catch (err) {

package/dist/services/files.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" resolution-mode="require"/>
-import type { File, BusboyFileStream } from '@directus/types';
+import type { BusboyFileStream, File } from '@directus/types';
 import type { Readable } from 'node:stream';
 import type { AbstractServiceOptions, MutationOptions, PrimaryKey } from '../types/index.js';
 import { ItemsService } from './items.js';
@@ -15,7 +15,7 @@ export declare class FilesService extends ItemsService {
     /**
      * Extract metadata from a buffer's content
      */
-    getMetadata(stream: Readable, allowList?: any): Promise<Metadata>;
+    getMetadata(stream: Readable, allowList?: string | string[]): Promise<Metadata>;
     /**
      * Import a single file from an external URL
      */

package/dist/services/files.js

@@ -1,7 +1,9 @@
+import { useEnv } from '@directus/env';
+import { ContentTooLargeError, ForbiddenError, InvalidPayloadError, ServiceUnavailableError } from '@directus/errors';
 import formatTitle from '@directus/format-title';
 import { toArray } from '@directus/utils';
 import encodeURL from 'encodeurl';
-import exif from 'exif-reader';
+import exif, {} from 'exif-reader';
 import { parse as parseIcc } from 'icc';
 import { clone, pick } from 'lodash-es';
 import { extension } from 'mime-types';
@@ -13,13 +15,13 @@ import sharp from 'sharp';
 import url from 'url';
 import { SUPPORTED_IMAGE_METADATA_FORMATS } from '../constants.js';
 import emitter from '../emitter.js';
-import env from '../env.js';
-import { ContentTooLargeError, ForbiddenError, InvalidPayloadError, ServiceUnavailableError } from '@directus/errors';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 import { getAxios } from '../request/index.js';
 import { getStorage } from '../storage/index.js';
 import { parseIptc, parseXmp } from '../utils/parse-image-metadata.js';
 import { ItemsService } from './items.js';
+const env = useEnv();
+const logger = useLogger();
 export class FilesService extends ItemsService {
     constructor(options) {
         super('directus_files', options);
@@ -138,7 +140,8 @@ export class FilesService extends ItemsService {
             if (!payload.metadata && metadata) {
                 payload.metadata = metadata;
             }
-            // Note that if this is a replace file upload, the below properities are fetched and included in the payload above in the `existingFile` variable...so this will ONLY set the values if they're not already set
+            // Note that if this is a replace file upload, the below properties are fetched and included in the payload above
+            // in the `existingFile` variable... so this will ONLY set the values if they're not already set
             if (!payload.description && description) {
                 payload.description = description;
             }
@@ -192,20 +195,25 @@ export class FilesService extends ItemsService {
                 const fullMetadata = {};
                 if (sharpMetadata.exif) {
                     try {
-                        const { image, thumbnail, interoperability, ...rest } = exif(sharpMetadata.exif);
-                        if (image) {
-                            fullMetadata.ifd0 = image;
+                        const { Image, ThumbnailTags, Iop, GPSInfo, Photo } = exif(sharpMetadata.exif);
+                        if (Image) {
+                            fullMetadata.ifd0 = Image;
+                        }
+                        if (ThumbnailTags) {
+                            fullMetadata.ifd1 = ThumbnailTags;
+                        }
+                        if (Iop) {
+                            fullMetadata.interop = Iop;
                         }
-                        if (thumbnail) {
-                            fullMetadata.ifd1 = thumbnail;
+                        if (GPSInfo) {
+                            fullMetadata.gps = GPSInfo;
                         }
-                        if (interoperability) {
-                            fullMetadata.interop = interoperability;
+                        if (Photo) {
+                            fullMetadata.exif = Photo;
                         }
-                        Object.assign(fullMetadata, rest);
                     }
                     catch (err) {
-                        logger.warn(`Couldn't extract EXIF metadata from file`);
+                        logger.warn(`Couldn't extract Exif metadata from file`);
                         logger.warn(err);
                     }
                 }

package/dist/services/graphql/index.js

@@ -1,6 +1,7 @@
 import { Action, FUNCTIONS } from '@directus/constants';
+import { useEnv } from '@directus/env';
 import { ErrorCode, ForbiddenError, InvalidPayloadError, isDirectusError } from '@directus/errors';
-import { parseFilterFunctionPath } from '@directus/utils';
+import { parseFilterFunctionPath, toBoolean } from '@directus/utils';
 import argon2 from 'argon2';
 import { GraphQLBoolean, GraphQLEnumType, GraphQLError, GraphQLFloat, GraphQLID, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLScalarType, GraphQLSchema, GraphQLString, GraphQLUnionType, NoSchemaIntrospectionCustomRule, execute, specifiedRules, validate, } from 'graphql';
 import { GraphQLJSON, InputTypeComposer, ObjectTypeComposer, SchemaComposer, toInputObjectType } from 'graphql-compose';
@@ -8,14 +9,12 @@ import { assign, flatten, get, mapKeys, merge, omit, pick, set, transform, uniq
 import { clearSystemCache, getCache } from '../../cache.js';
 import { DEFAULT_AUTH_PROVIDER, GENERATE_SPECIAL } from '../../constants.js';
 import getDatabase from '../../database/index.js';
-import env from '../../env.js';
 import { generateHash } from '../../utils/generate-hash.js';
 import { getGraphQLType } from '../../utils/get-graphql-type.js';
 import { getMilliseconds } from '../../utils/get-milliseconds.js';
 import { getService } from '../../utils/get-service.js';
 import { reduceSchema } from '../../utils/reduce-schema.js';
 import { sanitizeQuery } from '../../utils/sanitize-query.js';
-import { toBoolean } from '../../utils/to-boolean.js';
 import { validateQuery } from '../../utils/validate-query.js';
 import { ActivityService } from '../activity.js';
 import { AuthenticationService } from '../authentication.js';
@@ -41,6 +40,7 @@ import { GraphQLStringOrFloat } from './types/string-or-float.js';
 import { GraphQLVoid } from './types/void.js';
 import { addPathToValidationError } from './utils/add-path-to-validation-error.js';
 import processError from './utils/process-error.js';
+const env = useEnv();
 const validationRules = Array.from(specifiedRules);
 if (env['GRAPHQL_INTROSPECTION'] === false) {
     validationRules.push(NoSchemaIntrospectionCustomRule);
@@ -595,6 +595,47 @@ export class GraphQLService {
                     },
                 },
             });
+            const BigIntFilterOperators = schemaComposer.createInputTC({
+                name: 'big_int_filter_operators',
+                fields: {
+                    _eq: {
+                        type: GraphQLBigInt,
+                    },
+                    _neq: {
+                        type: GraphQLBigInt,
+                    },
+                    _in: {
+                        type: new GraphQLList(GraphQLBigInt),
+                    },
+                    _nin: {
+                        type: new GraphQLList(GraphQLBigInt),
+                    },
+                    _gt: {
+                        type: GraphQLBigInt,
+                    },
+                    _gte: {
+                        type: GraphQLBigInt,
+                    },
+                    _lt: {
+                        type: GraphQLBigInt,
+                    },
+                    _lte: {
+                        type: GraphQLBigInt,
+                    },
+                    _null: {
+                        type: GraphQLBoolean,
+                    },
+                    _nnull: {
+                        type: GraphQLBoolean,
+                    },
+                    _between: {
+                        type: new GraphQLList(GraphQLBigInt),
+                    },
+                    _nbetween: {
+                        type: new GraphQLList(GraphQLBigInt),
+                    },
+                },
+            });
             const GeometryFilterOperators = schemaComposer.createInputTC({
                 name: 'geometry_filter_operators',
                 fields: {
@@ -705,6 +746,8 @@ export class GraphQLService {
                                 filterOperatorType = BooleanFilterOperators;
                                 break;
                             case GraphQLBigInt:
+                                filterOperatorType = BigIntFilterOperators;
+                                break;
                             case GraphQLInt:
                             case GraphQLFloat:
                                 filterOperatorType = NumberFilterOperators;

package/dist/services/graphql/subscription.js

@@ -1,11 +1,11 @@
 import { EventEmitter, on } from 'events';
-import { getMessenger } from '../../messenger.js';
+import { useBus } from '../../bus/index.js';
 import { getSchema } from '../../utils/get-schema.js';
 import { refreshAccountability } from '../../websocket/authenticate.js';
 import { getPayload } from '../../websocket/utils/items.js';
 const messages = createPubSub(new EventEmitter());
 export function bindPubSub() {
-    const messenger = getMessenger();
+    const messenger = useBus();
     messenger.subscribe('websocket.event', (message) => {
         messages.publish(`${message['collection']}_mutated`, message);
     });

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

@@ -1,4 +1,7 @@
 import { GraphQLScalarType, Kind } from 'graphql';
+// minimum and maximum int64 values database vendors use for big integer
+const MIN_BIG_INT = -9223372036854775808n;
+const MAX_BIG_INT = 9223372036854775807n;
 export const GraphQLBigInt = new GraphQLScalarType({
     name: 'GraphQLBigInt',
     description: 'BigInt value',
@@ -26,11 +29,19 @@ export const GraphQLBigInt = new GraphQLScalarType({
     },
 });
 function parseNumberValue(input) {
-    if (!/[+-]?([0-9]+[.])?[0-9]+/.test(input))
-        return input;
-    const value = parseInt(input);
-    if (isNaN(value) || value < Number.MIN_SAFE_INTEGER || value > Number.MAX_SAFE_INTEGER) {
+    // Attempt to parse the input as a regular integer
+    const intValue = Number(input);
+    if (isNaN(intValue)) {
         throw new Error('Invalid GraphQLBigInt');
     }
-    return value;
+    if (!Number.isSafeInteger(intValue)) {
+        // If the input is not a safe integer, its a big int, so return it as string,
+        // because currently string is the best way to handle big int due to knex limitations and JSON.stringify not able to serialise bigInt
+        const bigIntInput = BigInt(input);
+        if (bigIntInput < MIN_BIG_INT || bigIntInput > MAX_BIG_INT) {
+            throw new Error('Invalid GraphQLBigInt');
+        }
+        return input;
+    }
+    return intValue;
 }

package/dist/services/graphql/utils/process-error.d.ts

@@ -1,4 +1,7 @@
+import { type DirectusError } from '@directus/errors';
 import type { Accountability } from '@directus/types';
 import type { GraphQLError, GraphQLFormattedError } from 'graphql';
-declare const processError: (accountability: Accountability | null, error: Readonly<GraphQLError>) => GraphQLFormattedError;
+declare const processError: (accountability: Accountability | null, error: Readonly<GraphQLError & {
+    originalError: GraphQLError | DirectusError | Error | undefined;
+}>) => GraphQLFormattedError;
 export default processError;

package/dist/services/graphql/utils/process-error.js

@@ -1,8 +1,12 @@
 import { isDirectusError } from '@directus/errors';
-import logger from '../../../logger.js';
+import { useLogger } from '../../../logger.js';
 const processError = (accountability, error) => {
+    const logger = useLogger();
     logger.error(error);
-    const { originalError } = error;
+    let originalError = error.originalError;
+    if (originalError && 'originalError' in originalError) {
+        originalError = originalError.originalError;
+    }
     if (isDirectusError(originalError)) {
         return {
             message: originalError.message,
@@ -10,6 +14,8 @@ const processError = (accountability, error) => {
                 code: originalError.code,
                 ...(originalError.extensions ?? {}),
             },
+            ...(error.locations && { locations: error.locations }),
+            ...(error.path && { path: error.path }),
         };
     }
     else {
@@ -19,13 +25,9 @@ const processError = (accountability, error) => {
                 extensions: {
                     code: 'INTERNAL_SERVER_ERROR',
                 },
+                ...(error.locations && { locations: error.locations }),
+                ...(error.path && { path: error.path }),
             };
-            if (error.locations) {
-                graphqlFormattedError.locations = error.locations;
-            }
-            if (error.path) {
-                graphqlFormattedError.path = error.path;
-            }
             return graphqlFormattedError;
         }
         else {

package/dist/services/{import-export/index.d.ts → import-export.d.ts}

@@ -2,7 +2,7 @@
 import type { Accountability, File, Query, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 import type { Readable } from 'node:stream';
-import type { AbstractServiceOptions } from '../../types/index.js';
+import type { AbstractServiceOptions } from '../types/index.js';
 type ExportFormat = 'csv' | 'json' | 'xml' | 'yaml';
 export declare class ImportService {
     knex: Knex;

package/dist/services/{import-export/index.js → import-export.js}

@@ -1,3 +1,5 @@
+import { useEnv } from '@directus/env';
+import { ForbiddenError, InvalidPayloadError, ServiceUnavailableError, UnsupportedMediaTypeError, } from '@directus/errors';
 import { parseJSON, toArray } from '@directus/utils';
 import { queue } from 'async';
 import destroyStream from 'destroy';
@@ -8,18 +10,18 @@ import { createReadStream } from 'node:fs';
 import { appendFile } from 'node:fs/promises';
 import Papa from 'papaparse';
 import StreamArray from 'stream-json/streamers/StreamArray.js';
-import getDatabase from '../../database/index.js';
-import emitter from '../../emitter.js';
-import env from '../../env.js';
-import { ForbiddenError, InvalidPayloadError, ServiceUnavailableError, UnsupportedMediaTypeError, } from '@directus/errors';
-import logger from '../../logger.js';
-import { getDateFormatted } from '../../utils/get-date-formatted.js';
-import { Url } from '../../utils/url.js';
-import { userName } from '../../utils/user-name.js';
-import { FilesService } from '../files.js';
-import { ItemsService } from '../items.js';
-import { NotificationsService } from '../notifications.js';
-import { UsersService } from '../users.js';
+import getDatabase from '../database/index.js';
+import emitter from '../emitter.js';
+import { useLogger } from '../logger.js';
+import { getDateFormatted } from '../utils/get-date-formatted.js';
+import { Url } from '../utils/url.js';
+import { userName } from '../utils/user-name.js';
+import { FilesService } from './files.js';
+import { ItemsService } from './items.js';
+import { NotificationsService } from './notifications.js';
+import { UsersService } from './users.js';
+const env = useEnv();
+const logger = useLogger();
 export class ImportService {
     knex;
     accountability;

package/dist/services/index.d.ts

@@ -10,7 +10,7 @@ export * from './files.js';
 export * from './flows.js';
 export * from './folders.js';
 export * from './graphql/index.js';
-export * from './import-export/index.js';
+export * from './import-export.js';
 export * from './items.js';
 export * from './mail/index.js';
 export * from './meta.js';

package/dist/services/index.js

@@ -10,7 +10,7 @@ export * from './files.js';
 export * from './flows.js';
 export * from './folders.js';
 export * from './graphql/index.js';
-export * from './import-export/index.js';
+export * from './import-export.js';
 export * from './items.js';
 export * from './mail/index.js';
 export * from './meta.js';

package/dist/services/items.js

@@ -1,19 +1,19 @@
 import { Action } from '@directus/constants';
+import { useEnv } from '@directus/env';
+import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
 import { assign, clone, cloneDeep, omit, pick, without } from 'lodash-es';
 import { getCache } from '../cache.js';
+import { translateDatabaseError } from '../database/errors/translate.js';
 import { getHelpers } from '../database/helpers/index.js';
 import getDatabase from '../database/index.js';
 import runAST from '../database/run-ast.js';
 import emitter from '../emitter.js';
-import env from '../env.js';
-import { ForbiddenError } from '@directus/errors';
-import { translateDatabaseError } from '../database/errors/translate.js';
-import { InvalidPayloadError } from '@directus/errors';
 import getASTFromQuery from '../utils/get-ast-from-query.js';
 import { shouldClearCache } from '../utils/should-clear-cache.js';
 import { validateKeys } from '../utils/validate-keys.js';
 import { AuthorizationService } from './authorization.js';
 import { PayloadService } from './payload.js';
+const env = useEnv();
 export class ItemsService {
     collection;
     knex;
@@ -118,15 +118,19 @@ export class ItemsService {
             const payloadWithTypeCasting = await payloadService.processValues('create', payloadWithoutAliases);
             // The primary key can already exist in the payload.
             // In case of manual string / UUID primary keys it's always provided at this point.
-            // In case of an integer primary key, it might be provided as the user can specify the value manually.
+            // In case of an (big) integer primary key, it might be provided as the user can specify the value manually.
             let primaryKey = payloadWithTypeCasting[primaryKeyField];
+            if (primaryKey) {
+                validateKeys(this.schema, this.collection, primaryKeyField, primaryKey);
+            }
             // If a PK of type number was provided, although the PK is set the auto_increment,
             // depending on the database, the sequence might need to be reset to protect future PK collisions.
             let autoIncrementSequenceNeedsToBeReset = false;
             const pkField = this.schema.collections[this.collection].fields[primaryKeyField];
             if (primaryKey &&
+                pkField &&
                 !opts.bypassAutoIncrementSequenceReset &&
-                pkField.type === 'integer' &&
+                ['integer', 'bigInteger'].includes(pkField.type) &&
                 pkField.defaultValue === 'AUTO_INCREMENT') {
                 autoIncrementSequenceNeedsToBeReset = true;
             }
@@ -505,7 +509,7 @@ export class ItemsService {
             nestedActionEvents.push(...nestedActionEventsM2O);
             nestedActionEvents.push(...nestedActionEventsA2O);
             for (const key of keys) {
-                const { revisions, nestedActionEvents: nestedActionEventsO2M } = await payloadService.processO2M(payload, key, opts);
+                const { revisions, nestedActionEvents: nestedActionEventsO2M } = await payloadService.processO2M(payloadWithA2O, key, opts);
                 childrenRevisions.push(...revisions);
                 nestedActionEvents.push(...nestedActionEventsO2M);
             }
@@ -569,7 +573,7 @@ export class ItemsService {
                     ? ['items.update', `${this.collection}.items.update`]
                     : `${this.eventScope}.update`,
                 meta: {
-                    payload,
+                    payload: payloadWithPresets,
                     keys,
                     collection: this.collection,
                 },

package/dist/services/mail/index.js

@@ -1,14 +1,16 @@
+import { useEnv } from '@directus/env';
 import { InvalidPayloadError } from '@directus/errors';
 import fse from 'fs-extra';
 import { Liquid } from 'liquidjs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import getDatabase from '../../database/index.js';
-import env from '../../env.js';
 import { getExtensionsPath } from '../../extensions/lib/get-extensions-path.js';
-import logger from '../../logger.js';
+import { useLogger } from '../../logger.js';
 import getMailer from '../../mailer.js';
 import { Url } from '../../utils/url.js';
+const env = useEnv();
+const logger = useLogger();
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const liquidEngine = new Liquid({
     root: [path.resolve(getExtensionsPath(), 'templates'), path.resolve(__dirname, 'templates')],

package/dist/services/notifications.js

@@ -1,10 +1,12 @@
-import env from '../env.js';
-import logger from '../logger.js';
+import { useEnv } from '@directus/env';
+import { useLogger } from '../logger.js';
 import { md } from '../utils/md.js';
 import { Url } from '../utils/url.js';
 import { ItemsService } from './items.js';
 import { MailService } from './mail/index.js';
 import { UsersService } from './users.js';
+const env = useEnv();
+const logger = useLogger();
 export class NotificationsService extends ItemsService {
     usersService;
     mailService;
@@ -30,7 +32,9 @@ export class NotificationsService extends ItemsService {
             const user = await this.usersService.readOne(data.recipient, {
                 fields: ['id', 'email', 'email_notifications', 'role.app_access'],
             });
-            const manageUserAccountUrl = new Url(env['PUBLIC_URL']).addPath('admin', 'users', user['id']).toString();
+            const manageUserAccountUrl = new Url(env['PUBLIC_URL'])
+                .addPath('admin', 'users', user['id'])
+                .toString();
             const html = data.message ? md(data.message) : '';
             if (user['email'] && user['email_notifications'] === true) {
                 try {