@directus/api 15.0.0 → 16.0.0

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.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';
@@ -10,9 +12,7 @@ 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 { 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';
@@ -20,6 +20,8 @@ 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/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 {

package/dist/services/relations.js

@@ -1,3 +1,4 @@
+import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
 import { createInspector } from '@directus/schema';
 import { toArray } from '@directus/utils';
 import { clearSystemCache, getCache } from '../cache.js';
@@ -5,7 +6,6 @@ import { getHelpers } from '../database/helpers/index.js';
 import getDatabase, { getSchemaInspector } from '../database/index.js';
 import { systemRelationRows } from '../database/system-data/relations/index.js';
 import emitter from '../emitter.js';
-import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
 import { getDefaultIndexName } from '../utils/get-default-index-name.js';
 import { getSchema } from '../utils/get-schema.js';
 import { ItemsService } from './items.js';
@@ -115,16 +115,18 @@ export class RelationsService {
         if (!relation.field) {
             throw new InvalidPayloadError({ reason: '"field" is required' });
         }
-        if (relation.collection in this.schema.collections === false) {
+        const collectionSchema = this.schema.collections[relation.collection];
+        if (!collectionSchema) {
             throw new InvalidPayloadError({ reason: `Collection "${relation.collection}" doesn't exist` });
         }
-        if (relation.field in this.schema.collections[relation.collection].fields === false) {
+        const fieldSchema = collectionSchema.fields[relation.field];
+        if (!fieldSchema) {
             throw new InvalidPayloadError({
                 reason: `Field "${relation.field}" doesn't exist in collection "${relation.collection}"`,
             });
         }
         // A primary key should not be a foreign key
-        if (this.schema.collections[relation.collection].primary === relation.field) {
+        if (collectionSchema.primary === relation.field) {
             throw new InvalidPayloadError({
                 reason: `Field "${relation.field}" in collection "${relation.collection}" is a primary key`,
             });
@@ -151,7 +153,7 @@ export class RelationsService {
             await this.knex.transaction(async (trx) => {
                 if (relation.related_collection) {
                     await trx.schema.alterTable(relation.collection, async (table) => {
-                        this.alterType(table, relation);
+                        this.alterType(table, relation, fieldSchema.nullable);
                         const constraintName = getDefaultIndexName('foreign', relation.collection, relation.field);
                         const builder = table
                             .foreign(relation.field, constraintName)
@@ -198,10 +200,12 @@ export class RelationsService {
         if (this.accountability && this.accountability.admin !== true) {
             throw new ForbiddenError();
         }
-        if (collection in this.schema.collections === false) {
+        const collectionSchema = this.schema.collections[collection];
+        if (!collectionSchema) {
             throw new InvalidPayloadError({ reason: `Collection "${collection}" doesn't exist` });
         }
-        if (field in this.schema.collections[collection].fields === false) {
+        const fieldSchema = collectionSchema.fields[field];
+        if (!fieldSchema) {
             throw new InvalidPayloadError({ reason: `Field "${field}" doesn't exist in collection "${collection}"` });
         }
         const existingRelation = this.schema.relations.find((existingRelation) => existingRelation.collection === collection && existingRelation.field === field);
@@ -225,7 +229,7 @@ export class RelationsService {
                             constraintName = this.helpers.schema.constraintName(constraintName);
                             existingRelation.schema.constraint_name = constraintName;
                         }
-                        this.alterType(table, relation);
+                        this.alterType(table, relation, fieldSchema.nullable);
                         const builder = table
                             .foreign(field, constraintName || undefined)
                             .references(`${existingRelation.related_collection}.${this.schema.collections[existingRelation.related_collection].primary}`);
@@ -447,11 +451,16 @@ export class RelationsService {
      *
      * @TODO This is a bit of a hack, and might be better of abstracted elsewhere
      */
-    alterType(table, relation) {
+    alterType(table, relation, nullable) {
         const m2oFieldDBType = this.schema.collections[relation.collection].fields[relation.field].dbType;
         const relatedFieldDBType = this.schema.collections[relation.related_collection].fields[this.schema.collections[relation.related_collection].primary].dbType;
         if (m2oFieldDBType !== relatedFieldDBType && m2oFieldDBType === 'int' && relatedFieldDBType === 'int unsigned') {
-            table.specificType(relation.field, 'int unsigned').alter();
+            const alterField = table.specificType(relation.field, 'int unsigned');
+            // Maintains the non-nullable state
+            if (!nullable) {
+                alterField.notNullable();
+            }
+            alterField.alter();
         }
     }
 }

package/dist/services/server.js

@@ -1,19 +1,20 @@
-import { toArray } from '@directus/utils';
+import { useEnv } from '@directus/env';
+import { toArray, toBoolean } from '@directus/utils';
 import { version } from 'directus/version';
 import { merge } from 'lodash-es';
 import { Readable } from 'node:stream';
 import { performance } from 'perf_hooks';
 import { getCache } from '../cache.js';
 import getDatabase, { hasDatabaseConnection } from '../database/index.js';
-import env from '../env.js';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 import getMailer from '../mailer.js';
 import { rateLimiterGlobal } from '../middleware/rate-limiter-global.js';
 import { rateLimiter } from '../middleware/rate-limiter-ip.js';
 import { SERVER_ONLINE } from '../server.js';
 import { getStorage } from '../storage/index.js';
-import { toBoolean } from '../utils/to-boolean.js';
 import { SettingsService } from './settings.js';
+const env = useEnv();
+const logger = useLogger();
 export class ServerService {
     knex;
     accountability;

package/dist/services/shares.js

@@ -1,7 +1,7 @@
+import { useEnv } from '@directus/env';
+import { ForbiddenError, InvalidCredentialsError } from '@directus/errors';
 import argon2 from 'argon2';
 import jwt from 'jsonwebtoken';
-import env from '../env.js';
-import { ForbiddenError, InvalidCredentialsError } from '@directus/errors';
 import { getMilliseconds } from '../utils/get-milliseconds.js';
 import { md } from '../utils/md.js';
 import { Url } from '../utils/url.js';
@@ -10,6 +10,7 @@ import { AuthorizationService } from './authorization.js';
 import { ItemsService } from './items.js';
 import { MailService } from './mail/index.js';
 import { UsersService } from './users.js';
+const env = useEnv();
 export class SharesService extends ItemsService {
     authorizationService;
     constructor(options) {

package/dist/services/specifications.js

@@ -1,13 +1,14 @@
+import { useEnv } from '@directus/env';
 import formatTitle from '@directus/format-title';
 import { spec } from '@directus/specs';
 import { version } from 'directus/version';
 import { cloneDeep, mergeWith } from 'lodash-es';
 import { OAS_REQUIRED_SCHEMAS } from '../constants.js';
 import getDatabase from '../database/index.js';
-import env from '../env.js';
 import { getRelationType } from '../utils/get-relation-type.js';
 import { reduceSchema } from '../utils/reduce-schema.js';
 import { GraphQLService } from './graphql/index.js';
+const env = useEnv();
 export class SpecificationService {
     accountability;
     knex;

package/dist/services/users.js

@@ -1,3 +1,5 @@
+import { useEnv } from '@directus/env';
+import { ForbiddenError, InvalidPayloadError, RecordNotUniqueError, UnprocessableContentError } from '@directus/errors';
 import { getSimpleHash, toArray } from '@directus/utils';
 import { FailedValidationError, joiValidationErrorItemToErrorExtensions } from '@directus/validation';
 import Joi from 'joi';
@@ -5,9 +7,6 @@ import jwt from 'jsonwebtoken';
 import { cloneDeep, isEmpty } from 'lodash-es';
 import { performance } from 'perf_hooks';
 import getDatabase from '../database/index.js';
-import env from '../env.js';
-import { ForbiddenError } from '@directus/errors';
-import { InvalidPayloadError, RecordNotUniqueError, UnprocessableContentError } from '@directus/errors';
 import isUrlAllowed from '../utils/is-url-allowed.js';
 import { verifyJWT } from '../utils/jwt.js';
 import { stall } from '../utils/stall.js';
@@ -15,6 +14,7 @@ import { Url } from '../utils/url.js';
 import { ItemsService } from './items.js';
 import { MailService } from './mail/index.js';
 import { SettingsService } from './settings.js';
+const env = useEnv();
 export class UsersService extends ItemsService {
     constructor(options) {
         super('directus_users', options);
@@ -213,9 +213,20 @@ export class UsersService extends ItemsService {
     async updateMany(keys, data, opts) {
         try {
             if (data['role']) {
-                // data['role'] will be an object with id with GraphQL mutations
-                const roleId = data['role']?.id ?? data['role'];
-                const newRole = await this.knex.select('admin_access').from('directus_roles').where('id', roleId).first();
+                /*
+                 * data['role'] has the following cases:
+                 * - a string with existing role id
+                 * - an object with existing role id for GraphQL mutations
+                 * - an object with data for new role
+                 */
+                const role = data['role']?.id ?? data['role'];
+                let newRole;
+                if (typeof role === 'string') {
+                    newRole = await this.knex.select('admin_access').from('directus_roles').where('id', role).first();
+                }
+                else {
+                    newRole = role;
+                }
                 if (!newRole?.admin_access) {
                     await this.checkRemainingAdminExistence(keys);
                 }
@@ -325,13 +336,13 @@ export class UsersService extends ItemsService {
             if (isEmpty(user) || user.status === 'invited') {
                 const subjectLine = subject ?? "You've been invited";
                 await mailService.send({
-                    to: user.email,
+                    to: user?.email ?? email,
                     subject: subjectLine,
                     template: {
                         name: 'user-invitation',
                         data: {
-                            url: this.inviteUrl(email, url),
-                            email: user.email,
+                            url: this.inviteUrl(user?.email ?? email, url),
+                            email: user?.email ?? email,
                         },
                     },
                 });