@directus/api 19.2.0 → 19.3.1

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

@@ -9,7 +9,7 @@ import * as numberHelpers from './number/index.js';
 export declare function getHelpers(database: Knex): {
     date: dateHelpers.postgres | dateHelpers.oracle | dateHelpers.mysql | dateHelpers.mssql | dateHelpers.sqlite;
     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;
+    schema: schemaHelpers.mysql | schemaHelpers.cockroachdb | schemaHelpers.mssql | schemaHelpers.postgres | schemaHelpers.sqlite | schemaHelpers.oracle | schemaHelpers.redshift;
     sequence: sequenceHelpers.mysql | sequenceHelpers.postgres;
     number: numberHelpers.cockroachdb | numberHelpers.mssql | numberHelpers.postgres | numberHelpers.sqlite | numberHelpers.oracle;
 };

package/dist/database/helpers/schema/dialects/cockroachdb.d.ts

@@ -4,4 +4,5 @@ import { SchemaHelper } from '../types.js';
 export declare class SchemaHelperCockroachDb extends SchemaHelper {
     changeToType(table: string, column: string, type: (typeof KNEX_TYPES)[number], options?: Options): Promise<void>;
     constraintName(existingName: string): string;
+    getDatabaseSize(): Promise<number | null>;
 }

package/dist/database/helpers/schema/dialects/cockroachdb.js

@@ -1,4 +1,6 @@
 import { SchemaHelper } from '../types.js';
+import { useEnv } from '@directus/env';
+const env = useEnv();
 export class SchemaHelperCockroachDb extends SchemaHelper {
     async changeToType(table, column, type, options = {}) {
         await this.changeToTypeByCopy(table, column, type, options);
@@ -14,4 +16,15 @@ export class SchemaHelperCockroachDb extends SchemaHelper {
             return existingName + suffix;
         }
     }
+    async getDatabaseSize() {
+        try {
+            const result = await this.knex
+                .select(this.knex.raw('round(SUM(range_size_mb) * 1024 * 1024, 0) AS size'))
+                .from(this.knex.raw('[SHOW RANGES FROM database ??]', [env['DB_DATABASE']]));
+            return result[0]?.['size'] ? Number(result[0]?.['size']) : null;
+        }
+        catch {
+            return null;
+        }
+    }
 }

package/dist/database/helpers/schema/dialects/mssql.d.ts

@@ -4,4 +4,5 @@ export declare class SchemaHelperMSSQL extends SchemaHelper {
     applyLimit(rootQuery: Knex.QueryBuilder, limit: number): void;
     applyOffset(rootQuery: Knex.QueryBuilder, offset: number): void;
     formatUUID(uuid: string): string;
+    getDatabaseSize(): Promise<number | null>;
 }

package/dist/database/helpers/schema/dialects/mssql.js

@@ -17,4 +17,13 @@ export class SchemaHelperMSSQL extends SchemaHelper {
     formatUUID(uuid) {
         return uuid.toUpperCase();
     }
+    async getDatabaseSize() {
+        try {
+            const result = await this.knex.raw('SELECT SUM(size) * 8192 AS size FROM sys.database_files;');
+            return result[0]?.['size'] ? Number(result[0]?.['size']) : null;
+        }
+        catch {
+            return null;
+        }
+    }
 }

package/dist/database/helpers/schema/dialects/mysql.d.ts

@@ -2,4 +2,5 @@ import type { Knex } from 'knex';
 import { SchemaHelper } from '../types.js';
 export declare class SchemaHelperMySQL extends SchemaHelper {
     applyMultiRelationalSort(knex: Knex, dbQuery: Knex.QueryBuilder, table: string, primaryKey: string, orderByString: string, orderByFields: Knex.Raw[]): Knex.QueryBuilder;
+    getDatabaseSize(): Promise<number | null>;
 }

package/dist/database/helpers/schema/dialects/mysql.js

@@ -1,5 +1,7 @@
+import { useEnv } from '@directus/env';
 import { getDatabaseVersion } from '../../../index.js';
 import { SchemaHelper } from '../types.js';
+const env = useEnv();
 export class SchemaHelperMySQL extends SchemaHelper {
     applyMultiRelationalSort(knex, dbQuery, table, primaryKey, orderByString, orderByFields) {
         if (getDatabaseVersion()?.startsWith('5.7')) {
@@ -11,4 +13,19 @@ export class SchemaHelperMySQL extends SchemaHelper {
         }
         return super.applyMultiRelationalSort(knex, dbQuery, table, primaryKey, orderByString, orderByFields);
     }
+    async getDatabaseSize() {
+        try {
+            const result = (await this.knex
+                .sum('size AS size')
+                .from(this.knex
+                .select(this.knex.raw('data_length + index_length AS size'))
+                .from('information_schema.TABLES')
+                .where('table_schema', '=', String(env['DB_DATABASE']))
+                .as('size')));
+            return result[0]?.['size'] ? Number(result[0]?.['size']) : null;
+        }
+        catch {
+            return null;
+        }
+    }
 }

package/dist/database/helpers/schema/dialects/oracle.d.ts

@@ -7,4 +7,5 @@ export declare class SchemaHelperOracle extends SchemaHelper {
     castA2oPrimaryKey(): string;
     preRelationChange(relation: Partial<Relation>): void;
     processFieldType(field: Field): Type;
+    getDatabaseSize(): Promise<number | null>;
 }

package/dist/database/helpers/schema/dialects/oracle.js

@@ -29,4 +29,13 @@ export class SchemaHelperOracle extends SchemaHelper {
         }
         return field.type;
     }
+    async getDatabaseSize() {
+        try {
+            const result = await this.knex.raw('select SUM(bytes) from dba_segments');
+            return result[0]?.['SUM(BYTES)'] ? Number(result[0]?.['SUM(BYTES)']) : null;
+        }
+        catch {
+            return null;
+        }
+    }
 }

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

@@ -0,0 +1,4 @@
+import { SchemaHelper } from '../types.js';
+export declare class SchemaHelperPostgres extends SchemaHelper {
+    getDatabaseSize(): Promise<number | null>;
+}

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

