@directus/api 18.1.0 → 18.2.0

package/dist/extensions/lib/sandbox/generate-api-extensions-sandbox-entrypoint.js

@@ -66,7 +66,7 @@ export function generateApiExtensionsSandboxEntrypoint(type, name, endpointRoute
 
 			const registerOperation = ${generateHostFunctionReference(index, ['id', 'handler'], { async: false })}
 
-			const operationConfig = extensionExport();
+			const operationConfig = extensionExport;
 
 			registerOperation(operationConfig.id, operationConfig.handler);
 		`;

package/dist/extensions/lib/sandbox/register/operation.d.ts

@@ -1,6 +1,6 @@
 import type { PromiseCallback } from '@directus/types';
 import type { Reference } from 'isolated-vm';
 export declare function registerOperationGenerator(): {
-    register: (id: Reference<string>, cb: Reference<(data: Record<string, unknown>) => unknown | Promise<unknown> | void>) => void;
+    register: (id: Reference<string>, cb: Reference<(options: Record<string, unknown>) => unknown | Promise<unknown> | void>) => void;
     unregisterFunctions: PromiseCallback[];
 };

package/dist/extensions/lib/sandbox/register/operation.js

@@ -9,7 +9,10 @@ export function registerOperationGenerator() {
         if (cb.typeof !== 'function')
             throw new TypeError('Operation config handler has to be of type function');
         const idCopied = id.copySync();
-        const handler = async (data) => callReference(cb, [data]);
+        const handler = async (options) => {
+            const response = await callReference(cb, [options]);
+            return response.copy();
+        };
         flowManager.addOperation(idCopied, handler);
         unregisterFunctions.push(() => {
             flowManager.removeOperation(idCopied);

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

@@ -28,8 +28,8 @@ export function requestGenerator(requestedScopes) {
         if (body !== undefined && body.typeof !== 'undefined' && body.typeof !== 'string' && body.typeof !== 'object') {
             throw new TypeError('Request body has to be of type string or object');
         }
-        if (headers !== undefined && headers.typeof !== 'undefined' && headers.typeof !== 'array') {
-            throw new TypeError('Request headers has to be of type array');
+        if (headers !== undefined && headers.typeof !== 'undefined' && headers.typeof !== 'object') {
+            throw new TypeError('Request headers has to be of type object');
         }
         const methodCopied = await method?.copy();
         const bodyCopied = await body?.copy();

package/dist/extensions/lib/sandbox/sdk/instantiate.js

@@ -18,7 +18,7 @@ export async function instantiateSandboxSdk(isolate, requestedScopes) {
     const handlerCode = sdk
         .map(({ name, args, async }) => `sdk.${name} = ${generateHostFunctionReference(index, args, { async })}`)
         .join('\n');
-    await apiContext.evalClosure(handlerCode, sdk.map(({ generator, async }) => (async ? wrap(generator(requestedScopes)) : generator(requestedScopes))), { filename: '<extensions-sdk>', arguments: { reference: true } });
+    await apiContext.evalClosure(handlerCode, sdk.map(({ name, generator, async }) => async ? wrap(name, generator(requestedScopes)) : generator(requestedScopes)), { filename: '<extensions-sdk>', arguments: { reference: true } });
     const exportCode = sdk.map(({ name }) => `export const ${name} = sdk.${name};`).join('\n');
     const apiModule = await isolate.compileModule(exportCode);
     await apiModule.instantiate(apiContext, () => {

package/dist/extensions/lib/sandbox/sdk/utils/wrap.d.ts

@@ -3,9 +3,11 @@
  *
  * This is needed as isolated-vm doesn't allow the isolate to catch errors that are thrown in the
  * host. Instead, we'll wrap the output in a known shape which allows the isolated sdk context to
- * re-throw the error in the correct context
+ * re-throw the error in the correct context.
+ *
+ * @see https://github.com/laverdet/isolated-vm/issues/417
  */
-export declare function wrap(util: (...args: any[]) => any): (...args: any[]) => Promise<{
+export declare function wrap(name: string, util: (...args: any[]) => any): (...args: any[]) => Promise<{
     result: any;
     error: boolean;
 }>;

package/dist/extensions/lib/sandbox/sdk/utils/wrap.js

@@ -3,15 +3,49 @@
  *
  * This is needed as isolated-vm doesn't allow the isolate to catch errors that are thrown in the
  * host. Instead, we'll wrap the output in a known shape which allows the isolated sdk context to
- * re-throw the error in the correct context
+ * re-throw the error in the correct context.
+ *
+ * @see https://github.com/laverdet/isolated-vm/issues/417
  */
-export function wrap(util) {
+export function wrap(name, util) {
     return async (...args) => {
         try {
             return { result: await util(...args), error: false };
         }
-        catch (e) {
-            return { result: e, error: true };
+        catch (error) {
+            // isolated-vm expects objects thrown from within the vm to be an instance of `Error`
+            let result;
+            if (error instanceof Error) {
+                // Don't expose the stack trace to the vm
+                delete error.stack;
+                // Serialize the remaining error properties
+                for (const key of Object.getOwnPropertyNames(error)) {
+                    const value = error[key];
+                    if (!value || typeof value !== 'object')
+                        continue;
+                    error[key] = JSON.stringify(value, getCircularReplacer());
+                }
+                result = error;
+            }
+            else if (error && typeof error !== 'object') {
+                result = error;
+            }
+            else {
+                result = new Error(`Unknown error in "${name}" Sandbox SDK function`);
+            }
+            return { result, error: true };
+        }
+    };
+}
+function getCircularReplacer() {
+    const seen = new WeakSet();
+    return (_key, value) => {
+        if (value !== null && typeof value === 'object') {
+            if (seen.has(value)) {
+                return '[Circular]';
+            }
+            seen.add(value);
         }
+        return value;
     };
 }

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

@@ -1 +1,3 @@
-export declare const syncExtensions: () => Promise<void>;
+export declare const syncExtensions: (options?: {
+    force: boolean;
+}) => Promise<void>;

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

@@ -7,56 +7,64 @@ import { dirname, join, relative, resolve, sep } from 'node:path';
 import { pipeline } from 'node:stream/promises';
 import Queue from 'p-queue';
 import { useBus } from '../../bus/index.js';
+import { useLock } from '../../lock/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 () => {
+export const syncExtensions = async (options) => {
+    const lock = useLock();
+    const messenger = useBus();
     const env = useEnv();
     const logger = useLogger();
-    const extensionsPath = getExtensionsPath();
-    const storageExtensionsPath = env['EXTENSIONS_PATH'];
-    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}`;
-    if (isPrimaryProcess === false) {
+    if (!options?.force) {
         const isDone = (await getSyncStatus()) === SyncStatus.DONE;
         if (isDone)
             return;
+    }
+    const machineId = await mid.machineId();
+    const machineKey = `extensions-sync/${machineId}`;
+    const processId = await lock.increment(machineKey);
+    const currentProcessShouldHandleSync = processId === 1;
+    if (currentProcessShouldHandleSync === false) {
         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
-         */
+        // Wait until the process that called the lock publishes a message that the syncing is complete
         return new Promise((resolve) => {
-            messenger.subscribe(message, () => resolve());
+            messenger.subscribe(machineKey, () => resolve());
         });
     }
-    if (await exists(extensionsPath)) {
-        // In case the FS still contains the cached extensions from a previous invocation. We have to
-        // clear them out to ensure the remote extensions folder remains the source of truth for all
-        // extensions that are loaded.
-        await rm(extensionsPath, { recursive: true, force: true });
+    try {
+        const extensionsPath = getExtensionsPath();
+        const storageExtensionsPath = env['EXTENSIONS_PATH'];
+        if (await exists(extensionsPath)) {
+            // In case the FS still contains the cached extensions from a previous invocation. We have to
+            // clear them out to ensure the remote extensions folder remains the source of truth for all
+            // extensions that are loaded.
+            await rm(extensionsPath, { recursive: true, force: true });
+        }
+        // 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(storageExtensionsPath)) {
+            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, storageExtensionsPath), 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 setSyncStatus(SyncStatus.DONE);
+        messenger.publish(machineKey, { ready: true });
     }
-    // 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(storageExtensionsPath)) {
-        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, storageExtensionsPath), resolve(sep, filepath)));
-        // Ensure that the directory path exists
-        await mkdir(dirname(destPath), { recursive: true });
-        const writeStream = createWriteStream(destPath);
-        queue.add(() => pipeline(readStream, writeStream));
+    finally {
+        await lock.delete(machineKey);
     }
