@directus/api 15.0.0 → 16.0.0

package/dist/app.js

@@ -1,3 +1,4 @@
+import { useEnv } from '@directus/env';
 import { InvalidPayloadError, ServiceUnavailableError } from '@directus/errors';
 import { handlePressure } from '@directus/pressure';
 import cookieParser from 'cookie-parser';
@@ -40,10 +41,9 @@ import versionsRouter from './controllers/versions.js';
 import webhooksRouter from './controllers/webhooks.js';
 import { isInstalled, validateDatabaseConnection, validateDatabaseExtensions, validateMigrations, } from './database/index.js';
 import emitter from './emitter.js';
-import env from './env.js';
 import { getExtensionManager } from './extensions/index.js';
 import { getFlowManager } from './flows.js';
-import logger, { expressLogger } from './logger.js';
+import { createExpressLogger, useLogger } from './logger.js';
 import authenticate from './middleware/authenticate.js';
 import cache from './middleware/cache.js';
 import { checkIP } from './middleware/check-ip.js';
@@ -55,14 +55,16 @@ import rateLimiterGlobal from './middleware/rate-limiter-global.js';
 import rateLimiter from './middleware/rate-limiter-ip.js';
 import sanitizeQuery from './middleware/sanitize-query.js';
 import schema from './middleware/schema.js';
+import { initTelemetry } from './telemetry/index.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
 import { Url } from './utils/url.js';
 import { validateEnv } from './utils/validate-env.js';
 import { validateStorage } from './utils/validate-storage.js';
 import { init as initWebhooks } from './webhooks.js';
