directus 9.22.4 → 9.23.3

package/dist/services/relations.js

@@ -27,19 +27,27 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RelationsService = void 0;
-const relations_1 = require("../database/system-data/relations");
-const exceptions_1 = require("../exceptions");
-const utils_1 = require("@directus/shared/utils");
-const items_1 = require("./items");
-const permissions_1 = require("./permissions");
 const schema_1 = __importDefault(require("@directus/schema"));
-const database_1 = __importStar(require("../database"));
-const get_default_index_name_1 = require("../utils/get-default-index-name");
+const utils_1 = require("@directus/shared/utils");
 const cache_1 = require("../cache");
+const database_1 = __importStar(require("../database"));
 const helpers_1 = require("../database/helpers");
+const relations_1 = require("../database/system-data/relations");
 const emitter_1 = __importDefault(require("../emitter"));
+const exceptions_1 = require("../exceptions");
+const get_default_index_name_1 = require("../utils/get-default-index-name");
 const get_schema_1 = require("../utils/get-schema");
+const items_1 = require("./items");
+const permissions_1 = require("./permissions");
 class RelationsService {
+    knex;
+    permissionsService;
+    schemaInspector;
+    accountability;
+    schema;
+    relationsItemService;
+    systemCache;
+    helpers;
     constructor(options) {
         this.knex = options.knex || (0, database_1.default)();
         this.permissionsService = new permissions_1.PermissionsService(options);
@@ -83,12 +91,11 @@ class RelationsService {
         return await this.filterForbidden(results);
     }
     async readOne(collection, field) {
-        var _a;
         if (this.accountability && this.accountability.admin !== true) {
             if (this.hasReadAccess === false) {
                 throw new exceptions_1.ForbiddenException();
             }
-            const permissions = (_a = this.accountability.permissions) === null || _a === void 0 ? void 0 : _a.find((permission) => {
+            const permissions = this.accountability.permissions?.find((permission) => {
                 return permission.action === 'read' && permission.collection === collection;
             });
             if (!permissions || !permissions.fields)
@@ -155,6 +162,7 @@ class RelationsService {
             throw new exceptions_1.InvalidPayloadException(`Field "${relation.field}" in collection "${relation.collection}" already has an associated relationship`);
         }
         const runPostColumnChange = await this.helpers.schema.preColumnChange();
+        this.helpers.schema.preRelationChange(relation);
         const nestedActionEvents = [];
         try {
             const metaRow = {
@@ -166,13 +174,12 @@ class RelationsService {
             await this.knex.transaction(async (trx) => {
                 if (relation.related_collection) {
                     await trx.schema.alterTable(relation.collection, async (table) => {
-                        var _a;
                         this.alterType(table, relation);
                         const constraintName = (0, get_default_index_name_1.getDefaultIndexName)('foreign', relation.collection, relation.field);
                         const builder = table
                             .foreign(relation.field, constraintName)
                             .references(`${relation.related_collection}.${this.schema.collections[relation.related_collection].primary}`);
-                        if ((_a = relation.schema) === null || _a === void 0 ? void 0 : _a.on_delete) {
+                        if (relation.schema?.on_delete) {
                             builder.onDelete(relation.schema.on_delete);
                         }
                     });
@@ -185,7 +192,7 @@ class RelationsService {
                     // happens in `filterForbidden` down below
                 });
                 await relationsItemService.createOne(metaRow, {
-                    bypassEmitAction: (params) => (opts === null || opts === void 0 ? void 0 : opts.bypassEmitAction) ? opts.bypassEmitAction(params) : nestedActionEvents.push(params),
+                    bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params),
                 });
             });
         }
@@ -193,10 +200,10 @@ class RelationsService {
             if (runPostColumnChange) {
                 await this.helpers.schema.postColumnChange();
             }
-            if ((opts === null || opts === void 0 ? void 0 : opts.autoPurgeSystemCache) !== false) {
-                await (0, cache_1.clearSystemCache)();
+            if (opts?.autoPurgeSystemCache !== false) {
+                await (0, cache_1.clearSystemCache)({ autoPurgeCache: opts?.autoPurgeCache });
             }
-            if ((opts === null || opts === void 0 ? void 0 : opts.emitEvents) !== false && nestedActionEvents.length > 0) {
+            if (opts?.emitEvents !== false && nestedActionEvents.length > 0) {
                 const updatedSchema = await (0, get_schema_1.getSchema)();
                 for (const nestedActionEvent of nestedActionEvents) {
                     nestedActionEvent.context.schema = updatedSchema;
@@ -225,15 +232,15 @@ class RelationsService {
             throw new exceptions_1.InvalidPayloadException(`Field "${field}" in collection "${collection}" doesn't have a relationship.`);
         }
         const runPostColumnChange = await this.helpers.schema.preColumnChange();
+        this.helpers.schema.preRelationChange(relation);
         const nestedActionEvents = [];
         try {
             await this.knex.transaction(async (trx) => {
                 if (existingRelation.related_collection) {
                     await trx.schema.alterTable(collection, async (table) => {
-                        var _a;
                         let constraintName = (0, get_default_index_name_1.getDefaultIndexName)('foreign', collection, field);
                         // If the FK already exists in the DB, drop it first
-                        if (existingRelation === null || existingRelation === void 0 ? void 0 : existingRelation.schema) {
+                        if (existingRelation?.schema) {
                             constraintName = existingRelation.schema.constraint_name || constraintName;
                             table.dropForeign(field, constraintName);
                             constraintName = this.helpers.schema.constraintName(constraintName);
@@ -243,7 +250,7 @@ class RelationsService {
                         const builder = table
                             .foreign(field, constraintName || undefined)
                             .references(`${existingRelation.related_collection}.${this.schema.collections[existingRelation.related_collection].primary}`);
-                        if ((_a = relation.schema) === null || _a === void 0 ? void 0 : _a.on_delete) {
+                        if (relation.schema?.on_delete) {
                             builder.onDelete(relation.schema.on_delete);
                         }
                     });
@@ -256,9 +263,9 @@ class RelationsService {
                     // happens in `filterForbidden` down below
                 });
                 if (relation.meta) {
-                    if (existingRelation === null || existingRelation === void 0 ? void 0 : existingRelation.meta) {
+                    if (existingRelation?.meta) {
                         await relationsItemService.updateOne(existingRelation.meta.id, relation.meta, {
-                            bypassEmitAction: (params) => (opts === null || opts === void 0 ? void 0 : opts.bypassEmitAction) ? opts.bypassEmitAction(params) : nestedActionEvents.push(params),
+                            bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params),
                         });
                     }
                     else {
@@ -268,7 +275,7 @@ class RelationsService {
                             many_field: relation.field,
                             one_collection: existingRelation.related_collection || null,
                         }, {
-                            bypassEmitAction: (params) => (opts === null || opts === void 0 ? void 0 : opts.bypassEmitAction) ? opts.bypassEmitAction(params) : nestedActionEvents.push(params),
+                            bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params),
                         });
                     }
                 }
@@ -278,10 +285,10 @@ class RelationsService {
             if (runPostColumnChange) {
                 await this.helpers.schema.postColumnChange();
             }
-            if ((opts === null || opts === void 0 ? void 0 : opts.autoPurgeSystemCache) !== false) {
-                await (0, cache_1.clearSystemCache)();
+            if (opts?.autoPurgeSystemCache !== false) {
+                await (0, cache_1.clearSystemCache)({ autoPurgeCache: opts?.autoPurgeCache });
             }
-            if ((opts === null || opts === void 0 ? void 0 : opts.emitEvents) !== false && nestedActionEvents.length > 0) {
+            if (opts?.emitEvents !== false && nestedActionEvents.length > 0) {
                 const updatedSchema = await (0, get_schema_1.getSchema)();
                 for (const nestedActionEvent of nestedActionEvents) {
                     nestedActionEvent.context.schema = updatedSchema;
@@ -311,10 +318,9 @@ class RelationsService {
         const nestedActionEvents = [];
         try {
             await this.knex.transaction(async (trx) => {
-                var _a;
                 const existingConstraints = await this.schemaInspector.foreignKeys();
                 const constraintNames = existingConstraints.map((key) => key.constraint_name);
-                if (((_a = existingRelation.schema) === null || _a === void 0 ? void 0 : _a.constraint_name) &&
+                if (existingRelation.schema?.constraint_name &&
                     constraintNames.includes(existingRelation.schema.constraint_name)) {
                     await trx.schema.alterTable(existingRelation.collection, (table) => {
                         table.dropForeign(existingRelation.field, existingRelation.schema.constraint_name);
@@ -335,7 +341,7 @@ class RelationsService {
                         accountability: this.accountability,
                     },
                 };
-                if (opts === null || opts === void 0 ? void 0 : opts.bypassEmitAction) {
+                if (opts?.bypassEmitAction) {
                     opts.bypassEmitAction(actionEvent);
                 }
                 else {
@@ -347,10 +353,10 @@ class RelationsService {
             if (runPostColumnChange) {
                 await this.helpers.schema.postColumnChange();
             }
-            if ((opts === null || opts === void 0 ? void 0 : opts.autoPurgeSystemCache) !== false) {
-                await (0, cache_1.clearSystemCache)();
+            if (opts?.autoPurgeSystemCache !== false) {
+                await (0, cache_1.clearSystemCache)({ autoPurgeCache: opts?.autoPurgeCache });
             }
-            if ((opts === null || opts === void 0 ? void 0 : opts.emitEvents) !== false && nestedActionEvents.length > 0) {
+            if (opts?.emitEvents !== false && nestedActionEvents.length > 0) {
                 const updatedSchema = await (0, get_schema_1.getSchema)();
                 for (const nestedActionEvent of nestedActionEvents) {
                     nestedActionEvent.context.schema = updatedSchema;
@@ -363,10 +369,9 @@ class RelationsService {
      * Whether or not the current user has read access to relations
      */
     get hasReadAccess() {
-        var _a, _b;
-        return !!((_b = (_a = this.accountability) === null || _a === void 0 ? void 0 : _a.permissions) === null || _b === void 0 ? void 0 : _b.find((permission) => {
+        return !!this.accountability?.permissions?.find((permission) => {
             return permission.collection === 'directus_relations' && permission.action === 'read';
-        }));
+        });
     }
     /**
      * Combine raw schema foreign key information with Directus relations meta rows to form final
@@ -398,11 +403,10 @@ class RelationsService {
             return !results.find((relation) => relation.meta === meta);
         })
             .map((meta) => {
-            var _a;
             return {
                 collection: meta.many_collection,
                 field: meta.many_field,
-                related_collection: (_a = meta.one_collection) !== null && _a !== void 0 ? _a : null,
+                related_collection: meta.one_collection ?? null,
                 schema: null,
                 meta: meta,
             };
@@ -415,16 +419,16 @@ class RelationsService {
      * permissions to
      */
     async filterForbidden(relations) {
-        var _a, _b, _c;
-        if (this.accountability === null || ((_a = this.accountability) === null || _a === void 0 ? void 0 : _a.admin) === true)
+        if (this.accountability === null || this.accountability?.admin === true)
             return relations;
-        const allowedCollections = (_c = (_b = this.accountability.permissions) === null || _b === void 0 ? void 0 : _b.filter((permission) => {
+        const allowedCollections = this.accountability.permissions
+            ?.filter((permission) => {
             return permission.action === 'read';
-        }).map(({ collection }) => collection)) !== null && _c !== void 0 ? _c : [];
+        })
+            .map(({ collection }) => collection) ?? [];
         const allowedFields = this.permissionsService.getAllowedFields('read');
         relations = (0, utils_1.toArray)(relations);
         return relations.filter((relation) => {
-            var _a, _b, _c;
             let collectionsAllowed = true;
             let fieldsAllowed = true;
             if (allowedCollections.includes(relation.collection) === false) {
@@ -433,8 +437,8 @@ class RelationsService {
             if (relation.related_collection && allowedCollections.includes(relation.related_collection) === false) {
                 collectionsAllowed = false;
             }
-            if (((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_allowed_collections) &&
-                ((_b = relation.meta) === null || _b === void 0 ? void 0 : _b.one_allowed_collections.every((collection) => allowedCollections.includes(collection))) === false) {
+            if (relation.meta?.one_allowed_collections &&
+                relation.meta?.one_allowed_collections.every((collection) => allowedCollections.includes(collection)) === false) {
                 collectionsAllowed = false;
             }
             if (!allowedFields[relation.collection] ||
@@ -443,7 +447,7 @@ class RelationsService {
                 fieldsAllowed = false;
             }
             if (relation.related_collection &&
-                ((_c = relation.meta) === null || _c === void 0 ? void 0 : _c.one_field) &&
+                relation.meta?.one_field &&
                 (!allowedFields[relation.related_collection] ||
                     (allowedFields[relation.related_collection].includes('*') === false &&
                         allowedFields[relation.related_collection].includes(relation.meta.one_field) === false))) {

package/dist/services/revisions.d.ts

@@ -1,4 +1,4 @@
-import { AbstractServiceOptions, PrimaryKey } from '../types';
+import type { AbstractServiceOptions, PrimaryKey } from '../types';
 import { ItemsService } from './index';
 export declare class RevisionsService extends ItemsService {
     constructor(options: AbstractServiceOptions);

package/dist/services/roles.d.ts

@@ -1,5 +1,5 @@
-import { AbstractServiceOptions, MutationOptions, PrimaryKey } from '../types';
-import { Query } from '@directus/shared/types';
+import type { Query } from '@directus/shared/types';
+import type { AbstractServiceOptions, MutationOptions, PrimaryKey } from '../types';
 import { ItemsService } from './items';
 export declare class RolesService extends ItemsService {
     constructor(options: AbstractServiceOptions);

package/dist/services/roles.js

@@ -18,7 +18,7 @@ class RolesService extends items_1.ItemsService {
             .whereNotIn('id', excludeKeys)
             .andWhere({ admin_access: true })
             .first();
-        const otherAdminRolesCount = +((otherAdminRoles === null || otherAdminRoles === void 0 ? void 0 : otherAdminRoles.count) || 0);
+        const otherAdminRolesCount = +(otherAdminRoles?.count || 0);
         if (otherAdminRolesCount === 0)
             throw new exceptions_1.UnprocessableEntityException(`You can't delete the last admin role.`);
     }
@@ -49,15 +49,20 @@ class RolesService extends items_1.ItemsService {
             .andWhere({ 'directus_roles.admin_access': true })
             .leftJoin('directus_roles', 'directus_users.role', 'directus_roles.id')
             .first();
-        const otherAdminUsersCount = +((otherAdminUsers === null || otherAdminUsers === void 0 ? void 0 : otherAdminUsers.count) || 0);
+        const otherAdminUsersCount = +(otherAdminUsers?.count || 0);
         if (otherAdminUsersCount === 0) {
             throw new exceptions_1.UnprocessableEntityException(`You can't remove the last admin user from the admin role.`);
         }
         return;
     }
     async updateOne(key, data, opts) {
-        if ('users' in data) {
-            await this.checkForOtherAdminUsers(key, data.users);
+        try {
+            if ('users' in data) {
+                await this.checkForOtherAdminUsers(key, data.users);
+            }
+        }
+        catch (err) {
+            (opts || (opts = {})).preMutationException = err;
         }
         return super.updateOne(key, data, opts);
     }
@@ -65,14 +70,24 @@ class RolesService extends items_1.ItemsService {
         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 (setsToNoAdmin) {
-            await this.checkForOtherAdminRoles(keys);
+        try {
+            if (setsToNoAdmin) {
+                await this.checkForOtherAdminRoles(keys);
+            }
+        }
+        catch (err) {
+            (opts || (opts = {})).preMutationException = err;
         }
         return super.updateBatch(data, opts);
     }
     async updateMany(keys, data, opts) {
-        if ('admin_access' in data && data.admin_access === false) {
-            await this.checkForOtherAdminRoles(keys);
+        try {
+            if ('admin_access' in data && data.admin_access === false) {
+                await this.checkForOtherAdminRoles(keys);
+            }
+        }
+        catch (err) {
+            (opts || (opts = {})).preMutationException = err;
         }
         return super.updateMany(keys, data, opts);
     }
@@ -81,7 +96,13 @@ class RolesService extends items_1.ItemsService {
         return key;
     }
     async deleteMany(keys) {
-        await this.checkForOtherAdminRoles(keys);
+        const opts = {};
+        try {
+            await this.checkForOtherAdminRoles(keys);
+        }
+        catch (err) {
+            opts.preMutationException = err;
+        }
         await this.knex.transaction(async (trx) => {
             const itemsService = new items_1.ItemsService('directus_roles', {
                 knex: trx,
@@ -106,17 +127,17 @@ class RolesService extends items_1.ItemsService {
             // Delete permissions/presets for this role, suspend all remaining users in role
             await permissionsService.deleteByQuery({
                 filter: { role: { _in: keys } },
-            });
+            }, opts);
             await presetsService.deleteByQuery({
                 filter: { role: { _in: keys } },
-            });
+            }, opts);
             await usersService.updateByQuery({
                 filter: { role: { _in: keys } },
             }, {
                 status: 'suspended',
                 role: null,
-            });
-            await itemsService.deleteMany(keys);
+            }, opts);
+            await itemsService.deleteMany(keys, opts);
         });
         return keys;
     }

package/dist/services/schema.d.ts

@@ -0,0 +1,15 @@
+import type { Accountability } from '@directus/shared/types';
+import type { Knex } from 'knex';
+import type { AbstractServiceOptions, Snapshot, SnapshotDiff, SnapshotDiffWithHash, SnapshotWithHash } from '../types';
+export declare class SchemaService {
+    knex: Knex;
+    accountability: Accountability | null;
+    constructor(options: Omit<AbstractServiceOptions, 'schema'>);
+    snapshot(): Promise<Snapshot>;
+    apply(payload: SnapshotDiffWithHash): Promise<void>;
+    diff(snapshot: Snapshot, options?: {
+        currentSnapshot?: Snapshot;
+        force?: boolean;
+    }): Promise<SnapshotDiff | null>;
+    getHashedSnapshot(snapshot: Snapshot): SnapshotWithHash;
+}

package/dist/services/schema.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaService = void 0;
+const database_1 = __importDefault(require("../database"));
+const exceptions_1 = require("../exceptions");
+const apply_diff_1 = require("../utils/apply-diff");
+const get_snapshot_1 = require("../utils/get-snapshot");
+const get_snapshot_diff_1 = require("../utils/get-snapshot-diff");
+const get_versioned_hash_1 = require("../utils/get-versioned-hash");
+const validate_diff_1 = require("../utils/validate-diff");
+const validate_snapshot_1 = require("../utils/validate-snapshot");
+class SchemaService {
+    knex;
+    accountability;
+    constructor(options) {
+        this.knex = options.knex ?? (0, database_1.default)();
+        this.accountability = options.accountability ?? null;
+    }
+    async snapshot() {
+        if (this.accountability?.admin !== true)
+            throw new exceptions_1.ForbiddenException();
+        const currentSnapshot = await (0, get_snapshot_1.getSnapshot)({ database: this.knex });
+        return currentSnapshot;
+    }
+    async apply(payload) {
+        if (this.accountability?.admin !== true)
+            throw new exceptions_1.ForbiddenException();
+        const currentSnapshot = await this.snapshot();
+        const snapshotWithHash = this.getHashedSnapshot(currentSnapshot);
+        if (!(0, validate_diff_1.validateApplyDiff)(payload, snapshotWithHash))
+            return;
+        await (0, apply_diff_1.applyDiff)(currentSnapshot, payload.diff, { database: this.knex });
+    }
+    async diff(snapshot, options) {
+        if (this.accountability?.admin !== true)
+            throw new exceptions_1.ForbiddenException();
+        (0, validate_snapshot_1.validateSnapshot)(snapshot, options?.force);
+        const currentSnapshot = options?.currentSnapshot ?? (await (0, get_snapshot_1.getSnapshot)({ database: this.knex }));
+        const diff = (0, get_snapshot_diff_1.getSnapshotDiff)(currentSnapshot, snapshot);
+        if (diff.collections.length === 0 && diff.fields.length === 0 && diff.relations.length === 0) {
+            return null;
+        }
+        return diff;
+    }
+    getHashedSnapshot(snapshot) {
+        const snapshotHash = (0, get_versioned_hash_1.getVersionedHash)(snapshot);
+        return {
+            ...snapshot,
+            hash: snapshotHash,
+        };
+    }
+}
+exports.SchemaService = SchemaService;

package/dist/services/schema.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/server.d.ts

@@ -1,6 +1,6 @@
-import { Knex } from 'knex';
-import { AbstractServiceOptions } from '../types';
-import { Accountability, SchemaOverview } from '@directus/shared/types';
+import type { Knex } from 'knex';
+import type { Accountability, SchemaOverview } from '@directus/shared/types';
+import type { AbstractServiceOptions } from '../types';
 import { SettingsService } from './settings';
 export declare class ServerService {
     knex: Knex;

package/dist/services/server.js

@@ -30,20 +30,25 @@ exports.ServerService = void 0;
 const lodash_1 = require("lodash");
 const os_1 = __importDefault(require("os"));
 const perf_hooks_1 = require("perf_hooks");
+const utils_1 = require("@directus/shared/utils");
+const node_stream_1 = require("node:stream");
 // @ts-ignore
 const package_json_1 = require("../../package.json");
 const cache_1 = require("../cache");
 const database_1 = __importStar(require("../database"));
 const env_1 = __importDefault(require("../env"));
 const logger_1 = __importDefault(require("../logger"));
-const rate_limiter_1 = require("../middleware/rate-limiter");
-const storage_1 = require("../storage");
-const utils_1 = require("@directus/shared/utils");
 const mailer_1 = __importDefault(require("../mailer"));
-const settings_1 = require("./settings");
+const rate_limiter_global_1 = require("../middleware/rate-limiter-global");
+const rate_limiter_ip_1 = require("../middleware/rate-limiter-ip");
+const storage_1 = require("../storage");
 const get_os_info_1 = require("../utils/get-os-info");
-const node_stream_1 = require("node:stream");
+const settings_1 = require("./settings");
 class ServerService {
+    knex;
+    accountability;
+    settingsService;
+    schema;
     constructor(options) {
         this.knex = options.knex || (0, database_1.default)();
         this.accountability = options.accountability || null;
@@ -51,7 +56,6 @@ class ServerService {
         this.settingsService = new settings_1.SettingsService({ knex: this.knex, schema: this.schema });
     }
     async serverInfo() {
-        var _a, _b;
         const info = {};
         const projectInfo = await this.settingsService.readSingleton({
             fields: [
@@ -67,7 +71,7 @@ class ServerService {
             ],
         });
         info.project = projectInfo;
-        if ((_a = this.accountability) === null || _a === void 0 ? void 0 : _a.user) {
+        if (this.accountability?.user) {
             if (env_1.default.RATE_LIMITER_ENABLED) {
                 info.rateLimit = {
                     points: env_1.default.RATE_LIMITER_POINTS,
@@ -77,11 +81,20 @@ class ServerService {
             else {
                 info.rateLimit = false;
             }
+            if (env_1.default.RATE_LIMITER_GLOBAL_ENABLED) {
+                info.rateLimitGlobal = {
+                    points: env_1.default.RATE_LIMITER_GLOBAL_POINTS,
+                    duration: env_1.default.RATE_LIMITER_GLOBAL_DURATION,
+                };
+            }
+            else {
+                info.rateLimitGlobal = false;
+            }
             info.flows = {
                 execAllowedModules: env_1.default.FLOWS_EXEC_ALLOWED_MODULES ? (0, utils_1.toArray)(env_1.default.FLOWS_EXEC_ALLOWED_MODULES) : [],
             };
         }
-        if (((_b = this.accountability) === null || _b === void 0 ? void 0 : _b.admin) === true) {
+        if (this.accountability?.admin === true) {
             const { osType, osVersion } = (0, get_os_info_1.getOSInfo)();
             info.directus = {
                 version: package_json_1.version,
@@ -100,14 +113,20 @@ class ServerService {
         return info;
     }
     async health() {
-        var _a;
         const { nanoid } = await import('nanoid');
         const checkID = nanoid(5);
         const data = {
             status: 'ok',
             releaseId: package_json_1.version,
             serviceId: env_1.default.KEY,
-            checks: (0, lodash_1.merge)(...(await Promise.all([testDatabase(), testCache(), testRateLimiter(), testStorage(), testEmail()]))),
+            checks: (0, lodash_1.merge)(...(await Promise.all([
+                testDatabase(),
+                testCache(),
+                testRateLimiter(),
+                testRateLimiterGlobal(),
+                testStorage(),
+                testEmail(),
+            ]))),
         };
         for (const [service, healthData] of Object.entries(data.checks)) {
             for (const healthCheck of healthData) {
@@ -126,7 +145,7 @@ class ServerService {
             if (data.status === 'error')
                 break;
         }
-        if (((_a = this.accountability) === null || _a === void 0 ? void 0 : _a.admin) !== true) {
+        if (this.accountability?.admin !== true) {
             return { status: data.status };
         }
         else {
@@ -229,8 +248,8 @@ class ServerService {
             };
             const startTime = perf_hooks_1.performance.now();
             try {
-                await rate_limiter_1.rateLimiter.consume(`health-${checkID}`, 1);
-                await rate_limiter_1.rateLimiter.delete(`health-${checkID}`);
+                await rate_limiter_ip_1.rateLimiter.consume(`health-${checkID}`, 1);
+                await rate_limiter_ip_1.rateLimiter.delete(`health-${checkID}`);
             }
             catch (err) {
                 checks['rateLimiter:responseTime'][0].status = 'error';
@@ -246,6 +265,43 @@ class ServerService {
             }
             return checks;
         }
+        async function testRateLimiterGlobal() {
+            if (env_1.default.RATE_LIMITER_GLOBAL_ENABLED !== true) {
+                return {};
+            }
+            const checks = {
+                'rateLimiterGlobal:responseTime': [
+                    {
+                        status: 'ok',
+                        componentType: 'ratelimiter',
+                        observedValue: 0,
+                        observedUnit: 'ms',
+                        threshold: env_1.default.RATE_LIMITER_GLOBAL_HEALTHCHECK_THRESHOLD
+                            ? +env_1.default.RATE_LIMITER_GLOBAL_HEALTHCHECK_THRESHOLD
+                            : 150,
+                    },
+                ],
+            };
+            const startTime = perf_hooks_1.performance.now();
+            try {
+                await rate_limiter_global_1.rateLimiterGlobal.consume(`health-${checkID}`, 1);
+                await rate_limiter_global_1.rateLimiterGlobal.delete(`health-${checkID}`);
+            }
+            catch (err) {
+                checks['rateLimiterGlobal:responseTime'][0].status = 'error';
+                checks['rateLimiterGlobal:responseTime'][0].output = err;
+            }
+            finally {
+                const endTime = perf_hooks_1.performance.now();
+                checks['rateLimiterGlobal:responseTime'][0].observedValue = +(endTime - startTime).toFixed(3);
+                if (checks['rateLimiterGlobal:responseTime'][0].observedValue >
+                    checks['rateLimiterGlobal:responseTime'][0].threshold &&
+                    checks['rateLimiterGlobal:responseTime'][0].status !== 'error') {
+                    checks['rateLimiterGlobal:responseTime'][0].status = 'warn';
+                }
+            }
+            return checks;
+        }
         async function testStorage() {
             const storage = await (0, storage_1.getStorage)();
             const checks = {};

package/dist/services/settings.d.ts

@@ -1,4 +1,4 @@
-import { AbstractServiceOptions } from '../types';
+import type { AbstractServiceOptions } from '../types';
 import { ItemsService } from './items';
 export declare class SettingsService extends ItemsService {
     constructor(options: AbstractServiceOptions);

package/dist/services/shares.d.ts

@@ -1,6 +1,6 @@
-import { AbstractServiceOptions, LoginResult, Item, PrimaryKey, MutationOptions } from '../types';
-import { ItemsService } from './items';
+import type { AbstractServiceOptions, Item, LoginResult, MutationOptions, PrimaryKey } from '../types';
 import { AuthorizationService } from './authorization';
+import { ItemsService } from './items';
 export declare class SharesService extends ItemsService {
     authorizationService: AuthorizationService;
     constructor(options: AbstractServiceOptions);