-    await queue.onIdle();
-    await setSyncStatus(SyncStatus.DONE);
-    messenger.publish(message, { ready: true });
 };

package/dist/extensions/manager.d.ts

@@ -92,7 +92,9 @@ export declare class ExtensionManager {
     /**
      * Reload all the extensions. Will unload if extensions have already been loaded
      */
-    reload(): Promise<unknown>;
+    reload(options?: {
+        forceSync: boolean;
+    }): Promise<unknown>;
     /**
      * Return the previously generated app extensions bundle
      */

package/dist/extensions/manager.js

@@ -2,7 +2,7 @@ import { useEnv } from '@directus/env';
 import { APP_SHARED_DEPS, HYBRID_EXTENSION_TYPES } from '@directus/extensions';
 import { generateExtensionsEntrypoint } from '@directus/extensions/node';
 import { isTypeIn, toBoolean } from '@directus/utils';
-import { getNodeEnv, pathToRelativeUrl, processId } from '@directus/utils/node';
+import { 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';
@@ -45,7 +45,7 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const env = useEnv();
 const defaultOptions = {
     schedule: true,
-    watch: env['EXTENSIONS_AUTO_RELOAD'] && getNodeEnv() !== 'development',
+    watch: env['EXTENSIONS_AUTO_RELOAD'],
 };
 export class ExtensionManager {
     options = defaultOptions;
@@ -170,22 +170,22 @@ export class ExtensionManager {
      */
     async install(versionId) {
         await this.installationManager.install(versionId);
-        await this.reload();
+        await this.reload({ forceSync: true });
         await this.messenger.publish(this.reloadChannel, { origin: this.processId });
     }
     async uninstall(folder) {
         await this.installationManager.uninstall(folder);
-        await this.reload();
+        await this.reload({ forceSync: true });
         await this.messenger.publish(this.reloadChannel, { origin: this.processId });
     }
     /**
      * Load all extensions from disk and register them in their respective places
      */
-    async load() {
+    async load(options) {
         const logger = useLogger();
         if (env['EXTENSIONS_LOCATION']) {
             try {
-                await syncExtensions();
+                await syncExtensions({ force: options?.forceSync ?? false });
             }
             catch (error) {
                 logger.error(`Failed to sync extensions`);
@@ -221,7 +221,7 @@ export class ExtensionManager {
     /**
      * Reload all the extensions. Will unload if extensions have already been loaded
      */
-    reload() {
+    reload(options) {
         if (this.reloadQueue.size > 0) {
             // The pending job in the queue will already handle the additional changes
             return Promise.resolve();
@@ -237,7 +237,7 @@ export class ExtensionManager {
             if (this.isLoaded) {
                 const prevExtensions = clone(this.extensions);
                 await this.unload();
-                await this.load();
+                await this.load(options);
                 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));
@@ -294,7 +294,8 @@ export class ExtensionManager {
         logger.info('Watching extensions for changes...');
         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'
+            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,
@@ -318,20 +319,20 @@ export class ExtensionManager {
      * removed
      */
     updateWatchedExtensions(added, removed = []) {
-        if (this.watcher) {
-            const toPackageExtensionPaths = (extensions) => extensions
-                .filter((extension) => !extension.local || extension.type === 'bundle')
-                .flatMap((extension) => isTypeIn(extension, HYBRID_EXTENSION_TYPES) || extension.type === 'bundle'
-                ? [
-                    path.resolve(extension.path, extension.entrypoint.app),
-                    path.resolve(extension.path, extension.entrypoint.api),
-                ]
-                : path.resolve(extension.path, extension.entrypoint));
-            const addedPackageExtensionPaths = toPackageExtensionPaths(added);
-            const removedPackageExtensionPaths = toPackageExtensionPaths(removed);
-            this.watcher.add(addedPackageExtensionPaths);
-            this.watcher.unwatch(removedPackageExtensionPaths);
-        }
+        if (!this.watcher)
+            return;
+        const extensionDir = path.resolve(getExtensionsPath());
+        const registryDir = path.join(extensionDir, '.registry');
+        const toPackageExtensionPaths = (extensions) => extensions
+            .filter((extension) => extension.local && extension.path.startsWith(extensionDir) && !extension.path.startsWith(registryDir))
+            .flatMap((extension) => isTypeIn(extension, HYBRID_EXTENSION_TYPES) || extension.type === 'bundle'
+            ? [
+                path.resolve(extension.path, extension.entrypoint.app),
+                path.resolve(extension.path, extension.entrypoint.api),
+            ]
+            : path.resolve(extension.path, extension.entrypoint));
+        this.watcher.add(toPackageExtensionPaths(added));
+        this.watcher.unwatch(toPackageExtensionPaths(removed));
     }
     /**
      * Uses rollup to bundle the app extensions together into a single file the app can download and
@@ -399,7 +400,8 @@ export class ExtensionManager {
         });
         this.unregisterFunctionMap.set(extension.name, async () => {
             await unregisterFunction();
-            isolate.dispose();
+            if (!isolate.isDisposed)
+                isolate.dispose();
         });
     }
     async registerApiExtensions() {

package/dist/flows.js

@@ -17,7 +17,6 @@ import { getSchema } from './utils/get-schema.js';
 import { JobQueue } from './utils/job-queue.js';
 import { mapValuesDeep } from './utils/map-values-deep.js';
 import { redactObject } from './utils/redact-object.js';
-import { sanitizeError } from './utils/sanitize-error.js';
 import { scheduleSynchronizedJob, validateCron } from './utils/schedule.js';
 import { isSystemCollection } from '@directus/system-data';
 let flowManager;
@@ -341,8 +340,9 @@ class FlowManager {
         catch (error) {
             let data;
             if (error instanceof Error) {
-                // make sure we don't expose the stack trace
-                data = sanitizeError(error);
+                // Don't expose the stack trace to the next operation
+                delete error.stack;
+                data = error;
             }
             else if (typeof error === 'string') {
                 // If the error is a JSON string, parse it and use that as the error data

package/dist/lock/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/use-lock.js';

package/dist/lock/index.js

@@ -0,0 +1 @@
+export * from './lib/use-lock.js';

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

@@ -0,0 +1,8 @@
+import { type Kv } from '@directus/memory';
+export declare const _cache: {
+    lock: Kv | undefined;
+};
+/**
+ * Returns globally shared lock kv instance.
+ */
+export declare const useLock: () => Kv;

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

@@ -0,0 +1,20 @@
+import { createKv } from '@directus/memory';
+import { redisConfigAvailable, useRedis } from '../../redis/index.js';
+export const _cache = {
+    lock: undefined,
+};
+/**
+ * Returns globally shared lock kv instance.
+ */
+export const useLock = () => {
+    if (_cache.lock) {
+        return _cache.lock;
+    }
+    if (redisConfigAvailable()) {
+        _cache.lock = createKv({ type: 'redis', redis: useRedis(), namespace: 'directus:lock' });
+    }
+    else {
+        _cache.lock = createKv({ type: 'local' });
+    }
+    return _cache.lock;
+};

package/dist/operations/mail/index.js

@@ -1,6 +1,8 @@
 import { defineOperationApi } from '@directus/extensions';
 import { MailService } from '../../services/mail/index.js';
 import { md } from '../../utils/md.js';
+import { useLogger } from '../../logger.js';
+const logger = useLogger();
 export default defineOperationApi({
     id: 'mail',
     handler: async ({ body, template, data, to, type, subject }, { accountability, database, getSchema }) => {
@@ -16,6 +18,8 @@ export default defineOperationApi({
         else {
             mailObject.html = type === 'wysiwyg' ? safeBody : md(safeBody);
         }
-        await mailService.send(mailObject);
+        mailService.send(mailObject).catch((error) => {
+            logger.error(error, 'Could not send mail in "mail" operation');
+        });
     },
 });

package/dist/redis/utils/redis-config-available.js

@@ -4,5 +4,8 @@ import { useEnv } from '@directus/env';
  */
 export const redisConfigAvailable = () => {
     const env = useEnv();
+    if ('REDIS_ENABLED' in env) {
+        return env['REDIS_ENABLED'] === true;
+    }
     return 'REDIS' in env || Object.keys(env).some((key) => key.startsWith('REDIS_'));
 };

package/dist/services/graphql/index.js

@@ -1,6 +1,7 @@
 import { Action, FUNCTIONS } from '@directus/constants';
 import { useEnv } from '@directus/env';
 import { ErrorCode, ForbiddenError, InvalidPayloadError, isDirectusError } from '@directus/errors';
+import { isSystemCollection } from '@directus/system-data';
 import { parseFilterFunctionPath, toBoolean } from '@directus/utils';
 import argon2 from 'argon2';
 import { GraphQLBoolean, GraphQLEnumType, GraphQLError, GraphQLFloat, GraphQLID, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLScalarType, GraphQLSchema, GraphQLString, GraphQLUnionType, NoSchemaIntrospectionCustomRule, execute, specifiedRules, validate, } from 'graphql';
@@ -12,6 +13,8 @@ import getDatabase from '../../database/index.js';
 import { generateHash } from '../../utils/generate-hash.js';
 import { getGraphQLType } from '../../utils/get-graphql-type.js';
 import { getService } from '../../utils/get-service.js';
+import isDirectusJWT from '../../utils/is-directus-jwt.js';
+import { verifyAccessJWT } from '../../utils/jwt.js';
 import { mergeVersionsRaw, mergeVersionsRecursive } from '../../utils/merge-version-data.js';
 import { reduceSchema } from '../../utils/reduce-schema.js';
 import { sanitizeQuery } from '../../utils/sanitize-query.js';
@@ -31,6 +34,7 @@ import { UsersService } from '../users.js';
 import { UtilsService } from '../utils.js';
 import { VersionsService } from '../versions.js';
 import { GraphQLExecutionError, GraphQLValidationError } from './errors/index.js';
+import { cache } from './schema-cache.js';
 import { createSubscriptionGenerator } from './subscription.js';
 import { GraphQLBigInt } from './types/bigint.js';
 import { GraphQLDate } from './types/date.js';
@@ -40,9 +44,6 @@ import { GraphQLStringOrFloat } from './types/string-or-float.js';
 import { GraphQLVoid } from './types/void.js';
 import { addPathToValidationError } from './utils/add-path-to-validation-error.js';
 import processError from './utils/process-error.js';
-import { isSystemCollection } from '@directus/system-data';
-import isDirectusJWT from '../../utils/is-directus-jwt.js';
-import { verifyAccessJWT } from '../../utils/jwt.js';
 const env = useEnv();
 const validationRules = Array.from(specifiedRules);
 if (env['GRAPHQL_INTROSPECTION'] === false) {
@@ -104,6 +105,10 @@ export class GraphQLService {
         return formattedResult;
     }
     getSchema(type = 'schema') {
+        const key = `${type}_${this.accountability?.role}_${this.accountability?.user}`;
+        const cachedSchema = cache.get(key);
+        if (cachedSchema)
+            return cachedSchema;
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const self = this;
         const schemaComposer = new SchemaComposer();
@@ -218,9 +223,13 @@ export class GraphQLService {
             }, {}));
         }
         if (type === 'sdl') {
-            return schemaComposer.toSDL();
+            const sdl = schemaComposer.toSDL();
+            cache.set(key, sdl);
+            return sdl;
         }
-        return schemaComposer.buildSchema();
+        const gqlSchema = schemaComposer.buildSchema();
+        cache.set(key, gqlSchema);
+        return gqlSchema;
         /**
          * Construct an object of types for every collection, using the permitted fields per action type
          * as it's fields.

package/dist/services/graphql/schema-cache.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLSchema } from 'graphql';
+import LRUMapDefault from 'mnemonist/lru-map.js';
+export declare const cache: LRUMapDefault.default<string, string | GraphQLSchema>;

package/dist/services/graphql/schema-cache.js

@@ -0,0 +1,12 @@
+import { useEnv } from '@directus/env';
+import { GraphQLSchema } from 'graphql';
+import LRUMapDefault from 'mnemonist/lru-map.js';
+import { useBus } from '../../bus/index.js';
+// Workaround for misaligned types in mnemonist package exports
+const LRUMap = LRUMapDefault;
+const env = useEnv();
+const bus = useBus();
+export const cache = new LRUMap(Number(env['GRAPHQL_SCHEMA_CACHE_CAPACITY'] ?? 100));
+bus.subscribe('schemaChanged', () => {
+    cache.clear();
+});

package/dist/services/mail/index.d.ts

@@ -14,7 +14,7 @@ export declare class MailService {
     knex: Knex;
     mailer: Transporter;
     constructor(opts: AbstractServiceOptions);
-    send(options: EmailOptions): Promise<void>;
+    send<T>(options: EmailOptions): Promise<T>;
     private renderTemplate;
     private getDefaultTemplateData;
 }

package/dist/services/mail/index.js

@@ -54,10 +54,8 @@ export class MailService {
                 .map((line) => line.trim())
                 .join('\n');
         }
-        this.mailer.sendMail({ ...emailOptions, from, html }).catch((error) => {
-            logger.warn(`Email send failed:`);
-            logger.warn(error);
-        });
+        const info = await this.mailer.sendMail({ ...emailOptions, from, html });
+        return info;
     }
     async renderTemplate(template, variables) {
         const customTemplatePath = path.resolve(env['EMAIL_TEMPLATES_PATH'], template + '.liquid');

package/dist/services/notifications.js

@@ -37,19 +37,18 @@ export class NotificationsService extends ItemsService {
                 .toString();
             const html = data.message ? md(data.message) : '';
             if (user['email'] && user['email_notifications'] === true) {
-                try {
-                    await this.mailService.send({
-                        template: {
-                            name: 'base',
-                            data: user['role']?.app_access ? { url: manageUserAccountUrl, html } : { html },
-                        },
-                        to: user['email'],
-                        subject: data.subject,
-                    });
-                }
-                catch (error) {
-                    logger.error(error.message);
-                }
+                this.mailService
+                    .send({
+                    template: {
+                        name: 'base',
+                        data: user['role']?.app_access ? { url: manageUserAccountUrl, html } : { html },
+                    },
+                    to: user['email'],
+                    subject: data.subject,
+                })
+                    .catch((error) => {
+                    logger.error(error, `Could not send notification via mail`);
+                });
             }
         }
     }

package/dist/services/shares.js

@@ -10,7 +10,9 @@ import { AuthorizationService } from './authorization.js';
 import { ItemsService } from './items.js';
 import { MailService } from './mail/index.js';
 import { UsersService } from './users.js';
+import { useLogger } from '../logger.js';
 const env = useEnv();
+const logger = useLogger();
 export class SharesService extends ItemsService {
     authorizationService;
     constructor(options) {
@@ -119,7 +121,8 @@ ${userName(userInfo)} has invited you to view an item in ${share['collection']}.
 [Open](${new Url(env['PUBLIC_URL']).addPath('admin', 'shared', payload.share).toString()})
 `;
         for (const email of payload.emails) {
-            await mailService.send({
+            mailService
+                .send({
                 template: {
                     name: 'base',
                     data: {
@@ -128,6 +131,9 @@ ${userName(userInfo)} has invited you to view an item in ${share['collection']}.
                 },
                 to: email,
                 subject: `${userName(userInfo)} has shared an item with you`,
+            })
+                .catch((error) => {
+                logger.error(error, `Could not send share notification mail`);
             });
         }
     }

package/dist/services/users.js

@@ -14,7 +14,9 @@ import { Url } from '../utils/url.js';
 import { ItemsService } from './items.js';
 import { MailService } from './mail/index.js';
 import { SettingsService } from './settings.js';
+import { useLogger } from '../logger.js';
 const env = useEnv();
+const logger = useLogger();
 export class UsersService extends ItemsService {
     constructor(options) {
         super('directus_users', options);
@@ -335,7 +337,8 @@ export class UsersService extends ItemsService {
             // Send invite for new and already invited users
             if (isEmpty(user) || user.status === 'invited') {
                 const subjectLine = subject ?? "You've been invited";
-                await mailService.send({
+                mailService
+                    .send({
                     to: user?.email ?? email,
                     subject: subjectLine,
                     template: {
@@ -345,6 +348,9 @@ export class UsersService extends ItemsService {
                             email: user?.email ?? email,
                         },
                     },
+                })
+                    .catch((error) => {
+                    logger.error(error, `Could not send user invitation mail`);
                 });
             }
         }
@@ -386,7 +392,8 @@ export class UsersService extends ItemsService {
             ? new Url(url).setQuery('token', token).toString()
             : new Url(env['PUBLIC_URL']).addPath('admin', 'reset-password').setQuery('token', token).toString();
         const subjectLine = subject ? subject : 'Password Reset Request';
-        await mailService.send({
+        mailService
+            .send({
             to: user.email,
             subject: subjectLine,
             template: {
@@ -396,6 +403,9 @@ export class UsersService extends ItemsService {
                     email: user.email,
                 },
             },
+        })
+            .catch((error) => {
+            logger.error(error, `Could not send password reset mail`);
         });
         await stall(STALL_TIME, timeStart);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@directus/api",
-  "version": "18.1.0",
+  "version": "18.2.0",
   "description": "Directus is a real-time API and App dashboard for managing SQL database content",
   "keywords": [
     "directus",
@@ -59,7 +59,7 @@
   ],
   "dependencies": {
     "@authenio/samlify-node-xmllint": "2.0.0",
-    "@aws-sdk/client-ses": "3.525.0",
+    "@aws-sdk/client-ses": "3.529.0",
     "@directus/format-title": "10.1.0",
     "@godaddy/terminus": "4.12.1",
     "@rollup/plugin-alias": "5.1.0",
@@ -113,6 +113,7 @@
     "micromustache": "8.0.3",
     "mime-types": "2.1.35",
     "minimatch": "9.0.3",
+    "mnemonist": "0.39.8",
     "ms": "2.1.3",
     "nanoid": "5.0.6",
     "node-machine-id": "1.1.12",
@@ -120,7 +121,7 @@
     "nodemailer": "6.9.11",
     "object-hash": "3.0.0",
     "openapi3-ts": "4.2.2",
-    "openid-client": "5.6.4",
+    "openid-client": "5.6.5",
     "ora": "8.0.1",
     "otplib": "12.0.1",
     "p-limit": "5.0.0",
@@ -130,7 +131,7 @@
     "pino-http": "9.0.0",
     "pino-http-print": "3.1.0",
     "pino-pretty": "10.3.1",
-    "qs": "6.11.2",
+    "qs": "6.12.0",
     "rate-limiter-flexible": "5.0.0",
     "rollup": "4.12.0",
     "samlify": "2.8.11",
@@ -144,28 +145,28 @@
     "ws": "8.16.0",
     "zod": "3.22.4",
     "zod-validation-error": "3.0.3",
-    "@directus/app": "11.0.1",
-    "@directus/errors": "0.2.4",
-    "@directus/env": "1.0.4",
+    "@directus/app": "11.0.3",
+    "@directus/env": "1.1.0",
     "@directus/constants": "11.0.3",
-    "@directus/extensions": "1.0.1",
-    "@directus/memory": "1.0.4",
+    "@directus/errors": "0.2.4",
     "@directus/extensions-registry": "1.0.1",
+    "@directus/extensions": "1.0.1",
     "@directus/extensions-sdk": "11.0.1",
-    "@directus/schema": "11.0.1",
+    "@directus/memory": "1.0.5",
     "@directus/pressure": "1.0.17",
-    "@directus/storage": "10.0.11",
     "@directus/specs": "10.2.7",
+    "@directus/schema": "11.0.1",
+    "@directus/storage": "10.0.11",
     "@directus/storage-driver-azure": "10.0.18",
     "@directus/storage-driver-cloudinary": "10.0.18",
     "@directus/storage-driver-gcs": "10.0.18",
     "@directus/storage-driver-s3": "10.0.19",
     "@directus/storage-driver-local": "10.0.18",
+    "@directus/storage-driver-supabase": "1.0.10",
     "@directus/system-data": "1.0.1",
     "@directus/utils": "11.0.6",
-    "@directus/storage-driver-supabase": "1.0.10",
-    "@directus/validation": "0.0.13",
-    "directus": "10.10.1"
+    "directus": "10.10.3",
+    "@directus/validation": "0.0.13"
   },
   "devDependencies": {
     "@ngneat/falso": "7.2.0",
@@ -227,7 +228,7 @@
   "scripts": {
     "build": "tsc --project tsconfig.prod.json && copyfiles \"src/**/*.{yaml,liquid}\" -u 1 dist",
     "cli": "NODE_ENV=development SERVE_APP=false tsx src/cli/run.ts",
-    "dev": "NODE_ENV=development SERVE_APP=true tsx watch --clear-screen=false src/start.ts",
+    "dev": "NODE_ENV=development SERVE_APP=true tsx watch --ignore extensions --clear-screen=false src/start.ts",
     "test": "vitest --watch=false"
   }
 }

package/dist/utils/sanitize-error.d.ts

@@ -1 +0,0 @@
-export declare function sanitizeError<T extends Error>(error: T): T;

package/dist/utils/sanitize-error.js

@@ -1,7 +0,0 @@
-export function sanitizeError(error) {
-    // clear the stack
-    if (error.stack !== undefined) {
-        delete error.stack;
-    }
-    return error;
-}