@directus/api 14.0.2 → 14.1.1

package/dist/__utils__/mock-env.d.ts

@@ -0,0 +1,18 @@
+export declare function setEnv(newEnv: Record<string, string>): void;
+/** Static env mock - to be used inside `vi.mock` */
+export declare function mockEnv(options?: {
+    env?: Record<string, string>;
+    withDefaults?: boolean;
+}): Promise<{
+    readonly default: Record<string, any>;
+}>;
+/** Dynamic env mock */
+export declare function doMockEnv(options?: {
+    env?: Record<string, string>;
+    withDefaults?: boolean;
+}): {
+    env: {
+        [x: string]: string;
+    };
+    setEnv: (newEnv: Record<string, string>) => void;
+};

package/dist/__utils__/mock-env.js

@@ -0,0 +1,41 @@
+import { afterEach, vi } from 'vitest';
+let env = {};
+export function setEnv(newEnv) {
+    env = { ...env, ...newEnv };
+}
+/** Static env mock - to be used inside `vi.mock` */
+export async function mockEnv(options) {
+    const initialEnv = options?.env ?? {};
+    const withDefaults = options && 'withDefaults' in options ? options.withDefaults : true;
+    env = { ...initialEnv };
+    afterEach(() => {
+        env = { ...initialEnv };
+    });
+    const { defaults, processValues } = await vi.importActual('../env.js');
+    return {
+        get default() {
+            return processValues({ ...(withDefaults && defaults), ...env });
+        },
+    };
+}
+/** Dynamic env mock */
+export function doMockEnv(options) {
+    const initialEnv = options?.env ?? {};
+    const withDefaults = options && 'withDefaults' in options ? options.withDefaults : true;
+    let env = { ...initialEnv };
+    vi.doMock('../env.js', async () => {
+        const { defaults, processValues } = await vi.importActual('../env.js');
+        return {
+            get default() {
+                return processValues({ ...(withDefaults && defaults), ...env });
+            },
+        };
+    });
+    afterEach(() => {
+        env = { ...initialEnv };
+    });
+    return { env, setEnv };
+    function setEnv(newEnv) {
+        env = { ...env, ...newEnv };
+    }
+}

package/dist/auth/drivers/oauth2.js

