@directus/api 17.1.0 → 18.0.0

package/dist/extensions/manager.js

@@ -1,22 +1,22 @@
-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 { APP_SHARED_DEPS, HYBRID_EXTENSION_TYPES } from '@directus/extensions';
 import { generateExtensionsEntrypoint } from '@directus/extensions/node';
-import { isIn, isTypeIn, pluralize, toBoolean } from '@directus/utils';
-import { getNodeEnv } from '@directus/utils/node';
+import { isTypeIn, toBoolean } from '@directus/utils';
+import { getNodeEnv, pathToRelativeUrl, processId } 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, debounce } from 'lodash-es';
+import { clone, debounce, isPlainObject } 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 { useBus } from '../bus/index.js';
 import getDatabase from '../database/index.js';
 import emitter, { Emitter } from '../emitter.js';
 import { getFlowManager } from '../flows.js';
@@ -32,6 +32,7 @@ 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 { getInstallationManager } from './lib/installation/index.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';
@@ -52,10 +53,12 @@ export class ExtensionManager {
      * Whether or not the extensions have been read from disk and registered into the system
      */
     isLoaded = false;
-    /**
-     * All extensions that are loaded within the current process
-     */
-    extensions = [];
+    // folder:Extension
+    localExtensions = new Map();
+    // versionId:Extension
+    registryExtensions = new Map();
+    // name:Extension
+    moduleExtensions = new Map();
     /**
      * Settings for the extensions that are loaded within the current process
      */
@@ -102,6 +105,30 @@ export class ExtensionManager {
      * Optional file system watcher to auto-reload extensions when the local file system changes
      */
     watcher = null;
+    /**
+     * installation manager responsible for installing extensions from registries
+     */
+    installationManager = getInstallationManager();
+    messenger = useBus();
+    /**
+     * channel to publish on registering extension from external registry
+     */
+    reloadChannel = `extensions.reload`;
+    processId = processId();
+    get extensions() {
+        return [...this.localExtensions.values(), ...this.registryExtensions.values(), ...this.moduleExtensions.values()];
+    }
+    getExtension(source, folder) {
+        switch (source) {
+            case 'module':
+                return this.moduleExtensions.get(folder);
+            case 'registry':
+                return this.registryExtensions.get(folder);
+            case 'local':
+                return this.localExtensions.get(folder);
+        }
+        return undefined;
+    }
     /**
      * Load and register all extensions
      *
@@ -129,33 +156,54 @@ export class ExtensionManager {
             }
         }
         if (this.options.watch && !wasWatcherInitialized) {
-            this.updateWatchedExtensions(this.extensions);
+            this.updateWatchedExtensions(Array.from(this.localExtensions.values()));
         }
+        this.messenger.subscribe(this.reloadChannel, (payload) => {
+            // Ignore requests for reloading that were published by the current process
+            if (isPlainObject(payload) && 'origin' in payload && payload['origin'] === this.processId)
+                return;
+            this.reload();
+        });
+    }
+    /**
+     * Installs an external extension from registry
+     */
+    async install(versionId) {
+        await this.installationManager.install(versionId);
+        await this.reload();
+        await this.messenger.publish(this.reloadChannel, { origin: this.processId });
+    }
+    async uninstall(folder) {
+        await this.installationManager.uninstall(folder);
+        await this.reload();
+        await this.messenger.publish(this.reloadChannel, { origin: this.processId });
     }
     /**
      * Load all extensions from disk and register them in their respective places
      */
     async load() {
         const logger = useLogger();
-        try {
-            await syncExtensions();
-        }
-        catch (error) {
-            logger.error(`Failed to sync extensions`);
-            logger.error(error);
-            process.exit(1);
+        if (env['EXTENSIONS_LOCATION']) {
+            try {
+                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);
+            const { local, registry, module } = await getExtensions();
+            this.localExtensions = local;
+            this.registryExtensions = registry;
+            this.moduleExtensions = module;
+            this.extensionsSettings = await getExtensionsSettings({ local, registry, module });
         }
         catch (error) {
             this.handleExtensionError({ error, reason: `Couldn't load extensions` });
         }
-        await this.registerHooks();
-        await this.registerEndpoints();
-        await this.registerOperations();
-        await this.registerBundles();
+        await Promise.all([this.registerInternalOperations(), this.registerApiExtensions()]);
         if (env['SERVE_APP']) {
             this.appExtensionsBundle = await this.generateExtensionBundle();
         }
@@ -176,9 +224,15 @@ export class ExtensionManager {
     reload() {
         if (this.reloadQueue.size > 0) {
             // The pending job in the queue will already handle the additional changes
-            return;
+            return Promise.resolve();
         }
         const logger = useLogger();
+        let resolve;
+        let reject;
+        const promise = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
         this.reloadQueue.enqueue(async () => {
             if (this.isLoaded) {
                 const prevExtensions = clone(this.extensions);
@@ -196,11 +250,14 @@ export class ExtensionManager {
                 if (removedExtensions.length > 0) {
                     logger.info(`Removed extensions: ${removedExtensions.join(', ')}`);
                 }
+                resolve();
             }
             else {
                 logger.warn('Extensions have to be loaded before they can be reloaded');
+                reject(new Error('Extensions have to be loaded before they can be reloaded'));
             }
         });
+        return promise;
     }
     /**
      * Return the previously generated app extensions bundle
@@ -229,37 +286,16 @@ export class ExtensionManager {
             body: wrapEmbeds('Custom Embed Body', this.hookEmbedsBody),
         };
     }
-    /**
-     * Allow reading the installed extensions
-     */
-    getExtensions() {
-        return this.extensions;
-    }
     /**
      * Start the chokidar watcher for extensions on the local filesystem
      */
     initializeWatcher() {
         const logger = useLogger();
         logger.info('Watching extensions for changes...');
-        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.join(typeDir, '*', `app.{${JAVASCRIPT_FILE_EXTS.join()}}`),
-                    path.join(typeDir, '*', `api.{${JAVASCRIPT_FILE_EXTS.join()}}`),
-                ];
-            }
-            else {
-                return path.join(typeDir, '*', `index.{${JAVASCRIPT_FILE_EXTS.join()}}`);
-            }
-        });
-        this.watcher = chokidar.watch([rootPackageJson, localExtensions, ...nestedExtensions], {
-            ignoreInitial: true,
-            // dotdirs are watched by default and frequently found in 'node_modules'
-            ignored: `${extensionsDir}/**/node_modules/**`,
+        const extensionDirUrl = pathToRelativeUrl(getExtensionsPath());
+        this.watcher = chokidar.watch([path.resolve('package.json'), path.posix.join(extensionDirUrl, '*', 'package.json')], {
+            ignoreInitial: true, // dotdirs are watched by default and frequently found in 'node_modules'
+            ignored: `${extensionDirUrl}/**/node_modules/**`,
             // on macOS dotdirs in linked extensions are watched too
             followSymlinks: os.platform() === 'darwin' ? false : true,
         });
@@ -283,12 +319,8 @@ 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) => !nestedExtensionDirs.some((path) => extension.path.startsWith(path)))
+                .filter((extension) => !extension.local || extension.type === 'bundle')
                 .flatMap((extension) => isTypeIn(extension, HYBRID_EXTENSION_TYPES) || extension.type === 'bundle'
                 ? [
                     path.resolve(extension.path, extension.entrypoint.app),
@@ -312,7 +344,7 @@ export class ExtensionManager {
             find: name,
             replacement: path,
         }));
-        const entrypoint = generateExtensionsEntrypoint(this.extensions, this.extensionsSettings);
+        const entrypoint = generateExtensionsEntrypoint({ module: this.moduleExtensions, registry: this.registryExtensions, local: this.localExtensions }, this.extensionsSettings);
         try {
             const bundle = await rollup({
                 input: 'entry',
@@ -370,154 +402,153 @@ export class ExtensionManager {
             isolate.dispose();
         });
     }
-    /**
-     * Import the hook module code for all hook extensions, and register them individually through
-     * registerHook
-     */
-    async registerHooks() {
-        const hooks = this.extensions.filter((extension) => extension.type === 'hook');
-        for (const hook of hooks) {
-            const { enabled } = this.extensionsSettings.find(({ name }) => name === hook.name) ?? { enabled: false };
-            if (!enabled)
-                continue;
-            try {
-                if (hook.sandbox?.enabled) {
-                    await this.registerSandboxedApiExtension(hook);
-                }
-                else {
-                    const hookPath = path.resolve(hook.path, hook.entrypoint);
-                    const hookInstance = await importFileUrl(hookPath, import.meta.url, {
-                        fresh: true,
-                    });
-                    const config = getModuleDefault(hookInstance);
-                    const unregisterFunctions = this.registerHook(config, hook.name);
-                    this.unregisterFunctionMap.set(hook.name, async () => {
-                        await Promise.all(unregisterFunctions.map((fn) => fn()));
-                        deleteFromRequireCache(hookPath);
-                    });
+    async registerApiExtensions() {
+        const sources = {
+            module: this.moduleExtensions,
+            registry: this.registryExtensions,
+            local: this.localExtensions,
+        };
+        await Promise.all(Object.entries(sources).map(async ([source, extensions]) => {
+            await Promise.all(Array.from(extensions.entries()).map(async ([folder, extension]) => {
+                const { id, enabled } = this.extensionsSettings.find((settings) => settings.source === source && settings.folder === folder) ?? { enabled: false };
+                if (!enabled)
+                    return;
+                switch (extension.type) {
+                    case 'hook':
+                        await this.registerHookExtension(extension);
+                        break;
+                    case 'endpoint':
+                        await this.registerEndpointExtension(extension);
+                        break;
+                    case 'operation':
+                        await this.registerOperationExtension(extension);
+                        break;
+                    case 'bundle':
+                        await this.registerBundleExtension(extension, source, id);
+                        break;
+                    default:
+                        return;
                 }
+            }));
+        }));
+    }
+    async registerHookExtension(hook) {
+        try {
+            if (hook.sandbox?.enabled) {
+                await this.registerSandboxedApiExtension(hook);
             }
-            catch (error) {
-                this.handleExtensionError({ error, reason: `Couldn't register hook "${hook.name}"` });
+            else {
+                const hookPath = path.resolve(hook.path, hook.entrypoint);
+                const hookInstance = await importFileUrl(hookPath, import.meta.url, {
+                    fresh: true,
+                });
+                const config = getModuleDefault(hookInstance);
+                const unregisterFunctions = this.registerHook(config, hook.name);
+                this.unregisterFunctionMap.set(hook.name, async () => {
+                    await Promise.all(unregisterFunctions.map((fn) => fn()));
+                    deleteFromRequireCache(hookPath);
+                });
             }
         }
+        catch (error) {
+            this.handleExtensionError({ error, reason: `Couldn't register hook "${hook.name}"` });
+        }
     }
-    /**
-     * Import the endpoint module code for all endpoint extensions, and register them individually through
-     * registerEndpoint
-     */
-    async registerEndpoints() {
-        const endpoints = this.extensions.filter((extension) => extension.type === 'endpoint');
-        for (const endpoint of endpoints) {
-            const { enabled } = this.extensionsSettings.find(({ name }) => name === endpoint.name) ?? { enabled: false };
-            if (!enabled)
-                continue;
-            try {
-                if (endpoint.sandbox?.enabled) {
-                    await this.registerSandboxedApiExtension(endpoint);
-                }
-                else {
-                    const endpointPath = path.resolve(endpoint.path, endpoint.entrypoint);
-                    const endpointInstance = await importFileUrl(endpointPath, import.meta.url, {
-                        fresh: true,
-                    });
-                    const config = getModuleDefault(endpointInstance);
-                    const unregister = this.registerEndpoint(config, endpoint.name);
-                    this.unregisterFunctionMap.set(endpoint.name, async () => {
-                        await unregister();
-                        deleteFromRequireCache(endpointPath);
-                    });
-                }
+    async registerEndpointExtension(endpoint) {
+        try {
+            if (endpoint.sandbox?.enabled) {
+                await this.registerSandboxedApiExtension(endpoint);
             }
-            catch (error) {
-                this.handleExtensionError({ error, reason: `Couldn't register endpoint "${endpoint.name}"` });
+            else {
+                const endpointPath = path.resolve(endpoint.path, endpoint.entrypoint);
+                const endpointInstance = await importFileUrl(endpointPath, import.meta.url, {
+                    fresh: true,
+                });
+                const config = getModuleDefault(endpointInstance);
+                const unregister = this.registerEndpoint(config, endpoint.name);
+                this.unregisterFunctionMap.set(endpoint.name, async () => {
+                    await unregister();
+                    deleteFromRequireCache(endpointPath);
+                });
             }
         }
-    }
-    /**
-     * Import the operation module code for all operation extensions, and register them individually through
-     * registerOperation
-     */
-    async registerOperations() {
-        const internalOperations = await readdir(path.join(__dirname, '..', 'operations'));
-        for (const operation of internalOperations) {
-            const operationInstance = await import(`../operations/${operation}/index.js`);
-            const config = getModuleDefault(operationInstance);
-            this.registerOperation(config);
+        catch (error) {
+            this.handleExtensionError({ error, reason: `Couldn't register endpoint "${endpoint.name}"` });
         }
-        const operations = this.extensions.filter((extension) => extension.type === 'operation');
-        for (const operation of operations) {
-            const { enabled } = this.extensionsSettings.find(({ name }) => name === operation.name) ?? { enabled: false };
-            if (!enabled)
-                continue;
-            try {
-                if (operation.sandbox?.enabled) {
-                    await this.registerSandboxedApiExtension(operation);
-                }
-                else {
-                    const operationPath = path.resolve(operation.path, operation.entrypoint.api);
-                    const operationInstance = await importFileUrl(operationPath, import.meta.url, {
-                        fresh: true,
-                    });
-                    const config = getModuleDefault(operationInstance);
-                    const unregister = this.registerOperation(config);
-                    this.unregisterFunctionMap.set(operation.name, async () => {
-                        await unregister();
-                        deleteFromRequireCache(operationPath);
-                    });
-                }
+    }
+    async registerOperationExtension(operation) {
+        try {
+            if (operation.sandbox?.enabled) {
+                await this.registerSandboxedApiExtension(operation);
             }
-            catch (error) {
-                this.handleExtensionError({ error, reason: `Couldn't register operation "${operation.name}"` });
+            else {
+                const operationPath = path.resolve(operation.path, operation.entrypoint.api);
+                const operationInstance = await importFileUrl(operationPath, import.meta.url, {
+                    fresh: true,
+                });
+                const config = getModuleDefault(operationInstance);
+                const unregister = this.registerOperation(config);
+                this.unregisterFunctionMap.set(operation.name, async () => {
+                    await unregister();
+                    deleteFromRequireCache(operationPath);
+                });
             }
         }
+        catch (error) {
+            this.handleExtensionError({ error, reason: `Couldn't register operation "${operation.name}"` });
+        }
     }
-    /**
-     * Import the module code for all hook, endpoint, and operation extensions registered within a
-     * bundle, and register them with their respective registration function
-     */
-    async registerBundles() {
-        const bundles = this.extensions.filter((extension) => extension.type === 'bundle');
+    async registerBundleExtension(bundle, source, bundleId) {
         const extensionEnabled = (extensionName) => {
-            const settings = this.extensionsSettings.find(({ name }) => name === extensionName);
+            const settings = this.extensionsSettings.find((settings) => settings.source === source && settings.folder === extensionName && settings.bundle === bundleId);
             if (!settings)
                 return false;
             return settings.enabled;
         };
-        for (const bundle of bundles) {
-            try {
-                const bundlePath = path.resolve(bundle.path, bundle.entrypoint.api);
-                const bundleInstances = await importFileUrl(bundlePath, import.meta.url, {
-                    fresh: true,
-                });
-                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, name } of configs.operations) {
-                    if (!extensionEnabled(`${bundle.name}/${name}`))
-                        continue;
-                    const unregister = this.registerOperation(config);
-                    unregisterFunctions.push(unregister);
-                }
-                this.unregisterFunctionMap.set(bundle.name, async () => {
-                    await Promise.all(unregisterFunctions.map((fn) => fn()));
-                    deleteFromRequireCache(bundlePath);
-                });
+        try {
+            const bundlePath = path.resolve(bundle.path, bundle.entrypoint.api);
+            const bundleInstances = await importFileUrl(bundlePath, import.meta.url, {
+                fresh: true,
+            });
+            const configs = getModuleDefault(bundleInstances);
+            const unregisterFunctions = [];
+            for (const { config, name } of configs.hooks) {
+                if (!extensionEnabled(name))
+                    continue;
+                const unregisters = this.registerHook(config, name);
+                unregisterFunctions.push(...unregisters);
             }
-            catch (error) {
-                this.handleExtensionError({ error, reason: `Couldn't register bundle "${bundle.name}"` });
+            for (const { config, name } of configs.endpoints) {
+                if (!extensionEnabled(name))
+                    continue;
+                const unregister = this.registerEndpoint(config, name);
+                unregisterFunctions.push(unregister);
+            }
+            for (const { config, name } of configs.operations) {
+                if (!extensionEnabled(name))
+                    continue;
+                const unregister = this.registerOperation(config);
+                unregisterFunctions.push(unregister);
             }
+            this.unregisterFunctionMap.set(bundle.name, async () => {
+                await Promise.all(unregisterFunctions.map((fn) => fn()));
+                deleteFromRequireCache(bundlePath);
+            });
+        }
+        catch (error) {
+            this.handleExtensionError({ error, reason: `Couldn't register bundle "${bundle.name}"` });
+        }
+    }
+    /**
+     * Import the operation module code for all operation extensions, and register them individually through
+     * registerOperation
+     */
+    async registerInternalOperations() {
+        const internalOperations = await readdir(path.join(__dirname, '..', 'operations'));
+        for (const operation of internalOperations) {
+            const operationInstance = await import(`../operations/${operation}/index.js`);
+            const config = getModuleDefault(operationInstance);
+            this.registerOperation(config);
         }
     }
     /**

package/dist/middleware/authenticate.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="qs" />
+/// <reference types="cookie-parser" />
 import type { NextFunction, Request, Response } from 'express';
 /**
  * Verify the passed JWT and assign the user ID and role to `req`

package/dist/middleware/error-handler.js

@@ -1,5 +1,5 @@
 import { ErrorCode, MethodNotAllowedError, isDirectusError } from '@directus/errors';
-import { toArray } from '@directus/utils';
+import { isObject, toArray } from '@directus/utils';
 import { getNodeEnv } from '@directus/utils/node';
 import getDatabase from '../database/index.js';
 import emitter from '../emitter.js';
@@ -13,43 +13,47 @@ const errorHandler = (err, req, res, _next) => {
     };
     const errors = toArray(err);
     let status = null;
-    for (const err of errors) {
+    for (const error of errors) {
         if (getNodeEnv() === 'development') {
-            err.extensions = {
-                ...(err.extensions || {}),
-                stack: err.stack,
-            };
+            if (isObject(error)) {
+                error['extensions'] = {
+                    ...(error['extensions'] || {}),
+                    stack: error['stack'],
+                };
+            }
         }
-        if (isDirectusError(err)) {
-            logger.debug(err);
+        if (isDirectusError(error)) {
+            logger.debug(error);
             if (!status) {
-                status = err.status;
+                status = error.status;
             }
-            else if (status !== err.status) {
+            else if (status !== error.status) {
                 status = 500;
             }
             payload.errors.push({
-                message: err.message,
+                message: error.message,
                 extensions: {
-                    code: err.code,
-                    ...(err.extensions ?? {}),
+                    code: error.code,
+                    ...(error.extensions ?? {}),
                 },
             });
-            if (isDirectusError(err, ErrorCode.MethodNotAllowed)) {
-                res.header('Allow', err.extensions.allowed.join(', '));
+            if (isDirectusError(error, ErrorCode.MethodNotAllowed)) {
+                res.header('Allow', error.extensions.allowed.join(', '));
             }
         }
         else {
-            logger.error(err);
+            logger.error(error);
             status = 500;
             if (req.accountability?.admin === true) {
+                const localError = isObject(error) ? error : {};
+                const message = localError['message'] ?? typeof error === 'string' ? error : null;
                 payload = {
                     errors: [
                         {
-                            message: err.message,
+                            message: message || 'An unexpected error occurred.',
                             extensions: {
                                 code: 'INTERNAL_SERVER_ERROR',
-                                ...err.extensions,
+                                ...(localError['extensions'] ?? {}),
                             },
                         },
                     ],

package/dist/middleware/extract-token.d.ts

@@ -1,11 +1,12 @@
+import type { RequestHandler } from 'express';
 /**
- * Extract access token from:
+ * Extract access token from
  *
- * Authorization: Bearer
- * access_token query parameter
+ * - 'access_token' query parameter
+ * - 'Authorization' header
+ * - Session cookie
  *
- * and store in req.token
+ * and store it under req.token
  */
-import type { RequestHandler } from 'express';
 declare const extractToken: RequestHandler;
 export default extractToken;