@directus/api 14.1.2 → 16.0.0

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);
@@ -126,7 +126,7 @@ export class GraphQLService {
                 delete: { value: 'delete' },
             },
         });
-        const { ReadCollectionTypes } = getReadableTypes();
+        const { ReadCollectionTypes, VersionCollectionTypes } = getReadableTypes();
         const { CreateCollectionTypes, UpdateCollectionTypes, DeleteCollectionTypes } = getWritableTypes();
         const scopeFilter = (collection) => {
             if (this.scope === 'items' && collection.collection.startsWith('directus_') === true)
@@ -158,6 +158,9 @@ export class GraphQLService {
                     acc[`${collectionName}_by_id`] = ReadCollectionTypes[collection.collection].getResolver(`${collection.collection}_by_id`);
                     acc[`${collectionName}_aggregated`] = ReadCollectionTypes[collection.collection].getResolver(`${collection.collection}_aggregated`);
                 }
+                if (this.scope === 'items') {
+                    acc[`${collectionName}_by_version`] = VersionCollectionTypes[collection.collection].getResolver(`${collection.collection}_by_version`);
+                }
                 return acc;
             }, {}));
         }
@@ -221,6 +224,7 @@ export class GraphQLService {
          */
         function getTypes(action) {
             const CollectionTypes = {};
+            const VersionTypes = {};
             const CountFunctions = schemaComposer.createObjectTC({
                 name: 'count_functions',
                 fields: {
@@ -289,13 +293,19 @@ export class GraphQLService {
                             type = new GraphQLNonNull(type);
                         }
                         if (collection.primary === field.field) {
-                            if (!field.defaultValue && !field.special.includes('uuid') && action === 'create') {
+                            // permissions IDs need to be nullable https://github.com/directus/directus/issues/20509
+                            if (collection.collection === 'directus_permissions') {
+                                type = GraphQLID;
+                            }
+                            else if (!field.defaultValue && !field.special.includes('uuid') && action === 'create') {
                                 type = new GraphQLNonNull(GraphQLID);
                             }
-                            else if (['create', 'update'].includes(action))
+                            else if (['create', 'update'].includes(action)) {
                                 type = GraphQLID;
-                            else
+                            }
+                            else {
                                 type = new GraphQLNonNull(GraphQLID);
+                            }
                         }
                         acc[field.field] = {
                             type,
@@ -345,6 +355,9 @@ export class GraphQLService {
                         return acc;
                     }, {}),
                 });
+                if (self.scope === 'items') {
+                    VersionTypes[collection.collection] = CollectionTypes[collection.collection].clone(`version_${collection.collection}`);
+                }
             }
             for (const relation of schema[action].relations) {
                 if (relation.related_collection) {
@@ -367,6 +380,16 @@ export class GraphQLService {
                                 },
                             },
                         });
+                        if (self.scope === 'items') {
+                            VersionTypes[relation.related_collection]?.addFields({
+                                [relation.meta.one_field]: {
+                                    type: GraphQLJSON,
+                                    resolve: (obj, _, __, info) => {
+                                        return obj[info?.path?.key ?? relation.meta.one_field];
+                                    },
+                                },
+                            });
+                        }
                     }
                 }
                 else if (relation.meta?.one_allowed_collections && action === 'read') {
@@ -399,13 +422,13 @@ export class GraphQLService {
                     });
                 }
             }