@@ -122,13 +122,15 @@ export class OAuth2AuthDriver extends LocalAuthDriver {
         if (userId) {
             // Run hook so the end user has the chance to augment the
             // user that is about to be updated
-            const updatedUserPayload = await emitter.emitFilter(`auth.update`, { auth_data: userPayload.auth_data ?? null }, {
+            const updatedUserPayload = await emitter.emitFilter(`auth.update`, { auth_data: userPayload.auth_data }, {
                 identifier,
                 provider: this.config['provider'],
                 providerPayload: { accessToken: tokenSet.access_token, userInfo },
             }, { database: getDatabase(), schema: this.schema, accountability: null });
             // Update user to update refresh_token and other properties that might have changed
-            await this.usersService.updateOne(userId, updatedUserPayload);
+            if (Object.values(updatedUserPayload).some((value) => value !== undefined)) {
+                await this.usersService.updateOne(userId, updatedUserPayload);
+            }
             return userId;
         }
         // Is public registration allowed?

package/dist/auth/drivers/openid.js

@@ -141,13 +141,15 @@ export class OpenIDAuthDriver extends LocalAuthDriver {
         if (userId) {
             // Run hook so the end user has the chance to augment the
             // user that is about to be updated
-            const updatedUserPayload = await emitter.emitFilter(`auth.update`, { auth_data: userPayload.auth_data ?? null }, {
+            const updatedUserPayload = await emitter.emitFilter(`auth.update`, { auth_data: userPayload.auth_data }, {
                 identifier,
                 provider: this.config['provider'],
                 providerPayload: { accessToken: tokenSet.access_token, userInfo },
             }, { database: getDatabase(), schema: this.schema, accountability: null });
             // Update user to update refresh_token and other properties that might have changed
-            await this.usersService.updateOne(userId, updatedUserPayload);
+            if (Object.values(updatedUserPayload).some((value) => value !== undefined)) {
+                await this.usersService.updateOne(userId, updatedUserPayload);
+            }
             return userId;
         }
         const isEmailVerified = !requireVerifiedEmail || userInfo['email_verified'];

package/dist/cli/load-extensions.js

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

package/dist/constants.js

@@ -55,7 +55,7 @@ export const COOKIE_OPTIONS = {
     secure: env['REFRESH_TOKEN_COOKIE_SECURE'] ?? false,
     sameSite: env['REFRESH_TOKEN_COOKIE_SAME_SITE'] || 'strict',
 };
-export const OAS_REQUIRED_SCHEMAS = ['Diff', 'Schema', 'Query', 'x-metadata'];
+export const OAS_REQUIRED_SCHEMAS = ['Query', 'x-metadata'];
 /** Formats from which transformation is supported */
 export const SUPPORTED_IMAGE_TRANSFORM_FORMATS = ['image/jpeg', 'image/png', 'image/webp', 'image/tiff', 'image/avif'];
 /** Formats where metadata extraction is supported */

package/dist/controllers/assets.js

@@ -32,11 +32,6 @@ asyncHandler(async (req, res, next) => {
     }
     const assetSettings = savedAssetSettings || defaults;
     const transformation = pick(req.query, ASSET_TRANSFORM_QUERY_KEYS);
-    if ('key' in transformation && Object.keys(transformation).length > 1) {
-        throw new InvalidQueryError({
-            reason: `You can't combine the "key" query parameter with any other transformation`,
-        });
-    }
     if ('transforms' in transformation) {
         let transforms;
         // Try parse the JSON array
@@ -90,13 +85,17 @@ asyncHandler(async (req, res, next) => {
         return next();
     }
     else if (assetSettings.storage_asset_transform === 'presets') {
-        if (allKeys.includes(transformation['key']))
+        if (allKeys.includes(transformation['key']) && Object.keys(transformation).length === 1) {
             return next();
+        }
         throw new InvalidQueryError({ reason: `Only configured presets can be used in asset generation` });
     }
     else {
-        if (transformation['key'] && systemKeys.includes(transformation['key']))
+        if (transformation['key'] &&
+            systemKeys.includes(transformation['key']) &&
+            Object.keys(transformation).length === 1) {
             return next();
+        }
         throw new InvalidQueryError({ reason: `Dynamic asset generation has been disabled for this project` });
     }
 }), asyncHandler(async (req, res, next) => {
@@ -116,9 +115,10 @@ asyncHandler(async (req, res) => {
         schema: req.schema,
     });
     const vary = ['Origin', 'Cache-Control'];
-    const transformationParams = res.locals['transformation'].key
-        ? res.locals['shortcuts'].find((transformation) => transformation['key'] === res.locals['transformation'].key)
-        : res.locals['transformation'];
+    const transformationParams = {
+        ...res.locals['shortcuts'].find((transformation) => transformation['key'] === res.locals['transformation']?.key),
+        ...res.locals['transformation'],
+    };
     let acceptFormat;
     if (transformationParams.format === 'auto') {
         if (req.headers.accept?.includes('image/avif')) {

package/dist/controllers/files.js

@@ -8,7 +8,7 @@ import Joi from 'joi';
 import { minimatch } from 'minimatch';
 import path from 'path';
 import env from '../env.js';
-import { ContentTooLargeError, ErrorCode, InvalidPayloadError } from '@directus/errors';
+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';
@@ -85,10 +85,6 @@ export const multipartHandler = (req, res, next) => {
         };
         // Clear the payload for the next to-be-uploaded file
         payload = {};
-        fileStream.on('limit', () => {
-            const error = new ContentTooLargeError();
-            next(error);
-        });
         try {
             const primaryKey = await service.uploadOne(fileStream, payloadWithRequiredFields, existingPrimaryKey);
             savedFiles.push(primaryKey);

package/dist/controllers/server.js

@@ -11,7 +11,7 @@ router.get('/specs/oas', asyncHandler(async (req, res, next) => {
         accountability: req.accountability,
         schema: req.schema,
     });
-    res.locals['payload'] = await service.oas.generate();
+    res.locals['payload'] = await service.oas.generate(req.headers.host);
     return next();
 }), respond);
 router.get('/specs/graphql/:scope?', asyncHandler(async (req, res) => {

package/dist/database/index.js

@@ -8,6 +8,7 @@ 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 { getConfigFromEnv } from '../utils/get-config-from-env.js';
 import { validateEnv } from '../utils/validate-env.js';
@@ -209,7 +210,7 @@ export async function validateMigrations() {
     const database = getDatabase();
     try {
         let migrationFiles = await fse.readdir(path.join(__dirname, 'migrations'));
-        const customMigrationsPath = path.resolve(env['EXTENSIONS_PATH'], 'migrations');
+        const customMigrationsPath = path.resolve(getExtensionsPath(), 'migrations');
         let customMigrationFiles = ((await fse.pathExists(customMigrationsPath)) && (await fse.readdir(customMigrationsPath))) || [];
         migrationFiles = migrationFiles.filter((file) => file.startsWith('run') === false && file.endsWith('.d.ts') === false);
         customMigrationFiles = customMigrationFiles.filter((file) => file.endsWith('.js'));

package/dist/database/migrations/run.js

@@ -5,13 +5,13 @@ import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import path from 'path';
 import { flushCaches } from '../../cache.js';
-import env from '../../env.js';
+import { getExtensionsPath } from '../../extensions/lib/get-extensions-path.js';
 import logger 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) {
     let migrationFiles = await fse.readdir(__dirname);
-    const customMigrationsPath = path.resolve(env['EXTENSIONS_PATH'], 'migrations');
+    const customMigrationsPath = path.resolve(getExtensionsPath(), 'migrations');
     let customMigrationFiles = ((await fse.pathExists(customMigrationsPath)) && (await fse.readdir(customMigrationsPath))) || [];
     migrationFiles = migrationFiles.filter((file) => /^[0-9]+[A-Z]-[^.]+\.(?:js|ts)$/.test(file));
     customMigrationFiles = customMigrationFiles.filter((file) => file.includes('-') && /\.(c|m)?js$/.test(file));

package/dist/database/system-data/collections/collections.yaml

@@ -16,7 +16,7 @@ data:
     accountability: null
 
   - collection: directus_collections
-    icon: list_alt
+    icon: database
     note: $t:directus_collection.directus_collections
 
   - collection: directus_fields

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

@@ -86,8 +86,20 @@ fields:
     width: half
     group: theming_group
 
+  - field: theming_divider
+    interface: presentation-divider
+    options:
+      icon: palette
+      title: $t:fields.directus_settings.theming
+    special:
+      - alias
+      - no-data
+    width: full
+    group: theming_group
+
   - field: default_appearance
     interface: select-dropdown
+    width: half
     options:
       choices:
         - value: auto
@@ -98,24 +110,12 @@ fields:
           text: $t:appearance_dark
     group: theming_group
 
-  - field: theming_divider
-    interface: presentation-divider
-    options:
-      icon: palette
-      title: $t:fields.directus_settings.theming
-    special:
-      - alias
-      - no-data
-    width: full
-    group: theming_group
-
   - field: default_theme_light
     width: full
     interface: system-theme
     options:
       appearance: light
     group: theming_group
-    hidden: true
 
   - field: theme_light_overrides
     width: full
@@ -130,7 +130,6 @@ fields:
     options:
       appearance: dark
     group: theming_group
-    hidden: true
 
   - field: theme_dark_overrides
     width: full

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

@@ -105,7 +105,7 @@ fields:
     options:
       choices:
         - value: null
-          text: $t:appearance_global
+          text: $t:default_sync_with_project
         - value: auto
           text: $t:appearance_auto
         - value: light
@@ -115,18 +115,11 @@ fields:
     width: half
 
   - field: theme_light
-    width: half
+    width: full
     interface: system-theme
     options:
       appearance: light
-    hidden: true
-
-  - field: theme_dark
-    width: half
-    interface: system-theme
-    options:
-      appearance: dark
-    hidden: true
+      includeNull: true
 
   - field: theme_light_overrides
     width: full
@@ -134,6 +127,13 @@ fields:
     special:
       - cast-json
 
+  - field: theme_dark
+    width: full
+    interface: system-theme
+    options:
+      appearance: dark
+      includeNull: true
+
   - field: theme_dark_overrides
     width: full
     interface: system-theme-overrides

package/dist/env.d.ts

@@ -2,14 +2,12 @@
  * @NOTE
  * For all possible keys, see: https://docs.directus.io/self-hosted/config-options/
  */
+export declare const defaults: Record<string, any>;
 declare let env: Record<string, any>;
 export default env;
-/**
- * Small wrapper function that makes it easier to write unit tests against changing environments
- */
-export declare const getEnv: () => Record<string, any>;
 /**
  * When changes have been made during runtime, like in the CLI, we can refresh the env object with
  * the newly created variables
  */
 export declare function refreshEnv(): Promise<void>;
+export declare function processValues(env: Record<string, any>): Record<string, any>;

package/dist/env.js

@@ -2,8 +2,8 @@
  * @NOTE
  * For all possible keys, see: https://docs.directus.io/self-hosted/config-options/
  */
-import { parseJSON, toArray } from '@directus/utils';
 import { JAVASCRIPT_FILE_EXTS } from '@directus/constants';
+import { parseJSON, toArray } from '@directus/utils';
 import dotenv from 'dotenv';
 import fs from 'fs';
 import { clone, toNumber, toString } from 'lodash-es';
@@ -23,6 +23,7 @@ const allowedEnvironmentVars = [
     'PUBLIC_URL',
     'LOG_LEVEL',
     'LOG_STYLE',
+    'LOG_HTTP_IGNORE_PATHS',
     'MAX_PAYLOAD_SIZE',
     'ROOT_REDIRECT',
     'SERVE_APP',
@@ -32,6 +33,7 @@ const allowedEnvironmentVars = [
     'QUERY_LIMIT_MAX',
     'QUERY_LIMIT_DEFAULT',
     'ROBOTS_TXT',
+    'TEMP_PATH',
     // server
     'SERVER_.+',
     // database
@@ -156,6 +158,7 @@ const allowedEnvironmentVars = [
     'AUTH_.+_SP.+',
     // extensions
     'PACKAGE_FILE_LOCATION',
+    'EXTENSIONS_LOCATION',
     'EXTENSIONS_PATH',
     'EXTENSIONS_AUTO_RELOAD',
     'EXTENSIONS_CACHE_TTL',
@@ -204,7 +207,7 @@ const allowedEnvironmentVars = [
     'WEBSOCKETS_.+',
 ].map((name) => new RegExp(`^${name}$`));
 const acceptedEnvTypes = ['string', 'number', 'regex', 'array', 'json'];
-const defaults = {
+export const defaults = {
     CONFIG_PATH: path.resolve(process.cwd(), '.env'),
     HOST: '0.0.0.0',
     PORT: 8055,
@@ -214,6 +217,7 @@ const defaults = {
     QUERY_LIMIT_DEFAULT: 100,
     MAX_BATCH_MUTATION: Infinity,
     ROBOTS_TXT: 'User-agent: *\nDisallow: /',
+    TEMP_PATH: './node_modules/.directus',
     DB_EXCLUDE_TABLES: 'spatial_ref_sys,sysdiagrams',
     STORAGE_LOCATIONS: 'local',
     STORAGE_LOCAL_DRIVER: 'local',
@@ -302,8 +306,10 @@ const defaults = {
     PRESSURE_LIMITER_RETRY_AFTER: false,
     FILES_MIME_TYPE_ALLOW_LIST: '*/*',
 };
-// Allows us to force certain environment variable into a type, instead of relying
-// on the auto-parsed type in processValues. ref #3705
+/**
+ * Allows us to force certain environment variable into a type, instead of relying
+ * on the auto-parsed type in processValues.
+ */
 const typeMap = {
     HOST: 'string',
     PORT: 'string',
@@ -320,6 +326,7 @@ const typeMap = {
     GRAPHQL_INTROSPECTION: 'boolean',
     MAX_BATCH_MUTATION: 'number',
     SERVER_SHUTDOWN_TIMEOUT: 'number',
+    LOG_HTTP_IGNORE_PATHS: 'array',
 };
 let env = {
     ...defaults,
@@ -329,10 +336,6 @@ let env = {
 process.env = env;
 env = processValues(env);
 export default env;
-/**
- * Small wrapper function that makes it easier to write unit tests against changing environments
- */
-export const getEnv = () => env;
 /**
  * When changes have been made during runtime, like in the CLI, we can refresh the env object with
  * the newly created variables
@@ -408,7 +411,7 @@ function getEnvironmentValueByType(envVariableString) {
 function isEnvSyntaxPrefixPresent(value) {
     return acceptedEnvTypes.some((envType) => value.includes(`${envType}:`));
 }
-function processValues(env) {
+export function processValues(env) {
     env = clone(env);
     for (let [key, value] of Object.entries(env)) {
         // If key ends with '_FILE', try to get the value from the file defined in this variable

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

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

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

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

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

@@ -1,10 +1,11 @@
 import { getLocalExtensions, getPackageExtensions, resolvePackageExtensions } from '@directus/extensions/node';
 import env from '../../env.js';
+import { getExtensionsPath } from './get-extensions-path.js';
 export const getExtensions = async () => {
-    const localExtensions = await getLocalExtensions(env['EXTENSIONS_PATH']);
+    const localExtensions = await getLocalExtensions(getExtensionsPath());
     const loadedNames = localExtensions.map(({ name }) => name);
     const filterDuplicates = ({ name }) => loadedNames.includes(name) === false;
-    const localPackageExtensions = (await resolvePackageExtensions(env['EXTENSIONS_PATH'])).filter((extension) => filterDuplicates(extension));
+    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];

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

@@ -0,0 +1 @@
+export declare const syncExtensions: () => Promise<void>;

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

@@ -0,0 +1,59 @@
+import { NESTED_EXTENSION_TYPES } from '@directus/extensions';
+import { ensureExtensionDirs } from '@directus/extensions/node';
+import mid from 'node-machine-id';
+import { createWriteStream } from 'node:fs';
+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 { 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 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 isPrimaryProcess = String(process.env['NODE_APP_INSTANCE']) === '0' || process.env['NODE_APP_INSTANCE'] === undefined;
+    const id = await mid.machineId();
+    const message = `extensions-sync/${id}`;
+    if (isPrimaryProcess === false) {
+        const isDone = (await getSyncStatus()) === SyncStatus.DONE;
+        if (isDone)
+            return;
+        logger.trace('Extensions already being synced to this machine from another process.');
+        /**
+         * Wait until the process that called the lock publishes a message that the syncing is complete
+         */
+        return new Promise((resolve) => {
+            messenger.subscribe(message, () => resolve());
+        });
+    }
+    // Ensure that the local extensions cache path exists
+    await mkdir(extensionsPath, { recursive: true });
+    await setSyncStatus(SyncStatus.SYNCING);
+    logger.trace('Syncing extensions from configured storage location...');
+    const storage = await getStorage();
+    const disk = storage.location(env['EXTENSIONS_LOCATION']);
+    // Make sure we don't overload the file handles
+    const queue = new Queue({ concurrency: 1000 });
+    for await (const filepath of disk.list(env['EXTENSIONS_PATH'])) {
+        const readStream = await disk.read(filepath);
+        // We want files to be stored in the root of `$TEMP_PATH/extensions`, so gotta remove the
+        // extensions path on disk from the start of the file path
+        const destPath = join(extensionsPath, relative(resolve(sep, env['EXTENSIONS_PATH']), resolve(sep, filepath)));
+        // Ensure that the directory path exists
+        await mkdir(dirname(destPath), { recursive: true });
+        const writeStream = createWriteStream(destPath);
+        queue.add(() => pipeline(readStream, writeStream));
+    }
+    await queue.onIdle();
+    await ensureExtensionDirs(extensionsPath, NESTED_EXTENSION_TYPES);
+    await setSyncStatus(SyncStatus.DONE);
+    messenger.publish(message, { ready: true });
+};

package/dist/extensions/lib/sync-status.d.ts

@@ -0,0 +1,10 @@
+export declare enum SyncStatus {
+    UNKNOWN = "UNKNOWN",
+    SYNCING = "SYNCING",
+    DONE = "DONE"
+}
+/**
+ * Retrieves the sync status from the `.status` file in the local extensions folder
+ */
+export declare const getSyncStatus: () => Promise<string>;
+export declare const setSyncStatus: (status: SyncStatus) => Promise<void>;

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

@@ -0,0 +1,27 @@
+import { exists } from 'fs-extra';
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { getExtensionsPath } from './get-extensions-path.js';
+export var SyncStatus;
+(function (SyncStatus) {
+    SyncStatus["UNKNOWN"] = "UNKNOWN";
+    SyncStatus["SYNCING"] = "SYNCING";
+    SyncStatus["DONE"] = "DONE";
+})(SyncStatus || (SyncStatus = {}));
+/**
+ * Retrieves the sync status from the `.status` file in the local extensions folder
+ */
+export const getSyncStatus = async () => {
+    const statusFilePath = join(getExtensionsPath(), '.status');
+    if (await exists(statusFilePath)) {
+        const status = await readFile(statusFilePath, 'utf8');
+        return status;
+    }
+    else {
+        return SyncStatus.UNKNOWN;
+    }
+};
+export const setSyncStatus = async (status) => {
+    const statusFilePath = join(getExtensionsPath(), '.status');
+    await writeFile(statusFilePath, status);
+};

package/dist/extensions/manager.js

@@ -1,6 +1,6 @@
 import { JAVASCRIPT_FILE_EXTS } from '@directus/constants';
 import { APP_SHARED_DEPS, HYBRID_EXTENSION_TYPES, NESTED_EXTENSION_TYPES } from '@directus/extensions';
-import { ensureExtensionDirs, generateExtensionsEntrypoint } from '@directus/extensions/node';
+import { generateExtensionsEntrypoint } from '@directus/extensions/node';
 import { isIn, isTypeIn, pluralize } from '@directus/utils';
 import { pathToRelativeUrl } from '@directus/utils/node';
 import aliasDefault from '@rollup/plugin-alias';
@@ -27,11 +27,13 @@ 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 { getExtensionsPath } from './lib/get-extensions-path.js';
 import { getExtensionsSettings } from './lib/get-extensions-settings.js';
 import { getExtensions } from './lib/get-extensions.js';
 import { getSharedDepsMapping } from './lib/get-shared-deps-mapping.js';
 import { generateApiExtensionsSandboxEntrypoint } from './lib/sandbox/generate-api-extensions-sandbox-entrypoint.js';
 import { instantiateSandboxSdk } from './lib/sandbox/sdk/instantiate.js';
+import { syncExtensions } from './lib/sync-extensions.js';
 import { wrapEmbeds } from './lib/wrap-embeds.js';
 // Workaround for https://github.com/rollup/plugins/issues/1329
 const virtual = virtualDefault;
@@ -132,13 +134,20 @@ export class ExtensionManager {
      */
     async load() {
         try {
-            await ensureExtensionDirs(env['EXTENSIONS_PATH'], NESTED_EXTENSION_TYPES);
+            await syncExtensions();
+        }
+        catch (error) {
+            logger.error(`Failed to sync extensions`);
+            logger.error(error);
+            process.exit(1);
+        }
+        try {
             this.extensions = await getExtensions();
             this.extensionsSettings = await getExtensionsSettings(this.extensions);
         }
-        catch (err) {
+        catch (error) {
             logger.warn(`Couldn't load extensions`);
-            logger.warn(err);
+            logger.warn(error);
         }
         await this.registerHooks();
         await this.registerEndpoints();
@@ -223,7 +232,7 @@ export class ExtensionManager {
      */
     initializeWatcher() {
         logger.info('Watching extensions for changes...');
-        const extensionDirUrl = pathToRelativeUrl(env['EXTENSIONS_PATH']);
+        const extensionDirUrl = pathToRelativeUrl(getExtensionsPath());
         const localExtensionUrls = NESTED_EXTENSION_TYPES.flatMap((type) => {
             const typeDir = path.posix.join(extensionDirUrl, pluralize(type));
             if (isIn(type, HYBRID_EXTENSION_TYPES)) {

package/dist/logger.d.ts

@@ -1,7 +1,8 @@
 /// <reference types="qs" />
 import type { RequestHandler } from 'express';
-import type { LoggerOptions } from 'pino';
+import { type LoggerOptions } from 'pino';
 export declare const httpLoggerOptions: LoggerOptions;
 declare const logger: import("pino").Logger<LoggerOptions & Record<string, any>>;
+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 default logger;