@directus/api 15.0.0 → 16.0.0

package/dist/extensions/manager.js

@@ -1,25 +1,26 @@
 import { JAVASCRIPT_FILE_EXTS } from '@directus/constants';
+import { useEnv } from '@directus/env';
 import { APP_SHARED_DEPS, HYBRID_EXTENSION_TYPES, NESTED_EXTENSION_TYPES } from '@directus/extensions';
 import { generateExtensionsEntrypoint } from '@directus/extensions/node';
-import { isIn, isTypeIn, pluralize } from '@directus/utils';
-import { pathToRelativeUrl } from '@directus/utils/node';
+import { isIn, isTypeIn, pluralize, toBoolean } from '@directus/utils';
+import { getNodeEnv } from '@directus/utils/node';
 import aliasDefault from '@rollup/plugin-alias';
 import nodeResolveDefault from '@rollup/plugin-node-resolve';
 import virtualDefault from '@rollup/plugin-virtual';
 import chokidar, { FSWatcher } from 'chokidar';
 import express, { Router } from 'express';
 import ivm from 'isolated-vm';
-import { clone } from 'lodash-es';
+import { clone, debounce } from 'lodash-es';
 import { readFile, readdir } from 'node:fs/promises';
+import os from 'node:os';
 import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import path from 'path';
 import { rollup } from 'rollup';
 import getDatabase from '../database/index.js';
 import emitter, { Emitter } from '../emitter.js';
-import env from '../env.js';
 import { getFlowManager } from '../flows.js';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 import * as services from '../services/index.js';
 import { deleteFromRequireCache } from '../utils/delete-from-require-cache.js';
 import getModuleDefault from '../utils/get-module-default.js';
@@ -27,7 +28,6 @@ import { getSchema } from '../utils/get-schema.js';
 import { importFileUrl } from '../utils/import-file-url.js';
 import { JobQueue } from '../utils/job-queue.js';
 import { scheduleSynchronizedJob, validateCron } from '../utils/schedule.js';
-import { toBoolean } from '../utils/to-boolean.js';
 import { getExtensionsPath } from './lib/get-extensions-path.js';
 import { getExtensionsSettings } from './lib/get-extensions-settings.js';
 import { getExtensions } from './lib/get-extensions.js';
@@ -41,9 +41,10 @@ const virtual = virtualDefault;
 const alias = aliasDefault;
 const nodeResolve = nodeResolveDefault;
 const __dirname = dirname(fileURLToPath(import.meta.url));