-            return { CollectionTypes };
+            return { CollectionTypes, VersionTypes };
         }
         /**
          * Create readable types and attach resolvers for each. Also prepares full filter argument structures
          */
         function getReadableTypes() {
-            const { CollectionTypes: ReadCollectionTypes } = getTypes('read');
+            const { CollectionTypes: ReadCollectionTypes, VersionTypes: VersionCollectionTypes } = getTypes('read');
             const ReadableCollectionFilterTypes = {};
             const AggregatedFunctions = {};
             const AggregatedFields = {};
@@ -572,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: {
@@ -682,6 +746,8 @@ export class GraphQLService {
                                 filterOperatorType = BooleanFilterOperators;
                                 break;
                             case GraphQLBigInt:
+                                filterOperatorType = BigIntFilterOperators;
+                                break;
                             case GraphQLInt:
                             case GraphQLFloat:
                                 filterOperatorType = NumberFilterOperators;
@@ -843,13 +909,6 @@ export class GraphQLService {
                         },
                     };
                 }
-                else {
-                    resolver.args = {
-                        version: {
-                            type: GraphQLString,
-                        },
-                    };
-                }
                 ReadCollectionTypes[collection.collection].addResolver(resolver);
                 ReadCollectionTypes[collection.collection].addResolver({
                     name: `${collection.collection}_aggregated`,
@@ -885,7 +944,6 @@ export class GraphQLService {
                         type: ReadCollectionTypes[collection.collection],
                         args: {
                             id: new GraphQLNonNull(GraphQLID),
-                            version: GraphQLString,
                         },
                         resolve: async ({ info, context }) => {
                             const result = await self.resolveQuery(info);
@@ -894,6 +952,23 @@ export class GraphQLService {
                         },
                     });
                 }
+                if (self.scope === 'items') {
+                    VersionCollectionTypes[collection.collection].addResolver({
+                        name: `${collection.collection}_by_version`,
+                        type: VersionCollectionTypes[collection.collection],
+                        args: collection.singleton
+                            ? { version: new GraphQLNonNull(GraphQLString) }
+                            : {
+                                version: new GraphQLNonNull(GraphQLString),
+                                id: new GraphQLNonNull(GraphQLID),
+                            },
+                        resolve: async ({ info, context }) => {
+                            const result = await self.resolveQuery(info);
+                            context['data'] = result;
+                            return result;
+                        },
+                    });
+                }
                 const eventName = `${collection.collection}_mutated`;
                 if (collection.collection in ReadCollectionTypes) {
                     const subscriptionType = schemaComposer.createObjectTC({
@@ -973,7 +1048,7 @@ export class GraphQLService {
                     }
                 }
             }
-            return { ReadCollectionTypes, ReadableCollectionFilterTypes };
+            return { ReadCollectionTypes, VersionCollectionTypes, ReadableCollectionFilterTypes };
         }
         function getWritableTypes() {
             const { CollectionTypes: CreateCollectionTypes } = getTypes('create');
@@ -1135,6 +1210,9 @@ export class GraphQLService {
             if (collection.endsWith('_by_id') && collection in this.schema.collections === false) {
                 collection = collection.slice(0, -6);
             }
+            if (collection.endsWith('_by_version') && collection in this.schema.collections === false) {
+                collection = collection.slice(0, -11);
+            }
         }
         if (args['id']) {
             query.filter = {

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/payload.js

@@ -1,13 +1,13 @@
+import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
 import { parseJSON, toArray } from '@directus/utils';
 import { format, isValid, parseISO } from 'date-fns';
-import flat from 'flat';
+import { unflatten } from 'flat';
 import Joi from 'joi';
 import { clone, cloneDeep, isNil, isObject, isPlainObject, omit, pick } from 'lodash-es';
 import { v4 as uuid } from 'uuid';
 import { parse as wktToGeoJSON } from 'wellknown';
 import { getHelpers } from '../database/helpers/index.js';
 import getDatabase from '../database/index.js';
-import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
 import { generateHash } from '../utils/generate-hash.js';
 import { ItemsService } from './items.js';
 /**
@@ -164,7 +164,7 @@ export class PayloadService {
         const aggregateKeys = Object.keys(payload[0]).filter((key) => key.includes('->'));
         if (aggregateKeys.length) {
             for (const item of payload) {
-                Object.assign(item, flat.unflatten(pick(item, aggregateKeys), { delimiter: '->' }));
+                Object.assign(item, unflatten(pick(item, aggregateKeys), { delimiter: '->' }));
                 aggregateKeys.forEach((key) => delete item[key]);
             }
         }

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 { version } from '../utils/package.js';
-import { toBoolean } from '../utils/to-boolean.js';
 import { SettingsService } from './settings.js';
+const env = useEnv();
+const logger = useLogger();
 export class ServerService {
     knex;
     accountability;
@@ -70,8 +71,6 @@ export class ServerService {
                 default: env['QUERY_LIMIT_DEFAULT'],
                 max: Number.isFinite(env['QUERY_LIMIT_MAX']) ? env['QUERY_LIMIT_MAX'] : -1,
             };
-        }
-        if (this.accountability?.user) {
             if (toBoolean(env['WEBSOCKETS_ENABLED'])) {
                 info['websocket'] = {};
                 info['websocket'].rest = toBoolean(env['WEBSOCKETS_REST_ENABLED'])
@@ -93,6 +92,7 @@ export class ServerService {
             else {
                 info['websocket'] = false;
             }
+            info['version'] = version;
         }
         return info;
     }

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) {