@directus/api 13.0.0 → 13.1.0

package/dist/database/helpers/index.d.ts

@@ -4,10 +4,12 @@ import * as dateHelpers from './date/index.js';
 import * as fnHelpers from './fn/index.js';
 import * as geometryHelpers from './geometry/index.js';
 import * as schemaHelpers from './schema/index.js';
+import * as sequenceHelpers from './sequence/index.js';
 export declare function getHelpers(database: Knex): {
     date: dateHelpers.mysql | dateHelpers.postgres | dateHelpers.mssql | dateHelpers.sqlite | dateHelpers.oracle;
     st: geometryHelpers.mysql | geometryHelpers.postgres | geometryHelpers.mssql | geometryHelpers.sqlite | geometryHelpers.oracle | geometryHelpers.redshift;
     schema: schemaHelpers.mysql | schemaHelpers.cockroachdb | schemaHelpers.mssql | schemaHelpers.postgres | schemaHelpers.sqlite | schemaHelpers.oracle;
+    sequence: sequenceHelpers.mysql | sequenceHelpers.postgres;
 };
 export declare function getFunctions(database: Knex, schema: SchemaOverview): fnHelpers.mysql | fnHelpers.postgres | fnHelpers.mssql | fnHelpers.sqlite | fnHelpers.oracle;
 export type Helpers = ReturnType<typeof getHelpers>;

package/dist/database/helpers/index.js

@@ -3,12 +3,14 @@ import * as dateHelpers from './date/index.js';
 import * as fnHelpers from './fn/index.js';
 import * as geometryHelpers from './geometry/index.js';
 import * as schemaHelpers from './schema/index.js';
