@directus/api 19.1.1 → 19.3.0

package/dist/services/roles.js

@@ -1,10 +1,16 @@
-import { ForbiddenError, InvalidPayloadError, UnprocessableContentError } from '@directus/errors';
+import { InvalidPayloadError, UnprocessableContentError } from '@directus/errors';
 import { getMatch } from 'ip-matching';
+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 { transaction } from '../utils/transaction.js';
 import { ItemsService } from './items.js';
 import { PermissionsService } from './permissions/index.js';
 import { PresetsService } from './presets.js';
 import { UsersService } from './users.js';
+import { shouldClearCache } from '../utils/should-clear-cache.js';
+import { omit } from 'lodash-es';
 export class RolesService extends ItemsService {
     constructor(options) {
         super('directus_roles', options);
@@ -24,8 +30,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,44 +158,211 @@ 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);
+        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 increasedCounts = {
+            admin: 0,
+            app: 0,
+            api: 0,
+        };
+        const existingIds = [];
         for (const partialItem of data) {
             this.assertValidIpAccess(partialItem);
+            if ('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']);
+                    }
+                }
+            }
         }
+        await checkIncreasedUserLimits(this.knex, increasedCounts, existingIds);
         return super.createMany(data, opts);
     }
     async updateOne(key, data, opts) {
         this.assertValidIpAccess(data);
         try {
+            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) {
                 await this.checkForOtherAdminUsers(key, data['users']);
+                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 +370,21 @@ export class RolesService extends ItemsService {
             if ('admin_access' in data && data['admin_access'] === false) {
                 await this.checkForOtherAdminRoles(keys);
             }
+            if ('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.d.ts

@@ -23,7 +23,7 @@ export declare class UsersService extends ItemsService {
      */
     private getUserByEmail;
     /**
-     * Create url for inviting users
+     * Create URL for inviting users
      */
     private inviteUrl;
     /**

package/dist/services/users.js

@@ -1,13 +1,17 @@
 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 { getSecret } from '../utils/get-secret.js';
 import isUrlAllowed from '../utils/is-url-allowed.js';
 import { verifyJWT } from '../utils/jwt.js';
@@ -126,14 +130,14 @@ export class UsersService extends ItemsService {
             .first();
     }
     /**
-     * Create url for inviting users
+     * Create URL for inviting users
      */
     inviteUrl(email, url) {
         const payload = { email, scope: 'invite' };
         const token = jwt.sign(payload, getSecret(), { expiresIn: '7d', issuer: 'directus' });
-        const inviteURL = url ? new Url(url) : new Url(env['PUBLIC_URL']).addPath('admin', 'accept-invite');
-        inviteURL.setQuery('token', token);
-        return inviteURL.toString();
+        return (url ? new Url(url) : new Url(env['PUBLIC_URL']).addPath('admin', 'accept-invite'))
+            .setQuery('token', token)
+            .toString();
     }
     /**
      * Validate array of emails. Intended to be used with create/update users
@@ -164,6 +168,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 +177,33 @@ export class UsersService extends ItemsService {
             if (passwords.length) {
                 await this.checkPasswordPolicy(passwords);
             }
+            if (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;
@@ -226,7 +258,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 +270,35 @@ export class UsersService extends ItemsService {
                 if (!newRole?.admin_access) {
                     await this.checkRemainingAdminExistence(keys);
                 }
+                if (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 (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 (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({
@@ -314,7 +375,7 @@ export class UsersService extends ItemsService {
         const opts = {};
         try {
             if (url && isUrlAllowed(url, env['USER_INVITE_URL_ALLOW_LIST']) === false) {
-                throw new InvalidPayloadError({ reason: `Url "${url}" can't be used to invite users` });
+                throw new InvalidPayloadError({ reason: `URL "${url}" can't be used to invite users` });
             }
         }
         catch (err) {
@@ -373,6 +434,12 @@ export class UsersService extends ItemsService {
         await service.updateOne(user.id, { password, status: 'active' });
     }
     async registerUser(input) {
+        if (input.verification_url &&
+            isUrlAllowed(input.verification_url, env['USER_REGISTER_URL_ALLOW_LIST']) === false) {
+            throw new InvalidPayloadError({
+                reason: `URL "${input.verification_url}" can't be used to verify registered users`,
+            });
+        }
         const STALL_TIME = env['REGISTER_STALL_TIME'];
         const timeStart = performance.now();
         const serviceOptions = { accountability: this.accountability, schema: this.schema };
@@ -424,9 +491,11 @@ export class UsersService extends ItemsService {
                 expiresIn: env['EMAIL_VERIFICATION_TOKEN_TTL'],
                 issuer: 'directus',
             });
-            const verificationURL = new Url(env['PUBLIC_URL'])
-                .addPath('users', 'register', 'verify-email')
-                .setQuery('token', token);
+            const verificationUrl = (input.verification_url
+                ? new Url(input.verification_url)
+                : new Url(env['PUBLIC_URL']).addPath('users', 'register', 'verify-email'))
+                .setQuery('token', token)
+                .toString();
             mailService
                 .send({
                 to: input.email,
@@ -434,7 +503,7 @@ export class UsersService extends ItemsService {
                 template: {
                     name: 'user-registration',
                     data: {
-                        url: verificationURL.toString(),
+                        url: verificationUrl,
                         email: input.email,
                         first_name,
                         last_name,
@@ -467,7 +536,7 @@ export class UsersService extends ItemsService {
             throw new ForbiddenError();
         }
         if (url && isUrlAllowed(url, env['PASSWORD_RESET_URL_ALLOW_LIST']) === false) {
-            throw new InvalidPayloadError({ reason: `Url "${url}" can't be used to reset passwords` });
+            throw new InvalidPayloadError({ reason: `URL "${url}" can't be used to reset passwords` });
         }
         const mailService = new MailService({
             schema: this.schema,
@@ -476,9 +545,9 @@ export class UsersService extends ItemsService {
         });
         const payload = { email: user.email, scope: 'password-reset', hash: getSimpleHash('' + user.password) };
         const token = jwt.sign(payload, getSecret(), { expiresIn: '1d', issuer: 'directus' });
-        const acceptURL = url
-            ? new Url(url).setQuery('token', token).toString()
-            : new Url(env['PUBLIC_URL']).addPath('admin', 'reset-password').setQuery('token', token).toString();
+        const acceptUrl = (url ? new Url(url) : new Url(env['PUBLIC_URL']).addPath('admin', 'reset-password'))
+            .setQuery('token', token)
+            .toString();
         const subjectLine = subject ? subject : 'Password Reset Request';
         mailService
             .send({
@@ -487,7 +556,7 @@ export class UsersService extends ItemsService {
             template: {
                 name: 'password-reset',
                 data: {
-                    url: acceptURL,
+                    url: acceptUrl,
                     email: user.email,
                 },
             },

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,
+    };
+};