+const env = useEnv();
 const defaultOptions = {
     schedule: true,
-    watch: env['EXTENSIONS_AUTO_RELOAD'] && env['NODE_ENV'] !== 'development',
+    watch: env['EXTENSIONS_AUTO_RELOAD'] && getNodeEnv() !== 'development',
 };
 export class ExtensionManager {
     options = defaultOptions;
@@ -109,6 +110,7 @@ export class ExtensionManager {
      * @param {boolean} options.watch - Whether or not to watch the local extensions folder for changes
      */
     async initialize(options = {}) {
+        const logger = useLogger();
         this.options = {
             ...defaultOptions,
             ...options,
@@ -134,6 +136,7 @@ export class ExtensionManager {
      * Load all extensions from disk and register them in their respective places
      */
     async load() {
+        const logger = useLogger();
         try {
             await syncExtensions();
         }
@@ -171,12 +174,17 @@ export class ExtensionManager {
      * Reload all the extensions. Will unload if extensions have already been loaded
      */
     reload() {
+        if (this.reloadQueue.size > 0) {
+            // The pending job in the queue will already handle the additional changes
+            return;
+        }
+        const logger = useLogger();
         this.reloadQueue.enqueue(async () => {
             if (this.isLoaded) {
-                logger.info('Reloading extensions');
                 const prevExtensions = clone(this.extensions);
                 await this.unload();
                 await this.load();
+                logger.info('Extensions reloaded');
                 const added = this.extensions.filter((extension) => !prevExtensions.some((prevExtension) => extension.path === prevExtension.path));
                 const removed = prevExtensions.filter((prevExtension) => !this.extensions.some((extension) => prevExtension.path === extension.path));
                 this.updateWatchedExtensions(added, removed);
@@ -231,27 +239,34 @@ export class ExtensionManager {
      * Start the chokidar watcher for extensions on the local filesystem
      */
     initializeWatcher() {
+        const logger = useLogger();
         logger.info('Watching extensions for changes...');
-        const extensionDirUrl = pathToRelativeUrl(getExtensionsPath());
-        const localExtensionUrls = NESTED_EXTENSION_TYPES.flatMap((type) => {
-            const typeDir = path.posix.join(extensionDirUrl, pluralize(type));
+        const extensionsDir = path.resolve(getExtensionsPath());
+        const rootPackageJson = path.resolve(env['PACKAGE_FILE_LOCATION'], 'package.json');
+        const localExtensions = path.join(extensionsDir, '*', 'package.json');
+        const nestedExtensions = NESTED_EXTENSION_TYPES.flatMap((type) => {
+            const typeDir = path.join(extensionsDir, pluralize(type));
             if (isIn(type, HYBRID_EXTENSION_TYPES)) {
                 return [
-                    path.posix.join(typeDir, '*', `app.{${JAVASCRIPT_FILE_EXTS.join()}}`),
-                    path.posix.join(typeDir, '*', `api.{${JAVASCRIPT_FILE_EXTS.join()}}`),
+                    path.join(typeDir, '*', `app.{${JAVASCRIPT_FILE_EXTS.join()}}`),
+                    path.join(typeDir, '*', `api.{${JAVASCRIPT_FILE_EXTS.join()}}`),
                 ];
             }
             else {
-                return path.posix.join(typeDir, '*', `index.{${JAVASCRIPT_FILE_EXTS.join()}}`);
+                return path.join(typeDir, '*', `index.{${JAVASCRIPT_FILE_EXTS.join()}}`);
             }
         });
-        this.watcher = chokidar.watch([path.resolve('package.json'), path.posix.join(extensionDirUrl, '*', 'package.json'), ...localExtensionUrls], {
+        this.watcher = chokidar.watch([rootPackageJson, localExtensions, ...nestedExtensions], {
             ignoreInitial: true,
+            // dotdirs are watched by default and frequently found in 'node_modules'
+            ignored: `${extensionsDir}/**/node_modules/**`,
+            // on macOS dotdirs in linked extensions are watched too
+            followSymlinks: os.platform() === 'darwin' ? false : true,
         });
         this.watcher
-            .on('add', () => this.reload())
-            .on('change', () => this.reload())
-            .on('unlink', () => this.reload());
+            .on('add', debounce(() => this.reload(), 500))
+            .on('change', debounce(() => this.reload(), 650))
+            .on('unlink', debounce(() => this.reload(), 2000));
     }
     /**
      * Close and destroy the local filesystem watcher if enabled
@@ -268,8 +283,12 @@ export class ExtensionManager {
      */
     updateWatchedExtensions(added, removed = []) {
         if (this.watcher) {
+            const extensionDir = path.resolve(getExtensionsPath());
+            const nestedExtensionDirs = NESTED_EXTENSION_TYPES.map((type) => {
+                return path.join(extensionDir, pluralize(type));
+            });
             const toPackageExtensionPaths = (extensions) => extensions
-                .filter((extension) => !extension.local || extension.type === 'bundle')
+                .filter((extension) => !nestedExtensionDirs.some((path) => extension.path.startsWith(path)))
                 .flatMap((extension) => isTypeIn(extension, HYBRID_EXTENSION_TYPES) || extension.type === 'bundle'
                 ? [
                     path.resolve(extension.path, extension.entrypoint.app),
@@ -287,6 +306,7 @@ export class ExtensionManager {
      * run.
      */
     async generateExtensionBundle() {
+        const logger = useLogger();
         const sharedDepsMapping = await getSharedDepsMapping(APP_SHARED_DEPS);
         const internalImports = Object.entries(sharedDepsMapping).map(([name, path]) => ({
             find: name,
@@ -316,6 +336,7 @@ export class ExtensionManager {
         return null;
     }
     async registerSandboxedApiExtension(extension) {
+        const logger = useLogger();
         const sandboxMemory = Number(env['EXTENSIONS_SANDBOX_MEMORY']);
         const sandboxTimeout = Number(env['EXTENSIONS_SANDBOX_TIMEOUT']);
         const entrypointPath = path.resolve(extension.path, isTypeIn(extension, HYBRID_EXTENSION_TYPES) ? extension.entrypoint.api : extension.entrypoint);
@@ -503,6 +524,7 @@ export class ExtensionManager {
      * Register a single hook
      */
     registerHook(hookRegistrationCallback, name) {
+        const logger = useLogger();
         let scheduleIndex = 0;
         const unregisterFunctions = [];
         const hookRegistrationContext = {
@@ -582,6 +604,7 @@ export class ExtensionManager {
      * Register an individual endpoint
      */
     registerEndpoint(config, name) {
+        const logger = useLogger();
         const endpointRegistrationCallback = typeof config === 'function' ? config : config.handler;
         const nameWithoutType = name.includes(':') ? name.split(':')[0] : name;
         const routeName = typeof config === 'function' ? nameWithoutType : config.id;
@@ -623,6 +646,7 @@ export class ExtensionManager {
      * Otherwise, the error will only be logged as a warning.
      */
     handleExtensionError({ error, reason }) {
+        const logger = useLogger();
         if (toBoolean(env['EXTENSIONS_MUST_LOAD'])) {
             logger.error('EXTENSION_MUST_LOAD is enabled and an extension failed to load.');
             logger.error(reason);

package/dist/flows.js

@@ -1,13 +1,13 @@
 import { Action } from '@directus/constants';
+import { useEnv } from '@directus/env';
+import { ForbiddenError } from '@directus/errors';
 import { applyOptionsData, getRedactedString, isValidJSON, parseJSON, toArray } from '@directus/utils';
 import { omit, pick } from 'lodash-es';
 import { get } from 'micromustache';
+import { useBus } from './bus/index.js';
 import getDatabase from './database/index.js';
 import emitter from './emitter.js';
-import env from './env.js';
-import { ForbiddenError } from '@directus/errors';
-import logger from './logger.js';
-import { getMessenger } from './messenger.js';
+import { useLogger } from './logger.js';
 import { ActivityService } from './services/activity.js';
 import { FlowsService } from './services/flows.js';
 import * as services from './services/index.js';
@@ -40,9 +40,11 @@ class FlowManager {
     reloadQueue;
     envs;
     constructor() {
+        const env = useEnv();
+        const logger = useLogger();
         this.reloadQueue = new JobQueue();
         this.envs = env['FLOWS_ENV_ALLOW_LIST'] ? pick(env, toArray(env['FLOWS_ENV_ALLOW_LIST'])) : {};
-        const messenger = getMessenger();
+        const messenger = useBus();
         messenger.subscribe('flows', (event) => {
             if (event['type'] === 'reload') {
                 this.reloadQueue.enqueue(async () => {
@@ -63,7 +65,7 @@ class FlowManager {
         }
     }
     async reload() {
-        const messenger = getMessenger();
+        const messenger = useBus();
         messenger.publish('flows', { type: 'reload' });
     }
     addOperation(id, operation) {
@@ -73,6 +75,7 @@ class FlowManager {
         this.operations.delete(id);
     }
     async runOperationFlow(id, data, context) {
+        const logger = useLogger();
         if (!(id in this.operationFlowHandlers)) {
             logger.warn(`Couldn't find operation triggered flow with id "${id}"`);
             return null;
@@ -81,6 +84,7 @@ class FlowManager {
         return handler(data, context);
     }
     async runWebhookFlow(id, data, context) {
+        const logger = useLogger();
         if (!(id in this.webhookFlowHandlers)) {
             logger.warn(`Couldn't find webhook or manual triggered flow with id "${id}"`);
             throw new ForbiddenError();
@@ -89,6 +93,7 @@ class FlowManager {
         return handler(data, context);
     }
     async load() {
+        const logger = useLogger();
         const flowsService = new FlowsService({ knex: getDatabase(), schema: await getSchema() });
         const flows = await flowsService.readByQuery({
             filter: { status: { _eq: 'active' } },
@@ -305,6 +310,7 @@ class FlowManager {
         return undefined;
     }
     async executeOperation(operation, keyedData, context = {}) {
+        const logger = useLogger();
         if (!this.operations.has(operation.type)) {
             logger.warn(`Couldn't find operation ${operation.type}`);
             return { successor: null, status: 'unknown', data: null, options: null };
@@ -314,7 +320,7 @@ class FlowManager {
         try {
             let result = await handler(options, {
                 services,
-                env,
+                env: useEnv(),
                 database: getDatabase(),
                 logger,
                 getSchema,

package/dist/logger.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="qs" />
 import type { RequestHandler } from 'express';
-import { type LoggerOptions } from 'pino';
-export declare const httpLoggerOptions: LoggerOptions;
-declare const logger: import("pino").Logger<never>;
-export declare const httpLoggerEnvConfig: Record<string, any>;
-export declare const expressLogger: RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
-export declare const useLogger: () => import("pino").Logger<never>;
-export default logger;
+import { type Logger } from 'pino';
+export declare const _cache: {
+    logger: Logger<never> | undefined;
+};
+export declare const useLogger: () => Logger<never>;
+export declare const createLogger: () => Logger<never>;
+export declare const createExpressLogger: () => RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;

package/dist/logger.js

@@ -1,112 +1,136 @@
+import { useEnv } from '@directus/env';
 import { REDACTED_TEXT, toArray } from '@directus/utils';
 import { merge } from 'lodash-es';
 import { URL } from 'node:url';
 import { pino } from 'pino';
 import { pinoHttp, stdSerializers } from 'pino-http';
-import env from './env.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
-const pinoOptions = {
-    level: env['LOG_LEVEL'] || 'info',
-    redact: {
-        paths: ['req.headers.authorization', 'req.headers.cookie'],
-        censor: REDACTED_TEXT,
-    },
-};
-export const httpLoggerOptions = {
-    level: env['LOG_LEVEL'] || 'info',
-    redact: {
-        paths: ['req.headers.authorization', 'req.headers.cookie'],
-        censor: REDACTED_TEXT,
-    },
+export const _cache = { logger: undefined };
+export const useLogger = () => {
+    if (_cache.logger) {
+        return _cache.logger;
+    }
+    _cache.logger = createLogger();
+    return _cache.logger;
 };
-if (env['LOG_STYLE'] !== 'raw') {
-    pinoOptions.transport = {
-        target: 'pino-pretty',
-        options: {
-            ignore: 'hostname,pid',
-            sync: true,
+export const createLogger = () => {
+    const env = useEnv();
+    const pinoOptions = {
+        level: env['LOG_LEVEL'] || 'info',
+        redact: {
+            paths: ['req.headers.authorization', 'req.headers.cookie'],
+            censor: REDACTED_TEXT,
         },
     };
-    httpLoggerOptions.transport = {
-        target: 'pino-http-print',
-        options: {
-            all: true,
-            translateTime: 'SYS:HH:MM:ss',
-            relativeUrl: true,
-            prettyOptions: {
+    if (env['LOG_STYLE'] !== 'raw') {
+        pinoOptions.transport = {
+            target: 'pino-pretty',
+            options: {
                 ignore: 'hostname,pid',
                 sync: true,
             },
+        };
+    }
+    const loggerEnvConfig = getConfigFromEnv('LOGGER_', 'LOGGER_HTTP');
+    // Expose custom log levels into formatter function
+    if (loggerEnvConfig['levels']) {
+        const customLogLevels = {};
+        for (const el of toArray(loggerEnvConfig['levels'])) {
+            const key_val = el.split(':');
+            customLogLevels[key_val[0].trim()] = key_val[1].trim();
+        }
+        pinoOptions.formatters = {
+            level(label, number) {
+                return {
+                    severity: customLogLevels[label] || 'info',
+                    level: number,
+                };
+            },
+        };
+        delete loggerEnvConfig['levels'];
+    }
+    return pino(merge(pinoOptions, loggerEnvConfig));
+};
+export const createExpressLogger = () => {
+    const env = useEnv();
+    const httpLoggerEnvConfig = getConfigFromEnv('LOGGER_HTTP', ['LOGGER_HTTP_LOGGER']);
+    const loggerEnvConfig = getConfigFromEnv('LOGGER_', 'LOGGER_HTTP');
+    const httpLoggerOptions = {
+        level: env['LOG_LEVEL'] || 'info',
+        redact: {
+            paths: ['req.headers.authorization', 'req.headers.cookie'],
+            censor: REDACTED_TEXT,
         },
     };
-}
-if (env['LOG_STYLE'] === 'raw') {
-    httpLoggerOptions.redact = {
-        paths: ['req.headers.authorization', 'req.headers.cookie', 'res.headers'],
-        censor: (value, pathParts) => {
-            const path = pathParts.join('.');
-            if (path === 'res.headers') {
-                if ('set-cookie' in value) {
-                    value['set-cookie'] = REDACTED_TEXT;
+    if (env['LOG_STYLE'] !== 'raw') {
+        httpLoggerOptions.transport = {
+            target: 'pino-http-print',
+            options: {
+                all: true,
+                translateTime: 'SYS:HH:MM:ss',
+                relativeUrl: true,
+                prettyOptions: {
+                    ignore: 'hostname,pid',
+                    sync: true,
+                },
+            },
+        };
+    }
+    if (env['LOG_STYLE'] === 'raw') {
+        httpLoggerOptions.redact = {
+            paths: ['req.headers.authorization', 'req.headers.cookie', 'res.headers'],
+            censor: (value, pathParts) => {
+                const path = pathParts.join('.');
+                if (path === 'res.headers') {
+                    if ('set-cookie' in value) {
+                        value['set-cookie'] = REDACTED_TEXT;
+                    }
+                    return value;
                 }
-                return value;
-            }
-            return REDACTED_TEXT;
-        },
-    };
-}
-const loggerEnvConfig = getConfigFromEnv('LOGGER_', 'LOGGER_HTTP');
-// Expose custom log levels into formatter function
-if (loggerEnvConfig['levels']) {
-    const customLogLevels = {};
-    for (const el of toArray(loggerEnvConfig['levels'])) {
-        const key_val = el.split(':');
-        customLogLevels[key_val[0].trim()] = key_val[1].trim();
+                return REDACTED_TEXT;
+            },
+        };
     }
-    pinoOptions.formatters = {
-        level(label, number) {
-            return {
-                severity: customLogLevels[label] || 'info',
-                level: number,
-            };
-        },
-    };
-    httpLoggerOptions.formatters = {
-        level(label, number) {
-            return {
-                severity: customLogLevels[label] || 'info',
-                level: number,
-            };
-        },
-    };
-    delete loggerEnvConfig['levels'];
-}
-const logger = pino(merge(pinoOptions, loggerEnvConfig));
-export const httpLoggerEnvConfig = getConfigFromEnv('LOGGER_HTTP', ['LOGGER_HTTP_LOGGER']);
-if (env['LOG_HTTP_IGNORE_PATHS']) {
-    const ignorePathsSet = new Set(env['LOG_HTTP_IGNORE_PATHS']);
-    httpLoggerEnvConfig['autoLogging'] = {
-        ignore: (req) => {
-            if (!req.url)
-                return false;
-            const { pathname } = new URL(req.url, 'http://example.com/');
-            return ignorePathsSet.has(pathname);
-        },
-    };
-}
-export const expressLogger = pinoHttp({
-    logger: pino(merge(httpLoggerOptions, loggerEnvConfig)),
-    ...httpLoggerEnvConfig,
-    serializers: {
-        req(request) {
-            const output = stdSerializers.req(request);
-            output.url = redactQuery(output.url);
-            return output;
+    // Expose custom log levels into formatter function
+    if (loggerEnvConfig['levels']) {
+        const customLogLevels = {};
+        for (const el of toArray(loggerEnvConfig['levels'])) {
+            const key_val = el.split(':');
+            customLogLevels[key_val[0].trim()] = key_val[1].trim();
+        }
+        httpLoggerOptions.formatters = {
+            level(label, number) {
+                return {
+                    severity: customLogLevels[label] || 'info',
+                    level: number,
+                };
+            },
+        };
+        delete loggerEnvConfig['levels'];
+    }
+    if (env['LOG_HTTP_IGNORE_PATHS']) {
+        const ignorePathsSet = new Set(env['LOG_HTTP_IGNORE_PATHS']);
+        httpLoggerEnvConfig['autoLogging'] = {
+            ignore: (req) => {
+                if (!req.url)
+                    return false;
+                const { pathname } = new URL(req.url, 'http://example.com/');
+                return ignorePathsSet.has(pathname);
+            },
+        };
+    }
+    return pinoHttp({
+        logger: pino(merge(httpLoggerOptions, loggerEnvConfig)),
+        ...httpLoggerEnvConfig,
+        serializers: {
+            req(request) {
+                const output = stdSerializers.req(request);
+                output.url = redactQuery(output.url);
+                return output;
+            },
         },
-    },
-});
-export const useLogger = () => logger;
-export default logger;
+    });
+};
 function redactQuery(originalPath) {
     const url = new URL(originalPath, 'http://example.com/');
     if (url.searchParams.has('access_token')) {

package/dist/mailer.js

@@ -1,6 +1,6 @@
+import { useEnv } from '@directus/env';
 import nodemailer from 'nodemailer';
-import env from './env.js';
-import logger from './logger.js';
+import { useLogger } from './logger.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
 import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);
@@ -8,6 +8,8 @@ let transporter;
 export default function getMailer() {
     if (transporter)
         return transporter;
+    const env = useEnv();
+    const logger = useLogger();
     const transportName = env['EMAIL_TRANSPORT'].toLowerCase();
     if (transportName === 'sendmail') {
         transporter = nodemailer.createTransport({

package/dist/middleware/cache.js

@@ -1,12 +1,14 @@
+import { useEnv } from '@directus/env';
 import { getCache, getCacheValue } from '../cache.js';
-import env from '../env.js';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 import asyncHandler from '../utils/async-handler.js';
 import { getCacheControlHeader } from '../utils/get-cache-headers.js';
 import { getCacheKey } from '../utils/get-cache-key.js';
 import { shouldSkipCache } from '../utils/should-skip-cache.js';
 const checkCacheMiddleware = asyncHandler(async (req, res, next) => {
+    const env = useEnv();
     const { cache } = getCache();
+    const logger = useLogger();
     if (req.method.toLowerCase() !== 'get' && req.originalUrl?.startsWith('/graphql') === false)
         return next();
     if (env['CACHE_ENABLED'] !== true)

package/dist/middleware/check-ip.js

@@ -1,18 +1,37 @@
-import getDatabase from '../database/index.js';
 import { InvalidIpError } from '@directus/errors';
+import getDatabase from '../database/index.js';
+import { useLogger } from '../logger.js';
 import asyncHandler from '../utils/async-handler.js';
+import { ipInNetworks } from '../utils/ip-in-networks.js';
 export const checkIP = asyncHandler(async (req, _res, next) => {
     const database = getDatabase();
+    const logger = useLogger();
+    const { role: roleId, ip } = req.accountability;
     const query = database.select('ip_access').from('directus_roles');
-    if (req.accountability.role) {
-        query.where({ id: req.accountability.role });
+    if (roleId) {
+        query.where({ id: roleId });
     }
     else {
         query.whereNull('id');
     }
     const role = await query.first();
-    const ipAllowlist = (role?.ip_access || '').split(',').filter((ip) => ip);
-    if (ipAllowlist.length > 0 && ipAllowlist.includes(req.accountability.ip) === false)
-        throw new InvalidIpError();
+    if (!role?.ip_access)
+        return next();
+    const ipAllowList = role.ip_access.split(',').filter((ip) => ip);
+    if (ipAllowList.length > 0) {
+        if (!ip)
+            throw new InvalidIpError();
+        let allowed;
+        try {
+            allowed = ipInNetworks(ip, ipAllowList);
+        }
+        catch (error) {
+            logger.warn(`Invalid IP access configuration for role "${roleId}"`);
+            logger.warn(error);
+            throw new InvalidIpError();
+        }
+        if (!allowed)
+            throw new InvalidIpError();
+    }
     return next();
 });

package/dist/middleware/cors.js

@@ -1,6 +1,7 @@
+import { useEnv } from '@directus/env';
 import cors from 'cors';
-import env from '../env.js';
 let corsMiddleware = (_req, _res, next) => next();
+const env = useEnv();
 if (env['CORS_ENABLED'] === true) {
     corsMiddleware = cors({
         origin: env['CORS_ORIGIN'] || true,

package/dist/middleware/error-handler.js

@@ -1,20 +1,20 @@
-import { isDirectusError } from '@directus/errors';
+import { ErrorCode, MethodNotAllowedError, isDirectusError } from '@directus/errors';
 import { toArray } from '@directus/utils';
+import { getNodeEnv } from '@directus/utils/node';
 import getDatabase from '../database/index.js';
 import emitter from '../emitter.js';
-import env from '../env.js';
-import { ErrorCode, MethodNotAllowedError } from '@directus/errors';
-import logger from '../logger.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) => {
+    const logger = useLogger();
     let payload = {
         errors: [],
     };
     const errors = toArray(err);
     let status = null;
     for (const err of errors) {
-        if (env['NODE_ENV'] === 'development') {
+        if (getNodeEnv() === 'development') {
             err.extensions = {
                 ...(err.extensions || {}),
                 stack: err.stack,

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

@@ -1,10 +1,12 @@
-import env from '../env.js';
+import { useEnv } from '@directus/env';
 import { HitRateLimitError } from '@directus/errors';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 import { createRateLimiter } from '../rate-limiter.js';
 import asyncHandler from '../utils/async-handler.js';
 import { validateEnv } from '../utils/validate-env.js';
 const RATE_LIMITER_GLOBAL_KEY = 'global-rate-limit';
+const env = useEnv();
+const logger = useLogger();
 let checkRateLimit = (_req, _res, next) => next();
 export let rateLimiterGlobal;
 if (env['RATE_LIMITER_GLOBAL_ENABLED'] === true) {

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

@@ -1,4 +1,4 @@
-import env from '../env.js';
+import { useEnv } from '@directus/env';
 import { HitRateLimitError } from '@directus/errors';
 import { createRateLimiter } from '../rate-limiter.js';
 import asyncHandler from '../utils/async-handler.js';
@@ -6,6 +6,7 @@ import { getIPFromReq } from '../utils/get-ip-from-req.js';
 import { validateEnv } from '../utils/validate-env.js';
 let checkRateLimit = (_req, _res, next) => next();
 export let rateLimiter;
+const env = useEnv();
 if (env['RATE_LIMITER_ENABLED'] === true) {
     validateEnv(['RATE_LIMITER_STORE', 'RATE_LIMITER_DURATION', 'RATE_LIMITER_POINTS']);
     rateLimiter = createRateLimiter('RATE_LIMITER');