@directus/api 20.1.0 → 21.0.0

package/dist/middleware/check-ip.js

@@ -1,6 +1,6 @@
 import { InvalidIpError } from '@directus/errors';
 import getDatabase from '../database/index.js';
-import { useLogger } from '../logger.js';
+import { useLogger } from '../logger/index.js';
 import asyncHandler from '../utils/async-handler.js';
 import { ipInNetworks } from '../utils/ip-in-networks.js';
 export const checkIP = asyncHandler(async (req, _res, next) => {

package/dist/middleware/error-handler.d.ts

@@ -1,3 +1,3 @@
+/// <reference types="qs" />
 import type { ErrorRequestHandler } from 'express';
-declare const errorHandler: ErrorRequestHandler;
-export default errorHandler;
+export declare const errorHandler: (err: any, req: import("express-serve-static-core").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: import("express-serve-static-core").Response<any, Record<string, any>, number>, next: import("express-serve-static-core").NextFunction) => Promise<ReturnType<ErrorRequestHandler>>;

package/dist/middleware/error-handler.js

@@ -1,40 +1,38 @@
-import { ErrorCode, MethodNotAllowedError, isDirectusError } from '@directus/errors';
-import { isObject, toArray } from '@directus/utils';
+import { ErrorCode, InternalServerError, isDirectusError } from '@directus/errors';
+import { isObject } from '@directus/utils';
 import { getNodeEnv } from '@directus/utils/node';
 import getDatabase from '../database/index.js';
 import emitter from '../emitter.js';
-import { useLogger } from '../logger.js';
-// Note: keep all 4 parameters here. That's how Express recognizes it's the error handler, even if
-// we don't use next
-const errorHandler = (err, req, res, _next) => {
+import { useLogger } from '../logger/index.js';
+const FALLBACK_ERROR = new InternalServerError();
+export const errorHandler = asyncErrorHandler(async (err, req, res) => {
     const logger = useLogger();
-    let payload = {
-        errors: [],
-    };
-    const errors = toArray(err);
+    let errors = [];
     let status = null;
-    for (const error of errors) {
-        if (getNodeEnv() === 'development') {
-            if (isObject(error)) {
-                error['extensions'] = {
-                    ...(error['extensions'] || {}),
-                    stack: error['stack'],
-                };
-            }
+    // It can be assumed that at least one error is given
+    const receivedErrors = Array.isArray(err) ? err : [err];
+    for (const error of receivedErrors) {
+        // In dev mode, if available, expose stack trace under error's extensions data
+        if (getNodeEnv() === 'development' && error instanceof Error && error.stack) {
+            (error.extensions ??= {})['stack'] = error.stack;
         }
         if (isDirectusError(error)) {
             logger.debug(error);
-            if (!status) {
+            if (status === null) {
+                // Use current error status as response status
                 status = error.status;
             }
             else if (status !== error.status) {
-                status = 500;
+                // Fallback if status has already been set by a preceding error
+                // and doesn't match the current one
+                status = FALLBACK_ERROR.status;
             }
-            payload.errors.push({
+            errors.push({
                 message: error.message,
                 extensions: {
-                    code: error.code,
                     ...(error.extensions ?? {}),
+                    // Expose error code under error's extensions data
+                    code: error.code,
                 },
             });
             if (isDirectusError(error, ErrorCode.MethodNotAllowed)) {
@@ -43,45 +41,50 @@ const errorHandler = (err, req, res, _next) => {
         }
         else {
             logger.error(error);
-            status = 500;
+            status = FALLBACK_ERROR.status;
             if (req.accountability?.admin === true) {
                 const localError = isObject(error) ? error : {};
-                const message = localError['message'] ?? typeof error === 'string' ? error : null;
-                payload = {
-                    errors: [
-                        {
-                            message: message || 'An unexpected error occurred.',
-                            extensions: {
-                                code: 'INTERNAL_SERVER_ERROR',
-                                ...(localError['extensions'] ?? {}),
-                            },
+                // Use 'message' prop if available, otherwise if 'error' is a string use that
+                const message = (typeof localError['message'] === 'string' ? localError['message'] : null) ??
+                    (typeof error === 'string' ? error : null);
+                errors = [
+                    {
+                        message: message || FALLBACK_ERROR.message,
+                        extensions: {
+                            code: FALLBACK_ERROR.code,
+                            ...(localError['extensions'] ?? {}),
                         },
-                    ],
-                };
+                    },
+                ];
             }
             else {
-                payload = {
-                    errors: [
-                        {
-                            message: 'An unexpected error occurred.',
-                            extensions: {
-                                code: 'INTERNAL_SERVER_ERROR',
-                            },
-                        },
-                    ],
-                };
+                // Don't expose unknown errors to non-admin users
+                errors = [{ message: FALLBACK_ERROR.message, extensions: { code: FALLBACK_ERROR.code } }];
             }
         }
     }
-    res.status(status ?? 500);
-    emitter
-        .emitFilter('request.error', payload.errors, {}, {
+    res.status(status ?? FALLBACK_ERROR.status);
+    const updatedErrors = await emitter.emitFilter('request.error', errors, {}, {
         database: getDatabase(),
         schema: req.schema,
         accountability: req.accountability ?? null,
-    })
-        .then((updatedErrors) => {
-        return res.json({ ...payload, errors: updatedErrors });
     });
-};
-export default errorHandler;
+    return res.json({ errors: updatedErrors });
+});
+function asyncErrorHandler(fn) {
+    return (err, req, res, next) => fn(err, req, res, next).catch((error) => {
+        // To be on the safe side and ensure this doesn't lead to an unhandled (potentially crashing) error
+        try {
+            const logger = useLogger();
+            logger.error(error, 'Unexpected error in error handler');
+        }
+        catch {
+            // Ignore
+        }
+        // Delegate to default error handler to close the connection
+        if (res.headersSent)
+            return next(err);
+        res.status(FALLBACK_ERROR.status);
+        return res.json({ errors: [{ message: FALLBACK_ERROR.message, extensions: { code: FALLBACK_ERROR.code } }] });
+    });
+}

package/dist/middleware/rate-limiter-global.js

@@ -1,6 +1,6 @@
 import { useEnv } from '@directus/env';
 import { HitRateLimitError } from '@directus/errors';
-import { useLogger } from '../logger.js';
+import { useLogger } from '../logger/index.js';
 import { createRateLimiter } from '../rate-limiter.js';
 import asyncHandler from '../utils/async-handler.js';
 import { validateEnv } from '../utils/validate-env.js';

package/dist/middleware/respond.js

@@ -1,7 +1,7 @@
 import { useEnv } from '@directus/env';
 import { parse as parseBytesConfiguration } from 'bytes';
 import { getCache, setCacheValue } from '../cache.js';
-import { useLogger } from '../logger.js';
+import { useLogger } from '../logger/index.js';
 import { ExportService } from '../services/import-export.js';
 import asyncHandler from '../utils/async-handler.js';
 import { getCacheControlHeader } from '../utils/get-cache-headers.js';

package/dist/operations/log/index.js

@@ -1,6 +1,6 @@
 import { defineOperationApi } from '@directus/extensions';
 import { optionToString } from '@directus/utils';
-import { useLogger } from '../../logger.js';
+import { useLogger } from '../../logger/index.js';
 export default defineOperationApi({
     id: 'log',
     handler: ({ message }) => {

package/dist/operations/mail/index.js

@@ -1,7 +1,7 @@
 import { defineOperationApi } from '@directus/extensions';
 import { MailService } from '../../services/mail/index.js';
 import { md } from '../../utils/md.js';
-import { useLogger } from '../../logger.js';
+import { useLogger } from '../../logger/index.js';
 const logger = useLogger();
 export default defineOperationApi({
     id: 'mail',

package/dist/request/is-denied-ip.js

@@ -1,6 +1,6 @@
 import { useEnv } from '@directus/env';
 import os from 'node:os';
-import { useLogger } from '../logger.js';
+import { useLogger } from '../logger/index.js';
 import { ipInNetworks } from '../utils/ip-in-networks.js';
 export function isDeniedIp(ip) {
     const env = useEnv();

package/dist/server.js

@@ -10,7 +10,7 @@ import url from 'url';
 import createApp from './app.js';
 import getDatabase from './database/index.js';
 import emitter from './emitter.js';
-import { useLogger } from './logger.js';
+import { useLogger } from './logger/index.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
 import { getIPFromReq } from './utils/get-ip-from-req.js';
 import { createSubscriptionController, createWebSocketController, getSubscriptionController, getWebSocketController, } from './websocket/controllers/index.js';

package/dist/services/activity.js

@@ -2,7 +2,7 @@ import { Action } from '@directus/constants';
 import { useEnv } from '@directus/env';
 import { ErrorCode, isDirectusError } from '@directus/errors';
 import { uniq } from 'lodash-es';
-import { useLogger } from '../logger.js';
+import { useLogger } from '../logger/index.js';
 import { getPermissions } from '../utils/get-permissions.js';
 import { isValidUuid } from '../utils/is-valid-uuid.js';
 import { Url } from '../utils/url.js';

package/dist/services/assets.js

@@ -7,13 +7,14 @@ import path from 'path';
 import sharp from 'sharp';
 import { SUPPORTED_IMAGE_TRANSFORM_FORMATS } from '../constants.js';
 import getDatabase from '../database/index.js';
-import { useLogger } from '../logger.js';
+import { useLogger } from '../logger/index.js';
 import { getStorage } from '../storage/index.js';
 import { getMilliseconds } from '../utils/get-milliseconds.js';
 import { isValidUuid } from '../utils/is-valid-uuid.js';
 import * as TransformationUtils from '../utils/transformations.js';
 import { AuthorizationService } from './authorization.js';
 import { FilesService } from './files.js';
+import { getSharpInstance } from './files/lib/get-sharp-instance.js';
 const env = useEnv();
 const logger = useLogger();
 export class AssetsService {
@@ -116,11 +117,7 @@ export class AssetsService {
                 });
             }
             const readStream = await storage.location(file.storage).read(file.filename_disk, range);
-            const transformer = sharp({
-                limitInputPixels: Math.pow(env['ASSETS_TRANSFORM_IMAGE_MAX_DIMENSION'], 2),
-                sequentialRead: true,
-                failOn: env['ASSETS_INVALID_IMAGE_SENSITIVITY_LEVEL'],
-            });
+            const transformer = getSharpInstance();
             transformer.timeout({
                 seconds: clamp(Math.round(getMilliseconds(env['ASSETS_TRANSFORM_TIMEOUT'], 0) / 1000), 1, 3600),
             });

package/dist/services/fields.d.ts

@@ -16,8 +16,11 @@ export declare class FieldsService {
     schema: SchemaOverview;
     cache: Keyv<any> | null;
     systemCache: Keyv<any>;
+    schemaCache: Keyv<any>;
     constructor(options: AbstractServiceOptions);
     private get hasReadAccess();
+    columnInfo(collection?: string): Promise<Column[]>;
+    columnInfo(collection: string, field: string): Promise<Column>;
     readAll(collection?: string): Promise<Field[]>;
     readOne(collection: string, field: string): Promise<Record<string, any>>;
     createField(collection: string, field: Partial<Field> & {

package/dist/services/fields.js

@@ -3,7 +3,7 @@ import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
 import { createInspector } from '@directus/schema';
 import { addFieldFlag, toArray } from '@directus/utils';
 import { isEqual, isNil, merge } from 'lodash-es';
-import { clearSystemCache, getCache } from '../cache.js';
+import { clearSystemCache, getCache, getCacheValue, setCacheValue } from '../cache.js';
 import { ALIAS_TYPES } from '../constants.js';
 import { translateDatabaseError } from '../database/errors/translate.js';
 import { getHelpers } from '../database/helpers/index.js';
@@ -19,7 +19,9 @@ import { transaction } from '../utils/transaction.js';
 import { ItemsService } from './items.js';
 import { PayloadService } from './payload.js';
 import { RelationsService } from './relations.js';
+import { useEnv } from '@directus/env';
 const systemFieldRows = getSystemFieldRowsWithAuthProviders();
+const env = useEnv();
 export class FieldsService {
     knex;
     helpers;
@@ -30,6 +32,7 @@ export class FieldsService {
     schema;
     cache;
     systemCache;
+    schemaCache;
     constructor(options) {
         this.knex = options.knex || getDatabase();
         this.helpers = getHelpers(this.knex);
@@ -38,15 +41,36 @@ export class FieldsService {
         this.itemsService = new ItemsService('directus_fields', options);
         this.payloadService = new PayloadService('directus_fields', options);
         this.schema = options.schema;
-        const { cache, systemCache } = getCache();
+        const { cache, systemCache, localSchemaCache } = getCache();
         this.cache = cache;
         this.systemCache = systemCache;
+        this.schemaCache = localSchemaCache;
     }
     get hasReadAccess() {
         return !!this.accountability?.permissions?.find((permission) => {
             return permission.collection === 'directus_fields' && permission.action === 'read';
         });
     }
+    async columnInfo(collection, field) {
+        const schemaCacheIsEnabled = Boolean(env['CACHE_SCHEMA']);
+        let columnInfo = null;
+        if (schemaCacheIsEnabled) {
+            columnInfo = await getCacheValue(this.schemaCache, 'columnInfo');
+        }
+        if (!columnInfo) {
+            columnInfo = await this.schemaInspector.columnInfo();
+            if (schemaCacheIsEnabled) {
+                setCacheValue(this.schemaCache, 'columnInfo', columnInfo);
+            }
+        }
+        if (collection) {
+            columnInfo = columnInfo.filter((column) => column.table === collection);
+        }
+        if (field) {
+            return columnInfo.find((column) => column.name === field);
+        }
+        return columnInfo;
+    }
     async readAll(collection) {
         let fields;
         if (this.accountability && this.accountability.admin !== true && this.hasReadAccess === false) {
@@ -67,7 +91,7 @@ export class FieldsService {
             fields = (await nonAuthorizedItemsService.readByQuery({ limit: -1 }));
             fields.push(...systemFieldRows);
         }
-        const columns = (await this.schemaInspector.columnInfo(collection)).map((column) => ({
+        const columns = (await this.columnInfo(collection)).map((column) => ({
             ...column,
             default_value: getDefaultValue(column, fields.find((field) => field.collection === column.table && field.field === column.name)),
         }));
@@ -175,7 +199,7 @@ export class FieldsService {
             fieldInfo ||
                 systemFieldRows.find((fieldMeta) => fieldMeta.collection === collection && fieldMeta.field === field);
         try {
-            column = await this.schemaInspector.columnInfo(collection, field);
+            column = await this.columnInfo(collection, field);
         }
         catch {
             // Do nothing
@@ -330,7 +354,7 @@ export class FieldsService {
                 throw new InvalidPayloadError({ reason: 'Alias type cannot be changed' });
             }
             if (hookAdjustedField.schema) {
-                const existingColumn = await this.schemaInspector.columnInfo(collection, hookAdjustedField.field);
+                const existingColumn = await this.columnInfo(collection, hookAdjustedField.field);
                 if (hookAdjustedField.schema?.is_nullable === true && existingColumn.is_primary_key) {
                     throw new InvalidPayloadError({ reason: 'Primary key cannot be null' });
                 }

package/dist/services/files/lib/get-sharp-instance.d.ts

@@ -0,0 +1,2 @@
+import { type Sharp } from 'sharp';
+export declare function getSharpInstance(): Sharp;

package/dist/services/files/lib/get-sharp-instance.js

@@ -0,0 +1,10 @@
+import { useEnv } from '@directus/env';
+import sharp, {} from 'sharp';
+export function getSharpInstance() {
+    const env = useEnv();
+    return sharp({
+        limitInputPixels: Math.trunc(Math.pow(env['ASSETS_TRANSFORM_IMAGE_MAX_DIMENSION'], 2)),
+        sequentialRead: true,
+        failOn: env['ASSETS_INVALID_IMAGE_SENSITIVITY_LEVEL'],
+    });
+}

package/dist/services/files/utils/get-metadata.js

@@ -1,19 +1,20 @@
+import { useEnv } from '@directus/env';
 import exif, {} from 'exif-reader';
 import { parse as parseIcc } from 'icc';
 import { pick } from 'lodash-es';
 import { pipeline } from 'node:stream/promises';
-import sharp from 'sharp';
-import { useEnv } from '@directus/env';
-import { useLogger } from '../../../logger.js';
+import { useLogger } from '../../../logger/index.js';
+import { getSharpInstance } from '../lib/get-sharp-instance.js';
 import { parseIptc, parseXmp } from './parse-image-metadata.js';
 const env = useEnv();
 const logger = useLogger();
 export async function getMetadata(stream, allowList = env['FILE_METADATA_ALLOW_LIST']) {
-    return new Promise((resolve, reject) => {
-        pipeline(stream, sharp().metadata(async (err, sharpMetadata) => {
+    const transformer = getSharpInstance();
+    return new Promise((resolve) => {
+        pipeline(stream, transformer.metadata(async (err, sharpMetadata) => {
             if (err) {
-                reject(err);
-                return;
+                logger.error(err);
+                return resolve({});
             }
             const metadata = {};
             if (sharpMetadata.orientation && sharpMetadata.orientation >= 5) {

package/dist/services/files.js

@@ -11,7 +11,7 @@ import path from 'path';
 import url from 'url';
 import { RESUMABLE_UPLOADS } from '../constants.js';
 import emitter from '../emitter.js';
-import { useLogger } from '../logger.js';
+import { useLogger } from '../logger/index.js';
 import { getAxios } from '../request/index.js';
 import { getStorage } from '../storage/index.js';
 import { extractMetadata } from './files/lib/extract-metadata.js';
@@ -57,6 +57,10 @@ export class FilesService extends ItemsService {
         const fileExtension = path.extname(payload.filename_download) || (payload.type && '.' + extension(payload.type)) || '';
         // The filename_disk is the FINAL filename on disk
         payload.filename_disk ||= primaryKey + (fileExtension || '');
+        // If the filename_disk extension doesn't match the new mimetype, update it
+        if (isReplacement === true && path.extname(payload.filename_disk) !== fileExtension) {
+            payload.filename_disk = primaryKey + (fileExtension || '');
+        }
         // Temp filename is used for replacements
         const tempFilenameDisk = 'temp_' + payload.filename_disk;
         if (!payload.type) {
@@ -125,6 +129,7 @@ export class FilesService extends ItemsService {
         const { size } = await storage.location(data.storage).stat(payload.filename_disk);
         payload.filesize = size;
         const metadata = await extractMetadata(data.storage, payload);
+        payload.uploaded_on = new Date().toISOString();
         // We do this in a service without accountability. Even if you don't have update permissions to the file,
         // we still want to be able to set the extracted values from the file on create
         const sudoService = new ItemsService('directus_files', {

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

@@ -1,5 +1,5 @@
 import { isDirectusError } from '@directus/errors';
-import { useLogger } from '../../../logger.js';
+import { useLogger } from '../../../logger/index.js';
 const processError = (accountability, error) => {
     const logger = useLogger();
     logger.error(error);

package/dist/services/graphql/utils/sanitize-gql-schema.js

@@ -1,4 +1,4 @@
-import { useLogger } from '../../../logger.js';
+import { useLogger } from '../../../logger/index.js';
 /**
  * Regex was taken from the spec
  * https://spec.graphql.org/June2018/#sec-Names

package/dist/services/import-export.js

@@ -14,7 +14,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 { useLogger } from '../logger.js';
+import { useLogger } from '../logger/index.js';
 import { getDateFormatted } from '../utils/get-date-formatted.js';
 import { getService } from '../utils/get-service.js';
 import { transaction } from '../utils/transaction.js';

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

@@ -14,7 +14,7 @@ export declare class MailService {
     knex: Knex;
     mailer: Transporter;
     constructor(opts: AbstractServiceOptions);
-    send<T>(options: EmailOptions): Promise<T>;
+    send<T>(options: EmailOptions): Promise<T | null>;
     private renderTemplate;
     private getDefaultTemplateData;
 }

package/dist/services/mail/index.js

@@ -5,9 +5,10 @@ import { Liquid } from 'liquidjs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import getDatabase from '../../database/index.js';
-import { useLogger } from '../../logger.js';
+import { useLogger } from '../../logger/index.js';
 import getMailer from '../../mailer.js';
 import { Url } from '../../utils/url.js';
+import emitter from '../../emitter.js';
 const env = useEnv();
 const logger = useLogger();
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -35,7 +36,14 @@ export class MailService {
         }
     }
     async send(options) {
-        const { template, ...emailOptions } = options;
+        const payload = await emitter.emitFilter(`email.send`, options, {
+            database: getDatabase(),
+            schema: null,
+            accountability: null,
+        });
+        if (!payload)
+            return null;
+        const { template, ...emailOptions } = payload;
         let { html } = options;
         const defaultTemplateData = await this.getDefaultTemplateData();
         const from = `${defaultTemplateData.projectName} <${options.from || env['EMAIL_FROM']}>`;

package/dist/services/notifications.js

@@ -1,5 +1,5 @@
 import { useEnv } from '@directus/env';
-import { useLogger } from '../logger.js';
+import { useLogger } from '../logger/index.js';
 import { md } from '../utils/md.js';
 import { Url } from '../utils/url.js';
 import { ItemsService } from './items.js';

package/dist/services/relations.d.ts

@@ -1,4 +1,4 @@
-import type { SchemaInspector } from '@directus/schema';
+import type { ForeignKey, SchemaInspector } from '@directus/schema';
 import type { Accountability, Relation, RelationMeta, SchemaOverview } from '@directus/types';
 import type Keyv from 'keyv';
 import type { Knex } from 'knex';
@@ -14,8 +14,10 @@ export declare class RelationsService {
     schema: SchemaOverview;
     relationsItemService: ItemsService<RelationMeta>;
     systemCache: Keyv<any>;
+    schemaCache: Keyv<any>;
     helpers: Helpers;
     constructor(options: AbstractServiceOptions);
+    foreignKeys(collection?: string): Promise<ForeignKey[]>;
     readAll(collection?: string, opts?: QueryOptions): Promise<Relation[]>;
     readOne(collection: string, field: string): Promise<Relation>;
     /**

package/dist/services/relations.js

@@ -2,7 +2,7 @@ import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
 import { createInspector } from '@directus/schema';
 import { systemRelationRows } from '@directus/system-data';
 import { toArray } from '@directus/utils';
-import { clearSystemCache, getCache } from '../cache.js';
+import { clearSystemCache, getCache, getCacheValue, setCacheValue } from '../cache.js';
 import { getHelpers } from '../database/helpers/index.js';
 import getDatabase, { getSchemaInspector } from '../database/index.js';
 import emitter from '../emitter.js';
@@ -11,6 +11,8 @@ import { getSchema } from '../utils/get-schema.js';
 import { transaction } from '../utils/transaction.js';
 import { ItemsService } from './items.js';
 import { PermissionsService } from './permissions/index.js';
+import { useEnv } from '@directus/env';
+const env = useEnv();
 export class RelationsService {
     knex;
     permissionsService;
@@ -19,6 +21,7 @@ export class RelationsService {
     schema;
     relationsItemService;
     systemCache;
+    schemaCache;
     helpers;
     constructor(options) {
         this.knex = options.knex || getDatabase();
@@ -33,9 +36,28 @@ export class RelationsService {
             // allowed to extract the relations regardless of permissions to directus_relations. This
             // happens in `filterForbidden` down below
         });
-        this.systemCache = getCache().systemCache;
+        const cache = getCache();
+        this.systemCache = cache.systemCache;
+        this.schemaCache = cache.localSchemaCache;
         this.helpers = getHelpers(this.knex);
     }
+    async foreignKeys(collection) {
+        const schemaCacheIsEnabled = Boolean(env['CACHE_SCHEMA']);
+        let foreignKeys = null;
+        if (schemaCacheIsEnabled) {
+            foreignKeys = await getCacheValue(this.schemaCache, 'foreignKeys');
+        }
+        if (!foreignKeys) {
+            foreignKeys = await this.schemaInspector.foreignKeys();
+            if (schemaCacheIsEnabled) {
+                setCacheValue(this.schemaCache, 'foreignKeys', foreignKeys);
+            }
+        }
+        if (collection) {
+            return foreignKeys.filter((row) => row.table === collection);
+        }
+        return foreignKeys;
+    }
     async readAll(collection, opts) {
         if (this.accountability && this.accountability.admin !== true && this.hasReadAccess === false) {
             throw new ForbiddenError();
@@ -58,7 +80,7 @@ export class RelationsService {
                 return true;
             return metaRow.many_collection === collection;
         });
-        const schemaRows = await this.schemaInspector.foreignKeys(collection);
+        const schemaRows = await this.foreignKeys(collection);
         const results = this.stitchRelations(metaRows, schemaRows);
         return await this.filterForbidden(results);
     }
@@ -95,7 +117,7 @@ export class RelationsService {
                 ],
             },
         });
-        const schemaRow = (await this.schemaInspector.foreignKeys(collection)).find((foreignKey) => foreignKey.column === field);
+        const schemaRow = (await this.foreignKeys(collection)).find((foreignKey) => foreignKey.column === field);
         const stitched = this.stitchRelations(metaRow, schemaRow ? [schemaRow] : []);
         const results = await this.filterForbidden(stitched);
         if (results.length === 0) {
@@ -310,7 +332,7 @@ export class RelationsService {
         const nestedActionEvents = [];
         try {
             await transaction(this.knex, async (trx) => {
-                const existingConstraints = await this.schemaInspector.foreignKeys();
+                const existingConstraints = await this.foreignKeys();
                 const constraintNames = existingConstraints.map((key) => key.constraint_name);
                 if (existingRelation.schema?.constraint_name &&
                     constraintNames.includes(existingRelation.schema.constraint_name)) {

package/dist/services/server.js

@@ -6,7 +6,7 @@ import { Readable } from 'node:stream';
 import { performance } from 'perf_hooks';
 import { getCache } from '../cache.js';
 import getDatabase, { hasDatabaseConnection } from '../database/index.js';
-import { useLogger } from '../logger.js';
+import { useLogger } from '../logger/index.js';
 import getMailer from '../mailer.js';
 import { rateLimiterGlobal } from '../middleware/rate-limiter-global.js';
 import { rateLimiter } from '../middleware/rate-limiter-ip.js';

package/dist/services/shares.js

@@ -2,7 +2,7 @@ import { useEnv } from '@directus/env';
 import { ForbiddenError, InvalidCredentialsError } from '@directus/errors';
 import argon2 from 'argon2';
 import jwt from 'jsonwebtoken';
-import { useLogger } from '../logger.js';
+import { useLogger } from '../logger/index.js';
 import { getMilliseconds } from '../utils/get-milliseconds.js';
 import { getSecret } from '../utils/get-secret.js';
 import { md } from '../utils/md.js';