@directus/api 15.0.0 → 17.0.0

package/dist/controllers/auth.js

@@ -1,10 +1,9 @@
-import { isDirectusError } from '@directus/errors';
+import { useEnv } from '@directus/env';
+import { ErrorCode, InvalidPayloadError, isDirectusError } from '@directus/errors';
 import { Router } from 'express';
 import { createLDAPAuthRouter, createLocalAuthRouter, createOAuth2AuthRouter, createOpenIDAuthRouter, createSAMLAuthRouter, } from '../auth/drivers/index.js';
 import { COOKIE_OPTIONS, DEFAULT_AUTH_PROVIDER } from '../constants.js';
-import env from '../env.js';
-import { ErrorCode, InvalidPayloadError } from '@directus/errors';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 import { respond } from '../middleware/respond.js';
 import { AuthenticationService } from '../services/authentication.js';
 import { UsersService } from '../services/users.js';
@@ -12,6 +11,8 @@ import asyncHandler from '../utils/async-handler.js';
 import { getAuthProviders } from '../utils/get-auth-providers.js';
 import { getIPFromReq } from '../utils/get-ip-from-req.js';
 const router = Router();
+const env = useEnv();
+const logger = useLogger();
 const authProviders = getAuthProviders();
 for (const authProvider of authProviders) {
     let authRouter;

package/dist/controllers/extensions.js

@@ -1,14 +1,15 @@
-import { ForbiddenError, RouteNotFoundError } from '@directus/errors';
+import { useEnv } from '@directus/env';
+import { ErrorCode, ForbiddenError, RouteNotFoundError, isDirectusError } from '@directus/errors';
 import express from 'express';
-import env from '../env.js';
 import { getExtensionManager } from '../extensions/index.js';
 import { respond } from '../middleware/respond.js';
 import useCollection from '../middleware/use-collection.js';
-import { ExtensionsService } from '../services/extensions.js';
+import { ExtensionReadError, ExtensionsService } from '../services/extensions.js';
 import asyncHandler from '../utils/async-handler.js';
 import { getCacheControlHeader } from '../utils/get-cache-headers.js';
 import { getMilliseconds } from '../utils/get-milliseconds.js';
 const router = express.Router();
+const env = useEnv();
 router.use(useCollection('directus_extensions'));
 router.get('/', asyncHandler(async (req, res, next) => {
     const service = new ExtensionsService({
@@ -29,9 +30,20 @@ router.patch('/:bundleOrName/:name?', asyncHandler(async (req, res, next) => {
     if (bundle === undefined || !name) {
         throw new ForbiddenError();
     }
-    await service.updateOne(bundle, name, req.body);
-    const updated = await service.readOne(bundle, name);
-    res.locals['payload'] = { data: updated || null };
+    try {
+        const result = await service.updateOne(bundle, name, req.body);
+        res.locals['payload'] = { data: result || null };
+    }
+    catch (error) {
+        let finalError = error;
+        if (error instanceof ExtensionReadError) {
+            finalError = error.originalError;
+            if (isDirectusError(finalError, ErrorCode.Forbidden)) {
+                return next();
+            }
+        }
+        throw finalError;
+    }
     return next();
 }), respond);
 router.get('/sources/:chunk', asyncHandler(async (req, res) => {

package/dist/controllers/files.js

@@ -1,4 +1,5 @@
-import { isDirectusError } from '@directus/errors';
+import { useEnv } from '@directus/env';
+import { ErrorCode, InvalidPayloadError, isDirectusError } from '@directus/errors';
 import formatTitle from '@directus/format-title';
 import { toArray } from '@directus/utils';
 import Busboy from 'busboy';
@@ -7,8 +8,6 @@ import express from 'express';
 import Joi from 'joi';
 import { minimatch } from 'minimatch';
 import path from 'path';
-import env from '../env.js';
-import { ErrorCode, InvalidPayloadError } from '@directus/errors';
 import { respond } from '../middleware/respond.js';
 import useCollection from '../middleware/use-collection.js';
 import { validateBatch } from '../middleware/validate-batch.js';
@@ -17,6 +16,7 @@ import { MetaService } from '../services/meta.js';
 import asyncHandler from '../utils/async-handler.js';
 import { sanitizeQuery } from '../utils/sanitize-query.js';
 const router = express.Router();
+const env = useEnv();
 router.use(useCollection('directus_files'));
 export const multipartHandler = (req, res, next) => {
     if (req.is('multipart/form-data') === false)

package/dist/controllers/permissions.js

@@ -1,6 +1,5 @@
-import { isDirectusError } from '@directus/errors';
+import { ErrorCode, isDirectusError } from '@directus/errors';
 import express from 'express';
-import { ErrorCode } from '@directus/errors';
 import { respond } from '../middleware/respond.js';
 import useCollection from '../middleware/use-collection.js';
 import { validateBatch } from '../middleware/validate-batch.js';
@@ -152,4 +151,14 @@ router.delete('/:pk', asyncHandler(async (req, _res, next) => {
     await service.deleteOne(req.params['pk']);
     return next();
 }), respond);
+router.get('/me/:collection/:pk?', asyncHandler(async (req, res, next) => {
+    const { collection, pk } = req.params;
+    const service = new PermissionsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const itemPermissions = await service.getItemPermissions(collection, pk);
+    res.locals['payload'] = { data: itemPermissions };
+    return next();
+}), respond);
 export default router;

package/dist/controllers/schema.js

@@ -1,9 +1,9 @@
+import { InvalidPayloadError, UnsupportedMediaTypeError } from '@directus/errors';
 import { parseJSON } from '@directus/utils';
 import Busboy from 'busboy';
 import express from 'express';
 import { load as loadYaml } from 'js-yaml';
-import { InvalidPayloadError, UnsupportedMediaTypeError } from '@directus/errors';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 import { respond } from '../middleware/respond.js';
 import { SchemaService } from '../services/schema.js';
 import asyncHandler from '../utils/async-handler.js';
@@ -36,6 +36,7 @@ const schemaMultipartHandler = (req, res, next) => {
     let isFileIncluded = false;
     let upload = null;
     busboy.on('file', async (_, fileStream, { mimeType }) => {
+        const logger = useLogger();
         if (isFileIncluded)
             return next(new InvalidPayloadError({ reason: `More than one file was included in the body` }));
         isFileIncluded = true;

package/dist/controllers/shares.js

@@ -1,9 +1,8 @@
-import { isDirectusError } from '@directus/errors';
+import { useEnv } from '@directus/env';
+import { ErrorCode, InvalidPayloadError, isDirectusError } from '@directus/errors';
 import express from 'express';
 import Joi from 'joi';
 import { COOKIE_OPTIONS, UUID_REGEX } from '../constants.js';
-import env from '../env.js';
-import { ErrorCode, InvalidPayloadError } from '@directus/errors';
 import { respond } from '../middleware/respond.js';
 import useCollection from '../middleware/use-collection.js';
 import { validateBatch } from '../middleware/validate-batch.js';
@@ -11,6 +10,7 @@ import { SharesService } from '../services/shares.js';
 import asyncHandler from '../utils/async-handler.js';
 import { sanitizeQuery } from '../utils/sanitize-query.js';
 const router = express.Router();
+const env = useEnv();
 router.use(useCollection('directus_shares'));
 const sharedLoginSchema = Joi.object({
     share: Joi.string().required(),

package/dist/controllers/utils.js

@@ -1,13 +1,11 @@
+import { InvalidPayloadError, InvalidQueryError, UnsupportedMediaTypeError } from '@directus/errors';
 import argon2 from 'argon2';
 import Busboy from 'busboy';
 import { Router } from 'express';
 import Joi from 'joi';
-import fs from 'node:fs';
-import { createRequire } from 'node:module';
-import { InvalidPayloadError, InvalidQueryError, UnsupportedMediaTypeError } from '@directus/errors';
 import collectionExists from '../middleware/collection-exists.js';
 import { respond } from '../middleware/respond.js';
-import { ExportService } from '../services/import-export/index.js';
+import { ExportService, ImportService } from '../services/import-export.js';
 import { RevisionsService } from '../services/revisions.js';
 import { UtilsService } from '../services/utils.js';
 import asyncHandler from '../utils/async-handler.js';
@@ -66,6 +64,10 @@ router.post('/import/:collection', collectionExists, asyncHandler(async (req, re
     if (req.is('multipart/form-data') === false) {
         throw new UnsupportedMediaTypeError({ mediaType: req.headers['content-type'], where: 'Content-Type header' });
     }
+    const service = new ImportService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
     let headers;
     if (req.headers['content-type']) {
         headers = req.headers;
@@ -78,34 +80,13 @@ router.post('/import/:collection', collectionExists, asyncHandler(async (req, re
     }
     const busboy = Busboy({ headers });
     busboy.on('file', async (_fieldname, fileStream, { mimeType }) => {
-        const { createTmpFile } = await import('@directus/utils/node');
-        const { getWorkerPool } = await import('../worker-pool.js');
-        const tmpFile = await createTmpFile().catch(() => null);
-        if (!tmpFile)
-            throw new Error('Failed to create temporary file for import');
-        fileStream.pipe(fs.createWriteStream(tmpFile.path));
-        fileStream.on('end', async () => {
-            const workerPool = getWorkerPool();
-            const require = createRequire(import.meta.url);
-            const filename = require.resolve('../services/import-export/import-worker');
-            const workerData = {
-                collection: req.params['collection'],
-                mimeType,
-                filePath: tmpFile.path,
-                accountability: req.accountability,
-                schema: req.schema,
-            };
-            try {
-                await workerPool.run(workerData, { filename });
-                res.status(200).end();
-            }
-            catch (error) {
-                next(error);
-            }
-            finally {
-                await tmpFile.cleanup();
-            }
-        });
+        try {
+            await service.import(req.params['collection'], mimeType, fileStream);
+        }
+        catch (err) {
+            return next(err);
+        }
+        return res.status(200).end();
     });
     busboy.on('error', (err) => next(err));
     req.pipe(busboy);

package/dist/database/helpers/index.d.ts

@@ -6,7 +6,7 @@ import * as geometryHelpers from './geometry/index.js';
 import * as schemaHelpers from './schema/index.js';
 import * as sequenceHelpers from './sequence/index.js';
 export declare function getHelpers(database: Knex): {
-    date: dateHelpers.mysql | dateHelpers.postgres | dateHelpers.mssql | dateHelpers.sqlite | dateHelpers.oracle;
+    date: dateHelpers.postgres | dateHelpers.oracle | dateHelpers.mysql | dateHelpers.mssql | dateHelpers.sqlite;
     st: geometryHelpers.mysql | geometryHelpers.postgres | geometryHelpers.mssql | geometryHelpers.sqlite | geometryHelpers.oracle | geometryHelpers.redshift;
     schema: schemaHelpers.mysql | schemaHelpers.cockroachdb | schemaHelpers.mssql | schemaHelpers.postgres | schemaHelpers.sqlite | schemaHelpers.oracle;
     sequence: sequenceHelpers.mysql | sequenceHelpers.postgres;

package/dist/database/index.js

@@ -1,3 +1,4 @@
+import { useEnv } from '@directus/env';
 import { createInspector } from '@directus/schema';
 import fse from 'fs-extra';
 import knex from 'knex';
@@ -7,9 +8,8 @@ import { fileURLToPath } from 'node:url';
 import path from 'path';
 import { performance } from 'perf_hooks';
 import { promisify } from 'util';
-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 { getConfigFromEnv } from '../utils/get-config-from-env.js';
 import { validateEnv } from '../utils/validate-env.js';
 import { getHelpers } from './helpers/index.js';
@@ -22,6 +22,8 @@ export function getDatabase() {
     if (database) {
         return database;
     }
+    const env = useEnv();
+    const logger = useLogger();
     const { client, version, searchPath, connectionString, pool: poolConfig = {}, ...connectionConfig } = getConfigFromEnv('DB_', ['DB_EXCLUDE_TABLES']);
     const requiredEnvVars = ['DB_CLIENT'];
     switch (client) {
@@ -165,6 +167,7 @@ export async function hasDatabaseConnection(database) {
 }
 export async function validateDatabaseConnection(database) {
     database = database ?? getDatabase();
+    const logger = useLogger();
     try {
         if (getDatabaseClient(database) === 'oracle') {
             await database.raw('select 1 from DUAL');
@@ -209,6 +212,7 @@ export async function isInstalled() {
 }
 export async function validateMigrations() {
     const database = getDatabase();
+    const logger = useLogger();
     try {
         let migrationFiles = await fse.readdir(path.join(__dirname, 'migrations'));
         const customMigrationsPath = path.resolve(getExtensionsPath(), 'migrations');
@@ -234,6 +238,7 @@ export async function validateDatabaseExtensions() {
     const client = getDatabaseClient(database);
     const helpers = getHelpers(database);
     const geometrySupport = await helpers.st.supported();
+    const logger = useLogger();
     if (!geometrySupport) {
         switch (client) {
             case 'postgres':
@@ -248,7 +253,9 @@ export async function validateDatabaseExtensions() {
     }
 }
 async function validateDatabaseCharset(database) {
+    const env = useEnv();
     database = database ?? getDatabase();
+    const logger = useLogger();
     if (getDatabaseClient(database) === 'mysql') {
         const { collation } = await database.select(database.raw(`@@collation_database as collation`)).first();
         const tables = await database('information_schema.tables')

package/dist/database/migrations/20210518A-add-foreign-key-constraints.js

@@ -1,7 +1,8 @@
 import { createInspector } from '@directus/schema';
-import logger from '../../logger.js';
+import { useLogger } from '../../logger.js';
 import { getDefaultIndexName } from '../../utils/get-default-index-name.js';
 export async function up(knex) {
+    const logger = useLogger();
     const inspector = createInspector(knex);
     const foreignKeys = await inspector.foreignKeys();
     const relations = await knex
@@ -87,6 +88,7 @@ export async function up(knex) {
     }
 }
 export async function down(knex) {
+    const logger = useLogger();
     const relations = await knex
         .select('many_collection', 'many_field', 'one_collection')
         .from('directus_relations');

package/dist/database/migrations/20210519A-add-system-fk-triggers.js

@@ -1,5 +1,5 @@
 import { createInspector } from '@directus/schema';
-import logger from '../../logger.js';
+import { useLogger } from '../../logger.js';
 /**
  * Things to keep in mind:
  *
@@ -77,6 +77,7 @@ const updates = [
     },
 ];
 export async function up(knex) {
+    const logger = useLogger();
     const inspector = createInspector(knex);
     const foreignKeys = await inspector.foreignKeys();
     for (const update of updates) {
@@ -123,6 +124,7 @@ export async function up(knex) {
     }
 }
 export async function down(knex) {
+    const logger = useLogger();
     for (const update of updates) {
         for (const constraint of update.constraints) {
             try {

package/dist/database/migrations/20210802A-replace-groups.js

@@ -1,6 +1,7 @@
 import { parseJSON } from '@directus/utils';
-import logger from '../../logger.js';
+import { useLogger } from '../../logger.js';
 export async function up(knex) {
+    const logger = useLogger();
     const dividerGroups = await knex.select('*').from('directus_fields').where('interface', '=', 'group-divider');
     for (const dividerGroup of dividerGroups) {
         const newOptions = { showHeader: true };

package/dist/database/migrations/20230721A-require-shares-fields.js

@@ -1,5 +1,5 @@
 import { createInspector } from '@directus/schema';
-import logger from '../../logger.js';
+import { useLogger } from '../../logger.js';
 import { getHelpers } from '../helpers/index.js';
 export async function up(knex) {
     const helper = getHelpers(knex).schema;
@@ -33,6 +33,7 @@ export async function down(knex) {
  * Temporarily drop foreign key constraint for MySQL instances, see https://github.com/directus/directus/issues/19399
  */
 async function dropConstraint(knex) {
+    const logger = useLogger();
     const inspector = createInspector(knex);
     const foreignKeys = await inspector.foreignKeys('directus_shares');
     const collectionForeignKeys = foreignKeys.filter((fk) => fk.column === 'collection');

package/dist/database/migrations/20231215A-add-focalpoints.d.ts

@@ -0,0 +1,3 @@
+import type { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20231215A-add-focalpoints.js

@@ -0,0 +1,12 @@
+export async function up(knex) {
+    await knex.schema.alterTable('directus_files', (table) => {
+        table.integer('focal_point_x').nullable();
+        table.integer('focal_point_y').nullable();
+    });
+}
+export async function down(knex) {
+    await knex.schema.alterTable('directus_files', (table) => {
+        table.dropColumn('focal_point_x');
+        table.dropColumn('focal_point_y');
+    });
+}

package/dist/database/migrations/run.js

@@ -6,10 +6,11 @@ import { fileURLToPath } from 'node:url';
 import path from 'path';
 import { flushCaches } from '../../cache.js';
 import { getExtensionsPath } from '../../extensions/lib/get-extensions-path.js';
-import logger from '../../logger.js';
+import { useLogger } from '../../logger.js';
 import getModuleDefault from '../../utils/get-module-default.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 export default async function run(database, direction, log = true) {
+    const logger = useLogger();
     let migrationFiles = await fse.readdir(__dirname);
     const customMigrationsPath = path.resolve(getExtensionsPath(), 'migrations');
     let customMigrationFiles = ((await fse.pathExists(customMigrationsPath)) && (await fse.readdir(customMigrationsPath))) || [];

package/dist/database/run-ast.js

@@ -1,13 +1,13 @@
+import { useEnv } from '@directus/env';
 import { toArray } from '@directus/utils';
 import { clone, cloneDeep, isNil, merge, pick, uniq } from 'lodash-es';
-import { getHelpers } from './helpers/index.js';
-import env from '../env.js';
 import { PayloadService } from '../services/payload.js';
 import { applyFunctionToColumnName } from '../utils/apply-function-to-column-name.js';
 import applyQuery, { applyLimit, applySort, generateAlias } from '../utils/apply-query.js';
 import { getCollectionFromAlias } from '../utils/get-collection-from-alias.js';
 import { getColumn } from '../utils/get-column.js';
 import { stripFunction } from '../utils/strip-function.js';
+import { getHelpers } from './helpers/index.js';
 import getDatabase from './index.js';
 /**
  * Execute a given AST using Knex. Returns array of items based on requested AST.
@@ -26,6 +26,7 @@ export default async function runAST(originalAST, schema, options) {
         return await run(ast.name, ast.children, options?.query || ast.query);
     }
     async function run(collection, children, query) {
+        const env = useEnv();
         // Retrieve the database columns to select in the current AST
         const { fieldNodes, primaryKeyField, nestedCollectionNodes } = await parseCurrentLevel(schema, collection, children, query);
         // The actual knex query builder instance. This is a promise that resolves with the raw items from the db
@@ -148,6 +149,7 @@ function getColumnPreprocessor(knex, schema, table) {
     };
 }
 async function getDBQuery(schema, knex, table, fieldNodes, query) {
+    const env = useEnv();
     const preProcess = getColumnPreprocessor(knex, schema, table);
     const queryCopy = clone(query);
     const helpers = getHelpers(knex);
@@ -296,6 +298,7 @@ function applyParentFilters(schema, nestedCollectionNodes, parentItem) {
     return nestedCollectionNodes;
 }
 function mergeWithParentItems(schema, nestedItem, parentItem, nestedNode) {
+    const env = useEnv();
     const nestedItems = toArray(nestedItem);
     const parentItems = clone(toArray(parentItem));
     if (nestedNode.type === 'm2o') {

package/dist/database/system-data/app-access-permissions/app-access-permissions.yaml

@@ -102,13 +102,6 @@
     - appearance
     - theme_light
     - theme_dark
-    - theme_light_overrides
-    - theme_dark_overrides
     - tfa_secret
     - status
     - role
-
-    # This is a temporary allowed field to help people migrate from
-    # 10.6 to 10.7 and should be removed in 10.8
-    # @TODO remove
-    - theme

package/dist/database/system-data/fields/files.yaml

@@ -46,6 +46,22 @@ fields:
     width: half
     readonly: true
 
+  - field: focal_point_divider
+    interface: presentation-divider
+    options:
+      icon: image_search
+      title: $t:field_options.directus_files.focal_point_divider
+    special:
+      - alias
+      - no-data
+    width: full
+
+  - field: focal_point_x
+    width: half
+
+  - field: focal_point_y
+    width: half
+
   - field: storage_divider
     interface: presentation-divider
     options:

package/dist/emitter.js

@@ -1,6 +1,6 @@
 import ee2 from 'eventemitter2';
 import getDatabase from './database/index.js';
-import logger from './logger.js';
+import { useLogger } from './logger.js';
 export class Emitter {
     filterEmitter;
     actionEmitter;
@@ -42,6 +42,7 @@ export class Emitter {
         return updatedPayload;
     }
     emitAction(event, meta, context = null) {
+        const logger = useLogger();
         const events = Array.isArray(event) ? event : [event];
         for (const event of events) {
             this.actionEmitter.emitAsync(event, { event, ...meta }, context ?? this.getDefaultContext()).catch((err) => {
@@ -51,6 +52,7 @@ export class Emitter {
         }
     }
     async emitInit(event, meta) {
+        const logger = useLogger();
         try {
             await this.initEmitter.emitAsync(event, { event, ...meta });
         }

package/dist/extensions/lib/get-extensions-path.d.ts

@@ -1 +1 @@
-export declare const getExtensionsPath: () => any;
+export declare const getExtensionsPath: () => string;

package/dist/extensions/lib/get-extensions-path.js

@@ -1,6 +1,7 @@
+import { useEnv } from '@directus/env';
 import { join } from 'path';
-import env from '../../env.js';
 export const getExtensionsPath = () => {
+    const env = useEnv();
     if (env['EXTENSIONS_LOCATION']) {
         return join(env['TEMP_PATH'], 'extensions');
     }

package/dist/extensions/lib/get-extensions.d.ts

@@ -1 +1 @@
-export declare const getExtensions: () => Promise<import("@directus/extensions/node").Extension[]>;
+export declare const getExtensions: () => Promise<any[]>;

package/dist/extensions/lib/get-extensions.js

@@ -1,12 +1,36 @@
+import { useEnv } from '@directus/env';
 import { getLocalExtensions, getPackageExtensions, resolvePackageExtensions } from '@directus/extensions/node';
-import env from '../../env.js';
+import { useLogger } from '../../logger.js';
 import { getExtensionsPath } from './get-extensions-path.js';
 export const getExtensions = async () => {
-    const localExtensions = await getLocalExtensions(getExtensionsPath());
-    const loadedNames = localExtensions.map(({ name }) => name);
-    const filterDuplicates = ({ name }) => loadedNames.includes(name) === false;
-    const localPackageExtensions = (await resolvePackageExtensions(getExtensionsPath())).filter((extension) => filterDuplicates(extension));
-    loadedNames.push(...localPackageExtensions.map(({ name }) => name));
-    const packageExtensions = (await getPackageExtensions(env['PACKAGE_FILE_LOCATION'])).filter((extension) => filterDuplicates(extension));
-    return [...packageExtensions, ...localPackageExtensions, ...localExtensions];
+    const env = useEnv();
+    const logger = useLogger();
+    const loadedExtensions = new Map();
+    const duplicateExtensions = [];
+    const filterDuplicates = (extension) => {
+        const isExistingExtension = loadedExtensions.has(extension.name);
+        if (isExistingExtension) {
+            duplicateExtensions.push(extension.name);
+            return;
+        }
+        if (extension.type === 'bundle') {
+            const bundleEntryNames = new Set();
+            for (const entry of extension.entries) {
+                if (bundleEntryNames.has(entry.name)) {
+                    // Do not load entire bundle if it has duplicated entries
+                    duplicateExtensions.push(extension.name);
+                    return;
+                }
+                bundleEntryNames.add(entry.name);
+            }
+        }
+        loadedExtensions.set(extension.name, extension);
+    };
+    (await getLocalExtensions(getExtensionsPath())).forEach(filterDuplicates);
+    (await resolvePackageExtensions(getExtensionsPath())).forEach(filterDuplicates);
+    (await getPackageExtensions(env['PACKAGE_FILE_LOCATION'])).forEach(filterDuplicates);
+    if (duplicateExtensions.length > 0) {
+        logger.warn(`Failed to load the following extensions because they have/contain duplicate names: ${duplicateExtensions.join(', ')}`);
+    }
+    return Array.from(loadedExtensions.values());
 };

package/dist/extensions/lib/get-shared-deps-mapping.js

@@ -1,14 +1,16 @@
+import { useEnv } from '@directus/env';
 import { resolvePackage } from '@directus/utils/node';
 import { escapeRegExp } from 'lodash-es';
 import { readdir } from 'node:fs/promises';
-import path from 'path';
-import env from '../../env.js';
-import logger from '../../logger.js';
-import { Url } from '../../utils/url.js';
 import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import path from 'path';
+import { useLogger } from '../../logger.js';
+import { Url } from '../../utils/url.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 export const getSharedDepsMapping = async (deps) => {
+    const env = useEnv();
+    const logger = useLogger();
     const appDir = await readdir(path.join(resolvePackage('@directus/app', __dirname), 'dist', 'assets'));
     const depsMapping = {};
     for (const dep of deps) {

package/dist/extensions/lib/sandbox/register/call-reference.js

@@ -1,6 +1,8 @@
-import env from '../../../../env.js';
-import logger from '../../../../logger.js';
+import { useEnv } from '@directus/env';
+import { useLogger } from '../../../../logger.js';
 export async function callReference(fn, args) {
+    const env = useEnv();
+    const logger = useLogger();
     const sandboxTimeout = Number(env['EXTENSIONS_SANDBOX_TIMEOUT']);
     try {
         return await fn.apply(undefined, args, {

package/dist/extensions/lib/sandbox/sdk/generators/log.js

@@ -1,5 +1,6 @@
-import logger from '../../../../../logger.js';
+import { useLogger } from '../../../../../logger.js';
 export function logGenerator(requestedScopes) {
+    const logger = useLogger();
     return (message) => {
         if (requestedScopes.log === undefined)
             throw new Error('No permission to access "log"');

package/dist/extensions/lib/sync-extensions.js

@@ -1,3 +1,4 @@
+import { useEnv } from '@directus/env';
 import { NESTED_EXTENSION_TYPES } from '@directus/extensions';
 import { ensureExtensionDirs } from '@directus/extensions/node';
 import mid from 'node-machine-id';
@@ -6,19 +7,20 @@ import { mkdir } from 'node:fs/promises';
 import { dirname, join, relative, resolve, sep } from 'node:path';
 import { pipeline } from 'node:stream/promises';
 import Queue from 'p-queue';
-import env from '../../env.js';
-import logger from '../../logger.js';
-import { getMessenger } from '../../messenger.js';
+import { useBus } from '../../bus/index.js';
+import { useLogger } from '../../logger.js';
 import { getStorage } from '../../storage/index.js';
 import { getExtensionsPath } from './get-extensions-path.js';
 import { SyncStatus, getSyncStatus, setSyncStatus } from './sync-status.js';
 export const syncExtensions = async () => {
+    const env = useEnv();
+    const logger = useLogger();
     const extensionsPath = getExtensionsPath();
     if (!env['EXTENSIONS_LOCATION']) {
         // Safe to run with multiple instances since dirs are created with `recursive: true`
         return ensureExtensionDirs(extensionsPath, NESTED_EXTENSION_TYPES);
     }
-    const messenger = getMessenger();
+    const messenger = useBus();
     const isPrimaryProcess = String(process.env['NODE_APP_INSTANCE']) === '0' || process.env['NODE_APP_INSTANCE'] === undefined;
     const id = await mid.machineId();
     const message = `extensions-sync/${id}`;