@@ -0,0 +1,14 @@
+import { useEnv } from '@directus/env';
+import { SchemaHelper } from '../types.js';
+const env = useEnv();
+export class SchemaHelperPostgres extends SchemaHelper {
+    async getDatabaseSize() {
+        try {
+            const result = await this.knex.select(this.knex.raw(`pg_database_size(?) as size;`, [env['DB_DATABASE']]));
+            return result[0]?.['size'] ? Number(result[0]?.['size']) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/database/helpers/schema/dialects/sqlite.d.ts

@@ -2,4 +2,5 @@ import { SchemaHelper } from '../types.js';
 export declare class SchemaHelperSQLite extends SchemaHelper {
     preColumnChange(): Promise<boolean>;
     postColumnChange(): Promise<void>;
+    getDatabaseSize(): Promise<number | null>;
 }

package/dist/database/helpers/schema/dialects/sqlite.js

@@ -10,4 +10,13 @@ export class SchemaHelperSQLite extends SchemaHelper {
     async postColumnChange() {
         await this.knex.raw('PRAGMA foreign_keys = ON');
     }
+    async getDatabaseSize() {
+        try {
+            const result = await this.knex.raw('SELECT page_count * page_size as "size" FROM pragma_page_count(), pragma_page_size();');
+            return result[0]?.['size'] ? Number(result[0]?.['size']) : null;
+        }
+        catch {
+            return null;
+        }
+    }
 }

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

@@ -1,7 +1,7 @@
-export { SchemaHelperDefault as postgres } from './dialects/default.js';
 export { SchemaHelperCockroachDb as cockroachdb } from './dialects/cockroachdb.js';
 export { SchemaHelperDefault as redshift } from './dialects/default.js';
+export { SchemaHelperMSSQL as mssql } from './dialects/mssql.js';
+export { SchemaHelperMySQL as mysql } from './dialects/mysql.js';
 export { SchemaHelperOracle as oracle } from './dialects/oracle.js';
+export { SchemaHelperPostgres as postgres } from './dialects/postgres.js';
 export { SchemaHelperSQLite as sqlite } from './dialects/sqlite.js';
-export { SchemaHelperMySQL as mysql } from './dialects/mysql.js';
-export { SchemaHelperMSSQL as mssql } from './dialects/mssql.js';

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

@@ -1,7 +1,7 @@
-export { SchemaHelperDefault as postgres } from './dialects/default.js';
 export { SchemaHelperCockroachDb as cockroachdb } from './dialects/cockroachdb.js';
 export { SchemaHelperDefault as redshift } from './dialects/default.js';
+export { SchemaHelperMSSQL as mssql } from './dialects/mssql.js';
+export { SchemaHelperMySQL as mysql } from './dialects/mysql.js';
 export { SchemaHelperOracle as oracle } from './dialects/oracle.js';
+export { SchemaHelperPostgres as postgres } from './dialects/postgres.js';
 export { SchemaHelperSQLite as sqlite } from './dialects/sqlite.js';
-export { SchemaHelperMySQL as mysql } from './dialects/mysql.js';
-export { SchemaHelperMSSQL as mssql } from './dialects/mssql.js';

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

@@ -23,4 +23,8 @@ export declare abstract class SchemaHelper extends DatabaseHelper {
     castA2oPrimaryKey(): string;
     applyMultiRelationalSort(knex: Knex, dbQuery: Knex.QueryBuilder, table: string, primaryKey: string, orderByString: string, orderByFields: Knex.Raw[]): Knex.QueryBuilder;
     formatUUID(uuid: string): string;
+    /**
+     * @returns Size of the database in bytes
+     */
+    getDatabaseSize(): Promise<number | null>;
 }

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

@@ -88,4 +88,10 @@ export class SchemaHelper extends DatabaseHelper {
     formatUUID(uuid) {
         return uuid; // no-op by default
     }
+    /**
+     * @returns Size of the database in bytes
+     */
+    async getDatabaseSize() {
+        return null;
+    }
 }

package/dist/middleware/graphql.js

@@ -3,6 +3,7 @@ import { getOperationAST, parse, Source } from 'graphql';
 import { InvalidPayloadError, InvalidQueryError, MethodNotAllowedError } from '@directus/errors';
 import { GraphQLValidationError } from '../services/graphql/errors/validation.js';
 import asyncHandler from '../utils/async-handler.js';
+import { useEnv } from '@directus/env';
 export const parseGraphQL = asyncHandler(async (req, res, next) => {
     if (req.method !== 'GET' && req.method !== 'POST') {
         throw new MethodNotAllowedError({ allowed: ['GET', 'POST'], current: req.method });
@@ -35,7 +36,10 @@ export const parseGraphQL = asyncHandler(async (req, res, next) => {
         throw new InvalidPayloadError({ reason: 'Must provide query string' });
     }
     try {
-        document = parse(new Source(query));
+        const env = useEnv();
+        document = parse(new Source(query), {
+            maxTokens: Number(env['GRAPHQL_QUERY_TOKEN_LIMIT']),
+        });
     }
     catch (err) {
         throw new GraphQLValidationError({

package/dist/services/extensions.js

@@ -52,7 +52,7 @@ export class ExtensionsService {
             const points = version.bundled.length ?? 1;
             const afterInstallCount = currentlyInstalledCount + points;
             if (afterInstallCount >= limit) {
-                throw new LimitExceededError();
+                throw new LimitExceededError({ category: 'Extensions' });
             }
         }
         return { extension, version };

package/dist/services/roles.d.ts

@@ -7,6 +7,7 @@ export declare class RolesService extends ItemsService {
     private checkForOtherAdminUsers;
     private isIpAccessValid;
     private assertValidIpAccess;
+    private getRoleAccessType;
     createOne(data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
     createMany(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
     updateOne(key: PrimaryKey, data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;

package/dist/services/roles.js

@@ -1,5 +1,12 @@
-import { ForbiddenError, InvalidPayloadError, UnprocessableContentError } from '@directus/errors';
+import { InvalidPayloadError, UnprocessableContentError } from '@directus/errors';
 import { getMatch } from 'ip-matching';
+import { omit } from 'lodash-es';
+import { checkIncreasedUserLimits } from '../telemetry/utils/check-increased-user-limits.js';
+import { getRoleCountsByUsers } from '../telemetry/utils/get-role-counts-by-users.js';
+import {} from '../telemetry/utils/get-user-count.js';
+import { getUserCountsByRoles } from '../telemetry/utils/get-user-counts-by-roles.js';
+import { shouldCheckUserLimits } from '../telemetry/utils/should-check-user-limits.js';
+import { shouldClearCache } from '../utils/should-clear-cache.js';
 import { transaction } from '../utils/transaction.js';
 import { ItemsService } from './items.js';
 import { PermissionsService } from './permissions/index.js';
@@ -24,8 +31,9 @@ export class RolesService extends ItemsService {
     }
     async checkForOtherAdminUsers(key, users) {
         const role = await this.knex.select('admin_access').from('directus_roles').where('id', '=', key).first();
+        // No-op if role doesn't exist
         if (!role)
-            throw new ForbiddenError();
+            return;
         const usersBefore = (await this.knex.select('id').from('directus_users').where('role', '=', key)).map((user) => user.id);
         const usersAdded = [];
         const usersUpdated = [];
@@ -151,13 +159,67 @@ export class RolesService extends ItemsService {
             });
         }
     }
+    getRoleAccessType(data) {
+        if ('admin_access' in data && data['admin_access'] === true) {
+            return 'admin';
+        }
+        else if (('app_access' in data && data['app_access'] === true) || 'app_access' in data === false) {
+            return 'app';
+        }
+        else {
+            return 'api';
+        }
+    }
     async createOne(data, opts) {
         this.assertValidIpAccess(data);
+        if (shouldCheckUserLimits()) {
+            const increasedCounts = {
+                admin: 0,
+                app: 0,
+                api: 0,
+            };
+            const existingIds = [];
+            if ('users' in data) {
+                const type = this.getRoleAccessType(data);
+                increasedCounts[type] += data['users'].length;
+                for (const user of data['users']) {
+                    if (typeof user === 'string') {
+                        existingIds.push(user);
+                    }
+                    else if (typeof user === 'object' && 'id' in user) {
+                        existingIds.push(user['id']);
+                    }
+                }
+            }
+            await checkIncreasedUserLimits(this.knex, increasedCounts, existingIds);
+        }
         return super.createOne(data, opts);
     }
     async createMany(data, opts) {
+        const needsUserLimitCheck = shouldCheckUserLimits();
+        const increasedCounts = {
+            admin: 0,
+            app: 0,
+            api: 0,
+        };
+        const existingIds = [];
         for (const partialItem of data) {
             this.assertValidIpAccess(partialItem);
+            if (needsUserLimitCheck && 'users' in partialItem) {
+                const type = this.getRoleAccessType(partialItem);
+                increasedCounts[type] += partialItem['users'].length;
+                for (const user of partialItem['users']) {
+                    if (typeof user === 'string') {
+                        existingIds.push(user);
+                    }
+                    else if (typeof user === 'object' && 'id' in user) {
+                        existingIds.push(user['id']);
+                    }
+                }
+            }
+        }
+        if (needsUserLimitCheck) {
+            await checkIncreasedUserLimits(this.knex, increasedCounts, existingIds);
         }
         return super.createMany(data, opts);
     }
@@ -167,28 +229,150 @@ export class RolesService extends ItemsService {
             if ('users' in data) {
                 await this.checkForOtherAdminUsers(key, data['users']);
             }
+            if (shouldCheckUserLimits()) {
+                const increasedCounts = {
+                    admin: 0,
+                    app: 0,
+                    api: 0,
+                };
+                let increasedUsers = 0;
+                const existingIds = [];
+                let existingRole = await this.knex
+                    .count('directus_users.id', { as: 'count' })
+                    .select('directus_roles.admin_access', 'directus_roles.app_access')
+                    .from('directus_users')
+                    .where('directus_roles.id', '=', key)
+                    .andWhere('directus_users.status', '=', 'active')
+                    .leftJoin('directus_roles', 'directus_users.role', '=', 'directus_roles.id')
+                    .groupBy('directus_roles.admin_access', 'directus_roles.app_access')
+                    .first();
+                if (!existingRole) {
+                    try {
+                        const role = (await this.knex
+                            .select('admin_access', 'app_access')
+                            .from('directus_roles')
+                            .where('id', '=', key)
+                            .first()) ?? { admin_access: null, app_access: null };
+                        existingRole = { count: 0, ...role };
+                    }
+                    catch {
+                        existingRole = { count: 0, admin_access: null, app_access: null };
+                    }
+                }
+                if ('users' in data) {
+                    const users = data['users'];
+                    if (Array.isArray(users)) {
+                        increasedUsers = users.length - Number(existingRole.count);
+                        for (const user of users) {
+                            if (typeof user === 'string') {
+                                existingIds.push(user);
+                            }
+                            else if (typeof user === 'object' && 'id' in user) {
+                                existingIds.push(user['id']);
+                            }
+                        }
+                    }
+                    else {
+                        increasedUsers += users.create.length;
+                        increasedUsers -= users.delete.length;
+                        const userIds = [];
+                        for (const user of users.update) {
+                            if ('status' in user) {
+                                // account for users being activated and deactivated
+                                if (user['status'] === 'active') {
+                                    increasedUsers++;
+                                }
+                                else {
+                                    increasedUsers--;
+                                }
+                            }
+                            userIds.push(user.id);
+                        }
+                        try {
+                            const existingCounts = await getRoleCountsByUsers(this.knex, userIds);
+                            if (existingRole.admin_access) {
+                                increasedUsers += existingCounts.app + existingCounts.api;
+                            }
+                            else if (existingRole.app_access) {
+                                increasedUsers += existingCounts.admin + existingCounts.api;
+                            }
+                            else {
+                                increasedUsers += existingCounts.admin + existingCounts.app;
+                            }
+                        }
+                        catch {
+                            // ignore failed user call
+                        }
+                    }
+                }
+                let isAccessChanged = false;
+                let accessType = 'api';
+                if ('app_access' in data) {
+                    if (data['app_access'] === true) {
+                        accessType = 'app';
+                        if (!existingRole.app_access)
+                            isAccessChanged = true;
+                    }
+                    else if (existingRole.app_access) {
+                        isAccessChanged = true;
+                    }
+                }
+                else if (existingRole.app_access) {
+                    accessType = 'app';
+                }
+                if ('admin_access' in data) {
+                    if (data['admin_access'] === true) {
+                        accessType = 'admin';
+                        if (!existingRole.admin_access)
+                            isAccessChanged = true;
+                    }
+                    else if (existingRole.admin_access) {
+                        isAccessChanged = true;
+                    }
+                }
+                else if (existingRole.admin_access) {
+                    accessType = 'admin';
+                }
+                if (isAccessChanged) {
+                    increasedCounts[accessType] += Number(existingRole.count);
+                }
+                increasedCounts[accessType] += increasedUsers;
+                await checkIncreasedUserLimits(this.knex, increasedCounts, existingIds);
+            }
         }
         catch (err) {
             (opts || (opts = {})).preMutationError = err;
         }
         return super.updateOne(key, data, opts);
     }
-    async updateBatch(data, opts) {
+    async updateBatch(data, opts = {}) {
         for (const partialItem of data) {
             this.assertValidIpAccess(partialItem);
         }
         const primaryKeyField = this.schema.collections[this.collection].primary;
-        const keys = data.map((item) => item[primaryKeyField]);
-        const setsToNoAdmin = data.some((item) => item['admin_access'] === false);
+        if (!opts.mutationTracker) {
+            opts.mutationTracker = this.createMutationTracker();
+        }
+        const keys = [];
         try {
-            if (setsToNoAdmin) {
-                await this.checkForOtherAdminRoles(keys);
-            }
+            await transaction(this.knex, async (trx) => {
+                const service = new RolesService({
+                    accountability: this.accountability,
+                    knex: trx,
+                    schema: this.schema,
+                });
+                for (const item of data) {
+                    const combinedOpts = Object.assign({ autoPurgeCache: false }, opts);
+                    keys.push(await service.updateOne(item[primaryKeyField], omit(item, primaryKeyField), combinedOpts));
+                }
+            });
         }
-        catch (err) {
-            (opts || (opts = {})).preMutationError = err;
+        finally {
+            if (shouldClearCache(this.cache, opts, this.collection)) {
+                await this.cache.clear();
+            }
         }
-        return super.updateBatch(data, opts);
+        return keys;
     }
     async updateMany(keys, data, opts) {
         this.assertValidIpAccess(data);
@@ -196,6 +380,21 @@ export class RolesService extends ItemsService {
             if ('admin_access' in data && data['admin_access'] === false) {
                 await this.checkForOtherAdminRoles(keys);
             }
+            if (shouldCheckUserLimits() && ('admin_access' in data || 'app_access' in data)) {
+                const existingCounts = await getUserCountsByRoles(this.knex, keys);
+                const increasedCounts = {
+                    admin: 0,
+                    app: 0,
+                    api: 0,
+                };
+                const type = this.getRoleAccessType(data);
+                for (const [existingType, existingCount] of Object.entries(existingCounts)) {
+                    if (existingType === type)
+                        continue;
+                    increasedCounts[type] += existingCount;
+                }
+                await checkIncreasedUserLimits(this.knex, increasedCounts);
+            }
         }
         catch (err) {
             (opts || (opts = {})).preMutationError = err;

package/dist/services/users.js

@@ -1,13 +1,18 @@
 import { useEnv } from '@directus/env';
 import { ForbiddenError, InvalidPayloadError, RecordNotUniqueError, UnprocessableContentError } from '@directus/errors';
-import { getSimpleHash, toArray, validatePayload } from '@directus/utils';
+import { getSimpleHash, toArray, toBoolean, validatePayload } from '@directus/utils';
 import { FailedValidationError, joiValidationErrorItemToErrorExtensions } from '@directus/validation';
 import Joi from 'joi';
 import jwt from 'jsonwebtoken';
-import { cloneDeep, isEmpty } from 'lodash-es';
+import { cloneDeep, isEmpty, mergeWith } from 'lodash-es';
 import { performance } from 'perf_hooks';
 import getDatabase from '../database/index.js';
 import { useLogger } from '../logger.js';
+import { checkIncreasedUserLimits } from '../telemetry/utils/check-increased-user-limits.js';
+import { getRoleCountsByRoles } from '../telemetry/utils/get-role-counts-by-roles.js';
+import { getRoleCountsByUsers } from '../telemetry/utils/get-role-counts-by-users.js';
+import {} from '../telemetry/utils/get-user-count.js';
+import { shouldCheckUserLimits } from '../telemetry/utils/should-check-user-limits.js';
 import { getSecret } from '../utils/get-secret.js';
 import isUrlAllowed from '../utils/is-url-allowed.js';
 import { verifyJWT } from '../utils/jwt.js';
@@ -164,6 +169,7 @@ export class UsersService extends ItemsService {
     async createMany(data, opts) {
         const emails = data['map']((payload) => payload['email']).filter((email) => email);
         const passwords = data['map']((payload) => payload['password']).filter((password) => password);
+        const roles = data['map']((payload) => payload['role']).filter((role) => role);
         try {
             if (emails.length) {
                 this.validateEmail(emails);
@@ -172,6 +178,33 @@ export class UsersService extends ItemsService {
             if (passwords.length) {
                 await this.checkPasswordPolicy(passwords);
             }
+            if (shouldCheckUserLimits() && roles.length) {
+                const increasedCounts = {
+                    admin: 0,
+                    app: 0,
+                    api: 0,
+                };
+                const existingRoles = [];
+                for (const role of roles) {
+                    if (typeof role === 'object') {
+                        if ('admin_access' in role && role['admin_access'] === true) {
+                            increasedCounts.admin++;
+                        }
+                        else if ('app_access' in role && role['app_access'] === true) {
+                            increasedCounts.app++;
+                        }
+                        else {
+                            increasedCounts.api++;
+                        }
+                    }
+                    else {
+                        existingRoles.push(role);
+                    }
+                }
+                const existingRoleCounts = await getRoleCountsByRoles(this.knex, existingRoles);
+                mergeWith(increasedCounts, existingRoleCounts, (x, y) => x + y);
+                await checkIncreasedUserLimits(this.knex, increasedCounts);
+            }
         }
         catch (err) {
             (opts || (opts = {})).preMutationError = err;
@@ -216,6 +249,7 @@ export class UsersService extends ItemsService {
      */
     async updateMany(keys, data, opts) {
         try {
+            const needsUserLimitCheck = shouldCheckUserLimits();
             if (data['role']) {
                 /*
                  * data['role'] has the following cases:
@@ -226,7 +260,11 @@ export class UsersService extends ItemsService {
                 const role = data['role']?.id ?? data['role'];
                 let newRole;
                 if (typeof role === 'string') {
-                    newRole = await this.knex.select('admin_access').from('directus_roles').where('id', role).first();
+                    newRole = await this.knex
+                        .select('admin_access', 'app_access')
+                        .from('directus_roles')
+                        .where('id', role)
+                        .first();
                 }
                 else {
                     newRole = role;
@@ -234,10 +272,35 @@ export class UsersService extends ItemsService {
                 if (!newRole?.admin_access) {
                     await this.checkRemainingAdminExistence(keys);
                 }
+                if (needsUserLimitCheck && newRole) {
+                    const existingCounts = await getRoleCountsByUsers(this.knex, keys);
+                    const increasedCounts = {
+                        admin: 0,
+                        app: 0,
+                        api: 0,
+                    };
+                    if (toBoolean(newRole.admin_access)) {
+                        increasedCounts.admin = keys.length - existingCounts.admin;
+                    }
+                    else if (toBoolean(newRole.app_access)) {
+                        increasedCounts.app = keys.length - existingCounts.app;
+                    }
+                    else {
+                        increasedCounts.api = keys.length - existingCounts.api;
+                    }
+                    await checkIncreasedUserLimits(this.knex, increasedCounts);
+                }
+            }
+            if (needsUserLimitCheck && data['role'] === null) {
+                await checkIncreasedUserLimits(this.knex, { admin: 0, app: 0, api: 1 });
             }
             if (data['status'] !== undefined && data['status'] !== 'active') {
                 await this.checkRemainingActiveAdmin(keys);
             }
+            if (needsUserLimitCheck && data['status'] === 'active') {
+                const increasedCounts = await getRoleCountsByUsers(this.knex, keys, { inactiveUsers: true });
+                await checkIncreasedUserLimits(this.knex, increasedCounts);
+            }
             if (data['email']) {
                 if (keys.length > 1) {
                     throw new RecordNotUniqueError({

package/dist/telemetry/lib/get-report.js

@@ -1,16 +1,21 @@
 import { useEnv } from '@directus/env';
 import { version } from 'directus/version';
+import { getHelpers } from '../../database/helpers/index.js';
 import { getDatabase, getDatabaseClient } from '../../database/index.js';
+import { getExtensionCount } from '../utils/get-extension-count.js';
+import { getFieldCount } from '../utils/get-field-count.js';
 import { getItemCount } from '../utils/get-item-count.js';
 import { getUserCount } from '../utils/get-user-count.js';
 import { getUserItemCount } from '../utils/get-user-item-count.js';
-const basicCountCollections = [
-    'directus_dashboards',
-    'directus_extensions',
-    'directus_files',
-    'directus_flows',
-    'directus_roles',
-    'directus_shares',
+const basicCountTasks = [
+    { collection: 'directus_dashboards' },
+    { collection: 'directus_files' },
+    {
+        collection: 'directus_flows',
+        where: ['status', '=', 'active'],
+    },
+    { collection: 'directus_roles' },
+    { collection: 'directus_shares' },
 ];
 /**
  * Create a telemetry report about the anonymous usage of the current installation
@@ -18,17 +23,20 @@ const basicCountCollections = [
 export const getReport = async () => {
     const db = getDatabase();
     const env = useEnv();
-    const [basicCounts, userCounts, userItemCount] = await Promise.all([
-        getItemCount(db, basicCountCollections),
+    const helpers = getHelpers(db);
+    const [basicCounts, userCounts, userItemCount, fieldsCounts, extensionsCounts, databaseSize] = await Promise.all([
+        getItemCount(db, basicCountTasks),
         getUserCount(db),
         getUserItemCount(db),
+        getFieldCount(db),
+        getExtensionCount(db),
+        helpers.schema.getDatabaseSize(),
     ]);
     return {
         url: env['PUBLIC_URL'],
         version: version,
         database: getDatabaseClient(),
         dashboards: basicCounts.directus_dashboards,
-        extensions: basicCounts.directus_extensions,
         files: basicCounts.directus_files,
         flows: basicCounts.directus_flows,
         roles: basicCounts.directus_roles,
@@ -38,5 +46,9 @@ export const getReport = async () => {
         api_users: userCounts.api,
         collections: userItemCount.collections,
         items: userItemCount.items,
+        fields_max: fieldsCounts.max,
+        fields_total: fieldsCounts.total,
+        extensions: extensionsCounts.totalEnabled,
+        database_size: databaseSize ?? 0,
     };
 };

package/dist/telemetry/types/report.d.ts

@@ -55,4 +55,16 @@ export interface TelemetryReport {
      * Number of shares in the system
      */
     shares: number;
+    /**
+     * Maximum number of fields in a collection
+     */
+    fields_max: number;
+    /**
+     * Number of fields in the system
+     */
+    fields_total: number;
+    /**
+     * Size of the database in bytes
+     */
+    database_size: number;
 }

package/dist/telemetry/utils/check-increased-user-limits.d.ts

@@ -0,0 +1,7 @@
+import type { Knex } from 'knex';
+import { type AccessTypeCount } from './get-user-count.js';
+import type { PrimaryKey } from '@directus/types';
+/**
+ * Ensure that user limits are not reached
+ */
+export declare function checkIncreasedUserLimits(db: Knex, increasedUserCounts: AccessTypeCount, ignoreIds?: PrimaryKey[]): Promise<void>;

package/dist/telemetry/utils/check-increased-user-limits.js

@@ -0,0 +1,22 @@
+import { useEnv } from '@directus/env';
+import { LimitExceededError } from '@directus/errors';
+import { getUserCount } from './get-user-count.js';
+const env = useEnv();
+/**
+ * Ensure that user limits are not reached
+ */
+export async function checkIncreasedUserLimits(db, increasedUserCounts, ignoreIds = []) {
+    if (!increasedUserCounts.admin && !increasedUserCounts.app && !increasedUserCounts.api)
+        return;
+    const userCounts = await getUserCount(db, ignoreIds);
+    if (increasedUserCounts.admin > 0 &&
+        increasedUserCounts.admin + userCounts.admin > Number(env['USERS_ADMIN_ACCESS_LIMIT'])) {
+        throw new LimitExceededError({ category: 'Active Admin users' });
+    }
+    if (increasedUserCounts.app > 0 && increasedUserCounts.app + userCounts.app > Number(env['USERS_APP_ACCESS_LIMIT'])) {
+        throw new LimitExceededError({ category: 'Active App users' });
+    }
+    if (increasedUserCounts.api > 0 && increasedUserCounts.api + userCounts.api > Number(env['USERS_API_ACCESS_LIMIT'])) {
+        throw new LimitExceededError({ category: 'Active API users' });
+    }
+}

package/dist/telemetry/utils/get-extension-count.d.ts

@@ -0,0 +1,9 @@
+import { type Knex } from 'knex';
+export interface ExtensionCount {
+    /**
+     * Total count of enabled extensions excluding Bundle-Parents,
+     * meaning a Bundle extensions with one extension inside of it counts as one.
+     */
+    totalEnabled: number;
+}
+export declare const getExtensionCount: (db: Knex) => Promise<ExtensionCount>;

package/dist/telemetry/utils/get-extension-count.js

@@ -0,0 +1,19 @@
+import {} from 'knex';
+import { ExtensionsService } from '../../services/extensions.js';
+import { getSchema } from '../../utils/get-schema.js';
+export const getExtensionCount = async (db) => {
+    const extensionsService = new ExtensionsService({
+        knex: db,
+        schema: await getSchema({ database: db }),
+    });
+    const extensions = await extensionsService.readAll();
+    let totalEnabled = 0;
+    for (const extension of extensions) {
+        if (extension.meta.enabled && extension.schema && extension.schema.type !== 'bundle') {
+            totalEnabled++;
+        }
+    }
+    return {
+        totalEnabled,
+    };
+};

package/dist/telemetry/utils/get-field-count.d.ts

@@ -0,0 +1,6 @@
+import { type Knex } from 'knex';
+export interface FieldCount {
+    max: number;
+    total: number;
+}
+export declare const getFieldCount: (db: Knex) => Promise<FieldCount>;

package/dist/telemetry/utils/get-field-count.js

@@ -0,0 +1,12 @@
+import {} from 'knex';
+export const getFieldCount = async (db) => {
+    const query = (await db
+        .max({ max: 'field_count' })
+        .sum({ total: 'field_count' })
+        .from(db.select('collection').count('* as field_count').from('directus_fields').groupBy('collection').as('inner'))
+        .first());
+    return {
+        max: query?.max ? Number(query.max) : 0,
+        total: query?.total ? Number(query.total) : 0,
+    };
+};

package/dist/telemetry/utils/get-item-count.d.ts

@@ -3,13 +3,17 @@ export interface CollectionCount {
     collection: string;
     count: number;
 }
+export interface CollectionCountTask {
+    collection: string;
+    where?: readonly [string, string, string | boolean | number];
+}
 /**
- * Get the item count of the given collection in the given database
+ * Get the item count of the given task in the given database
  * @param db Knex instance to count against
- * @param collection Table to count rows in
+ * @param task Task to count rows for
  * @returns Collection name and count
  */
-export declare const countCollection: (db: Knex, collection: string) => Promise<CollectionCount>;
+export declare const countCollection: (db: Knex, task: CollectionCountTask) => Promise<CollectionCount>;
 /**
  * Merge the given collection count in the object accumulator
  * Intended for use with .reduce()
@@ -19,8 +23,8 @@ export declare const countCollection: (db: Knex, collection: string) => Promise<
  */
 export declare const mergeResults: (acc: Record<string, number>, value: CollectionCount) => Record<string, number>;
 /**
- * Get an object of item counts for the given collections
+ * Get an object of item counts for the given tasks
  * @param db Database instance to get counts in
- * @param collections Array of table names to get count from
+ * @param tasks Array of tasks to get count for
  */
-export declare const getItemCount: <T extends readonly string[]>(db: Knex, collections: T) => Promise<Record<T[number], number>>;
+export declare const getItemCount: <T extends readonly CollectionCountTask[]>(db: Knex, tasks: T) => Promise<Record<T[number]["collection"], number>>;

package/dist/telemetry/utils/get-item-count.js

@@ -1,14 +1,18 @@
 import {} from 'knex';
 import pLimit from 'p-limit';
 /**
- * Get the item count of the given collection in the given database
+ * Get the item count of the given task in the given database
  * @param db Knex instance to count against
- * @param collection Table to count rows in
+ * @param task Task to count rows for
  * @returns Collection name and count
  */
-export const countCollection = async (db, collection) => {
-    const count = await db.count('*', { as: 'count' }).from(collection).first();
-    return { collection, count: Number(count?.['count'] ?? 0) };
+export const countCollection = async (db, task) => {
+    const query = db.count('*', { as: 'count' }).from(task.collection);
+    if (task.where) {
+        query.where(...task.where);
+    }
+    const count = await query.first();
+    return { collection: task.collection, count: Number(count?.['count'] ?? 0) };
 };
 /**
  * Merge the given collection count in the object accumulator
@@ -22,15 +26,15 @@ export const mergeResults = (acc, value) => {
     return acc;
 };
 /**
- * Get an object of item counts for the given collections
+ * Get an object of item counts for the given tasks
  * @param db Database instance to get counts in
- * @param collections Array of table names to get count from
+ * @param tasks Array of tasks to get count for
  */
-export const getItemCount = async (db, collections) => {
+export const getItemCount = async (db, tasks) => {
     // Counts can be a little heavy if the table is very large, so we'll only ever execute 3 of these
     // queries simultaneously to not overload the database
     const limit = pLimit(3);
-    const calls = collections.map((collection) => limit(countCollection, db, collection));
+    const calls = tasks.map((task) => limit(countCollection, db, task));
     const results = await Promise.all(calls);
     return results.reduce(mergeResults, {});
 };

package/dist/telemetry/utils/get-role-counts-by-roles.d.ts

@@ -0,0 +1,6 @@
+import type { Knex } from 'knex';
+import { type AccessTypeCount } from './get-user-count.js';
+/**
+ * Get the role type counts by role IDs
+ */
+export declare function getRoleCountsByRoles(db: Knex, roles: string[]): Promise<AccessTypeCount>;

package/dist/telemetry/utils/get-role-counts-by-roles.js

@@ -0,0 +1,27 @@
+import { toBoolean } from '@directus/utils';
+import {} from './get-user-count.js';
+/**
+ * Get the role type counts by role IDs
+ */
+export async function getRoleCountsByRoles(db, roles) {
+    const counts = {
+        admin: 0,
+        app: 0,
+        api: 0,
+    };
+    const result = (await db.select('id', 'admin_access', 'app_access').from('directus_roles').whereIn('id', roles));
+    for (const role of result) {
+        const adminAccess = toBoolean(role.admin_access);
+        const appAccess = toBoolean(role.app_access);
+        if (adminAccess) {
+            counts.admin++;
+        }
+        else if (appAccess) {
+            counts.app++;
+        }
+        else {
+            counts.api++;
+        }
+    }
+    return counts;
+}

package/dist/telemetry/utils/get-role-counts-by-users.d.ts

@@ -0,0 +1,11 @@
+import type { PrimaryKey } from '@directus/types';
+import type { Knex } from 'knex';
+import type { AccessTypeCount } from './get-user-count.js';
+type CountOptions = {
+    inactiveUsers?: boolean;
+};
+/**
+ * Get the role type counts by user IDs
+ */
+export declare function getRoleCountsByUsers(db: Knex, userIds: PrimaryKey[], options?: CountOptions): Promise<AccessTypeCount>;
+export {};

package/dist/telemetry/utils/get-role-counts-by-users.js

@@ -0,0 +1,34 @@
+import { toBoolean } from '@directus/utils';
+/**
+ * Get the role type counts by user IDs
+ */
+export async function getRoleCountsByUsers(db, userIds, options = {}) {
+    const counts = {
+        admin: 0,
+        app: 0,
+        api: 0,
+    };
+    const result = await db
+        .count('directus_users.id', { as: 'count' })
+        .select('directus_roles.admin_access', 'directus_roles.app_access')
+        .from('directus_users')
+        .whereIn('directus_users.id', userIds)
+        .andWhere('directus_users.status', options.inactiveUsers ? '!=' : '=', 'active')
+        .leftJoin('directus_roles', 'directus_users.role', '=', 'directus_roles.id')
+        .groupBy('directus_roles.admin_access', 'directus_roles.app_access');
+    for (const record of result) {
+        const adminAccess = toBoolean(record.admin_access);
+        const appAccess = toBoolean(record.app_access);
+        const count = Number(record.count);
+        if (adminAccess) {
+            counts.admin += count;
+        }
+        else if (appAccess) {
+            counts.app += count;
+        }
+        else {
+            counts.api += count;
+        }
+    }
+    return counts;
+}

package/dist/telemetry/utils/get-user-count.d.ts

@@ -1,7 +1,8 @@
+import type { PrimaryKey } from '@directus/types';
 import { type Knex } from 'knex';
-export interface UserCount {
+export interface AccessTypeCount {
     admin: number;
     app: number;
     api: number;
 }
-export declare const getUserCount: (db: Knex) => Promise<UserCount>;
+export declare const getUserCount: (db: Knex, ignoreIds?: PrimaryKey[]) => Promise<AccessTypeCount>;

package/dist/telemetry/utils/get-user-count.js

@@ -1,6 +1,6 @@
 import { toBoolean } from '@directus/utils';
 import {} from 'knex';
-export const getUserCount = async (db) => {
+export const getUserCount = async (db, ignoreIds = []) => {
     const counts = {
         admin: 0,
         app: 0,
@@ -10,20 +10,23 @@ export const getUserCount = async (db) => {
         .count('directus_users.id', { as: 'count' })
         .select('directus_roles.admin_access', 'directus_roles.app_access')
         .from('directus_users')
+        .whereNotIn('directus_users.id', ignoreIds)
+        .andWhere('directus_users.status', 'active')
         .leftJoin('directus_roles', 'directus_users.role', '=', 'directus_roles.id')
+        .where('directus_users.status', '=', 'active')
         .groupBy('directus_roles.admin_access', 'directus_roles.app_access'));
     for (const record of result) {
         const adminAccess = toBoolean(record.admin_access);
         const appAccess = toBoolean(record.app_access);
         const count = Number(record.count);
         if (adminAccess) {
-            counts.admin = count;
+            counts.admin += count;
         }
         else if (appAccess) {
-            counts.app = count;
+            counts.app += count;
         }
         else {
-            counts.api = count;
+            counts.api += count;
         }
     }
     return counts;

package/dist/telemetry/utils/get-user-counts-by-roles.d.ts

@@ -0,0 +1,7 @@
+import type { PrimaryKey } from '@directus/types';
+import type { Knex } from 'knex';
+import { type AccessTypeCount } from './get-user-count.js';
+/**
+ * Get the user type counts by role IDs
+ */
+export declare function getUserCountsByRoles(db: Knex, roleIds: PrimaryKey[]): Promise<AccessTypeCount>;

package/dist/telemetry/utils/get-user-counts-by-roles.js

@@ -0,0 +1,35 @@
+import { toBoolean } from '@directus/utils';
+import {} from './get-user-count.js';
+/**
+ * Get the user type counts by role IDs
+ */
+export async function getUserCountsByRoles(db, roleIds) {
+    const counts = {
+        admin: 0,
+        app: 0,
+        api: 0,
+    };
+    const result = (await db
+        .count('directus_users.id', { as: 'count' })
+        .select('directus_roles.admin_access', 'directus_roles.app_access')
+        .from('directus_users')
+        .whereIn('directus_roles.id', roleIds)
+        .andWhere('directus_users.status', '=', 'active')
+        .leftJoin('directus_roles', 'directus_users.role', '=', 'directus_roles.id')
+        .groupBy('directus_roles.admin_access', 'directus_roles.app_access'));
+    for (const record of result) {
+        const adminAccess = toBoolean(record.admin_access);
+        const appAccess = toBoolean(record.app_access);
+        const count = Number(record.count);
+        if (adminAccess) {
+            counts.admin += count;
+        }
+        else if (appAccess) {
+            counts.app += count;
+        }
+        else {
+            counts.api += count;
+        }
+    }
+    return counts;
+}

package/dist/telemetry/utils/get-user-item-count.js

@@ -1,7 +1,7 @@
+import { isSystemCollection } from '@directus/system-data';
 import {} from 'knex';
 import { getSchema } from '../../utils/get-schema.js';
 import { getItemCount } from './get-item-count.js';
-import { isSystemCollection } from '@directus/system-data';
 /**
  * Sum all passed values together. Meant to be used with .reduce()
  */
@@ -11,7 +11,9 @@ export const sum = (acc, val) => (acc += val);
  */
 export const getUserItemCount = async (db) => {
     const schema = await getSchema({ database: db });
-    const userCollections = Object.keys(schema.collections).filter((collection) => isSystemCollection(collection) === false);
+    const userCollections = Object.keys(schema.collections)
+        .filter((collection) => isSystemCollection(collection) === false)
+        .map((collection) => ({ collection }));
     const counts = await getItemCount(db, userCollections);
     const collections = userCollections.length;
     const items = Object.values(counts).reduce(sum, 0);

package/dist/telemetry/utils/should-check-user-limits.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Confirm whether user limits needs to be checked
+ */
+export declare function shouldCheckUserLimits(): boolean;

package/dist/telemetry/utils/should-check-user-limits.js

@@ -0,0 +1,13 @@
+import { useEnv } from '@directus/env';
+/**
+ * Confirm whether user limits needs to be checked
+ */
+export function shouldCheckUserLimits() {
+    const env = useEnv();
+    if (Number(env['USERS_ADMIN_ACCESS_LIMIT']) !== Infinity ||
+        Number(env['USERS_APP_ACCESS_LIMIT']) !== Infinity ||
+        Number(env['USERS_API_ACCESS_LIMIT']) !== Infinity) {
+        return true;
+    }
+    return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@directus/api",
-  "version": "19.2.0",
+  "version": "19.3.1",
   "description": "Directus is a real-time API and App dashboard for managing SQL database content",
   "keywords": [
     "directus",
@@ -65,7 +65,7 @@
     "@rollup/plugin-node-resolve": "15.2.3",
     "@rollup/plugin-virtual": "3.0.2",
     "@types/cookie": "0.6.0",
-    "argon2": "0.40.1",
+    "argon2": "0.40.3",
     "async": "3.2.5",
     "axios": "1.7.2",
     "busboy": "1.6.0",
@@ -96,7 +96,7 @@
     "graphql-ws": "5.16.0",
     "helmet": "7.1.0",
     "icc": "3.0.0",
-    "inquirer": "9.2.22",
+    "inquirer": "9.2.23",
     "ioredis": "5.4.1",
     "ip-matching": "2.1.2",
     "isolated-vm": "4.7.2",
@@ -108,7 +108,7 @@
     "keyv": "4.5.4",
     "knex": "3.1.0",
     "ldapjs": "2.3.3",
-    "liquidjs": "10.12.0",
+    "liquidjs": "10.13.1",
     "lodash-es": "4.17.21",
     "marked": "12.0.2",
     "micromustache": "8.0.3",
@@ -121,14 +121,14 @@
     "node-schedule": "2.1.1",
     "nodemailer": "6.9.13",
     "object-hash": "3.0.0",
-    "openapi3-ts": "4.3.1",
+    "openapi3-ts": "4.3.2",
     "openid-client": "5.6.5",
     "ora": "8.0.1",
     "otplib": "12.0.1",
     "p-limit": "5.0.0",
     "p-queue": "8.0.1",
     "papaparse": "5.4.1",
-    "pino": "9.0.0",
+    "pino": "9.1.0",
     "pino-http": "9.0.0",
     "pino-http-print": "3.1.0",
     "pino-pretty": "11.0.0",
@@ -140,35 +140,35 @@
     "sharp": "0.33.3",
     "snappy": "7.2.2",
     "stream-json": "1.8.0",
-    "tar": "7.1.0",
-    "tsx": "4.9.3",
+    "tar": "7.2.0",
+    "tsx": "4.12.0",
     "wellknown": "0.5.0",
     "ws": "8.17.0",
     "zod": "3.23.8",
     "zod-validation-error": "3.2.0",
-    "@directus/app": "12.1.2",
     "@directus/constants": "11.0.4",
-    "@directus/env": "1.1.5",
-    "@directus/errors": "0.3.1",
-    "@directus/extensions": "1.0.6",
-    "@directus/extensions-registry": "1.0.6",
-    "@directus/extensions-sdk": "11.0.6",
-    "@directus/memory": "1.0.8",
-    "@directus/pressure": "1.0.19",
-    "@directus/schema": "11.0.2",
-    "@directus/specs": "10.2.9",
+    "@directus/app": "12.1.4",
+    "@directus/env": "1.1.6",
+    "@directus/extensions": "1.0.8",
+    "@directus/errors": "0.3.2",
+    "@directus/extensions-registry": "1.0.8",
+    "@directus/extensions-sdk": "11.0.8",
     "@directus/format-title": "10.1.2",
+    "@directus/pressure": "1.0.20",
+    "@directus/memory": "1.0.9",
+    "@directus/schema": "11.0.3",
+    "@directus/specs": "10.2.10",
     "@directus/storage": "10.0.13",
-    "@directus/storage-driver-cloudinary": "10.0.21",
-    "@directus/storage-driver-azure": "10.0.21",
-    "@directus/storage-driver-gcs": "10.0.22",
+    "@directus/storage-driver-azure": "10.0.22",
+    "@directus/storage-driver-gcs": "10.0.23",
     "@directus/storage-driver-local": "10.0.20",
-    "@directus/storage-driver-supabase": "1.0.13",
-    "@directus/system-data": "1.0.3",
-    "@directus/storage-driver-s3": "10.0.22",
-    "@directus/utils": "11.0.8",
-    "directus": "10.11.2",
-    "@directus/validation": "0.0.16"
+    "@directus/storage-driver-cloudinary": "10.0.22",
+    "@directus/storage-driver-s3": "10.0.23",
+    "@directus/storage-driver-supabase": "1.0.14",
+    "@directus/system-data": "1.0.4",
+    "@directus/utils": "11.0.9",
+    "@directus/validation": "0.0.17",
+    "directus": "10.12.1"
   },
   "devDependencies": {
     "@ngneat/falso": "7.2.0",
@@ -182,7 +182,7 @@
     "@types/destroy": "1.0.3",
     "@types/encodeurl": "1.0.2",
     "@types/express": "4.17.21",
-    "@types/express-serve-static-core": "4.19.0",
+    "@types/express-serve-static-core": "4.19.3",
     "@types/fs-extra": "11.0.4",
     "@types/glob-to-regexp": "0.4.4",
     "@types/inquirer": "9.0.7",
@@ -210,8 +210,8 @@
     "typescript": "5.4.5",
     "vitest": "1.5.3",
     "@directus/random": "0.2.8",
-    "@directus/types": "11.1.2",
-    "@directus/tsconfig": "1.0.1"
+    "@directus/tsconfig": "1.0.1",
+    "@directus/types": "11.1.3"
   },
   "optionalDependencies": {
     "@keyv/redis": "2.8.4",