-import { initTelemetry } from './telemetry/index.js';
 const require = createRequire(import.meta.url);
 export default async function createApp() {
+    const env = useEnv();
+    const logger = useLogger();
     const helmet = await import('helmet');
     validateEnv(['KEY', 'SECRET']);
     if (!new Url(env['PUBLIC_URL']).isAbsolute()) {
@@ -124,7 +126,7 @@ export default async function createApp() {
     }
     await emitter.emitInit('app.before', { app });
     await emitter.emitInit('middlewares.before', { app });
-    app.use(expressLogger);
+    app.use(createExpressLogger());
     app.use((_req, res, next) => {
         res.setHeader('X-Powered-By', 'Directus');
         next();

package/dist/auth/drivers/ldap.js

@@ -1,12 +1,11 @@
-import { isDirectusError } from '@directus/errors';
+import { useEnv } from '@directus/env';
+import { ErrorCode, InvalidCredentialsError, InvalidPayloadError, InvalidProviderConfigError, InvalidProviderError, ServiceUnavailableError, UnexpectedResponseError, isDirectusError, } from '@directus/errors';
 import { Router } from 'express';
 import Joi from 'joi';
 import ldap from 'ldapjs';
 import getDatabase from '../../database/index.js';
 import emitter from '../../emitter.js';
-import env from '../../env.js';
-import { ErrorCode, InvalidCredentialsError, InvalidPayloadError, InvalidProviderError, InvalidProviderConfigError, ServiceUnavailableError, UnexpectedResponseError, } 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';
@@ -24,6 +23,7 @@ export class LDAPAuthDriver extends AuthDriver {
     config;
     constructor(options, config) {
         super(options, config);
+        const logger = useLogger();
         const { bindDn, bindPassword, userDn, provider, clientUrl } = config;
         if (bindDn === undefined ||
             bindPassword === undefined ||
@@ -42,6 +42,7 @@ export class LDAPAuthDriver extends AuthDriver {
         this.config = config;
     }
     async validateBindClient() {
+        const logger = useLogger();
         const { bindDn, bindPassword, provider } = this.config;
         return new Promise((resolve, reject) => {
             // Healthcheck bind user
@@ -168,6 +169,7 @@ export class LDAPAuthDriver extends AuthDriver {
         if (!payload['identifier']) {
             throw new InvalidCredentialsError();
         }
+        const logger = useLogger();
         await this.validateBindClient();
         const { userDn, userScope, userAttribute, groupDn, groupScope, groupAttribute, defaultRoleId } = this.config;
         const userInfo = await this.fetchUserInfo(userDn, new ldap.EqualityFilter({
@@ -292,6 +294,7 @@ export function createLDAPAuthRouter(provider) {
         otp: Joi.string(),
     }).unknown();
     router.post('/', asyncHandler(async (req, res, next) => {
+        const env = useEnv();
         const accountability = {
             ip: getIPFromReq(req),
             role: null,

package/dist/auth/drivers/local.js

@@ -1,10 +1,10 @@
+import { InvalidCredentialsError, InvalidPayloadError } from '@directus/errors';
 import argon2 from 'argon2';
 import { Router } from 'express';
 import Joi from 'joi';
 import { performance } from 'perf_hooks';
 import { COOKIE_OPTIONS } from '../../constants.js';
-import env from '../../env.js';
-import { InvalidCredentialsError, InvalidPayloadError } from '@directus/errors';
+import { useEnv } from '@directus/env';
 import { respond } from '../../middleware/respond.js';
 import { AuthenticationService } from '../../services/authentication.js';
 import asyncHandler from '../../utils/async-handler.js';
@@ -36,6 +36,7 @@ export class LocalAuthDriver extends AuthDriver {
     }
 }
 export function createLocalAuthRouter(provider) {
+    const env = useEnv();
     const router = Router();
     const userLoginSchema = Joi.object({
         email: Joi.string().email().required(),

package/dist/auth/drivers/oauth2.js

@@ -1,3 +1,4 @@
+import { useEnv } from '@directus/env';
 import { ErrorCode, InvalidCredentialsError, InvalidProviderConfigError, InvalidProviderError, InvalidTokenError, isDirectusError, ServiceUnavailableError, } from '@directus/errors';
 import { parseJSON } from '@directus/utils';
 import express, { Router } from 'express';
@@ -7,8 +8,7 @@ import { errors, generators, Issuer } from 'openid-client';
 import { getAuthProvider } from '../../auth.js';
 import getDatabase from '../../database/index.js';
 import emitter from '../../emitter.js';
-import env from '../../env.js';
-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';
@@ -25,6 +25,8 @@ export class OAuth2AuthDriver extends LocalAuthDriver {
     config;
     constructor(options, config) {
         super(options, config);
+        const env = useEnv();
+        const logger = useLogger();
         const { authorizeUrl, accessUrl, profileUrl, clientId, clientSecret, ...additionalConfig } = config;
         if (!authorizeUrl || !accessUrl || !profileUrl || !clientId || !clientSecret || !additionalConfig['provider']) {
             logger.error('Invalid provider config');
@@ -81,6 +83,7 @@ export class OAuth2AuthDriver extends LocalAuthDriver {
         return user?.id;
     }
     async getUserID(payload) {
+        const logger = useLogger();
         if (!payload['code'] || !payload['codeVerifier'] || !payload['state']) {
             logger.warn('[OAuth2] No code, codeVerifier or state in payload');
             throw new InvalidCredentialsError();
@@ -160,6 +163,7 @@ export class OAuth2AuthDriver extends LocalAuthDriver {
         return this.refresh(user);
     }
     async refresh(user) {
+        const logger = useLogger();
         let authData = user.auth_data;
         if (typeof authData === 'string') {
             try {
@@ -186,6 +190,7 @@ export class OAuth2AuthDriver extends LocalAuthDriver {
     }
 }
 const handleError = (e) => {
+    const logger = useLogger();
     if (e instanceof errors.OPError) {
         if (e.error === 'invalid_grant') {
             // Invalid token
@@ -209,6 +214,7 @@ const handleError = (e) => {
 };
 export function createOAuth2AuthRouter(providerName) {
     const router = Router();
+    const env = useEnv();
     router.get('/', (req, res) => {
         const provider = getAuthProvider(providerName);
         const codeVerifier = provider.generateCodeVerifier();
@@ -227,6 +233,7 @@ export function createOAuth2AuthRouter(providerName) {
         res.redirect(303, `./callback?${new URLSearchParams(req.body)}`);
     }, respond);
     router.get('/callback', asyncHandler(async (req, res, next) => {
+        const logger = useLogger();
         let tokenData;
         try {
             tokenData = jwt.verify(req.cookies[`oauth2.${providerName}`], env['SECRET'], {

package/dist/auth/drivers/openid.js

@@ -1,3 +1,4 @@
+import { useEnv } from '@directus/env';
 import { ErrorCode, InvalidCredentialsError, InvalidProviderConfigError, InvalidProviderError, InvalidTokenError, isDirectusError, ServiceUnavailableError, } from '@directus/errors';
 import { parseJSON } from '@directus/utils';
 import express, { Router } from 'express';
@@ -7,8 +8,7 @@ import { errors, generators, Issuer } from 'openid-client';
 import { getAuthProvider } from '../../auth.js';
 import getDatabase from '../../database/index.js';
 import emitter from '../../emitter.js';
-import env from '../../env.js';
-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';
@@ -25,6 +25,8 @@ export class OpenIDAuthDriver extends LocalAuthDriver {
     config;
     constructor(options, config) {
         super(options, config);
+        const env = useEnv();
+        const logger = useLogger();
         const { issuerUrl, clientId, clientSecret, ...additionalConfig } = config;
         if (!issuerUrl || !clientId || !clientSecret || !additionalConfig['provider']) {
             logger.error('Invalid provider config');
@@ -93,6 +95,7 @@ export class OpenIDAuthDriver extends LocalAuthDriver {
         return user?.id;
     }
     async getUserID(payload) {
+        const logger = useLogger();
         if (!payload['code'] || !payload['codeVerifier'] || !payload['state']) {
             logger.warn('[OpenID] No code, codeVerifier or state in payload');
             throw new InvalidCredentialsError();
@@ -180,6 +183,7 @@ export class OpenIDAuthDriver extends LocalAuthDriver {
         return this.refresh(user);
     }
     async refresh(user) {
+        const logger = useLogger();
         let authData = user.auth_data;
         if (typeof authData === 'string') {
             try {
@@ -207,6 +211,7 @@ export class OpenIDAuthDriver extends LocalAuthDriver {
     }
 }
 const handleError = (e) => {
+    const logger = useLogger();
     if (e instanceof errors.OPError) {
         if (e.error === 'invalid_grant') {
             // Invalid token
@@ -229,6 +234,7 @@ const handleError = (e) => {
     return e;
 };
 export function createOpenIDAuthRouter(providerName) {
+    const env = useEnv();
     const router = Router();
     router.get('/', asyncHandler(async (req, res) => {
         const provider = getAuthProvider(providerName);
@@ -248,6 +254,7 @@ export function createOpenIDAuthRouter(providerName) {
         res.redirect(303, `./callback?${new URLSearchParams(req.body)}`);
     }, respond);
     router.get('/callback', asyncHandler(async (req, res, next) => {
+        const logger = useLogger();
         let tokenData;
         try {
             tokenData = jwt.verify(req.cookies[`openid.${providerName}`], env['SECRET'], {

package/dist/auth/drivers/saml.js

@@ -1,14 +1,13 @@
 import * as validator from '@authenio/samlify-node-xmllint';
-import { isDirectusError } from '@directus/errors';
+import { useEnv } from '@directus/env';
+import { ErrorCode, InvalidCredentialsError, InvalidProviderError, isDirectusError } from '@directus/errors';
 import express, { Router } from 'express';
 import * as samlify from 'samlify';
 import { getAuthProvider } from '../../auth.js';
 import { COOKIE_OPTIONS } from '../../constants.js';
 import getDatabase from '../../database/index.js';
 import emitter from '../../emitter.js';
-import env from '../../env.js';
-import { ErrorCode, InvalidCredentialsError, InvalidProviderError } 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';
@@ -38,6 +37,7 @@ export class SAMLAuthDriver extends LocalAuthDriver {
         return user?.id;
     }
     async getUserID(payload) {
+        const logger = useLogger();
         const { provider, emailKey, identifierKey, givenNameKey, familyNameKey, allowPublicRegistration } = this.config;
         const email = payload[emailKey ?? 'http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress'];
         const identifier = payload[identifierKey ?? 'http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier'];
@@ -79,6 +79,7 @@ export class SAMLAuthDriver extends LocalAuthDriver {
 }
 export function createSAMLAuthRouter(providerName) {
     const router = Router();
+    const env = useEnv();
     router.get('/metadata', asyncHandler(async (_req, res) => {
         const { sp } = getAuthProvider(providerName);
         return res.header('Content-Type', 'text/xml').send(sp.getMetadata());
@@ -106,6 +107,7 @@ export function createSAMLAuthRouter(providerName) {
         return res.redirect(context);
     }));
     router.post('/acs', express.urlencoded({ extended: false }), asyncHandler(async (req, res, next) => {
+        const logger = useLogger();
         const relayState = req.body?.RelayState;
         try {
             const { sp, idp } = getAuthProvider(providerName);

package/dist/auth.js

@@ -1,15 +1,15 @@
+import { useEnv } from '@directus/env';
+import { InvalidProviderConfigError } from '@directus/errors';
 import { toArray } from '@directus/utils';
 import { LDAPAuthDriver, LocalAuthDriver, OAuth2AuthDriver, OpenIDAuthDriver, SAMLAuthDriver, } from './auth/drivers/index.js';
 import { DEFAULT_AUTH_PROVIDER } from './constants.js';
 import getDatabase from './database/index.js';
-import env from './env.js';
-import { InvalidProviderConfigError } from '@directus/errors';
-import logger from './logger.js';
+import { useLogger } from './logger.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
 import { getSchema } from './utils/get-schema.js';
-const providerNames = toArray(env['AUTH_PROVIDERS']);
 const providers = new Map();
 export function getAuthProvider(provider) {
+    const logger = useLogger();
     if (!providers.has(provider)) {
         logger.error('Auth provider not configured');
         throw new InvalidProviderConfigError({ provider });
@@ -17,7 +17,10 @@ export function getAuthProvider(provider) {
     return providers.get(provider);
 }
 export async function registerAuthProviders() {
+    const env = useEnv();
+    const logger = useLogger();
     const options = { knex: getDatabase(), schema: await getSchema() };
+    const providerNames = toArray(env['AUTH_PROVIDERS']);
     // Register default provider if not disabled
     if (!env['AUTH_DISABLE_DEFAULT']) {
         const defaultProvider = getProviderInstance('local', options);

package/dist/bus/index.d.ts

@@ -0,0 +1 @@
+export { useBus } from './lib/use-bus.js';

package/dist/bus/index.js

@@ -0,0 +1 @@
+export { useBus } from './lib/use-bus.js';

package/dist/bus/lib/use-bus.d.ts

@@ -0,0 +1,9 @@
+import { type Bus } from '@directus/memory';
+export declare const _cache: {
+    bus: Bus | undefined;
+};
+/**
+ * Returns globally shared message bus. If Redis is available, will use a redis-driven pub/sub bus.
+ * Otherwise will default to a local-only bus.
+ */
+export declare const useBus: () => Bus;

package/dist/bus/lib/use-bus.js

@@ -0,0 +1,21 @@
+import { createBus } from '@directus/memory';
+import { redisConfigAvailable, useRedis } from '../../redis/index.js';
+export const _cache = {
+    bus: undefined,
+};
+/**
+ * Returns globally shared message bus. If Redis is available, will use a redis-driven pub/sub bus.
+ * Otherwise will default to a local-only bus.
+ */
+export const useBus = () => {
+    if (_cache.bus) {
+        return _cache.bus;
+    }
+    if (redisConfigAvailable()) {
+        _cache.bus = createBus({ type: 'redis', redis: useRedis(), namespace: 'directus:bus' });
+    }
+    else {
+        _cache.bus = createBus({ type: 'local' });
+    }
+    return _cache.bus;
+};

package/dist/cache.js

@@ -1,13 +1,16 @@
+import { useEnv } from '@directus/env';
 import { getSimpleHash } from '@directus/utils';
 import Keyv from 'keyv';
-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 { redisConfigAvailable } from './redis/index.js';
 import { compress, decompress } from './utils/compress.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
 import { getMilliseconds } from './utils/get-milliseconds.js';
 import { validateEnv } from './utils/validate-env.js';
 import { createRequire } from 'node:module';
+const logger = useLogger();
+const env = useEnv();
 const require = createRequire(import.meta.url);
 let cache = null;
 let systemCache = null;
@@ -15,11 +18,8 @@ let localSchemaCache = null;
 let sharedSchemaCache = null;
 let lockCache = null;
 let messengerSubscribed = false;
-const messenger = getMessenger();
-if (env['MESSENGER_STORE'] === 'redis' &&
-    env['CACHE_STORE'] === 'memory' &&
-    env['CACHE_AUTO_PURGE'] &&
-    !messengerSubscribed) {
+const messenger = useBus();
+if (redisConfigAvailable() && env['CACHE_STORE'] === 'memory' && env['CACHE_AUTO_PURGE'] && !messengerSubscribed) {
     messengerSubscribed = true;
     messenger.subscribe('schemaChanged', async (opts) => {
         if (cache && opts?.['autoPurgeCache'] !== false) {
@@ -122,7 +122,7 @@ function getConfig(store = 'memory', ttl, namespaceSuffix = '') {
     };
     if (store === 'redis') {
         const KeyvRedis = require('@keyv/redis');
-        config.store = new KeyvRedis(env['REDIS'] || getConfigFromEnv('REDIS'));
+        config.store = new KeyvRedis(env['REDIS'] || getConfigFromEnv('REDIS'), { useRedisSets: false });
     }
     return config;
 }

package/dist/cli/commands/bootstrap/index.js

@@ -1,15 +1,17 @@
+import { useEnv } from '@directus/env';
 import getDatabase, { hasDatabaseConnection, isInstalled, validateDatabaseConnection, } from '../../../database/index.js';
 import runMigrations from '../../../database/migrations/run.js';
 import installDatabase from '../../../database/seeds/run.js';
-import env from '../../../env.js';
-import logger from '../../../logger.js';
+import { useLogger } from '../../../logger.js';
 import { RolesService } from '../../../services/roles.js';
 import { SettingsService } from '../../../services/settings.js';
 import { UsersService } from '../../../services/users.js';
 import { getSchema } from '../../../utils/get-schema.js';
 import { defaultAdminRole, defaultAdminUser } from '../../utils/defaults.js';
 export default async function bootstrap({ skipAdminInit }) {
+    const logger = useLogger();
     logger.info('Initializing bootstrap...');
+    const env = useEnv();
     const database = getDatabase();
     await waitForDatabase(database);
     if ((await isInstalled()) === false) {
@@ -52,6 +54,8 @@ async function waitForDatabase(database) {
     return database;
 }
 async function createDefaultAdmin(schema) {
+    const logger = useLogger();
+    const env = useEnv();
     const { nanoid } = await import('nanoid');
     logger.info('Setting up first admin role...');
     const rolesService = new RolesService({ schema });

package/dist/cli/commands/count/index.js

@@ -1,7 +1,8 @@
 import getDatabase from '../../../database/index.js';
-import logger from '../../../logger.js';
+import { useLogger } from '../../../logger.js';
 export default async function count(collection) {
     const database = getDatabase();
+    const logger = useLogger();
     if (!collection) {
         logger.error('Collection is required');
         process.exit(1);

package/dist/cli/commands/database/install.js

@@ -1,8 +1,9 @@
 import installSeeds from '../../../database/seeds/run.js';
 import getDatabase from '../../../database/index.js';
-import logger from '../../../logger.js';
+import { useLogger } from '../../../logger.js';
 export default async function start() {
     const database = getDatabase();
+    const logger = useLogger();
     try {
         await installSeeds(database);
         database.destroy();

package/dist/cli/commands/database/migrate.js

@@ -1,8 +1,9 @@
 import run from '../../../database/migrations/run.js';
 import getDatabase from '../../../database/index.js';
-import logger from '../../../logger.js';
+import { useLogger } from '../../../logger.js';
 export default async function migrate(direction) {
     const database = getDatabase();
+    const logger = useLogger();
     try {
         logger.info('Running migrations...');
         await run(database, direction);

package/dist/cli/commands/roles/create.js

@@ -1,9 +1,10 @@
 import { getSchema } from '../../../utils/get-schema.js';
 import { RolesService } from '../../../services/roles.js';
 import getDatabase from '../../../database/index.js';
-import logger from '../../../logger.js';
+import { useLogger } from '../../../logger.js';
 export default async function rolesCreate({ role: name, admin }) {
     const database = getDatabase();
+    const logger = useLogger();
     if (!name) {
         logger.error('Name is required');
         process.exit(1);

package/dist/cli/commands/schema/apply.js

@@ -5,13 +5,14 @@ import inquirer from 'inquirer';
 import { load as loadYaml } from 'js-yaml';
 import path from 'path';
 import getDatabase, { isInstalled, validateDatabaseConnection } from '../../../database/index.js';
-import logger from '../../../logger.js';
+import { useLogger } from '../../../logger.js';
 import { DiffKind } from '../../../types/index.js';
 import { isNestedMetaUpdate } from '../../../utils/apply-diff.js';
 import { applySnapshot } from '../../../utils/apply-snapshot.js';
 import { getSnapshotDiff } from '../../../utils/get-snapshot-diff.js';
 import { getSnapshot } from '../../../utils/get-snapshot.js';
 export async function apply(snapshotPath, options) {
+    const logger = useLogger();
     const filename = path.resolve(process.cwd(), snapshotPath);
     const database = getDatabase();
     await validateDatabaseConnection(database);

package/dist/cli/commands/schema/snapshot.js

@@ -1,12 +1,13 @@
-import getDatabase from '../../../database/index.js';
-import logger from '../../../logger.js';
-import { getSnapshot } from '../../../utils/get-snapshot.js';
-import { constants as fsConstants, promises as fs } from 'fs';
-import path from 'path';
+import { promises as fs, constants as fsConstants } from 'fs';
 import inquirer from 'inquirer';
 import { dump as toYaml } from 'js-yaml';
+import path from 'path';
+import getDatabase from '../../../database/index.js';
+import { useLogger } from '../../../logger.js';
+import { getSnapshot } from '../../../utils/get-snapshot.js';
 export async function snapshot(snapshotPath, options) {
     const database = getDatabase();
+    const logger = useLogger();
     try {
         const snapshot = await getSnapshot({ database });
         let snapshotString;

package/dist/cli/commands/users/create.js

@@ -1,9 +1,10 @@
-import { getSchema } from '../../../utils/get-schema.js';
-import { UsersService } from '../../../services/users.js';
 import getDatabase from '../../../database/index.js';
-import logger from '../../../logger.js';
+import { useLogger } from '../../../logger.js';
+import { UsersService } from '../../../services/users.js';
+import { getSchema } from '../../../utils/get-schema.js';
 export default async function usersCreate({ email, password, role, }) {
     const database = getDatabase();
+    const logger = useLogger();
     if (!email || !password || !role) {
         logger.error('Email, password, role are required');
         process.exit(1);

package/dist/cli/commands/users/passwd.js

@@ -1,10 +1,11 @@
-import { getSchema } from '../../../utils/get-schema.js';
-import { generateHash } from '../../../utils/generate-hash.js';
-import { UsersService } from '../../../services/users.js';
 import getDatabase from '../../../database/index.js';
-import logger from '../../../logger.js';
+import { useLogger } from '../../../logger.js';
+import { UsersService } from '../../../services/users.js';
+import { generateHash } from '../../../utils/generate-hash.js';
+import { getSchema } from '../../../utils/get-schema.js';
 export default async function usersPasswd({ email, password }) {
     const database = getDatabase();
+    const logger = useLogger();
     if (!email || !password) {
         logger.error('Email and password are required');
         process.exit(1);

package/dist/cli/load-extensions.js

@@ -1,8 +1,10 @@
+import { useEnv } from '@directus/env';
 import { isInstalled, validateMigrations } from '../database/index.js';
-import env from '../env.js';
 import { getExtensionManager } from '../extensions/index.js';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 export const loadExtensions = async () => {
+    const env = useEnv();
+    const logger = useLogger();
     if (!('DB_CLIENT' in env))
         return;
     const installed = await isInstalled();

package/dist/cli/utils/create-env/env-stub.liquid

@@ -187,7 +187,7 @@ STORAGE_LOCAL_ROOT="./uploads"
 
 ## A comma-separated list of metadata keys to collect during file upload. Use * for all
 # Extracting all metadata might cause memory issues when the file has an unusually large set of metadata
-# [ifd0.Make,ifd0.Model,exif.FNumber,exif.ExposureTime,exif.FocalLength,exif.ISO]
+# [ifd0.Make,ifd0.Model,exif.FNumber,exif.ExposureTime,exif.FocalLength,exif.ISOSpeedRatings]
 # FILE_METADATA_ALLOW_LIST=
 
 ####################################################################################################

package/dist/constants.d.ts

@@ -1,7 +1,7 @@
 import type { CookieOptions } from 'express';
 import type { TransformationParams } from './types/index.js';
 export declare const SYSTEM_ASSET_ALLOW_LIST: TransformationParams[];
-export declare const ASSET_TRANSFORM_QUERY_KEYS: Array<keyof TransformationParams>;
+export declare const ASSET_TRANSFORM_QUERY_KEYS: readonly ["key", "transforms", "width", "height", "format", "fit", "quality", "withoutEnlargement", "focal_point_x", "focal_point_y"];
 export declare const FILTER_VARIABLES: string[];
 export declare const ALIAS_TYPES: string[];
 export declare const DEFAULT_AUTH_PROVIDER = "default";

package/dist/constants.js

@@ -1,5 +1,6 @@
-import env from './env.js';
+import { useEnv } from '@directus/env';
 import { getMilliseconds } from './utils/get-milliseconds.js';
+const env = useEnv();
 export const SYSTEM_ASSET_ALLOW_LIST = [
     {
         key: 'system-small-cover',
@@ -41,6 +42,8 @@ export const ASSET_TRANSFORM_QUERY_KEYS = [
     'fit',
     'quality',
     'withoutEnlargement',
+    'focal_point_x',
+    'focal_point_y',
 ];
 export const FILTER_VARIABLES = ['$NOW', '$CURRENT_USER', '$CURRENT_ROLE'];
 export const ALIAS_TYPES = ['alias', 'o2m', 'm2m', 'm2a', 'o2a', 'files', 'translations'];

package/dist/controllers/assets.js

@@ -1,12 +1,12 @@
+import { useEnv } from '@directus/env';
+import { InvalidQueryError, RangeNotSatisfiableError } from '@directus/errors';
 import { parseJSON } from '@directus/utils';
 import contentDisposition from 'content-disposition';
 import { Router } from 'express';
 import { merge, pick } from 'lodash-es';
 import { ASSET_TRANSFORM_QUERY_KEYS, SYSTEM_ASSET_ALLOW_LIST } from '../constants.js';
 import getDatabase from '../database/index.js';
-import env from '../env.js';
-import { InvalidQueryError, RangeNotSatisfiableError } from '@directus/errors';
-import logger from '../logger.js';
+import { useLogger } from '../logger.js';
 import useCollection from '../middleware/use-collection.js';
 import { AssetsService } from '../services/assets.js';
 import { PayloadService } from '../services/payload.js';
@@ -16,6 +16,7 @@ import { getCacheControlHeader } from '../utils/get-cache-headers.js';
 import { getConfigFromEnv } from '../utils/get-config-from-env.js';
 import { getMilliseconds } from '../utils/get-milliseconds.js';
 const router = Router();
+const env = useEnv();
 router.use(useCollection('directus_files'));
 router.get('/:pk/:filename?', 
 // Validate query params
@@ -109,6 +110,7 @@ asyncHandler(async (req, res, next) => {
 }), 
 // Return file
 asyncHandler(async (req, res) => {
+    const logger = useLogger();
     const id = req.params['pk'].substring(0, 36);
     const service = new AssetsService({
         accountability: req.accountability,