@directus/api 14.1.2 → 16.0.0

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/database/system-data/relations/relations.yaml

@@ -96,6 +96,10 @@ data:
     many_field: public_background
     one_collection: directus_files
 
+  - many_collection: directus_settings
+    many_field: public_favicon
+    one_collection: directus_files
+
   - many_collection: directus_settings
     many_field: storage_default_folder
     one_collection: directus_folders

package/dist/emitter.d.ts

@@ -17,4 +17,5 @@ export declare class Emitter {
     offAll(): void;
 }
 declare const emitter: Emitter;
+export declare const useEmitter: () => Emitter;
 export default emitter;

package/dist/emitter.js

@@ -1,6 +1,6 @@
 import ee2 from 'eventemitter2';
-import logger from './logger.js';
 import getDatabase from './database/index.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 });
         }
@@ -84,4 +86,5 @@ export class Emitter {
     }
 }
 const emitter = new Emitter();
+export const useEmitter = () => emitter;
 export default emitter;

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,18 +1,20 @@
+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) {
-        const depRegex = new RegExp(`${escapeRegExp(dep.replace(/\//g, '_'))}\\.[0-9a-f]{8}\\.entry\\.js`);
+        const depRegex = new RegExp(`${escapeRegExp(dep.replace(/\//g, '_'))}\\.[a-zA-Z0-9_-]{8}\\.entry\\.js`);
         const depName = appDir.find((file) => depRegex.test(file));
         if (depName) {
             const depUrl = new Url(env['PUBLIC_URL']).addPath('admin', 'assets', depName);

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/register/route.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" resolution-mode="require"/>
 import type { Router } from 'express';
 import type { Reference } from 'isolated-vm';
 import type { IncomingHttpHeaders } from 'node:http';

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}`;

package/dist/extensions/manager.d.ts

@@ -155,4 +155,9 @@ export declare class ExtensionManager {
      * Remove the registration for all API extensions
      */
     private unregisterApiExtensions;
+    /**
+     * If extensions must load successfully, any errors will cause the process to exit.
+     * Otherwise, the error will only be logged as a warning.
+     */
+    private handleExtensionError;
 }

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';
@@ -40,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;
@@ -108,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,
@@ -133,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();
         }
@@ -146,8 +150,7 @@ export class ExtensionManager {
             this.extensionsSettings = await getExtensionsSettings(this.extensions);
         }
         catch (error) {
-            logger.warn(`Couldn't load extensions`);
-            logger.warn(error);
+            this.handleExtensionError({ error, reason: `Couldn't load extensions` });
         }
         await this.registerHooks();
         await this.registerEndpoints();
@@ -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,12 +306,13 @@ 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,
             replacement: path,
         }));
-        const entrypoint = generateExtensionsEntrypoint(this.extensions);
+        const entrypoint = generateExtensionsEntrypoint(this.extensions, this.extensionsSettings);
         try {
             const bundle = await rollup({
                 input: 'entry',
@@ -316,15 +336,16 @@ 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);
         const extensionCode = await readFile(entrypointPath, 'utf-8');
         const isolate = new ivm.Isolate({
             memoryLimit: sandboxMemory,
-            onCatastrophicError: (e) => {
+            onCatastrophicError: (error) => {
                 logger.error(`Error in API extension sandbox of ${extension.type} "${extension.name}"`);
-                logger.error(e);
+                logger.error(error);
                 process.abort();
             },
         });
@@ -377,8 +398,7 @@ export class ExtensionManager {
                 }
             }
             catch (error) {
-                logger.warn(`Couldn't register hook "${hook.name}"`);
-                logger.warn(error);
+                this.handleExtensionError({ error, reason: `Couldn't register hook "${hook.name}"` });
             }
         }
     }
@@ -410,8 +430,7 @@ export class ExtensionManager {
                 }
             }
             catch (error) {
-                logger.warn(`Couldn't register endpoint "${endpoint.name}"`);
-                logger.warn(error);
+                this.handleExtensionError({ error, reason: `Couldn't register endpoint "${endpoint.name}"` });
             }
         }
     }
@@ -449,8 +468,7 @@ export class ExtensionManager {
                 }
             }
             catch (error) {
-                logger.warn(`Couldn't register operation "${operation.name}"`);
-                logger.warn(error);
+                this.handleExtensionError({ error, reason: `Couldn't register operation "${operation.name}"` });
             }
         }
     }
@@ -460,6 +478,12 @@ export class ExtensionManager {
      */
     async registerBundles() {
         const bundles = this.extensions.filter((extension) => extension.type === 'bundle');
+        const extensionEnabled = (extensionName) => {
+            const settings = this.extensionsSettings.find(({ name }) => name === extensionName);
+            if (!settings)
+                return false;
+            return settings.enabled;
+        };
         for (const bundle of bundles) {
             try {
                 const bundlePath = path.resolve(bundle.path, bundle.entrypoint.api);
@@ -469,14 +493,20 @@ export class ExtensionManager {
                 const configs = getModuleDefault(bundleInstances);
                 const unregisterFunctions = [];
                 for (const { config, name } of configs.hooks) {
+                    if (!extensionEnabled(`${bundle.name}/${name}`))
+                        continue;
                     const unregisters = this.registerHook(config, name);
                     unregisterFunctions.push(...unregisters);
                 }
                 for (const { config, name } of configs.endpoints) {
+                    if (!extensionEnabled(`${bundle.name}/${name}`))
+                        continue;
                     const unregister = this.registerEndpoint(config, name);
                     unregisterFunctions.push(unregister);
                 }
-                for (const { config } of configs.operations) {
+                for (const { config, name } of configs.operations) {
+                    if (!extensionEnabled(`${bundle.name}/${name}`))
+                        continue;
                     const unregister = this.registerOperation(config);
                     unregisterFunctions.push(unregister);
                 }
@@ -486,8 +516,7 @@ export class ExtensionManager {
                 });
             }
             catch (error) {
-                logger.warn(`Couldn't register bundle "${bundle.name}"`);
-                logger.warn(error);
+                this.handleExtensionError({ error, reason: `Couldn't register bundle "${bundle.name}"` });
             }
         }
     }
@@ -495,6 +524,7 @@ export class ExtensionManager {
      * Register a single hook
      */
     registerHook(hookRegistrationCallback, name) {
+        const logger = useLogger();
         let scheduleIndex = 0;
         const unregisterFunctions = [];
         const hookRegistrationContext = {
@@ -534,7 +564,7 @@ export class ExtensionManager {
                     });
                 }
                 else {
-                    logger.warn(`Couldn't register cron hook. Provided cron is invalid: ${cron}`);
+                    this.handleExtensionError({ reason: `Couldn't register cron hook. Provided cron is invalid: ${cron}` });
                 }
             },
             embed: (position, code) => {
@@ -556,7 +586,7 @@ export class ExtensionManager {
                     }
                 }
                 else {
-                    logger.warn(`Couldn't register embed hook. Provided code is empty!`);
+                    this.handleExtensionError({ reason: `Couldn't register embed hook. Provided code is empty!` });
                 }
             },
         };
@@ -574,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;
@@ -610,4 +641,23 @@ export class ExtensionManager {
         const unregisterFunctions = Array.from(this.unregisterFunctionMap.values());
         await Promise.all(unregisterFunctions.map((fn) => fn()));
     }
+    /**
+     * If extensions must load successfully, any errors will cause the process to exit.
+     * 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);
+            if (error)
+                logger.error(error);
+            process.exit(1);
+        }
+        else {
+            logger.warn(reason);
+            if (error)
+                logger.warn(error);
+        }
+    }
 }