+import * as sequenceHelpers from './sequence/index.js';
 export function getHelpers(database) {
     const client = getDatabaseClient(database);
     return {
         date: new dateHelpers[client](database),
         st: new geometryHelpers[client](database),
         schema: new schemaHelpers[client](database),
+        sequence: new sequenceHelpers[client](database),
     };
 }
 export function getFunctions(database, schema) {

package/dist/database/helpers/sequence/dialects/default.d.ts

@@ -0,0 +1,3 @@
+import { AutoSequenceHelper } from '../types.js';
+export declare class AutoIncrementHelperDefault extends AutoSequenceHelper {
+}

package/dist/database/helpers/sequence/dialects/default.js

@@ -0,0 +1,3 @@
+import { AutoSequenceHelper } from '../types.js';
+export class AutoIncrementHelperDefault extends AutoSequenceHelper {
+}

package/dist/database/helpers/sequence/dialects/postgres.d.ts

@@ -0,0 +1,9 @@
+import type { Knex } from 'knex';
+import { AutoSequenceHelper } from '../types.js';
+export declare class AutoIncrementHelperPostgres extends AutoSequenceHelper {
+    /**
+     * Resets the auto increment sequence for a table based on the max value of the PK column.
+     * The sequence name of determined using a sub query.
+     */
+    resetAutoIncrementSequence(table: string, column: string): Promise<Knex.Raw | void>;
+}

package/dist/database/helpers/sequence/dialects/postgres.js

@@ -0,0 +1,10 @@
+import { AutoSequenceHelper } from '../types.js';
+export class AutoIncrementHelperPostgres extends AutoSequenceHelper {
+    /**
+     * Resets the auto increment sequence for a table based on the max value of the PK column.
+     * The sequence name of determined using a sub query.
+     */
+    async resetAutoIncrementSequence(table, column) {
+        return await this.knex.raw(`WITH sequence_infos AS (SELECT pg_get_serial_sequence('${table}', '${column}') AS seq_name, MAX(${column}) as max_val FROM ${table}) SELECT SETVAL(seq_name, max_val) FROM sequence_infos;`);
+    }
+}

package/dist/database/helpers/sequence/index.d.ts

@@ -0,0 +1,7 @@
+export { AutoIncrementHelperPostgres as postgres } from './dialects/postgres.js';
+export { AutoIncrementHelperDefault as mysql } from './dialects/default.js';
+export { AutoIncrementHelperDefault as cockroachdb } from './dialects/default.js';
+export { AutoIncrementHelperDefault as redshift } from './dialects/default.js';
+export { AutoIncrementHelperDefault as oracle } from './dialects/default.js';
+export { AutoIncrementHelperDefault as sqlite } from './dialects/default.js';
+export { AutoIncrementHelperDefault as mssql } from './dialects/default.js';

package/dist/database/helpers/sequence/index.js

@@ -0,0 +1,7 @@
+export { AutoIncrementHelperPostgres as postgres } from './dialects/postgres.js';
+export { AutoIncrementHelperDefault as mysql } from './dialects/default.js';
+export { AutoIncrementHelperDefault as cockroachdb } from './dialects/default.js';
+export { AutoIncrementHelperDefault as redshift } from './dialects/default.js';
+export { AutoIncrementHelperDefault as oracle } from './dialects/default.js';
+export { AutoIncrementHelperDefault as sqlite } from './dialects/default.js';
+export { AutoIncrementHelperDefault as mssql } from './dialects/default.js';

package/dist/database/helpers/sequence/types.d.ts

@@ -0,0 +1,5 @@
+import type { Knex } from 'knex';
+import { DatabaseHelper } from '../types.js';
+export declare class AutoSequenceHelper extends DatabaseHelper {
+    resetAutoIncrementSequence(_table: string, _column: string): Promise<Knex.Raw | void>;
+}

package/dist/database/helpers/sequence/types.js

@@ -0,0 +1,6 @@
+import { DatabaseHelper } from '../types.js';
+export class AutoSequenceHelper extends DatabaseHelper {
+    async resetAutoIncrementSequence(_table, _column) {
+        return;
+    }
+}

package/dist/database/index.js

@@ -43,6 +43,14 @@ export default function getDatabase() {
                 requiredEnvVars.push('DB_CONNECTION_STRING');
             }
             break;
+        case 'mysql':
+            if (!env['DB_SOCKET_PATH']) {
+                requiredEnvVars.push('DB_HOST', 'DB_PORT', 'DB_DATABASE', 'DB_USER', 'DB_PASSWORD');
+            }
+            else {
+                requiredEnvVars.push('DB_DATABASE', 'DB_USER', 'DB_PASSWORD', 'DB_SOCKET_PATH');
+            }
+            break;
         case 'mssql':
             if (!env['DB_TYPE'] || env['DB_TYPE'] === 'default') {
                 requiredEnvVars.push('DB_HOST', 'DB_PORT', 'DB_DATABASE', 'DB_USER', 'DB_PASSWORD');

package/dist/database/migrations/20230721A-require-shares-fields.js

@@ -1,28 +1,57 @@
+import { createInspector } from '@directus/schema';
+import logger from '../../logger.js';
+import { getHelpers } from '../helpers/index.js';
 export async function up(knex) {
+    const helper = getHelpers(knex).schema;
+    const isMysql = helper.isOneOfClients(['mysql']);
+    if (isMysql) {
+        await dropConstraint(knex);
+    }
     await knex.schema.alterTable('directus_shares', (table) => {
-        if (knex.client.constructor.name === 'Client_MySQL') {
-            // Temporary drop foreign key constraint, see https://github.com/directus/directus/issues/19399
-            table.dropForeign('collection', 'directus_shares_collection_foreign');
-        }
         table.dropNullable('collection');
-        if (knex.client.constructor.name === 'Client_MySQL') {
-            // Recreate foreign key constraint, from 20211211A-add-shares.ts
-            table.foreign('collection').references('directus_collections.collection').onDelete('CASCADE');
-        }
         table.dropNullable('item');
     });
+    if (isMysql) {
+        await recreateConstraint(knex);
+    }
 }
 export async function down(knex) {
+    const helper = getHelpers(knex).schema;
+    const isMysql = helper.isOneOfClients(['mysql']);
+    if (isMysql) {
+        await dropConstraint(knex);
+    }
     await knex.schema.alterTable('directus_shares', (table) => {
-        if (knex.client.constructor.name === 'Client_MySQL') {
-            // Temporary drop foreign key constraint, see https://github.com/directus/directus/issues/19399
-            table.dropForeign('collection', 'directus_shares_collection_foreign');
-        }
         table.setNullable('collection');
-        if (knex.client.constructor.name === 'Client_MySQL') {
-            // Recreate foreign key constraint, from 20211211A-add-shares.ts
-            table.foreign('collection').references('directus_collections.collection').onDelete('CASCADE');
-        }
         table.setNullable('item');
     });
+    if (isMysql) {
+        await recreateConstraint(knex);
+    }
+}
+/**
+ * Temporarily drop foreign key constraint for MySQL instances, see https://github.com/directus/directus/issues/19399
+ */
+async function dropConstraint(knex) {
+    const inspector = createInspector(knex);
+    const foreignKeys = await inspector.foreignKeys('directus_shares');
+    const collectionForeignKeys = foreignKeys.filter((fk) => fk.column === 'collection');
+    const constraintName = collectionForeignKeys[0]?.constraint_name;
+    if (constraintName && collectionForeignKeys.length === 1) {
+        await knex.schema.alterTable('directus_shares', (table) => {
+            table.dropForeign('collection', constraintName);
+        });
+    }
+    else {
+        logger.warn(`Unexpected number of foreign key constraints on 'directus_shares.collection':`);
+        logger.warn(JSON.stringify(collectionForeignKeys, null, 4));
+    }
+}
+/**
+ * Recreate foreign key constraint for MySQL instances, from 20211211A-add-shares.ts
+ */
+async function recreateConstraint(knex) {
+    return knex.schema.alterTable('directus_shares', async (table) => {
+        table.foreign('collection').references('directus_collections.collection').onDelete('CASCADE');
+    });
 }

package/dist/env.d.ts

@@ -12,4 +12,4 @@ 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(): void;
+export declare function refreshEnv(): Promise<void>;

package/dist/env.js

@@ -3,11 +3,14 @@
  * 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 dotenv from 'dotenv';
 import fs from 'fs';
 import { clone, toNumber, toString } from 'lodash-es';
 import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
 import path from 'path';
+import getModuleDefault from './utils/get-module-default.js';
 import { requireYAML } from './utils/require-yaml.js';
 import { toBoolean } from './utils/to-boolean.js';
 const require = createRequire(import.meta.url);
@@ -317,7 +320,7 @@ const typeMap = {
 let env = {
     ...defaults,
     ...process.env,
-    ...processConfiguration(),
+    ...(await processConfiguration()),
 };
 process.env = env;
 env = processValues(env);
@@ -330,30 +333,30 @@ 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
  */
-export function refreshEnv() {
+export async function refreshEnv() {
     env = {
         ...defaults,
         ...process.env,
-        ...processConfiguration(),
+        ...(await processConfiguration()),
     };
     process.env = env;
     env = processValues(env);
 }
-function processConfiguration() {
+async function processConfiguration() {
     const configPath = path.resolve(process.env['CONFIG_PATH'] || defaults['CONFIG_PATH']);
     if (fs.existsSync(configPath) === false)
         return {};
-    const fileExt = path.extname(configPath).toLowerCase();
-    if (fileExt === '.js') {
-        const module = require(configPath);
-        const exported = module.default || module;
-        if (typeof exported === 'function') {
-            return exported(process.env);
+    const fileExt = path.extname(configPath).toLowerCase().substring(1);
+    if (JAVASCRIPT_FILE_EXTS.includes(fileExt)) {
+        const data = await import(pathToFileURL(configPath).toString());
+        const config = getModuleDefault(data);
+        if (typeof config === 'function') {
+            return config(process.env);
         }
-        else if (typeof exported === 'object') {
-            return exported;
+        else if (typeof config === 'object') {
+            return config;
         }
-        throw new Error(`Invalid JS configuration file export type. Requires one of "function", "object", received: "${typeof exported}"`);
+        throw new Error(`Invalid JS configuration file export type. Requires one of "function", "object", received: "${typeof config}"`);
     }
     if (fileExt === '.json') {
         return require(configPath);

package/dist/services/activity.js

@@ -60,6 +60,9 @@ export class ActivityService extends ItemsService {
                         comment = comment.replace(new RegExp(mention, 'gm'), userPreviews[uuid] ?? '@Unknown User');
                     }
                     comment = `> ${comment.replace(/\n+/gm, '\n> ')}`;
+                    const href = new Url(env['PUBLIC_URL'])
+                        .addPath('admin', 'content', data['collection'], data['item'])
+                        .toString();
                     const message = `
 Hello ${userName(user)},
 
@@ -67,9 +70,7 @@ ${userName(sender)} has mentioned you in a comment:
 
 ${comment}
 
-<a href="${new Url(env['PUBLIC_URL'])
-                        .addPath('admin', 'content', data['collection'], data['item'])
-                        .toString()}">Click here to view.</a>
+<a href="${href}">Click here to view.</a>
 `;
                     await this.notificationsService.createOne({
                         recipient: userID,

package/dist/services/assets.js

@@ -129,7 +129,23 @@ export class AssetsService {
                 logger.error(e, `Couldn't transform file ${file.id}`);
                 readStream.unpipe(transformer);
             });
-            await storage.location(file.storage).write(assetFilename, readStream.pipe(transformer), type);
+            try {
+                await storage.location(file.storage).write(assetFilename, readStream.pipe(transformer), type);
+            }
+            catch (error) {
+                try {
+                    await storage.location(file.storage).delete(assetFilename);
+                }
+                catch {
+                    // Ignored to prevent original error from being overwritten
+                }
+                if (error?.message?.includes('timeout')) {
+                    throw new ServiceUnavailableError({ service: 'assets', reason: `Transformation timed out` });
+                }
+                else {
+                    throw error;
+                }
+            }
             return {
                 stream: await storage.location(file.storage).read(assetFilename, range),
                 stat: await storage.location(file.storage).stat(assetFilename),

package/dist/services/files.js

@@ -5,7 +5,9 @@ import exif from 'exif-reader';
 import { parse as parseIcc } from 'icc';
 import { clone, pick } from 'lodash-es';
 import { extension } from 'mime-types';
+import { PassThrough as PassThroughStream, Transform as TransformStream } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
+import zlib from 'node:zlib';
 import path from 'path';
 import sharp from 'sharp';
 import url from 'url';
@@ -209,6 +211,7 @@ export class FilesService extends ItemsService {
             const axios = await getAxios();
             fileResponse = await axios.get(encodeURL(importURL), {
                 responseType: 'stream',
+                decompress: false,
             });
         }
         catch (err) {
@@ -227,7 +230,7 @@ export class FilesService extends ItemsService {
             title: formatTitle(filename),
             ...(body || {}),
         };
-        return await this.uploadOne(fileResponse.data, payload);
+        return await this.uploadOne(decompressResponse(fileResponse.data, fileResponse.headers), payload);
     }
     /**
      * Create a file (only applicable when it is not a multipart/data POST request)
@@ -267,3 +270,57 @@ export class FilesService extends ItemsService {
         return keys;
     }
 }
+function decompressResponse(stream, headers) {
+    const contentEncoding = (headers['content-encoding'] || '').toLowerCase();
+    if (!['gzip', 'deflate', 'br'].includes(contentEncoding)) {
+        return stream;
+    }
+    let isEmpty = true;
+    const checker = new TransformStream({
+        transform(data, _encoding, callback) {
+            if (isEmpty === false) {
+                callback(null, data);
+                return;
+            }
+            isEmpty = false;
+            handleContentEncoding(data);
+            callback(null, data);
+        },
+        flush(callback) {
+            callback();
+        },
+    });
+    const finalStream = new PassThroughStream({
+        autoDestroy: false,
+        destroy(error, callback) {
+            stream.destroy();
+            callback(error);
+        },
+    });
+    stream.pipe(checker);
+    return finalStream;
+    function handleContentEncoding(data) {
+        let decompressStream;
+        if (contentEncoding === 'br') {
+            decompressStream = zlib.createBrotliDecompress();
+        }
+        else if (contentEncoding === 'deflate' && isDeflateAlgorithm(data)) {
+            decompressStream = zlib.createInflateRaw();
+        }
+        else {
+            decompressStream = zlib.createUnzip();
+        }
+        decompressStream.once('error', (error) => {
+            if (isEmpty && !stream.readable) {
+                finalStream.end();
+                return;
+            }
+            finalStream.destroy(error);
+        });
+        checker.pipe(decompressStream).pipe(finalStream);
+    }
+    function isDeflateAlgorithm(data) {
+        const DEFLATE_ALGORITHM_HEADER = 0x08;
+        return data.length > 0 && (data[0] & DEFLATE_ALGORITHM_HEADER) === 0;
+    }
+}

package/dist/services/import-export.js

@@ -17,9 +17,12 @@ import env from '../env.js';
 import { ForbiddenError, InvalidPayloadError, ServiceUnavailableError, UnsupportedMediaTypeError, } from '../errors/index.js';
 import logger from '../logger.js';
 import { getDateFormatted } from '../utils/get-date-formatted.js';
+import { userName } from '../utils/user-name.js';
 import { FilesService } from './files.js';
 import { ItemsService } from './items.js';
 import { NotificationsService } from './notifications.js';
+import { UsersService } from './users.js';
+import { Url } from '../utils/url.js';
 export class ImportService {
     knex;
     accountability;
@@ -226,10 +229,23 @@ export class ExportService {
                     accountability: this.accountability,
                     schema: this.schema,
                 });
+                const usersService = new UsersService({
+                    schema: this.schema,
+                });
+                const user = await usersService.readOne(this.accountability.user, {
+                    fields: ['first_name', 'last_name', 'email'],
+                });
+                const href = new Url(env['PUBLIC_URL']).addPath('admin', 'files', savedFile).toString();
+                const message = `
+Hello ${userName(user)},
+
+Your export of ${collection} is ready. <a href="${href}">Click here to view.</a>
+`;
                 await notificationsService.createOne({
                     recipient: this.accountability.user,
                     sender: this.accountability.user,
                     subject: `Your export of ${collection} is ready`,
+                    message,
                     collection: `directus_files`,
                     item: savedFile,
                 });

package/dist/services/items.js

@@ -116,8 +116,20 @@ export class ItemsService {
             const { payload: payloadWithA2O, revisions: revisionsA2O, nestedActionEvents: nestedActionEventsA2O, } = await payloadService.processA2O(payloadWithM2O, opts);
             const payloadWithoutAliases = pick(payloadWithA2O, without(fields, ...aliases));
             const payloadWithTypeCasting = await payloadService.processValues('create', payloadWithoutAliases);
-            // In case of manual string / UUID primary keys, the PK already exists in the object we're saving.
+            // The primary key can already exist in the payload.
+            // In case of manual string / UUID primary keys it's always provided at this point.
+            // In case of an integer primary key, it might be provided as the user can specify the value manually.
             let primaryKey = payloadWithTypeCasting[primaryKeyField];
+            // If a PK of type number was provided, although the PK is set the auto_increment,
+            // depending on the database, the sequence might need to be reset to protect future PK collisions.
+            let autoIncrementSequenceNeedsToBeReset = false;
+            const pkField = this.schema.collections[this.collection].fields[primaryKeyField];
+            if (primaryKey &&
+                !opts.bypassAutoIncrementSequenceReset &&
+                pkField.type === 'integer' &&
+                pkField.defaultValue === 'AUTO_INCREMENT') {
+                autoIncrementSequenceNeedsToBeReset = true;
+            }
             try {
                 const result = await trx
                     .insert(payloadWithoutAliases)
@@ -125,7 +137,7 @@ export class ItemsService {
                     .returning(primaryKeyField)
                     .then((result) => result[0]);
                 const returnedKey = typeof result === 'object' ? result[primaryKeyField] : result;
-                if (this.schema.collections[this.collection].fields[primaryKeyField].type === 'uuid') {
+                if (pkField.type === 'uuid') {
                     primaryKey = getHelpers(trx).schema.formatUUID(primaryKey ?? returnedKey);
                 }
                 else {
@@ -146,6 +158,8 @@ export class ItemsService {
                 // to read from it
                 payload[primaryKeyField] = primaryKey;
             }
+            // At this point, the primary key is guaranteed to be set.
+            primaryKey = primaryKey;
             const { revisions: revisionsO2M, nestedActionEvents: nestedActionEventsO2M } = await payloadService.processO2M(payloadWithPresets, primaryKey, opts);
             nestedActionEvents.push(...nestedActionEventsM2O);
             nestedActionEvents.push(...nestedActionEventsA2O);
@@ -189,6 +203,9 @@ export class ItemsService {
                     }
                 }
             }
+            if (autoIncrementSequenceNeedsToBeReset) {
+                await getHelpers(trx).sequence.resetAutoIncrementSequence(this.collection, primaryKeyField);
+            }
             return primaryKey;
         });
         if (opts.emitEvents !== false) {
@@ -241,12 +258,20 @@ export class ItemsService {
             });
             const primaryKeys = [];
             const nestedActionEvents = [];
-            for (const payload of data) {
+            const pkField = this.schema.collections[this.collection].primary;
+            for (const [index, payload] of data.entries()) {
+                let bypassAutoIncrementSequenceReset = true;
+                // the auto_increment sequence needs to be reset if the current item contains a manual PK and
+                // if it's the last item of the batch or if the next item doesn't include a PK and hence one needs to be generated
+                if (payload[pkField] && (index === data.length - 1 || !data[index + 1]?.[pkField])) {
+                    bypassAutoIncrementSequenceReset = false;
+                }
                 const primaryKey = await service.createOne(payload, {
                     ...(opts || {}),
                     autoPurgeCache: false,
                     bypassEmitAction: (params) => nestedActionEvents.push(params),
                     mutationTracker: opts.mutationTracker,
+                    bypassAutoIncrementSequenceReset,
                 });
                 primaryKeys.push(primaryKey);
             }

package/dist/types/items.d.ts

@@ -47,6 +47,7 @@ export type MutationOptions = {
      */
     mutationTracker?: MutationTracker | undefined;
     preMutationError?: DirectusError | undefined;
+    bypassAutoIncrementSequenceReset?: boolean;
 };
 export type ActionEventParams = {
     event: string | string[];

package/dist/websocket/controllers/base.d.ts

@@ -30,6 +30,7 @@ export default abstract class SocketController {
         maxConnections: number;
     };
     protected getRateLimiter(): RateLimiterAbstract | null;
+    private catchInvalidMessages;
     protected handleUpgrade(request: IncomingMessage, socket: internal.Duplex, head: Buffer): Promise<void>;
     protected handleStrictUpgrade({ request, socket, head }: UpgradeContext, query: ParsedUrlQuery): Promise<void>;
     protected handleHandshakeUpgrade({ request, socket, head }: UpgradeContext): Promise<void>;

package/dist/websocket/controllers/base.js

@@ -67,6 +67,19 @@ export default class SocketController {
         }
         return null;
     }
+    catchInvalidMessages(ws) {
+        /**
+         * This fix was done to prevent the API from crashing on receiving invalid WebSocket frames
+         * https://github.com/directus/directus/security/advisories/GHSA-hmgw-9jrg-hf2m
+         * https://github.com/websockets/ws/issues/2098
+         */
+        // @ts-ignore <- required because "_socket" is not typed on WS
+        ws._socket.prependListener('data', (data) => data.toString());
+        ws.on('error', (error) => {
+            if (error.message)
+                logger.debug(error.message);
+        });
+    }
     async handleUpgrade(request, socket, head) {
         const { pathname, query } = parse(request.url, true);
         if (pathname !== this.endpoint)
@@ -87,6 +100,7 @@ export default class SocketController {
             return;
         }
         this.server.handleUpgrade(request, socket, head, async (ws) => {
+            this.catchInvalidMessages(ws);
             const state = { accountability: null, expires_at: null };
             this.server.emit('connection', ws, state);
         });
@@ -109,12 +123,14 @@ export default class SocketController {
             return;
         }
         this.server.handleUpgrade(request, socket, head, async (ws) => {
+            this.catchInvalidMessages(ws);
             const state = { accountability, expires_at };
             this.server.emit('connection', ws, state);
         });
     }
     async handleHandshakeUpgrade({ request, socket, head }) {
         this.server.handleUpgrade(request, socket, head, async (ws) => {
+            this.catchInvalidMessages(ws);
             try {
                 const payload = await waitForAnyMessage(ws, this.authentication.timeout);
                 if (getMessageType(payload) !== 'auth')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@directus/api",
-  "version": "13.0.0",
+  "version": "13.1.0",
   "description": "Directus is a real-time API and App dashboard for managing SQL database content",
   "keywords": [
     "directus",
@@ -131,7 +131,7 @@
     "rollup": "3.22.0",
     "samlify": "2.8.10",
     "sanitize-html": "2.10.0",
-    "sharp": "0.32.1",
+    "sharp": "0.32.5",
     "snappy": "7.2.2",
     "stream-json": "1.7.5",
     "strip-bom-stream": "5.0.0",
@@ -143,22 +143,22 @@
     "ws": "8.12.1",
     "zod": "3.21.4",
     "zod-validation-error": "1.0.1",
-    "@directus/app": "10.7.0",
+    "@directus/app": "10.8.0",
     "@directus/constants": "10.2.3",
     "@directus/errors": "0.0.2",
-    "@directus/extensions-sdk": "10.1.9",
-    "@directus/pressure": "1.0.8",
+    "@directus/extensions-sdk": "10.1.10",
+    "@directus/pressure": "1.0.9",
     "@directus/schema": "10.0.2",
     "@directus/specs": "10.2.0",
     "@directus/storage": "10.0.5",
-    "@directus/storage-driver-azure": "10.0.9",
-    "@directus/storage-driver-cloudinary": "10.0.9",
-    "@directus/storage-driver-gcs": "10.0.9",
-    "@directus/storage-driver-local": "10.0.9",
-    "@directus/storage-driver-s3": "10.0.9",
-    "@directus/storage-driver-supabase": "1.0.1",
-    "@directus/utils": "10.0.9",
-    "@directus/validation": "0.0.4"
+    "@directus/storage-driver-azure": "10.0.10",
+    "@directus/storage-driver-cloudinary": "10.0.10",
+    "@directus/storage-driver-gcs": "10.0.10",
+    "@directus/storage-driver-local": "10.0.10",
+    "@directus/storage-driver-s3": "10.0.10",
+    "@directus/storage-driver-supabase": "1.0.2",
+    "@directus/utils": "10.0.10",
+    "@directus/validation": "0.0.5"
   },
   "devDependencies": {
     "@ngneat/falso": "6.4.0",
@@ -207,7 +207,7 @@
     "vitest": "0.31.1",
     "@directus/random": "0.2.2",
     "@directus/tsconfig": "1.0.0",
-    "@directus/types": "10.1.5"
+    "@directus/types": "10.1.6"
   },
   "optionalDependencies": {
     "@keyv/redis": "2.5.8",